zoj3613 Wormhole Transport(斯坦纳树/子集条件限制)

题目

N(N<=200)个星球，第i个星球有pi，si两个参数

pi代表星球有pi个工厂，si={0,1}代表星球是否为资源星球

一个资源星球只能给一个工厂提供资源，

以下m(0<m<=5e3)行u,v,w为在星球间建边的代价

在工厂数<=4且资源星球数<=4的情况下

最大化工厂运作数num，num相等条件下最小化建边总代价cost

思路来源

http://www.it610.com/article/1247393.htm

题解

将是工厂的星球和是资源的星球压到二进制位里，

注意对于两个都是的星球，需存二者的or值

先处理出dp[i][state]的值，

考虑每一个状态ans[state]是所有合法i中的dp[i][state]的最小值

再考虑枚举子集，剪枝是先判当前状态工厂数>=资源数，

若不满足这一点，必有资源浪费，使答案不为最大

那么从两个子集转移来时，最优子结构也要求二者满足剪枝要求

不关心树根是谁，只关心ans[]的值，处理ans[]的时候动态更新

 

spfa()有把state和顶点u用位运算压在一个int里的不同位段的写法，

也有乘上一个maxn左右的数最后用商/maxn和余数%maxn分离的写法

但感觉没有必要，不如这个板子清晰易懂

代码

#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,这里K用tot表示 
 *  dp[i][state] 表示以i为根，连通状态为state的生成树值
 */
const int N=210;
const int M=6e3+10;
const int K=9;
int p[N],s[N];
int dp[N][1<<K],st[N],endSt;
int ans[1<<K];
int n,m;
int f,r,tot,sum[K];//factory,resource,tot
int u,v,num,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()
{
	num=cost=0;
	cnt=tot=0;
	f=r=0;
	memset(head,0,sizeof head);
	memset(dp,-1,sizeof dp);
	memset(ans,-1,sizeof ans);
	memset(st,0,sizeof st);
    for(int i=1;i<=n;i++)
    memset(vis[i],0,sizeof vis[i]);
    //对每个st[i]赋值 对endSt赋值 
}
void input()
{
    for(int i=1;i<=n;++i)
    {
  	  scanf("%d%d",&p[i],&s[i]);
  	  f+=p[i]>0;//此处有工厂 
  	  r+=s[i];
  	}
  	for(int i=1;i<=n;++i)
  	if(p[i])
  	{
  		sum[tot]=p[i];
  		st[i]|=1<<(tot++);
  	}
  	for(int i=1;i<=n;++i)
  	if(s[i])st[i]|=1<<(tot++);//注意|= 可能存在既为resource又为factory的情形 
    scanf("%d",&m);
    for(int i=1;i<=m;++i)
    {
    	scanf("%d%d%d",&u,&v,&cost);
    	add(u,v,cost);
    	add(v,u,cost);
    }
    //tot是总的处于集合中的点的数量 
    endSt=1<<tot;
    for(int i=1;i<=n;i++)
    if(st[i])dp[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(dp[v][st[v]|state]==-1 || dp[v][st[v]|state]>dp[u][state]+W[i])
			{
        	    dp[v][st[v]|state]=dp[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=1;i<=n;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(dp[i][x]!=-1 && dp[i][y]!=-1)
                update(dp[i][j],dp[i][x]+dp[i][y]);//拆成两半枚举 
            }
            if(dp[i][j]!=-1)//对于j状态 可以以i为根 
            {
            	que.push(i);
				vis[i][j]=true;
			}
        }
        SPFA(j);
    }
}
bool ok(int state)
{
	//保证工厂数>=资源数 否则有资源浪费 一定不是最优解 
	int res=0;
	for(int i=0;i<f;++i)
	if(state>>i&1)res+=sum[i];//工厂 
	for(int i=f;i<tot;++i)
	if(state>>i&1)res--;//资源 
	return res>=0;
}
void upgrade(int state,int c,int &num,int &cost)
{
	int res=0;
	for(int i=f;i<tot;++i)
	if(state>>i&1)res++;
	if(res>num||(res==num&&c<cost))
	{
		//printf("state:%d c:%d\n",state,c);
		num=res;
		cost=c;
	}
}
void solve()
{
	for(int j=1;j<endSt;++j)
	{
		for(int i=1;i<=n;i++)//枚举根为i 状态j最小值为ans[j] 
		if(dp[i][j]!=-1) 
		update(ans[j],dp[i][j]);
		//printf("ans[%d]:%d\n",j,ans[j]); 
	}
	for(int j=1;j<endSt;++j)
	{
		if(!ok(j))continue;
       	for(int sub=(j-1)&j;sub;sub=(sub-1)&j)
		{
         	int x=sub,y=j-sub;//sub是j的子集p+以i为根 j-sub是p的补集+以j为根
			if(!ok(x)||!ok(y))continue;
			if(ans[x]!=-1 && ans[y]!=-1) 
           	update(ans[j],ans[x]+ans[y]);//拆成两半枚举
        }
        if(ans[j]!=-1)upgrade(j,ans[j],num,cost);	
	} 
	printf("%d %d\n",num,cost);
}
int main()
{
	while(~scanf("%d",&n))
	{
		initSteinerTree();
		input();
		steinerTree();
		solve();
	}
	return 0;
}