最小度限制生成树

poj 1639 最小度限制生成树

最小度限制生成树就是给一个图，让求它的最小生成树。找的的最小生成树满足并且点vo的度最大为k。

 

算法流程如下：
1.将该点（以下用v0表示）从图中删除，将得到p个连通分量。
2.对每个连通分量求最小生成树。
3.从每个连通分量中找与v0关联的权值最小的边，与v0相连接，这样将得到v0的最小p度生成树
4.如果 k  < p 那么这种树是不存在的。
5.如果 k >= p ，那么考虑构建 p+1度最小生成树，即加入每一条与v0相连的且不在当前的树中的边。
6.显然在第5步将其加入树中 ，必然会存在一个环，那么删掉该环中与v0不关联的权值最大边，将得到加入该边后的最小生成树，且v0是p+1度的。
7.枚举上述 5,6 的边找树权值最小，那么即是p+1度限制的最小生成树。如果p+1度最小生成树的值大于p度最小生成树的话直接输出当前p度的值即可。
8.重复5.6.7，直到k 度最小生成树出现。

 

显然上述算法的1-->3步可以用prim算法实现。复杂度是O(n^2)。而5--->7如果枚举每条边进行增删操作则是O(n^2)的复杂度,总的复杂度达到了O(k*n^2)。在求次小生成树的过程中我们用到了一个path[x][y]记录x -->y的最长边。这里也是用类似的方法设立一个del[]数组，记录v0--->vi路径上的最长边。这样我们每次只要枚举max(del[i] - g[v0][i])即可。注意每次操作后都要更新该连通块的del[]。这样复杂度就降为O(k*n)。

#include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #include<stack>
 #include<string>
 #include<vector>
 #include<cstdlib>
 #include<map>
 #include<set>
 using namespace std;
 #define inf 0x3f3f3f3f
 const int maxn = 25;
 int m,n,k,g[maxn][maxn],dis[maxn],pre[maxn],ans;
 bool vis[maxn],link[maxn][maxn];//link[][]数组来保存在MST中的边
 struct node
 {
     int u,v,len;
     node(){}
     node(int u, int v, int len):u(u),v(v),len(len){}
 }del[maxn];//保存 0到当前节点的路径上的最长边
 int kk;
 void prim(int st)//求包含st的连通块的MST
 {
     vis[st] = 1;
     memset(pre, -1, sizeof(pre));
     for (int i = 1; i < n; ++i)
     {
         dis[i] = g[st][i];
         pre[i] = st;
     }
     while(1)
     {
         int tmp = inf, nt = st;
         for (int i = 1; i < n; ++i)
         {
             if (!vis[i] && dis[i] < tmp)
             {
                 nt = i;
                 tmp = dis[i];
             }
         }
         if (st == nt) break;//该连通分量最小生成树完成
         if (g[0][nt] < g[0][kk]) kk = nt;//kk保存该连通分量到0距离最近的点
         link[pre[nt]][nt] = link[nt][pre[nt]] = 1;//将边加入到MST中
         vis[nt] = 1;
         ans += dis[nt];
         for (int i = 1; i < n; ++i)
         {
             if (!vis[i] && dis[i] > g[nt][i])
             {
                 pre[i] = nt;//记录该点前驱
                 dis[i] = g[nt][i];
             }
         }
     }
 }
 void dfs(int cur, int cpre, int u, int v)//修改当前连通分量中到达0的路径上的最大边
 {
     //cur 当前节点，cpre为当前节点的前驱,(u,v)表示当前节点到0节点的路径上最大边
     for (int i = 1; i < n; ++i)
     {
         if (cpre != i && link[cur][i])
         {
             if (cpre == -1|| g[cur][i] >= g[u][v])//当前边大于之前保存的最大边
             {
                 del[i] = node(cur, i, g[cur][i]);
                 dfs(i, cur, cur, i);
             }
             else
             {
                 del[i] = node(u, v, g[u][v]);
                 dfs(i, cur, u, v);
             }
         }
     }
 }
 void solve()
 {
     for (int i = 1; i < n; ++i)
     {
         if (vis[i]) continue;
         k--;
         kk = i;
         prim(i);
         ans += g[0][kk];
         link[kk][0] = link[0][kk] = 1;
         dfs(kk, -1, -1, -1);
     }
     while(k--)
     {
         int c = 0, nt = 0;
         for (int j = 1; j < n; ++j)//枚举所有节点，找出最大边
         {
             if (link[0][j] || g[0][j] == inf) continue;
             if(c < del[j].len - g[0][j])//找出最大的添删操作
             {
                 nt = j;
                 c = del[j].len - g[0][j];
             }
         }
         if (c == 0) break;
         ans -= c;
         link[del[nt].u][del[nt].v] = link[del[nt].v][del[nt].u] = false;
         link[0][nt] = link[nt][0] = 1;
         dfs(nt, 0, -1, -1);//每次操作完成后修改当前连通分量的最长边
     }
     printf("Total miles driven: %d\n",ans);
 }
 void init()
 {
     char s1[20],s2[20];
     int w, u, v;
     n = 0;
     map <string,int> name;
     map <string,int>::iterator it1,it2;
     name.clear();
     name["Park"] = n++;
     memset(g, 0x3f, sizeof(g));
     memset(vis, 0, sizeof(vis));
     memset(link, 0, sizeof(link));
     for (int i = 0; i < m; ++i)
     {
         scanf("%s %s %d", &s1, &s2, &w);
         it1 = name.find(s1);
         it2 = name.find(s2);
         if (it1 != name.end()) u = it1->second;
         else
         {
             name[s1] = n;
             u = n++;
         }
         if (it2 != name.end()) v = it2->second;
         else
         {
             name[s2] = n;
             v = n++;
         }
         if (g[u][v] > w)
             g[u][v] = g[v][u] = w;
     }
     scanf("%d", &k);
     ans = 0;
 }
 int main()
 {
     while(scanf("%d", &m) != EOF)
     {
         init();
         solve();
     }
     return 0;
 }