Un gioco di posizionamento di cerchi sovrapposti per massimizzare il tempo di viaggio tra di loro


13

Ho incontrato il seguente gioco. Migrerò questo come richiesto.

  • Un bug sta visitando le cerchie e un avversario desidera massimizzare il suo tempo di viaggio.

  • L'avversario mette un cerchio in ogni turno.

  • Il bug cammina dalla sua posizione corrente direttamente verso il centro del cerchio più recente, quindi si ferma quando incontra l'interno del cerchio (quindi: non cammina se un cerchio viene giocato coprendo la sua posizione). Questo è il turno del bug.

  • Ci sono N cerchie disponibili per l'avversario.

  • Ogni cerchio successivo ha un raggio inferiore al cerchio precedente.

  • Ogni cerchio deve intersecare l'intersezione di tutti i cerchi precedentemente giocati. Cioè, tutti i cerchi devono avere un incrocio comune una volta che tutti sono giocati.

EDIT: l'avversario è libero di scegliere i raggi dei cerchi, con il vincolo che i raggi diminuiscano monotonicamente.


Domande e risposte:


  1. La distanza come limitata? NA: No, un esempio di strategia avversaria è dato da questa risposta
  2. Qual è la distanza massima che il bug deve percorrere giocando cerchi. NA: cresce a , con la stessa risposta.Θ(log(N))

Variante 2 : il bug si dirige direttamente verso l'intersezione delle due cerchie giocate più di recente .

AGGIORNAMENTO: questa variante è stata risolta, supponendo che il bug possa ricordare solo gli ultimi 2 cerchi giocati qui . Il risultato è stato di nuovo una distanza illimitata.


Che impatto ha la memoria senza limiti ? cioè, il bug va all'intersezione di tutte le cerchie giocate in precedenza . Ciò ha prodotto un limite "sciolto" di , dove d è il diametro del primo cerchio. Ovviamente non può essere inferiore a questo. Vedi qui . L'attuale limite superiore era 1000 × dO(d)d1000×d . Ciò è stato ottenuto approssimando il percorso nel caso peggiore come un giro attorno a cerchi progressivamente più piccoli. È stato dimostrato che il bug fa sempre progressi verso l'incrocio finale, riducendo così la distanza del passo successivo che deve percorrere.

Sospetto che la distanza percorsa sia una piccola volta costante la circonferenza del primo cerchio, ma al momento non sono in grado di fornire una buona prova.


Il raggio dei cerchi è scelto dall'avversario? È autorizzato a prendere i raggi in funzione di ? (Inoltre, non penso che questo appartenga alla teoria dei giochi)N
HdM,

È sicuramente un gioco ..
Suresh Venkat

2
Mi sembra un po 'strano che ci sia una limitazione che i cerchi hanno un'intersezione comune ma che il movimento dell'insetto non lo porta necessariamente in quell'intersezione comune. Forse la risposta sarebbe diversa se il bug raggiungesse direttamente il punto più vicino nell'intersezione corrente, piuttosto che verso il centro del nuovo cerchio?
David Eppstein,

1
@DavidEppstein: penso che il tuo suggerimento sia corretto. Nella variante suggerita, la distanza totale percorsa è delimitata da dove r è la distanza iniziale dal bug al centro del primo cerchio. Aggiungerò uno schizzo di prova in una seconda risposta di seguito. O(r)r
Neal Young,

1
@vzn e le mod di solito soddisfano le richieste.
Josh Vander Hook,

Risposte:


15

Questa risposta ha due parti, mostrando insieme che il limite corretto è :Θ(logN)

  1. Un limite inferiore di (volte il raggio del primo cerchio).Ω(logN)
  2. Un limite superiore corrispondente di .O(logN)

Limite inferiore di Ω(logN)

Considera due cerchi unitari che si toccano in un punto . (Vedi sotto; p è a destra, il bug inizia a sinistra.) Alternare tra un cerchio e l'altro. Il bug viaggerà su e giù a zig-zag attraverso la fessura tra i due cerchi, spostandosi principalmente su e giù ma anche procedendo lentamente verso destra. Se ho eseguito correttamente la trigonometria, dopopp passaggi, la distanza dal punto comune sarà Θ ( 1 / N, e ilN° passo farà sì che il bug di camminareΘ(1/N)Θ(1/N)NΘ(1/N) , per una distanza totale di .Θ(logN)

illustrazione

Ecco uno schizzo dei calcoli. Considera due passaggi consecutivi eseguiti dal bug. Va da un punto , a b , a c . I punti a e c sono sullo stesso cerchio; il punto b si trova sull'altro cerchio. Diciamo o essere il centro del cerchio che una è in. Considera i tre triangoli seguenti, in ordine decrescente di dimensione:abcacboa

  1. Il triangolo isocele (ricorda poapp è il punto comune).
  2. Il triangolo abp .
  3. Il piccolo triangolo abc

Questi triangoli sono quasi simili (ad esempio, ridimensionamento del modulo congruente). Più precisamente, per , tutti e tre hanno la seguente proprietà: il rapporto tra la lunghezza della gamba corta e quella lunga è Θ ( ϵ ) . (Non lo dimostrerò in modo più dettagliato qui, ma nota che ϵ 0ϵ=|ap|Θ(ϵ)ϵ0 mentre il bug cammina, e perturbando un vertice in ciascun triangolo di una quantità trascurabile, i triangoli possono essere resi simili.)

Le gambe lunghe e p o del primo triangolo hanno lunghezza 1. La gamba corta | a p | ha lunghezza ϵ . Il segmento a p è una gamba lunga del secondo triangolo, quindi la gamba corta del triangolo a b ha lunghezza Θ ( ϵ 2 ) . Il segmento a b è una gamba lunga del terzo triangolo, quindi la gamba corta del triangolo a c ha lunghezza Θ ( ϵ 3 ) . Pertanto, in questi due passaggi che il bug esegue:copo|ap|ϵapabΘ(ϵ2)abacΘ(ϵ3)

  1. La distanza il bug viaggia è|ab|+|bc| .Θ(ϵ2)
  2. La distanza dal bug al punto comune diminuisce da ϵ a ϵ - Θ ( ϵ 3 ) .pϵϵΘ(ϵ3)

Definire il tempo sia il numero di passi prima ε t1 / 2 k . Di (2) sopra, ϵ diminuisce di un fattore costante dopo circa Θ ( 1 / ϵ 2 ) passi, quindi t k + 1 = t k + Θ ( 2 2 k ) = t k + Θ ( 4 k ) . Pertanto, t k = Θ ( 4 ktkϵt1/2kϵΘ(1/ϵ2)tk+1=tk+Θ(22k)=tk+Θ(4k)tk=Θ(4k) . Cioè, dopo Θ(4k) steps, the distance from the bug to the common point p will be about 1/2k. Changing variables, after N steps, the distance from the bug to the common point will be ϵ=Θ(1/N). And, in the Nth step, the bug travels Θ(ϵ2)=Θ(1/N). So the total distance traveled in the first N steps is Θ(1+1/2+1/3+...+1/N)=Θ(logN).

This is the lower bound.

It extends to proposed Variant 2 (as I understand it), as follows:

Adding the restriction that the bug should move to the nearest point in the intersection of the two most recently placed circles does not help. That is, the Ω(logN) lower bound above still applies. To see why, we will modify the example above by adding a single extraneous circle that allows the bug to meet the restriction while still traveling the same path:

enter image description here

The green and blue circles are the two circles from the example above. The intersection points a and b are the same a and b as in the example above. The red circle is the new "extraneous" circle. The previous sequence alternated between the blue and green circles. The new sequence will be this sequence, but with the red circle added before every circle in the old sequence: red, blue, red, green, red, blue, red, green, red, blue, ...

Suppose the bug is sitting at a after blue is placed. The next circle placed is red. Red contains the bug, so the bug doesn't move. The next circle placed is green. Now the bug moves to b (which is the closest point on the intersection of the green and red circles). By repeating this, the bug travels as before.


Upper bound of O(logN)

I only sketch the proof.

Fix any sequence of circles. We will argue that as N, the total distance traveled by the bug in the first N steps is O(logN). Assume without loss of generality that the first circle has radius 1.

Fix an arbitrarily large N. Let p by any point in the intersection of the first N circles. Note that because of the way the bug moves, in each step that the bug moves it gets closer to p.

First, consider steps where the following ratio is at least 1/logN:

the reduction in the distance to pthe distance traveled in the step.
The total distance traveled in such steps is O(logN), because the total distance traveled in such steps is O(logN) times the initial distance to p. So we only need to bound the total distance traveled in the other steps --- those in which that ratio is at most 1/logN.

First, we argue something slightly weaker: that the total distance traveled in such steps before the circle radius decreases to 1/2 or less is O(logN). (We show later this is enough to give the bound.)

Consider any such step. Let a and b, respectively, denote the locations of the bug before and after the step. Let o denote the center of the current circle. Let b denote the point on the ray pb such that |pa|=|pb|:

enter image description here

Consider the following triangles:

  1. opb
  2. pba
  3. abb

By geometric arguments similar to those in the lower bound, for some ϵ, each of these triangles has two long legs and one short leg, and the ratio (for each triangle) of the short leg length to the long leg lengths is Θ(ϵ):

|bb||ab|=Θ(|ab||pa|)=Θ(|pa||bo|)=Θ(ϵ).

This equation and the assumption that |bo|, which is the circle radius, is in [1/2,1] imply that |ab|=Θ(|pa|2/|bo|)=Θ(|pa|2), and then that |bb|=Θ(|ab||pa|/|bo|)=Θ(|pa|3).

Now we focus on the bug's distance to p. Call it d before the step, and d after the step. (Note d=|pa|, d=|pb|, and dd=|bb|.)

In this step, this distance d reduces by |bb|, which by the above observations is Ω(d3).

Thus, the number of additional steps required to reduce the distance by a factor of 2 (to at most d/2) is O(1/d2). Changing variables, if d=1/2k, the number of additional steps required to bring the distance below 1/2k+1 is O(4k). Since the sum is geometric, the total number of steps required to bring the distance below 1/2k is O(1/4k). Changing variables again, after n steps, the distance to p will be O(1/n).

Finally, recalling the displayed equation several paragraphs up, in the nth step, the distance that the bug travels, i.e. |ab|, is O((the current distance to p)2)=O(1/n). Thus, the total distance traveled in the first N such steps while the circle radius is in [1/2,1] is at most

n=1NO(1/n)=O(logN).

By scaling, we conclude that, for any k, the total distance traveled while the circle radius is in the range [1/2k,1/2k+1] is O(log(N)/2k). Summing over k, the total distance traveled is O(logN). QED


3
very neat construction !
Suresh Venkat

I'd love to love this answer but I don't trust your trig. Any chance of some more details?
Josh Vander Hook

OK, I added the details.
Neal Young

4
If each circle was at most 99% percent as big as the previous one, then the total distance traveled is bounded, simply because in each step the distance traveled is at most the diameter of the previous circle, and the sum of the diameters of the circles is at most i=00.99i=100. (Times the initial distance from the bug to the furthest point on the first circle.)
Neal Young

2
It's a shame that we can't mark answers as favorites!
Jeffε

5

David E. conjectured

"Maybe the answer would be different if the bug walked directly to the closest point in the current intersection, rather than towards the center of the new circle?"

(EDIT: Note that this is not the same as the "variant 2" at the end of the original poster's question.)

Here's a proof (more or less) of his conjecture (it is bounded in this case).

Lemma. For the variant suggested by David, the total distance traveled by the bug is always O(d0), where d0 is the maximum distance between the bug and any point in the first circle placed.

proof. Assume WLOG that the final resting place is the origin o, and that the bug starts at distance 1 from o. For exposition assume the bug starts at time 0, travels at unit rate (one inch per second), and stops only when it reaches the last disc placed. Note that (as explained further below) as the bug crawls its distance to the origin strictly decreases.

Partition the unit-radius disc (centered at o) into infinitely many rings by drawing concentric circles of radii 1,0.99,0.992,0.993,.


Claim. Within any ring of (outer) radius d, the bug travels a total of at most 10d units.

Proof sketch. WIthout loss of generality (by scaling) assume the outer radius is 1. Assume for contradiction that the bug spends more than 10 seconds in this ring before moving into the next ring (of outer radius 0.99). At any time t, consider the angle α(t) formed by the following two vectors: the vector pointing from the bug in the direction the bug is traveling, and the vector pointing from the bug to the origin.

The bug is always moving towards the nearest point in the intersection of the discs placed so far, and that intersection is convex and contains the origin. Hence, the angle α(t) is always strictly less than ninety degrees, and the distance from the bug to the origin is strictly decreasing.

Whenever the angle α(t) is, say, less than eighty-nine degrees, the distance to the origin is decreasing at rate at least 1/100. But, during the entire time in the ring, this distance decreases by less than 1/100, so the total amount of time spent in the ring when α(t)<89 is at most 1 second. Thus, at least 9 seconds are spent with the angle α(t) being at least 89 degrees and at most 90 degrees. Now consider any such time t. Since α(t)[89,90], and the ring has width 1/100, the bug is traveling either distinctly clockwise around the ring, or distinctly counter-clockwise.

Let p denote the point that the bug is moving towards (the closest point in the intersection of the discs placed so far). As the bug moves towards p, consider the line through the bug and perpendicular to the direction of motion of the bug. This line separates the plane into two half-planes, one "ahead" of the bug (containing p and the intersection of the discs), and the other "behind" the bug. Mark the points in the half-plane behind the bug dead --- the bug can never return to any point once it is marked dead (because the point is not in the intersection of the discs).

Since α(t)[89,90], and the ring has radius 1 and width 1/100, almost half of the points in the ring are behind the bug and are dead, including the points immediately behind the bug. The bug cannot return to those points, so, if the bug is initially traveling, say, clockwise, then the bug cannot "turn around" and start traveling counter-clockwise (for more than say, 1 second). Thus, of the 10 seconds, the bug would have to spend at least 8 seconds traveling clockwise. But the circumference of the ring is 2π<7, half of the ring is dead as soon as the bug starts, and the bug cannot return to any dead point, so this is impossible. This proves the claim (more or less; maybe somebody can give a more precise argument).


By the claim, the total distance traveled (in all rings) is at most

i=010(0.99)i = 1000.

Obviously the constant factor here is loose. For example, if the bug travels in the first ring at an angle of 89 degrees or more, this immediately kills almost half the points in the disc of radius 1 (not just the points in that one ring).


I'm not exactly interested in this second variant, since it is obviously upper-bounded by 2πr0.
Josh Vander Hook

Huh, to me it's not obvious. Note that in the first example above, the bug stays within a circle of radius of O(1) but still travels Ω(logN) in N steps. Do you have a simpler proof?
Neal Young

Hm. Yeah I retract that bit about "obvious", that was in poor taste. It is not immediately obvious. Is it true that the upper bound in problem 2 should be lower than the upper bound in problem 1?
Josh Vander Hook

1
The upper bound in problem 2 is O(d0) (independent of N), while the lower bound in problem 1 is Ω(d0logN). (Here d0 is the initial distance from the bug to the furthest point in the first circle. This parameter or similar has to be there, because scaling any problem instance trivially increases the length traveled by the scale factor.) So I would say the first variant is unbounded, while the second variant is bounded (and thus lower).
Neal Young
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.