2929 - Origami

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ț.

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

2

Exemplu 2

origamiin.txt

4 5

abcda

bcdee

daaab

efbca

origamiout.txt

10

Rezolvare

#2929 - Origami
def count_distinct_submatrices(N, M, configuration):
    MOD = 1000000007

    if not (1 <= N <= M <= 1000000):
        print("Fals")
        return 0

    def hash_submatrix(start_row, end_row, start_col, end_col):
        h = 0
        power = 1

        for i in range(start_row, end_row + 1):
            for j in range(start_col, end_col + 1):
                h = (h + (ord(configuration[i][j]) - ord('a') + 1) * power) % MOD
                power = (power * 31) % MOD

        return h

    distinct_submatrices = set()

    # Calculul hash-urilor pentru toate submatricele posibile
    for i in range(N):
        for j in range(M):
            h = 0
            for k in range(i, N):
                for l in range(j, M):
                    h = (h * 31 + ord(configuration[k][l]) - ord('a') + 1) % MOD
                    distinct_submatrices.add(h)

    return len(distinct_submatrices)

# Citirea datelor de intrare
with open("origamiin.txt", "r") as infile:
    N, M = map(int, infile.readline().split())
    configuration = [infile.readline().strip() for _ in range(N)]

# Verificarea restricțiilor și calculul rezultatului
result = count_distinct_submatrices(N, M, configuration)

# Scrierea rezultatului în fișierul de ieșire
if result:
    with open("origamiout.txt", "w") as outfile:
        outfile.write(str(result) + '\n')

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ă.