AtCoder Regular Contest 112 (3 / 6)

A、A - B = C

题目：给定L、R，求问存在多少个A、B、C三元组，使得A=B+C，其中L <= A <= R, L <= B <= R, L <= C <= R

答案：针对一个固定的A，存在满足条件的（B、C）两元组的数量为 A - 2 * L + 1，所以当你遍历A时，答案为一个等差数列，最小值=1，最大值=R - 2 * L + 1，差=1，则对等差数列求和即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 7;
const ll mod = 1e9 + 7;
 
int main()
{
    int t;
    cin >> t;
    while(t--){
        int l, r;
        cin >> l >> r;
        ll ans = max(0, (r - 2 * l + 2)) * 1LL * max(0, (r - 2 * l + 1)) / 2;
        cout << ans << "
";
    }
    return 0;
}

B、B - -- - B

题目：你有一个数字B 和 C 元钱，你可以做如下两种操作：1）花费1元对数字B乘以-1，2）花费2元对数字B减去1，问你最终有可能得到多少个数字。

答案：针对B，你可以一直减1，扩大在坐标轴上左边的范围；还可以先*-1，再不断减，扩大范围。针对你在坐标轴左右两侧的每一侧，你都可以获得一定的可达范围，那么同时你也可以*-1，获得同绝对值下的另一端的范围。最终你会发现，B两侧相距 C / 2的点都可以达到，对0点求对称，坐标轴另一侧可以达到，大概距离为 C / 2 * 2 * 2，再考虑不同情况去重即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 7;
const ll mod = 1e9 + 7;
 
int main()
{
    ll b, c;
    cin >> b >> c;
    ll ans = 0, l, r;
    if(b > 0){
        if(b - (c / 2) > 0){
            ans += c / 2 * 2 + 2;
            if(c > 0 && c % 2 == 0)--ans;
            --c;
            ans += c / 2 * 2;
            if(c > 0 && c % 2 == 0)--ans;
        }
        else{
            ans += b * 2 + 1;
            --c;
            ans += c / 2 * 2;
            if(c > 0 && c % 2 == 0)--ans;
        }
    }
    else{
        ans += c / 2 * 2 + 2;
        if(c > 0 && c % 2 == 0)--ans;
        if((c - 1) / 2 >= b * -1)ans += b * -1 * 2 - 1;
        else{
            ans += (c - 1) / 2 * 2;
            if((c - 1) % 2 == 0)--ans;
        }
    }
    cout << ans << "
";
    return 0;
}

C、DFS Game

题目：题目是个游戏，比较负责，就不翻译了。https://atcoder.jp/contests/arc112/tasks/arc112_c

答案：主要难点在于针对不同子树遍历的优先级选择上，即最先选择哪颗子树去遍历；每颗子树有两个属性是可以提前求得的：1）遍历完该子树之后选择权是否会转移，2）遍历完该子树会相会少获得几个coin；那么遍历的优先级如下

1、当损失都为负值时，即遍历该树能赚，那么优先考虑遍历完选择权不会转移的子树（因为选择权不转移，下次还可以继续优选选择），即损失为偶数的子树（损失为偶数，代表遍历完选择权不会转移，反之亦然）
2、当损失一负一正时，优先考虑负值，因为负值可以获得正加权，即能赚
3、当损失两正时，优先考虑奇数，即选择权转化，因为要下次把锅刷给对方（锅就代表遍历完子树是吃亏的）
4、当损失为正数且同奇偶性时，先考虑小值，尽量少损失一些

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 7;
const ll mod = 1e9 + 7;
 
vector<int> v[maxn];
bool comp(pair<int, int> x, pair<int, int> y){
    int a = x.first, b = y.first;
    if(a < 0 || b < 0){
        if(a < 0 && b < 0 && a % 2 != b % 2){
            return a % 2 == 0;
        }
        return a < b;
    }
    if(a % 2 != b % 2){
        return a % 2 == 1;
    }
    return a < b;
}
pair<int, int> dfs(int x, int pre = 0){
    vector<pair<int, int>> vn;
    for(int y: v[x]){
        pair<int, int> now = dfs(y);
        vn.push_back(now);
    }
    sort(vn.begin(), vn.end(), comp);
    int a[2], ins = 0;
    a[0] = 1;
    a[1] = 0;
    //cout << "x = " << x << '
';
    for(pair<int, int> tmp: vn){
        int x = tmp.first, y = tmp.second;
        //cout << ins << " " << x << " " << y << " " << y - x << " " << a[0] << " " << a[1] << "
";
        a[ins] += y;
        a[ins ^ 1] += y - x;
        if(x % 2 != 0){
            ins ^= 1;
        }
    }
    //cout << "x = " << x << " " << a[0] - a[1] << " " << a[0] << " " << a[1] << "
";
    return make_pair(a[0] - a[1], a[0]);
}
int main()
{
    int n;
    cin >> n;
    for(int i = 2; i <= n; ++i){
        int x;
        cin >> x;
        v[x].push_back(i);
    }
    pair<int, int> ans = dfs(1);
    cout << ans.second << "
";
    return 0;
}