Codeforces Round #401 (Div. 2) 题解

首先先来婊一下自己。不知道自己的状态是怎么了，这场DIV2应该是最简单的DIV2了，但是我莫名其妙打崩了，在两个队友快速AK之后我还一直卡在C题，并非是不会，而是自己傻吊的开了个二维的动态数组。

    int **aa, **dp;
    aa = new int*[n];
    dp = new int *[n];
    for(int j = 0; j < n; j++){
        aa[j] = new int[m];
        dp[j] = new int[m];
    }

我考试写的时候，写的是aa[j] = dp[j] = new int[m]，指针相互指自然是GG了，我是真的智障。然后b题 First print the minimum possible number of flicks Moriarty will get. Then print the maximum possible number of flicks that Sherlock can get from Moriarty.把第一个名字看错了，WA了6发才发现。导致心态真的炸，这个时候队友已经在做D了，什么时候才能改掉自己不心思缜密的毛病啊，真的是不能浮躁啊。接下来一定要静下来，好好搞，不然就退役，棉的拖累队友。写一下这场题解吧，5个题都比较简单。

A: 水题。首先可以发现6轮肯定会回到初始状态，所以n先模6之后我们直接倒着模拟就可以了。

#include <bits/stdc++.h>
using namespace std;
int n, x;
int a[4];
int main(){
    scanf("%d%d", &n, &x);
    n %= 6;
    a[x + 1] = 1;
    for(int i = n; i >= 1; i--){
        if(i%2==0){
            swap(a[2], a[3]);
        }
        else{
            swap(a[1], a[2]);
        }
    }
    for(int i = 1; i <= 3; i++){
        if(a[i] != 0){
            cout << i - 1 << endl;
            return 0;
        }
    }
}

B:同水题，贪心。计数之后贪心，这个简单问题应该都想得到，就不详细说了，读对题=AC

#include <bits/stdc++.h>
using namespace std;
char s1[1010], s2[1010];
int n, a[11], b[11];

int main(){
    scanf("%d", &n);
    scanf("%s", s1);
    scanf("%s", s2);
    for(int i = 0; i < strlen(s1); i++){
        a[s1[i] - '0']++;
    }
    for(int i = 0; i < strlen(s2); i++){
        b[s2[i] - '0']++;
    }
    int Max = 0, Min = 0;
    for(int i = 0; i < strlen(s1); i++){
        bool ok = 0;
        for(int j = s1[i] - '0'; j <= 9; j++){
            if(b[j]){
                ok = 1;
                b[j]--;
                break;
            }
        }
        if(ok == 0) Min++;
    }
    cout << Min << endl;
    memset(b, 0, sizeof(b));
    for(int i = 0; i < strlen(s2); i++){
        b[s2[i] - '0']++;
    }
    for(int i = 0; i < strlen(s1); i++){
        for(int j = s1[i] - '0' + 1; j <= 9; j++){
            if(b[j]){
                Max++;
                b[j]--;
                break;
            }
        }
    }
    cout << Max << endl;
}

C:一个非常简单的思路，记录一下每一行以当前行每一个元素结尾的每一列的最长上升子序列的值的最大值，然后判断一下r行的最大值是否>=r-l+1就ok了。本来可以快速10分钟a掉，应该傻逼问题真的卡了全场。哎，弱啊。

#include <bits/stdc++.h>
using namespace std;
int ans[100010];
int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    int **aa, **dp;
    aa = new int*[n];
    dp = new int *[n];
    for(int j = 0; j < n; j++){
        aa[j] = new int[m];
        dp[j] = new int[m];
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            scanf("%d", &aa[i][j]);
        }
    }
    for(int j = 0; j < m; j++){
        dp[0][j] = 1;
    }
    memset(ans, 0, sizeof(ans));
    ans[0] = 1;
    for(int i = 1; i < n; i++){
        for(int j = 0; j < m; j++){
            if(aa[i][j] >= aa[i - 1][j]){
                dp[i][j] = dp[i - 1][j] + 1;
            }
            else{
                dp[i][j] = 1;
            }
            ans[i] = max(ans[i], dp[i][j]);
        }
    }
    int k;
    scanf("%d", &k);
    while(k--){
        int l, r;
        scanf("%d%d", &l, &r);
        --l, --r;
        if(ans[r] >= (r - l + 1)) puts("Yes");
        else puts("No");
    }
    for(int i = 0; i < n; i++){
        delete [] dp[i];
        delete [] aa[i];
    }
    delete [] aa;
    delete [] dp;
    return 0;
}

D: 首先，题目中说了顺序是固定的所以我们考虑前一个和后一个的关系就好，但是会发现顺着考虑好做吗？我们会发现顺着做并不好做，相反我们逆着做就非常简单了。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010;
int n;
string s[maxn];
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i++){
        cin >> s[i];
    }
    for(int i = n - 1; i >= 1; i--){
        int len = s[i].size();
        for(int j = 0; j < len; j++){
            if(s[i][j] > s[i+1][j]){
                s[i][j] = 0;
                break;
            }
            else if(s[i][j] < s[i+1][j]) break;
        }
    }
    for(int i = 1; i <= n; i++) printf("%s\n", s[i].c_str());
    return 0;
}

E : 给了一些圆环，要把这些圆环堆在一起，需要满足的条件为下面的圆环外半径大于上面环的外半径，下面的圆环内径小于上面的圆环外径，问最多堆出来的圆环的高度是什么？比较裸的DP+数据结构优化了,dp[i]表示i放在最上面是得到的最大告诉，转移显然：

$$dp[i] = max(dp[j]) + a[i].h$$
然后转移既可以线段树，也可以树状数组，维护一个最大值就行了。a,b,h很大，显然离散化再做。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, tot;
struct Q{
    int a, b, h;
    Q(){}
    Q(int a, int b, int h) : a(a), b(b), h(h){}
    bool operator <(const Q &rhs) const{
        if(b == rhs.b) return a > rhs.a;
        return b > rhs.b;
    }
}a[maxn];
vector <int> v;
int getid(int x){
    return lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
}
namespace BIT{
    long long c[maxn*2];
    void init(){memset(c, 0, sizeof(c));}
    inline int lowbit(int x){return x&-x;}
    inline void update(int i, long long v){for(; i <= tot; i += lowbit(i)) c[i] = max(c[i], v);}
    inline long long query(int i){long long res = 0; for(; i; i -= lowbit(i)) res = max(res, c[i]); return res;}
}
using namespace BIT;
int main(){
    cin >> n;
    for(int i = 1; i <= n; i++){scanf("%d%d%d", &a[i].a, &a[i].b, &a[i].h); v.push_back(a[i].a); v.push_back(a[i].b);}
    sort(a + 1, a + n + 1);
    sort(v.begin(), v.end()), v.erase(unique(v.begin(), v.end()), v.end());
    tot = v.size();
    long long ans = 0;
    for(int i = 1; i <= n; i++){
        int id = getid(a[i].b);
        long long cur = query(id - 1) + a[i].h;
        ans = max(ans, cur);
        int id2 = getid(a[i].a);
        update(id2, cur);
    }
    cout << ans << endl;
    return 0;
}

不离散化用动态开点线段树也是可以的。 贴一份金牌爷的int64线段树代码

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
typedef long long LL;
struct node
{
    int a, b, h;
    node(int a = 0, int b = 0, int h = 0): a(a), b(b), h(h) {}
    bool operator < (const node &x)const
    {
        if(b == x.b) return a > x.a;
        return b > x.b;
    }
} e[maxn];
int clk = 1;
int lson[maxn * 33], rson[maxn * 33];
LL mx[maxn * 33];
void update(int &id, int L, int R, int pos, LL val)
{
    if(id == 0) id = ++clk;
    mx[id] = max(mx[id], val);
    if(L != R)
    {
        int mid = L + R >> 1;
        if(pos <= mid) update(lson[id], L, mid, pos, val);
        else update(rson[id], mid + 1, R, pos, val);
    }
}
LL que(int id, int L, int R, int l, int r)
{
    if(id == 0) return 0;
    if(l <= L && R <= r) return mx[id];
    int mid = L + R >> 1;
    LL ret = 0;
    if(l <= mid) ret = max(ret, que(lson[id], L, mid, l, r));
    if(mid < r) ret = max(ret, que(rson[id], mid + 1, R, l, r));
    return ret;
}
int main()
{
    int n;
    scanf("%d", &n);
    int xx = 0;
    for(int i = 1; i <= n; i++)
    {
        int a, b, h;
        scanf("%d %d %d", &a, &b, &h);
        e[i] = node(a, b, h);
        xx = max(xx, a);
    }
    sort(e + 1, e + 1 + n);
    for(int i = 1; i <= n; i++)
    {
        LL dp = que(1, 1, xx, 1, e[i].b - 1);
        dp += e[i].h;
        int rt = 1;
        update(rt, 1, xx, e[i].a, dp);
    }
    printf("%lld\n", mx[1]);
    return 0;
}