Dikey görünürlük sorunu için etkili algoritmalar

Bir problem üzerinde düşünürken, aşağıdaki görevi çözen verimli bir algoritma oluşturmam gerektiğini fark ettim:

Sorun: tarafları eksenlere paralel olan iki boyutlu bir yan taraf kare kutusu verilir $n$ . Üstünden bakabiliriz. Bununla birlikte, $m$ yatay segmentler de vardır. Her segment bir tamsayıdır sahip $y$ -coordinate ( $0 \le y \le n$ ) ve $x$ -coordinates ( $0 \le x_1 < x_2 \le n$ ) ve bağlanır noktası $(x_1,y)$ ve $(x_2,y)$ en (önceki Resim aşağıda).

Kutunun üstündeki her birim segment için, bu segmente bakarsak kutunun içinde ne kadar derin görünebileceğimizi bilmek isteriz.

$x \in \{0,\dots,n-1\}$ $\max_{i:\ [x,x+1]\subseteq[x_{1,i},x_{2,i}]} y_i$

Örnek: aşağıdaki resimdeki gibi bulunan ve segmenti verildiğinde sonuç . Kutunun içine ne kadar derin ışık girebileceğine bakın. $n=9$ $m=7$ $(5, 5, 5, 3, 8, 3, 7, 8, 7)$

Yedi bölüm; gölgeli kısım ışıkla ulaşılabilecek bölgeyi gösterir

Neyse ki bizim için hem ve olan oldukça küçük ve biz off-line hesaplamalar yapabilirsiniz. $n$ $m$

Bu sorunu çözmenin en kolay algoritması kaba kuvvettir: her segment için tüm diziyi çaprazlayın ve gerektiğinde güncelleyin. Ancak, bize çok etkileyici bir vermez . $O(mn)$

Büyük bir gelişme, sorgu sırasında segment üzerindeki değerleri en üst düzeye çıkarabilen ve son değerleri okuyabilen bir segment ağacı kullanmaktır. Daha fazla açıklamayacağım, ancak zaman karmaşıklığının olduğunu görüyoruz . $O((m+n) \log n)$

Ancak, daha hızlı bir algoritma buldum:

anahat:

Segmentleri azalan koordinatına göre sıralayın (sayma sıralamasının bir varyasyonunu kullanarak doğrusal zaman). Şimdi, eğer herhangi bir birim segmenti daha önce herhangi bir segment tarafından kaplanmışsa, aşağıdaki hiçbir segmentin artık bu birim segmentinden geçen ışık demetini bağlayamayacağını unutmayın. Sonra kutunun üstünden altına doğru bir çizgi süpürme yapacağız. $y$ $x$ $x$
Şimdi bazı tanımları tanıtalım : birim bölümü, koordinatları tamsayı olan ve uzunluğu 1 olan taramadaki hayali bir yatay bölümdür. Süpürme işlemi sırasında her bölüm işaretlenmemiş olabilir (yani, kutunun üst kısmı bu segmente ulaşabilir) veya işaretli (karşıt durum). Her zaman işaretlenmemiş , olan bir birimi segmentini düşünün . Ayrıca $x$ $x$ $x$ $x_1=n$ $x_2=n+1$ . Her kümede,aşağıdakiişaretlenmemişbölümlebirlikteardışıkişaretli bir birimi birimi (varsa) yeralacaktır. $S_0=\{0\}, S_1=\{1\}, \dots, S_n=\{n\}$ $x$
Bu segmentler üzerinde çalışabilen ve verimli bir şekilde ayarlanabilen bir veri yapısına ihtiyacımız var. Maksimum birim segment indeksini ( işaretlenmemiş segmentin endeksi) tutan bir alan tarafından genişletilen bir birleştirme birliği yapısı kullanacağız . $x$
Şimdi segmentleri verimli bir şekilde idare edebiliriz. En şimdi düşünüyoruz diyelim -inci başlar segmentin ( "sorgusu" diyoruz), ve uçları . segmentinin içinde yer alan tüm işaretlenmemiş birimi segmentlerini bulmamız gerekir (bunlar tam olarak ışık demetinin yolunu bitireceği segmentlerdir). Aşağıdakileri yapacağız: ilk olarak, sorgunun içindeki ilk işaretlenmemiş segmenti buluruz ( içerdiği kümenin temsilcisini bulun ve tanımı gereği işaretlenmemiş segment olan bu kümenin maksimum dizinini alın ). Sonra bu endeks $i$ $x_1$ $x_2$ $x$ $i$ $x_1$ , sorgunun içindedir, sonuca ekleyin (bu segment için sonuç ) ve bu dizini işaretleyin ( ve içerenbirleşimkümeleri). Ardından,işaretlenmemiştümsegmentleribulana kadar bu işlemi tekrarlayın, yani bir sonrakiSorgubulbize dizin . $x$ $y$ $x$ $x+1$ $x \ge x_2$

Her bir birleşim işleminin yalnızca iki durumda gerçekleştirileceğini unutmayın: ya bir segmenti düşünmeye başlarız ( kez olabilir) ya da sadece bir birim segmenti işaretledik (bu kez olabilir). Bu nedenle, genel karmaşıklığı ( olan bir Ackermann fonksiyonu ters ). Bir şey net değilse, bu konuda daha fazla ayrıntı verebilirim. Belki biraz zamanım varsa resim ekleyebilirim. $m$ $x$ $n$ $O((n+m)\alpha(n))$ $\alpha$

Şimdi "duvara" ulaştım. Doğrusal bir algoritma bulamıyorum, ancak bir tane olması gerektiği anlaşılıyor. İki sorum var:

Yatay segment görünürlük problemini çözen bir doğrusal zaman algoritması ( ) var mı? $O(n+m)$
Değilse, görünürlük sorununun olduğunun kanıtı nedir? $\omega(n+m)$

— mnbvmar
kaynak

M segmentlerinizi ne kadar hızlı sıralıyorsunuz?

— babou

@babou, soru, sorunun dediği gibi doğrusal zamanda ("sayım sıralamasının bir varyasyonunu kullanarak doğrusal zaman") çalışan sayım sıralamasını belirtir.

— DW

Soldan sağa doğru süpürmeyi denedin mi? Tek ihtiyacınız üzerinde tasnif edilir

hem

sağa yürümeye adımları tekrarlayın. Yani toplamda

x 1

$x1$

x 2

$x2$

O (m)

$O(m)$

O (m)

$O(m)$

O (m)

$O(m)$

— invalid_id

@invalid_id Evet, denedim. Bununla birlikte, bu durumda, süpürme çizgisi, segmentin başlangıcını karşıladığında (başka bir deyişle, segmentin

koordinatına eşit olan sayıyı multiset'e eklediğinde ), segmentin sonunu karşıladığında (

-koordinat) ve en yüksek aktif segmenti (çoklu sette maksimum çıkış değeri) çıktılar. Bunu (amortismanlı) sabit zamanda yapmamıza izin veren veri yapılarını duymadım.

y

$y$

y

$y$

— mnbvmar

@ mnbvmar aptalca bir öneri olabilir, ama

büyüklüğünde bir dizi hakkında , her hücreyi

süpürür ve durdurursunuz . Evry hücre için size maksimum biliyorum

ayrıca bir değişkenle genel maksimum takip edebilir ve matris içinde girebilirsiniz.

n

$n$

O (n)

$O(n)$

y

$y$

— invalid_id

Yanıtlar:

İlk çeşit, hem ve iki ayrı dizilerde hatlar koordinatlarını ve . $x1$ $x2$ $A$ $B$ $O(m)$
Ayrıca aktif segmentleri takip etmek için yardımcı bit dizisi boyutu de koruyoruz . $n$
Soldan sağa doğru süpürmeye başlayın:
için $(i=0,i<n,i++)$
{
..if ile değeri $\exists x1=i$ $y$ $c$ $O(1)$
.. {
.... bul ( ) $\max$
.... mağaza ( ) $\max$ $O(1)$
..}
..if ile değeri $\exists x2=i$ $y$ $c$ $O(1)$
.. {
.... bul ( ) $\max$
.... mağaza ( ) $\max$ $O(1)$
..}
}

find( $\max$ ) can be implemented using an bit array with $n$ bits. Now whenever we remove or add an element to $L$ we can update this integer by setting a bit to true or false respectively. Now you have two options depending on the programming language used and the assumption $n$ is relatively small i.e. smaller than $long long int$ which is at least 64 bits or a fixed amount of these integers:

Get the least significant bit in constant time is supported by some hardware and gcc.
By converting $L$ to an integer $O(1)$ you will get the maximum (not directly but you can derive it).

I know this is quite a hack because it assumes a maximum value for $n$ and hence $n$ can be seen as a constant then...

— invalid_id
kaynak

As I see, assuming you have got 64-bit x86 processor, you are able to handle only

n \leq 64

$n \le 64$ . What if

n

$n$ is in the order of millions?

— mnbvmar

Then you'll need more integers. With two integers you can handle

n

$n$ up to 128, etc. So the

O (m)

$O(m)$ maximum finding step is hidden in the number of integers required, which you might still optimize if

m

$m$ is small. You mentioned in your question that

n

$n$ is relatively small so I guessed it is not in the order of millions. By the way long long int is always at least 64bits by definition even on a 32-bit processor.

— invalid_id

Of course it is true, C++ standard defines long long int as at least 64-bit integer type. However, won't it be that if

n

$n$ is huge and we denote the word size as

w

$w$ (usually

w = 64

$w=64$ ), then each find will take

O (\frac{n}{w})

$O\left(\frac{n}{w}\right)$ time? Then we would end up with total

O (\frac{m n}{w})

$O\left(\frac{mn}{w}\right)$ .

— mnbvmar

Yes, unfortunately for big values of

n

$n$ that is the case. So now I wonder how big

n

$n$ will be in your case and whether it is bounded. If it is indeed in the order of millions this hack-around will not work anymore, but if

c \cdot w \geq n

$c\cdot w\geq n$ for low

c

$c$ values it will be fast and practically

O (n + m)

$O(n+m)$ . So the best algorithm choice is, as usual, input dependent. For example for

n \leq 100

$n\leq 100$ insertion sort is normally faster then merge sort, even with a running time of

O (n^{2})

$O(n^2)$ compared to

O (n \log n)

$O(n \log n)$ .

— invalid_id

I am confused by your choice of formatting. You know you can typeset code here, right?

— Raphael

I don't have a linear algorithm, but this one seems to be O(m log m).

Sort the segments based on the first coordinate and height. This means that (x1, l1) always comes before (x2, l2) whenever x1 < x2. Also, (x1, l1) at height y1 comes before (x1, l2) at height y2 whenever y1 > y2.

For every subset with the same first coordinate, we do the following. Let the first segment be (x1, L). For all other segments in the subset: If the segment is longer than the first, then change it from (x1,xt) to (L, xt) and add it to the L-subset in the proper order. Otherwise drop it. Finally, if the next subset has a first coordinate less than L, then split the (x1,L) to (x1, x2) and (x2, L). Add the (x2, L) to the next subset in the correct order. We can do this because the first segment in the subset is higher and covers the range from (x1, L). This new segment may be the one which covers (L, x2), but we won't know that until we look at the subset which has first coordinate L.

After we run through all of the subsets, we will have a set of segments which don't overlap. To determine what the Y value is for a given X, we only have to run through the remaining segments.

So what is the complexity here: The sort is O(m log m). Looping through the subsets is O(m). A lookup is also O(m).

So it seems that this algorithm is independent of n.

— No One in Particular
kaynak