[Educational Codeforces Round 93]1398

---

---

Educational Codeforces Round 93 (Rated for Div. 2)

A - Bad Triangle

题意

问是否存在三条边，无法组成三角形，如果不存在输出-1，存在输出这三条边的下标

分析

直接比较最小两条边的和与最大条边的关系

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 5;

int a[maxn];

int main(){
    int T;
    scanf("%d", &T);
    while(T--) {
        int n;
        scanf("%d", &n);
        for(int i = 1; i <= n; ++i)
            scanf("%d", &a[i]);
        if(a[1] + a[2] <= a[n]) 
            printf("%d %d %d\n", 1, 2, n);
        else
            puts("-1");
    }
    return 0;
}

---

B - Substring Removal Game

题意

Alice 和 Bob 轮流取数，取的数满足 要么是连续的1，要么是连续的0
得分为每个人最终得到的1的个数
Alice和Bob都会尽量使自己的得分更大，问Alice可以得到的最大得分

分析

如果可以取，每个人取的应该都是当前存在的连续最多的1字段
直接计算连续的1的个数，排个序，从最大的开始隔一个取

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 100 + 5;

char s[maxn];
int a[maxn];

int main(){
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%s", s + 1);
        int k = 0, n = strlen(s + 1) + 1;
        for(int i = 1, cnt = 0; i <= n; ++i) {
            if(s[i] == '1') {
                cnt += 1;
            }else{
                if(cnt) a[++k] = cnt;
                cnt = 0;
            }
        }
        int ans = 0;
        sort(a + 1, a + 1 + k);
        for(int i = k; i >= 1; i -= 2) ans += a[i];
        printf("%d\n", ans);
    }
    return 0;
}

---

C - Good Subarrays [思维][前缀和] ★★

题意

求满足 ${\sum }_{i=l}^r{a}_i=r-l+1$ 的区间个数

分析

这样的区间其实相当于平均区间中的每个位置值为 $1$
将每个数都 $-1$，就相当于找区间和为 $0$ 区间个数
区间和为 $0$ 就只要求前缀和个数一样的数

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 5;

char s[maxn];
map<int, int> vis;

int main(){
    int T;
    scanf("%d", &T);
    while(T--) {
        int n; vis.clear();
        scanf("%d%s", &n, s + 1);
        ll ans = 0; vis[0] = 1;
        for(int i = 1, sum = 0; i <= n; ++i) {
            sum += s[i] - '1';
            ans += vis[sum];
            vis[sum] += 1;
        }
        printf("%lld\n", ans);
    }
    return 0;
}

---

D - Colored Rectangles [dp] ★

题意

有三种边 $R,G,B$，矩形可以由任意两种边构成，比如 $r_i,g_j$ 或者 $r_i,b_k$ 或者 $g_j,b_k$
求最后组成的所有矩形面积和最大为多少

分析

感觉这题比上一题好想
可以对每种边分别先进行排序，将边比较大的排在前面
令 $dp[i][j][k]$ 表示 $R$ 选到了 $i$，$G$ 选到了 $j$，$B$ 选到了 $k$，所可以得到的最大矩形面积和
对于 $dp[i][j][k]$ 的转移有三种情况
$dp[i+1][j+1][k]=dp[i][j][k]+R[i+1]\ast G[j+1]$
$dp[i+1][j][k+1]=dp[i][j][k]+R[i+1]\ast B[k+1]$
$dp[i][j+1][k+1]=dp[i][j][k]+R[j+1]\ast B[k+1]$
即分别取 $i+1,j+1$的，$i+1,k+1$的和 $j+1,k+1$的 所组成的矩形

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 200 + 5;

int a[3][maxn];
ll dp[maxn][maxn][maxn];

bool cmp(int x, int y) {
    return x > y;
}

int main(){
    int co[3];
    for(int i = 0; i < 3; ++i) scanf("%d", &co[i]);
    for(int i = 0; i < 3; ++i) {
        for(int j = 1; j <= co[i]; ++j)
            scanf("%d", &a[i][j]);
        sort(a[i] + 1, a[i] + 1 + co[i], cmp);
    }
    ll ans = 0;
    memset(dp, 0, sizeof(dp));
    for(int i = 0; i <= co[0]; ++i) {
        for(int j = 0; j <= co[1]; ++j) {
            for(int k = 0; k <= co[2]; ++k) {
                dp[i+1][j+1][k] = max(dp[i+1][j+1][k], dp[i][j][k] + a[0][i+1] * 1ll * a[1][j+1]);
                dp[i+1][j][k+1] = max(dp[i+1][j][k+1], dp[i][j][k] + a[0][i+1] * 1ll * a[2][k+1]);
                dp[i][j+1][k+1] = max(dp[i][j+1][k+1], dp[i][j][k] + a[1][j+1] * 1ll * a[2][k+1]);
            }
        }
    }
    for(int i = 0; i <= co[0]; ++i)
        for(int j = 0; j <= co[1]; ++j)
            for(int k = 0; k <= co[2]; ++k)
                ans = max(ans, dp[i][j][k]);
    printf("%lld\n", ans);
    return 0;
}

---

E - Two Types of Spells [权值线段树][思维] ★★★

参考博客
Codeforces1398 E. Two Types of Spells（权值线段树）

题意

有两种法术
0 x：若 $x\ge 0$，则加入一个造成 $x$ 点伤害的法术；若 $x<0$，则删除一个造成 $x$ 点伤害的 $0$ 法术（这里造成的伤害是指没有经过加倍的）
1 x：若 $x\ge 0$，则加入一个造成 $x$ 点伤害的法术，且下一次的法术伤害变为两倍；若 $x<0$，则删除一个造成 $x$ 点伤害的 $1$ 法术
保证删除是合法的，给出第 $i$ 个法术后，这 $1\to i$ 个法术可以任意改变次序，问总伤害最大可以为多少

分析

加倍的法术要放在伤害最大的法术之前，这样可以使伤害尽可能大
但第一个加倍的法术是没办法被加倍的，所以第一个加倍的法术要放伤害最小的
如果有 $num$ 个加倍的法术，则次序应该是
伤害最小的加倍 $\to$ 伤害最大 $\to$ 加倍 $\to$ 伤害次大 $...$
直到排完 $num$ 个加倍法术
问题就可以转化为：

1. 可以添加、删除
2. 求后 $num$ 大值的和（$num$ 即加倍法术个数）
3. 求伤害最小的加倍法术，即求最小值

这个问题就可以利用权值线段树来解决
由于要求伤害最小的加倍法术，所以加倍法术要另外建一棵权值线段树
另一棵权值线段树就用来存放所有的法术，这棵树可以用来查询后 $num$ 大值的和
线段树就维护法术值为 $val\in [l,r]$ 的个数 $a[l,r]$，以及总和 $sum[l,r]$
另外由于值较大且有负值，要进行离散化处理

代码

#include <bits/stdc++.h>
#define lson id<<1
#define rson id<<1|1
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
const int maxm = 1e6 + 5;

int xx[maxn];
int op[maxn];
int x[maxn];
struct Tree{
    int a[maxm]; ll sum[maxm]; // 个数，和
    void init() {
        memset(a, 0, sizeof(a));
        memset(sum, 0, sizeof(sum));
    }
    void update(int id, int l, int r, int k, int val) {
        if(l == r) {
            a[id] += val, sum[id] += val * 1ll * xx[l];
            return ;
        }
        int mid = (l + r) >> 1;
        if(k <= mid) update(lson, l, mid, k, val);
        else update(rson, mid+1, r, k, val);
        a[id] = a[lson] + a[rson];
        sum[id] = sum[lson] + sum[rson];
    }
    ll ask(int id, int l, int r, int k) { // 后k大的和
        if(k <= 0)      return 0;
        if(a[id] <= k)  return sum[id];
        if(l == r)      return k * 1ll * xx[l];
        int mid = (l + r) >> 1;
        if(a[rson] >= k) {
            return ask(rson, mid+1, r, k);
        }else{
            return sum[rson] * 1ll + ask(lson, l, mid, k - a[rson]);
        }
    }
    int askmi(int id, int l, int r) { // 最小值是第几个
        if(l == r) return l;
        int mid = (l + r) >> 1;
        if(a[lson]) return askmi(lson, l, mid);
        else return askmi(rson, mid+1, r);
    }
}t1, t2; // t1是所有的, t2是双倍的

ll ans[maxn];
void solve(int n, int k) {
    int num = 0; // 个数
    for(int i = 1, f = 1; i <= n; ++i, f = 1) {
        if(x[i] < 0)    f = -1, x[i] = -x[i];
        if(op[i] == 0) {
            t1.update(1, 1, k, x[i], f);
        }else{
            num += f;
            t1.update(1, 1, k, x[i], f);
            t2.update(1, 1, k, x[i], f);
        }
        ans[i] = t1.sum[1];
        if(num == 0)    continue;
        int minn = t2.askmi(1, 1, k); // 双倍的最小值是第几个
        t1.update(1, 1, k, minn, -1);
        ans[i] += t1.ask(1, 1, k, num); // 后k大的和变成双倍的
        t1.update(1, 1, k, minn, 1);
    }
}

int main(){
    int n; 
    scanf("%d", &n);
    t1.init(), t2.init();
    for(int i = 1; i <= n; ++i) {
        scanf("%d%d", &op[i], &x[i]); xx[i] = abs(x[i]);
    }
    sort(xx + 1, xx + 1 + n);
    int k = unique(xx + 1, xx + 1 + n) - xx - 1;
    for(int i = 1, f = 1; i <= n; ++i, f = 1) {
        if(x[i] < 0) f = -1, x[i] = -x[i];
        x[i] = lower_bound(xx + 1, xx + 1 + k, x[i]) - xx;
        if(f < 0) x[i] = -x[i];
    }
    solve(n, k);
    for(int i = 1; i <= n; ++i) printf("%lld\n", ans[i]);
    return 0;
}

---