斯坦纳树

• 定义：

• 斯坦纳树问题是组合优化问题，是最短网络的一种
• 其实最小生成树是最小斯坦纳树的一种特殊情况
• 最小生成树是在给定的点集和边中寻求最短网络使所有点连通
• 而最小斯坦纳树允许在给定点外增加额外的点，使生成的最短网络开销最小

• 求解：

• 首先我们知道，最优解必然是一棵树，这棵树又是由若干棵子树合并成的，
  于是我们可以状态压缩，把k个节点的连通状态用一个二进制数j表示
  dp[i][j]表示以i为根，与对应状态为j

  的节点连通的子树的最小权值

  有两种转移方法：

• 枚举子树的形态：dp[i][j]=min(dp[i][j]，dp[i][k]+dp[i][l])，其中k和l是对j的一个划分
• 按照边进行松弛：dp[i][j]=min(dp[i][j]，dp[i′][j]+w[i][i′])，其中i和i′之间有边相连

• 对于第一种转移，我们直接枚举子集就行了
  对于第二种转移，我们仔细观察可以发现这个方程和最短路的约束条件是很类似的，于是我们可以用spfa或者dijkstra来进行状态转移

  枚举子集的复杂度=n∗∑C(k，i)∗2i=n∗3k，spfa的复杂度为n∗2k

  所以总复杂度为O(n∗3k)

• 基础模板：

int f[1<<M][N];
queue<int> q;
bool in[N];

void spfa(int S)
{
    while (!q.empty())
    {
        int now=q.front(); q.pop();
        in[now]=0;
        for (int i=st[now];i;i=way[i].nxt)
        {
            int y=way[i].y;
            if (f[S][y]>f[S][now]+val[y])
            {
                f[S][y]=f[S][now]+val[y];
                if (!in[y]) q.push(y),in[y]=1;
            }
        }
    }
}

void work()
{
    int cnt=0;
    memset(f,0x7f,sizeof(f));

    for (int i=1;i<=n;i++)
        if (!val[i]) f[1<<cnt][i]=0,cnt++;
    for (int S=1;S<(1<<cnt);S++)
    {
        for (s=(S-1)&S;s;s=(s-1)&S) 
            for (int i=1;i<=n;i++)
                f[S][i]=min(f[S][i],f[s][i]+f[S^s][i]-val[i]);
        for (int i=1;i<=n;i++)
            if (f[S][i]<INF&&!in[i])
                q.push(i),in[i]=1;
        spfa(S);
    }

    int ans=INF;
    for (int i=1;i<=n;i++) ans=min(ans,f[(1<<cnt)-1][i]);
    printf("%d\n",ans);
}

 poj3123

• 给出n个点，m条边，给出四组点，让它们连通，求最小花费。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <map>
typedef long long int ll;
const int MOD = (int)1e9 + 7;
const int INF = 99999999;
using namespace std;

int n, m;
map<string, int> city;
int dp1[1 << 8][35];
int dp2[1 << 8];
int d[35][35];
int vis[35];

bool check(int s)
{
    for (int i = 0; i < 4; i++)
    {
        if (((s & 3) != 3) && ((s & 3) != 0))
            return false;

        s >>= 2;
    }

    return true;
}

int main()
{
    while (~scanf("%d%d", &n, &m) && (n || m))
    {
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                d[i][j] = (i == j) ? 0 : INF;

        string s1, s2;
        int w;
        for (int i = 0; i < n; i++)
        {
            cin >> s1;
            city[s1] = i;
        }
        for (int i = 0; i < m; i++)
        {
            cin >> s1 >> s2 >> w;
            int u = city[s1];
            int v = city[s2];

            if (w < d[u][v])
                d[u][v] = d[v][u] = w;
        }

        // Floyd
        for (int k = 0; k < n; k++)
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++)
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);

        for (int i = 0; i < 8; i++)
        {
            cin >> s1;

            for (int j = 0; j < n; j++)
                dp1[1 << i][j] = d[j][city[s1]];
        }

        for (int i = 0; i < (1 << 8); i++)
        {
            if (!(i & (i - 1)))
                continue;

            for (int j = 0; j < n; j++)
            {
                dp1[i][j] = INF;

                for (int sub = (i - 1) & i; sub != 0; sub = (sub - 1) & i)
                    dp1[i][j] = min(dp1[i][j], dp1[sub][j] + dp1[i - sub][j]);
            }

            memset(vis, 0, sizeof(vis));

            int min_w, min_i;
            for (int j = 0; j < n; j++)
            {
                min_w = INF;

                for (int k = 0; k < n; k++)
                {
                    if (dp1[i][k] < min_w && !vis[k])
                    {
                        min_w = dp1[i][k];
                        min_i = k;
                    }
                }

                vis[min_i] = 1;

                for (int k = 0; k < n; k++)
                    dp1[i][min_i] = min(dp1[i][min_i], dp1[i][k] + d[k][min_i]);
            }
        }

        for (int i = 0; i < (1 << 8); i++)
        {
            dp2[i] = INF;

            for (int j = 0; j < n; j++)
                dp2[i] = min(dp2[i], dp1[i][j]);
        }

        for (int i = 0; i < (1 << 8); i++)
        {
            if (check(i))
            {
                for (int j = i; j != 0; j = (j - 1) & i)
                {
                    if (check(j))
                        dp2[i] = min(dp2[i], dp2[j] + dp2[i - j]);
                }
            }
        }
        printf("%d\n", dp2[(1 << 8) - 1]);
    }
    return 0;
}