Affectation des tâches de travailleur

Au lieu d'assigner gourmandeusement les travailleurs à la tâche la plus proche, essayez d'assigner la tâche de gourmandise à son ouvrier «le plus proche», c'est-à-dire que le travailleur dont le chemin passe de près et a suffisamment de temps perdu pour le gérer. De cette façon, vous avez une notion (gourmande) du plus petit temps nécessaire pour compléter toutes les tâches.

Par exemple: P>

D est la «tâche la plus éloignée», même sans définir ce terme encore, donc attribuer D à 1. Il est de 15 + 10 unités, donc définissez t code> = 25 et le relâché sur 2 à 25. p>

Voici le coût de la distance Tâche suivante, en prenant en compte les itinéraires les plus courts. p> xxx pré>

mais voici le coût réel en fonction de l'idée gourmande; l'augmentation du temps maximum t code>. p> xxx pré>

car c a le coût le plus élevé (c'est la tâche la plus dangereuse d'une perspective gourmande), Attribuez C à 2. P>

Les coûts suivants sont les suivants: P>

    A   B   slack    A  B
1  10  22     0     10 22
2  21  11  (-)7     14  4

(Remarque: après tout cela, je vous rends compte que vous avez dit que vous avez dit 14 ticks car par "adjacent" que vous pensais "au-dessus de" pendant que je l'ai interprété comme "à côté" ... Alors gardez à l'esprit mes calculs sont basés sur mes calculs. cela, mais cela ne devrait pas changer le résultat de beaucoup.)

Mon premier instinct serait de créer d'abord une file d'attente indépendante pour chaque travailleur en fonction du temps optimal à compléter, en supposant qu'aucun autre travailleur n'existe et ne traite pas des conflits plus tard ( Notez que, selon mon interprétation, lorsque 1 est terminé avec A, alors B est plus proche que d que d, mais une chose essentielle que nous voulons empêcher est 1 prise B): P>

1 [A=13, D=24]
2 [C=17, B=28]

Je suppose que la gourmandise "en temps réel" s'avère être mauvaise, car les travailleurs se retrouvent sur la chasse à l'oie sauvage vers des tâches qui seront complètes ou presque donc au moment de leur arrivée. Je vais donc proposer un algorithme de planification: un moyen d'attribuer intelligemment chaque travailleur à une séquence de tâches où l'Union des séquences est une couverture.

Comme d'autres ont déclaré que le TSP est intégré à cette condition de planification, c'est donc un NP Problème dur. P>

Mais il y a un algorithme d'approximation de temps polynomial facile pour le TSP qui produit un chemin d'accès maximal de 2x de longueur optimale. Il suffit de calculer une arborescence minimale étendue comprenant tous les sites de travail plus l'un des travailleurs. Ensuite, le chemin évident traversant chaque bord une fois dans chaque direction touche chaque nœud. P>

Bien sûr, lors de la mise en route Vous pouvez "abeilles-line" passé déjà visité des nœuds. Cela signifie simplement émettre la séquence de tâches en parcourant le MST en pré-commande. En raison de l'inégalité du triangle, ce chemin est souvent un peu meilleur que 2 fois optimal. (Je suppose que les mesures diagonales sont autorisées ici. Sinon, ce n'est pas vrai, mais l'algorithme fonctionne toujours bien.) P>

Donc, une approche de la planification est la suivante: P>

1. Compute un MST pour chaque travailleur et tous les sites de travail. li>
2. Utilisez le MST associé à chaque travailleur w pour calculer un chemin de pré-commande: s_w, t_wi, i = 1, 2 .... Ici, s_w est l'emplacement de départ du travailleur W. et les T_WI sont des emplacements de tâches dans la commande w aura leur visiter. li>
3. Faites maintenant une simple simulation entraînée par des événements pour créer un plan comme ci-dessous. (Il s'agit d'une simulation "intérieure" dans la simulation de jeu, juste pour construire un plan.) Li> ol>

   Dans l'algorithme ci-dessous, les événements incluent une heure d'apparition projetée et sont placées sur la file d'attente d'événement avec cette fois-ci comme clé. P>

   Let Arrive(W, T, L) be an arrival event of worker W 
     at task T starting from previous location L, traveling the shortest path
   Let Complete(W, T) be a completion event for worker W of task T
   
   For each worker W, place Arrive(W, T_W1, S_W) on the queue
   While events are left on the queue
     Remove an event E
     If E is an arrival Arrive(W, TW_i, L) 
       If TW_i has no worker yet, 
         Assign TW_i to W
         Schedule a future event Complete(W, TW_i) 10 time units in the future.
       Else // T has a worker
         Schedule Arrive(W, TW_{i+1}, L), if TW_{i+1} exists
     Else E is a completion Complete(W, TW_i)
       Schedule Arrive(W, TW_{i+1}, TW_i), if TW_{i+1} exists
   

Je suppose que l'apparition des travailleurs a besoin de ressembler à ce qu'un humain ferait (l'algorithme doit affecter chaque travail en tant que potentiel humain). Si l'algorithme ne le fait pas, un joueur se demandera ce que l'IA est faire et probablement essayer de parcourir manuellement (même s'il est moins optimal). Je pense que toute solution "globe optimale" ne ressemblerait probablement pas à ce qu'un humain ferait ...

Donc, je dirais que votre algorithme initial (volonté) pourrait avoir une légère amélioration du travail. Laissez chaque travailleur se diriger vers le travail de vaccant le plus proche, mais simulez-le là-bas et arrêtez la simulation lorsque le travailleur atteint le travail ou un autre travailleur est gratuit qui est plus proche (alors que le travailleur prendra ce travail). Si aucun emploi de vaccant ne peut être atteint, choisissez le travail occupé le plus proche et y aidez-y.