斯坦纳树（Steiner Tree）

1. 什么是 斯坦纳树？

       斯坦纳树问题是组合优化学科中的一个问题。将指定点集合中的所有点连通，且边权总和最小的生成树称为最小斯坦纳树（Minimal Steiner Tree），其实最小生成树是最小斯坦纳树的一种特殊情况。而斯坦纳树可以理解为使得指定集合中的点连通的树，但不一定最小。

2. 如何求解最小斯坦纳树？

      可以用DP求解，dp[i][state]表示以i为根，指定集合中的点的连通状态为state的生成树的最小总权值。

      转移方程有两重：

      第一重，先通过连通状态的子集进行转移。

      dp[i][state]=min{ dp[i][subset1]+dp[i][subset2] } 

      枚举子集的技巧可以用 for(sub=(state-1)&state;sub;sub=(sub-1)&state)。

      第二重，在当前枚举的连通状态下，对该连通状态进行松弛操作。

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

      为什么只需对该连通状态进行松弛？因为更后面的连通状态会由先前的连通状态通过第一重转移得到，所以无需对别的连通状态松弛。松弛操作用SPFA即可。

      复杂度 O(n*3^k+cE*2^k)

      c为SPFA复杂度中的常数，E为边的数量，但几乎达不到全部边的数量，甚至非常小。3^k来自于子集的转移sum{C(i,n)*2^i} (1<=i<=n)，用二项式展开求一下和。

模版：

[cpp]  view plain copy

1. /* 
2.  *  Steiner Tree：求，使得指定K个点连通的生成树的最小总权值 
3.  *  st[i] 表示顶点i的标记值，如果i是指定集合内第m(0<=m<K)个点，则st[i]=1<<m  
4.  *  endSt=1<<K 
5.  *  dptree[i][state] 表示以i为根，连通状态为state的生成树值 
6.  */  
7. #define CLR(x,a) memset(x,a,sizeof(x))  
8.   
9. int dptree[N][1<<K],st[N],endSt;  
10. bool vis[N][1<<K];  
11. queue<int> que;  
12.   
13. int input()  
14. {  
15.    /* 
16.     *    输入，并且返回指定集合元素个数K 
17.     *    因为有时候元素个数需要通过输入数据处理出来，所以单独开个输入函数。 
18.     */  
19. }  
20.   
21. void initSteinerTree()  
22. {  
23.     CLR(dptree,-1);  
24.     CLR(st,0);  
25.     for(int i=1;i<=n;i++) CLR(vis[i],0);  
26.     endSt=1<<input();  
27.     for(int i=1;i<=n;i++)  
28.         dptree[i][st[i]]=0;  
29. }  
30.   
31. void update(int &a,int x)  
32. {  
33.     a=(a>x || a==-1)? x : a;  
34. }  
35.   
36. void SPFA(int state)  
37. {  
38.     while(!que.empty()){  
39.         int u=que.front();  
40.         que.pop();  
41.         vis[u][state]=false;  
42.         for(int i=p[u];i!=-1;i=e[i].next){  
43.             int v=e[i].vid;  
44.             if(dptree[v][st[v]|state]==-1 ||   
45.                 dptree[v][st[v]|state]>dptree[u][state]+e[i].w){  
46.   
47.                 dptree[v][st[v]|state]=dptree[u][state]+e[i].w;  
48.                 if(st[v]|state!=state || vis[v][state])   
49.                     continue; //只更新当前连通状态  
50.                 vis[v][state]=true;  
51.                 que.push(v);  
52.             }  
53.         }  
54.     }  
55. }  
56.   
57. void steinerTree()  
58. {  
59.     for(int j=1;j<endSt;j++){  
60.         for(int i=1;i<=n;i++){  
61.             if(st[i] && (st[i]&j)==0) continue;  
62.             for(int sub=(j-1)&j;sub;sub=(sub-1)&j){  
63.                 int x=st[i]|sub,y=st[i]|(j-sub);  
64.                 if(dptree[i][x]!=-1 && dptree[i][y]!=-1)  
65.                     update(dptree[i][j],dptree[i][x]+dptree[i][y]);  
66.             }  
67.             if(dptree[i][j]!=-1)   
68.                 que.push(i),vis[i][j]=true;  
69.         }  
70.         SPFA(j);  
71.     }  
72. }  

也有用Floyd求的，但是个人认为还是SPFA效率稳定。Floyd的话，数据达到三五百就可能T了。