圆方树学习笔记 例题 uoj30 Tourists

我好像要从双联通分量的阴影中走出来了….

这是我做的第一道有关圆方树的题目 实际上这个东西也不是很难
它让图上的东西能在树上做也就是有了更好的性质

搬一张网上到处都有的图

这张图很形象地说明了圆方树的建树过程

首先对于每一个点双 我们把它新开一个点记为方点，同时删去点双内所有边并用方点对所有点双内原来的点我们称为原点连边。
如果一条边只连接两个点 我们也把它看作点双 在这条边上新建一个方点

首先我们来证明这个东西是树 如果原图联通，新建的图联通块个数肯定不会增加，那么连通性不变，同时建树过程就是保证了点数等于边数加一，那就证明完了

我们来看一道例题吧

#UOJ30 Tourists

题意是支持单点修改，每次询问两点间点不重复路径的最小点权

我们首先把这个图建成圆方树，对于方点权值为它所在点双的权值最小值，每个点开一个 std::multiset s t d :: m u l t i s e t 来维护，询问的话树剖即可

但是这个做法有一个显而易见的问题，如果一个圆点连着很多个方点，岂不是每个都要修改一遍？那这样修改复杂度就爆炸了，我们换一种思维考虑，我们新定义一下方点权值为其子节点中的权值最小值，因为树中一个节点的父亲唯一的性质，我们查询的时候如果 lca l c a 为方点的话再把它父亲的权值统计进答案就够了

时间复杂度 O(nlog2n) O ( n l o g 2 n )

Codes

#include

using namespace std;

template<class T>inline bool chkmin(T &_, T __) {return _ > __ ? _ = __, 1 : 0;}
template<class T>inline bool chkmax(T &_, T __) {return _ < __ ? _ = __, 1 : 0;}

const int N = 1e6 + 10;
int to[N], head[N], nxt[N], e;
int TO[N], HEAD[N], NXT[N], E;
int color, be[N];
vector<int> kuai[N];
multiset<int> w[N];

void add(int x, int y) {
    to[++ e] = y; nxt[e] = head[x]; head[x] = e;
}

void ADD(int x, int y) {
    TO[++ E] = y, NXT[E] = HEAD[x]; HEAD[x] = E;
}

namespace Tarjan {
    int low[N], dfn[N], cnt;
    int Sta[N], top;
    void dfs(int x, int fa) {
        low[x] = dfn[x] = ++ cnt; Sta[++ top] = x;
        for(int i = head[x]; i; i = nxt[i]) {
            if(!dfn[to[i]]) {
                dfs(to[i], x);
                low[x] = min(low[x], low[to[i]]);
                if(low[to[i]] >= dfn[x]) {
                    ++ color;
                    do {
                        be[Sta[top]] = color;
                        kuai[color].push_back(Sta[top]);
                    }while(Sta[top --] != to[i]);
                    kuai[color].push_back(x);
                }
            }
            else if(to[i] != fa)
                low[x] = min(low[x], dfn[to[i]]);
        }
    }
}

int fa[N], dep[N], size[N], heavy[N];
int top[N], id[N], tot, n, rel[N];

void dfs1(int x) {
    size[x] = 1;
    for(int i = HEAD[x]; i; i = NXT[i]) {
        if(dep[TO[i]])
            continue;
        dep[TO[i]] = dep[x] + 1;
        fa[TO[i]] = x;
        dfs1(TO[i]);
        if(x > n) w[x].insert(*w[TO[i]].begin());
        size[x] += size[TO[i]];
        if(size[TO[i]] > size[heavy[x]])
            heavy[x] = TO[i];
    }
}

void dfs2(int x, int ancestor) {
    id[x] = ++ tot; rel[tot] = x;
    top[x] = ancestor;
    if(heavy[x]) dfs2(heavy[x], ancestor);
    for(int i = HEAD[x]; i; i = NXT[i]) 
        if(TO[i] != heavy[x] && TO[i] != fa[x])
            dfs2(TO[i], TO[i]);
}

struct Segment_Tree {
#define ls (bh << 1)
#define rs (ls | 1)
#define mid ((l + r) >> 1)
    int S[N << 2];
    void pushup(int bh) {
        S[bh] = min(S[ls], S[rs]);
    }
    void build(int bh, int l, int r) {
        S[bh] = INT_MAX;
        if(l == r) 
            S[bh] = *w[rel[l]].begin();
        else {
            build(ls, l, mid);
            build(rs, mid + 1, r);
            pushup(bh);
        }
    }
    void update(int bh, int l, int r, int x) {
        S[bh] = INT_MAX;
        if(l == r) {
            S[bh] = *w[rel[x]].begin();
            //cout << x << ' ' << rel[x] << endl;
            //puts("");
        }
        else {
            if(x <= mid) update(ls, l, mid, x);
            else update(rs, mid + 1, r, x);
            pushup(bh);
        }
        //if(S[bh] == 0) cout << l << ' ' << r << endl;
    }
    int query(int bh, int l, int r, int x, int y) {
        int res = INT_MAX;
        if(x <= l && r <= y) 
            res = S[bh];
        else {
            if(x <= mid) res = min(res, query(ls, l, mid, x, y));
            if(y > mid) res = min(res, query(rs, mid + 1, r, x, y));
        }
        return res;
    }
}T;

int main() {
#ifndef ONLINE_JUDGE
    freopen("30.in", "r", stdin);
    freopen("30.out", "w", stdout);
#endif
    int m, q, x, y; char c;
    scanf("%d%d%d", &n, &m, &q);
    for(int i = 1; i <= n; ++ i) {
        scanf("%d", &x);
        w[i].insert(x);
    }
    for(int i = 1; i <= m; ++ i) {
        scanf("%d%d", &x, &y);
        add(x, y), add(y, x);
    }
    Tarjan::dfs(1, 0);
    for(int i = 1; i <= color; ++ i) 
        for(int j = 0, sz = kuai[i].size(); j < sz; ++ j) 
            ADD(i + n, kuai[i][j]), ADD(kuai[i][j], n + i);
    dfs1(dep[1] = 1), dfs2(1, 1);
    T.build(1, 1, n + color);
    for(int i = 1; i <= q; ++ i) {
        cin >> c; scanf("%d%d", &x, &y);
        if(c == 'C') {
            int old = *w[x].begin();
            if(fa[x] > n) {
                w[fa[x]].erase(w[fa[x]].find(old));
                w[fa[x]].insert(y);
                T.update(1, 1, n + color, id[fa[x]]);
            }
            w[x].erase(w[x].find(old));
            w[x].insert(y);
            T.update(1, 1, n + color, id[x]);
        }
        else {
            int ans = INT_MAX;
            while(top[x] != top[y]) {
                if(dep[top[x]] < dep[top[y]]) swap(x, y);
                ans = min(ans, T.query(1, 1, n + color, id[top[x]], id[x]));
                x = fa[top[x]];
            }
            if(dep[x] > dep[y]) swap(x, y);
            ans = min(ans, T.query(1, 1, n + color, id[x], id[y]));
            if(x > n) ans = min(ans, *w[fa[x]].begin());
            printf("%d\n", ans);
        }
    }
    return 0;
}