Codeforces Gym 100814C Connecting Graph (并查集, 树链剖分)

原创 2015年11月21日 20:28:30

题目大意:

就是现在初始的时候有一个只有n个点的图(n <= 1e5), 现在进行m( m <= 1e5 )次操作

每次操作要么添加一条无向边, 要么询问之前结点u和v最早在哪一次操作的时候连通了


大致思路:

这个题表示只想到了O(m*logn*logn)的做法....

首先用并查集维护连通性

当添加边的时候,如果两个点在不同连通块,就选取其连通块的代表结点连一条边, 权值为该操作的编号, 否则不作操作.

那么在n次操作之后, 会得到一个森林

然后我们离线处理询问

如果操作为询问, 则就相当于问树上两个点路径上的最大边权值就是答案(同一连通块, 也就是同一棵树的情况)不在一棵树上就是-1

如果操作为添加边, 那么就把之前的添加的边的权值设置为-1即可

对于边上边权的修改和树的路径的最大边权询问, 树链剖分即可解决

貌似有更简单的方法....不过表示只想到了这个比较明显的做法....并查集只会用来表示连通性好捉急....


代码如下:

Result  :  Accepted     Memory  :  13412 KB     Time  :  638 ms

/*
 * Author: Gatevin
 * Created Time:  2015/11/21 14:02:38
 * File Name: Sakura_Chiyo.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

#define maxn 100010

int top[maxn];
int grandson[maxn];
int dep[maxn];
int siz[maxn];
int belong[maxn];
int father[maxn];
int Q[maxn];
int cnt;
int hson[maxn];

int q, s;
bool vis[maxn];
int T, n, m;
int id[maxn];
int antiID[maxn];

struct Edge
{
    int u, v, w, nex;
    Edge(int _u, int _v, int _w, int _nex)
    {
        u = _u, v = _v, w = _w, nex = _nex;
    }
    Edge(){}
};

int head[maxn];
int tot;
Edge edge[maxn << 1];
int w[maxn];
int idx;

void add_Edge(int x, int y, int w)
{
    edge[++tot] = Edge(x, y, w, head[x]);
    head[x] = tot;
}

void split(int root)
{
    int l = 0, r = 1;
    dep[Q[r] = root] = 1;
    father[root] = -1;
    w[root] = 0;
    while(l < r)
    {
        int x = Q[++l];
        if(head[x] == -1) continue;
        for(int j = head[x]; j + 1; j = edge[j].nex)
        {
            int y = edge[j].v;
            if(y == father[x]) continue;
            w[y] = edge[j].w;
            dep[Q[++r] = y] = dep[x] + 1;
            father[y] = x;
        }
    }
    for(int i = r ; i ; i--)
    {
        int x = Q[i], p = -1;
        siz[x] = 1;
        if(head[x] == -1) continue;
        for(int j = head[x]; j + 1; j = edge[j].nex)
        {
            int y = edge[j].v;
            if(y == father[x]) continue;
            siz[x] += siz[y];
            if(p == -1 || (p > 0 && siz[y] > siz[p]))
                p = y;
        }
        if(p == -1)
        {
            hson[x] = -1;
            grandson[++cnt] = x;
            belong[top[cnt] = x] = cnt;
        }
        else
        {
            hson[x] = p;
            belong[x] = belong[p];
            top[belong[x]] = x;
        }
    }
    //int idx = 0;
    //memset(vis, 0, sizeof(vis));
    for(int i = r; i; i--)
    {
        int x = Q[i];
        if(vis[x]) continue;
        vis[x] = 1;
        id[x] = ++idx;
        antiID[idx] = x;
        while(father[x] != -1 && belong[father[x]] == belong[x] && !vis[father[x]])
        {
            x = father[x];
            id[x] = ++idx;
            antiID[idx] = x;
            vis[x] = 1;
        }
    }
    return;
}

#define lson l, mid, rt << 1
#define rson mid + 1, r , rt << 1 | 1
int val[maxn << 2];

void pushUp(int rt)
{
    val[rt] = max(val[rt << 1], val[rt << 1 | 1]);
    return;
}

void build(int l, int r, int rt)
{
    if(l == r)
    {
        val[rt] = w[antiID[l]];
        return;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    pushUp(rt);
}

void update(int l, int r, int rt, int pos, int value)
{
    if(l == r)
    {
        val[rt] = value;
        return;
    }
    int mid = (l + r) >> 1;
    if(pos <= mid) update(lson, pos, value);
    else update(rson, pos, value);
    pushUp(rt);
    return;
}

int query(int l, int r, int rt, int L, int R)
{
    if(l >= L && r <= R)
        return val[rt];
    int mid = (l + r) >> 1;
    int ret = 0;
    if(mid >= L) ret = max(ret, query(lson, L, R));
    if(mid + 1 <= R) ret = max(ret, query(rson, L, R));
    return ret;
}

int answer(int x, int y)
{
    int ans= 0;
    while(top[belong[x]] != top[belong[y]])
    {
        if(dep[top[belong[x]]] < dep[top[belong[y]]])
            swap(x, y);
        ans = max(ans, query(1, n, 1, id[x], id[top[belong[x]]]));
        x = father[top[belong[x]]];
    }
    if(x == y) return ans;
    if(dep[x] < dep[y]) swap(x, y);
    ans = max(ans, query(1, n, 1, id[x], id[hson[y]]));
    return ans;
}

void change(int x, int w)
{
    x <<= 1;
    int u = edge[x].u, v = edge[x].v;
    if(father[u] == v)
        update(1, n, 1, id[u], w);
    else update(1, n, 1, id[v], w);
    return;
}


struct Op
{
    int type, u, v, fu, fv, edge;
    bool add;
    Op(int _t, int _u, int _v)
    {
        type = _t, u = _u, v = _v;
        add = false;
    }
    Op(){}
};

Op op[maxn];

int fa[maxn];
int find(int x)
{
    return x == fa[x] ? x : fa[x] = find(fa[x]);
}
int E;//添加的边的次数
void Union(int x, int y, int opid)
{
    int fx = find(x);
    int fy = find(y);
    op[opid].fu = fx, op[opid].fv = fy;
    op[opid].add = false;
    if(fx != fy)
    {
        fa[fx] = fy;
        op[opid].add = true;
        op[opid].edge = ++E;
        add_Edge(fx, fy, opid);
        add_Edge(fy, fx, opid);
    }
}

int ans[maxn];

int read()
{
    int x = 0;
    char c;
    while(!isdigit(c = getchar())) continue;
    x = (x << 3) + (x << 1) + c - '0';
    while(isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - '0';
    return x;
}

int sis[maxn];

int main()
{
    //scanf("%d", &T);
    T = read();
    int cas = 0;
    while(T--)
    {
        cas++;
        //scanf("%d %d", &n, &m);
        n = read(), m = read();
        memset(head, -1, sizeof(head));
        tot = 0; E = 0;
        for(int i = 1; i <= n; i++) fa[i] = i;
        for(int i = 1; i <= m; i++)
        {
            //scanf("%d %d %d", &op[i].type, &op[i].u, &op[i].v);
            op[i].type = read(), op[i].u = read(), op[i].v = read();
            if(op[i].type == 1) Union(op[i].u, op[i].v, i);
        }
        idx = 0;
        memset(vis, 0, sizeof(vis));
        cnt = 0;
        for(int i = 1; i <= n; i++)
        {
            int fi = find(i);
            if(sis[fi] != cas)
            {
                split(fi);
                sis[fi] = cas;
            }
        }
        build(1, n, 1);
        for(int i = m; i > 0; i--)
        {
            if(op[i].type == 2)//query
            {
                int u = op[i].u, v = op[i].v;
                if(find(u) != find(v))//一直就是不连通的
                {
                    ans[i] = -1;
                    continue;
                }
                ans[i] = answer(op[i].u, op[i].v);
            }
            else
            {
                if(op[i].add == false) continue;//这个操作没有造成过添加边的影响
                change(op[i].edge, 1e9);
            }
        }
        for(int i = 1; i <= m; i++)
            if(op[i].type == 2)
                printf("%d\n", ans[i] == 1e9 ? -1 : ans[i]);
    }
    return 0;
}


版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

Codeforces Gym 100814C Connecting Graph (并查集, 树链剖分)

题目大意: 就是现在初始的时候有一个只有n个点的图(n 每次操作要么添加一条无向边, 要么询问之前结点u和v最早在哪一次操作的时候连通了 大致思路: 这个题表示只想到了O(m*logn*logn...

[codeforces] Gym - 100814C Connecting Graph (并查集+LCA)

[codeforces] Gym - 100814C Connecting Graph (并查集+LCA)题目大意: 给定n个点, m个操作, 操作由两种形式 1uv1 u v 将u,vu, v...

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

JZOJ 4604 树【NOIP2016模拟7.11】

树题目描述输入格式输出格式样例输入5 5 1 2 1 3 2 4 2 5 Q 2 C 2 Q 2 Q 5 Q 3样例输出1 2 2 1数据范围题解解法一:树链剖分,暴力维护即可...

【TJOI2016&&HEOI2016】树

DescriptionSolution第一眼的链剖维护重链上打过标记的点的下标的最大值就好了。倒着做并查集也可以Code#include #include #include #include #inc...

日常训练 20170606 极地旅行社

题目描述不久之前,Mirko建立了一个旅行社,名叫“极地之梦”。这家旅行社在北极附近购买了 NN 座冰岛,并且提供观光服务。当地最受欢迎的当然是帝企鹅了,这些小家伙经常成群结队的游走在各个冰岛之间。M...

BZOJ1576 洛谷P2934 : [Usaco2009 Jan]安全路经Travel

1576: [Usaco2009 Jan]安全路经TravelDescription Input * 第一行: 两个空格分开的数, N和M * 第2..M+1行: 三个空格分开的数a_i, ...

CodeForces 593D Happy Tree Party(树链剖分(边权) or LCA+并查集)

题意:给你一棵数,n个点n-1条边,每条边有个权值,q次询问,询问有两种: 1 a b y : a到b的路径上不断进行y = y/xi(像下取整),问最后y的值 2 p c :  将第p条边的权值改为...

codeforces #329 D. Happy Tree Party (LCA+并查集 || 树链剖分)

题目:http://codeforces.com/contest/593/problem/D 题意:给定一棵n个节点的树。有两种操作:①给定 u v p, 求p除u--->v这条链上所有的边权的值(...

codeforces 593D happy tree party 树链剖分

/* 题目描述:给定一棵树及其边权,有两种操作 1 u v y 用y依次去除uv的公共路径上的每一条边的边权,注意这里的除法是整数的除法 2 x p 把第x条输入边的边权变为p ...

codeforces 592D 树链剖分

题意:给一棵树,边上有权值,有两种操作 1 a b f 输出f div(a、b两点间的路径权值和)  向下取整 2 a f  把第a条边的权值修改为f~~~ 一开始就想到是树链剖分,但是...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)