P2021: Razonamiento inverso Enfoque 1: Asignación de índices (correspondencia valor-índice) usando cola

Código``` #include #include using namespace std; const int LIMITE = 1000010; int num_elementos, asignacion[LIMITE]; queue cola;

int main() { cin >> num_elementos; for(int i = 1; i <= num_elementos; i++) { cola.push(i); } int paso = 1, valor = 0; while(!cola.empty()) { if(paso == 2) { paso = 1; asignacion[cola.front()] = ++valor; cola.pop(); } cola.push(cola.front()); cola.pop(); paso++; } for(int i = 1; i <= num_elementos; i++) { cout << asignacion[i] << ' '; } return 0; }

**Enfoque 2: Inversión del proceso**
Problema original: tomar primera carta al fondo y obtener la siguiente
Solución inversa: añadir mientras se mueve el último elemento al inicio

P3405: Arreglo de mapas para resolución de colisiones
Conversión de strings a llaves numéricas

Código```
#include <iostream>
#include <map>
using namespace std;
int n_total, resultado = 0;
const int BASE = 100;
string origen, destino;

int main() {
    cin >> n_total;
    map<int, map<int, int>> diccionario;
    
    for(int i = 0; i < n_total; i++) {
        cin >> origen >> destino;
        int hash_origen = origen[0] * BASE + origen[1];
        int hash_destino = destino[0] * BASE + destino[1];
        
        if(hash_origen != hash_destino) {
            resultado += diccionario[hash_destino][hash_origen];
            diccionario[hash_origen][hash_destino]++;
        }
    }
    cout << resultado << endl;
    return 0;
}

Alternativa: Vector de estados con pares válidos

P8889: Métodos de coincidencia

• Hashing
• Búsqueda binaria
• Punteros paralelos

P7935: Principio de la distribución + ordenamiento topológico Identificación de elemantos faltantes mediante reducción de contadores

Código``` #include #include using namespace std; const int MAX_N = 100010; int n_valores, resultado; int secuenciaA[MAX_N], indexA[MAX_N], contB[MAX_N], contC[MAX_N], borrado[MAX_N]; queue lista_pendientes;

int main() { cin >> n_valores; for(int i = 1; i <= n_valores; i++) { cin >> secuenciaA[i]; indexA[secuenciaA[i]] = i; } // Inicialización contadores para secuencias B y C for(int i = 1; i <= n_valores; i++) { int tmp; cin >> tmp; contB[tmp]++; } for(int i = 1; i <= n_valores; i++) { int tmp; cin >> tmp; contC[tmp]++; }

// Procesamiento inicial
for(int i = 1; i <= n_valores; i++) {
    if(!contB[i] || !contC[i]) {
        lista_pendientes.push(i);
        while(!lista_pendientes.empty()) {
            int actual = lista_pendientes.front();
            lista_pendientes.pop();
            int pos = indexA[actual];
            
            if(borrado[pos]) continue;
            borrado[pos] = 1;
            resultado++;
            
            if(--contB[secuenciaB[pos]] == 0) lista_pendientes.push(secuenciaB[pos]);
            if(--contC[secuenciaC[pos]] == 0) lista_pendientes.push(secuenciaC[pos]);
        }
    }
}
cout << resultado << endl;
return 0;

}

P5250: Mapas para búsqueda de vecinos cercanos
Implementación con nodo temporal:

Pseudocódigo clave

conjunto[valor] = 1; // Marcador temporal iterador = buscar(valor); if (primer elemento) -> remover apuntado else if (último elemanto) -> remover anterior else comparar distancias -> eliminar según proximidad

P1090: Árbol de Huffman
Mínimo consumo mediante cola de prioridad

P6704: Pilas monótonas
Inicialización con cero para garantizar operaciones

P1160: Listas enlazadas
Manipulación directa de nodos