度限制MST

POJ1639 顶点度数限制的最小生成树

做法:首先把和顶点相连的X条边全部删掉 得到顶点和 X个连通块

然后求出这X个连通块的MST 再把X条边连接回去这样我们就首先求出了X度MST

知道了X度MST 我们接下来要求X+1度MST 也就是再给顶点一条边 但是加上了这条边就会生成一个环

我们需要删掉这个环上最大权值的边

所有我们每次从N度向N+1度推进的时候需要O(N)DP求出并记录顶点到其他点的权值最大边

然后我们枚举还没有连上的边 如果删掉的边不会比加入的边大的话 就不继续推进了(剪枝)

 /*Huyyt*/
 //#include<bits/stdc++.h>
 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<cmath>
 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<vector>
 #define mem(a,b) memset(a,b,sizeof(a))
 #define pb push_back
 using namespace std;
 typedef long long ll;
 typedef unsigned long long ull;
 const int mod = 1e9 + ;
 const int gakki =  +  +  +  + 1e9;
 const int MAXN = 1e2 + , MAXM = 2e4 + ;
 /*int to[MAXM << 1], nxt[MAXM << 1], Head[MAXN], ed = 1;
 int cost[MAXM << 1];
 inline void addedge(int u, int v, int c)
 {
         to[++ed] = v;
         nxt[ed] = Head[u];
         cost[ed] = c;
         Head[u] = ed;
 }*/
 int dis[][];
 int par[];
 map<string, int> mp;
 string mpu, mpv;
 bool connect[];
 int n, K;
 int cnt = , root, costnow, ans = , ccnt = ;
 int dp[];
 struct node
 {
         int u, v, c;
 } edge[], cmin[], rootedge[], cur, choose[];
 bool cmp(node a, node b)
 {
         return a.c < b.c;
 }
 int findpar(int x)
 {
         return par[x] == x ? x : par[x] = findpar(par[x]);
 }
 void init()
 {
         for (int i = ; i <= n; i++)
         {
                 dp[i] = -;
                 choose[i].c = -;
         }
 }
 void dfs(int x, int pre)
 {
         node better;
         for (int v = ; v <= n; v++)
         {
                 if (v != pre && (dis[x][v] != ))
                 {
                         if (dis[x][v] > choose[x].c)
                         {
                                 choose[v].u = x, choose[v].v = v, choose[v].c = dis[x][v];
                                 dp[v] = dis[x][v];
                         }
                         else
                         {
                                 choose[v] = choose[x];
                                 dp[v] = dp[x];
                         }
                         dfs(v, x);
                 }
         }
 }
 int main()
 {
         scanf("%d", &n);
         for (int i = ; i <= n + ; i++)
         {
                 par[i] = i;
                 cmin[i].c = ;
                 for (int j = ; j <= n + ; j++)
                 {
                         dis[i][j] = ;
                 }
         }
         mp["Park"] = ;
         for (int i = ; i <= n; i++)
         {
                 cin >> mpu >> mpv >> costnow;
                 if (!mp[mpu])
                 {
                         mp[mpu] = ++cnt;
                 }
                 if (!mp[mpv])
                 {
                         mp[mpv] = ++cnt;
                 }
                 edge[i].u = mp[mpu], edge[i].v = mp[mpv];
                 edge[i].c = costnow;
                 //cout << edge[i].u << "  " << edge[i].v << "  " << costnow << endl;
                 if (edge[i].u ==  || edge[i].v == )
                 {
                         rootedge[++ccnt] = edge[i];
                 }
         }
         scanf("%d", &K);
         sort(edge + , edge +  + n, cmp);
         for (int i = ; i <= n; i++)
         {
                 int u1, v1;
                 u1 = edge[i].u, v1 = edge[i].v;
                 if (u1 !=  && v1 != )
                 {
                         int fx = findpar(u1), fy = findpar(v1);
                         if (fx != fy)
                         {
                                 par[fx] = fy;
                                 dis[u1][v1] = dis[v1][u1] = edge[i].c;
                                 ans += edge[i].c;
                                 //cout << " u " << u1 << " v " << v1 << "   " << ans << endl;
                         }
                 }
         }
         for (int i = ; i <= ccnt; i++)
         {
                 int u1, v1;
                 u1 = rootedge[i].u, v1 = rootedge[i].v;
                 if (u1 != )
                 {
                         int fx = findpar(u1);
                         if (cmin[fx].c > rootedge[i].c)
                         {
                                 cmin[fx] = rootedge[i];
                         }
                 }
                 else
                 {
                         int fx = findpar(v1);
                         if (cmin[fx].c > rootedge[i].c)
                         {
                                 cmin[fx] = rootedge[i];
                         }
                 }
         }
         int m = ;
         for (int i = ; i <= cnt; i++)
         {
                 int fx = findpar(i);
                 if (!connect[fx])
                 {
                         m++;
                         connect[fx] = true;
                         cur = cmin[fx];
                         dis[cur.u][cur.v] = dis[cur.v][cur.u] = cur.c;
                         ans += cur.c;
                         //cout << " i " << i <<  " u " << cur.u << " v " << cur.v << "   " << ans << endl;
                         for (int j = ; j <= ccnt; j++)
                         {
                                 if (rootedge[j].u == cur.u && rootedge[j].v == cur.v)
                                 {
                                         rootedge[j].c = -;
                                         break;
                                 }
                         }
                 }
         }
         for (int i = m + ; i <= K; i++)
         {
                 init();
                 dfs(, -);
                 int ansmanx = ;
                 node best;
                 int want;
                 int where;
                 for (int j = ; j <= ccnt; j++)
                 {
                         if (rootedge[j].c != -)
                         {
                                 int u1, v1;
                                 u1 = rootedge[j].u, v1 = rootedge[j].v;
                                 if (u1 != )
                                 {
                                         if (dp[u1] - rootedge[j].c > ansmanx)
                                         {
                                                 where = j;
                                                 best = rootedge[j];
                                                 want = u1;
                                                 ansmanx = dp[u1] - rootedge[j].c;
                                         }
                                 }
                                 else
                                 {
                                         if (dp[v1] - rootedge[j].c > ansmanx)
                                         {
                                                 where = j;
                                                 best = rootedge[j];
                                                 want = v1;
                                                 ansmanx = dp[v1] - rootedge[j].c;
                                         }
                                 }
                         }
                 }
                 if (ansmanx == )
                 {
                         break;
                 }
                 dis[best.u][best.v] = dis[best.v][best.u] = best.c;
                 dis[choose[want].u][choose[want].v] = dis[choose[want].v][choose[want].u] = ;
                 rootedge[where].c = -;
                 ans -= ansmanx;
         }
         printf("Total miles driven: %d\n", ans);
         //cout << "Total miles driven: " << ans << endl;
         return ;
 }

//度生成树