定义
在一张无向带权图中,找出一棵生成树,使得某个特定结点的度数不超过
K
或者恰好等于
求解算法
首先我们对不与特殊结点相连的边求最小生成树,得到几个连通分量。然后找出每个连通分量到特殊结点的最短的边,把这条边添加到生成树中,这样我们就得到了一个度限制为连通分量数的最小生成树。如果有连通分量到特殊结点没有边,则说明无法构成生成树。如果连通分量数大于
K
,则说明无法在度数限制下构成生成树。
对于当前求得的K度生成树,我们可以求出
总时间复杂度
O(E×logE+K×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;
}