ZOJ 3613 Wormhole Transport

题意：n个星球组成的一张图，星球上有资源、工厂或者什么都没有（一个星球上可以有多个工厂，但只能有一个资源，这种星球最多8个）。每个工厂需要有一个有资源星球为它提供资源才能生产。已知在各各星球间建立运输用的虫洞的花费，求最多有多少工厂能生产同时求最小花费。

思路：一开始我还以为是网络流，但是N分钟过去后毫无想法。。。无奈算法能力太弱，搜了解题报告后才知道有斯坦纳树这东西。学了一下，终于会做了。

        解法就是先求出这张图关于那K（K<=8）个有资源或者工厂的星球的最小斯坦纳树，最优解显然是一种树型状态的连接方式。因为最终解可能由多棵树组成的深林，所以最后还需要DP一下，求出最优的组合，dp[state]表示深林中由K个点中哪些点组成，转移方程：dp[state]=min{ dp[state], dp[ div1 ]+dp[ div2 ] }（div1和div2是对state的一种划分）。然后我们只找工厂个数大于资源个数的state即可，所以还要check一下状态。

关于上述的斯坦纳树可以看这里：http://blog.csdn.net/gzh1992n/article/details/9119543

代码：

#include <algorithm>
#include <iostream>
#include <string>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <set>
#include <bitset>
#include <map>
using namespace std;

/*--in common define-----*/
#define N  410
#define E  100010
#define ll long long
const int INF   =0x3fffffff;
const int PRIME =999983;
const int MOD   =1000000007;
const int MULTI =1000000007;
const double EPS=1e-6;
/*--end in common define-*/

/*--in common use--------*/
#define CUBE(x) ((x)*(x)*(x))
#define SQ(x)     ((x)*(x))
#define ALL(x)     x.begin(),x.end()
#define CLR(x,a) memset(x,a,sizeof(x))
#define maxAry(a,n) max_element(a,a+(n))
#define minAry(a,n) min_element(a,a+(n))
inline bool isodd(int x){return x&1;}
inline bool isodd(ll x) {return x&1;}
/*--end in common use----*/


int n,inc,num[N],type[N],dp[1<<8],cnt[N];
int fac,res;
int eid,p[N];

struct edge{
	int vid,w,next;
}e[E];

void init()
{
	CLR(p,-1);
	CLR(dp,-1);
	eid=0;
}

void insert(int from,int to,int w)
{
	e[eid].vid=to;
	e[eid].w=w;
	e[eid].next=p[from];
	p[from]=eid++;
}

int dptree[N][1<<8],st[N],endSt; //dptree[i][j] 以i为根，形态为j
bool vis[N][1<<8];
queue<int> que;

int input()
{
	inc=fac=res=0;
	for(int i=1;i<=n;i++){
		scanf("%d%d",&num[i],&type[i]);
		if(num[i] && type[i]){
			inc++; num[i]--; type[i]=0;
		}
		if(num[i]){
			st[i]=1<<fac;
			cnt[fac++]=num[i];
		}
	}
	for(int i=1;i<=n;i++)
		if(type[i])
			st[i]=1<<(fac+res++);
	return fac+res;
}

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=p[u];i!=-1;i=e[i].next){
			int v=e[i].vid;
			if(dptree[v][st[v]|state]==-1 || 
				dptree[v][st[v]|state]>dptree[u][state]+e[i].w){

			    dptree[v][st[v]|state]=dptree[u][state]+e[i].w;
				if(st[v]|state!=state || vis[v][state]) 
					continue; //只更新同层
				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;
			for(int sub=(j-1)&j;sub;sub=(sub-1)&j){
				int x=st[i]|sub,y=st[i]|(j-sub);
				if(dptree[i][x]!=-1 && dptree[i][y]!=-1)
					update(dptree[i][j],dptree[i][x]+dptree[i][y]);
			}
			if(dptree[i][j]!=-1) 
				que.push(i),vis[i][j]=true;
		}
		SPFA(j);
	}
}

void initSteinerTree()
{
	CLR(dptree,-1);
	CLR(st,0);
	for(int i=1;i<=n;i++) CLR(vis[i],0);
	endSt=1<<input();
	for(int i=1;i<=n;i++)
		dptree[i][st[i]]=0;
}

bool check(int state)
{
	int ans=0;
	for(int i=0;state;state>>=1,i++){
		if(state&1) ans+=i<fac? cnt[i]:-1;
	}
	return ans>=0;
}

int count(int state)
{
	int ans=0;
	for(int i=0;state;state>>=1,i++){
		if(state&1) ans+=i<fac? 0:1;
	}
	return ans;
}

pair<int,int> solve()
{
	int ans=0,cost=0;
	steinerTree();
	for(int j=1;j<endSt;j++){
		for(int i=1;i<=n;i++)
			if(dptree[i][j]!=-1)
				update(dp[j],dptree[i][j]);
	}
	for(int j=1;j<endSt;j++){
		if(check(j)){
			for(int sub=(j-1)&j;sub;sub=(sub-1)&j){
				int x=sub,y=j-sub;
				if(dp[x]!=-1 && dp[y]!=-1 && check(x) && check(y))
					update(dp[j],dp[x]+dp[y]);
			}
			if(dp[j]==-1) continue;
			int tmp=count(j);
			if(tmp>ans || (tmp==ans && dp[j]<cost))
				ans=tmp,cost=dp[j];
		}
	}
	return make_pair(ans,cost);
}

int main()
{
	while(~scanf("%d",&n)){
		init();
		initSteinerTree();
		int m;
		scanf("%d",&m);
		while(m--){
			int x,y,c;
			scanf("%d%d%d",&x,&y,&c);
			insert(x,y,c);
			insert(y,x,c);
		}
		pair<int,int> pr;
		pr=solve();
		printf("%d %d\n",pr.first+inc,pr.second);
	}
	return 0;
}