Szukanie minimalnego wektora pozycji, różnic w podanych tablicach

Cześć,

trochę nie wiedziałem jak nazwać temat, pewnie nie oddałem nim istoty mojego problemu, więc:

Mam zdefiniowane tablice z danymi. Tablice zawsze kwadratowe, wielkość znana. Tablic jest ~1000 o wymirach 30x30.

Dla uproszczenia przyjmijmy mniejsze tablice.

Problem mam taki, że mając takie tablice:

000
010
000

010
111
010

010
111
000

na wyjściu chciałbym mieć wektor pozycji
1,0
2,1

żeby potem, mając którąś z tych tablic na wejściu, patrząc na wartości pod tymi pozycjami wiemy, którą dokładnie tablice dostaliśmy na wejściu.

No i pytanie do Was, czy przychodzi Wam do głowy jakiś algorytm bardziej ogarnięty niż brute-force? Bardzo z grubsza szacując dla tablic NxN brute-force ma złożoność O(NxN!) co trochę przerasta możliwości mojego skromnego lapka :/

Z góry dzięki za pomoc

Możesz napisać jaśniej jakiego rodzaju przetwarzanie chcesz wykonać?

Może rzeczywiście trochę niejasno napisałem.

Mam w pliku bazę tablic 30x30.

Chcę napisać programik, który zanalizuje wszystkie tablice i na ich podstawie wypluje wektor pozycji, takich jak napisałem w temacie.
Potem, już we właściwym programie, będzie jakaś funkcja, która będzie dostawać tablice wejściową i będzie musiała zwrócić id tej tablicy w bazie.

Czyli na przykładzie z tematu:

Mamy bazę:

id: 1
000
010
000

id: 2
010
111
010

id: 3
010
111
000

Przed kompilacją głównego programu, chcę uruchomić mój program, który zanalizuje tę bazę i wypluje wektor pozycji:
1,0
2,1

i teraz, w głównym programie, wcześniej wspomniana funkcja mogła by wyglądać tak:

size_t getArrayId(vector<vector<int>> arr)
        {
            int a, b;

            a = v[1][0];
            b = v[2][1];

            if (a == 0 && b == 0) return 1;
            if (a == 1 && b == 1) return 2;
            if (a == 1 && b == 0) return 3;
        }

czyli zamiast porównywać tablicę arr z każdą tablicą w bazie, porównujemy tylko dwie wartości.

Jak mniemam wektor pozycji zawiera te komórki po których te tablice się różnią, i zamiast porównywać wszystkie komórki chcesz tylko po tych z wektora.
Czyli oryginalny problem ma złożoności nie O(NxN!) tylko O(NxNxT), gdzie T to jest liczba tablic, stosując porównanie tylko wybranych komórek ciągle będziesz miał złożoność O(NxNxT), tylko pewnie ze znacznie mniejszą stałą.

Zamiast porównywać komórki, policz hasha dla całej tablicy, i później wyszykuj po tym hashu co da O(NxN).

Tak oryginalny problem ma złożoność taką jak podałeś. O(NxN!) to złożoność brute-forca wyznaczającego ten wektor. T pominąłem bo, jak pisałem, oszacowanie jest bardzo z grubsza. Bardziej chodziło mi o pokazanie, że mój lapek nie da rady.

Ale i tak dzięki (: Byłem trochę zaślepiony pomysłem z wektorem, że nie pomyślałem o hashu. Jak hash będzie za wolny, będę kombinował dalej.

Kombinujesz za bardzo. Weź to po prostu potraktuj jako bity liczby binarnej, albo w kolejności kolumn albo wierszy, obojętne. Przecież każda data tablica jak ja sobie rozłożysz kolumnowo czy wierszowo to jest 9-bitowy int.

edit: hmm teraz widzę że są 30x30, w takim razie faktycznie najprościej będzie trzymać to w jakejś HashMapie.