Minimum kümülatif küme toplamı

Bu sorunu ele alalım: sonlu kümeler listesi göz önüne alındığında, bir sipariş bulmak $s_1, s_2, s_3, \ldots$ o en aza indirir $|s_1| + |s_1 \cup s_2| + |s_1 \cup s_2 \cup s_3| + \ldots$ .

Bunun için bilinen algoritmalar var mı? Karmaşıklığı nedir? Henüz verimli bir optimal algoritma düşünemedim, ancak NP-Hard'da da belli değil.

Bu sorun aslında "Ağırlıklı tamamlama süresini en aza indirmek için Öncelik kısıtlı zamanlama" olarak bilinen bir zamanlama sorunuyla ilgilidir. Sorun şu şekildedir: Her işin bir işlem süresi (p) ve ağırlığı (w) olduğu ve işler üzerinde bir öncelik grafiğinin tanımlandığı bir dizi iş verildiğinde. Amaç, öncelik kısıtlamalarının yerine getirilmesi ve ağırlıklı tamamlanma süresinin toplamının minimize edilmesi için işleri tek bir makinede (önleyici olmayan) programlamaktır. Problem NP-zordur ve 2-yaklaşımı bilinmektedir.

Minimum kümülatif toplam probleminden Öncelik kısıtlamalı çizelgeleme problemine indirgeme: Her eleman için p = 1, w = 0 ile bir iş oluşturun. Ayrıca her küme için p = 0, w = 1 ile bir iş oluşturun. öğesi varsa , e , S'den önce programlanmalıdır . Programlama sorununun bu özel durumunun NP-zor olduğunu düşünüyorum.$e \in S$$e$$S$

Aşağıdaki bağlantılara bakın,

1) http://www.win.tue.nl/~gwoegi/papers/precsum.pdf

2) http://web.engr.illinois.edu/~chekuri/papers/dam_sched.ps

Shalmoli Gupta, genel sorunun NP-Hard olduğunu zaten açıkladı, bu yüzden herhangi bir özel vakanın polinomun çözülebilir olup olmadığını araştırmaya karar verdim. Sonunda, bir ağacı temsil eden setlerin özel durumuna ya da daha genel olarak, tüm kıyaslanamayan setlerin ayrılmasıyla alt kümeye dahil edilmesiyle seri paralel bir sıraya bir çözüm buldum.

İşleri kolaylaştıran özelliklerden biri, küme listesinin kesişme noktası altında kapalı olmasıdır. Eğer , o zaman s 1'in s 2'den önce geldiği optimal bir düzen vardır . WLOG'u, optimal sıralamanın, alt kümeye dahil etme ile verilen kısmi sıralamanın doğrusal bir uzantısı olduğunu varsayabiliriz.$s_1 \subseteq s_2$$s_1$$s_2$

Bir kümenin tüm alt kümeleri sırayla önünde göründüğünden, belirli bir kümenin çalışma toplamına eklenen miktar, göründüğü yerden bağımsız olarak sabittir. Eğer setlerinin listesi, bunun bir dizi artan maliyetinin görünen s herhangi alt kümesinde olmayan s elemanların sayısıdır S . Aynı set S'de birden çok kez görünüyorsa , önce gitmek için birini seçebilir ve diğerlerinin 0'a mal olmasına izin verebiliriz.$S$$S$$S$

Bu, sorunun öncelik kısıtlamaları olan tek makine programlamasında minimum ağırlıklı tamamlanma süresi sorununa eşdeğer olduğu anlamına gelir. Bu sorun olarak, ağırlık ile işler bir dizi verilmiştir ve zaman t j , ve iş kısmi bir düzen P , biz ağırlıklı toplam tamamlanma süresini en aza indirir işler bir sipariş, yani bulmak istiyoruz$w_j$$t_j$$P$

$\sum_{i=1}^{n} w_{j_i} \left(\sum_{k=1}^{i} t_{j_k}\right)$

Öncelik kısıtlamaları tabi . Kavşak kapalı kümelerdeki minimal kümülatif küme problemi, her küme için bir iş yaratılarak bu duruma dönüştürülebilir, burada her işin ağırlığı 1, yukarıda tanımlanan artımlı maliyete eşittir ve P , alt kümeye dahil etme ile verilen sıradır.$P$$P$

Anlaşıldığı gibi, bu sorun genel için NP-Hard'dur . Bununla birlikte, bazı özel P formları polinom zamanında çözülebilir.$P$$P$

Bu makale , seri paralel siparişler P için (ağaçların önemli durumlarını da içerir ) bir algoritması verir . Ne yazık ki, bu makaleye erişemedim, bu yüzden bağımsız olarak yeniden keşfetmeye karar verdim. İşte ortaya koyduğum şey.$O(nlogn)$$P$

Bu sorunu çözmek için birkaç gözlem gereklidir.

Her şeyden önce, öncelik kısıtlamaları yokluğunda, optimal çözüm artan sırasına göre basitçe sıralama işler etmektir . Basit olması için, bunav(j)kısaltılmış işin değeri olarak değineceğim. SıralamaO(nlogn)olduğundan, bu karmaşıklıktan daha iyisini yapmak imkansızdır.$\frac{t_j}{w_j}$$v(j)$$O(nlogn)$

Kural 1 Let ve b öyle ki işler olmak bir < b ∈ P b kapakları a. Eğer v ( a ) < v ( b ) ise , o zaman optimal sıralama veya objektif değeri etkilemeden a < b kısıtlamasını düşürebiliriz .$a$$b$$a < b \in P$$v(a) < v(b)$$a < b$

Varsayalım önce görünen bir rahat problemin optimum sıralamada. B başlangıçta kapsadığı için, yeni sıradaki b ve a arasındaki tüm işlerin a ve b ile karşılaştırılamaz olduğu anlamına gelir. Ancak b, a'dan daha yüksek bir değere sahip olduğundan, b ve a'yı, bir çelişkiyi değiştirerek objektif değeri azaltabiliriz.$b$$a$

Benzer şekilde, değerine göre sıraladıktan sonra, orijinal (basitleştirilmiş) sorunun öncelik ilişkilerine danışarak bağları koparmamızı sağladığımız sürece kısıtı bırakabiliriz . Bu, rahat problem için bulunan en uygun çözümün orijinal soruna da en uygun çözüm olmasını sağlar.$v(a) = v(b)$

Therefore, whenever b covers a and $v(a) \leq v(b)$, we can simplify the problem by dropping the constraint $a < b$.

Kural 2 diyelim ki b'nin hemen ardından a'nın en uygun çözüm olduğunu takip ettiğimizi biliyoruz. A ve b'yi ile yeni bir c düğümüne birleştirebiliriz$w_c = w_a + w_b$$t_c = t_a + t_b$, while contracting the poset $P$ appropriately.

The optimal objective value of the new problem differs by a constant from the original objective value (specifically $w_at_b$), however this constant does not depend on ordering and hence the optimal ordering is not affected. We can recover an optimal solution to the old problem by taking an optimal solution to the new problem and replacing $c$ with $ab$.

Rule 3 Suppose that in an optimal solution to a problem instance, $a$ comes immediately before $b$ and $v(a) > v(b)$. Now suppose we create a larger problem instance by adding new jobs with the new poset formed from series or parallel composition with the original. There will always be an optimal solution to the larger problem where $a$ comes immediately before $b$.

Suppose otherwise. Let the optimal solution contain $a, x_1, x_2, \ldots, b$. Since $P$ was formed by series parallel composition, we know that all $x_i$s are incomparable to $a$ and $b$. Merge all the $x_i$ nodes into a new node $x'$ using rule 2. Now consider $v(x')$. If $v(x') \leq v(a)$ then we can swap $x'$ and $a$ without increasing objective value. Likewise, if $v(x') \geq v(b)$, we can swap $x'$ and $b$. Therefore, $v(a) < v(x') < v(b)$. But $v(a) > v(b)$, a contradiction.

Using rule 2 and rule 3, we can already get a simple but suboptimal $O(n^2)$ algorithm. Since $P$ is a series parallel order, assume the input contains a tree representation of $P$ where each node represents series composition or parallel composition, and the leaves are individual jobs. We can find an optimal solution with preorder traversal of the tree by maintaining the invariant that the optimal solution to each subproblem is a chain in increasing value order.

Suppose $P$ is the series composition of subproblems with posets $P_1$ and $P_2$. Let the optimal solutions be ordering $C_1$ and $C_2$. The optimal solution to $P$ is clearly the concatenation of these chains. However, it is possible that the first job in $C_2$ has lower value than the last job in $C_1$. In order to maintain the invariant that the solution is a sorted chain, we use rule 3 + rule 2 to merge the endpoints as long as they aren't in sorted order.

If $P$ is instead a parallel composition, we simply take the sorted chains $S_1$ and $S_2$ and merge them into a new sorted chain. Thanks to the invariant, this is valid.

Unfortunately, this algorithm is $O(n^2)$. In order to get an $O(nlogn)$ algorithm, we need to compute the chains lazily using rule 1.

Specifically, if a subproblem contains only nodes where the precedence constraints are the same as the order of values, then we can forget the precedence constraints completely and only look at the values. This is ensured by the same invariant that ensured the solutions are sorted chains in the previous algorithm.

Instead of computing a sorted chain for each subproblem, we represent the optimal solution to a subproblem as a pair of Fibonacci heaps, one a min heap, and one a max heap, both containing all the jobs in the subproblem. This means that we can pop off the minimum or maximum element of the solution in logarithmic time.

As before, we do a preorder traversal. Where $P$ is a series composition, we examine the maximum job of the first heap pair and the minimum job of the second heap pair. If their values are out of order, we pop them off and merge them using rule 2 and 3. Then we compare the newly created job to the new endpoints and continue popping and merging as long as they are out of order. Once the endpoints no longer have out of order values, we can safely forget the series precedence restriction thanks to rule 1. Then we just push the newly created jobs if any onto a heap, then merge the heaps to create the heap pair representing the solution to $P$ itself.

For a parallel composition, we simply merge the heap pairs. The new min heap is the merge of the min heap from each subproblem and likewise with the max heap. Note that Fibonacci heaps are mergeable in constant time.

Once we have a heap pair representing the solution to the entire problem, we can find the actual solution ordering by popping off the min heap until it is empty. After that we undo all the rule 2 substitutions to get a solution to the original problem.

Each job that is popped off a heap is either immediately merged into a new job, reducing the total job count, or is popped exactly once at the end. Therefore there is at most a linear number of heap pops, leading to $O(nlogn)$ time over all. The other operations are constant time per node or job and hence linear over all.