Editing 2068 - kpal

== Enunt ==

Alecu este un copil năzdrăvan care strică orice lucru. El a scris pe o foaie de hârtie un cuvânt. Fiind elev în clasa întâi, el nu a învățat decât primele <code>X</code> litere mici ale alfabetului englez, iar cuvântul de pe foaie este scris doar cu aceste litere.

El își propune să taie foaia în mai multe bucăți dar să obțină doar cuvinte având același număr de litere și în același timp toate cuvintele obținute în urma tăierii să fie palindromuri. Un cuvânt este palindrom dacă citit de la stânga spre dreapta este identic cu cuvântul obținut prin citire de la dreapta spre stânga. Exemplu de palindrom este cuvântul <code>abcba</code>.

În dorința de a obține în urma tăierii doar cuvinte palindrom, Alecu poate schimba orice literă a cuvântului, în oricare alta cunoscută de el, dar fiecare astfel de schimbare are un cost cunoscut. Mai mult, el știe că o literă din cuvântul inițial nu o poate schimba decât cel mult o singură dată.

Notăm cu <code>Nr(c)</code> numărul minim de palindromuri de lungimi egale în care poate fi tăiat cuvântul de pe foaie, având voie să se efectueze schimbări ale literelor, dar care să nu însumeze un cost total mai mare decât <code>c</code>. Alecu știe să determine valoarea <code>Nr(c)</code> pentru orice număr natural <code>c</code>.

= Cerința =
Scrieți un program care pentru un număr natural <code>Q</code> și șirul numerelor naturale <code>0,1,2,...,Q-1,Q</code>, determină suma: <code>Nr(0)+Nr(1)+Nr(2)+...+ Nr(Q-1)+Nr(Q)</code>.

= Date de intrare =
Fișierul de intrare <code>kpalIN.txt</code> pe prima linie conține numărul natural <code>X2. Următoarele</code> X@ linii conțin câte <code>X</code> numere. Pentru toate aceste linii, al <code>j</code>-lea număr de pe linia <code>i</code> reprezintă costul de a transforma a <code>i</code>-a literă în a <code>j</code>-a literă a alfabetului englez (<code>cost[i][j]</code>). Pe linia <code>X+2</code> se găsește un șir de litere ale alfabetului englez, reprezentând cuvântul scris inițial pe foaie. Ultima linie a fișierului conține numărul natural <code>Q</code>.

= Date de ieșire =
Fișierul de ieșire <code>kpalOUT.txt</code> va conține pe prima linie un număr natural reprezentând suma determinată. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Datele nu corespund restrictiilor impuse".

= Restricții și precizări =

* <code>1 ≤ lungimea cuvântului  ≤ 100 000</code>, iar cuvântul conține doar litere mici;
* <code>1 ≤ X ≤ 26</code>;
* <code>0 ≤ Q ≤ 1 000 000 000</code>;
* <code>1 ≤ cost[i][j] ≤ 10000</code>, unde <code>1 ≤ i</code>, <code>j ≤ X</code> și <code>i ≠ j</code>;
* <code>cost[i][i]=0</code>, unde <code>1 ≤ i ≤ X</code>;
* Dacă cuvântul inițial este palindrom, atunci considerăm că a fost obținut tot în urma unei tăieturi;

= Exemplul 1: =
<code>kpalIN.txt</code>
 3
 0 1 2 
 3 0 2
 3 8 0 
 aabbbc
 3
<code>kpalOUT.txt</code>
 16

= Exemplul 2: =
<code>kpalIN.txt</code>
 27
 0 1 2 
 3 0 2
 3 8 0 
 aabbbc
 3
<code>kpalOUT.txt</code>
 Datele nu corespund restrictiilor impuse
:

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(Sigma, Q, Cost):
    # Restrictiile impuse
    if not (1 <= Sigma <= 26 and 0 <= Q <= 1000000000):
        return False
    for i in range(Sigma):
        for j in range(Sigma):
            if i != j and not (1 <= Cost[i][j] <= 10000):
                return False
    return True

def main():
    with open("kpalIN.txt", "r") as f:
        Sigma = int(f.readline().strip())
        if Sigma > 26:  # Verificare pentru Sigma
            with open("kpalOUT.txt", "w") as out_file:
                out_file.write("Datele nu corespund restrictiilor impuse\n")
            return
        Cost = [list(map(int, f.readline().split())) for _ in range(Sigma)]
        cuvant = f.readline().strip()
        Q = int(f.readline().strip())

    if not verifica_restrictii(Sigma, Q, Cost):
        with open("kpalOUT.txt", "w") as f:
            f.write("Datele nu corespund restrictiilor impuse\n")
        return

    INF = 1000000000
    CostMatch = [[0] * 30 for _ in range(30)]
    Price = [0] * 300
    Count = [0] * 300

    for i in range(Sigma):
        for j in range(Sigma):
            CostMatch[i][j] = INF
            for k in range(Sigma):
                CostMatch[i][j] = min(CostMatch[i][j], Cost[i][k] + Cost[j][k])

    N = len(cuvant)
    StackSize = 0

    for lung in range(1, N + 1):
        if N % lung != 0:
            continue

        current_price = 0
        for i in range(N // lung):
            left = i * lung
            right = left + lung - 1
            while left < right:
                current_price += CostMatch[ord(cuvant[left]) - ord('a')][ord(cuvant[right]) - ord('a')]
                right -= 1
                left += 1

        while StackSize > 0 and Price[StackSize - 1] >= current_price:
            StackSize -= 1
        Count[StackSize] = N // lung
        Price[StackSize] = current_price
        StackSize += 1

    while StackSize > 0 and Price[StackSize - 1] > Q:
        StackSize -= 1
    Price[StackSize] = Q + 1

    answer = 0
    for i in range(StackSize):
        answer += (Price[i + 1] - Price[i]) * Count[i]

    with open("kpalOUT.txt", "w") as f:
        f.write(str(answer) + '\n')

if __name__ == "__main__":
    main()

</syntaxhighlight>