【算法】斯坦纳树

参考资料

• OI-Wiki: 斯坦纳树
• T_a_r_j_a_n: [图论]-------斯坦纳树
• 编程客: 集合枚举子集-学习笔记

概念

斯坦纳树原本是在一个几何图中提出来的问题。在一个平面内给出 $n$ 个点 $p_i$，可以加入一些新的点（称为斯坦纳点），要求在使得这些点连通并且边的总长度最小。

在 OI 中，斯坦纳树不再是在几何图上的问题，而是变成了图上的问题。它用于解决给出有 $n$ 个点和 $m$ 条边的一张图，选出 $k$ 个关键点，要求在边集中选出一些边使得这些点连通，并且选出的边的边权之和最小。有时只选这 $k$ 个点不一定使得代价最小，而需要选一部分非关键点。

可以将斯坦纳树理解为针对于关键点的最小生成树问题，同样，最小生成树也可以理解为斯坦纳树的普遍情况。但两者的解决方式完全不同，斯坦纳树用到的是状态压缩 dp。

实现

通过最小生成树的想法，我们不难想到最后选出的这些边构成的一定是一颗树。因此我们设 $dp_{i,s}$ 表示以 $i$ 为根节点的子树内包含点的状态是 $s$。

1. 子集转移

以 $i$ 为根节点的子树内还可以继续进行划分，然后划分后的子树包含点的状态的并集就是 $s$。那么枚举 $s$ 的子集 $t$，$dp_{i,s}=\min(dp_{i,t}+dp_{i,s-t})$，$s-t$ 在二进制含义下也可以写成 $s\oplus t$，表示 $t$ 对于 $s$ 的补集。

如何枚举子集？常见的代码是这样的：for(int t=s;t;t=(t-1)&s)，但是为什么这样是可行的？

首先 $s$ 一定是 $s$ 的子集，而后面进行的又是与的操作，因此保证 $t$ 一定是 $s$ 子集。

其次，减法和按位与都可以保证枚举出来的 $t$ 单调递减，因此保证不重。

最后，$t-1$ 在二进制下相当于将 $t$ 最低位的 $1$ 更改为 $0$，并且这一位右边的 $0$ 全部更改为 $1$，最后和 $s$ 与上之后一定就是最靠近 $t$ 的另一个子集，因此可以保证不漏。

dp 状态的初始值除原本就是关键点的一开始都是正无穷，而是关键点的只有 $s$ 中只有它这一个点的代价是 $0$，其余也是正无穷。最后随便找一个关键点做根即可。

2. 松弛

$dp_{i,s}$ 不仅可以由自己本身的子树划分中转移而来，还可能是由别的点进行添边操作而来的。由此得，$dp_{i,s}=\min{dp_{j,s}+w(i,j)}$。发现这就是一个最短路的松弛操作，用 spfa 或者 dijkstra 对于每一个 $s$ 在子集转移后跑一遍即可。

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e2+5;
const int K=2e3+5;
const int M=5e2+5;
int n,m,k;
int head[N],tot;
int dp[N][K];
int a[N];

struct node{
    int nex,to,w;
}edge[M<<1];

void add(int x,int y,int z){
    edge[++tot].nex=head[x];
    edge[tot].to=y;
    edge[tot].w=z;
    head[x]=tot;
}

struct Node{
    int x,v;
    bool operator < (const Node &x) const{
        return x.v<this->v;
    }
};

bool vis[N];

void dijkstra(int s){
    priority_queue<Node>q;
    for(int i=1;i<=n;++i){
        if(dp[i][s]!=(int)1e9){
            Node sta={i,dp[i][s]};
            q.push(sta);
        }
        vis[i]=false;
    }
    while(!q.empty()){
        int x=q.top().x;
        q.pop();
        if(vis[x]) continue;
        vis[x]=true;
        for(int i=head[x];i;i=edge[i].nex){
            int v=edge[i].to;
            // cout<<dp[x][s]<<" "<<edge[i].w<<"\n";
            if(dp[x][s]+edge[i].w<dp[v][s]){
                dp[v][s]=dp[x][s]+edge[i].w;
                Node nxt={v,dp[v][s]};
                q.push(nxt);
            }
        }
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin>>n>>m>>k;
    for(int i=1;i<=m;++i){
        int x,y,w;
        cin>>x>>y>>w;
        add(x,y,w);
        add(y,x,w);
    }
    for(int s=0;s<(1<<k);++s){
        for(int i=1;i<=n;++i) dp[i][s]=(int)1e9;
    }
    for(int i=1;i<=k;++i){
        cin>>a[i];
        dp[a[i]][1<<(i-1)]=0;
    }

    for(int s=1;s<(1<<k);++s){
        for(int i=1;i<=n;++i){
            for(int t=s&(s-1);t;t=(t-1)&s){
                dp[i][s]=min(dp[i][s],dp[i][t]+dp[i][s^t]);
            }
        }
        dijkstra(s);
    }
    cout<<dp[a[1]][(1<<k)-1];
    return 0;
} 

例题

咕咕