soma de índices semelhantes em listas circulares

Considere o seguinte problema:

Seja definido um wheel como uma lista indexada circularmente indexada de inteiros. Por exemplo…$k$$k$

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

… É um 5 rodas com 3 na posição 0, 4 na posição 1 e assim por diante. Uma roda suporta a operação de rotação, de modo que uma rotação em uma etapa transforma a roda acima em…

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

… Agora com 6 na posição 0, 3 na posição 1 e assim por diante. Seja $W_{N_k}$ um conjunto ordenado de N rodas k$N$ distintas . Dado algum W_ {N_k} e algum inteiro t , encontre uma série de rotações tais que…$k$$W_{N_k}$$t$

$$\forall\ 0 \leq i < k, \sum_{N \in W} N_i = t$$

Em outras palavras, se você dispor as rodas como uma matriz, a soma de cada coluna será $t$ . Suponha que $W_{N_k}$ seja construído para que a solução seja única até as rotações de cada elemento (ou seja, existem exatamente $k$ soluções únicas que consistem em tomar uma solução e girar cada roda em $W$ pelo mesmo número de etapas).

A solução trivial para esse problema envolve simplesmente verificar todas as rotações possíveis. Aqui está um pseudocódigo para isso:

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)

Esta é uma solução bastante lenta (algo como $O(k^n)$ ). Gostaria de saber se é possível resolver esse problema mais rapidamente e também se existe um nome para ele.

Para a maior parte desta resposta, discuto a versão de decisão do problema, na qual é dada uma instância com no máximo uma solução (a "promessa") e você precisa decidir se tem alguma solução ou nenhuma.

Você pode reduzir a PARTIÇÃO do seu problema (exercício). (PARTITION é o problema de determinar se um conjunto de números inteiros pode ser particionado em duas partes com a mesma soma.) É certo que isso não satisfaz necessariamente a condição de que a solução seja única.

Com um pouco mais de trabalho, você pode (diretamente) reduzir o SAT (a versão de decisão) do seu problema, e talvez isso possa ser feito de maneira a que, se a instância do SAT tiver uma solução exclusiva, a instância resultante de seu problema. Nesse caso, concluímos que a versão da decisão não pode ser solucionada no polytime, a menos que NP = RP, o que é considerado improvável.

Observe que, se a versão de decisão (mais precisamente, a versão prometida) do problema não puder ser solucionada no polytime, nenhum algoritmo poderá resolver todas as instâncias YES no polytime: se o fizesse, você poderia executá-lo até o tempo de execução alocado e verifique a solução (se o algoritmo parou a tempo).