Editing 1131 - Arc

Irinuca a descoperit un nou joc pe calculator. Pe ecran sunt plasate pe o linie <code>n</code> bile colorate. Culorile bilelor sunt codificate cu numere naturale. Un subșir de bile alăturate având toate aceeași culoare se numește secvență. O secvență va conține numărul maxim de bile alăturate având aceeași culoare. Lungimea unei secvențe este egală cu numărul de bile din care este compusă.

Irinuca are la dispoziție un arc special. Trăgând cu arcul asupra unei bile, dacă aceasta face parte dintr-o secvență de lungime cel puțin egală cu <code>3</code>, întreaga secvență va fi eliminată, iar bilele din dreapta secvenței se vor deplasa spre stânga pentru a umple “golul” lăsat de bilele eliminate. Dacă imediat în stânga și în dreapta secvenței eliminate se găseau două secvențe având aceeași culoare și dacă secvența obținută din unirea acestora după eliminare are o lungime cel puțin egală cu <code>3</code>, atunci va fi și ea eliminată la rândul ei. Procesul continuă până când secvențele din stânga și dreapta unei secvențe tocmai eliminate au culori diferite sau până când lungimea secvenței obținute prin alăturare este mai mică decât <code>3</code> sau până când în stânga ori în dreapta unei secvențe eliminate nu se mai găsesc bile sau până sunt eliminate toate bilele de pe ecran.

Scopul jocului este de a elimina cât mai multe bile de pe ecran. Cum Irinuca încă nu se pricepe prea bine la acest joc și-a stabilit o strategie. Va trage cu arcul întotdeauna asupra unei bile ce face parte din secvența de lungime maximă de pe ecran. Dacă sunt mai multe astfel de secvențe, ea va alege cea mai din stânga secvență de lungime maximă. Dacă toate secvențele de pe ecran au lungimi mai mici decât 3, Irinuca nu va mai putea elimina nici una din ele și jocul se încheie.

De exemplu, dacă șirul inițial de bile este 

<code>5 1 3 3 2 2 2 2 3 1 1 5 6 4 4 4 4 7</code>

Irinuca va acționa asupra unei bile de culoare <code>2</code>.  Prin eliminare se obține șirul de bile

<code>5 1 3 3 3 1 1 5 6 4 4 4 4 7</code>

din care se elimină și secvența de bile de culoare <code>3</code> obținându-se șirul de bile

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

din care se elimină și secvența de culoare <code>1</code>.

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

Cum secvența de bile de culoare <code>5</code> nu este suficient de lungă, aceasta nu se mai elimină. Acum Irinuca trage asupra unei bile de culoare <code>4</code> și obține

<code>5 5 6 7</code>

dar cum în stânga și în dreapta secvenței eliminate sunt secvențe de culori diferite, nu se va mai elimina nici o secvență. Jocul se încheie deoarece nu mai există nici o secvență de lungime cel puțin <code>3</code> asupra căreia să se poată trage.

= Cerinţă =
Cunoscând numărul de bile și culorile fiecărei bile de pe ecran se cere să se determine:

'''1.''' numărul de secvențe de bile care se aflau inițial pe ecran;

'''2.''' numărul de bile care rămân neeliminate de pe ecran și culorile bilelor rămase în ordine pe ecran la finalul jocului.

= Date de intrare =
Fișierul de intrare <code>arc.in</code> conține pe prima linie un număr natural <code>V</code>. Pentru toate testele de intrare, numărul <code>V</code> poate avea doar valoarea <code>1</code> sau <code>2</code>.

A doua linie conține un număr natural <code>n</code> reprezentând numărul de bile, iar a treia linie conține <code>n</code> numere naturale <code>c<sub>1</sub></code>, <code>c<sub>2</sub></code>, …, <code>c<sub>n</sub></code>  separate prin câte un spațiu, reprezentând culorile celor <code>n</code> bile de pe ecran.

= Date de ieșire =
Dacă valoarea lui <code>V</code> este <code>1</code>,  se va rezolva numai punctul <code>1</code> din cerință.

În acest caz, în fişierul de ieşire <code>arc.out</code> se va scrie un singur număr natural <code>n<sub>1</sub></code>, reprezentând numărul de secvențe de bile aflate inițial pe ecran.

Dacă valoarea lui <code>V</code> este <code>2</code>, se va rezolva numai punctul <code>2</code> din cerință.

În acest caz, în fişierul de ieşire <code>arc.out</code> se va scrie pe prima linie un singur număr natural <code>n<sub>2</sub></code>, reprezentând numărul de bile care rămân neeliminate de pe ecran la finalul jocului, iar pe următoarele <code>n<sub>2</sub></code> linii se va scrie câte un număr natural reprezentând în ordine culorile bilelor rămase neeliminate la finalul jocului.

Dacă la finalul jocului nu mai rămâne nici o bilă neeliminată, fișierul de ieșire va conține pe prima sa linie valoarea <code>0</code>.

= Restricții și precizări =

* <code>1 ≤ n ≤ 10 000</code>
* <code>1 ≤ c<sub>1</sub></code>, <code>c<sub>2</sub></code>, …, <code>c<sub>n</sub> ≤ 100 000</code>
* Pentru rezolvarea corectă a primei cerinţe se acordă 20 de puncte, iar pentru cerința a doua se acordă 80 de puncte.

= Exemplul 1 =
<code>arc.in</code>
 1
 18
 5 1 3 3 2 2 2 2 3 1 1 5 6 4 4 4 4 7
<code>arc.out</code>
 10

= Explicație =
<code>V = 1</code>

'''Atenție!''' Pentru acest test se rezolvă doar cerința 1.

Secvențele sunt <code>(5)</code>, <code>(1)</code>, <code>(3, 3)</code>, <code>(2,2,2,2)</code>, <code>(3)</code>, <code>(1,1)</code>, <code>(5)</code>, <code>(6)</code>, <code>(4,4,4,4)</code>, <code>(7)</code>.

== Încărcare soluție ==

=== Lipește codul aici ===
<syntaxhighlight lang="python" line="1">
f = open("arc.in", "r")
g = open("arc.out", "w")

p = 0
c = [0] * 10000
x = [0] * 100000
m = 0
n = 0

def citire():
    global p, n, c, x, m
    p = int(f.readline())
    n = int(f.readline())
    c[1] = int(f.readline())
    x[1] = 1
    m = 1
    for i in range(2, n+1):
        k = int(f.readline())
        if k == c[m]:
            x[m] += 1
        else:
            m += 1
            c[m] = k
            x[m] = 1

def maxim():
    mx = x[1]
    k = 1
    for i in range(1, m+1):
        if x[i] > mx:
            mx = x[i]
            k = i
    return k

def elim(k):
    global n, m
    if x[k] > 2:
        n -= x[k]
        i = k - 1
        j = k + 1
        while c[i] == c[j] and i >= 1 and j <= m and x[i] + x[j] > 2:
            n -= x[i] + x[j]
            i -= 1
            j += 1
        if j > m:
            m = i
        else:
            if i >= 1 and j <= m and c[i] == c[j]:
                x[i] += x[j]
                j += 1
            m1 = m - j + i + 1
            i += 1
            while j <= m:
                x[i] = x[j]
                c[i] = c[j]
                i += 1
                j += 1
            m = m1

citire()
if p == 1:
    g.write(str(m) + "\n")
else:
    k = maxim()
    while n > 0 and x[k] > 2:
        elim(k)
        if k > 0:
            k = maxim()
    if n > 0:
        g.write(str(n) + " ")
        for i in range(1, m+1):
            for j in range(1, x[i]+1):
                g.write(str(c[i]) + " ")
    else:
        g.write("0 ")
    
f.close()
g.close()
</syntaxhighlight>