Codeforces Round #800 (Div. 2) A - D

‎先简单评价一下这场，前两题送分，但是第二题需要少量的思维。 第三题有点需要思考，第四题较难。 五六两题就比较难了‎。

从中可以看出第四题是一个分水岭，总体比赛码量很少，更多的是思维性。

下面直接进入正题！

---

A. Creep

题意：给定0和1的个数，需要你构造一个01串，最小化串中前缀01数量的绝对值之差。

分析：为了让绝对值之差最小，贪心地思考，在0和1充足的条件下让0和1交替摆放，那么每一个前缀01绝对值之差一定是最小的，多出来的一部分(可能是0或者1)放在末尾就行了，因为不管怎么放都不能使答案更小。题目很长，但其实就是幌子。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 1e5, INF = 1e9;
int n, m;

void solve()
{
    cin >> n >> m;
    int t = min(n, m);
    n -= t, m -= t;
    for(int i = 1 ; i <= t ; i ++ )  cout << "01";
    
    if(n) 
        for(int i = 1 ; i <= n ; i ++ ) cout << "0";
    else 
        for(int i = 1 ; i <= m ; i ++ ) cout << "1";
    cout << endl;
}


int main()
{
    int T;
    cin >> T;
    while(T -- ) solve();
    return 0;
}

B. Paranoid String

题意：给定一个01串，你可以进行两种操作

1 . 把 01 替换成1

2 . 把 10 替换成0

假设字符串的长度为m，请你进行吗m - 1次操作把一个字符串变成长度为1的串，则表示这个串符合要求。题目求的是一个长度为n的串中有多少个连续的子串可以满足要求，即[l, r]的子串符合要求的个数。

分析：这种题一眼看到一定是结论题，通过题目中的两次操作我们可以发现，1可以“吃掉”前面的0，0可以吃掉前面的1，我们可以发现判断这个串能不能符合要求的其实只是字符串的最后两个字符。

第一种情况：若该字符串为0000001，那么1可以吃掉任意多个0

第二种情况：如果是0000100001，那么可以先让前面的0把前面的1先消除，也就转化成第一种情况

第三种情况：如果是000000011，那么无论怎么消除，也不能转化成第一种情况，因为倒数第二个1不能被最后一个1吃掉，000001111，若1越来越多也是一样。

因此我们可以得出结论，若末尾的两位不同，则这个串符合要求。假如最后一个串是1，倒数第二个是0，可以先让0吃掉前面所有的1，最终一定会转化成第一种情。我们从左往右扫描，表示以第i个为结尾，与前面的进行比较，如果不同的话表示不管前面取多少个都会产生 i 的贡献，如果s[i] == s[i - 1]，那么s[i]对答案的贡献只有他自己。注意一定要开long long，2e5 * 2e5 会爆int 。i = 1 要特判，因为前面没有元素，贡献为1.

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
#define int long long
const int N = 2e5 + 10;
int n, m;
char s[N];

void solve()
{
    cin >> n;
    cin >> s + 1;
    int res = 0;
    for(int i = 1 ; i <= n ; i ++ )
    {
        if(i == 1)
        {
            res ++ ;
            continue;
        }
        
        if(s[i] != s[i - 1]) res += i;
        else res ++ ;
    }
    cout << res << endl;
    return ;
}


signed main()
{
    int T;
    cin >> T;
    while(T -- ) solve();
    
    return 0;
}

C. Directional Increase （比较有意思）

题意：给你一个长度为n，刚开始全为0的数组，初始位置为1，可以进行两种操作：

1 . 向右移动一格，原来位置上的数字 + 1

2 . 向左移动一个，原来位置上的数字 - 1

再给你一个目标数组，判断能否通过移动，使数组变成目标数组，限定最后完成时终点为1。

分析：首先我们先看两种操作，往右走和往左走，因为我们最终的位置还是在1。先看一个特殊情况，n == 2， 我们要不停的往右走再往左走，最后一定会让1的位置一直++，2的位置一直--。并且p[1] + p[2] == 0 ，不管n是多少，最后增加和减少的数都是守恒的。因此我们可以发现，一个位置想要增加，一定是后面的位置减少作为代价换来的。通过这个性质，我们可以构造一个前缀和数组，它一定是一个单调>=0的数组，因为增加的数在前，减少的数在后。通过刚才的分析我们可以知道增加和减少的数守恒，那么这个前缀和数组最后一定是0为末尾。那么答案就呼之欲出了，想要让这个数组成立，条件就是前缀数组中所有数都>=0，在没有降到0的情况下数字值一定 > 0；若降到0，表示前面已经守恒了，而位置回到了1, 后面必须全为0才行。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#define int long long
const int N = 2e5 + 10, INF = 1e7;
int n, m;
int a[N];

void solve()
{
    cin >> n;
    for(int i = 1 ; i <= n ; i ++ ) cin >> a[i] , a[i] += a[i - 1]; // 前缀和
    if(abs(a[n]) != 0) //守恒, 若不守恒直接return
    {
        puts("NO");
        return ;
    }
    bool flag = false; // 标记表示前缀和数组有没有降到0，如果降到0，后面一定为0
    
    for(int i = 1 ; i <= n ; i ++ )
    {
        if(a[i] == 0)  flag = true;
        if(flag) 
        {
            if(a[i] != 0) 
            {
                puts("NO");
                return ;
            }
        }
        if(a[i] < 0) 
        {
            puts("NO");
            return ;
        }
    }
    puts("YES");
}

signed main()
{
    int T;
    cin >> T;
    while(T -- ) solve();
    return 0;
}

D. Fake Plastic Trees

题意：给你一颗以1为根的树，每一个节点有一个范围[L, R] ，构造一颗树使得每一个节点的权值满足区间。增加权值的方式，选择一个节点，使从根到该节点的路径上加上一段值，这一段值是任意一段>=0的不下降序列。需要你最小化操作数。

分析：题意比较晦涩难懂，当时在考场上一脸懵逼什么垃圾构造题直接不会。建议大家先模拟一下样例，这里我就不分析样例了。

首先这是一道树上构造问题，这题的困难之处在于满足每一个范围。首先考虑递推的顺序，最终答案在根节点上，那么我们一定是从下往上递推。从叶子节点开始递推。然后我们进行思考，什么情况下答案会增加：考虑一个节点u ， 当u的子树向上累加的总和 < L[u]时，说明子节点怎么加都不够u用，u就要自己在给自己加一次。那么如何确定累加的总和呢？累加是一个区间，如何向上累加呢？

这个问题其实只需要考虑一个问题，我们发现只有不够的情况下操作数才需要++，如果足够的话，极限的来说，在u处随便少加一点即可满足，因此最多加多少取决于子节点的最大值的总和 min(add[u], R)，这是最多可以加的数。那么判断条件就非常简单，我们用add数组表示从下往上向父节点累加的值的总和, 在向上递推的过程中判断add[u] 是否 < L[u]就可以了。本体我们用bfs进行解决，因为dfs有点不好理解，而bfs宽搜刚好符合这道题一层一层网上累加的思考方式。还有一些细节问题在代码中说明。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;
#define int long long
const int N = 2e5 + 10, M = 2 * N, INF = 1e9;
int n, m;
int a[N], b[N]; // ab数组表示每一个节点的上下边界
int fa[N];
int d[N]; // 记录每个节点的出度。用于判断叶子节点
int add[N];
int ans;

void bfs()
{
    queue<int> q;
    for(int i = 1 ; i <= n ; i ++ )
        if(!d[i]) q.push(i)；
    while(q.size())
    {
        int t = q.front();
        q.pop();
        int p = fa[t];
        int down = a[t] , up = b[t]; 
        if(add[t] < down) ans ++ , add[p] += up; // 若子节点的累加总和不够用，ans ++ ，向父节点累加up，因为t还要给自己加一个数值，最多就是up
        else add[p] += min(add[t], up); 
        // 子节点累加的够用，再向上累加，但是不能超过add[t],因为子节点们最多加这么多，up如果很大也是加不了这么多的，我们的要求是合法
        
        d[p] -- ;
        if(!d[p]) q.push(p);
    }
}


void solve()
{
    cin >> n;
    ans = 0; // 记得清空数组和答案
    memset(d, 0, sizeof d);
    memset(add, 0, sizeof add);
    for(int i = 2 ; i <= n ; i ++ ) 
    {
        int p;
        cin >> p;
        fa[i] = p; //记录父亲节点，用于向上递推
        d[x] ++ ; // 记录出度，出度为0表示为叶子节点
    }
    for(int i = 1 ; i <= n ; i ++  )  cin >> a[i] >> b[i];
    bfs();
    cout << ans << endl;
    return ;
}


signed main()
{
    int T;
    cin >> T;
    while(T -- ) solve();
    
    return 0;
}