Cerința

Tocmai ai primit o foaie dreptunghiulară (foarte mare) de dimensiuni N⨯M, împărțită în pătrățele de 1⨯1. Fiecare pătrățel este colorat pe ambele părți cu una din cele 26 de culori existente în univers, identificată pentru simplitate printr-un caracter mic al alfabetului englez.

Neavând ceva mai bun de făcut în timpul probei de baraj, te-ai gândit să înveți origami. Totuși, cum nu oricine este maestru în origami și acest sport necesită experiență și viziune artistică (lucruri pe care, bineînțeles, le vei dobândi cu timpul), ai hotărât că, pentru început, este mai interesant să împăturești foaia într-un mod clar stabilit.

Mai exact, la fiecare pas vei alege o dreaptă (orizontală sau verticală) situată între două linii (respectiv coloane) consecutive și vei “îndoi” jumătatea mai mică peste cea mare doar dacă culorile se vor suprapune perfect. Un exemplu de o astfel de îndoire validă este prezentat mai jos:

După orice îndoire vei obține un nou model (bineînțeles, de dimensiuni mai mici). În cazul în care cele două jumătăți sunt egale, ambele variante de îndoire sunt valide. Maestru în algoritmi și structuri de date eficiente, observi imediat că, după orice îndoitură, modelul rezultat va constitui o submatrice din modelul inițial. Natural, îți vine următoarea

întrebare:

“Câte submatrice distincte pot obține, îndoind foaia de un număr arbitrar de ori (sau deloc), fără a roti foaia sau a o întoarce pe cealaltă parte?”

Formal, două submatrice se consideră distincte, dacă măcar unul din cele patru colțuri diferă de la o submatrice la alta (ca indici).

Date de intrare

Fișierul origamiIN.txt conține pe prima linie numerele naturale N și M separate printr-un spațiu, iar pe următoarele N linii se află câte un șir de caractere de lungime M, reprezentând configurația culorilor foii inițiale.

Date de ieșire

Fișierul origamiOUT.txt va conține un singur număr natural pozitiv X, reprezentând numărul de submatrice distincte care se pot obține aplicând operațiile din enunț. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Datele nu corespund restrictiilor impuse".

Restricții și precizări

Pentru toate testele: 1 ≤ N ≤ M, N * M ≤ 1 000 000
Pentru 10 puncte: M ≤ 10
Pentru 30 de puncte: M ≤ 40
Pentru 50 de puncte: M ≤ 600, X ≤ 100 000

Exemplu 1:

origamiIN.txt

5 7
baabbaa
cbbccbb
ababbab
cabccba
bccaacc

origamiOUT.txt

Exemplu 2:

origamiIN.txt

5 4
baabbaa
cbbccbb
ababbab
cabccba
bccaacc

origamiOUT.txt

Datele nu corespund restrictiilor impuse

Rezolvare

<syntaxhighlight lang="python" line="1"> def verifica_restrictii(N, M):

   if not (1 <= N <= M and N * M <= 1_000_000 and M <= 600):
       with open("origamiOUT.txt", "w") as fout:
           fout.write("Datele nu corespund restrictiilor impuse\n")
       return False
   return True

def solve(t, N, M, A):

   L = [float('inf')] * (M + 1)
   R = [float('inf')] * (M + 1)
   C = [] * (2 * M + 1)
   d = [0] * (2 * M + 1)
   pref = [False] * (M + 1)
   suf = [False] * (M + 1)
   
   for i in range(1, N + 1):
       C[0] = '#'
       le, ri, len_ = 0, 0, 0
       for j in range(1, M + 1):
           C[2 * j - 1] = A[t][i][j]
           C[2 * j] = '#'
       size = 2 * M
       d[0] = 0
       for j in range(1, size + 1):
           if j > ri:
               len_ = 0
           else:
               len_ = min(ri - j, d[le + ri - j])
           while j + len_ <= size and j - len_ >= 0 and C[j + len_] == C[j - len_]:
               len_ += 1
           len_ -= 1
           d[j] = len_
           if j + len_ > ri:
               ri = j + len_
               le = j - len_
       for j in range(1, M + 1):
           R[j] = min(R[j], d[2 * j] // 2)
       for j in range(1, M + 1):
           L[j] = R[j - 1]

   pref[M] = True
   suf[1] = True
   last = 1
   for i in range(2, M + 1):
       if L[i] > 0:
           if i - L[i] <= last:
               suf[i] = True
               last = i

   last = M
   for i in range(M, 0, -1):
       if R[i] > 0:
           if i + R[i] >= last:
               pref[i] = True
               last = i

   ret = 0
   cnt = 0
   for i in range(1, M + 1):
       if suf[i]:
           cnt += 1
       if pref[i]:
           ret += cnt
   return ret

def main():

   with open("origamiIN.txt", "r") as fin:
       N, M = map(int, fin.readline().split())
       
       if not verifica_restrictii(N, M):
           return
       
       A = [[None] * (N + 1), [None] * (M + 1)]
       
       for i in range(1, N + 1):
           A[0][i] = ['#'] + list(fin.readline().strip())
       
       for j in range(1, M + 1):
           A[1][j] = ['#'] + [A[0][i][j] for i in range(1, N + 1)]

   with open("origamiOUT.txt", "w") as fout:
       fout.write(str(solve(0, N, M, A) * solve(1, M, N, A)) + "\n")

if __name__ == "__main__":

   main()

</syntaxhighlight>

Explicatie

Este exemplul din desenul de mai sus. Singurele răspunsuri posibile sunt matricea inițială, respectiv submatricea de după aplicarea operației evidențiate în figură.