Codeforces Round #800 (Div. 2)

div2 唯唯诺诺

A

0101 输出 大胆猜结论

#define endl '\n';
int t;
int main() {
    cin >> t;
    while (t --) {
        int a, b;
        cin >> a >> b;
        while (a || b) {
            if (a) cout << '0', a --;
            if (b) cout << '1', b --;
        }
        cout << endl;
    }
    return 0;
}

B

每次有一对不相同的元素 那么，前面所有值都可以在这个位置再被算一次

#define int long long
#define endl '\n';
int t;
int f[N][2];
signed main() {
    cin >> t;
    while (t --) {
        int n;
        cin >> n;
        string s;
        cin >> s;
        int cnt = 1, ans = 0;
        for (int i = 1; i < n; i ++) {
            if (s[i - 1] != s[i]) {
                ans += i;
            }
        }
        cout << ans + n << endl;
    }
    return 0;
}

C

模拟去判定 定义一个cnt 意为 当前位置之和应该回来的值， 比如当前位置cnt为-2，意思是从左边至少还要回来两次。 然后去判定一下cnt是否大于0

#define int long long
#define endl '\n';
int t, g[N];
signed main() {
    cin >> t;
    while (t --) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i ++) cin >> g[i];
        int cnt = -g[1], f = 1;
        for (int i = 2; i <= n && f; i ++) {
            if (!cnt && g[i]) f = 0;
            if (cnt > 0) f = 0;
            cnt -= g[i];
        }
        if (cnt != 0) f = 0;
        cout << (f ? "YES" : "NO") << endl;
    }
    return 0;
}

D

对于每一个节点来说， 如果他的子节点和的值小于他的 l 值， 那么在这个节点，需要再多操作一次
否则当前子节点的和的值累加上去时应该不超过当前节点的值

#define l first
#define r second
#define int long long
#define endl '\n';
int t;
int g[N], s[N];
pair<int, int> d[N];
signed main() {
    cin >> t;
    while (t --) {
        int n;
        cin >> n;
        for (int i = 2; i <= n; i ++) cin >> g[i];
        for (int i = 1; i <= n; i ++) cin >> d[i].l >> d[i].r, s[i] = 0;
        int ans = 0;
        for (int i = n; i > 0; i --) {
            if (s[i] < d[i].l) ans ++, s[i] = d[i].r;
            else s[i] = min(s[i], d[i].r);
            if (g[i]) s[g[i]] += s[i];
        }
        cout << ans << endl;
    }
    return 0;
}

E

最短路 从前往后走是不确定是， 但是从后往前走的路，是确定的。反向建图 去找最小值
从 u 到 v 的路上， dist[v] = min(dist[v], dist[u] + w); w就是需要 删除的边的次数 + 边权 1
对于从后往前找时， 每次找的dist 一定是最小的dist，那么对于v点到u点来说
要想一定走到这个点 那么需要删去大于这个dist的所有边。换句话说，从u到v的路上，每求一个dist之和，就删去一个入度，来保持还有g[v]个dist 大于这个dist

#define l first
#define r second
#define int long long
#define endl '\n';
int t;
int g[N], d[N], v[N], x, y;
vector<int> ve[N];
signed main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) 
        ve[i].clear(), g[i] = 0, d[i] = 0x3f3f3f3f, v[i] = 0;
    while (m --) {
        cin >> x >> y;
        ve[y].push_back(x);
        g[x] ++;
    }
    priority_queue<pair<int, int>, 
    vector<pair<int, int>>, greater<pair<int, int>>> que;
    d[n] = 0;
    que.push({0, n});
    while (que.size()) {
        auto [x, y] = que.top(); que.pop();
        if (v[y]) continue; v[y] = 1;
        for (auto v : ve[y]) {
            int w = d[y] + g[v];
            if (d[v] > w) {
                d[v] = w;
                que.push({w, v});
            }
            g[v] --;
        }
    }
    cout << d[1] << endl;
    return 0;
}