Editing 2929 - Origami

= Cerința =
Tocmai ai primit o foaie dreptunghiulară (foarte mare) de dimensiuni <code>N⨯M</code>, împărțită în pătrățele de <code>1⨯1</code>. Fiecare pătrățel este colorat pe ambele părți cu una din cele <code>26</code> 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 <code>origamiIN.txt</code> conține pe prima linie numerele naturale <code>N</code> și <code>M</code> separate printr-un spațiu, iar pe următoarele <code>N</code> linii se află câte un șir de caractere de lungime <code>M</code>, reprezentând configurația culorilor foii inițiale.

= Date de ieșire =
Fișierul <code>origamiOUT.txt</code> va conține un singur număr natural pozitiv <code>X</code>, 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: <code>1 ≤ N ≤ M, N * M ≤ 1 000 000</code>
* Pentru <code>10</code> puncte: <code>M ≤ 10</code>
* Pentru <code>30</code> de puncte: <code>M ≤ 40</code>
* Pentru <code>50</code> de puncte: <code>M ≤ 600, X ≤ 100 000</code>

= Exemplu 1: =
<code>origamiIN.txt</code>
 5 7
 baabbaa
 cbbccbb
 ababbab
 cabccba
 bccaacc
<code>origamiOUT.txt</code>
 2 

= Exemplu 2: =
<code>origamiIN.txt</code>
 5 4
 baabbaa
 cbbccbb
 ababbab
 cabccba
 bccaacc
<code>origamiOUT.txt</code>
 Datele nu corespund restrictiilor impuse
<br>
== 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ă.