Все возможные комбинации длины 8 в массиве 2d

Чтобы устранить дубликаты, вы можете преобразовать 8-значные последовательности в 8-значные целые числа и поместить их в хеш-таблицу.

Мемоизация может быть хорошей идеей. Вы можете запомнить для каждой ячейки матрицы все возможные комбинации длины 2-7, которые можно из нее получить. Идя назад: сначала сгенерируйте для каждой ячейки все последовательности из 2 цифр. Затем на основе 3 цифр и т.д.

ОБНОВЛЕНИЕ: код на Python

# original matrix
lst = [
   [1,2,3,4,5,6],
   [8,9,1,2,3,4],
   [5,6,7,8,9,1],
   [2,3,4,5,6,7],
   [8,9,1,2,3,4],
   [5,6,7,8,9,1]]

# working matrtix; wrk[i][j] contains a set of all possible paths of length k which can end in lst[i][j]
wrk = [[set() for i in range(6)] for j in range(6)]

# for the first (0rh) iteration initialize with single step paths
for i in range(0, 6):
    for j in range(0, 6):
        wrk[i][j].add(lst[i][j])

# run iterations 1 through 7
for k in range(1,8):
    # create new emtpy wrk matrix for the next iteration
    nw = [[set() for i in range(6)] for j in range(6)]

    for i in range(0, 6):
        for j in range(0, 6):
            # the next gen. wrk[i][j] is going to be based on the current wrk paths of its neighbors
            ns = set()
            if i > 0:
                for p in wrk[i-1][j]:
                    ns.add(10**k * lst[i][j] + p)
            if i < 5:
                for p in wrk[i+1][j]:
                    ns.add(10**k * lst[i][j] + p)
            if j > 0:
                for p in wrk[i][j-1]:
                    ns.add(10**k * lst[i][j] + p)
            if j < 5:
                for p in wrk[i][j+1]:
                    ns.add(10**k * lst[i][j] + p)

            nw[i][j] = ns
    wrk = nw

# now build final set to eliminate duplicates
result = set()

for i in range(0, 6):
    for j in range(0, 6):
        result |= wrk[i][j]

print len(result)
print result

Есть МНОГО способов сделать это. Прохождение каждой комбинации является вполне разумным первым подходом. Все зависит от ваших требований. Если ваша матрица небольшая и эта операция не чувствительна ко времени, то проблем нет.

Я не очень разбираюсь в алгоритмах, но я уверен, что есть действительно умные способы сделать это, которые кто-нибудь опубликует после меня.

Кроме того, в Java при использовании CamelCase имена методов должны начинаться со строчной буквы.

int a={{1,2,3,4,5,6}, {8,9,1,2,3,4}, {5,6,7,8,9,1}, {2,3,4,5,6,7}, {8,9,1,2,3,4}, {5,6,7,8,9,1}, }

Под длиной вы подразумеваете суммирование комбинации элементов матрицы, в результате чего получается 8.
т. е. элементы для суммирования 8 с самой строкой и с другими элементами строки.
Из строки 1 = { {2,6}, {3,5}, } и теперь элементы строки 1 со строкой 2 и так далее. Это то, что вы ожидаете?

Вы можете думать о своей матрице, как об одномерном массиве - здесь неважно ("разместите" строки одну за другой). Для одномерного массива вы можете написать такую ​​функцию (при условии, что вы должны распечатать комбинации)

f(i, n) prints all combinations of length n using elements a[i] ... a[last].

Он должен пропустить некоторые элементы от a[i] до a[i + k] (для всех возможных k), вывести a[k] и сделать рекурсивный вызов f(i + k + 1, n - 1).