Aufgabe

Sie erhalten eine Reihe von Kreisen in der Ebene mit ihren Mittelpunkten auf der Linie y = 0 . Es ist garantiert, dass kein Kreispaar mehr als einen gemeinsamen Punkt hat.

Sie müssen bestimmen, in wie viele Bereiche die Kreise die Ebene unterteilen. Eine Region ist eine einschlussmaximale zusammenhängende Menge von Punkten, die keinen der Kreise schneiden.

Sie sollten ein Programm schreiben, das diese Antwort berechnet, wenn Sie eine Beschreibung der Kreise erhalten.

Hier ist ein Beispiel:

Auf der linken Seite sehen Sie die in der Ebene gezeichneten Kreise. In der rechten Bildhälfte sind die durch die Kreise erzeugten Bereiche jedoch deutlich gefärbt (eine Farbe pro Bereich). In diesem Beispiel gibt es sechs Regionen.

Eingang

Die erste Zeile der Eingabe enthält eine Zahl N, die Anzahl der folgenden Kreisbeschreibungen. Diese Zeile ist optional. Wenn Ihre Lösung ohne sie funktioniert, ist dies in Ordnung.

Die folgenden NZeilen enthalten jeweils zwei Ganzzahlen, x _i und r _i > 0 , die einen Kreis mit Mittelpunkt (x _i , 0) und Radius r _{i darstellen} .

Es ist garantiert, dass kein Kreispaar mehr als einen gemeinsamen Punkt hat. Es ist weiterhin garantiert, dass x _i und r _{i den}10^9 absoluten Wert nicht überschreiten (so dass sie bequem in eine 32-Bit-Ganzzahl passen).

Die Eingabe kann sein:

• aus STDIN lesen

• Aus einer Datei Iim aktuellen Verzeichnis lesen

Alternativ könnte die Eingabe sein:

• Verfügbar als Zeichenfolge (einschließlich Zeilenumbrüchen) in einer globalen Variablen

• auf dem Stapel

Ausgabe

Dies sollte eine einzelne Ganzzahl sein, die Anzahl der produzierten Regionen. Dies sollte in STDOUT oder in eine Datei geschrieben werden, die Oim aktuellen Verzeichnis benannt ist.

Regeln

• Kürzester Code in Bytes gewinnt

• +200 Byte Strafe, wenn Ihr Code kein Laufzeit- + Raumkomplexitätspolynom enthält n

• -100-Byte-Bonus für die im schlimmsten Fall zu erwartende Laufzeit + Speicherplatzkomplexität O(n log n)

• -50-Byte-Bonus für die im schlimmsten Fall zu erwartende Laufzeit + Speicherplatzkomplexität O(n)

• -100-Byte-Bonus für deterministische Laufzeit + Speicherplatzkomplexität O(n)

Bei der Beurteilung der Laufzeit:

• Angenommen, Hash-Tabellen haben O(1)unabhängig von der Reihenfolge der Operationen und den Eingabedaten eine erwartete Laufzeit für das Einfügen, Löschen und Nachschlagen. Dies kann wahr sein oder nicht, abhängig davon, ob die Implementierung eine Randomisierung verwendet.

• Angenommen, die eingebaute Art Ihrer Programmiersprache benötigt deterministische O(n log n)Zeit, wobei ndie Größe der Eingabesequenz angegeben wird.

• Nehmen wir an, dass arithmetische Operationen an Eingabenummern nur O(1)Zeit in Anspruch nehmen .

• Nehmen Sie nicht an, dass Eingabezahlen durch eine Konstante gebunden sind, obwohl dies aus praktischen Gründen der Fall ist. Dies bedeutet, dass Algorithmen wie radix sort oder counting sort keine lineare Zeit sind. Im Allgemeinen sollten sehr große konstante Faktoren vermieden werden.

Beispiele

Eingang:

2 
1 3
5 1

Ausgabe: 3

Eingang:

3
2 2
1 1
3 1

Ausgabe: 5

4
7 5
-9 11
11 9
0 20

Eingang:

9
38 14
-60 40
73 19
0 100
98 2
-15 5
39 15
-38 62
94 2

Ausgabe: 11

Hinweise

Wir können die folgende Idee für eine sehr kompakte Lösung verwenden. Lässt uns die Menge der Kreise mit der X-Achse schneiden und die Schnittpunkte als Knoten in einem ebenen Graphen interpretieren:

Jeder Kreis erzeugt in diesem Diagramm genau 2 Kanten und bis zu zwei Knoten. Wir können die Anzahl der Knoten zählen, indem wir eine Hash-Tabelle verwenden, um die Gesamtzahl der unterschiedlichen linken oder rechten Ränder zu verfolgen.

Dann können wir die Euler-Kennlinienformel verwenden , um die Anzahl der Flächen einer Zeichnung des Graphen zu berechnen:

V - E + F - C = 1

F = E - V + C + 1

Um Cdie Anzahl der verbundenen Komponenten zu berechnen , können wir eine Tiefensuche verwenden .

^{Hinweis: Diese Problemidee stammt aus einem kürzlich durchgeführten kroatischen Programmierwettbewerb. Betrügen Sie jedoch nicht, indem Sie sich die Lösungsskizzen ansehen. :)}

Mathematica, 125, 122-150 = -28 Zeichen

Ich kenne die Komplexität der eingebauten Funktion nicht ConnectedComponents.

1+{-1,2,1}.Length/@{VertexList@#,EdgeList@#,ConnectedComponents@#}&@Graph[(+##)<->(#-#2)&@@@Rest@ImportString[#,"Table"]]&

Verwendung:

1+{-1,2,1}.Length/@{VertexList@#,EdgeList@#,ConnectedComponents@#}&@Graph[(+##)<->(#-#2)&@@@Rest@ImportString[#,"Table"]]&[
"9
38 14
-60 40
73 19
0 100
98 2
-15 5
39 15
-38 62
94 2"]

11

Ruby - 312 306 285 273 269 259 Zeichen

Diese Antwort wurde durch meinen anderen Ansatz abgelöst, bei dem wesentlich weniger Zeichen verwendet werden und die Eingabe erfolgt O(n log n).

Okay, los geht's. Für den Anfang wollte ich nur eine funktionierende Implementierung, daher ist diese noch nicht algorithmisch optimiert. Ich sortiere die Kreise vom größten zum kleinsten und baue einen Baum (Kreise in anderen Kreisen sind Kinder dieser größeren). Beide Operationen dauern O(n^2)im schlimmsten und O(n log n)besten Fall . Dann durchlaufe ich den Baum, um Bereiche zu zählen. Wenn die Kinder eines Kreises seinen gesamten Durchmesser ausfüllen, gibt es zwei neue Bereiche, ansonsten gibt es nur einen. Diese Iteration nehmen O(n). Ich bin also insgesamt komplex O(n^2)und qualifiziere mich weder für Belohnungen noch für Strafen.

Dieser Code erwartet, dass die Eingabe ohne die Anzahl der Kreise in einer Variablen gespeichert wird s:

t=[]
s.lines.map{|x|x,r=x.split.map &:to_i;{d:2*r,l:x-r,c:[]}}.sort_by!{|c|-c[:d]}.map{|c|i=-1;n=t
while o=n[i+=1]
if 0>d=c[:l]-o[:l]
break
elsif o[:d]>d
n=o[:c]
i=-1
end
end
n[i,0]=c}
a=1
t.map &(b=->n{d=0
n[:c].each{|c|d+=c[:d]}.map &b
a+=d==n[:d]?2:1})
p a

Ungolfed-Version (erwartet Eingabe in Variable string):

list = []
string.split("\n").map { |x|
  m = x.split
  x,radius = m.map &:to_i
  list<<{x:x, d:2*radius, l:x-radius, r:x+radius, children:[]}
}
list.sort_by! { |circle| -circle[:d] }
tree = []
list.map { |circle|
  i = -1
  node = tree
  while c=node[i+=1]
    if circle[:x]<c[:l]
      break
    elsif circle[:x]<c[:r]
      node = c[:children]
      i = -1
    end
  end
  node[i,0] = circle
}
areas = 1
tree.map &(count = -> node {
  d = 0
  i = -1
  while c=node[:children][i+=1]
    count.call c
    d += c[:d]
  end
  areas += d == node[:d] ? 2 : 1
})
p areas

Ruby, 203 183 173 133 - 100 = 33 Zeichen

Also hier ist ein anderer Ansatz. Dieses Mal sortiere ich die Kreise nach dem Punkt ganz links. Kreise, die sich am äußersten linken Punkt berühren, werden vom größten zum kleinsten sortiert. Dies dauert O(n log n)(nun, Ruby verwendet die schnelle Sortierung, O(n^2)aber das Implementieren der Zusammenführungs- / Heap-Sortierung sprengt wahrscheinlich den Rahmen dieser Herausforderung). Dann durchlaufe ich diese Liste und erinnere mich an alle Positionen ganz links und ganz rechts der Kreise, die ich besucht habe. Auf diese Weise kann ich erkennen, ob eine Reihe von Kreisen über einen umschließenden größeren Kreis verbunden ist. In diesem Fall gibt es zwei Unterbereiche, ansonsten nur einen. Diese Iteration erfordert nur O(n)eine Gesamtkomplexität, von O(n log n)der sich die 100-Zeichen-Belohnung qualifiziert.

Dieses Snippet erwartet, dass die Eingabe über eine Datei in den Befehlszeilenargumenten ohne die Anzahl der Kreise bereitgestellt wird :

l,r={},{}
a=1
$<.map{|x|c,q=x.split.map &:to_r;[c-q,-2*q]}.sort.map{|x,y|a+=r[y=x-y]&&l[x]?2:1
l[y]=1 if l[x]&&!r[y]
l[x]=r[y]=1}
p a

Ungolfed-Version (erwartet Eingabe in eine Variable string):

list = []
string.split("\n").map { |x|
  m = x.split
  x,radius = m.map &:to_r
  list<<{x:x, d:2*radius, l:x-radius, r:x+radius}
}
list.sort_by! { |circle| circle[:l] + 1/circle[:d] }
l,r={},{}
areas = 1
list.map { |circle|
  x,y=circle[:l],circle[:r]
  if l[x] && r[y]
    areas += 2
  else
    areas += 1
    l[y]=1 if l[x]
  end
  r[y]=1
  l[x]=1
}
p areas

Julia - 260 -100 (Bonus?) = 160

Wenn wir die Kreise als Figuren mit Scheitelpunkten (Schnittpunkten), Kanten und Flächen (Flächen der Ebene) interpretieren, können wir sie mit der Euler-Eigenschaft in Beziehung setzen , sodass wir nur die Anzahl der "Scheitelpunkte" und "Kanten" kennen müssen, um die Anzahl zu erhalten von "Flächen" oder Regionen der Ebene mit der folgenden Formel:

UPDATE: Nachdem ich eine Weile nachgedacht hatte, stellte ich fest, dass das Problem mit meiner Methode nur dann bestand, wenn Kreise nicht verbunden waren. Deshalb kam mir die Idee, warum man sie nicht künstlich verbindet. Das Ganze wird also die Euler-Formel erfüllen.

F = 2 + EV (V = 6, E = 9)

[Arbeiten Sie nicht mit verschachtelten Kreisen, daher ist dies keine Antwort auf das Problem für allgemeine Fälle.]

Code :

s=readlines(open("s"))
n=int(s[1])
c=zeros(n,2)
t=[]
for i=1:n
    a=int(split(s[i+1]))
    c[i,1]=a[1]-a[2]
    c[i,2]=a[1]+a[2]
    if i==1 t=[c[1]]end
    append!(t,[c[i,1]:.5:c[i,2]])
end
e=0
t=sort(t)
for i in 1:(length(t)-1) e+=t[i+1]-t[i]>=1?1:0end #adds one edge for every gap
2+2n+e-length(unique(c)) # 2+E-V = 2+(2n+e)-#vertices

Spidermonkey JS, 308, 287 , 273 - 100 = 173

Ich denke, wenn ich dies in Ruby oder Python umschreibe, könnte ich Zeichen speichern.

Code:

for(a=[d=readline],e={},u=d(n=1);u--;)[r,q]=d().split(' '),l=r-q,r-=-q,e[l]=e[l]||[0,0],e[r]=e[r]||[0,0],e[r][1]++,e[l][0]++
for(k=Object.keys(e).sort(function(a,b)b-a);i=k.pop();a.length&&a.pop()&a.push(0)){for([l,r]=e[i];r--;)n+=a.pop()
for(n+=l;l--;)a.push(l>0)}print(n)

Algorithmus:

n = 1 // this will be the total
e = {x:[numLeftBounds,numRightBounds]} // imagine this as the x axis with a count of zero-crossings
a = [] // this is the stack of circles around the "cursor".  
       // values will be 1 if that circle's never had alone time, else 0
k = sort keys of e on x
for each key in k: // this is the "cursor"
  n += key[numLeftBounds] // each circle that opens has at least one space.
  k[numRightBounds].times {n += a.pop()} // pop the closing circles. if any were never alone, add 1
  k[numLeftBounds].times {a.push(alwaysAlone)} // push the opening circles
  if !a.empty():
     set the innermost circle (top of stack) to false (not never alone)
  fi
loop

Ich bin nicht besonders gut in der großen O-Notation, aber ich denke, das ist O (n), da ich effektiv drei Mal durch jeden Kreis laufe (erstellen, links, rechts) und auch die Schlüssel der Karte sortiere (und ich sortiere nach O ( n log n) aber das verschwindet). Ist das deterministisch?

JavaScript (ES6) - 255 254 Zeichen - 100 250 Bonus = 155 4

R=/(\S+) (\S+)/ym;N=1;i=w=l=0;for(X=[];m=R.exec(S);){X[N++]={w:j=m[2]*1,l:k=m[1]-j,r:k+2*j};l=k<l?k:l;w=j<w?w:j}M=[];X.map(x=>M[(x.l-l+1)*w-x.w]=x);s=[];M.map(x=>{while(i&&s[i-1].r<x.r)N+=s[--i].w?0:1;i&&(s[i-1].w-=x.w);s[i++]=x});while(i)N+=s[--i].w?0:1

Angenommen, die Eingabezeichenfolge befindet sich in der Variablen Sund gibt die Anzahl der Regionen an die Konsole aus.

R=/(\S+) (\S+)/ym;                  // Regular expression to find centre and width.
N=1;                                // Number of regions
w=l=0;                              // Maximum width and minimum left boundary.
X=[];                               // A 1-indexed array to contain the circles.
                                    // All the above are O(1)
for(;m=R.exec(S);){                 // For each circle
    X[N++]={w:j=m[2]*1,l:k=m[1]-j,r:k+2*j};
                                    // Create an object with w (width), l (left boundary)
                                    // and r (right boundary) attributes.
    l=k<l?k:l;                      // Update the minimum left boundary.
    w=j<w?w:j                       // Update the maximum width.
}                                   // O(1) per iteration = O(N) total.
M=[];                               // An array.
X.map(x=>M[(x.l-l+1)*w-x.w]=x);     // Map the 1-indexed array of circles (X) to a
                                    // sparse array indexed so that the elements are
                                    // sorted by ascending left boundary then descending
                                    // width.
                                    // If there are N circles then only N elements are
                                    // created in the array and it can be treated as if it
                                    // is a hashmap (associative array) with a built in
                                    // ordering and as per the rules set in the question
                                    // is O(1) per insert so is O(N) total cost.
                                    // Since the array is sparse then it is still O(N)
                                    // total memory.
s=[];                               // An empty stack
i=0;                                // The number of circles on the stack.
M.map(x=>{                          // Loop through each circle
    while(i&&s[i-1][1]<x[1])        // Check to see if the current circle  is to the right
                                    // of the circles on the stack;
      N+=s[--i][0]?0:1;             // if so, decrement the length of the stack and if the
                                    // circle that pops off has radius equal to the total
                                    // radii of its children then increment the number of
                                    // regions by 1.

                                    // Since there can be at most N items on the stack then
                                    // there can be at most N items popped off the stack
                                    // over all the iterations; therefore this operation
                                    // has an O(N) total cost.
    i&&(s[i-1][0]-=x[0]);           // If there is a circle on the stack then this circle
                                    // is its child. Decrement the parent's radius by the
                                    // current child's radius.
                                    // O(1) per iteration
    s[i++]=x                        // Add the current circle to the stack.
  });
while(i)N+=s[--i][0]?0:1            // Finally, remove all the remaining circles from the
                                    // stack and if the circle that pops off has radius
                                    // equal to the total radii of its children then
                                    // increment the number of regions by 1.
                                    // Since there will always be at least one circle on the
                                    // stack then this has the added bonus of being the final
                                    // command so the value of N is printed to the console.
                                    // As per the previous comment on the complexity, there
                                    // can be at most N items on the stack so between this
                                    // and the iterations over the circles then there can only
                                    // be N items popped off the stack so the complexity of
                                    // all these tests on the circles on the stack is O(N).

Die zeitliche Komplexität ist nun O (N).

Testfall 1

S='2\n1 3\n5 1';
R=/(\S+) (\S+)/ym;N=1;i=w=l=0;for(X=[];m=R.exec(S);){X[N++]={w:j=m[2]*1,l:k=m[1]-j,r:k+2*j};l=k<l?k:l;w=j<w?w:j}M=[];X.map(x=>M[(x.l-l+1)*w-x.w]=x);s=[];M.map(x=>{while(i&&s[i-1].r<x.r)N+=s[--i].w?0:1;i&&(s[i-1].w-=x.w);s[i++]=x});while(i)N+=s[--i].w?0:1

Ausgänge: 3

Testfall 2

S='3\n2 2\n1 1\n3 1';
R=/(\S+) (\S+)/ym;N=1;i=w=l=0;for(X=[];m=R.exec(S);){X[N++]={w:j=m[2]*1,l:k=m[1]-j,r:k+2*j};l=k<l?k:l;w=j<w?w:j}M=[];X.map(x=>M[(x.l-l+1)*w-x.w]=x);s=[];M.map(x=>{while(i&&s[i-1].r<x.r)N+=s[--i].w?0:1;i&&(s[i-1].w-=x.w);s[i++]=x});while(i)N+=s[--i].w?0:1

Ausgänge: 5

Testfall 3

S='4\n7 5\n-9 11\n11 9\n0 20';
R=/(\S+) (\S+)/ym;N=1;i=w=l=0;for(X=[];m=R.exec(S);){X[N++]={w:j=m[2]*1,l:k=m[1]-j,r:k+2*j};l=k<l?k:l;w=j<w?w:j}M=[];X.map(x=>M[(x.l-l+1)*w-x.w]=x);s=[];M.map(x=>{while(i&&s[i-1].r<x.r)N+=s[--i].w?0:1;i&&(s[i-1].w-=x.w);s[i++]=x});while(i)N+=s[--i].w?0:1

Ausgänge: 6

Testfall 4

S='9\n38 14\n-60 40\n73 19\n0 100\n98 2\n-15 5\n39 15\n-38 62\n94 2';
R=/(\S+) (\S+)/ym;N=1;i=w=l=0;for(X=[];m=R.exec(S);){X[N++]={w:j=m[2]*1,l:k=m[1]-j,r:k+2*j};l=k<l?k:l;w=j<w?w:j}M=[];X.map(x=>M[(x.l-l+1)*w-x.w]=x);s=[];M.map(x=>{while(i&&s[i-1].r<x.r)N+=s[--i].w?0:1;i&&(s[i-1].w-=x.w);s[i++]=x});while(i)N+=s[--i].w?0:1

Ausgänge: 11

Testfall 5

S='87\n-730 4\n-836 2\n-889 1\n-913 15\n-883 5\n-908 8\n-507 77\n-922 2\n-786 2\n-782 2\n-762 22\n-776 2\n-781 3\n-913 3\n-830 2\n-756 4\n-970 30\n-755 5\n-494 506\n-854 4\n15 3\n-914 2\n-840 2\n-833 1\n-505 75\n-888 10\n-856 2\n-503 73\n-745 3\n-903 25\n-897 1\n-896 2\n-848 10\n-878 50\n-864 2\n0 1000\n-934 6\n-792 4\n-271 153\n-917 1\n-891 3\n-833 107\n-847 3\n-758 2\n-754 2\n-892 2\n-738 2\n-876 2\n-52 64\n-882 2\n-270 154\n-763 3\n-868 72\n-846 4\n-427 3\n-771 3\n-767 17\n-852 2\n-765 1\n-772 6\n-831 1\n-582 2\n-910 6\n-772 12\n-764 2\n-907 9\n-909 7\n-578 2\n-872 2\n-848 2\n-528 412\n-731 3\n-879 1\n-862 4\n-909 1\n16 4\n-779 1\n-654 68\n510 490\n-921 3\n-773 5\n-653 69\n-926 2\n-737 3\n-919 1\n-841 1\n-863 3';
R=/(\S+) (\S+)/ym;N=1;i=w=l=0;for(X=[];m=R.exec(S);){X[N++]={w:j=m[2]*1,l:k=m[1]-j,r:k+2*j};l=k<l?k:l;w=j<w?w:j}M=[];X.map(x=>M[(x.l-l+1)*w-x.w]=x);s=[];M.map(x=>{while(i&&s[i-1].r<x.r)N+=s[--i].w?0:1;i&&(s[i-1].w-=x.w);s[i++]=x});while(i)N+=s[--i].w?0:1

Ausgänge: 105

Vorherige Version

C=S.split('\n');N=1+C.shift()*1;s=[];C.map(x=>x.split(' ')).map(x=>[w=x[1]*1,x[i=0]*1+w]).sort((a,b)=>(c=a[1]-2*a[0])==(d=b[1]-2*b[0])?b[0]-a[0]:c-d).map(x=>{while(i&&s[i-1][1]<x[1])N+=s[--i][0]?0:1;i&&(s[i-1][0]-=x[0]);s[i++]=x});while(i)N+=s[--i][0]?0:1

Mit Kommentaren:

C=S.split('\n');                    // Split the input into an array on the newlines.
                                    // O(N)
N=1+C.shift()*1;                    // Remove the head of the array and store the value as
                                    // if there are N disjoint circles then there will be
                                    // N+1 regions.
                                    // At worst O(N) depending on how .shift() works.
s=[];                               // Initialise an empty stack.
                                    // O(1)
C .map(x=>x.split(' '))             // Split each line into an array of the two values.
                                    // O(1) per line = O(N) total.
  .map(x=>[w=x[1]*1,x[i=0]*1+w])    // Re-map the split values to an array storing the
                                    // radius and the right boundary.
                                    // O(1) per line = O(N) total.

  .sort((a,b)=>(c=a[1]-2*a[0])==(d=b[1]-2*b[0])?b[0]-a[0]:c-d)
                                    // Sort the circles on increasing left boundary and
                                    // then descending radius.
                                    // O(1) per comparison = O(N.log(N)) total.
  .map(x=>{                         // Loop through each circle
    while(i&&s[i-1][1]<x[1])        // Check to see if the current circle  is to the right
                                    // of the circles on the stack;
      N+=s[--i][0]?0:1;             // if so, decrement the length of the stack and if the
                                    // circle that pops off has radius equal to the total
                                    // radii of its children then increment the number of
                                    // regions by 1.

                                    // Since there can be at most N items on the stack then
                                    // there can be at most N items popped off the stack
                                    // over all the iterations; therefore this operation
                                    // has an O(N) total cost.
    i&&(s[i-1][0]-=x[0]);           // If there is a circle on the stack then this circle
                                    // is its child. Decrement the parent's radius by the
                                    // current child's radius.
                                    // O(1) per iteration
    s[i++]=x                        // Add the current circle to the stack.
  });
while(i)N+=s[--i][0]?0:1            // Finally, remove all the remaining circles from the
                                    // stack and if the circle that pops off has radius
                                    // equal to the total radii of its children then
                                    // increment the number of regions by 1.
                                    // Since there will always be at least one circle on the
                                    // stack then this has the added bonus of being the final
                                    // command so the value of N is printed to the console.
                                    // As per the previous comment on the complexity, there
                                    // can be at most N items on the stack so between this
                                    // and the iterations over the circles then there can only
                                    // be N items popped off the stack so the complexity of
                                    // all these tests on the circles on the stack is O(N).

Die Gesamtzeitkomplexität ist O (N) für alles außer der Sortierung O (N.log (N)). Wenn Sie diese jedoch durch eine Bucket-Sortierung ersetzen, wird die Gesamtkomplexität auf O (N) reduziert.

Der benötigte Speicher ist O (N).

Ratet mal, was als nächstes auf meiner ToDo-Liste steht ... Bucket-Sortierung in weniger als 150 Zeichen. Getan