Approche : Simulation directe de la logique.

Code AC :

void solution() {
    string chaine;
    int compteur = 0;
    cin >> chaine;
    for (char c : chaine) {
        if (c == 'i' || c == 'j') {
            compteur++;
        }
    }
    cout << compteur << endl;
}

Problème B - Joueur de Musique

Approche : Simulation des opérations d'achat, de vente et de verrouillage.

Code AC :

void solution() {
    int nombre;
    bool morceau;
    cin >> nombre;
    for (int i = 1; i <= nombre; i++) {
        string operation;
        cin >> operation;
        if (operation == "1") {
            nombre++;
        } else if (operation == "2") {
            if (nombre >= 1) {
                nombre--;
            }
        } else {
            morceau = !morceau;
        }
        if (nombre >= 3 && morceau) {
            cout << "Oui" << endl;
        } else {
            cout << "Non" << endl;
        }
    }
}

Problème C - Revue Par Pairs

Approche : Calcul de combinaisons basé sur le nombre de reviewers disponibles.

Code AC :

void solution() {
    int personnes, domaines;
    cin >> personnes >> domaines;
    map<int int=""> capacite;
    for (int i = 1; i <= personnes; i++) {
        capacite[i] = personnes - 1;
    }
    for (int i = 1; i <= domaines; i++) {
        int a, b;
        cin >> a >> b;
        capacite[a]--;
        capacite[b]--;
    }
    for (int i = 1; i <= personnes; i++) {
        int x = capacite[i];
        if (x < 3) {
            cout << 0 << " ";
        } else {
            cout << (x * (x - 1) * (x - 2)) / 6 << " ";
        }
    }
    cout << endl;
}</int>

Problème D - Echange et Sommes de Plages

Approche : Utilisation de sommes cumulatives pour gérer les modifications rapides.

Code AC :

void solution() {
    vector<long long=""> prefix;
    vector<int> tab;
    cin >> tab.size() + 1 >> tab[0];
    prefix.reserve(tab.size() + 1);
    prefix[0] = 0;
    for (int i = 1; i <= tab.size(); i++) {
        prefix[i] = prefix[i - 1] + tab[i];
    }
    int operations;
    cin >> operations;
    while (operations--) {
        string action;
        cin >> action;
        if (action == "mise_a_jour") {
            int indice;
            cin >> indice;
            prefix[indice] = prefix[indice] - tab[indice] + tab[indice + 1];
            swap(tab[indice], tab[indice + 1]);
        } else {
            int debut, fin;
            cin >> debut >> fin;
            cout << prefix(fin) - prefix(debut - 1) << endl;
        }
    }
}</int></long>

Problème E - Laser de Takahashi

Approche : Tri par comparateur basé sur la polarité et le rangement.

Code AC :

struct Point {
    int x;
    int y;
};

bool comparateur(const Point& a, const Point& b) {
    int hauteurA = (a.y < 0) || ((a.y == 0) && (a.x > 0));
    int hauteurB = (b.y < 0) || ((b.y == 0) && (b.x > 0));
    if (hauteurA != hauteurB) {
        return hauteurA > hauteurB;
    } else {
        return (a.y * b.x) > (b.y * a.x);
    }
}

void solution() {
    int nb_points, requetes;
    cin >> nb_points >> requetes;
    vector<point> points(nb_points + 1);
    for (int i = 1; i <= nb_points; i++) {
        cin >> points[i].x >> points[i].y;
    }
    vector<int> indice(nb_points + 1);
    iota(indice.begin(), indice.end(), 0);
    sort(indice.begin() + 1, indice.end(), [&points](int i, int j) {
        return comparateur(points[i], points[j]);
    });
    vector<int> rev(nb_points + 1);
    for (int i = 1; i <= nb_points; i++) {
        rev[indice[i]] = i;
    }
    vector<int> gauche(nb_points + 1), droite(nb_points + 1);
    gauche[1] = 1;
    for (int i = 2; i <= nb_points; i++) {
        if (comparateur(points[indice[i - 1]], points[indice[i]])) {
            gauche[i] = i;
        } else {
            gauche[i] = gauche[i - 1];
        }
    }
    droite[nb_points] = nb_points;
    for (int i = nb_points - 1; i >= 1; i--) {
        if (comparateur(points[indice[i]], points[indice[i + 1]])) {
            droite[i] = i;
        } else {
            droite[i] = droite[i + 1];
        }
    }
    while (requetes--) {
        int a, b;
        cin >> a >> b;
        int i = rev[a];
        int j = rev[b];
        if (gauche[j] <= i && i <= droite[j]) {
            cout << j - i + 1 << endl;
        } else {
            cout << nb_points - i + j + 1 << endl;
        }
    }
}</int></int></int></point>

Problème F - Séparation Diagonale 2

Approche : Utilisation de la programmation dynamique pour minimiser les opérations tout en respectant les contraintes de déplacement.

Code AC :

struct Etat {
    int ligne;
    int blancs;
    int cout;
};

void solution() {
    vector<vector>> dp(201, vector<int>(201, INT_MAX));
    for (int j = 1; j <= 200; j++) {
        dp[1][j] = j;
    }
    for (int i = 2; i <= 200; i++) {
        int min_prev = INT_MAX;
        for (int j = 200; j >= 1; j--) {
            min_prev = min(min_prev, dp[i - 1][j]);
            dp[i][j] = min_prev + j - prefix[i][j] + suffix[i][j + 1];
        }
    }
    cout << dp[n][m] << endl;
}</int></vector>