最小度限制生成树

定义

　　在一张无向带权图中，找出一棵生成树，使得某个特定结点的度数不超过$K$或者恰好等于$K$的，并且权值和最小。

求解算法

　　首先我们对不与特殊结点相连的边求最小生成树，得到几个连通分量。然后找出每个连通分量到特殊结点的最短的边，把这条边添加到生成树中，这样我们就得到了一个度限制为连通分量数的最小生成树。如果有连通分量到特殊结点没有边，则说明无法构成生成树。如果连通分量数大于$K$，则说明无法在度数限制下构成生成树。
　　对于当前求得的K度生成树，我们可以求出$K+1$度生成树，方法如下。令特殊结点为根结点，首先对当前生成树进行一次树形DP求出任意一点到根节点的不与最长边，然后枚举当前不在树中的各条与跟结点相连的边，如果把它加到生成树中，则要去掉它指向的点到跟结点最长的一个边。这样我们就可以知道添加每条边生成树权值和的变化情况，选择令权值和最小的一条边即可。如果当前没有个替换的边对则无法得到$K+1$度的生成树。
　　总时间复杂度$O(E \times \log E+K \times V)$

代码（POJ1639）

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <map>
using namespace std;
#define INF 0x3f3f3f3f
#define mem(a,b) memset((a),(b),sizeof(a))

const int MAXLEN=10+3;
const int MAXV=20+3;
const int MAXE=MAXV*MAXV;

struct Edge
{
    int from, to, cost;
    bool operator < (const Edge &other)const
    {
        return cost<other.cost;
    }
}edge[MAXE];//保存图中的所有边

int V, E, K;//结点数，边数，度数限制
int par[MAXV], high[MAXV];//并查集数组
int G[MAXV][MAXV];//图的邻接矩阵表示（没有边，花费为INF）
bool in_tree[MAXV][MAXV];//在生成树中标记
int the_min[MAXV];//连通块到特殊点的最近的边
Edge dp[MAXV];

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

bool unite(int a, int b)//并查集合并
{
    int fa=findfather(a), fb=findfather(b);
    if(fa==fb)
        return false;
    if(high[fa]>high[fb])
        par[fb]=fa;
    else
    {
        par[fa]=fb;
        if(high[fa]==high[fb])
            ++high[fb];
    }
    return true;
}

void dfs(int u, int fa)
{
    for(int v=1;v<=V;++v)
        if(v!=fa && in_tree[u][v])
        {
            if(fa==-1)
                dp[v].cost=-INF;
            else
            {
                if(G[u][v]>dp[u].cost)
                {
                    dp[v].from=u;
                    dp[v].to=v;
                    dp[v].cost=G[u][v];
                }
                else dp[v]=dp[u];
            }
            dfs(v, u);
        }
}

bool degree_limit_tree()//返回是否能构成满足要求的树，形成的树保存在in_tree数组中
{
    //初始化
    for(int i=1;i<=V;++i)
    {
        par[i]=i;
        high[i]=0;
        for(int j=1;j<=V;++j)
            in_tree[i][j]=false;
    }
    //Kruskal计算求不与特殊点连接的边的最小生成树
    sort(edge+1, edge+1+E);
    for(int i=1;i<=E;++i)
    {
        if(edge[i].from>edge[i].to)
            swap(edge[i].from, edge[i].to);
        if(edge[i].from!=1 && unite(edge[i].from, edge[i].to))
            in_tree[edge[i].from][edge[i].to]=in_tree[edge[i].to][edge[i].from]=true;
    }
    //把各个连通块连接到特殊点
    for(int i=1;i<=V;++i)
        the_min[i]=-1;
    for(int i=1;i<=E;++i)
        if(edge[i].from==1)
        {
            int fa=findfather(edge[i].to);
            if(the_min[fa]==-1 || edge[i].cost<edge[the_min[fa]].cost)
                the_min[fa]=i;
        }
    int deg=0;//根节点度数
    for(int i=2;i<=V;++i)
        if(~the_min[i])
        {
            int id=the_min[i];
            in_tree[edge[id].from][edge[id].to]=G[edge[id].to][edge[id].from]=true;
            ++deg;
        }
        else if(the_min[findfather(i)]==-1)//有连通块无法连接到根节点
            return false;
    if(deg>K)//无法在限制内构成生成树
        return false;
    dp[1].cost=-INF;
    //不断增加特殊结点的度数
    for(++deg;deg<=K;++deg)
    {
        int add=INF, index=-1;
        dfs(1, -1);
        for(int v=2;v<=V;++v)
            if(G[1][v]!=INF && !in_tree[1][v] && add>G[1][v]-dp[v].cost)
            {
                add=G[1][v]-dp[v].cost;
                index=v;
            }
        if(add>=0)//不能使答案更小，跳出
            break;
        in_tree[1][index]=in_tree[index][1]=true;
        in_tree[dp[index].from][dp[index].to]=in_tree[dp[index].to][dp[index].from]=false;
    }
    return true;
}

map<string, int> to_id;

inline int get_id(char s[])
{
    int res=to_id[s];
    if(!res)
        to_id[s]=res=++V;
    return res;
}

void init()
{
    V=1;
    to_id.clear();
    to_id["Park"]=1;
    mem(G, 0x3f);
}

int main()
{
    while(~scanf("%d", &E))
    {
        init();
        for(int i=1;i<=E;++i)
        {
            char s[MAXLEN];
            scanf("%s", s);
            edge[i].from=get_id(s);
            scanf("%s", s);
            edge[i].to=get_id(s);
            scanf("%d", &edge[i].cost);
            if(G[edge[i].from][edge[i].to]>edge[i].cost)
                G[edge[i].from][edge[i].to]=G[edge[i].to][edge[i].from]=edge[i].cost;
        }
        scanf("%d", &K);
        degree_limit_tree();
        int ans=0;
        for(int i=1;i<=V;++i)
            for(int j=i+1;j<=V;++j)
                if(in_tree[i][j])
                    ans+=G[i][j];
        printf("Total miles driven: %d\n", ans);
    }

    return 0;
}