51nod1307(暴力树剖/二分&dfs/并查集)

题目链接: http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1307

题意: 中文题诶~

思路:

解法1:暴力树剖

用一个数组 num[i] 维护编号为 i 的边当前最大能承受的重量. 在加边的过程中根据给出的父亲节点将当前边所在的链上所有边的num都减去当前加的边的重量, 注意当前边也要减自重. 那么当num首次出现负数时加的边号即位答案；

事实上这个算法的时间复杂度是O(n^2)的, 不过本题并没有出那种退化成单链的数据, 所以直接暴力也能水过；

代码:

 #include <iostream>
 #include <stdio.h>
 using namespace std;

 const int MAXN = 5e4 + ;
 struct node{
     int c, w, pre;
 }gel[MAXN];
 int num[MAXN];//num[i]为编号为i的绳子当前可以承受的最大重量

 int main(void){
     int n, ans = -;
     scanf("%d", &n);
     for(int i = ; i < n; i++){
         scanf("%d%d%d", &gel[i].c, &gel[i].w, &gel[i].pre);
         if(ans != -) continue;
         num[i] = gel[i].c;
         int cnt = i;
         while(cnt != -){
             num[cnt] -= gel[i].w;
             if(ans == - && num[cnt] <= -) ans = i;
             cnt = gel[cnt].pre;//指向cnt的父亲节点
         }
     }
     if(ans == -) cout << n << endl;
     else cout << ans << endl;
     return ;
 }

解法2: 二分 + dfs

很显然在加边的过程中所有边的承受重量都是单调不减的, 那么可以考虑二分答案. 不过要注意判断函数的写法, 每一次判断都需要判断当前 mid条 边组成的树的所有边, 而不能只判断当前 mid 所在链上的边, 显然其他链上也可能存在不合法的边. 判断所有边的话可以 dfs 一遍, 回溯时判断即可.

代码:

 #include <iostream>
 #include <stdio.h>
 #include <vector>
 #define ll long long
 using namespace std;

 const int MAXN = 5e4 + ;
 struct node{
     int c, w, pre;
 }gel[MAXN];
 vector<int> sol[MAXN];
 bool flag;

 ll dfs(int u, int x){
     ll sum = gel[u].w;
     if(u > x) return ;//mid边后面的不要算上去
     for(int i = ; i < sol[u].size(); i++){
         sum += dfs(sol[u][i], x);
     }
     if(sum > gel[u].c && u) flag = false;//0是一个虚根,并没有对应的边
     return sum;
 }

 int main(void){
     int n;
     scanf("%d", &n);
     for(int i = ; i <= n; i++){
         scanf("%d%d%d", &gel[i].c, &gel[i].w, &gel[i].pre);
         gel[i].pre++;
         sol[gel[i].pre].push_back(i);
     }
     int l = , r = n, cnt = n;
     while(l <= r){
         flag = true;
         int mid = (l + r) >> ;
         dfs(, mid);
         if(flag) cnt = mid, l = mid + ;
         else r = mid - ;
     }
     printf("%d\n", cnt);
 }

解法3: 并查集

记录每个节点的父节点

然后按输入顺序的倒叙 遍历每一个节点

计算以当前节点为根的子树的重量 ( 因为按照题目的输入顺序来说  当前节点要么没有子节点  要么子树已经遍历完 算入当前树的重量）

当遍历到某个节点时

当前节点与父节点的边无法承载当前节点为根的子树  便从输入序列最晚输入的节点开始删除 

直到与父节点的边的能够承载当前节点为根的子树

又或者已经把遍历过的点都删除完了 

 

这个过程中  用并查集维护某个节点 属于那一个跟节点 并且不断的压缩路径

每个条路径被压缩一次 均摊时间 就是边的数量 所以 这种做法很稳定的 O(n)

 

上面这段话是直接从讨论中复制过来的

代码:

 #include <iostream>
 #include <stdio.h>
 #include <vector>
 #define ll long long
 using namespace std;

 const int MAXN = 1e5 + ;
 struct node{
     ll c, w, p;
 }gel[MAXN];

 ll ww[MAXN];
 vector<int> vt[MAXN];
 int pre[MAXN], sol;

 int find(int x){
     return pre[x] == x ? x : pre[x] = find(pre[x]);
 }

 void update(int u){
     for(int i = ; i < vt[u].size(); i++){
         gel[u].w += gel[vt[u][i]].w;
         pre[vt[u][i]] = u;
     }
     while(gel[u].w > gel[u].c){//u即为当前根节点
         gel[find(sol)].w -= ww[sol];
         sol--;
     }
 }

 int main(void){
     int n;
     scanf("%d", &n);
     for(int i = ; i <= n; i++){
         scanf("%lld%lld%lld", &gel[i].c, &gel[i].w, &gel[i].p);
         gel[i].p++;
         vt[gel[i].p].push_back(i);
         ww[i] = gel[i].w;//后面会对gel操作,所以需要先记录下gel的初始值来
         pre[i] = i;
     }
     sol = n;
     for(int i = n; i > ; i--){
         update(i);
     }
     printf("%d\n", sol);
     return ;
 }