Somme d'ensemble cumulative minimale

Considérez ce problème: étant donné une liste d'ensembles finis, recherchez un ordre qui minimise .$s_1, s_2, s_3, \ldots$$|s_1| + |s_1 \cup s_2| + |s_1 \cup s_2 \cup s_3| + \ldots$

Existe-t-il des algorithmes connus pour cela? Quelle est sa complexité? Je n'ai pas encore pu penser à un algorithme optimal efficace, mais ce n'est évidemment pas non plus dans NP-Hard.

Ce problème est en fait lié à un problème de planification connu sous le nom de "Planification contrainte par priorité pour minimiser le temps d'achèvement pondéré". Le problème est le suivant: étant donné un ensemble de travaux, où chaque travail a un temps de traitement (p) et un poids (w) et un graphique de priorité est défini sur les travaux. L'objectif est de planifier les travaux sur une seule machine (non préemptive) de telle sorte que les contraintes de priorité soient satisfaites et que la somme du temps d'achèvement pondéré soit minimisée. Le problème est NP-difficile et une approximation 2 est connue.

Réduction du problème de somme cumulée minimale au problème d'ordonnancement contraint par priorité: pour chaque élément, créez un travail avec p = 1, w = 0. Créez également un travail avec p = 0, w = 1 pour chaque ensemble. Créez le graphique de priorité, de telle sorte que si l' élément , alors doit être programmé avant . Je pense que ce cas particulier du problème de planification est également NP-difficile.$e \in S$$e$$S$

Voir les liens suivants,

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

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

Shalmoli Gupta a déjà expliqué que le problème général est NP-difficile, j'ai donc décidé de rechercher si des cas particuliers sont résolubles polynomiaux. Finalement, j'ai trouvé une solution au cas particulier des ensembles qui représentent un arbre, ou plus généralement, un ordre série parallèle par inclusion de sous-ensemble avec tous les ensembles incomparables disjoints.

Une propriété qui facilite les choses est que la liste des ensembles est fermée sous l'intersection. Si , alors, il existe un ordre optimal dans lequel s 1 précède s 2 . Nous pouvons supposer WLOG que l'ordre optimal est une extension linéaire de l'ordre partiel donné par l'inclusion de sous-ensemble.$s_1 \subseteq s_2$$s_1$$s_2$

Étant donné que tous les sous-ensembles d'un ensemble apparaissent devant lui dans l'ordre, cela signifie que le montant ajouté à la somme cumulée par un ensemble donné est fixe, quel que soit son emplacement. Si est la liste des ensembles, le coût supplémentaire d'un ensemble est le nombre d'éléments s qui ne sont pas dans un sous - ensemble de s qui apparaît dans S . Si le même ensemble apparaît plusieurs fois en S , nous pouvons arbitrairement en choisir un pour commencer et laisser les autres coûter 0.$S$$S$$S$

Cela signifie que le problème est équivalent au problème du temps d'achèvement pondéré minimum dans la planification d'une seule machine avec des contraintes de priorité. Dans ce problème, étant donné un ensemble de travaux avec des poids et des temps t j , et un ordre partiel sur les travaux P , nous souhaitons trouver un ordre des travaux qui minimise le temps total d'achèvement pondéré, c'est-à-dire$w_j$$t_j$$P$

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

sous réserve des contraintes de priorité . Le problème de jeu cumulatif minimal avec les jeux fermés d'intersection peut être transformé en ceci en créant un travail pour chaque jeu, où chaque travail a un poids 1, un temps égal au coût incrémentiel défini ci-dessus, et P est l'ordre donné par l'inclusion de sous-ensemble.$P$$P$

Il s'avère que ce problème est également NP-Hard pour le général . Cependant, certaines formes spéciales de P peuvent être résolues en temps polynomial.$P$$P$

Cet article donne un algorithme pour le cas des ordres parallèles en série P (qui inclut également le cas important des arbres). Malheureusement, je n'ai pas pu accéder à ce document, j'ai donc décidé d'essayer de le réinventer indépendamment. Voici ce que j'ai trouvé.$O(nlogn)$$P$

Afin de résoudre ce problème, plusieurs observations sont nécessaires.

Tout d'abord, en l'absence de contraintes de précédence, la solution optimale est de simplement trier les jobs dans l'ordre croissant de . Par souci de simplicité, je ferai référence à cela comme la valeur du travail, abrégéev(j). Notez que le tri étantO(nlogn), il est impossible de faire mieux que cette complexité.$\frac{t_j}{w_j}$$v(j)$$O(nlogn)$

Règle 1 Soit et b des emplois tels que a < b ∈ P et b couvre a. Si v ( a ) < v ( b ) , alors nous pouvons supprimer la contrainte a < b sans affecter l'ordre optimal ou la valeur objective.$a$$b$$a < b \in P$$v(a) < v(b)$$a < b$

Supposons que apparaisse devant a dans l'ordre optimal du problème relaxé. Puisque b couvrait a l'origine, cela signifie que tous les travaux entre b et a dans la nouvelle commande sont incomparables avec a et b. Mais puisque b a une valeur supérieure à a, nous pouvons diminuer la valeur objective en échangeant b et a, une contradiction.$b$$a$

De même, nous pouvons supprimer la contrainte dans le cas où tant que nous nous assurons qu'après tri par valeur, nous rompons les liens en consultant les relations de priorité du problème d'origine (simplifié). Cela garantit que la solution optimale trouvée pour le problème détendu est également une solution optimale au problème d'origine.$v(a) = v(b)$

Par conséquent, chaque fois que b couvre a et , nous pouvons simplifier le problème en supprimant la contrainte a < b .$v(a) \leq v(b)$$a < b$

Règle 2 Supposons que nous savons que b suit immédiatement après a dans une solution optimale. Nous pouvons fusionner a et b en un nouveau nœud c avec et t c = t a + t b , tout en contractant le poset P de manière appropriée.$w_c = w_a + w_b$$t_c = t_a + t_b$$P$

La valeur objective optimale du nouveau problème diffère par une constante de la valeur objective d'origine (spécifiquement ), mais cette constante ne dépend pas de l'ordre et donc l'ordre optimal n'est pas affecté. Nous pouvons récupérer une solution optimale à l'ancien problème en prenant une solution optimale au nouveau problème et en remplaçant c par a b .$w_at_b$$c$$ab$

Règle 3 Supposons que dans une solution optimale à une instance de problème, vienne immédiatement avant b et v ( a ) > v ( b ) . Supposons maintenant que nous créons une instance de problème plus grande en ajoutant de nouveaux travaux avec le nouveau poset formé à partir d'une composition série ou parallèle avec l'original. Il y aura toujours une solution optimale au problème plus large où a vient juste avant b .$a$$b$$v(a) > v(b)$$a$$b$

Supposons le contraire. Que la solution optimale contienne . Puisque P a été formé par une composition parallèle en série, nous savons que tous les x i sont incomparables avec a et b . Fusionnez tous les nœuds x i en un nouveau nœud x ′ en utilisant la règle 2. Considérons maintenant v ( x ′ ) . Si v ( x ′ ) ≤ v ( a ) alors on peut échanger$a, x_1, x_2, \ldots, b$$P$$x_i$$a$$b$$x_i$$x'$$v(x')$$v(x') \leq v(a)$ et a sans augmenter la valeur objective. De même, si v ( x ′ ) ≥ v ( b ) , on peut échanger x ′ et b . Par conséquent, v ( a ) < v ( x ′ ) < v ( b ) . Mais v ( a ) > v ( b ) , une contradiction.$x'$$a$$v(x') \geq v(b)$$x'$$b$$v(a) < v(x') < v(b)$$v(a) > v(b)$

En utilisant la règle 2 et la règle 3, nous pouvons déjà obtenir un algorithme simple mais sous-optimal . Puisque P est un ordre parallèle en série, supposons que l'entrée contient une représentation arborescente de P où chaque nœud représente la composition en série ou la composition parallèle, et les feuilles sont des tâches individuelles. Nous pouvons trouver une solution optimale avec une traversée en précommande de l'arbre en maintenant l'invariant que la solution optimale pour chaque sous-problème est une chaîne en ordre croissant de valeur.$O(n^2)$$P$$P$

Supposons que soit la composition en série de sous-problèmes avec les posets P 1 et P 2 . Soit les solutions optimales ordonnant C 1 et C 2 . La solution optimale à P est clairement la concaténation de ces chaînes. Cependant, il est possible que le premier travail en C 2 ait une valeur inférieure à celle du dernier travail en C 1 . Afin de maintenir l'invariant que la solution est une chaîne triée, nous utilisons la règle 3 + la règle 2 pour fusionner les points de terminaison tant qu'ils ne sont pas dans l'ordre trié.$P$$P_1$$P_2$$C_1$$C_2$$P$$C_2$$C_1$

Si est plutôt une composition parallèle, nous prenons simplement les chaînes triées S 1 et S 2 et les fusionnons en une nouvelle chaîne triée. Grâce à l'invariant, c'est valable.$P$$S_1$$S_2$

Malheureusement, cet algorithme est . Afin d'obtenir un algorithme O ( n l o g n ) , nous devons calculer les chaînes paresseusement en utilisant la règle 1.$O(n^2)$$O(nlogn)$

Plus précisément, si un sous-problème ne contient que des nœuds où les contraintes de priorité sont les mêmes que l'ordre des valeurs, alors nous pouvons complètement oublier les contraintes de priorité et ne regarder que les valeurs. Ceci est assuré par le même invariant qui a assuré que les solutions sont des chaînes triées dans l'algorithme précédent.

Au lieu de calculer une chaîne triée pour chaque sous-problème, nous représentons la solution optimale à un sous-problème sous la forme d'une paire de tas de Fibonacci, un tas min et un tas max, contenant tous les deux les travaux du sous-problème. Cela signifie que nous pouvons supprimer l'élément minimum ou maximum de la solution en temps logarithmique.

$P$$P$

Pour une composition parallèle, nous fusionnons simplement les paires de tas. Le nouveau segment min est la fusion du segment min de chaque sous-problème et de même avec le segment max. Notez que les tas de Fibonacci peuvent être fusionnés en temps constant.

Une fois que nous avons une paire de segments représentant la solution à l'ensemble du problème, nous pouvons trouver l'ordre réel de la solution en sortant le segment min jusqu'à ce qu'il soit vide. Après cela, nous annulons toutes les substitutions de la règle 2 pour obtenir une solution au problème d'origine.

$O(nlogn)$