最小瓶颈路

开始研究最小瓶颈路。
最小瓶颈路 ：给定一个加权无向图，并给定无向图中两个结点u和v，求u到v的一条路径，使得路径上边的最大权值最小。这个问题可以稍微加强一下，即求很多对结点之间的最小瓶颈路。
PS: 最小瓶颈路其实是边！！！
最小瓶颈路：
给定一个加权无向图，并给定无向图中两个结点u和v，求u到v的一条路径，使得路径上边的 最大权值 最小。这个问题可以稍微加强一下，即求很多对结点之间的最小瓶颈路。
无向图中，任意两个结点的最小瓶颈路肯定在最小生成树上。因此，对于第一个问题，我们可以先求出最小生成树，然后从结点u对最小生成树进行DFS直到访问到结点v，DFS过程中就可以求出最长边。这种方法非常简单，但是效率就不够高，如果结点对很多的话，我们每次都对最小生成树进行DFS就会很慢了（一次时间O(n)）。
我们可以在查询前进行预处理，将所有结点对的最长边保存在一个maxcost数组中，之后每次查询直接访问数组即可，只需要O(1)时间。具体的方法是将无根的最小生成树转成有根树，转换过程中同时计算maxcost[u][v]。当访问一个新结点u时，考虑所有已经访问过的结点j，对maxcost[j][u]进行更新，公式如下：
maxcost[j][u]=max(maxcost[j][fa[u]], maxcost[j][u])
其中，fa数组中保存结点在有根树中的父节点。
代码实现：
代码实现有两种具体方式，一种基于prim算法，一种则为kruskal算法。
Prim算法：
如果使用prim算法，那么我们可以在求解最小生成树的过程中将有根树建立起来，并且同时求所有结点对maxcost。

int prim(int s)
{
    int res=0;
    memset(maxcost,0,sizeof(maxcost));// 初始化目标数组
    for(int i=1;i<=n;i++)
        vis[i] = 0, d[i] = INF, pre[i]=i;//初始化 标记、距离、父亲数组。

    d[s]=0; // 自身的距离为零
    for(int i=0;i<n;i++) // prim考察剩下的n - 1个点
    {
        int maxx=INF, index=-1; // 比较和点的位置
        for(int j=1;j<=n;j++) // 寻找与最小生成树集合最近的点
        {
            if(!vis[j]&&d[j]<maxx)
            {
                maxx=d[index=j]; // 写法不错
            }
        }
        if(index==-1) // 未找到的判断
            break;

        for(int j=1;j<=n;j++) // 
            if(vis[j])
                maxcost[index][j] = maxcost[j][index] =
                    max(maxcost[pre[index]][j], maxx);
                    /*在已经建好的集合中
                    寻找最大边，因为maxcost[[pre[index]][j]存的是在已经找的
                    目标点之前的路径中的最长边，当加入这个新点时对这个maxcost
                    造成的影响是有可能这个边会代替之前路上的边。*/

        res+=maxx; // 最小生成树权值更新
        vis[index]=1; // 将找到的点加入集合

        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&g[index][j]<d[j])
            {
                d[j] = g[index][j]; // 更新距离
                pre[j] = index; // 更新父亲节点。
            }
        }
    }
    return res;
}

先来简单总结一下的话，就是预处理，在建立集合的过程中利用动态规划的方法记录任意两点路径上的那个最大值。

kruskal的做法没看懂，有时间在研究

struct Edge{
    int u,v,w;
    Edge(int u=0,int v=0,int dist=0):u(u),v(v),w(dist){}
}e[maxm];
vector<Edge> vec[maxn];

bool cmp(const Edge& a,const Edge& b){
    return a.w<b.w;
}

int find(int x){
    return p[x]==x?x:p[x]=find(p[x]);
}

void kruskal()
{
    sort(e,e+m,cmp);
    for(int i=1;i<=n;i++)
        p[i]=i;
    int cnt=0;
    for(int i=0;i<m;i++){
        int x=find(e[i].u),y=find(e[i].v);
        if(x!=y){
            p[y]=x;
            vec[e[i].u].push_back(Edge(e[i].u, e[i].v, e[i].w));
            vec[e[i].v].push_back(Edge(e[i].v, e[i].u, e[i].w));
            if(++cnt==n-1)
                break;
        }
    }
}

void dfs(int index)
{
    vis[index]=1;
    for(int i=0;i<vec[index].size();i++)
    {
        int tmp=vec[index][i].v;
        if(!vis[tmp])
        {
            for(int j=1;j<=n;j++)
                if(vis[j])
                {
                    maxcost[j][tmp] = maxcost[tmp][j] = 
                        max(maxcost[j][index], vec[index][i].w);
                }
            pre[tmp]=index;
            dfs(tmp);
        }
    }
}

转载自
http://blog.csdn.net/fuyukai/article/details/51321680