1027 - Cool

Se consideră un șir A format din N elemente naturale nenule. Numim secvență de lungime K a șirului A orice succesiune de elemente consecutive din șir de forma Ai, Ai+1 ,…, Ai+K-1.

O secvență o numim secvență cool dacă elementele care o compun sunt distincte și pot fi rearanjate astfel încât să alcătuiască o secvență continuă de numere consecutive.

De exemplu, considerând șirul A=(3,1,6,8,4,5,6,7,4,3,4), atunci secvența (8,4,5,6,7) este o secvență cool deoarece conține elemente distincte ce pot fi rearanjate astfel încât să alcătuiască șirul de numere consecutive 4,5,6,7,8, pe când secvențele (4,3,4), (6,7,4,3) nu sunt considerate secvențe cool.

Cerinţă

Fiind dat un şir de N numere naturale nenule se cer următoarele:

1. Pentru o valoare dată K să se verifice dacă secvența A1, A2 ,…, AK este secvență cool. Dacă secvența este cool, atunci se va afișa cea mai mare valoare ce aparține secvenței. Dacă secvența nu este cool, atunci se va afișa numărul elementelor distincte din secvența A1, A2 ,…, AK , adică numărul elementelor care apar o singură dată.

2. Lungimea maximă a unei secvențe cool și numărul secvențelor cool de lungime maximă.

Date de intrare

Fişierul de intrare input.txt conţine pe prima linie un număr natural p. Pentru toate testele de intrare, numărul p poate avea doar valoarea 1 sau valoarea 2. Pe linia a doua se găsesc, despărțite printr-un spațiu, două numere naturale N K. Pe următoarea linie se găsesc N numere întregi, separate prin câte un spațiu, ce reprezintă elementele şirului.

Date de ieşire

Dacă valoarea lui p este 1, atunci se va rezolva numai punctul 1 din cerință. În acest caz, fişierul de ieşire output.txt va conţine pe prima linie un număr natural, număr ce reprezintă conform cerinței 1, maximul secvenței A1, A2 ,…, AK, dacă secvența este secvență cool, sau numărul elementelor distincte din secvență, dacă aceasta nu este secvență cool.

Dacă valoarea lui p este 2, se va rezolva numai punctul 2 din cerință. În acest caz, fişierul de ieşire output.txt va avea două linii. Prima linie va conține un număr natural nenul ce reprezintă lungimea maximă a unei secvențe cool, iar următoarea linie un număr natural nenul ce reprezintă numărul de secvențe cool care au lungimea maximă.

Restricţii și precizări

• 1 ≤ N ≤ 5000
• 2 ≤ K ≤ 1000

Exemplul 1

input.txt:

1

7 4

6 4 5 7 8 3 5

output.txt:

7

Explicație:

Secvența 6 4 5 7 este cool.

Valoarea maximă din secvență este 7

Exemplul 2

input.txt:

1

7 6

6 4 5 7 5 4 3

output.txt:

2

Explicație:

Secvența 6 4 5 7 5 4 nu este secvență cool. Numărul valorilor distincte din secvență este 2. Valorile distincte sunt: 6,7

Exemplul 3

input.txt:

2

11 4

7 4 5 6 8 4 5 7 4 3 2

output.txt:

5

2

Explicație:

Cele două secvențe cool de lungime maximă 5 sunt:

7 4 5 6 8

6 8 4 5 7

Exemplul 4

input.txt:

99999999999999999

11 4

7 4 5 6 8 4 5 7 4 3 2

Output:

Invalid input. Please ensure 1 <= T <= 2, 2 <= K <= 1000, and 1 <= N <= 5000.

Rezolvare

def validate_input(T, K, N):
    if not (1 <= T <= 2) or not (2 <= K <= 1000) or not (1 <= N <= 5000):
        print("Invalid input. Please ensure 1 <= T <= 2, 2 <= K <= 1000, and 1 <= N <= 5000.")
        exit()


def main():
    with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
        cnt = [0] * 1003
        a = [0] * 5001
        nr = [0] * 5001
        T, K, n, maxK, minK = 0, 0, 0, 0, 5001
        L, Lmax, nMaxCool, amin, amax, bad = 0, 1, 1, 0, 0, 0

        T = int(fin.readline())
        n, K = map(int, fin.readline().split())

        validate_input(T,K, n)

        l=list(map(int, fin.readline().split()))

        for i in range(n):
            a[i] = l[i]
            if i < K:
                maxK = max(maxK, a[i])
                minK = min(minK, a[i])
                nr[a[i]] += 1

        if T == 1:
            cool = True
            distincte = 0

            for x in range(minK, maxK + 1):
                if nr[x] == 0 or nr[x] > 1:
                    cool = False
                if nr[x] == 1:
                    distincte += 1

            if cool:
                fout.write(str(maxK) + '\n')
            else:
                fout.write(str(distincte) + '\n')

        else:
            for i in range(n):
                cnt[a[i]] += 1
                bad = 0
                amin = amax = a[i]

                for j in range(i + 1, n):
                    cnt[a[j]] += 1
                    L = j - i + 1

                    if cnt[a[j]] > 1:
                        bad += 1

                    if amax < a[j]:
                        amax = a[j]
                    if amin > a[j]:
                        amin = a[j]

                    if bad or amax - amin != j - i:
                        continue

                    if L > Lmax:
                        Lmax = L
                        nMaxCool = 1
                    elif L == Lmax:
                        nMaxCool += 1

                cnt[a[i]] -= 1
                cnt = [0] * 1003

            fout.write(str(Lmax) + '\n' + str(nMaxCool) + '\n')

if __name__ == "__main__":
    main()