Hdu 3311 Dig The Wells (综合_斯坦纳树)


 

Zoj 3613 Wormhole Transport (综合_斯坦纳树)

分类: 全部博客 ACM_动态规划(DP) ACM_数据结构 ACM_图论系列   462人阅读  评论(0)  收藏  举报
tree struct null output input c

题目链接:  http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3613


题目大意: 给定一张图有n个顶点,某些点有工厂,某些点有资源,每个资源可以供应给一个工厂,有m条无向边,边有边权。已知有资源的点不超过4个,有工厂的点也不超过4个,问选择若干条边如何使有资源工厂的工厂最多,当数量一样多时输出最小权值。n <= 200, m <= 5000.


解题思路: 很一般的斯坦纳树。这类问题模型一般是固定的,就比如这题和Hdu 4085就十分相像,但这题会略微复杂点。首先是找有工厂和有资源的点然后先存起来,k = 工厂点数+资源点数,总状态为1<<k.然后这题的工厂数应该要大等于资源数,这个很显然,这样的话判断转改合法不合法就要判断着两个数量的关系了。


测试数据:

Input:
2
0 1
1 0
1
1 2 3

2
1 1
1 1
1
1 2 3

4
2 1
1 0
0 1
1 1
3
1 2 3
2 3 4
3 4 4


4
0 1
0 1
1 0
1 0
2
1 3 1
2 4 1


OutPut:
1 3
2 0
3 4
2 2


C艹代码:

[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <string.h>  
  3. #include <queue>  
  4. using namespace std;  
  5. #define MIN 1000  
  6. #define MAX 5100  
  7. #define INF (1<<29)  
  8. #define min(a,b) ((a)<(b)?(a):(b))  
  9.   
  10.   
  11. struct planet{  
  12.   
  13.     int a,b;  
  14. }arr[MIN];  
  15. struct node {  
  16.   
  17.     int v,len;  
  18.     node *next;  
  19. }*head[MAX*2],tree[MAX*2];  
  20. queue<int> qu;  
  21. bool in[MIN][MIN];  
  22. int k,res[MIN],tot,fac[MIN];  
  23. int n,m,ans,ansi,ptr,st[MIN],nn;  
  24. int orik,cost[MIN][MIN],dp[MIN];  
  25.   
  26.   
  27. void Initial() {  
  28.   
  29.     int i,j,t;  
  30.   
  31.   
  32.     ptr = 0,orik = k;  
  33.     memset(st,0,sizeof(st));  
  34.     memset(in,false,sizeof(in));  
  35.     memset(head,NULL,sizeof(head));  
  36.     for (i = 0; i < tot; ++i)  
  37.         res[k++] = fac[i];  
  38.   
  39.       
  40.     nn = 1 << k;  
  41.     for (i = 0; i < nn; ++i)   
  42.         for (j = 0; j < n; ++j)  
  43.             cost[j][i] = INF;  
  44.   
  45.   
  46.     for (i = 0; i < k; ++i)  
  47.         st[res[i]] = 1<<i,cost[res[i]][st[res[i]]] = 0;  
  48. }  
  49. void AddEdge(int a,int b,int c) {  
  50.   
  51.     tree[ptr].v = b,tree[ptr].len = c;  
  52.     tree[ptr].next = head[a],head[a] = &tree[ptr++];  
  53. }  
  54. void Spfa() {  
  55.   
  56.     while (!qu.empty()) {  
  57.   
  58.         int j = qu.front() / MAX;  
  59.         int i = qu.front() % MAX;  
  60.         qu.pop(),in[j][i] = false;  
  61.   
  62.   
  63.         node *p = head[j];  
  64.         while (p != NULL) {  
  65.   
  66.             int v = p->v,nst = i | st[v];  
  67.             if (cost[j][i] + p->len < cost[v][nst]) {  
  68.   
  69.                 cost[v][nst] = cost[j][i] + p->len;  
  70.                 if (nst == i && !in[v][nst])  
  71.                     qu.push(v*MAX+nst),in[v][nst] = true;  
  72.             }  
  73.             p = p->next;  
  74.         }  
  75.     }  
  76. }  
  77. void Steiner_Tree() {  
  78.   
  79.     int i,j,t,s;  
  80.     for (i = 0; i < nn; ++i) {  
  81.   
  82.         for (j = 0; j < n; ++j) {  
  83.               
  84.             if (st[j] && !(st[j] & i)) continue;   
  85.             for (t = (i-1)&i; t; t = (t-1)& i)   
  86.                 cost[j][i] = min(cost[j][i],cost[j][t|st[j]]+cost[j][(i-t)|st[j]]);  
  87.             if (cost[j][i] != INF) qu.push(j*MAX+i),in[j][i] = true;      
  88.         }  
  89.         Spfa();  
  90.     }  
  91. }  
  92. int Check(int st) {  
  93.   
  94.     int i,cnt = 0;  
  95.     for (i = 0; i < orik; ++i)  
  96.         if (st & (1<<i)) cnt++;  
  97.     for (i = orik; i < k; ++i)  
  98.         if (st & (1<<i)) cnt -= arr[fac[i-orik]].a;  
  99.     return cnt <= 0;  
  100. }  
  101. void Solve_DP() {  
  102.   
  103.     int i,j,t;  
  104.     for (i = 0; i < nn; ++i) {  
  105.   
  106.         dp[i] = INF;  
  107.         for (j = 0; j < n; ++j)  
  108.             dp[i] = min(dp[i],cost[j][i]);  
  109.     }  
  110.   
  111.   
  112.     for (i = 0; i < nn; ++i)  
  113.         if (Check(i))for (t = (i-1)&i; t; t = (t-1)&i)  
  114.             if (Check(t)&&Check(i-t)) dp[i] = min(dp[i],dp[t]+dp[i-t]);  
  115.     for (i = 0; i < nn; ++i)  
  116.         if (dp[i] != INF && Check(i)){  
  117.   
  118.             int cnt = 0;  
  119.             for (j = 0; j < orik; ++j)  
  120.                 if (i & (1<<j)) cnt++;  
  121.             if (cnt > ans) ans = cnt,ansi = dp[i];  
  122.             else if (cnt == ans && ansi > dp[i]) ansi = dp[i];  
  123.         }  
  124. }  
  125.   
  126.   
  127. int main()  
  128. {  
  129.     int i,j,a,b,c,num;  
  130.   
  131.   
  132.     while (scanf("%d",&n) != EOF) {  
  133.   
  134.         ans = ansi = 0;  
  135.         num = k = tot = 0;  
  136.         for (i = 0; i < n; ++i) {  
  137.   
  138.             scanf("%d%d",&arr[i].a,&arr[i].b);  
  139.             if (arr[i].a && arr[i].b)  
  140.                 num++,arr[i].a--,arr[i].b--;  
  141.             if (arr[i].a) fac[tot++] = i;  
  142.             if (arr[i].b) res[k++] = i;  
  143.         }  
  144.           
  145.   
  146.         Initial();  
  147.         scanf("%d",&m);  
  148.         for (i = 0; i < m; ++i) {  
  149.   
  150.             scanf("%d%d%d",&a,&b,&c);  
  151.             a--,b--;  
  152.             AddEdge(a,b,c),AddEdge(b,a,c);  
  153.         }  
  154.           
  155.   
  156.         Steiner_Tree();  
  157.         Solve_DP();  
  158.         printf("%d %d\n",ans+num,ansi);  
  159.     }  
  160. }  

分类: 全部博客 ACM_动态规划(DP) ACM_数据结构 ACM_图论系列   517人阅读  评论(0)  收藏  举报

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=3311


题目大意:n个和尚要去挑水,他们可以再他们所在的地方挑水,也可以再其他m个地方挑水,挑水之前需要挖井,在n+m个地方挖井对应着n+m个费用,然后给定p条边,表示两个地方可以互达,边有边权表示需要的费用。


解题思路: 因为必须覆盖n个和尚,那么便是求一颗包含前n个点的斯坦纳树。

    一开始我的做法是将每个点挖井的费用表示在cost[i][st[i]]里,即以i为根并在i挖井的费用,写着写着就蛋疼了写不下去,点的费用会被重复计算好多次,这不是坑爹吗,然后就困了。睡一觉醒来后灵感大爆发,TMD的加个点0,然后连1条边到n+m的点,边权为点权,这样问题就转换成了:求覆盖点0,点1...点n的斯坦纳树,不需考虑点权了,也不会重复计算了。

    按上面的思路套个斯坦纳树模版,发现结果全为0.在求解dp[i]的时候,我没有加一些就进行dp[i] = min(dp[i],dp[k]+dp[i-k])。这样结果当然都为0,如dp[7] = dp[4] + dp[2] + dp[1],dp[1] = cost[0][1] = 0,dp[2]=cost[1][2] = 0,dp[4] = cost[2][4] = 0,这样的话一个集合就由若干个单点集合组合,费用都为0.其实这样忽视了一个条件,我们增加的点0是必须和1.2..n绑定在一起的,也就是说必须判断某个集合里是否为点0在

     其实,ans = min(cost[i][(1<<(n+1))-1])(i<=i<=n+m),因为这样的集合包含了所有点,并且这只会是一棵树,也就是答案了。

 

测试数据:

InPut:
3 1 3
1 2 3 4
1 4 2
2 4 2
3 4 4 

4 1 4
5 5 5 5 1
1 5 1
2 5 1
3 5 1
4 5 1


OutPut:
6
5


代码:
[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <string.h>  
  3. #include <queue>  
  4. using namespace std;  
  5. #define MIN (1<<6)  
  6. #define MAX 1100  
  7. #define INF (1<<29)  
  8. #define min(a,b) ((a)<(b)?(a):(b))  
  9.   
  10.   
  11. struct node {  
  12.   
  13.     int v,len;  
  14.     node *next;  
  15. }*head[MAX],tree[MAX*11];  
  16. queue<int> qu;  
  17. bool in[MAX][MIN];  
  18. int n,m,p,nn,ptr,ans,st[MAX];  
  19. int well[MAX],cost[MAX][MIN],dp[MAX];  
  20.   
  21.   
  22. void Initial() {  
  23.   
  24.     ptr = 0,nn = (1<<(n+1)) - 1;  
  25.     memset(st,0,sizeof(st));  
  26.     memset(in,false,sizeof(in));  
  27.     memset(head,NULL,sizeof(head));  
  28.   
  29.   
  30.     for (int i = 0; i <= (n+m); ++i)  
  31.         for (int j = 0; j < MIN; ++j)  
  32.             cost[i][j] = INF;  
  33.     for (i = 0; i <= n ; ++i)  
  34.         st[i] = 1<<i,cost[i][st[i]] = 0;  
  35. }  
  36. void AddEdge(int a,int b,int c) {  
  37.   
  38.     tree[ptr].v = b,tree[ptr].len = c;  
  39.     tree[ptr].next = head[a],head[a] = &tree[ptr++];  
  40. }  
  41. void Spfa() {  
  42.   
  43.     while (!qu.empty()) {  
  44.   
  45.         int i = qu.front() / MAX;  
  46.         int j = qu.front() % MAX;  
  47.         qu.pop(),in[i][j] = false;  
  48.   
  49.   
  50.         node *p = head[i];  
  51.         while (p != NULL) {  
  52.   
  53.             int v = p->v,nst = j | st[v];  
  54.             if (cost[i][j] + p->len < cost[v][nst]) {  
  55.   
  56.                 cost[v][nst] = cost[i][j] + p->len;  
  57.                 if (nst == j && !in[v][nst])  
  58.                     qu.push(v * MAX + nst),in[v][nst] = true;  
  59.             }  
  60.             p = p->next;  
  61.         }  
  62.     }  
  63. }  
  64. void Steiner_Tree() {  
  65.   
  66.     int i,j,k;  
  67.      for (j = 0; j <= nn; ++j){  
  68.           
  69.          for (i = 0; i <= (n + m); ++i){  
  70.   
  71.             for (k = (j-1)&j; k; k = (k-1) & j)  
  72.                 cost[i][j] = min(cost[i][j],cost[i][k|st[i]]+cost[i][(j-k)|st[i]]);  
  73.             if (cost[i][j] != INF) qu.push(i * MAX + j),in[i][j] = true;  
  74.         }  
  75.         Spfa();  
  76.     }  
  77. }  
  78. int Solve_DP() {  
  79.   
  80.     int i,j,k;  
  81.     for (j = 0; j <= nn; ++j) {  
  82.   
  83.         dp[j] = INF;  
  84.         for (i = 0; i <= (n + m); ++i)  
  85.             dp[j] = min(dp[j],cost[i][j]);  
  86.     }  
  87.     //for (i = 1; i <= nn; ++i)  
  88.     //  if (i&1)for (k = (i-1)&i; k; k = (k-1)&i)  
  89.     //      if ((k&1)&&((i-k)&1))dp[i] = min(dp[i],dp[k]+dp[i-k]);  
  90.     return dp[nn];  
  91. }  
  92.   
  93.   
  94. int main()  
  95. {  
  96.     int i,j,k,a,b,c;  
  97.   
  98.   
  99.     while (scanf("%d%d%d",&n,&m,&p) != EOF) {  
  100.   
  101.         for (i = 1; i <= (n + m); ++i)  
  102.             scanf("%d",&well[i]);  
  103.         Initial();  
  104.         for (i = 1; i <= p; ++i) {  
  105.   
  106.             scanf("%d%d%d",&a,&b,&c);  
  107.             AddEdge(a,b,c),AddEdge(b,a,c);  
  108.         }  
  109.         for (i = 1; i <= (n + m); ++i)  
  110.             AddEdge(0,i,well[i]),AddEdge(i,0,well[i]);  
  111.   
  112.   
  113.         Steiner_Tree();  
  114.         ans = Solve_DP();  
  115.         printf("%d\n",ans);  
  116.     }  
  117. }  


本文ZeroClock原创,但可以转载,因为我们是兄弟。

你可能感兴趣的:(ACM_数据结构,ACM_数据结构,ACM_动态规划(DP),ACM_图论系列,全部博客,全部博客,ACM_动态规划(DP),ACM_图论系列)