生成树

prim算法和kruskal算法是解决生成树的算法，prim更快，但kruskal实现简单，

思路上是贪心：

prim：每次寻找离生成树最近的点，加入生成树，再用那个点松弛其他点到生成树的距离，一般是O(N²)；当然，有优化，二叉堆可以到达，斐波那契堆可以优化到

kruskal:给边排序，区最小的边加入就好，用并查集维护联通；时间复杂度为；A是阿克曼函数的反函数，再加V因为并查集要初始化

证明我就不搞了，就是两个反证，意思一下就好啦。

板子还是要上的

int prime(int n)
{
    const int INF = 1<<29;
    int d[maxn];
    int k = 1;d[k] = 0;
    for(int i = 1;i <= n;i++) d[i] = G[1][i];
    int vis[maxn];int ans = 0;
    memset(vis,0,sizeof(vis));
    for(int i = 1;i < n;i++)
    {    
        vis[k] = 1;
        int M =INF;int last = 0;
        for(int j = 1;j <= n;j++)
        {
            if(d[j] < M&& !vis[j]){
                M =d[j];
                last = j;
            }
        }
        if(M == INF) break;
        ans += M;
        k = last;
        for(int j = 1;j <= n;j++)
            if(j != k&&d[j] > G[k][j])
                d[j] = G[k][j];
    }
    return ans;
};

斐波那契堆的不会：好吧，我还是会用STL的：

struct HeapNode{
    int d,u;
    bool operator < (const HeapNode& rhs)const{
        return  d > rhs.d;
    }
};
int prime(int n)
{
    int ans = 0;
    priority_queue<HeapNode> Q;
    Q.push((HeapNode){0,1});
    for(int i = 0;i <= n;i++) d[i] = INF;
    d[1] = 0;
    Q.push((HeapNode){0,1});
    int vis[maxn];
    memset(vis,0,sizeof(vis));
    while(!Q.empty()){    
        HeapNode x =Q.top();Q.pop();
        int k = x.u;
        if(vis[k]) continue;
        vis[k] = 1;
        ans += x.d;
        for(int j = 1;j <= n;j++)
            if(j != k&&d[j] > G[k][j])
            {
                d[j] = G[k][j];
                Q.push((HeapNode){d[j],j});
        
            }
    }
    return ans;
};

int find(int x)
{
    if(pa[x] == x) return x;
    return pa[x] = find(pa[x]);
}
int kruskal(int n,int m)
{
    for(int i = 0;i <= n;i++) pa[i] = i;
    int ans = 0;
    sort(edges.begin(),edges.end());
    for(int i = 0;i < edges.size();i++)
    {
        Edge& e =edges[i];
        int x = find(e.from);int y = find(e.to);
        if(x != y){
            pa[x] = y;
            ans += e.dist;
            printf("%d %d ",min(e.from,e.to),max(e.from,e.to ));
        }        
    }
    return ans;
}

建图部分就不要我再贴了吧

结论：瓶颈生成树 无向图G的一颗瓶颈生成树是这样的一颗生成树，它最大的边权值在G的所有生成树中是最小的。瓶颈生成树的值为T中最大权值边的权。

无向图的最小生成树一定是瓶颈生成树，但瓶颈生成树不一定是最小生成树。

命题：无向图的最小生成树一定是瓶颈生成树。

证明：可以采用反证法予以证明。

假设最小生成树不是瓶颈树，设最小生成树T的最大权边为e，则存在一棵瓶颈树T_b，其所有的边的权值小于w(e)。删除T中的e，形成两棵数T', T''，用T_b中连接T', T''的边连接这两棵树，得到新的生成树，其权值小于T，与T是最小生成树矛盾。^[1-2] 

命题：瓶颈生成树不一定是最小生成树。

下面是一个反例：

由红色边组成的生成树是最小瓶颈树，但并非最小生成树。

从上面可以看出，最小瓶颈生成树不止一条。

最小生成树是最小瓶颈生成树的一个子集。

POJ 2395

直接模板；

#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<cstdio>


using namespace std;

const int maxn = 101010;
int pa[maxn];

struct Edge
{
    int from,to,dist;
    Edge(int from,int to,int dist) :from(from),to(to),dist(dist){}    
    bool operator < (const Edge& b) const{
        return dist < b.dist;
    }
};
vector<Edge> edges;
int find(int x)
{
    if(pa[x] == x) return x;
    else return pa[x] = find(pa[x]);
}

int kruskal(int n,int m)
{
    for(int i = 1;i <= n;i++) pa[i] = i;
    sort(edges.begin() ,edges.end());
    int cnt = 0;
    for(int i = 0;i < m;i++)
    {
        Edge& e = edges[i];
        int x = find(e.from);int y = find(e.to);
        if(x != y)
        {
            pa[x] = y;
            cnt++;
        }
        if(cnt == n-1) return e.dist ;
    }
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 0;i < m;i++)
    {
        int from,to,dist;
        scanf("%d%d%d",&from,&to,&dist);
        edges.push_back(Edge(from,to,dist));  
    }
    printf("%d\n",kruskal(n,m));
    return 0;
}

 最小瓶颈生成树：先求最小生成树，处理出所有路径的最大路径，依次加不在最小生成树里的边，肯定形成环，去最长路径，扫描维护一下增量值，因为是自己想的，没做题来验证，估计又慢又丑还不对，还是贴下吧：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cstdlib>
using namespace std;

struct Edge
{
    int from,to,dist;
    Edge(int from,int to,int dist):from(from),to(to),dist(dist){}    
    bool operator < (const Edge& rhs)const{
        return dist < rhs.dist;
    }
};
const int maxn = 1000;
vector<Edge> edges1;
vector<int> G1[maxn];
vector<Edge> edges2;
vector<int> G2[maxn];
int pa[maxn];
int maxcost[maxn][maxn];
int vis[maxn];
int find(int x)
{
    if(pa[x] == x) return x;
    else return pa[x] = find(pa[x]);
}

int kruskal(int n)
{
    for(int i = 0;i <= n;i++) pa[i] = i;
    sort(edges1.begin(),edges1.end());
    int m = edges1.size();
    int ans = 0;int cnt = 0;
    for(int i = 0;i < m;i++)
    {
        Edge& e = edges1[i];
        int x = find(e.from);int y = find(e.to);
        if(x != y)
        {
            pa[x] = y;
            ans += e.dist;
            edges2.push_back(Edge(e.from,e.to,e.dist));
            edges2.push_back(Edge(e.to,e.from,e.dist));
            int m2 = edges2.size();
            G2[e.from].push_back(m2-2);
            G2[e.to].push_back(m2-1);
            cnt++;
        }
        if(cnt == n-1) return ans;
    }
}

void dfs(int from,int now,int maxdist)
{
    maxcost[from][now] = maxdist;
    for(int i = 0;i < G2[now].size();i++)
    {
        Edge& e = edges2[G2[now][i]];
        if(vis[e.to]) continue;
        int mid = maxdist;
        maxdist = max(maxdist,e.dist);
        vis[e.to] = 1;
        dfs(from,e.to,maxdist);
        vis[e.to] = 0;
        maxdist = mid;        
    }
    return;
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 0 ;i < m;i++)
    {
        int from,to,dist;
        scanf("%d%d%d",&from,&to,&dist);
        edges1.push_back(Edge(from,to,dist));
        edges2.push_back(Edge(to,from,dist));
        int k = edges1.size();
        G1[from].push_back(k-2);
        G1[to].push_back(k-1);
    }
    int ans = kruskal(n);
    for(int i = 1;i <= n;i++)
    {
        vis[i] = 1;
        dfs(i,i,0);
        vis[i] = 0;
    }
    int add = 9999999;
    for(int i = 0;i < m;i++)
    {
        Edge& e = edges1[i];
        if(e.dist > maxcost[e.from][e.to])
        {
            add = min(e.dist-maxcost[e.from][e.to],add);
        }
    }
    cout<<ans<<endl;
    cout<<ans+add<<endl;
    return 0;
}

最小增量生成树，暂时不会

 最小树形图： 朱刘；妈的毒瘤，搞了好久还是不知道哪里挑错了。