最近打全国高校绿色计算机大赛遇到了一个斯坦纳树(决赛第二阶段第三题),当时网上找了模板水过去了,赛后学习一下
【一】什么是斯坦纳树
斯坦纳树问题是组合优化学科中的一个问题。将指定点集合中的所有点连通,且边权总和最小的生成树称为最小斯坦纳树(Minimal Steiner Tree),其实最小生成树是最小斯坦纳树的一种特殊情况。而斯坦纳树可以理解为使得指定集合中的点连通的树,但不一定最小。
【二】如何求解斯坦纳树
可以用DP求解,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),用二项式展开求一下和。
【三】模板
/*
* Steiner Tree:求,使得指定K个点连通的生成树的最小总权值
* st[i] 表示顶点i的标记值,如果i是指定集合内第m(0<=m<K)个点,则st[i]=1<<m
* endSt=1<<K
* dptree[i][state] 表示以i为根,连通状态为state的生成树值
*/
#define CLR(x,a) memset(x,a,sizeof(x))
int dptree[N][1<<K],st[N],endSt;
bool vis[N][1<<K];
queue<int> que;
int input()
{
/*
* 输入,并且返回指定集合元素个数K
* 因为有时候元素个数需要通过输入数据处理出来,所以单独开个输入函数。
*/
}
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;
}
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);
}
}
【四】hdu4085
题意:n个点编号为1~n,m条双向边,每条边都有一个边权,n个点中前k个点构成点集s1,后k个点构成点集s2,现在要选择一些边使得两个集合中的点可以一一对应(这个一一对应可以理解为s1中的点全部出发,顺着选好的边走,每个点都可以在s2那里找到一个归宿,且不重复),总边权之和最小是多少?
思路:比较明显的斯坦纳树,但是最后的边不一定非要连通,可能是一个森林,所以求完斯坦纳树后还要进行一遍状压dp,这个状压dp合并状态时只能合并合法状态,合法状态的定义为已选择的s1中的点的个数要等于已选择的s2中的点的个数
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
const int maxm = 2000 + 10;
const int maxs = 12;
const int INF = 0x3f3f3f3f;
int N, M, K;
int st[maxn], endst, dp[maxn][1<<maxs];
bool vis[maxn][1<<maxs];
queue<int> que;
int tot, head[maxn];
struct Edge { int to, cost, next; }edges[maxm];
int f[1<<maxs];
void init_edges() {
tot = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int cost) {
edges[tot].to = v; edges[tot].cost = cost; edges[tot].next = head[u]; head[u] = tot++;
}
void initstn() {
memset(st, 0, sizeof(st));
memset(dp, -1, sizeof(dp));
memset(vis, 0, sizeof(vis));
int bit = 0;
for (int i = 1; i <= K; i++) {
st[i] = (1<<bit);
bit++;
}
for (int i = N-K+1; i <= N; i++) {
st[i] = (1<<bit);
bit++;
}
endst = (1<<bit);
for (int i = 1; i <= N; 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 = edges[i].next) {
int v = edges[i].to, cost = edges[i].cost;
if (dp[v][st[v]|state] == -1 || dp[v][st[v]|state] > dp[u][state] + cost) {
dp[v][st[v]|state] = dp[u][state] + cost;
if ((st[v]|state) != state || vis[v][state]) continue;
vis[v][state] = true;
que.push(v);
}
}
}
}
void stn() {
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 (dp[i][x] != -1 && dp[i][y] != -1) {
update(dp[i][j], dp[i][x]+dp[i][y]);
}
}
if (dp[i][j] != -1) {
que.push(i); vis[i][j] = true;
}
}
spfa(j);
}
}
bool judge(int s) {
int cnt1 = 0;
for (int i = 0; i < K; i++) {
if (s & (1<<i)) cnt1++;
}
int cnt2 = 0;
for (int i = K; i < 2*K; i++) {
if (s & (1<<i)) cnt2++;
}
return cnt1 == cnt2;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d%d", &N, &M, &K);
init_edges();
for (int i = 0; i < M; i++) {
int u, v, cost;
scanf("%d%d%d", &u, &v, &cost);
addedge(u, v, cost);
addedge(v, u, cost);
}
initstn();
stn();
for (int i = 0; i < endst; i++) {
f[i] = INF;
for (int j = 1; j <= N; j++) {
if (dp[j][i] != -1) f[i] = min(f[i], dp[j][i]);
}
}
for (int s = 1; s < endst; s++) {
if (!judge(s)) continue;
for (int sub = (s-1)&s; sub; sub = (sub-1)&s) {
if (!judge(sub)) continue;
f[s] = min(f[s], f[sub] + f[s-sub]);
}
}
if (f[endst-1] == INF) puts("No solution");
else printf("%d\n", f[endst-1]);
}
return 0;
}
参考博文:https://www.cnblogs.com/ECJTUACM-873284962/p/7643445.html