somme d'indices similaires dans des listes circulaires

Considérez le problème suivant:

Soit une roue définie comme une liste indexée liée de façon circulaire de entiers. Par exemple… $k$ $k$

{3, 4, 9, -1, 6}

… Est une 5 roues avec 3 en position 0, 4 en position 1, etc. Une roue prend en charge l'opération de rotation, de sorte qu'une rotation en une étape transformerait la roue ci-dessus en…

{6, 3, 4, 9, -1}

… Maintenant avec 6 en position 0, 3 en position 1, etc. Soit un ensemble ordonné de roues distinctes . Étant donné certains et certains entiers , trouvez une série de rotations telles que… $W_{N_k}$ $N$ $k$ $W_{N_k}$ $t$

$\forall 0 \leq je < k, \sum_{N \in W} N_{je} = t$ $\forall\ 0 \leq i < k, \sum_{N \in W} N_i = t$
En d'autres termes, si vous disposiez les roues sous forme de matrice, la somme de chaque colonne serait . Supposons que est construit de telle sorte que la solution soit unique jusqu'aux rotations de chaque élément (c'est-à-dire qu'il existe exactement solutions uniques qui consistent à prendre une solution, puis à faire tourner chaque roue en du même nombre d'étapes). $t$ $W_{N_k}$ $k$ $W$

La solution triviale à ce problème consiste simplement à vérifier chaque rotation possible. Voici un pseudocode pour cela:

function solve(wheels, index)
    if wheels are solved:
        return true
    if index >= wheels.num_wheels:
        return false
    for each position 1..k:
        if solve(index + 1) is true:
            return true
        else:
            rotate wheels[index] by 1

solve(wheels, 0)

C'est une solution assez lente (quelque chose comme ). Je me demande s'il est possible de faire ce problème plus rapidement, et aussi s'il y a un nom pour cela. $O(k^n)$

algorithms

— Apis Utilis
source

Je soupçonne que cela pourrait être NP-complet, car il ne semble pas que nous pouvons vraiment dire si une solution partielle va conduire à une solution correcte jusqu'à ce que nous définissions la roue finale ... Je n'ai pas encore de preuve cependant . J'ajouterai une réponse si j'y pense.

— Matt Lewis

Pour la plupart de cette réponse, je discute de la version de décision du problème, dans laquelle une instance ayant au plus une solution est donnée (la "promesse"), et vous devez décider si elle a des solutions ou aucune.

Vous pouvez réduire la PARTITION à votre problème (exercice). (PARTITION est le problème de déterminer si un ensemble d'entiers peut être partitionné en deux parties avec une somme égale.) Certes, cela ne satisfait pas nécessairement la condition que la solution soit unique.

Avec un peu plus de travail, vous pouvez (directement) réduire SAT à (la version de décision de) votre problème, et peut-être que cela peut être fait de telle sorte que si l'instance SAT a une solution unique, l'instance résultante de ton problème. Dans ce cas, nous obtenons que la version de décision n'est pas résoluble en polytime sauf si NP = RP, ce qui est considéré comme improbable.

Notez que si la version de décision (plus précisément, la version promise) du problème n'est pas résoluble en polytime, aucun algorithme ne peut résoudre toutes les instances YES en polytime: si c'est le cas, vous pouvez l'exécuter jusqu'au temps d'exécution alloué, et vérifier la solution (si l'algorithme s'est arrêté à temps).

— Yuval Filmus
source