Editing 1027 - Cool

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

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

= Cerinţă =
Fiind dat un şir de <code>N</code> numere naturale nenule se cer următoarele:

1. Pentru o valoare dată <code>K</code> să se verifice dacă secvența <code>A1</code>, <code>A2</code> ,…, <code>AK</code> 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 <code>A1</code>, <code>A2</code> ,…, <code>AK</code> , 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 <code>input.txt</code> conţine pe prima linie un număr natural <code>p</code>. Pentru toate testele de intrare, numărul p poate avea doar valoarea <code>1</code> sau valoarea <code>2</code>. Pe linia a doua se găsesc, despărțite printr-un spațiu, două numere naturale <code>N K</code>. Pe următoarea linie se găsesc <code>N</code> numere întregi, separate prin câte un spațiu, ce reprezintă elementele şirului.

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

Dacă valoarea lui <code>p</code> este <code>2</code>, se va rezolva numai punctul <code>2</code> din cerință. În acest caz, fişierul de ieşire <code>output.txt</code> 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 =

* <code>1 ≤ N ≤ 5000</code>
* <code>2 ≤ K ≤ 1000</code>

== Exemplul 1 ==
input.txt:

1

7 4

6 4 5 7 8 3 5

output.txt:

7

Explicație:

Secvența <code>6 4 5 7</code> este cool.

Valoarea maximă din secvență este <code>7</code>

== Exemplul 2 ==
input.txt:

1

7 6

6 4 5 7 5 4 3

output.txt:

2

Explicație:

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

== 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:

<code>7 4 5 6 8</code>

<code>6 8 4 5 7</code>

== 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 ==
<syntaxhighlight lang="python3" line="1">
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()

</syntaxhighlight>