hdu3311 Dig The Wells(斯坦纳树模板题)

题目

n(1<=n<=5)个和尚，每个和尚位于一个寺庙内，标号1-n

m(0<=m<=1e3)个其他地方，标号n+1到n+m

以下n+m个数，为在第i个地方打井所需的代价

以下p(0<=p<=5e3)行，每行u，v，w，为在标号u和标号v之间建边的代价w

求最小代价和，使得所有和尚都能喝到水

思路来源

https://blog.csdn.net/u010372095/article/details/44656931

题解

所有喝到水，换言之，与打了井的地方连通，

把所有打井的点权代价认为是边权代价，和虚节点0相连，

构建含虚节点0的最小斯坦纳树，包含了所有点，也包含了最少一口井

 

斯坦纳树思想（摘自思路来源）

dp[i][state]表示以i为根，指定集合中的点的连通状态为state的生成树的最小总权值。

转移方程有两重：

第一重，先通过连通状态的子集进行转移。（通过划分的代价凑成完整的代价）

dp[i][state]=min{ dp[i][subset1]+dp[i][subset2] } 

枚举子集的技巧可以用 for(sub=(state-1)&state;sub;sub=(sub-1)&state)。

第二重，在当前枚举的连通状态下，对该连通状态进行松弛操作。（通过不换子集而换根尝试减少代价）

dp[i][state]=min{ dp[i][state], dp[j][state]+e[i][j] }

为什么只需对该连通状态进行松弛？

因为更后面的连通状态会由先前的连通状态通过第一重转移得到，所以无需对别的连通状态松弛。

松弛操作用SPFA即可。复杂度 O(n*3^k+cE*2^k)

c为SPFA复杂度中的常数，E为边的数量，但几乎达不到全部边的数量，甚至非常小。

3^k来自于子集的转移sum{C(i,n)*2^i} (1<=i<=n)，用二项式展开求一下和。

代码

#include<bits/stdc++.h>
using namespace std;
/*
 *  Steiner Tree：求，使得指定K个点连通的生成树的最小总权值
 *  st[i] 表示顶点i的标记值，如果i是指定集合内第m(0<=m<K)个点，则st[i]=1<<m 
 *  endSt=1<<K
 *  dptree[i][state] 表示以i为根，连通状态为state的生成树值
 */
const int N=1e3+10;
const int M=6e3+10;
const int K=7;
int dptree[N][1<<K],st[N],endSt;
int n,m,p;
int u,v,cost;
int head[N],nex[M<<1],V[M<<1],W[M<<1],cnt;
bool vis[N][1<<K];
queue<int> que;
void add(int u,int v,int w)
{
	V[++cnt]=v;
	W[cnt]=w;
	nex[cnt]=head[u];
	head[u]=cnt;
}
void initSteinerTree()
{
	cnt=0;
	memset(head,0,sizeof head);
	memset(dptree,-1,sizeof dptree);
	memset(st,0,sizeof st);
    for(int i=0;i<=n;i++)
    memset(vis[i],0,sizeof vis[i]);
    //对每个st[i]赋值 对endSt赋值 
}
void input()
{
    for(int i=0;i<=n;++i)
    st[i]=1<<i;
    for(int i=1;i<=n+m;++i)
    {
    	scanf("%d",&cost);
    	add(0,i,cost);
    	add(i,0,cost);
    }
    for(int i=1;i<=p;++i)
    {
    	scanf("%d%d%d",&u,&v,&cost);
    	add(u,v,cost);
    	add(v,u,cost);
    }
    endSt=1<<(n+1);
    for(int i=0;i<=n;i++)
    dptree[i][st[i]]=0;
}
void update(int &a,int x)
{
    a=(a>x || a==-1)? x : a;
}
void SPFA(int state)
{
    while(!que.empty())
	{
        int u=que.front();
        que.pop();
        vis[u][state]=false;
        for(int i=head[u];i;i=nex[i])
		{
            int v=V[i];//以v为根 不管v不是所选集合节点还是是 
            if(dptree[v][st[v]|state]==-1 || dptree[v][st[v]|state]>dptree[u][state]+W[i])
			{
        	    dptree[v][st[v]|state]=dptree[u][state]+W[i];
    	        if(st[v]|state!=state || vis[v][state])continue; //只用当前state更新所有根节点i的dp[i][state]的最小值 
        	    vis[v][state]=true;
       	 	    que.push(v);
            }
        }
    }
}
void steinerTree()
{
    for(int j=1;j<endSt;j++)
	{
        for(int i=0;i<=n+m;i++)
		{
            if(st[i] && (st[i]&j)==0) continue;//i要么不是选中集合的点 也就是新加的点 要么是枚举的j集合的子集 
            for(int sub=(j-1)&j;sub;sub=(sub-1)&j)
			{
                int x=st[i]|sub,y=st[i]|(j-sub);//sub是j的子集p+以i为根 j-sub是p的补集+以j为根 
                if(dptree[i][x]!=-1 && dptree[i][y]!=-1)
                update(dptree[i][j],dptree[i][x]+dptree[i][y]);//拆成两半枚举 
            }
            if(dptree[i][j]!=-1)//对于j状态 可以以i为根 
            {
            	que.push(i);
				vis[i][j]=true;
			}
        }
        SPFA(j);
    }
}
int main()
{
	while(~scanf("%d%d%d",&n,&m,&p))
	{
		initSteinerTree();
		input();
		steinerTree();
		printf("%d\n",dptree[0][endSt-1]);
	}
	return 0;
}