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;
}