[BZOJ4006][JLOI2015]管道连接状压dp+斯坦纳树

4006: [JLOI2015]管道连接

Time Limit: 30 Sec Memory Limit: 128 MB
Submit: 1020 Solved: 552
[Submit][Status][Discuss]

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

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。

Source

斯坦纳树

f[i][state]表示以i为根，指定集合中的点的连通状态为state的生成树的最小总权值。
f[i][state]=min{f[i][subset1]+f[i][subset2] }

f[i][state]=min{ f[i][state],f[j][state]+e[i][j] }

第二个转移很像最短路，可以用spfa，dj转移。
最后由于是求斯坦纳森林，所以再加一个dp。

g[state]表示森林包含state的最小费用。

枚举子集

g[i]=min(g[i],g[j]+g[i-j])

 #include<iostream>

 #include<cstring>

 #include<cstdlib>

 #include<cstdio>

 #include<cmath>

 #include<algorithm>

 using namespace std;

 const int MAXN=;

 const int MAXM=;

 const int MAXS=;

 int read() {

     int x=,f=;char ch=getchar();

     for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-;

     for(;isdigit(ch);ch=getchar()) x=x*+ch-'';

     return x*f;

 }

 struct data {

     int to,next,v;

 }e[MAXM];

 int head[MAXN],cnt;

 void add(int u,int v,int val) {e[cnt].next=head[u];e[cnt].to=v;e[cnt].v=val;head[u]=cnt++;}

 int n,m,p;

 int f[MAXN][MAXS],g[MAXS];

 int col[MAXN][MAXN],sum,state[MAXN];

 int bit[MAXN];

 int q[MAXM];

 bool vis[MAXN];

 void spfa(int s) {

     int h=,t=;

     for(int i=;i<=n;i++) if(f[i][s]!=f[][]) q[t++]=i,vis[i]=;

     while(h!=t) {

         int now=q[h++];if(h==MAXN-) h=;

         for(int i=head[now];i>=;i=e[i].next) {

             int to=e[i].to;

             if(f[to][s]>f[now][s]+e[i].v) {

                 f[to][s]=f[now][s]+e[i].v;

                 if(!vis[to]){vis[to]=;q[t++]=to;if(t==MAXN-) t=;}

             }

         }

         vis[now]=;

     }

 }

 bool check(int s){

     for(int i=;i<=sum;i++) {

         if(state[i]==) continue;

         if(((state[i]&s)!=)&&((s&state[i])!=state[i])) return false;

     }

     return true;

 }

 int main() {

     memset(head,-,sizeof(head));

     n=read(),m=read(),p=read();

     for(int i=;i<=m;i++) {

         int u=read(),v=read(),w=read();

         add(u,v,w);add(v,u,w);

     }

     memset(f,,sizeof(f));

     for(int i=;i<=p;i++) {

         int x=read(),y=read();

         if(col[x][]) sum++;

         col[x][++col[x][]]=y;

         bit[y]=<<(i-);

         f[y][bit[y]]=;

     }

     for(int i=;i<=(<<p)-;i++) {

         for(int j=;j<=n;j++) {

             for(int k=i;k;k=(k-)&i) {

                 if(f[j][k]==f[][]||f[j][i-k]==f[][]) continue;

                 f[j][i]=min(f[j][i],f[j][k]+f[j][i-k]);

             }

         }

         spfa(i);

     }

     for(int i=;i<=sum;i++)

         for(int j=;j<=col[i][];j++) state[i]|=bit[col[i][j]];

     memset(g,,sizeof(g));

     for(int i=;i<=(<<p)-;i++)

         for(int j=;j<=n;j++) g[i]=min(g[i],f[j][i]);

     for(int i=;i<=(<<p)-;i++) {

         if(!check(i)) continue;

         for(int j=i;j;j=(j-)&i) {

             if(!check(j)||g[j]==g[]||g[i-j]==g[]) continue;

             g[i]=min(g[i],g[j]+g[i-j]);

         }

     }

     printf("%d",g[(<<p)-]);

 }