POJ-1639 Picnic Planning 度数限制最小生成树

解法参考的论文：https://wenku.baidu.com/view/8abefb175f0e7cd1842536aa.html

觉得网上的代码好像都是用邻接矩阵来实现的，觉得可能数据量大了会比较慢。于是自己写了一遍。

实现细节可以看代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
const int N=+;
const int INF=0x3f3f3f3f;
int n,m,k,ans,fa[N];
struct edge{
    int x,y,z;
    bool used;
    edge() {}
    edge(int x,int y,int z) : x(x),y(y),z(z) { used=; }
    bool operator < (const edge &rhs) const {
        return z<rhs.z;
    }
}e[N];
map<string,int> mp;
vector<int> G[N];

int getfa(int x) { return x==fa[x] ? x : fa[x]=getfa(fa[x]); } 

void kruskal() {
    sort(e+,e+m+);
    for (int i=;i<=n;i++) fa[i]=i;
    for (int i=;i<=m;i++) {
        int fx=getfa(e[i].x),fy=getfa(e[i].y);
        if (e[i].x== || e[i].y== || fx==fy) continue;
        fa[fy]=fa[fx];
        e[i].used=;
        ans+=e[i].z;
    }
}

int Max[N];
void dfs(int x,int f) {
    for (int i=;i<G[x].size();i++) {
        int y; if (e[G[x][i]].x==x) y=e[G[x][i]].y; else y=e[G[x][i]].x;
        if (!e[G[x][i]].used || y==f) continue;
        if (x!=) //这个很重要：去掉的边必须和V0不相连（否则会使得根节点度数减少）
        if (Max[x]== || e[G[x][i]].z>e[Max[x]].z) Max[y]=G[x][i];
            else Max[y]=Max[x];
        dfs(y,x);
    }
}

int cnt=,Min[N];
void solve() {
    memset(Min,,sizeof(Min));
    for (int i=;i<G[].size();i++) {  //把各个MST森林最小边连到根节点 变成一棵树
        int ty;
        if (e[G[][i]].x==) ty=getfa(e[G[][i]].y);
            else ty=getfa(e[G[][i]].x);
        if (Min[ty]== || e[G[][i]].z<e[Min[ty]].z) Min[ty]=G[][i];
    }
    for (int i=;i<=n;i++)
        if (Min[i]) { cnt++; ans+=e[Min[i]].z; e[Min[i]].used=; }

    for (int i=cnt+;i<=k;i++) {  //拓展根节点度数
        memset(Max,,sizeof(Max));
        dfs(,);  //dfs找每个点到根节点的路径上的最长边
        int minn=INF,New,Old;
        for (int j=;j<G[].size();j++)
            if (!e[G[][j]].used) {
                int y; if (e[G[][j]].x==) y=e[G[][j]].y; else y=e[G[][j]].x;
                if (Max[y]==) continue;
                int tmp=e[G[][j]].z-e[Max[y]].z;
                if (tmp<minn) {  //记录本次结点拓展最大的收益
                    minn=tmp;
                    New=G[][j]; Old=Max[y];
                }
            }
        if (minn>=) break;
        ans+=minn;
        e[New].used=; e[Old].used=;  //替换最长边
    }
} 

int main()
{
    cin>>m;
    string s1,s2; int x,y,z;
    n=; mp["Park"]=;
    for (int i=;i<=m;i++) {
        cin>>s1>>s2>>z;
        if (!mp.count(s1)) mp[s1]=++n;
        if (!mp.count(s2)) mp[s2]=++n;
        x=mp[s1]; y=mp[s2];
        e[i]=edge(x,y,z);
    }
    cin>>k;

    kruskal();  //先忽略根节点做一次MST 得到MST森林
    for (int i=;i<=m;i++) { G[e[i].x].push_back(i); G[e[i].y].push_back(i); }
    solve();  //拓展根节点度数得到更小的MST 

    printf("Total miles driven: %d\n",ans);
    return ;
}