bzoj 4336[BJOI2015]骑士的旅行 - 树链剖分 + mulitiset

4336: BJOI2015 骑士的旅行

Time Limit: 20 Sec  Memory Limit: 512 MB

Description

在一片古老的土地上，有一个繁荣的文明。

这片大地几乎被森林覆盖，有N座城坐落其中。巧合的是，这N座城由恰好N-1条双向道路连接起来，使得任意两座城都是连通的。

也就是说，这些城形成了树的结构，任意两座城之间有且仅有一条简单路径。

在这个文明中，骑士是尤其受到尊崇的职业。任何一名骑士，都是其家族乃至家乡的荣耀。Henry从小就渴望成为一名能守护家乡、驱逐敌人的骑士。勤奋训练许多年后，Henry终于满18岁了。他决定离开家乡，向那些成名已久的骑士们发起挑战！根据Henry的调查，大陆上一共有M名受封骑士，不妨编号为1到M。

第i个骑士居住在城Pi，武力值为Fi。Henry计划进行若干次旅行，每次从某座城出发沿着唯一的简单路径前往另一座城，

同时会挑战路线上武力值最高的K个骑士（Henry的体力有限，为了提高水平，当然要挑战最强的骑士）。如果路线上的骑士不足K人，Henry会挑战遇到的所有人。

每次旅行前，可能会有某些骑士的武力值或定居地发生变化，Henry自然会打听消息，并对计划做出调整。

为了在每次旅行时做好充分准备，Henry希望你能帮忙在每次旅行前计算出这条路线上他将挑战哪些对手。

 

Input

第一行，一个整数N，表示有N座城，编号为1~N。

接下来N-1行，每行两个整数Ui和Vi，表示城Ui和城Vi之间有一条道路相连。

第N+1行，一个整数M，表示有M个骑士。

接下来M行，每行两个整数Fi和Pi。按顺序依次表示编号为1~M的每名骑士的武

力值和居住地。

第N+M+2行，两个整数Q,K，分别表示操作次数和每次旅行挑战的骑士数目上限。

接下来Q行，每行三个整数Ti,Xi,Yi。Ti取值范围为{1,2,3}，表示操作类型。

一共有以下三种类型的操作：

Ti=1时表示一次旅行，Henry将从城Xi出发前往城市Yi；

Ti=2时表示编号为Xi的骑士的居住地搬到城Yi；

Ti=3时表示编号为Xi的骑士的武力值修正为Yi。

Output

输出若干行，依次为每个旅行的答案。

对每个Ti=1的询问，输出一行，按从大到小的顺序输出Henry在这次旅行中挑战的

所有骑士的武力值。如果路线上没有骑士，输出一行，为一个整数-1。

Sample Input

5
1 2
1 3
2 4
2 5
4
10 1
6 1
14 5
7 3
5 3
1 2 3
1 5 3
1 4 4
2 1 4
1 2 3

Sample Output

10 7 6
14 10 7
-1
7 6

HINT

 

100%的数据中，1 ≤ N, M ≤ 40,000，1 ≤ Ui, Vi, Pi ≤ N，1 ≤ Q ≤ 80,000, 1 ≤ K ≤ 

20，旅行次数不超过 40,000 次，武力值为不超过1,000的正整数。 

 

 

对于这类树上问题，可以考虑树链剖分解决

重点是如何维护前k大个

对于一个单点，可以用muiliset 直接按顺序存储所有的人

这样向上合并的时候就用归并的思想很简单就解决了。

 

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#define LL long long

using namespace std;

const int MAXN = 5e4 + 10;

int T;
int x, y;
multiset<int> city[MAXN];
int ans[30];
int N, M;
int head[MAXN];
int m[MAXN];
int cnt = 0;
int vis[MAXN];
int dfn[MAXN], top[MAXN], fa[MAXN];
int size[MAXN], son[MAXN];
int deep[MAXN];
int Q, K;

struct edge {
    int v;
    int next;
} g[MAXN * 2];

struct segment {
    int l, r;
    int big[30];
} seg[MAXN * 20];

struct knight {
    int force, loc;
} kt[MAXN];

void addedge(int u, int v)
{
    g[++cnt].v = v;
    g[cnt].next = head[u];
    head[u] = cnt;
}

inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

void pushup(int x)
{
    int l1 = 1, l2 = 1;
    for(int i = 1; i <= K; i++) {
        if(seg[x * 2].big[l1] >= seg[x * 2 + 1].big[l2]) {
            seg[x].big[i] = seg[x * 2].big[l1++];
        } else {
            seg[x].big[i] = seg[x * 2 + 1].big[l2++];
        }
    }
}

void merge(int x)
{
    int temp[30];
    int l1 = 1, l2 = 1;
    for(int i = 1; i <= K; i++) {
        temp[i] = ans[i];
    }
    for(int i = 1; i <= K; i++) {
        if(temp[l1] >= seg[x].big[l2]) {
            ans[i] = temp[l1++];
        } else {
            ans[i] = seg[x].big[l2++];
        }
    }
}

void dfs1(int x)
{
    deep[x] = deep[fa[x]] + 1;
    size[x] = 1;
    vis[x] = 1;
    for(int j = head[x]; j; j = g[j].next) {
        int to = g[j].v;
        if(!vis[to]) {
            fa[to] = x;
            dfs1(to);
            size[x] += size[to];
            if(size[to] > size[son[x]]) {
                son[x] = to;
            }
        }
    }
}

void dfs2(int x, int k)
{
    top[x] = k;
    dfn[x] = ++cnt;
    m[cnt] = x;
    if(son[x]) {
        dfs2(son[x], k);
    }
    for(int j = head[x]; j; j = g[j].next) {
        int to = g[j].v;
        if(!dfn[to]) {
            dfs2(to, to);
        }
    }
}

void update(int u, int l, int r, int root, int k)
{
    if(l == r) {
        city[m[l]].insert(k);
        multiset<int>::iterator t;
        int i = 1;
        t = city[m[l]].end();
        t--;
        for(; i <= K; i++, t--) {
            seg[root].big[i] = *t;
            if(t == city[m[l]].begin()) {
                i++;
                for(; i <= K; i++) {
                    seg[root].big[i] = 0;
                }
                break;
            }
        }
        return;
    }
    int mid = (l + r) >> 1;
    if(u <= mid) {
        update(u, l, mid, root * 2, k);
    } else {
        update(u, mid + 1, r, root * 2 + 1, k);
    }
    pushup(root);
}

void del(int u, int l, int r, int root, int k)
{
    if(l == r) {
        multiset<int> :: iterator t;
        t = city[m[l]].find(k);
        city[m[l]].erase(t);
        int i = 1;
        t = city[m[l]].end();
        if(city[m[l]].empty()) {
            for(int i = 1; i <= K; i++) {
                seg[root].big[i] = 0;
            }
            return;
        }
        t--;
        for(; i <= K; i++, t--) {
            seg[root].big[i] = *t;
            if(t == city[m[l]].begin()) {
                i++;
                for(;i <= K; i++) {
                    seg[root].big[i] = 0;
                }
                break;
            }
        }
        return;
    }
    int mid = (l + r) >> 1;
    if(u <= mid) {
        del(u, l, mid, root * 2, k);
    } else {
        del(u, mid + 1, r, root * 2 + 1, k);
    }
    pushup(root);
}

void build()
{
    dfs1(1);
    cnt = 0;
    dfs2(1, 1);
}

void query(int ql, int qr, int l, int r, int root)
{
    if(l >= ql && r <= qr) {
        merge(root);
        return;
    }
    int mid = (l + r) >> 1;
    if(mid >= ql) {
        query(ql, qr, l, mid, root * 2);
    }
    if(mid < qr) {
        query(ql, qr, mid + 1, r, root * 2 + 1);
    }
}

int LCA(int x, int y)
{
    int fx = top[x], fy = top[y];
    while(fx != fy) {
        if(deep[fx] >= deep[fy]) {
            query(dfn[fx], dfn[x], 1, N, 1);
            x = fa[fx];
            fx = top[x];
        } else {
            query(dfn[fy], dfn[y], 1, N, 1);
            y = fa[fy];
            fy = top[y];
        }
    }
    if(deep[x] >= deep[y]) {
        query(dfn[y], dfn[x], 1, N, 1);
        return y;
    } else {
        query(dfn[x], dfn[y], 1, N, 1);
        return x;
    }
}

int main()
{ 
    //freopen("knight10.in", "r", stdin);
    //freopen("knight.out", "w", stdout);
    N = read();
    for(int i = 1; i < N; i++) {
        int u = read(), v = read();
        addedge(u, v);
        addedge(v, u);
    }
    build();
    M = read();
    for(int i = 1; i <= M; i++) {
        kt[i].force = read(), kt[i].loc = read();
    } 
    Q = read(), K = read();
    for(int i = 1; i <= M; i++) {
        update(dfn[kt[i].loc], 1, N, 1, kt[i].force);
    }
    int tot = 1;
    while(Q--) {
        /*cout<<tot++<<endl;
        multiset<int> ::iterator t;
        t = city[4527].begin();
        for(; t != city[4527].end(); t++) {
            cout<<*t<<" ";
        }
        cout<<endl;*/ 
        T = read();
        x = read(), y = read();
        //cout<<T<<" "<<x<<" "<<y<<endl; 
        if(T == 1) {
            for(int i = 1; i <= K; i++) {
                ans[i] = 0;
            }
            /*if(x == 1 && y == 2){
                multiset<int> ::iterator t;
                t = city[x].begin();
                for(; t != city[x].end(); t++) {
                    cout<<*t<<" ";
                }
                cout<<endl;
                
            }*/
            LCA(x, y);
            /*for(int i = 1; i <= N; i++) {
                for(int j = 1; j <= 20; j++) {
                    ans[j] = 0;
                }
                query(dfn[i], dfn[i], 1, N, 1);
                for(int j = 1; j <= 3; j++) {
                    cout<<ans[j]<<" ";
                }
                cout<<endl<<endl;
            }*/
            for(int i = 1; i <= K; i++) {
                if(ans[i] == 0) {
                    if(i == 1) {
                        printf("-1");
                    }
                    break;
                }
                printf("%d ", ans[i]);
            }
            printf("\n");
        } else if(T == 2) {
            /*if(x == 720 && y == 6713) {
                cout<<dfn[kt[x].loc] <<" "<<kt[x].force<<" "<<kt[x].loc<<endl;
                multiset<int> ::iterator t;
                t = city[kt[x].loc].begin();
                for(; t != city[kt[x].loc].end(); t++) {
                    cout<<*t<<" ";
                }
                cout<<endl;
                return 0;
            }*/
            del(dfn[kt[x].loc], 1, N, 1, kt[x].force);
            kt[x].loc = y;
            update(dfn[kt[x].loc], 1, N, 1, kt[x].force);
        } else {
            del(dfn[kt[x].loc], 1, N, 1, kt[x].force);
            kt[x].force = y;
            update(dfn[kt[x].loc], 1, N, 1, kt[x].force);
        }
    }
}    


/*
5 

1 2 

1 3 

2 4 

2 5 

4 

10 1 

6 1 

14 5 

7 3 

5 3 

1 2 3 

1 5 3 

1 4 4 

2 1 4 

1 2 3 

*/