2440 - puzzle

Mihai a primit de ziua lui un joc de puzzle. Jocul are N piese confecţionate prin lipirea unor bucăţi de dimensiune 1x1 (ilustrate în figurile de mai jos prin X); aceste bucăţi le vom numi în continuare, pe scurt, X-uri. Pentru confecţionarea unei piese se respectă următoarele reguli:

1. X-urile sunt aşezate unul peste altul, formând coloane ce pot avea înălţimi diferite, apoi coloanele se aliniază în partea de jos şi se lipesc între ele, una după cealaltă, de la stânga spre dreapta;

2. pe o coloană sunt cel mult nouă X-uri;

3. toate piesele au acelaşi număr de coloane.

Exemple:

În figurile 1, 2, 3, 4 sunt piese de puzzle care respectă regulile descrise, iar în figura 5 și în figura 6 NU sunt piese de puzzle, pentru că nu pot fi obţinute prin lipirea unor coloane de X-uri, una după cealaltă, de la stânga spre dreapta.

Fiind mic, Mihai nu poate rezolva puzzle-ul, dar poate face o singură operaţie: alege două piese şi le îmbină în dreptul laturilor de sus, răsturnând una dintre piese sus-jos (fără să o rotească sau să o răstoarne stânga-dreapta). Dacă în urma acestei operaţii el obţine un dreptunghi format din coloane complete de X-uri, toate coloanele având aceeaşi înălţime, este mulţumit. De exemplu, piesa din figura 1 și cea din figura 2 pot fi îmbinate în modul descris.

În figura 7 este piesa din figura 2 răsturnată sus-jos. În figura 8 este ilustrat dreptunghiul care se obţine din piesa din figura 1 şi piesa din figura 2 răsturnată sus-jos.

Observaţi că, dacă am roti piesa din figura 4, am putea să o îmbinăm cu piesa din figura 1, dar rotaţia nu este permisă.

Vom codifica o piesă printr-un număr natural, fiecare cifră din număr reprezentând (în ordine de la stânga la dreapta) câte X-uri se află pe coloana corespunzătoare din piesă.

De exemplu:

– piesa din figura 1 este codificată 4232;

– piesa din figura 2 este codificată 1323;

– piesa din figura 3 este codificată 4444;

– piesa din figura 4 este codificată 3231.

Cerința

Determinați care este numărul de moduri în care Mihai poate alege câte două piese dintre cele N pentru a face o operaţie în modul descris mai sus.

Date de intrare

Fișierul de intrare input.txt conține pe prima linie un număr natural N ce reprezintă numărul de piese din joc. Pe linia a doua se găsesc N numere naturale, separate prin câte un singur spațiu, reprezentând codificările celor N piese.

Date de ieșire

Fișierul de ieșire output.txt va conține o singură linie pe care va fi scris numărul cerut.

Restricții și precizări

• 2 ≤ N ≤ 100 000

Exemplul 1

input.txt:

5

222 432 234 123 111

output.txt:

3

Explicație:

Se pot îmbina 3 perechi de piese: piesa 1 cu piesa 5, piesa 2 cu piesa 3, piesa 2 cu piesa 4. Piesele 3 și 4 s-ar putea îmbina corect dacă una dintre ele ar fi răsturnată stânga-dreapta sau rotită, dar acest lucru nu e permis.

Exemplul 2

input.txt:

99999999999999999

32 3 2 1 31 4 1

Output:

Input-ul nu convine conditiilor

Rezolvare

def verificare(n):
    if not(2<=n<=100000):
        print("Input-ul nu convine conditiilor")
        exit()

f = [0] * 100001
v = []
frecv = [0] * 12
rez = 0
n = 0
k = 0

def fa(numar):
    global frecv
    t = 0
    mi = 9
    while numar:
        t += 1
        frecv[t] = numar % 10
        numar //= 10
        if frecv[t] < mi:
            mi = frecv[t]
    r = 0
    for i in range(t, 0, -1):
        r = r * 10 + (frecv[i] - mi)
    return r

def intoarce(code, k):
    global frecv
    t = 0
    aux = code
    ma = 0
    for i in range(1, k + 1):
        t += 1
        frecv[t] = aux % 10
        aux //= 10
        ma = max(ma, frecv[t])
    r = 0
    for i in range(t, 0, -1):
        r = r * 10 + (ma - frecv[i])
    return r

def lungime_nr(n):
    cnt = 0
    while n:
        cnt += 1
        n //= 10
    return cnt

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
    n = int(fin.readline().strip())
    verificare(n)
    v = list(map(int, fin.readline().split()))
    if n > 0:
        k = lungime_nr(v[0])
    
    for i in range(1, n + 1):
        f[fa(v[i - 1])] += 1

    rez = 0
    for i in range(1, 100001):
        rez += 1 * f[i] * f[intoarce(i, k)]

    rez //= 2
    rez += 1 * f[0] * (f[0] - 1) // 2
    fout.write(str(rez) + "\n")