hdu 3726 Graph and Queries (Treap应用，名次树)

最新推荐文章于 2021-08-30 14:40:23 发布
最新推荐文章于 2021-08-30 14:40:23 发布
阅读量712 收藏
点赞数
分类专栏： ACM.数据结构 文章标签： Treap 名次树 离线算法 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slowlight93/article/details/39770969
版权

名次树还是比较容易理解的。这道题经典主要在于可以用并查集来维护连通的点，并且使用离线算法，倒过来处理，把分开变成了合并！！

PS: 虽然这道题不存在这个问题。但有时，可能remove不存在的值，如果不先find就可能会爆栈。。（因为一直找不到->一直找）

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <set>
#include <limits>
using namespace std;

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, s, t) for(int (i)=(s);(i)<=(t);++(i))
#define UREP(i, s, t) for(int (i)=(s);(i)>=(t);--(i))
#define REPOK(i, s, t, o) for(int (i)=(s);(i)<=(t) && (o);++(i))

#define MAXN 100
#define MAXM 10000
#define MOD 10000007

#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398

typedef long long LL;

const double maxdouble = numeric_limits<double>::max();
const double eps = 1e-10;
const int INF = 0x7FFFFFFF;

//Treap
// 每个节点有两个属性：rank和value
// 按照rank 这是一个堆
// 按照value 是一颗排序二叉树
//节点定义
typedef struct Node {
    Node *ch[2];
    int r;  // rank
    int v;  // value
    int s;  // size 名次树中子树结点个数

    int cmp(int x) const {
        if (x == v) return -1;
        return x < v ? 0 : 1;
    }
    void maintain() {
        s = 1;
        if (ch[0] != NULL) s += ch[0]->s;
        if (ch[1] != NULL) s += ch[1]->s;
    }
}TreapNode;
class Treap {
public:
    void insert(TreapNode* &o, int x) {
        if (o == NULL) {
            //o = new TreapNode();
            //o->ch[0] = o->ch[1] = NULL;
            //o->v = x;
            //o->r = rand();
            //o->s = 1;
            make_node(o, x);
        } else {
            //int d = o->cmp(x);
            int d = o->v > x ? 0 : 1; // 名次数中的v可能重复
            insert(o->ch[d], x);
            if (o->ch[d]->r > o->r)
                rotate(o, d^1);
        }
        o->maintain();
    }
    // 两棵子树：先把优先级较高的旋转到根
    // 然后在另一棵子树中递归删除x
    void remove(TreapNode* &o, int x) {
        int d = o->cmp(x);
        if (d == -1) {
            TreapNode* u = o;
            if (o->ch[0] == NULL) {
                o = o->ch[1];
                delete u;
            } else if (o->ch[1] == NULL) {
                o = o->ch[0];
                delete u;
            } else {
                if (o->ch[0]->r > o->ch[1]->r) {
                    d = 1;
                } else {
                    d = 0;
                }
                rotate(o, d);
                remove(o->ch[d], x);
            }
        } else {
            remove(o->ch[d], x);
        }
        if(o != NULL) o->maintain();
    }
    // 求第k大的值 0表示不存在
    int kth(TreapNode* o, int k) {
        if (o == NULL || k <= 0 || k > o->s) return 0;
        int s = o->ch[1] == NULL ? 0 : o->ch[1]->s;
        if (k == s+1) return o->v;
        else if (k <= s) return kth(o->ch[1], k);
        else return kth(o->ch[0], k-s-1);
    }
    void make_node(TreapNode* &o, int x) {
        o = new TreapNode();
        o->ch[0] = o->ch[1] = NULL;
        o->r = rand();
        o->s = 1;
        o->v = x;
    }
    void destroy(TreapNode* &o) {
        if (o->ch[0] != NULL) destroy(o->ch[0]);
        if (o->ch[1] != NULL) destroy(o->ch[1]);
        delete o;
        o = NULL;
    }

private:
        // 旋转操作：d=0左转 d=1右转
    void rotate(TreapNode* &o, int d) {
        TreapNode* k = o->ch[d^1];o->ch[d^1] = k->ch[d];k->ch[d] = o;
        // o成为k的子树 而k的另一个子树没发生变化
        // 所以先维护o 在维护k
        o->maintain();
        k->maintain();
        o = k;
    }
};

struct Command{
    char c;
    int param1;
    int param2;
};

const int maxn = 20000;
const int maxm = 60000;
const int maxc = 600000;

int n, m;
Command cmds[maxc+5];
int from[maxm + 5];
int to[maxm + 5];
bool removed[maxm + 5];
int w[maxn + 5];
//Treap
Treap treap;
TreapNode* root[maxn + 5];
// Union-find
int pa[maxn + 1];
int findset(int x) {
    return pa[x] == x ? x : pa[x] = findset(pa[x]);
}

void mergeto(TreapNode* &src, TreapNode* &dst) {
    if (src->ch[0] != NULL) mergeto(src->ch[0], dst);
    if (src->ch[1] != NULL) mergeto(src->ch[1], dst);
    treap.insert(dst, src->v);
    delete src;
    src = NULL;
}

int main() {
    //freopen("input.in", "r", stdin);
    char ch;
    int cases = 0, x, y;
    while(scanf("%d%d",&n,&m) == 2 && (n || m)) {
        memset(removed, false, sizeof(removed));
        REP(i, 1, n) scanf("%d", &w[i]);
        REP(i, 1, m) scanf("%d%d",&from[i], &to[i]);
        int cnt = 0;
        for(;;) {
            for(;;) {
                scanf("%c",&ch);
                if (isalpha(ch))
                    break;
            }
            cmds[cnt].c = ch;
            if (ch == 'E') break;
            if (ch == 'D') {
                scanf("%d",&x);
                removed[x] = true;
                cmds[cnt].param1 = x;
            } else if(ch == 'Q') {
                scanf("%d%d",&x, &y);
                cmds[cnt].param1 = x;
                cmds[cnt].param2 = y;
            } else {
                scanf("%d%d",&x, &y);
                cmds[cnt].param1 = x;
                cmds[cnt].param2 = w[x];
                w[x] = y;
            }
            ++cnt;
        }

        REP(i, 1, n) treap.make_node(root[i], w[i]);

        REP(i, 1, n) pa[i] = i;
        REP(i, 1, m)
            if (!removed[i]) {
                x = findset(from[i]);
                y = findset(to[i]);
                if (x != y) {
                    if (root[x]->s < root[y]->s) {
                        mergeto(root[x], root[y]);
                        pa[x] = y;
                    } else {
                        mergeto(root[y], root[x]);
                        pa[y] = x;
                    }
                }
            }
        LL sum = 0;
        int query_cnt = 0;
        UREP(i, cnt-1, 0) {
            if (cmds[i].c == 'D') {
                int e = cmds[i].param1;
                int x = findset(from[e]), y = findset(to[e]);
                if (x != y) {
                    if (root[x]->s < root[y]->s) {
                        mergeto(root[x], root[y]);
                        pa[x] = y;
                    } else {
                        mergeto(root[y], root[x]);
                        pa[y] = x;
                    }
                }
            } else if (cmds[i].c == 'C') {
                int x = cmds[i].param1;
                int v = cmds[i].param2;
                int fa = findset(x);
                treap.remove(root[fa], w[x]);
                treap.insert(root[fa], v);
                w[x] = v;
            } else {
                int x = findset(cmds[i].param1);
                int k = cmds[i].param2;
                ++query_cnt;
                sum += treap.kth(root[x], k);
            }
        }
        printf("Case %d: %.6f\n",++cases, sum/(double)query_cnt);

        REP(i, 1, n)
            if (root[i] != NULL) treap.destroy(root[i]);
    }

    return 0;
}
使用真实指针null代替NULL的版本 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <set>
#include <limits>
using namespace std;

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, s, t) for(int (i)=(s);(i)<=(t);++(i))
#define UREP(i, s, t) for(int (i)=(s);(i)>=(t);--(i))
#define REPOK(i, s, t, o) for(int (i)=(s);(i)<=(t) && (o);++(i))

#define MAXN 100
#define MAXM 10000
#define MOD 10000007

#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398

typedef long long LL;

const double maxdouble = numeric_limits<double>::max();
const double eps = 1e-10;
const int INF = 0x7FFFFFFF;

//Treap
// 每个节点有两个属性：rank和value
// 按照rank 这是一个堆
// 按照value 是一颗排序二叉树
//节点定义
typedef struct Node {
    Node *ch[2];
    int r;  // rank
    int v;  // value
    int s;  // size 名次树中子树结点个数

    int cmp(int x) const {
        if (x == v) return -1;
        return x < v ? 0 : 1;
    }
    void maintain() {
        s = ch[0]->s + ch[1]->s + 1;
    }
}TreapNode;
class Treap {
public:
    Treap() {
        null = new TreapNode();
        null->ch[0] = null->ch[1] = null;
        null->s = 0;}
    ~Treap(){delete null;}
    void insert(TreapNode* &o, int x) {
        if (o == null) {
            //o = new TreapNode();
            //o->ch[0] = o->ch[1] = null;
            //o->v = x;
            //o->r = rand();
            //o->s = 1;
            make_node(o, x);
        } else {
            //int d = o->cmp(x);
            int d = o->v > x ? 0 : 1; // 名次数中的v可能重复
            insert(o->ch[d], x);
            if (o->ch[d]->r > o->r)
                rotate(o, d^1);
        }
        o->maintain();
    }
    // 两棵子树：先把优先级较高的旋转到根
    // 然后在另一棵子树中递归删除x
    void remove(TreapNode* &o, int x) {
        int d = o->cmp(x);
        if (d == -1) {
            TreapNode* u = o;
            if (o->ch[0] == null) {
                o = o->ch[1];
                delete u;
            } else if (o->ch[1] == null) {
                o = o->ch[0];
                delete u;
            } else {
                if (o->ch[0]->r > o->ch[1]->r) {
                    d = 1;
                } else {
                    d = 0;
                }
                rotate(o, d);
                remove(o->ch[d], x);
            }
        } else {
            remove(o->ch[d], x);
        }
        if(o != null) o->maintain();
    }
    // 求第k大的值 0表示不存在
    int kth(TreapNode* o, int k) {
        if (o == null || k <= 0 || k > o->s) return 0;
        int s = o->ch[1] == null ? 0 : o->ch[1]->s;
        if (k == s+1) return o->v;
        else if (k <= s) return kth(o->ch[1], k);
        else return kth(o->ch[0], k-s-1);
    }
    void make_node(TreapNode* &o, int x) {
        o = new TreapNode();
        o->ch[0] = o->ch[1] = null;
        o->r = rand();
        o->s = 1;
        o->v = x;
    }
    void destroy(TreapNode* &o) {
        if (o == null) return;
        if (o->ch[0] != null) destroy(o->ch[0]);
        if (o->ch[1] != null) destroy(o->ch[1]);
        delete o;
        o = null;
    }

    TreapNode* null;
private:
        // 旋转操作：d=0左转 d=1右转
    void rotate(TreapNode* &o, int d) {
        TreapNode* k = o->ch[d^1];o->ch[d^1] = k->ch[d];k->ch[d] = o;
        // o成为k的子树 而k的另一个子树没发生变化
        // 所以先维护o 在维护k
        o->maintain();
        k->maintain();
        o = k;
    }
};

struct Command{
    char c;
    int param1;
    int param2;
};

const int maxn = 20000;
const int maxm = 60000;
const int maxc = 600000;

int n, m;
Command cmds[maxc+5];
int from[maxm + 5];
int to[maxm + 5];
bool removed[maxm + 5];
int w[maxn + 5];
//Treap
Treap treap;
TreapNode* root[maxn + 5];
// Union-find
int pa[maxn + 1];
int findset(int x) {
    return pa[x] == x ? x : pa[x] = findset(pa[x]);
}

void mergeto(TreapNode* &src, TreapNode* &dst) {
    if (src->ch[0] != treap.null) mergeto(src->ch[0], dst);
    if (src->ch[1] != treap.null) mergeto(src->ch[1], dst);
    treap.insert(dst, src->v);
    delete src;
    src = treap.null;
}

int main() {
    freopen("input.in", "r", stdin);

    char ch;
    int cases = 0, x, y;
    while(scanf("%d%d",&n,&m) == 2 && (n || m)) {
        memset(removed, false, sizeof(removed));
        REP(i, 1, n) scanf("%d", &w[i]);
        REP(i, 1, m) scanf("%d%d",&from[i], &to[i]);
        int cnt = 0;
        for(;;) {
            for(;;) {
                scanf("%c",&ch);
                if (isalpha(ch))
                    break;
            }
            cmds[cnt].c = ch;
            if (ch == 'E') break;
            if (ch == 'D') {
                scanf("%d",&x);
                removed[x] = true;
                cmds[cnt].param1 = x;
            } else if(ch == 'Q') {
                scanf("%d%d",&x, &y);
                cmds[cnt].param1 = x;
                cmds[cnt].param2 = y;
            } else {
                scanf("%d%d",&x, &y);
                cmds[cnt].param1 = x;
                cmds[cnt].param2 = w[x];
                w[x] = y;
            }
            ++cnt;
        }

        REP(i, 1, n) treap.make_node(root[i], w[i]);

        REP(i, 1, n) pa[i] = i;
        REP(i, 1, m)
            if (!removed[i]) {
                x = findset(from[i]);
                y = findset(to[i]);
                if (x != y) {
                    if (root[x]->s < root[y]->s) {
                        mergeto(root[x], root[y]);
                        pa[x] = y;
                    } else {
                        mergeto(root[y], root[x]);
                        pa[y] = x;
                    }
                }
            }

        LL sum = 0;
        int query_cnt = 0;
        UREP(i, cnt-1, 0) {
            if (cmds[i].c == 'D') {
                int e = cmds[i].param1;
                int x = findset(from[e]), y = findset(to[e]);
                if (x != y) {
                    if (root[x]->s < root[y]->s) {
                        mergeto(root[x], root[y]);
                        pa[x] = y;
                    } else {
                        mergeto(root[y], root[x]);
                        pa[y] = x;
                    }
                }
            } else if (cmds[i].c == 'C') {
                int x = cmds[i].param1;
                int v = cmds[i].param2;
                int fa = findset(x);
                treap.remove(root[fa], w[x]);
                treap.insert(root[fa], v);
                w[x] = v;
            } else {
                int x = findset(cmds[i].param1);
                int k = cmds[i].param2;
                ++query_cnt;
                sum += treap.kth(root[x], k);
            }
        }
        printf("Case %d: %.6f\n",++cases, sum/(double)query_cnt);

        REP(i, 1, n) treap.destroy(root[i]);
    }

    return 0;
}


slowlight93
关注
专栏目录
数据结构之Treap、RankTree（名次树）
阿飝的博客
09-09 1591
一、Treap 简单地说，Treap是一棵拥有键值、优先级两种权值的树。对于键值而言，它是BST，对于优先级而言，它是堆。它的插入、删除和查找的期望时间复杂度均为O(log n) 它在插入的时候，随机生成一个优先级，首先根据键值以BST的方式插入到Treap里，然后通过BST的旋转来维护优先级堆的性质，而旋转本身是不会破坏BST的性质的，这就保证了插入完成之后，仍然是一棵Treap 其它的没...
Treap树模板 hdu-4585
Lee's blog
09-13 586
目录 例题：hdu 4585 Treap树 1、Treap树的唯一性 2、Treap树的平衡问题 3、Treap树的数据结构 4、Treap树的插入 5、插入过程中维护堆的过程中用到的旋转 6、寻找第k大的数 O(logn) 7、查询某个数的名次 O(logn) 8、hdu 4585 AC代码 例题：hdu 4585 Treap树 是一种简单的平衡二叉搜索...
HDU 3726 Graph and Queries treap树
嗯。
09-01 1372
题目来源：HDU 3726 Graph and Queries 题意：见白书 思路：刚学treap 参考白皮书 #include #include #include using namespace std; struct Node { Node *ch[2]; int r; int v; int s; Node(int v): v(v) { ch[0] = ch[1]
HDU 3726 Graph and Queries(treap)
LJ__
04-04 374
treap
HDU3726 - Graph and Queries
ayw1069的博客
03-09 214
Portal Description 给出一个\(n(n\leq2\times10^4)\)个点，\(m(m\leq6\times10^4)\)条边的有点权无向图。进行若干次操作： 删除第\(i\)条边。 求与点\(u\)连通的所有点中，权值第\(k\)大的点的权值。 将点\(u\)的权值改为\(x\)。 Solution 将操作离线，并从终止状态开始反向操作：删边变为加边，将权值由...
hdu 3726
weixin_30602505的博客
09-11 247
大白书上的一道题。 离线，倒着操作。 这样删除就会变成合并两颗树。 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <algorithm> 5 #include <vector> ...
Treap树的随机优先级策略与并查集应用
本资源主要介绍了Treap树如何解决平衡问题以及其在数据结构中的应用。Treap树是一种结合了优先队列（堆）特性和二叉搜索树（BST）性质的自平衡二叉查找树。在Treap树中，每个节点除了包含键值之外，还额外有一个...
【题解】「HDU1166」敌兵布阵(线段树)
01-20
题面 【题目描述】 有nnn个营地，已知每个营地的人数，有四条命令： (1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正...
2017CCPC女生赛 hdu 6029 Graph Theory
萌の上揺れ
05-17 593
题目链接分析： 只是瞎构造了一下，从后面往前扫，如果遇到2，那么需要找后面的cnt里找一个配对，cnt–，如果遇到一个1，那么计入cnt。 如果n是奇数就不可行。代码：#include <iostream> #include <cstdio> #include <vector> #include <cstring> #include <stack> #include <queue>using n
hdu.rar_hdu
09-23
3. **数据结构**：数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图（邻接矩阵、邻接表、最小生成树、拓扑排序等）。 4. **字符串处理**：KMP算法、Manacher's Algorithm、Rabin-Karp算法等。 5. **...
UVALive 5031 Graph and Queries （Treap）
weixin_34260991的博客
09-13 94
删除边的操作不容易实现，那么就先离线然后逆序来做。 逆序就变成了合并，用并存集判断连通，用Treap树来维护一个连通分量里的名次。 Treap = Tree + Heap。用一个随机的优先级来平衡搜索树。 名次查询需要维护树的结点数量，假设当前在u点，u的左子树有n个结点，那么u的就是以u为根的树上第n+1小的。 如果查询的不是n+1，那么根据结点数量判断一下在哪颗子树上，然后去查询。 ...
[HDU3726]Graph and Queries
Q882199的博客
10-10 193
Problem 给你一张图，点的权值，边和几个操作: D x: 删除第x条边 Q x y: 询问包含x的联通块中权值第y大的权值 C x y: 将x这个点的权值改为y Solution 一看就要离线处理，把所有操作都倒过来 然后删除操作变为加边操作 Notice 记得: 是改完以后再把点一个一个加入Treap中！！ Code 非旋转Treap #pragma GCC optimize(2...
hdu3726
xuwnehao的博客
08-30 135
离线：统计完所有输入数据在处理问题 treap树 #include<iostream> #include<cstdlib> #include<cstdio> #include<cstring> #include<vector> #include<algorithm> using namespace std; struct node{ node *ch[2]; int s,v; int r; node (int v):v(
HDU 3726 Graph and Queries (Treap)
= =
09-20 1212
题意： 给出一幅无向图，点有权，要求支持： 1，删边 2，询问与点u相连的第k大点的权值 （注意k可能不合法） 3，修改一个点权 输出操作2中的权值总和除以操作2的数量。 解法： 离线，用Treap维护第k大，把所有操作倒过来做，那么删边就变成合并连通块，注意修改点权的操作在离线前需要先处理。 /* Created Time: 2013年09月20日 星期五 06时16分58秒 *
hdu3726：Graph and Queries（treap+启发式合并+离线）
KsCla
04-17 974
题目传送门：http://acm.hdu.edu.cn/showproblem.php?pid=3726 题目大意：给出一幅无向边构成的图，每个点有一个点权。有3种操作：删掉一条边，更改一个点的点权，以及查询一个点所在的连通块的第k大点权。 分析：这里我们可以通过对每一个连通块维护一棵treap在log(n)的时间内完成操作2,3，至于操作1，我们发现分离比较难办，于是我们考虑离线读入，然后从
hdu3726 Graph and Queries
生活不易，多才多艺
02-24 323
hdu3726 题意呢就是说，给你一个n个点m条边的..东西？然后有三种操作，第一个删除第x条边，第二个查询与x联通的第k大的数，第三个把第x点的值改为v 看到第二个和第三个..能知道用并查集维护会很开心，然后并查集并不能支持删除（我不会..不过好像也可以？？？），就又又又不是很开心了。不过我们再看数据，发现只有删除而没有插入，所以有一个很妙的方法——离散做！倒着做！ ps：预处理好麻烦诶，...
hdu 3726 （数据结构综合（好题））
一个人的生活
10-17 1388
题目链接 LRJ白书上的例题， 最近复习数据结构时又A了一遍这题， 此题很经典同时考察了数据结构中的离线，平衡树， 并查集， 启发式合并等多个常用技巧， 其中离线将所有操作反向处理值得回味， 详细讲解可以看白书。 #include #include #include #include #include using namespace std; inline int read(
【HDU】3726 Graph and Queries
weixin_30595035的博客
08-19 86
1 #include<cstdio> 2 #include<iostream> 3 #define MAXN 400010 4 #define PushUp(x) num[x] = num[next[x][0]] + num[next[x][1]] + 1; 5 using namespace std; 6 pair<int, i...
数据结构之--Treap（hdu3726）
nucshiyilang的博客
07-18 375
//可以用来求区间第K大。下一步，深入了解spaly #include using namespace std; typedef long long ll; int w[20010],vis[60010],pre[20010],cnt,n,m; ll ans;int num; struct p1{int a,b;}edge[60010]; struct pp{int x,p;char op;}c
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值