Editing 2438 - Pal

== Enunt ==

Micul Prinț a ajuns în țara numerelor palindrom cu număr impar de cifre unde a primit de la sfetnicul regelui o listă care conține N numere naturale, fiecare cu număr impar de cifre. Un număr este palindrom dacă prima lui cifră este egală cu ultima, a doua cu penultima, ș.a.m.d. Acesta i-a transmis că regele este foarte bolnav. Odată cu regele, numerele din listă s-au îmbolnăvit și ele. Sfetnicul i-a spus că lista corectă poate fi obținută prin înlocuirea fiecărui număr din ea cu cel mai mic palindrom mai mare sau egal cu numărul respectiv.
După ce a urmat recomandarea sfetnicului, Micul Prinț a constatat că în lista corectă obținută toate palindromurile sunt distincte. Uitându-se mai cu atenție la palindromurile din această listă, a observat că există perechi de palindromuri în care cel mai mic se poate obține din cel mai mare prin ștergerea aceluiași număr de cifre de la ambele capete. De exemplu pentru perechea 7531357 și 313 palindromul 313 se obține din 7531357 prin eliminarea a câte două cifre de la ambele capete ale sale.
Considerăm un șir de palindromuri din lista corectă și notăm cu X valoarea maximă a acestui șir. Vom spune că șirul este magic dacă toate palindromurile din el se pot obține după metoda descrisă mai sus, din palindromul de valoare X. Un exemplu de șir magic este 4, 53435, 7534357, 89753435798, presupunând că toate aceste numere se regăsesc în lista corectă.
== Cerinţa ==
Scrieți un program care citește numerele din lista primită de la sfetnicul regelui și afișează:
1) Lista corectă obținută de Micul Prinț;
2) Numărul de elemente ale celui mai lung șir magic care se poate obține din lista corectă;
3) Palindromurile din care este format cel mai lung șir magic, afișate în ordine crescătoare. Dacă există mai multe astfel de șiruri în lista corectă a Micului Prinț, se va afișa cel în care ultimul număr este cel mai mare.
== Date de intrare ==
Fișierul de intrare '''pal.in''' conţine pe prima linie numărul natural P, care nu poate avea decât valorile 1, 2 sau 3 și indică numărul cerinței care va fi rezolvată. Pe a doua linie numărul natural N de numere de pe lista primită de la sfetnicul regelui. Pe a treia linie se află numerele naturale din lista primită de la sfetnic, separate prin câte un spațiu.
== Date de ieșire ==
Fișierul de ieșire '''pal.out''' va conţine pe prima linie răspunsul la cerința rezolvată. Dacă s-a rezolvat prima cerință, fișierul de ieșire va conține un șir de N numere naturale, separate prin câte un spațiu, reprezentând numerele din lista corectă, în ordinea corespunzătoare listei inițiale. Dacă s-a rezolvat cerința 2, pe prima linie a fișierului de ieșire se va scrie lungimea celui mai lung șir magic. Dacă s-a rezolvat cerința 3, fișierul de ieșire va conține numerele determinate și afișate conform cerinței.
== Restricţii şi precizări ==
* '''0 < N ≤ 50.000''';
* Numerele de pe lista sfetnicului sunt naturale nenule și fiecare are cel mult 17 cifre;
* Pentru rezolvarea corectă a primei cerinţe se acordă 20 de puncte, pentru rezolvarea corectă a celei de a doua cerințe se acordă 20 de puncte, iar pentru rezolvarea corectă a celei de a treia cerințe se acordă 50 de puncte.
* În concurs s-au acordat 10 puncte din oficiu. Aici se vor acorda pentru exemplele din enunț.
== Exemplul 1 ==
; pal.in

  1
  3
  345 214 64325
; pal.out

  353 222 64346
== Explicație ==
Șirul palindromurilor de pe lista corectă obținută de Micul Prinț.
<br>

== Exemplul 2 ==
; pal.in

  2
  8
  2 3 120 4 432 5643461 7 21211
; pal.out

  3
== Explicație ==
Lista corectă conține palindromurile 2 3 121 4 21212 434 5643465 7 și cel mai lung șir magic este 3 434 5643465.
<br>

== Exemplul 3 ==
; pal.in

  3
  8
  2 3 5643461 7 120 4 21211 432
; pal.out

  3 434 5643465
== Explicație ==
Șirul magic 2 121 21212 are aceeași lungime dar se termină într-un număr mai mic.
<br>

== Rezolvare ==
<syntaxhighlight lang="python" line>
def is_palindrome(num):
    return str(num) == str(num)[::-1]

def next_palindrome(num):
    num += 1
    while not is_palindrome(num):
        num += 1
    return num

def prev_palindrome(num):
    num -= 1
    while not is_palindrome(num):
        num -= 1
    return num

def find_longest_magic_sequence(palindromes):
    n = len(palindromes)
    dp = [[0] * n for _ in range(n)]
    max_length = 1

    for i in range(n):
        dp[i][i] = 1

    for length in range(2, n + 1):
        for i in range(n - length + 1):
            j = i + length - 1
            if length == 2 and palindromes[i] == palindromes[j]:
                dp[i][j] = 2
                max_length = max(max_length, 2)
            elif palindromes[i] == palindromes[j] and dp[i + 1][j - 1] == length - 2:
                dp[i][j] = length
                max_length = max(max_length, length)

    return max_length

def main():
    with open("pal.in", "r") as fin:
        p = int(fin.readline())
        n = int(fin.readline())
        numbers = list(map(int, fin.readline().split()))

    if p == 1:
        correct_numbers = [next_palindrome(num) for num in numbers]
        with open("pal.out", "w") as fout:
            fout.write(" ".join(map(str, correct_numbers)))
    elif p == 2:
        max_length = find_longest_magic_sequence(numbers)
        with open("pal.out", "w") as fout:
            fout.write(f"{max_length}\n")
    elif p == 3:
        max_length = find_longest_magic_sequence(numbers)
        max_palindromes = []
        for i in range(n):
            for j in range(i + 1, n):
                if numbers[i] == numbers[j]:
                    palindromes = [numbers[k] for k in range(i, j + 1)]
                    if find_longest_magic_sequence(palindromes) == max_length:
                        max_palindromes = palindromes
        with open("pal.out", "w") as fout:
            fout.write(" ".join(map(str, max_palindromes)))

if __name__ == "__main__":
    main()

</syntaxhighlight>