树分治入门 POJ1741,hdu5977

最新推荐文章于 2022-09-07 17:16:34 发布
最新推荐文章于 2022-09-07 17:16:34 发布
阅读量367 收藏
点赞数
分类专栏： 图论初步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cww97/article/details/77506430
版权

经常发现一些布布扣一类的网站直接爬csdn的blog，娘的

原文地址在这http://blog.csdn.net/cww97/article/details/77506430

树分治讲解

对于树上的路径问题，一种高效的处理方式就是分治算法。关于树分治算法的研究，详见2009年IOI国家集训队论文——《分治算法在树的路径问题中的应用》。
通常对于树上的分治算法有两种，第一种是针对点进行的分治，另一种是针对边进行的分治，可以证明，大部分情况下点分治算法的性能更加稳定，而边分治在某些情况下，算法效率非常低。所以以下主要讨论点分治。
如POJ-1741,求解一棵树中路径长度不大于K的有多少点对。
对于一棵有根树，树中满足对所对应的一条路径，必然是以下两种情况之一：
1.经过根节点
2.路径在以根节点某个儿子为根的一棵子树中
对于情况2，可以递归求解，下面主要来考虑情况1.
那么对于这道题的情况1，设dis[i]为节点i到根的距离，我们就是要求解有多少对经过根的路径，那么问题等价于能找到多少对不同的点对(i,j)，使得dis[i]+dis[j]<=k，而且i和j要属于以当前根的两个不同的儿子为根的子树中。
将问题转化以下，就可以发现所求结果等价于在一棵有根树中找到的点对数x-在以当前根的儿子为根的子树所找到的点对数。
求X、Y的过程均可以转化为以下问题：已知A[1],A[2],…A[m]，求满足i

poj1741

论文里第一道例题

参考了网上的两个板

kuangbin的solve写的很csy，这一部分用了这个

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e4 + 7;
const int INF = 0x3f3f3f3f;
int n, k, ans;

struct Edge{
    int from, to, w, nxt;
    Edge(){}
    Edge (int f, int t, int _w, int n):from(f),to(t),w(_w),nxt(n){}
} edges[N * 2];
bool vis[N];
int head[N], E, siz[N], dep[N];

void Init(){
    E = 0;
    memset(head, -1, sizeof(head));
    memset(vis, false, sizeof(vis));
}
void AddEdge(int u,int v,int w){
    edges[E] = Edge(u, v, w, head[u]);
    head[u] = E++;
}

int dfssize(int u, int pre){
    siz[u] = 1;
    for(int i = head[u]; i != -1; i = edges[i].nxt){
        Edge &e = edges[i];
        if(e.to == pre || vis[e.to])continue;
        siz[u] += dfssize(e.to, u);
    }
    return siz[u];
}

//找重心
void dfsroot(int u, int pre, int totnum, int &minn, int &root){
    int maxx = totnum - siz[u];
    for (int i = head[u]; i != -1;i = edges[i].nxt){
        Edge &e = edges[i];
        if(e.to == pre || vis[e.to]) continue;
        dfsroot(e.to, u, totnum, minn, root);
        maxx = max(maxx, siz[e.to]);
    }
    if(maxx < minn){minn = maxx; root = u;}
}

//求每个点离重心的距离
void dfsdep(int u,int pre,int dist, int &num){
    dep[num++] = dist;
    for(int i = head[u]; i != -1; i = edges[i].nxt){
        Edge &e = edges[i];
        if(e.to == pre || vis[e.to])continue;
        dfsdep(e.to, u, dist + e.w, num);
    }
}

//计算以u为根的子树中有多少点对的距离小于等于K
int calc(int u, int d){
    //printf("calc(%d, %d)\n", u, d);
    int ans = 0, num = 0;
    dfsdep(u, -1, d, num);
    sort(dep, dep + num);
    int i = 0, j = num - 1;
    for (; i < j; i++){
        while (dep[i]+dep[j]>k && i<j) j--;
        ans += j - i;
    }
    return ans;
}

void solve(int u){
    int Max = N, root, minn = INF;
    int totnum = dfssize(u, -1);
    dfsroot(u, -1, totnum, minn, root);
    ans += calc(root, 0);
    vis[root] = 1;
    for(int i = head[root]; i != -1; i = edges[i].nxt){
        Edge &e = edges[i];
        if (vis[e.to]) continue;
        ans -= calc(e.to, e.w);
        solve(e.to);
    }
}

int main(){
    ///freopen("in.txt","r",stdin);
    int u, v, w;
    for (; ~scanf("%d%d", &n, &k) && (n|k);){
        Init();
        for(int i = 1; i < n; i++){
            scanf("%d%d%d", &u, &v, &w);
            AddEdge(u, v, w);
            AddEdge(v, u, w);
        }
        ans = 0;
        solve(1);
        printf("%d\n", ans);
    }
    return 0;
}

2016ICPC大连 hdu5977

现场的时候k = 7，树形dp可以水过，重现赛的时候k改为了10

需要树分治，裸的树分治（如上），统计距离小于等于k的点对数

本题问路径经包含所有颜色的点对数

利用位运算状压，k种颜色，k<=10，每种颜色占一位

原题转化为统计路径 or运算和 == fullk的点对数

fullk = (1<<k) - 1;

poj1741通过一个sort和两个指针统计出了dist<=k的点对数

这里是二进制位，sort不灵了，需要另一种nlogn的方案

对于每点u的状态dep[u]，枚举其每个子集s0，ans += hash[fullk ^ so]

枚举子集一开始也不会，很玄学，这里有一些讲解，骚到了

这里写图片描述

位运算状压其实很好想，把原来的加号改成or运算就好了

很骚的一段就是calc中的一段，从这里再次盗个图来，举了个枚举子集的例子

这里写图片描述

我见他代码第一行是

/**此代码借鉴了某大神的，我看懂了后又分析的*/

似乎他也参考了这个blog

扯了一堆有的没的

最后贴自己的代码吧，用上题的板子改，dfsdep和dfs看着改就好，calc动些脑子

#include <map>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 5e4 + 7;
const int INF = 0x3f3f3f3f;
int n, k;
LL ans;
int col[N], fullk;
LL hashS[1200];

struct Edge{
    int from, to, w, nxt;
    Edge(){}
    Edge (int f, int t, int _w, int n):from(f),to(t),w(_w),nxt(n){}
} edges[N * 2];
bool vis[N];
//本题中边无w，dep为节点到root col or运算和
int head[N], E, siz[N], dep[N];

void Init(){
    E = 0; fullk = (1<<k) - 1;
    memset(head, -1, sizeof(head));
    memset(vis, false, sizeof(vis));
}
void AddEdge(int u,int v,int w){
    edges[E] = Edge(u, v, w, head[u]);
    head[u] = E++;
}

int dfssize(int u, int pre){
    siz[u] = 1;
    for(int i = head[u]; i != -1; i = edges[i].nxt){
        Edge &e = edges[i];
        if(e.to == pre || vis[e.to])continue;
        siz[u] += dfssize(e.to, u);
    }
    return siz[u];
}

//找重心
void dfsroot(int u, int pre, int totnum, int &minn, int &root){
    int maxx = totnum - siz[u];
    for (int i = head[u]; i != -1;i = edges[i].nxt){
        Edge &e = edges[i];
        if(e.to == pre || vis[e.to]) continue;
        dfsroot(e.to, u, totnum, minn, root);
        maxx = max(maxx, siz[e.to]);
    }
    if(maxx < minn){minn = maxx; root = u;}
}

//求每个点离重心的距离
void dfsdep(int u, int pre, int dist, int &num){
    //printf("u = %d, num = %d, dist = %d\n", u, num, dist);
    dep[num++] = dist;
    for(int i = head[u]; i != -1; i = edges[i].nxt){
        Edge &e = edges[i];
        if(e.to == pre || vis[e.to])continue;
        dfsdep(e.to, u, dist | (1<<col[e.to]), num);
    }
}

//计算以u为根的子树中有多少点对的距离小于等于K, 经过u
LL calc(int u, int d){ //d为基础距离
    //printf("calc(%d, %d)\n", u, d);
    LL ans = 0;
    int num = 0;
    dfsdep(u, -1, d, num);
    memset(hashS, 0, sizeof(hashS));
    for (int i = 0; i < num; i++) hashS[dep[i]]++;
    for (int i = 0; i < num; i++){
        hashS[dep[i]]--;
        ans += hashS[fullk];
        for (int s0 =  dep[i]; s0; s0 = (s0-1) & dep[i]){
            ans += hashS[fullk ^ s0];
        }
        hashS[dep[i]]++;
    }
    return ans;
}

void dfs(int u){
    int root, minn = INF;
    int totnum = dfssize(u, -1);
    dfsroot(u, -1, totnum, minn, root);
    //printf("---------> root = %d\n", root);
    ans += calc(root, 1<<col[root]);
    //printf("ans = %d\n", ans);
    vis[root] = 1;
    for(int i = head[root]; i != -1; i = edges[i].nxt){
        Edge &e = edges[i];
        if (vis[e.to]) continue;
        ans -= calc(e.to, (1<<col[root]) | (1<<col[e.to])); //减去重复部分，即没必要经过u的
        //printf("ans = %d\n", ans);
        dfs(e.to);                             //在下一层dfs中解决
    }
}

int main(){
    //freopen("in.txt", "r", stdin);
    int u, v;
    for (; scanf("%d%d", &n, &k) == 2;){
        Init();
        for (int i = 1; i <= n; i++) {
            scanf("%d", &col[i]);
            col[i]--;
        }
        for (int i = 1; i < n; i++){
            scanf("%d%d", &u, &v);
            AddEdge(u, v, 0);
            AddEdge(v, u, 0);
        }
        ans = 0;
        if (k == 1) ans = (LL)n * (LL)n;
        else dfs(1);
        printf("%lld\n", ans);
    }
    return 0;
}

一个子集枚举的小题目

poj2531，给个20个点的图，问最小割

还有点迷糊这个怎么就能剪枝了

#include <cstdio>
#include <algorithm>
using namespace std;

int main(){
    int n, g[20][20];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            scanf("%d", &g[i][j]);
    int ans = 0;
    //剪枝就是把i++改成了i+=2，让i总是奇数
    for(int i = 1; i < (1<<n); i += 2){
        int sum = 0;
        for (int j = 0; j < n; j++) if (i & (1<<j)){
            for(int k = 0; k < n; k++)
                if ((~i) & (1<<k)) sum += g[j][k];
        }
        ans = max(ans, sum);
    }
    printf("%d\n", ans);
    return 0;
}

这题正解好像是dfs

不过，随机化乱搞似乎也可以，乱搞好玩啊，here

操作1e5次
对于每一次操作，随机选择一个点，把他放到另一个集合里面去，然后for一遍，算出当前的割值sum，再与记录的最大值ans比较更新

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int n, g[22][22];
bool go[22];

int main(){
    for (; ~scanf("%d", &n);){
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                scanf("%d", &g[i][j]);

        memset(go, 0, sizeof(0));
        int _ = 1e5, sum = 0, ans = 0;
        for (; _--;){
            int t = rand() % n;
            go[t] ^= 1;
            for (int i = 0; i < n; i++){
                if (go[t] ^ go[i]) sum += g[t][i];
                else sum -= g[t][i];
            }
            ans = max(sum, ans);
        }
        printf("%d\n", ans);
    }
    return 0;
}
伟大的蚊子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu oj poj 题目代码与详解
09-08
很多经典的杭电oj与poj习题的ac代码与详解!全部ac,决对没有错误的代码!
树的分治
shi_zi_183的博客
08-20 612
树的分治 树的分治分为两种：点分治、边分治。 点分治：点分治就是每次找到重心，然后把重心去掉，对分成的每两棵树之间分别统计路径信息（以重心的每个相邻点为根，遍历整棵子树即可得到这个根到每个结点的统计信息），就可以知道包含这个重心的所有路径的信息，然后对于剩下的路径就是在子树里面进行同样的操作了，直到只剩一个点为止（注意这一个点所构成的路径有时也要处理一下）。 边分治：边分治就是每次找到一条边，使得删掉这条边后分成的两棵子树大小尽可能平均，然后以删掉的边的两端点为根，分别统计根到两棵树中的每个结点的路径信息，
树上分治详解 超级详细（附带例题 poj1741（给了题目））
gronkie的博客
11-02 330
#include <iostream> #include <stdio.h> #include <vector> #include <algorithm> #define INF 1000000005 using namespace std; struct edge { int to, length; edge(int t, int l) { to = t; length = l; } }; vector<
点分治(树分治)详解
yyh_getAC的博客
09-07 1058
点分治，又叫树分治，顾名思义，点分治就是在树上进行分治并统计答案的一种方式。此前我们就有涉及过分治的思想：将原问题分解成若干相同形式、相互独立的子问题，并逐个干掉。
（动态）树分治 学习笔记
531 の 流 水 线
06-30 232
浅谈一下学了好久的树分治。适合处理大规模树上路径信息问题。P3806 【模板】点分治1很基础的了，询问树上距离为 kkk 的点对是否存在。大概就是每次找重心当作根，对于当前的根，统计每个子节点到它的距离，然后用双指针遍历，当且仅当两个儿子到当前根的距离之和为 kkk 且来自根的不同子树时，这两个子节点的距离就为 kkk，那么距离为 kkk 的点对存在。 另一道类似的升级题：P4178 Tree。题意变为求出树上两点距离小于等于 kkk 的点对数量。思路差不多，不过是在遍历统计答案的时候使用双指针统计答案，即
树分治
slark_的博客
07-16 1027
什么是分治算法： 分治算法的思想是将一个规模为N的问题分解为K个规模的较小的子问题，这些子问题相互独立且与原问题性质相同。求出这些问题的解后再将这些子问题的解合并，就可以得到原问题的解。例如快速排序和归并排序。 所谓树分治，就是在树形结构上的一种分治问题，主要操作是去除原本树中的某些对象，使得原树被分解成若干个互不相交的部分，由此可以解决许多以路径为询问对象的问题。 树分治分为以下两种...
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
POJ3277.rar_3277 poj_poj3277_多个面积_线段树
09-24
问题：求平面上多个矩形的总面积。 算法：线段树（经典的线段树题目）
POJ、HDU、ZOJ、SOJ水题过滤器
11-08
自动探测POJ、HDU、SOJ、ZOJ水题，对于有志于刷遍各种水题的ACMer来说非常有用
poj2823.cpp.tar.gz_线段树
09-20
poj2823，使用线段树进行查询区域间最大最小值，线段树初步
树分治 点分治
02-26
树分治就是在树形结构上进行分而治之的操作，包括点分治和边分治。 点分治的效率比较稳定，最坏情况下递归深度为O(logn)。 边分治在定点度数D为常数时，基于边的分治递归最坏深度为O(log N) ，然而D较大时会达到O(N)
动态树分治
11-24
点分治是一种树分治算法，在解决树上路径满足某种属性的数量统计方面有着很大的作用，而动态点分治相当把重心拿出来重新构了一个新的树型关系，每个重心所管辖的就是他能getdeep的那一片连通块,然后每个重心额外记一个上层重心即可，可以支持在线修改查询的一类树上问题。
[TreeDivideAndConquer]点分治
srand(time(0))
05-19 719
点分治
树分治之点分治模板总结
weixin_30933531的博客
05-22 117
点分治的时间复杂度为O（NlogN）。由于每次都是找重心，所以处理完一个大小为N的树后，每个子树的大小最大都为N/2，所以最多分治NlogN层，每层都是N所以是O（NlogN）。【具体流程】1，选取一个点，将无根树变成有根树 　为了使每次的处理最优，我们通常要选取树的重心。 　何为“重心”，就是要保证与此点连接的子树的节点数最大值最小，可以防止被卡。 　重心求法：...
树分治小结
Occult
06-07 1296
一个月，总算完结了树分治的内容（专题里还有一题还不会搞，不知道能不能分治） 其实树分治也没有想象中那么难，如果对于链上的分治能熟练掌握的话，那么树分治的上手会比较容易。 树分治分为静态和动态两种，静态即直接分治，在分治过程中统计答案。 而动态的需要先按照重心重新建树，然后在每个点上记录答案，这样修改东西的时候就可以更新了， 这一点其实可以看出，动态树分治和线段树其实非常相像。 单单是树分
点分治（树分治）
qq_35975367的博客
10-22 597
介绍： 将原问题分解成若干相同形式，相互独立的子问题，各个击破 一般用来解决有关树上路径的统计和询问 题目： P4178 Tree 给定一棵 n 个节点的树，每条边有边权，求出树上两点距离小于等于 k 的点对数量。 做法： 暴力做法；(O(n2)) 点分治做法： 选择一个点作为分治中心，令其为rt做dfs。对于一条路径path(u,v)，其要么经过rt(即lca(u,v) = = rt)，要么在某个子树sub(son[rt])中 把问题形式化为： solve(T,rt) = 统计T树中经过rt且长度&lt
LCA系列 hdu2587
cww97的博客
11-10 1351
题http://acm.hdu.edu.cn/showproblem.php?pid=2586好久不写LCA了#include <cstdio> #include <cstring> #include <iostream> using namespace std; typedef long long LL; const int N = 1e5+10; struct tree { struct
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值