【POJ 1639】 Picnic Planning （最小k度限制生成树）

【题意】

　　有n个巨人要去Park聚会。巨人A和先到巨人B那里去，然后和巨人B一起去Park。B君是个土豪，他家的停车场很大，可以停很多车，但是Park的停车场是比较小。只能停k辆车。现在问你在这个限制条件下。巨人到达Park的最短距离。

　　如果把那个条件去掉。那么就是就是求最小生成树。加上那个条件其实就是求顶点度数限制为k的最小生成树。

Input

Input will consist of one problem instance. The first line will contain a single integer n indicating the number of highway connections between brothers or between brothers and the park. The next n lines will contain one connection per line, of the form name1 name2 dist, where name1 and name2 are either the names of two brothers or the word Park and a brother's name (in either order), and dist is the integer distance between them. These roads will all be 2-way roads, and dist will always be positive.The maximum number of brothers will be 20 and the maximumlength of any name will be 10 characters.Following these n lines will be one final line containing an integer s which specifies the number of cars which can fit in the parking lot of the picnic site. You may assume that there is a path from every brother's house to the park and that a solution exists for each problem instance.

Output

Output should consist of one line of the form 
Total miles driven: xxx 
where xxx is the total number of miles driven by all the brothers' cars.

Sample Input

10
Alphonzo Bernardo 32
Alphonzo Park 57
Alphonzo Eduardo 43
Bernardo Park 19
Bernardo Clemenzi 82
Clemenzi Park 65
Clemenzi Herb 90
Clemenzi Eduardo 109
Park Herb 24
Herb Eduardo 79
3

Sample Output

Total miles driven: 183

【分析】

　　其实我还没A，233，先打着题解。

　　题意也没看懂，反正就求最小k度生成树吧。

　　感觉这种生成树都有自己的方法，跟kruskal没什么太大关系，只是里面要用到一下，要先求出去点根的MST。

/*************************************************

算法引入：
最小k度限制生成树,就是指有特殊的某一点的度不能超过k时的最小生成树;
如果T是G的一个生成树且dT(v0)=k,则称T为G的k度限制生成树;
G中权值和最小的k度限制生成树称为G的最小k度生成树;

算法思想：
设特殊的那点为v0,先把v0删除,求出剩下连通图的所有最小生成树;
假如有m棵最小生成树,那么这些生成树必定要跟v0点相连;
也就是说这棵生成树的v0点至少是m度的;
若m>k,条件不成立,无法找到最小k度限制生成树;
若m<=k,则枚举m到k的所有最小生成树,即一步步将v0点的度加1,直到v0点的度为k为止;
则v0点度从m到k的(k-m+1)棵最小生成树中最小的那棵即为答案;

算法步骤：
(1)先求出最小m度限制生成树:
原图中去掉和V0相连的所有边(可以先存两个图,建议一个邻接矩阵,一个邻接表,用方便枚举边的邻接表来构造新图);
得到m个连通分量,则这m个连通分量必须通过v0来连接;
则在图G的所有生成树中dT(v0)>=m;
则当k<m时,问题无解;
对每个连通分量求一次最小生成树;
对于每个连通分量V’,用一条与V0直接连接的最小的边把它与V0点连接起来,使其整体成为一个生成树;
就得到了一个m度限制生成树,即为最小m度限制生成树;

(2)由最小m度限制生成树得到最小m+1度限制生成树;
连接和V0相邻的点v,则可以知道一定会有一个环出现(因为原来是一个生成树);
只要找到这个环上的最大权边(不能与v0点直接相连)并删除,就可以得到一个m+1度限制生成树;
枚举所有和V0相邻点v,找到替换后,增加权值最小的一次替换(如果找不到这样的边,就说明已经求出);
就可以求得m+1度限制生成树;
如果每添加一条边,都需要对环上的边一一枚举,时间复杂度将比较高;
用动态规划解决;
设dp(v)为路径v0—v上与v0无关联且权值最大的边;
定义father(v)为v的父结点,由此可以得到状态转移方程:
dp(v)=max(dp(father(v)),ω(father(v),v));
边界条件为dp[v0]=-∞(因为每次寻找的是最大边,所以-∞不会被考虑),dp[v’]=-∞|(v0,v’)∈E(T);

(3)当dT(v0)=k时停止(即当V0的度为k的时候停止),但不一定k的时候最优;

算法实现：
并查集+kruskal;
首先,每个连通分量的的最小生成树可以直接用一个循环,循环着Kruskal求出;
这里利用了联通分量间的独立性,对每个连通分量分别求最小生成树,和放在一起求,毫不影响;
而且kruskral算法保证了各连通分量边的有序性;
找最小边的时候,可以用动态规划,也可以这么做：
先走一个循环,但我们需要逆过来加边,将与v0关联的所有边从小到达排序;
然后将各连通分量连接起来,利用并查集可以保证每个连通分量只有一条边与v0相连;
由于边已经从小到达排序,故与每个连通分量相连的边就是每个连通分量与v0相连中的最小边;
然后求m+1度的最小生成树时,可以直接用DFS,最小生成树要一直求到k度,然后从中找出一个最优值;

转自：http://blog.csdn.net/jarily/article/details/8779621

　　好吧AC了，度数可以小于等于k的哦~~

　　我还以为要把小于等于k的全部求出来然后min，其实有个地方可以直接break（看代码！！）

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<map>
#include<string>
using namespace std;
#define INF 0xfffffff
#define Maxn 310

struct node
{
    int x,y,c;
}t[Maxn*Maxn],dp[Maxn];

bool cmp(node x,node y) {return x.c<y.c;}

map<string,int> M;

bool flag[Maxn][Maxn];
int G[Maxn][Maxn],fa[Maxn];
int cnt;

int get_num(string s)
{
    if(M.find(s)==M.end())
    {
        M[s]=++cnt;
    }
    return M[s];
}

int ffa(int x)
{
    if(fa[x]!=x) fa[x]=ffa(fa[x]);
    return fa[x];
}

int ans,n,m;
void init()
{
    cnt=1;ans=0;
    M["Park"]=1;
    memset(flag,0,sizeof(flag));
    memset(G,-1,sizeof(G));
    scanf("%d",&n);
    for(int i=1;i<Maxn;i++) fa[i]=i;
    string s;
    for(int i=1;i<=n;i++)
    {
        cin>>s;
        t[i].x=get_num(s);
        cin>>s;
        t[i].y=get_num(s);
        scanf("%d",&t[i].c);
        if(G[t[i].x][t[i].y]==-1)
            G[t[i].x][t[i].y]=G[t[i].y][t[i].x]=t[i].c;
        else
            G[t[i].x][t[i].y]=G[t[i].y][t[i].x]=min(G[t[i].y][t[i].x],t[i].c);
    }
    scanf("%d",&m);
}

void kruskal()
{
    sort(t+1,t+1+n,cmp);
    int ct=0;
    for(int i=1;i<=n;i++)
    {
        if(t[i].x==1||t[i].y==1) continue;
        if(ffa(t[i].x)!=ffa(t[i].y))
        {
            fa[ffa(t[i].x)]=ffa(t[i].y);
            ct++;
            flag[t[i].x][t[i].y]=flag[t[i].y][t[i].x]=1;
            ans+=t[i].c;
        }
        // if(ct==cnt-2) break;
    }
}

void dfs(int x,int f)
{
    for(int i=2;i<=cnt;i++) if(i!=f&&flag[x][i])
    {
        if(!flag[1][i])
        {
            if(dp[x].c>G[x][i]) dp[i]=dp[x];
            else dp[i].c=G[x][i],dp[i].x=x,dp[i].y=i;
        }
        dfs(i,x);
    }
}

int mn[Maxn],tmp[Maxn];
void solve()
{
    kruskal();
    for(int i=1;i<=cnt;i++) mn[i]=INF;
    for(int i=2;i<=cnt;i++) if(G[1][i]!=-1)
    {
        int r=ffa(i);
        if(mn[r]>G[1][i])
        {
            tmp[r]=i;
            mn[r]=G[1][i];
        }
    }
    int r=0;
    for(int i=1;i<=cnt;i++) if(mn[i]!=INF)
    {
        r++;
        flag[1][tmp[i]]=flag[tmp[i]][1]=1;
        ans+=G[1][tmp[i]];
    }
    for(int i=r+1;i<=m;i++)
    {
        dp[1].c=-INF;
        for(int j=1;j<=cnt;j++) if(flag[1][j]) dp[j].c=-INF;
        
        dfs(1,0);
        int tmp,minn=INF;
        for(int j=2;j<=cnt;j++) if(G[1][j]!=-1)
        {
            if(minn>G[1][j]-dp[j].c)
            {
                minn=G[1][j]-dp[j].c;
                tmp=j;
            }
        }
        if(minn>=0) break;
        flag[1][tmp]=flag[tmp][1]=1;
        int x=dp[tmp].x,y=dp[tmp].y;
        flag[x][y]=flag[y][x]=0;
        ans+=minn;
    }
    printf("Total miles driven: %d
",ans);
}

int main()
{
    init();
    solve();
    return 0;
}

放一个有解释的代码，我就是看着他打的。。

#include<iostream>
#include<string>
#include<cstdio>
#include<map>
#include<cstring>
#include<algorithm>
using namespace std;

const int INF=99999999;
const int N=100;

int n,m;//n为边的数量,m表示限度值
int cnt;//计算出来的结点数
int set[N];
bool flag[N][N];
int G[N][N];
int ans;

map<string,int> Map;

struct node
{
    int x,y,v;
} a[N*N];

struct edge
{
    int x,y,v;
} dp[N];

int get_num(string s)//返回每个人对应结点
{
    if(Map.find(s)==Map.end())//没有搜索到该键值
    {
        Map[s]=++cnt;//对应建图
    }
    // cout<<"  Map["<<s<<"]=="<<Map[s]<<endl;
    return Map[s];
}

bool cmp(node a,node b)
{
    return a.v<b.v;
}

int find_set(int x)
{
    if(x!=set[x])
        set[x]=find_set(set[x]);
    return set[x];
}

inline void union_set(int x,int y)
{
    set[y]=x;
}

void kruskal()//求m个连通分量的最小生成树
{
    for(int i=1; i<=n; i++)
    {
        if(a[i].x==1||a[i].y==1)
            continue;
        int x=find_set(a[i].x);
        int y=find_set(a[i].y);
        if(x==y)
            continue;
        flag[a[i].x][a[i].y]=flag[a[i].y][a[i].x]=true;
        set[y]=x;
        ans+=a[i].v;
    }
}

void dfs(int x,int fa)
{
    for(int i=2; i<=cnt; i++)
        if(i!=fa&&flag[x][i])
        {
            if(dp[i].v==-1)
            {
                if(dp[x].v>G[x][i])//dp(v)=max(dp(father(v)),ω(father(v),v));
                {
                    dp[i]=dp[x];
                }
                else
                {
                    dp[i].v=G[x][i];
                    dp[i].x=x;
                    dp[i].y=i;
                }
            }
            dfs(i,x);
        }
}

void init()
{
    ans=0;
    cnt=1;
    Map["Park"]=1;
    memset(flag,0,sizeof(flag));
    memset(G,-1,sizeof(G));
    scanf("%d",&n);
    for(int i=1; i<N; i++)//并查集初始化
        set[i]=i;
    string s;
    for(int i=1; i<=n; i++)
    {
        cin>>s;
        a[i].x=get_num(s);
        cin>>s;
        a[i].y=get_num(s);
        cin>>a[i].v;
        if(G[a[i].x][a[i].y]==-1)
            G[a[i].x][a[i].y]=G[a[i].y][a[i].x]=a[i].v;
        else//有重边
            G[a[i].x][a[i].y]=G[a[i].y][a[i].x]=min(G[a[i].y][a[i].x],a[i].v);
    }
    scanf("%d",&m);//m表示限度值
}

void solve()
{
    int tmp[N],Min[N];
    for(int i=1; i<=cnt; i++)
        Min[i]=INF;
    sort(a+1,a+1+n,cmp);
    kruskal();
    for(int i=2; i<=cnt; i++)
    {
        if(G[1][i]!=-1)
        {
            int t=find_set(i);
            if(Min[t]>G[1][i])//求每个连通分量中和顶点1连接的最小权边
            {
                tmp[t]=i;
                Min[t]=G[1][i];
            }
        }
    }
    
    int t=0;//t表示最小限度
    for(int i=1; i<=cnt; i++)
        if(Min[i]!=INF)
        {
            t++;
            flag[1][tmp[i]]=flag[tmp[i]][1]=true;
            ans+=G[1][tmp[i]];
        }
        
    for(int i=t+1; i<=m; i++)//枚举t到m的所有最小生成树,即一步步将v1点的度加1,直到v1点的度为m为止;
    {
        memset(dp,-1,sizeof(dp));//dp[v]为路径v0—v上与v0无关联且权值最大的边;
        dp[1].v=-INF;
        for(int j=2; j<=cnt; j++)
            if(flag[1][j])
                dp[j].v=-INF;
        dfs(1,-1);
        int tmp,Min=INF;
        for(int j=2; j<=cnt; j++)
            if(G[1][j]!=-1)
            {
                if(Min>G[1][j]-dp[j].v)
                {
                    Min=G[1][j]-dp[j].v;
                    tmp=j;
                }
            }
        if(Min>=0)//找不到这样的边,就说明已经求出
            break;
        flag[1][tmp]=flag[tmp][1]=true;
        int x=dp[tmp].x;
        int y=dp[tmp].y;
        flag[x][y]=false;
        flag[y][x]=false;
        ans+=Min;
        printf("%d
",ans);
    }
    
    printf("Total miles driven: %d
",ans);
}

int main()
{
    init();
    solve();
    return 0;
}

2016-11-03 08:45:50