[BZOJ4006][JLOI2015]管道连接-最小斯坦纳树-动态规划

管道连接

Description

小铭铭最近进入了某情报部门，该部门正在被如何建立安全的通道连接困扰。

该部门有 n 个情报站，用 1 到 n 的整数编号。给出 m 对情报站 ui;vi 和费用 wi，表示情
报站 ui 和 vi 之间可以花费 wi 单位资源建立通道。
如果一个情报站经过若干个建立好的通道可以到达另外一个情报站，那么这两个情报站就
建立了通道连接。形式化地，若 ui 和 vi 建立了通道，那么它们建立了通道连接；若 ui 和 vi 均与 ti 建立了通道连接，那么 ui 和 vi 也建立了通道连接。
现在在所有的情报站中，有 p 个重要情报站，其中每个情报站有一个特定的频道。小铭铭
面临的问题是，需要花费最少的资源，使得任意相同频道的情报站之间都建立通道连接。

Input

第一行包含三个整数 n;m;p，表示情报站的数量，可以建立的通道数量和重要情报站的数量。接下来 m 行，每行包含三个整数 ui;vi;wi，表示可以建立的通道。最后有 p 行，每行包含两个整数 ci;di，表示重要情报站的频道和情报站的编号。

Output

输出一行一个整数，表示任意相同频道的情报站之间都建立通道连接所花费的最少资源总量。

Sample Input

5 8 4
1 2 3
1 3 2
1 5 1
2 4 2
2 5 1
3 4 3
3 5 1
4 5 1
1 1
1 2
2 3
2 4

Sample Output

4

HINT

选择 (1; 5); (3; 5); (2; 5); (4; 5) 这 4 对情报站连接。

对于 100% 的数据，0 < ci <= p <= 10; 0 < ui;vi;di <= n <= 1000; 0 <= m <= 3000; 0 <= wi <=20000。

---

第一次写最小斯坦纳树……
这么经典的姿势居然之前从未遇到过……

---

思路:
最终答案一定是若干个联通块，每个联通块包含若干种频道的点。
于是状压，设$dp[i]$代表选择的频道集合为$i$时，最优的方案。

可以发现，$dp[i]=\min(g[i],\min\limits_{j \in i}(dp[j]+dp[i \wedge j]))$
其中，$g[i]$代表对应频道在集合$i$内的所有重要情报站共同构成一个联通块时的最优方案。

考虑如何计算$g[i]$。
可以发现，问题即给定一个点集$S$，求原图的一棵生成树满足$S$中的点联通的同时，总边权最小。
这就是最小斯坦纳树解决的问题。

最小斯坦纳树同样需要状压。
设$f[i][j]$表示以$j$为根，已经联通的点集为$i$的最小代价。

转移有两种。
第一种为合并状态:

$$f[i][j]=\min_{k \in i}(f[k][j]+f[i \wedge k][j])$$
第二种为移动根节点，这部分采用spfa转移:
$$f[i][j]=\min_{k \in ch[j]}(f[i][k]+w[j][k])$$
其中 $w[i][j]$为 $i$到$j$的边权。
最后可知最优方案 $ans=\min\limits_{i=1}^n(f[all][i])$。

于是这就做完了~

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

const int P=19;
const int N=1009;
const int M=3009;
const int K=(1<<10)+9;
const int Inf=2139062143;

int n,m,p;
int c[P],d[P],ha[P],htop;
int to[M<<1],nxt[M<<1],w[M<<1],beg[N],tot;
int f[K][N],dp[K],inq[N];
queue<int> q;

inline bool chkmin(int &a,int b){if(a>b){a=b;return 1;}return 0;}

inline void add(int u,int v,int c)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    w[tot]=c;
    beg[u]=tot;
}

inline void spfa(int *f)
{
    while(!q.empty())
    {
        int u=q.front();q.pop();inq[u]=0;
        for(int i=beg[u];i;i=nxt[i])
            if(chkmin(f[to[i]],f[u]+w[i]) && !inq[to[i]])
                q.push(to[i]),inq[to[i]]=1;
    }
}

inline int calc(int st)
{
    int cnt=0,ans=Inf;
    memset(f,127,sizeof(f));
    for(int i=1;i<=p;i++)
        if(st&(1<<c[i]-1))
            f[1<<(cnt++)][d[i]]=0;
    for(int i=1,e=1<<cnt;i<e;i++)
    {
        for(int j=(i-1)&i;j;j=(j-1)&i)
            for(int k=1;k<=n;k++)
                chkmin(f[i][k],f[j][k]+f[i^j][k]);
        for(int j=1;j<=n;j++)
            if(f[i][j]<Inf && !inq[j])
                q.push(j),inq[j]=1;
        spfa(f[i]);
    }
    for(int i=1;i<=n;i++)
        chkmin(ans,f[(1<<cnt)-1][i]);
    return ans;
}

int main()
{
    n=read();m=read();p=read();
    for(int i=1,u,v,c;i<=m;i++)
    {
        u=read();v=read();c=read();
        add(u,v,c);add(v,u,c);
    }

    for(int i=1;i<=p;i++)
        ha[++htop]=c[i]=read(),d[i]=read();
    sort(ha+1,ha+htop+1);
    htop=unique(ha+1,ha+htop+1)-ha-1;
    for(int i=1;i<=p;i++)
        c[i]=lower_bound(ha+1,ha+htop+1,c[i])-ha;

    memset(dp,127,sizeof(dp));
    for(int i=1,e=1<<htop;i<e;i++)
    {
        dp[i]=calc(i);
        for(int j=(i-1)&i;j;j=(j-1)&i)
            chkmin(dp[i],dp[j]+dp[i^j]);
    }

    printf("%d\n",dp[(1<<htop)-1]);
    return 0;
}