Editing 1208 - Solitar

Se consideră un joc de cărţi cu un număr nelimitat de coloane. Iniţial, pe prima coloană există, într‑o ordine oarecare, <code>N</code> cărţi cu numere distincte din mulţimea <code>{1,2,…,N}</code>, următoarele coloane fiind vide (fără cărţi). Numim secvenţă de la sfârşitul coloanei ultima sau ultimele două sau ultimele trei etc. cărţi din coloană care au scrise pe ele numere consecutive în ordine crescătoare, considerate de jos în sus. De exemplu, în figurile 1 şi 2 sunt reprezentate două astfel de coloane cu câte <code>6</code> cărţi având numere între <code>1</code> şi <code>6</code>. În figura 1, secvenţa de la sfârşitul coloanei este formată doar din cartea <code>1</code>. În figura 2, secvenţa de la sfârşitul coloanei este formată din cărţile <code>3</code>, <code>4</code> şi <code>5</code>. Se observă că în coloana din figura 1 mai există o secvenţă formată din cărţile <code>2</code>, <code>3</code> şi <code>4</code>, dar aceasta nu este la sfârşitul coloanei.

Operaţiile permise ale jocului sunt:

A. mutarea secvenţei de cărţi de la sfârşitul unei coloane pe o coloană nouă, dacă acea coloană este vidă (nu conţine nicio carte);

B. mutarea secvenţei de cărţi de la sfârşitul unei coloane la sfârşitul altei coloane cu cărţi, doar dacă secvenţa mutată formează o secvenţă de numere consecutive cu cele de pe cartea sau cărţile aflate la sfârşitul coloanei respective.

Se doreşte ca, printr-un număr minim de operaţii permise, să se obţină pe una dintre coloane toate numerele de la <code>1</code> la <code>N</code>, în ordine crescătoare, considerate de jos în sus.

De exemplu, de la configuraţia iniţială din figura 2 se va obţine, printr-o operaţie <code>A</code>, configuraţia 1 de mai jos. Apoi, printr-o operaţie <code>B</code>, se obţine configuraţia 2, printr-o nouă operaţie <code>B</code> se obţine configuraţia 3, apoi se mută secvenţa <code>2,3,4,5,6</code> pe o coloană vidă (operaţia <code>A</code>), apoi se mută secvenţa <code>1</code> peste secvenţa <code>2,3,4,5,6</code> (operaţia <code>B</code>) şi se obţine, pe coloana a doua, configuraţia finală cerută.
{| class="wikitable"
|Configurația 1
|Configurația 2
|Configurația 3
|Configurația 4
|Configurația 5
|-
|
|
|
|}

= Cerința =
Cunoscând valoarea lui <code>N</code>, precum şi valorile cărţilor de pe prima coloană, să se determine numărul minim de operaţii prin care se poate obţine secvenţa <code>1, 2, …, N</code> pe una dintre coloane.

= Date de intrare =
Fişierul <code>solitar.in</code> conţine pe prima linie numărul natural <code>N</code> şi pe linia următoare <code>N</code> numere naturale distincte din mulţimea <code>{1,2,…,N}</code>, separate prin câte un spaţiu, date în ordinea de pe coloană, de sus în jos.

= Date de ieșire =
Fişierul <code>solitar.out</code> va conţine o singură linie pe care va fi scris un număr natural <code>M</code> reprezentând numărul minim de operaţii prin care se poate obţine secvenţa cerută.

= Restricții și precizări =

* <code>2 ≤ n ≤ 100 000</code>

= Exemplu: =
<code>solitar.in</code>
 6
 1 6 2 5 4 3
<code>solitar.out</code>
 5

= Explicație =
Cele <code>5</code> mutări sunt descrise în enunţul problemei.

<syntaxhighlight lang="python" line="1">
from collections import deque

def min_operations_to_sort_cards(N, cards):
    # Initialize columns with the initial column
    columns = [deque(cards)]
    
    def find_sequences(column):
        sequences = []
        start = len(column) - 1
        while start >= 0:
            end = start
            while start > 0 and column[start] - 1 == column[start - 1]:
                start -= 1
            sequences.append((start, end))
            start -= 1
        return sequences
    
    def move_sequence(src, dst):
        if not columns[dst] or columns[dst][-1] + 1 == columns[src][sequences[0][0]]:
            for _ in range(sequences[0][1] - sequences[0][0] + 1):
                columns[dst].append(columns[src].popleft())
        else:
            for _ in range(sequences[0][1] - sequences[0][0] + 1):
                columns.append(deque())
                columns[-1].append(columns[src].popleft())
    
    operations = 0
    while len(columns) > 1 or len(columns[0]) != N:
        for idx, col in enumerate(columns):
            sequences = find_sequences(col)
            if sequences[0][0] == 0:
                if idx == 0 and len(sequences) == 1 and sequences[0][1] == N - 1:
                    return operations
                continue
            move_sequence(idx, (idx + 1) % len(columns))
            operations += 1
    
    return operations

# Exemplu de utilizare
N = 6
cards = [5, 4, 3, 2, 1, 6]
print("Numărul minim de operații:", min_operations_to_sort_cards(N, cards))
</syntaxhighlight>