ABCDEFjiangly的学习代码&& 菜鸡何时可以上紫（入门x）

大佬太强了，我何时可以上紫。。。。。。。。。。。

div2C

我以为是要模拟，但是jangly On（查看了）

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t;
    std::cin >> t;
    while (t--) {
        int n;
        std::cin >> n;
        std::vector<int> p(n);
        for (int i = 0; i < n; ++i) {
            std::cin >> p[i];
            --p[i];
        }
        int l = -1, m = n;
        bool ok = true;
        for (int i = 0; i < n; ++i) {
            if (i < n - m && p[i] != p[l] + i - l) {
                ok = false;
                break;
            } else {
                l = i;
                m = p[i];
            }
        }
        if (ok) {
            std::cout << "Yes\n";
        } else {
            std::cout << "No\n";
        }
    }
    return 0;
}

div2D

放一个dfs写法，其实是DAG
他的dp有点长，还是看自己的吧。

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
std::string S[] = {"1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011"};
int a[10];
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    for (int i = 0; i < 10; ++i)
        for (int j = 0; j < 7; ++j)
            a[i] = 2 * a[i] + S[i][j] - '0';
    int n, k;
    std::cin >> n >> k;
    std::vector<int> s(n);
    std::vector<std::vector<bool>> able(n, std::vector<bool>(8));
    std::vector<std::vector<bool>> suf(n + 1, std::vector<bool>(7 * n + 1));
    for (int i = 0; i < n; ++i) {
        int x = 0;
        for (int j = 0; j < 7; ++j) {
            char c;
            std::cin >> c;
            x = 2 * x + c - '0';
        }
        s[i] = x;
        for (int j = 0; j < 10; ++j) {
            if ((a[j] & x) == x) {
                int cnt = __builtin_popcount(a[j] ^ x);
                able[i][cnt] = true;
            }
        }
    }
    suf[n][0] = true;
    for (int i = n - 1; i >= 0; --i)
        for (int j = 0; j <= 7 * n; ++j)
            if (suf[i + 1][j])
                for (int k = 0; k <= 7; ++k)
                    if (able[i][k])
                        suf[i][j + k] = true;
    if (!suf[0][k]) {
        std::cout << -1 << "\n";
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 9; ; --j) {
            if ((a[j] & s[i]) == s[i]) {
                int cnt = __builtin_popcount(a[j] ^ s[i]);
                if (k >= cnt && suf[i + 1][k - cnt]) {
                    std::cout << j;
                    k -= cnt;
                    break;
                }
            }
        }
    }
    std::cout << "\n";
    return 0;
}

div2E

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
#include <deque>
#include <tuple>
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n, m;
    std::cin >> n >> m;
    std::vector<int> d(m);
    for (int i = 0; i < m; ++i)
        std::cin >> d[i];
    std::sort(d.begin(), d.end());
    int g, r;
    std::cin >> g >> r;
    std::vector<std::vector<int>> dp(m, std::vector<int>(g + 1, -1));
    std::deque<std::tuple<int, int, int>> que;
    que.emplace_back(0, 0, 0);
    while (!que.empty()) {
        auto [u, t, f] = que.front();
        que.pop_front();
        if (dp[u][t] != -1)
            continue;
        dp[u][t] = f;
        if (t == g)
            que.emplace_back(u, 0, f + 1);
        if (u != 0 && t + d[u] - d[u - 1] <= g)
            que.emplace_front(u - 1, t + d[u] - d[u - 1], f);
        if (u != m - 1 && t + d[u + 1] - d[u] <= g)
            que.emplace_front(u + 1, t + d[u + 1] - d[u], f);
    }
    long long ans = -1;
    for (int i = 0; i <= g; ++i)
        if (dp[m - 1][i] != -1 && (ans == -1 || ans > 1ll * (g + r) * dp[m - 1][i] + i))
            ans = 1ll * (g + r) * dp[m - 1][i] + i;
    std::cout << ans << "\n";
    return 0;
}

DIV2G

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
#include <deque>
#include <tuple>
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n;
    std::cin >> n;
    std::vector<std::vector<int>> e(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        std::cin >> u >> v;
        --u;
        --v;
        e[u].push_back(v);
        e[v].push_back(u);
    }
    int ans = 0;
    for (int i = 0; i < n; ++i)
        ans = std::max(ans, int(e[i].size()));
    std::vector<std::pair<int, int>> steps;
    std::function<void(int, int, int)> dfs = [&](int u, int t, int p) {
        steps.emplace_back(u, t);
        int cur = t, rest = e[u].size() - (p != -1);
        for (auto v : e[u]) {
            if (v == p)
                continue;
            if (cur == ans) {
                cur = t - 1 - rest;
                steps.emplace_back(u, cur);
            }
            dfs(v, cur + 1, u);
            --rest;
            ++cur;
            steps.emplace_back(u, cur);
        }
        if (u == 0)
            return;
        if (cur != t - 1)
            steps.emplace_back(u, t - 1);
    };
    dfs(0, 0, -1);
    std::cout << steps.size() << "\n";
    for (auto [u, t] : steps)
        std::cout << u + 1 << " " << t << "\n";
    return 0;
}