最近打全国高校绿色计算机大赛遇到了一个斯坦纳树（决赛第二阶段第三题），当时网上找了模板水过去了，赛后学习一下

【一】什么是斯坦纳树

斯坦纳树问题是组合优化学科中的一个问题。将指定点集合中的所有点连通，且边权总和最小的生成树称为最小斯坦纳树（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