ACM学习历程—SNNUOJ 1110 传输网络（(并查集 && 离线) || (线段树 && 时间戳)）（2015陕西省大学生程序设计竞赛D题）

Description

Byteland国家的网络单向传输系统可以被看成是以首都 Bytetown为中心的有向树，一开始只有Bytetown建有基站，所有其他城市的信号都是从Bytetown传输过来的。现在他们开始在其他城市陆续建立了新的基站，命令“C x“代表在城市x建立了一个新的基站，不会在同一个城市建立多个基站；城市编号为1到n，其中城市1就是首都Bytetown。在建立基站的过程中他们还会询问某个城市的网络信号是从哪个城市传输过来的，命令”Q x“代表查询城市x的来源城市。

Input

输入有多组测试数据。每组数据的第一行包含两个正整数n和m（1 <= n,m <= 100,000），分别代表城市数和命令数。接下来n-1行，每行两个正整数u和v，代表一条从城市u到城市v的网络传输通道。之后的m行，每行一个命令”C x“或”Q x”。
所有输入的n和m的总和分别都不超过500,000，两组输入数据之间用一个空行隔开。

Output

对于每个查询命令，输出一个整数y，表示来源城市。每两组数据之间用一个空格隔开。

Sample Input

3 4

1 2

2 3

Q 3

C 2

Q 2

Q 3

Sample Output

题目大意是给了一个树，一开始所有结点的来源都是编号为1的那个结点。然后可以通过C操作来将某个城市设为来源城市，通过Q操作来查询最近的祖先来源城市。
当时省赛时的第一反应是用带时间戳的线段树去解决，但是没有看清查询的是最近的祖先来源城市，当成了纯粹的染色，果断写跪了。
于是这道题理论上可以有两种解法。不过本地测时，用递归去得到时间戳，深度很深会爆。

解法一：（带时间戳的线段树）
这个和线段树的苹果那题很像，首先通过dfs（当然理论上可以不通过递归实现），得到每个结点的左值和右值；
其中右值代表新编号，即是在dfs中后序遍历的标号。
左值代表子树中右值的最小值，即子树中的最小编号。
通过手画一张图基本上可以知道递归时的操作。

然后就是如何诠释C和Q操作了。
C操作原本是将原编号设为来源城市，即将子树中左值到右值区间内的所有结点染为当前城市编号，由于是染最近祖先来源城市，而且在树中时间戳从上往下是变小的。所以这一步应该是染结点的右值，而且进行懒人操作的pushDown时应该更新右值小的那一个。
Q操作是查询某个点，自然是查询这个点的右值到这个点的右值这个单点区间。得到的是时间戳的右值，再通过Hash回去，得到原编号即可。

解法二：（并查集离线查询）
由于查询操作和点修改操作是混合的，所以查询的时候不能带路径压缩，否则树的结构会被破坏。
但是如果所有的C操作都完成后，对剩余的Q操作便可以进行路径压缩。
于是考虑能不能从最后一个C操作还原到倒数第二个C操作，这样的话，就可以对这两个C直接的Q进行路径压缩。
由于C操作仅是将结点指向自己，所以还原C操作就是将结点指向原来的父节点。这样就只需要记录每个点的父节点。
综上可以对查询进行离线：先正着来一遍，只执行C操作，然后倒着查询，遇到C操作还原，遇到Q操作进行路径压缩，并将查询结果存入数组。

代码：(带时间戳的线段树)

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <set>

#include <map>

#include <queue>

#include <string>

#include <algorithm>

#define LL long long

using namespace std;

const int maxN = ;

//链式前向星

struct Edge

{

    int to, next;

}edge[maxN];

int head[maxN], cnt;

void addEdge(int u, int v)

{

    edge[cnt].to = v;

    edge[cnt].next = head[u];

    head[u] = cnt;

    cnt++;

}

void initEdge()

{

    memset(head, -, sizeof(head));

    cnt = ;

}

int n, m;

int idL[maxN], idR[maxN];

int Hash[maxN];

void dfs(int now, int &num)

{

    idL[now] = num;

    for (int i = head[now]; i != -; i = edge[i].next)

        dfs(edge[i].to, num);

    idR[now] = num;

    Hash[num] = now;

    num++;

}

//线段树

//区间染色变形，染最值

struct node

{

    int lt, rt;

    int val;

    int turn;

}tree[*maxN];

//向下更新

void pushDown(int id)

{

    if (tree[id].turn != )

    {

        tree[id<<].turn = min(tree[id].turn, tree[id<<].val);

        tree[id<<].val = tree[id<<].turn;

        tree[id<<|].turn = min(tree[id].turn, tree[id<<|].val);

        tree[id<<|].val = tree[id<<|].turn;

        tree[id].turn = ;

    }

}

//建立线段树

void build(int lt, int rt, int id)

{

    tree[id].lt = lt;

    tree[id].rt = rt;

    tree[id].val = idR[];//每段的初值，根据题目要求

    tree[id].turn = ;

    if (lt == rt)

        return;

    int mid = (lt + rt) >> ;

    build(lt, mid, id<<);

    build(mid + , rt, id<<|);

    //pushUp(id);

}

//修改区间值

void change(int lt, int rt, int id, int v)

{

    if (lt <= tree[id].lt && rt >= tree[id].rt)

    {

        tree[id].val = tree[id].turn = min(tree[id].val, v);

        return;

    }

    pushDown(id);

    int mid = (tree[id].lt + tree[id].rt) >> ;

    if (lt <= mid)

        change(lt, rt, id<<, v);

    if (rt > mid)

        change(lt, rt, id<<|, v);

    //pushUp(id);

}

//查询单点的值

int query(int lt, int rt, int id)

{

    if (lt <= tree[id].lt && rt >= tree[id].rt)

        return tree[id].val;

    pushDown(id);

    int mid = (tree[id].lt + tree[id].rt) >> ;

    if (rt <= mid)

        return query(lt, rt, id<<);

    if (lt > mid)

        return query(lt, rt, id<<|);

}

void input()

{

    initEdge();

    int u, v;

    for (int i = ; i < n; ++i)

    {

        scanf("%d%d", &u, &v);

        addEdge(u, v);

    }

    int num = ;

    dfs(, num);

    build(, n, );

}

void work()

{

    char str[];

    int v;

    for (int i = ; i < m; ++i)

    {

        scanf("%s%d", str, &v);

        if (str[] == 'C')

            change(idL[v], idR[v], , idR[v]);

        else

            printf("%d\n", Hash[query(idR[v], idR[v], )]);

    }

}

int main()

{

    //freopen("test.in", "r", stdin);

    //freopen("test.out", "w", stdout);

    while (scanf("%d%d", &n, &m) != EOF)

    {

        input();

        work();

    }

    return ;

}

代码：（并查集离线查询）

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <set>

#include <map>

#include <queue>

#include <string>

#include <algorithm>

#define LL long long

using namespace std;

const int maxN = ;

int n, m;

int ufs[maxN];

int fa[maxN];

char op[maxN][];

int query[maxN];

int ans[maxN], top;

int findRoot(int x)

{

    int pre, now, rx;

    rx = x;

    while(ufs[rx] != )

        rx = ufs[rx];

    pre = x;

    while(pre != rx)

    {

        now = ufs[pre];

        ufs[pre] = rx;

        pre = now;

    }

    return rx;

}

void input()

{

    memset(ufs, , sizeof(ufs));

    top = ;

    int u, v;

    for (int i = ; i < n; ++i)

    {

        scanf("%d%d", &u, &v);

        ufs[v] = u;

        fa[v] = u;

    }

    for (int i = ; i < m; ++i)

    {

        scanf("%s%d", op[i], &query[i]);

        if (op[i][] == 'C')

        {

            ufs[query[i]] = ;

        }

    }

}

void work()

{

    for (int i = m-; i >= ; --i)

    {

        if (op[i][] == 'C')

        {

            ufs[query[i]] = fa[query[i]];

        }

        else

        {

            ans[top++] = findRoot(query[i]);

        }

    }

    while (top)

    {

        top--;

        printf("%d\n", ans[top]);

    }

}

int main()

{

    //freopen("test.in", "r", stdin);

    //freopen("test.out", "w", stdout);

    while (scanf("%d%d", &n, &m) != EOF)

    {

        input();

        work();

    }

    return ;

}