A. Tres Cuatro

Simulación

Implementación de código``` n = int(input()) a = list(map(int, input().split())) resultado = any(a[i] == a[i+1] == a[i+2] for i in range(n-2)) print('Sí' if resultado else 'No')

B. Pila de Cartas
------------

Simulación

Implementación de código```
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;

int main() {
    int q;
    cin >> q;
    
    vector<int> st(100, 0);
    rep(qi, q) {
        int tipo;
        cin >> tipo;
        if (tipo == 1) {
            int x;
            cin >> x;
            st.push_back(x);
        }
        else {
            int res = st.back();
            st.pop_back();
            cout << res << '\n';
        }
    }
    
    return 0;
}

C. Comprar Bolas

Primero ordenar descendentemente los valores de \(B\) y \(W\) El resultado es el máximo entre la suma acumulada de \(B\) y la máxima suma acumulada de \(W\)

Implementación de código``` #include <bits/stdc++.h> #define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std; using ll = long long;

int main() { int n, m; cin >> n >> m;

vector<int> b(n), w(m);
rep(i, n) cin >> b[i];
rep(i, m) cin >> w[i];

ranges::sort(b, greater<>());
ranges::sort(w, greater<>());

ll res = 0;
ll sum_b = 0;
ll max_w = 0, sum_w = 0;
rep(i, n) {
    sum_b += b[i];
    if (i < m) sum_w += w[i];
    max_w = max(max_w, sum_w);
    res = max(res, sum_b + max_w);
}

cout << res << '\n';

return 0;

}

D. Camino con XOR Mínimo
-------------------

Búsqueda en profundidad

Implementación de código```
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
using ll = long long;

int main() {
    int n, m;
    cin >> n >> m;
    
    vector<vector<pair<int, ll>>> grafo(n);
    rep(i, m) {
        int a, b; ll w;
        cin >> a >> b >> w;
        --a; --b;
        grafo[a].emplace_back(b, w);
        grafo[b].emplace_back(a, w);
    }
    
    ll min_xor = 1ll<<60;
    auto dfs = [&](auto& f, int v, int used=0, ll x=0) -> void {
        used |= 1<<v;
        if (v == n-1) {
            min_xor = min(min_xor, x);
            return;
        }
        for (auto [u, w] : grafo[v]) {
            if (used>>u&1) continue;
            f(f, u, used, x^w);
        }
    };
    dfs(dfs, 0);
    
    cout << min_xor << '\n';
    
    return 0;
}

E. Mínimo de Suma Restringida

Procesamiento por bits Cada componente conectada se maneja por separado Para cada componente hay dos maneras de asignar números, y eelgimos la que tenga menos unos

Implementación de código``` #include <bits/stdc++.h> #define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std; using P = pair<int, int>;

int main() { int n, m; cin >> n >> m;

vector<vector<P>> grafo(n);
rep(i, m) {
    int a, b, c;
    cin >> a >> b >> c;
    --a; --b;
    grafo[a].emplace_back(b, c);
    grafo[b].emplace_back(a, c);
}

bool valid = true;
vector<int> resultado(n);
rep(k, 30) {
    vector<int> color(n, -1);
    rep(sv, n) if (color[sv] == -1) {
        vector<vector<int>> grupos(2);
        auto dfs = [&](auto& f, int v, int c=0) -> void {
            if (color[v] != -1) {
                if (color[v] != c) valid = false;
                return;
            }
            color[v] = c;
            grupos[c].push_back(v);
            for (auto [u, z] : grafo[v]) {
                f(f, u, c^(z>>k&1));
            }
        };
        dfs(dfs, sv);
        if (grupos[0].size() < grupos[1].size()) swap(grupos[0], grupos[1]);
        for (int v : grupos[1]) resultado[v] |= 1<<k;
    }
}
if (!valid) {
    puts("-1");
    return 0;
}

rep(i, n) cout << resultado[i] << " \n"[i == n-1];

return 0;

}

F. Inversiones Rotadas
---------------------

Considerar la contribución de cada par \\((i, j)\\) como un par inverso
Cuando el valor en la posición \\(i\\) cambia de \\(M-1\\) a \\(0\\), aumentan \\(i-1\\) pares inversos a la izquierda y disminuyen \\(n-i\\) a la derecha

Implementación de código```
#include <bits/stdc++.h>
#include <atcoder/all>
using namespace atcoder;
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
using ll = long long;
using P = pair<int, int>;

int main() {
    int n, m;
    cin >> n >> m;
    
    vector<P> datos;
    rep(i, n) {
        int a;
        cin >> a;
        datos.emplace_back(a, i);
    }
    
    ranges::sort(datos);
    
    ll actual = 0;
    fenwick_tree<int> arbol(n);
    rep(i, n) {
        int j = datos[i].second;
        actual += arbol.sum(j, n);
        arbol.add(j, 1);
    }
    
    for (int x = m-1; x >= 0; --x) {
        cout << actual << '\n';
        while (datos.size() and datos.back().first == x) {
            int j = datos.back().second;
            datos.pop_back();
            actual += j; actual -= n-1-j;
        }
    }
    
    return 0;
}

G. Invertir Filas o Columnas

Problema original: CF662C

No entiendo por qué la solución oficial no usa convolución XOR