Реши на с++

Вот короткое и надёжное решение. Идея: у команды из 3 человек возможны только такие наборы медалей (0/1/2 на участника) и, соответственно, суммы сил:

• 0: (3,0,0)
• 1: (2,1,0)
• 2: (2,0,1) или (1,2,0)
• 3: (1,1,1) или (0,3,0)
• 4: (1,0,2) или (0,2,1)
• 5: (0,1,2)
• 6: (0,0,3)

Для каждой суммы отдельно считаем максимум возможных команд (можно смешивать варианты с одной и той же суммой), затем берём максимум по всем суммам. Случаи 0,1,5,6 считаются напрямую; для 2,3,4 — небольшая «переборка» по 2–3 кандидатам, чтобы учесть целочисленные ограничения.

cpp
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;

static inline int64 clamp_to(int64 x, int64 lo, int64 hi){
    if (x < lo) return lo;
    if (x > hi) return hi;
    return x;
}

// max команд с суммой 2: комбинации (2,0,1) и (1,2,0)
int64 sum2(int64 c0, int64 c1, int64 c2){
    int64 A = c1 / 2;                    // максимум (1,2,0) по единичкам
    int64 Xmax = min(c2, c0 / 2);        // максимум (2,0,1) по двойкам и нулям

    vector<int64> cand;
    cand.push_back(0);
    cand.push_back(Xmax);
    // граница, где ограничение по нулям сменяет ограничение по единичкам
    int64 x0 = (c0 - A) / 2;
    cand.push_back(clamp_to(x0, 0, Xmax));
    cand.push_back(clamp_to(x0 + 1, 0, Xmax));

    int64 best = 0;
    for (int64 x : cand) {
        int64 y = min(A, c0 - 2*x);      // по нулям и единичкам
        if (y < 0) y = 0;
        best = max(best, x + y);
    }
    return best;
}

// max команд с суммой 3: (1,1,1) и (0,3,0)
int64 sum3(int64 c0, int64 c1, int64 c2){
    int64 Xmax = min({c0, c1, c2}); // столько трёхцветных команд (1,1,1) максимально по ресурсам
    int64 best = 0;
    // Достаточно проверить Xmax и пару ближайших значений из-за деления на 3
    for (int d = 0; d <= 2; ++d) {
        int64 x = (Xmax >= d) ? (Xmax - d) : 0;
        int64 ones_left = c1 - x;
        if (ones_left < 0) continue;
        int64 y = ones_left / 3; // (0,3,0)
        best = max(best, x + y);
    }
    return best;
}

// max команд с суммой 4: (1,0,2) и (0,2,1) — симметрия к сумме 2 (ноль <-> двойка)
int64 sum4(int64 c0, int64 c1, int64 c2){
    int64 A = c1 / 2;                    // максимум (0,2,1) по единичкам
    int64 Xmax = min(c0, c2 / 2);        // максимум (1,0,2) по нулям и двойкам

    vector<int64> cand;
    cand.push_back(0);
    cand.push_back(Xmax);
    int64 x0 = (c2 - A) / 2;
    cand.push_back(clamp_to(x0, 0, Xmax));
    cand.push_back(clamp_to(x0 + 1, 0, Xmax));

    int64 best = 0;
    for (int64 x : cand) {
        int64 y = min(A, c2 - 2*x);      // по двойкам и единичкам
        if (y < 0) y = 0;
        best = max(best, x + y);
    }
    return best;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int64 c0, c1, c2;
    if (!(cin >> c0 >> c1 >> c2)) return 0;

    int64 ans = 0;
    // суммы 0,1,5,6 — прямые формулы
    ans = max(ans, c0 / 3);                               // sum=0: (3,0,0)
    ans = max(ans, min(c0 / 2, c1));                      // sum=1: (2,1,0)
    ans = max(ans, sum2(c0, c1, c2));                     // sum=2
    ans = max(ans, sum3(c0, c1, c2));                     // sum=3
    ans = max(ans, sum4(c0, c1, c2));                     // sum=4
    ans = max(ans, min(c1, c2 / 2));                      // sum=5: (0,1,2)
    ans = max(ans, c2 / 3);                               // sum=6: (0,0,3)

    cout << ans << "\n";
    return 0;
}

Алгоритм работает за O(1) и корректен для любых 0 ≤ c0, c1, c2 ≤ 10^9.