军团指挥官(权限题)

Orz zzd大神太强啦！

解：首先发现几个性质：如果把区间还原到原序列上的话，可以发现这些区间要么包含，要么相离。不存在相交。

然后发现如果区间a包含区间b，那么最后剩下来的人，a一定不小于b。又发现最优决策要么是0，要么是在某个极小的区间内。

然后我们发现这TM不就可以建出一棵树来么？枚举叶节点然后树上倍增找到最多能胜场数，然后取max即可。

怎么搞出原序列上的区间来呢？我先想到树状数组(????)，然后搞了一个小时还不会定位区间，爆0了。

后来发现splay可以随便水......

 

#include <bits/stdc++.h>

const int N = 100010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

struct Node {
    int x, y, l, r, val;
    inline bool operator <(const Node &w) const {
        if(l != w.l) return l < w.l;
        return r > w.r;
    }
}node[N];

int a[N], stk[N], top, root, n, m, K, e[N], pw[N], d[N], fa[N];
int s[N][2], faa[N][20], siz[N], lc[N], rc[N], tot, ST[N][20];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

inline void pushup(int x) {
    siz[x] = siz[s[x][0]] + siz[s[x][1]] + 1;
    if(!fa[x]) root = x;
    return;
}

inline void pushdown(int x) {
    return;
}

inline void rotate(int x) {
    int y = fa[x];
    int z = fa[y];
    bool f = (s[y][1] == x);

    fa[x] = z;
    if(z) {
        s[z][s[z][1] == y] = x;
    }
    s[y][f] = s[x][!f];
    if(s[x][!f]) {
        fa[s[x][!f]] = y;
    }
    s[x][!f] = y;
    fa[y] = x;

    pushup(y);
    return;
}

inline void splay(int x, int g = 0) {
    int y = x;
    stk[top = 1] = y;
    while(fa[y]) {
        y = fa[y];
        stk[++top] = y;
    }
    while(top) {
        pushdown(stk[top]);
        top--;
    }
    y = fa[x];
    int z = fa[y];
    while(y != g) {
        if(z != g) {
            (s[y][1] == x) ^ (s[z][1] == y) ?
            rotate(x) : rotate(y);
        }
        rotate(x);
        y = fa[x];
        z = fa[y];
    }
    pushup(x);
    return;
}

inline int np(int f, int l, int r) {
    int x = ++tot;
    fa[x] = f;
    lc[x] = l;
    rc[x] = r;
    siz[x] = 1;
    return x;
}

inline int getPbyR(int k) {
    int p = root;
    k++;
    while(1) {
        if(k <= siz[s[p][0]]) {
            p = s[p][0];
        }
        else if(k == siz[s[p][0]] + 1) {
            break;
        }
        else {
            k -= siz[s[p][0]] + 1;
            p = s[p][1];
        }
    }
    splay(p);
    return p;
}

int build(int f, int l, int r) {
    if(l == r) {
        return np(f, l, r);
    }
    int mid = (l + r) >> 1;
    int x = np(f, mid, mid);
    if(l < mid) s[x][0] = build(x, l, mid - 1);
    if(mid < r) s[x][1] = build(x, mid + 1, r);
    pushup(x);
    return x;
}

inline int getL(int p = root) {
    pushdown(p);
    while(s[p][0]) {
        p = s[p][0];
        pushdown(p);
    }
    return p;
}

inline int getR(int p = root) {
    pushdown(p);
    while(s[p][1]) {
        p = s[p][1];
        pushdown(p);
    }
    return p;
}

inline void merge(int x, int l, int r) {
    lc[x] = l;
    rc[x] = r;
    siz[x] = 1;
    s[x][0] = s[x][1] = 0;
    return;
}

inline void prework() {
    for(int i = 2; i <= n; i++) {
        pw[i] = pw[i >> 1] + 1;
    }
    for(int i = 1; i < n; i++) ST[i][0] = a[i];
    for(int j = 1; j <= pw[n]; j++) {
        for(int i = 1; i + (1 << j) - 1 <= n; i++) {
            ST[i][j] = std::max(ST[i][j - 1], ST[i + (1 << (j - 1))][j - 1]);
        }
    }
    return;
}

inline void prework2() {
    for(int j = 1; j <= pw[m]; j++) {
        for(int i = 1; i <= m; i++) {
            faa[i][j] = faa[faa[i][j - 1]][j - 1];
        }
    }
    return;
}

inline int getPos(int x) {
    int t = pw[m];
    while(t >= 0) {
        if(faa[x][t] && node[faa[x][t]].val <= K) {
            x = faa[x][t];
        }
        t--;
    }
    return x;
}

inline int getMax(int x, int y) {
    int t = pw[y - x + 1];
    return std::max(ST[x][t], ST[y - (1 << t) + 1][t]);
}
/*
5 3 3
1 0 2 4
1 3
0 1
0 1
*/
int main() {

    scanf("%d%d%d", &n, &m, &K);
    for(int i = 1; i < n; i++) {
        scanf("%d", &a[i]);
    }
    for(int i = 1; i <= m; i++) {
        scanf("%d%d", &node[i].x, &node[i].y);
        node[i].x++;
        node[i].y++;
    }
    /// input OVER

    prework();
    root = build(0, 0, n + 1);

    for(int i = 1; i <= m; i++) {
        int L = getPbyR(node[i].x - 1);
        int R = getPbyR(node[i].y + 1);
        splay(L, R);
        int l = getL(s[L][1]), r = getR(s[L][1]);
        node[i].l = lc[l];
        node[i].r = rc[r];
        node[i].val = getMax(node[i].l, node[i].r - 1);
        merge(s[L][1], node[i].l, node[i].r);
        pushup(L);
        pushup(R);
    }

    std::sort(node + 1, node + m + 1);
    top = 0;
    for(int i = 1; i <= m; i++) {
        while(top && node[i].l > node[stk[top]].r) {
            top--;
        }
        if(top) {
            add(stk[top], i);
            faa[i][0] = stk[top];
        }
        stk[++top] = i;
    }

    prework2();
    for(int i = 1; i <= m; i++) {
        d[i] = d[faa[i][0]] + 1;
    }

    int ans = 0, pos = 1;
    for(int x = 1; x <= m; x++) {
        if(e[x] || node[x].val > K) continue;
        int t = getPos(x);
        t = d[x] - d[t] + 1;
        if(t > ans) {
            ans = t;
            pos = node[x].l;
        }
        else if(t == ans) {
            pos = std::min(pos, node[x].l);
        }
    }

    printf("%d\n", pos - 1);
    return 0;
}