Problema 1: Conteo de Elementos Únicos en un Conjunto

Dada la limitación del conjunto de datos (52 elementos en una baraja estándar), el desafío principal reside en la correcta deduplicación y conteo de los elementos ingresados. Para optimizar la búsqueda y asegurar que cada carta sea contabilizada una sola vez, una estructura de datos basada en conjuntos (set) o tablas de dispersión (hash map) es ideal.

En esta implementación, utilizamos std::set para almacenar las cadenas de texto representativas de cada carta. Al final, la diferencia entre el tamaño total de la baraja (52) y el tamaño del conjunto nos proporciona la cantidad de cartas faltantes.

#include <iostream>
#include <set>
#include <string>

using namespace std;

int main() {
    int n;
    if (!(cin >> n)) return 0;
    
    set<string> baraja;
    for (int i = 0; i < n; ++i) {
        string carta;
        cin >> carta;
        baraja.insert(carta);
    }
    
    cout << 52 - baraja.size() << endl;
    return 0;
}

Problmea 2: Simulación de Trayectoria en Rejilla 2D

Este problema requiere una simulación precisa de un agente moviéndose en un mapa con obstáculos. El agente sigue una dirección específica y, en caso de encontrar un obstáculo o el límite del mapa, debe rotar 90 grados en sentido horario.

Para gestionar el movimiento, definimos arreglos de desplazamiento para las coordenadas (x, y) según la dirección actual (0: derecha, 1: abajo, 2: izquierda, 3: arriba). Es fundamental utilizar una matriz booleana para registrar las celdas visitadas y evitar duplicados en el conteo final.

#include <iostream>
#include <vector>
#include <string>

using namespace std;

void ejecutar_simulacion() {
    int n, m, k;
    int r, c, d;
    cin >> n >> m >> k;
    cin >> r >> c >> d;
    
    // Ajuste a índice base 0
    r--; c--;

    vector<string> mapa(n);
    for (int i = 0; i < n; ++i) cin >> mapa[i];

    vector<vector<bool>> visitado(n, vector<bool>(m, false));
    int dr[] = {0, 1, 0, -1};
    int dc[] = {1, 0, -1, 0};

    visitado[r][c] = true;
    long long celdas_unicas = 1;

    for (int paso = 0; paso < k; ++paso) {
        int nr = r + dr[d];
        int nc = c + dc[d];

        if (nr >= 0 && nr < n && nc >= 0 && nc < m && mapa[nr][nc] == '.') {
            r = nr;
            c = nc;
            if (!visitado[r][c]) {
                visitado[r][c] = true;
                celdas_unicas++;
            }
        } else {
            d = (d + 1) % 4;
        }
    }
    cout << celdas_unicas << "\n";
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        ejecutar_simulacion();
    }
    return 0;
}

Problema 3: Optimización de Dígitos con Cerillas (Matchsticks)

El objetivo es construir el número más pequeño posible utilizando exactamente n cerillas. La estrategia óptima para minimizar un número es reducir su cantidad de dígitos y, en segundo lugar, minimizar el valor de los dígitos más significativos.

Dado que el dígito '8' utiliza la mayor cantidad de ceirllas (7), es el bloque de construcción principal para números grandes. Analizando los residuos de n al dividirlo por 7, podemos determinar el prefijo necesario para que el número sea el mínimo posible antes de rellenar el resto con ochos.

#include <iostream>
#include <string>

using namespace std;

void resolver_cerillas() {
    int n;
    cin >> n;
    
    // Casos base y valores especiales para n pequeño
    int tabla_minima[] = {-1, -1, 1, 7, 4, 2, 6, 8, 10, 18, 22, 20, 28, 68, 88};
    
    if (n <= 14) {
        cout << tabla_minima[n] << "\n";
    } else {
        // Prefijos basados en n % 7 para garantizar el mínimo valor
        string prefijos[] = {"888", "108", "188", "200", "208", "288", "688"};
        cout << prefijos[n % 7];
        
        int ochos_adicionales = (n - 1) / 7 - 2;
        for (int i = 0; i < ochos_adicionales; ++i) {
            cout << "8";
        }
        cout << "\n";
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        resolver_cerillas();
    }
    return 0;
}