Zoj 3613 Wormhole Transport (综合_斯坦纳树)

题目链接:  http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3613

题目大意: 给定一张图有n个顶点，某些点有工厂，某些点有资源，每个资源可以供应给一个工厂，有m条无向边，边有边权。已知有资源的点不超过4个，有工厂的点也不超过4个，问选择若干条边如何使有资源工厂的工厂最多，当数量一样多时输出最小权值。n <= 200, m <= 5000.


解题思路: 很一般的斯坦纳树。这类问题模型一般是固定的，就比如这题和Hdu 4085就十分相像，但这题会略微复杂点。首先是找有工厂和有资源的点然后先存起来，k = 工厂点数+资源点数,总状态为1<<k.然后这题的工厂数应该要大等于资源数，这个很显然，这样的话判断转改合法不合法就要判断着两个数量的关系了。

测试数据:

Input:
2
0 1
1 0
1
1 2 3

2
1 1
1 1
1
1 2 3

4
2 1
1 0
0 1
1 1
3
1 2 3
2 3 4
3 4 4

4
0 1
0 1
1 0
1 0
2
1 3 1
2 4 1

OutPut:
1 3
2 0
3 4
2 2

C艹代码:

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
#define MIN 1000
#define MAX 5100
#define INF (1<<29)
#define min(a,b) ((a)<(b)?(a):(b))


struct planet{

	int a,b;
}arr[MIN];
struct node {

	int v,len;
	node *next;
}*head[MAX*2],tree[MAX*2];
queue<int> qu;
bool in[MIN][MIN];
int k,res[MIN],tot,fac[MIN];
int n,m,ans,ansi,ptr,st[MIN],nn;
int orik,cost[MIN][MIN],dp[MIN];


void Initial() {

	int i,j,t;


	ptr = 0,orik = k;
	memset(st,0,sizeof(st));
	memset(in,false,sizeof(in));
	memset(head,NULL,sizeof(head));
	for (i = 0; i < tot; ++i)
		res[k++] = fac[i];

	
	nn = 1 << k;
	for (i = 0; i < nn; ++i) 
		for (j = 0; j < n; ++j)
			cost[j][i] = INF;


	for (i = 0; i < k; ++i)
		st[res[i]] = 1<<i,cost[res[i]][st[res[i]]] = 0;
}
void AddEdge(int a,int b,int c) {

	tree[ptr].v = b,tree[ptr].len = c;
	tree[ptr].next = head[a],head[a] = &tree[ptr++];
}
void Spfa() {

	while (!qu.empty()) {

		int j = qu.front() / MAX;
		int i = qu.front() % MAX;
		qu.pop(),in[j][i] = false;


		node *p = head[j];
		while (p != NULL) {

			int v = p->v,nst = i | st[v];
			if (cost[j][i] + p->len < cost[v][nst]) {

				cost[v][nst] = cost[j][i] + p->len;
				if (nst == i && !in[v][nst])
					qu.push(v*MAX+nst),in[v][nst] = true;
			}
			p = p->next;
		}
	}
}
void Steiner_Tree() {

	int i,j,t,s;
	for (i = 0; i < nn; ++i) {

		for (j = 0; j < n; ++j) {
			
			if (st[j] && !(st[j] & i)) continue; 
			for (t = (i-1)&i; t; t = (t-1)& i) 
				cost[j][i] = min(cost[j][i],cost[j][t|st[j]]+cost[j][(i-t)|st[j]]);
			if (cost[j][i] != INF) qu.push(j*MAX+i),in[j][i] = true;	
		}
		Spfa();
	}
}
int Check(int st) {

	int i,cnt = 0;
	for (i = 0; i < orik; ++i)
		if (st & (1<<i)) cnt++;
	for (i = orik; i < k; ++i)
		if (st & (1<<i)) cnt -= arr[fac[i-orik]].a;
	return cnt <= 0;
}
void Solve_DP() {

	int i,j,t;
	for (i = 0; i < nn; ++i) {

		dp[i] = INF;
		for (j = 0; j < n; ++j)
			dp[i] = min(dp[i],cost[j][i]);
	}


	for (i = 0; i < nn; ++i)
		if (Check(i))for (t = (i-1)&i; t; t = (t-1)&i)
			if (Check(t)&&Check(i-t)) dp[i] = min(dp[i],dp[t]+dp[i-t]);
	for (i = 0; i < nn; ++i)
		if (dp[i] != INF && Check(i)){

			int cnt = 0;
			for (j = 0; j < orik; ++j)
				if (i & (1<<j)) cnt++;
			if (cnt > ans) ans = cnt,ansi = dp[i];
			else if (cnt == ans && ansi > dp[i]) ansi = dp[i];
		}
}


int main()
{
	int i,j,a,b,c,num;


	while (scanf("%d",&n) != EOF) {

		ans = ansi = 0;
		num = k = tot = 0;
		for (i = 0; i < n; ++i) {

			scanf("%d%d",&arr[i].a,&arr[i].b);
			if (arr[i].a && arr[i].b)
				num++,arr[i].a--,arr[i].b--;
			if (arr[i].a) fac[tot++] = i;
			if (arr[i].b) res[k++] = i;
		}
		

		Initial();
		scanf("%d",&m);
		for (i = 0; i < m; ++i) {

			scanf("%d%d%d",&a,&b,&c);
			a--,b--;
			AddEdge(a,b,c),AddEdge(b,a,c);
		}
		

		Steiner_Tree();
		Solve_DP();
		printf("%d %d\n",ans+num,ansi);
	}
}

本文ZeroClock原创，但可以转载，因为我们是兄弟。