Codeforces Round #381 (Div. 1)

A. Alyona and mex

这道题就是使The mex of a set S最大，那么很明显直接找到最小的区间，然后就可以找到最小的The mex of a set S为n，然后对于构造这个序列为循环的（0~n-1），因为这样每个给定的区间的The mex of a set S至少为n。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

int main(){
    int n, m;
    while(scanf("%d%d", &n, &m) != EOF){
        int cnt = 1e6, l, r;
        for(int i = 0; i < m; i++){
            scanf("%d%d", &l, &r);
            cnt = min(cnt, r-l+1);
        }
        printf("%d\n", cnt);
        int flag = -1;
        for(int i = 0; i < n; i++)
            printf("%d ", ++flag%cnt);
        printf("\n");
    }
    return 0;
}

B. Alyona and a tree

一道反方向推的题目，对于dfs来说肯定是有一个顺序的，这时候我们用一个数组存放该点之前的所有父亲节点，然后二分查找最近的父亲节点，然后让该节点x的值减1，这样我们按照dfs顺序访问完子节点往父节点推的过程中，x以及x上面所有父亲节点都会减1，这样正是我们想要的。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define LL long long
const int maxn = 2e5+100;
int a[maxn], head[maxn], ans[maxn], que[maxn], tot, cnt;
LL dep[maxn];

struct Edge{
    int to, next, w;
}e[maxn];


void addedge(int from, int to, int w){
    e[tot].to = to;
    e[tot].w = w;
    e[tot].next = head[from];
    head[from] = tot++;
}

void dfs(int u){
    que[++cnt] = u;
    for(int i = head[u]; i != -1; i = e[i].next){
        int v = e[i].to;
        dep[v] = dep[u] + e[i].w;
        dfs(v);
        ans[u] += ans[v] + 1;
    }
    int l = 0, r = cnt-1;
    while(l < r){
        int mid = (l+r+1)/2;
        if(dep[u] - dep[que[mid]] > a[u]) l = mid;
        else r = mid-1;
    }
    ans[que[l]]--;
    cnt--;
}

void init(){
    tot = cnt = 0;
    memset(head, -1, sizeof(head));
    memset(ans, 0, sizeof(ans));
    memset(dep, 0, sizeof(dep));
}

int main(){
    int n;
    init();
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
    int p, w;
    for(int i = 2; i <= n; i++){
        scanf("%d%d", &p, &w);
        addedge(p, i, w);
    }
    dfs(1);
    for(int i = 1; i <= n; i++)
        printf("%d ", ans[i]);
    printf("\n");
    return 0;
}

C. Alyona and towers

特别邪门的一道题，用线段树处理，自己看了半天发现细节问题好多，然后处理不出来，然后到网上找了找，发现写的代码并没有注释，按照之前我的想法对于每行重要的代码进行研究终于理清了思路。这个将别人的代码加上注释贴上。转自：rua~

/*
这道题按照了对于区间进行了一次转换，新的区间是前后元素的差值，这样我们很快就可以
知道哪个地方是递增的，哪个地方是递减的。当然了我们找的是一个像山顶一样的形状，也就是
先单调增后单调减，因为处理的过程比较复杂，用到的数组比较多，后面我会对数组加注释表明
该数组表示的意思。
*/

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxnum = 3 * 101000;
long long maxn[4*maxnum],lnmax[4*maxnum],lpnmax[4*maxnum],rpmax[4*maxnum],rpnmax[4*maxnum];
long long diff[2*maxnum];
int a[2*maxnum],n,m;
void pushup(int o,int l,int r){
    int mid = (l + r)/2;
    //maxn数组表示该节点满足题目要求条件的最大值
    maxn[o] = max(maxn[o << 1],max(maxn[o << 1|1],max(rpmax[o << 1] + lpnmax[o << 1|1], rpnmax[o << 1] + lnmax[o << 1|1])));
    //lnmax表示靠是从该区间的最左端一直递减的最长长度
    lnmax[o] = lnmax[o << 1]==(mid - l + 1)?mid - l + 1 + lnmax[o << 1|1]:lnmax[o << 1];  
    //lpnmax表示从该区间最左端先递增后递减的最长长度
    lpnmax[o] = lpnmax[o << 1]==(mid - l + 1)?mid - l + 1 + lnmax[o << 1|1]:lpnmax[o << 1]; 
    //这里表示左孩子单点增，右孩子先单调增后单调减的情况
    if(rpmax[o << 1] == mid - l + 1) lpnmax[o] = max(lpnmax[o],rpmax[o << 1] + lpnmax[o << 1|1]); 
    //靠右边一直增加的，并且递增到该区间的右端点
    rpmax[o] = rpmax[o << 1|1] == (r - mid)?r - mid + rpmax[o << 1]:rpmax[o << 1|1];  
    //靠右边先单调增后单调减并且最后到达的点是区间的右端点
    rpnmax[o] = rpnmax[o << 1|1] == (r - mid)?r - mid + rpmax[o << 1]:rpnmax[o << 1|1]; 
    //这里表示右孩子单调递减，左孩子先增后减的情况。 
    if(lnmax[o << 1|1] ==r - mid) rpnmax[o] = max(rpnmax[o],rpnmax[o << 1] + lnmax[o << 1|1]);
}

void change(int o,int l){   
    if(diff[l] == 0) maxn[o] = lnmax[o] = lpnmax[o] = rpmax[o] = rpnmax[o] = 0;
    else if(diff[l] > 0){
        lnmax[o] = 0;
        rpnmax[o] = lpnmax[o] = maxn[o] = rpmax[o] = 1;
    }
    else{
        rpmax[o] = 0;
        maxn[o] = lpnmax[o]= lnmax[o] = rpnmax[o] = 1;
    }
}

void build(int o,int l,int r){
    if(l == r){
        change(o,l);
        return ;
    }
    int mid = (l + r)/2;
    build(o << 1,l,mid);
    build(o << 1|1,mid + 1,r);
    pushup(o,l,r);
}

void update(int o,int l,int r,int k,int pos){
    if(l == r){
        diff[pos] += k;
        change(o,pos);
        return;
    }
    int mid = (l + r)/2;
    if(pos <= mid) update(o<<1,l,mid,k,pos);
    else update(o << 1|1,mid + 1,r,k,pos);
    pushup(o,l,r);
}

int main(){
    scanf("%d",&n);
    for(int i = 1;i <= n;i ++){
        scanf("%d",&a[i]);
        diff[i] = i == 1?0:a[i] - a[i - 1];
    }
    build(1,1,n);
    scanf("%d",&m);
    int l,r,k;
    for(int i = 1;i <= m;i ++){
        scanf("%d%d%d",&l,&r,&k);
        if(l != 1)update(1,1,n,k,l);
        if(r != n) update(1,1,n,-k,r + 1);
        printf("%I64d\n",maxn[1] + 1);  //这里加1是因为最左端的那个点并没有加上因为第一个点假设为正，那么该点之前还有一个元素
    }
    return 0;
}