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

题目链接：http://poj.org/problem?id=1639

题意：

　　给你一个无向图，n个节点，m条边，每条边有边权。

　　让你求一棵最小生成树，同时保证1号节点的度数<=k。

　　

题解：

　　最小度限制生成树：

　　　　（1）不用与1号节点相连的边，跑一次kruskal，得到了deg个连通块。

　　　　（2）选取与1相连的deg条边，并使得边尽可能小，将1与这些连通块连起来，得到了一棵deg度最小生成树。

　　　　（3）利用当前的deg度最小生成树，求出deg+1度最小生成树。如此重复至k度最小生成树：

　　　　　　I. 在当前生成树上dfs求出：从1出发到i节点路径上的最大边dp[i]（除去与1相连的边）。

　　　　　　II. 枚举与1相连且不在生成树内的边，添加一条能使当前生成树变得最小的边。

　　　　　　III. 如果无论如何都无法将生成树变小，则已求出答案，退出循环。

 

AC Code:

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <map>
#define MAX_N 35
#define MAX_M 905
#define INF 1000000000

using namespace std;

struct Edge
{
    int s;
    int t;
    int len;
    Edge(int _s,int _t,int _len)
    {
        s=_s;
        t=_t;
        len=_len;
    }
    Edge(){}
    friend bool operator < (const Edge &a,const Edge &b)
    {
        return a.len<b.len;
    }
};

int n=0,m,k;
int ans=0,deg=0;
int par[MAX_N];
int lnk[MAX_N];
int minn[MAX_N];
int a[MAX_N][MAX_N];
bool flag[MAX_N][MAX_N];
Edge dp[MAX_N];
Edge edge[MAX_M];
map<string,int> mp;

int cal_id(const string &s)
{
    if(mp.count(s)>0) return mp[s];
    mp.insert(pair<string,int>(s,++n));
    return n;
}

void read()
{
    cin>>m;
    string s1,s2;
    int v;
    memset(a,-1,sizeof(a));
    cal_id("Park");
    for(int i=0;i<m;i++)
    {
        cin>>s1>>s2>>v;
        int id1=cal_id(s1);
        int id2=cal_id(s2);
        edge[i]=Edge(id1,id2,v);
        if(a[id1][id2]==-1) a[id1][id2]=a[id2][id1]=v;
        else a[id1][id2]=a[id2][id1]=min(a[id1][id2],v);
    }
    cin>>k;
}

void init_union_find()
{
    for(int i=1;i<=n;i++)
    {
        par[i]=i;
    }
}

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

void unite(int x,int y)
{
    int px=find(x);
    int py=find(y);
    if(px==py) return;
    par[px]=py;
}

bool same(int x,int y)
{
    return find(x)==find(y);
}

void kruskal()
{
    init_union_find();
    sort(edge,edge+m);
    memset(flag,false,sizeof(flag));
    for(int i=0;i<m;i++)
    {
        Edge temp=edge[i];
        if(temp.s==1 || temp.t==1) continue;
        if(!same(temp.s,temp.t))
        {
            ans+=temp.len;
            unite(temp.s,temp.t);
            flag[temp.s][temp.t]=flag[temp.t][temp.s]=true;
        }
    }
}

void cal_mdeg()
{
    memset(minn,0x3f,sizeof(minn));
    for(int i=2;i<=n;i++)
    {
        if(a[1][i]!=-1)
        {
            int p=find(i);
            if(a[1][i]<minn[p])
            {
                minn[p]=a[1][i];
                lnk[p]=i;
            }
        }
    }
    for(int i=2;i<=n;i++)
    {
        if(minn[i]<INF)
        {
            deg++;
            ans+=minn[i];
            flag[1][lnk[i]]=flag[lnk[i]][1]=true;
        }
    }
}

void dfs(int x,int p)
{
    for(int i=1;i<=n;i++)
    {
        if(flag[x][i] && i!=p)
        {
            if(dp[i].len==-1)
            {
                if(a[x][i]>dp[x].len) dp[i]=Edge(x,i,a[x][i]);
                else dp[i]=dp[x];
            }
            dfs(i,x);
        }
    }
}

void cal_kdeg()
{
    for(int j=deg+1;j<=k;j++)
    {
        dp[1]=Edge(-1,-1,-INF);
        for(int i=2;i<=n;i++)
        {
            if(flag[1][i]) dp[i]=Edge(-1,-1,-INF);
            else dp[i]=Edge(-1,-1,-1);
        }
        dfs(1,-1);
        int dst,maxn=-INF;
        for(int i=2;i<=n;i++)
        {
            if(a[1][i]!=-1 && dp[i].len-a[1][i]>maxn)
            {
                maxn=dp[i].len-a[1][i];
                dst=i;
            }
        }
        if(maxn<=0) return;
        int x=dp[dst].s,y=dp[dst].t;
        flag[x][y]=flag[y][x]=false;
        flag[1][dst]=flag[dst][1]=true;
        ans-=maxn;
    }
}

void solve()
{
    kruskal();
    cal_mdeg();
    cal_kdeg();
}

void print()
{
    cout<<"Total miles driven: "<<ans<<endl;
}

int main()
{
    read();
    solve();
    print();
}