Excellent round

Good round

Average round

Bad round

Awful round

#include<bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, C;
        cin >> n >> C;
        int ans = 0;
        vector<int> a(n), b(n);
        for (int i = 0; i < n; ++i) cin >> a[i];
        for (int i = 0; i < n; ++i) cin >> b[i];
        bool needReorder = false;
        for (int i = 0; i < n; ++i) {
            if (a[i] < b[i]) needReorder = true;
            ans += a[i];
            ans -= b[i];
        }
        if (needReorder) {
            needReorder = false;
            ans += C;
            sort(a.begin(), a.end());
            sort(b.begin(), b.end());
            for (int i = 0; i < n; ++i) {
                if (a[i] < b[i]) {
                    needReorder = true;
                }
            }
        }
        if (needReorder) cout << "-1\n";
        else cout << ans << "\n";
    }
}

Excellent problem

Good problem

Average problem

Bad problem

Awful problem

#include <bits/stdc++.h>

using namespace std;


void solve() {
    int n;
    cin >> n;
    long long an = 0;
    for (int b = 1; b <= n; b++) {
        an += 1ll * (n / b) * (n / b);
    }
    cout << an << '\n';
}

signed main() {
    signed t_ = 1;
    cin >> t_;
    while (t_--) {
        solve();
    }
}

Excellent problem

Good problem

Average problem

Bad problem

Awful problem

#include <bits/stdc++.h>

using namespace std;

const int maxn = 2e5;
vector<int> g[maxn];
int depth[maxn], dp[maxn];
long long ans[maxn];

void dfs(int v, int p = -1) {
    ans[v] = 0;
    dp[v] = depth[v];
    int m1 = depth[v], m2 = depth[v];
    for (auto u : g[v]) {
        if (u != p) {
            depth[u] = depth[v] + 1;
            dfs(u, v);
            dp[v] = max(dp[v], dp[u]);
            ans[v] += ans[u];
            if (dp[u] >= m1) {
                m2 = m1;
                m1 = dp[u];
            }  else if (dp[u] >= m2) {
                m2 = dp[u];
            }
        }
    }
    ans[v] += m2 - depth[v] + 1;
}

void solve() {
    int n;
    cin >> n;
    for (int i = 1; i < n; ++i) {
        int p;
        cin >> p;
        g[p - 1].push_back(i);
    }
    dfs(0);
    cout << ans[0] << '\n';
    for (int i = 0; i < n; ++i) {
        g[i].clear();
    }
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(0);

    int t = 1;
    cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}

Excellent problem

Good problem

Average problem

Bad problem

Awful problem

#include <bits/stdc++.h>

using namespace std;

const int maxn = 1e6 + 7;

int m[maxn], A[maxn], prime[maxn], nxt[maxn];

int main() {
    for (int p = 2; p < maxn; ++p) {
        if (prime[p] == 0) {
            for (int x = p; x < maxn; x += p) {
                if (prime[x] == 0) prime[x] = p;
            }
        }
        if (prime[p / prime[p]] == prime[p]) nxt[p] = nxt[p / prime[p]];
        else nxt[p] = p / prime[p];
        m[p] = m[nxt[p]] + 1;
        A[p] = A[p / prime[p]] + 1;
    }
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        cout << m[n] + A[n] - 1 << "\n";
    }
    return 0;
}

Excellent problem

Good problem

Average problem

Bad problem

Awful problem

#include <bits/stdc++.h>

using namespace std;

void solve() {
    int n;
    string s;
    cin >> n >> s;
    vector<vector<int>> dp(n + 1, vector<int> (n + 1, 1e9));
    dp[0][0] = 0; 
    for (int i = 0; i < n; ++i) {
        vector<vector<int>> ndp(n + 1, vector<int> (n + 1, 1e9));
        for (int cnt_f = 0; cnt_f <= i; ++cnt_f) {
            for (int cur_s = 0; cur_s <= i; ++cur_s) {
                if (s[i] != 'T') {
                    ndp[cnt_f + 1][cur_s + 1] = min(ndp[cnt_f + 1][cur_s + 1], max(dp[cnt_f][cur_s], cur_s + 1));
                }
                if (s[i] != 'F') {
                    ndp[cnt_f][max(0, cur_s - 1)] = min(ndp[cnt_f][max(0, cur_s - 1)], dp[cnt_f][cur_s]);
                }
            }
        }
        swap(dp, ndp);
    }
    int rs = 0;
    for (int i = 0; i <= n; ++i) {
        for (int j = 0; j <= n; ++j) {
            rs = max(rs, i - dp[i][j]);
        }
    }
    cout << rs << '\n';
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(0);

    int t;
    cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}

Excellent problem

Good problem

Average problem

Bad problem

Awful problem

#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int maxn = 2e6 + 1;
const ll mod = 1e9 + 7;

struct md {
    ll x;

    md(ll p) {
        x = p % mod;
    }

    md operator+(md other) {
        int p = x + other.x;
        if (p >= mod) {
            p -= mod;
        }
        if (p >= mod) {
            p %= mod;
        }
        return {p};
    }

    md operator-(md other) {
        int p = x - other.x;
        if (p < 0) {
            p += mod;
        }
        if (p < 0) {
            p = (p % mod + mod) % mod;
        }
        return {p};
    }

    md operator*(md other) {
        return {1ll * x * other.x % mod};
    }

    md operator^(int x) {
        if (x == 0) {
            return {1};
        }
        if (x % 2 == 0) {
            md p = *this ^ (x / 2);
            return {p * p};
        }
        return *this * (*this ^ (x - 1));
    }

    md operator/(md p) {
        return *this * (p ^ (mod - 2));
    }
};

vector<md> fact(1, md(1));
vector<md> rfact = fact;

void prec() {
    fact.resize(maxn, md(1));
    rfact = fact;
    for (int i = 1; i < fact.size(); ++i) {
        fact[i] = fact[i - 1] * md(i);
    }
    rfact[maxn - 1] = md(1) / fact[maxn - 1];
    for (int i = maxn - 2; i >= 0; --i) {
        rfact[i] = rfact[i + 1] * (i + 1);
    }
}

md c(int n, int k) {
    if (n < 0 || k < 0 || k > n)return md(1);
    return fact[n] * rfact[k] * rfact[n - k];
}

md catalan(int n) {
    if(n == 0){
        return 1;
    }
    return c(2 * n, n) - c(2 * n, n - 1);
}

void solve() {
    ll n, k;
    cin >> n >> k;
    k++;
    vector<ll> bits(61);
    for (int i = 0; i < 61; ++i) {
        bits[i] = k >> i & 1;
    }
    for (ll x = 60; x >= n; x--) {
        bits[x - 1] += 2 * bits[x];
        bits[x] = 0;
    }
    int sm = 0;
    for (int i = 0; i < 61; ++i) {
        sm += bits[i];
    }
    md an = catalan(sm - 1) * fact[sm];
    for (int i = 0; i < 61; ++i) {
        if (bits[i] >= 2) {
            an = an * rfact[bits[i]];
        }
    }
    cout << an.x << '\n';
}

signed main() {
    prec();
    signed t_ = 1;
    cin >> t_;
    while (t_--) {
        solve();
    }
}

Excellent problem

Good problem

Average problem

Bad problem

Awful problem