最小斯坦纳树

最小斯坦纳树

给定 $k$ 个关键点必须选，选一些点，选一些边连接他们，求总边权最小。

首先最终肯定选出一棵树。看到 $k$ 的范围，果断状压。

$dp[i][S]$ 表示以 $i$ 为根，至少（不是恰好）包含 $S$ 中的关键点的最小边权总和。

如果最终的树中 $i$ 的度数 $>1$，考虑把树分成两个树，各自包含不同的关键点：

$dp[i][S]\leftarrow min(dp[i][S],dp[i][T]+dp[i][S-T]).$

$T$ 是枚举的 $S$ 的一个真子集。

否则，就考虑 $i$ 唯一连着的结点 $j$:

$dp[i][S]\leftarrow min(dp[i][S],dp[j][S]+w(j,i)).$

我们发现，这个式子和求最短路的松弛式子意外的相似：

$dist(v)\leftarrow min(dist(v),dist(u)+w(v,u)).$

我们可以通过求最短路的方式求。我们可以在每次从队列中取出 $i$ 这个结点，然后拓展 $i$ 的所有邻点。

详见代码注释。

#include <bits/stdc++.h>

using namespace std;

const int maxn = 510;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> P;
int n, m, k;

struct edge {
  int to, next, w;
} e[maxn << 1];

int head[maxn << 1], tree[maxn << 1], tot;
int dp[maxn][5000], vis[maxn];
int key[maxn];
priority_queue<P, vector<P>, greater<P> > q;

void add(int u, int v, int w) {
  e[++tot] = edge{v, head[u], w};
  head[u] = tot;
}

void dijkstra(int s) {  
// 求解最短路，注意这里的S是给定的状态，dijkstra应当只更新dp[x][s]，真正的起点已经在调用之前塞进队列里了 
  memset(vis, 0, sizeof(vis));
  while (!q.empty()) {
    P item = q.top();
    q.pop();
    if (vis[item.second]) continue;
    vis[item.second] = 1;
    for (int i = head[item.second]; i; i = e[i].next) {
      if (dp[tree[i]][s] > dp[item.second][s] + e[i].w) { 
	  //如果tree[i]这个点当作根只有item.second(通过i拓展了若干次的结点得到item.second) 这一个儿子，
	  //那么根据状态转移式，可以用dp[item.second][s]尝试更新dp[tree[i]][s]
	  //注意这里即使使用了s之外的关键点为根也无所谓——我们定义的dp是至少不是恰好 
        dp[tree[i]][s] = dp[item.second][s] + e[i].w;
        q.push(P(dp[tree[i]][s], tree[i]));
      }
    }
  }
}

int main() {
  memset(dp, INF, sizeof(dp));
  scanf("%d %d %d", &n, &m, &k);
  int u, v, w;
  for (int i = 1; i <= m; i++) {
    scanf("%d %d %d", &u, &v, &w);
    add(u, v, w);
    tree[tot] = v;
    add(v, u, w);
    tree[tot] = u;
  }
  for (int i = 1; i <= k; i++) {
    scanf("%d", &key[i]);
    dp[key[i]][1 << (i - 1)] = 0; //dp初值 
  }
  for (int s = 1; s < (1 << k); s++) {
    for (int i = 1; i <= n; i++) {
      for (int subs = s & (s - 1); subs; subs = s & (subs - 1)) { //子集枚举，复杂度 O(3^n) 
        dp[i][s] = min(dp[i][s], dp[i][subs] + dp[i][s ^ subs]); //第一个转移式子 
    	}
      if (dp[i][s] != INF) q.push(P(dp[i][s], i)); //如果连起点都到达不了就不必要了（注意这里提前放好起点） 
    }
    dijkstra(s); //拓展，dp[i][S]能尝试更新所有 dp[x][S]，x是任意i可达的结点 
  }
  printf("%d\n", dp[key[1]][(1 << k) - 1]); //其实这里根取哪个关键点都无所谓 
  return 0;
}