【算法系列学习】Dijkstra算法变形 [kuangbin带你飞]专题四 最短路练习

https://vjudge.net/contest/66569#problem/B

类试题：noip2013 货物运输

           POJ 1797 Heavy Transportation

方法一：Dijkstra变形

http://blog.csdn.net/u013446688/article/details/42777173

关键在于对松弛的变形，这里不是求源点到每个点的所有路径中的路径长度最小值，而是求源点到每个点的所有路径中Frog distance(路径中的最大距离)的最小值

所以dis[k]=min(dis[k],dis[v]+map[v][k])变成了dis[k]=min(dis[k],max(dis[v],map[v][k]))

这里的dis[k]不再是源点到结点k所有路径中路径长度的最小值，而是源点到结点k所有路径中Frog distance（路径中的最大距离）的最小值。

为了理解dis[k]=min(dis[k],max(dis[v],map[v][k]))，我们可以做这样的假设：源点到v的路径有三条，这三条路径的frog distance分别是3,4,5;那么dis[v]就是3。

现在分两种情况分别进行讨论：

1.map[v][k]>dis[v],由于源点经过v到达k的路径也有三条，这三条的frog distance就分别变成了map[v][k],max(4,map[v][k]),max(5,map[v][k]);那么dis[k]就一定是最小值map[v][k].

2.map[v][k]<=dis[v],则这三条路径的frog distance 还是3,4,5.dis[k]就等于dis[v]

下面是AC的代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
const double inf=0x3f3f3f3f;
using namespace std;
int n;
struct node
{
    int x,y;
}nd[203];
double map[203][203];
double dist(node a,node b)
{
    return sqrt((double)(a.x-b.x)*(a.x-b.x)+(double)(a.y-b.y)*(a.y-b.y));
}
double dis[203];
void Dijkstra()
{
    bool vis[203];
    memset(vis,0,sizeof(vis));
    dis[1]=0.0;
    for(int i=2;i<=n;i++)
    {
        dis[i]=inf;
    }
    int v;
    for(int i=1;i<=n;i++)
    {
        int m=inf;
        for(int k=1;k<=n;k++)
        {
            if(!vis[k]&&dis[k]<m)
            {
                m=dis[k];
                v=k;        
            }
        }
        vis[v]=1;
        //对以v为顶点的边进行松弛 
        for(int k=1;k<=n;k++)
        {
            if(!vis[k])
            {
                dis[k]=min(dis[k],max(dis[v],map[v][k])); 
            }
        }
    }
}
int main()
{
    int kas=1;
    while(scanf("%d",&n)&&n)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&nd[i].x,&nd[i].y);
            for(int k=1;k<i;k++)
            {
                map[i][k]=map[k][i]=dist(nd[i],nd[k]);
            }
        }
        Dijkstra();
        if(kas!=1)
        {
            printf("
");
        }
        printf("Scenario #%d
",kas++);
        printf("Frog Distance = %.3f
",dis[2]);
    }
    return 0;
}

 要注意四点:

1.sqrt()要强制转化为double

2.double不能用memset(dis,inf,sizeof(dis))

3.

for(int k=1;k<=n;k++)
{
　　if(!vis[k])
　　{
　　　　dis[k]=min(dis[k],max(dis[v],map[v][k]));
　　}
}

不写vis[k]也对，但是增加时间复杂度

4.注意输入输出,最后一个样例之后是没有空行的

方法二：二分+并查集

http://xwk.iteye.com/blog/2129453

二分出一个mid值表示最大边的长度，然后遍历所有边，只要当前边的长度不超过mid,就合并当前边所连接的两个点。最后判断1和2在不在同一个连通分量上，如果是则说明当前mid已经足够，为了找到mid的最小值，R=mid.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>

using namespace std;
const int maxn=2e2+10;
const double eps=1e-7;
int n;
struct node
{
    int x,y;
}nd[maxn];
double map[maxn][maxn];
double dist(const node& a,const node& b)
{
    return sqrt((double)(a.x-b.x)*(a.x-b.x)+(double)(a.y-b.y)*(a.y-b.y));
}
int fa[maxn];
int find(int i)
{
    if(fa[i]==-1)
    {
        return i;
    }
    return fa[i]=find(fa[i]);
}
bool bind(int i,int k)
{
    i=find(i);
    k=find(k);
    if(i!=k)
    {
        fa[i]=k;
    }
    return true;
}
bool ok(double mid)
{
    memset(fa,-1,sizeof(fa));
    //加进去的边的最大值为mid 
    for(int i=1;i<=n;i++)
    {
        for(int k=i+1;k<=n;k++)
        {
            if(map[i][k]<mid)
            {
                bind(i,k);
            }
        }
    }
    return find(1)==find(2);
}

int main()
{
    int kas=1;
    while(scanf("%d",&n)&&n)
    {    
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&nd[i].x,&nd[i].y);
            for(int k=1;k<i;k++)
            {
                map[i][k]=map[k][i]=dist(nd[i],nd[k]);
            }
        }
        double l=0.0;
        double r=map[1][2];
        while(r-l>eps)
        {
            double mid=(l+r)/2;
            if(ok(mid))
            {
                r=mid;
            }
            else
            {
                l=mid;
            }
        }
        if(kas!=1)
        {
            printf("
");
        }    
        printf("Scenario #%d
",kas++);
        printf("Frog Distance = %.3f
",r); 
    }
    return 0;
}

注意在ok函数里，每次都要初始化memset(fa,-1,sizeof(fa));

方法三：最小生成树

http://blog.csdn.net/shouwang_tomorrow/article/details/47616983

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>

using namespace std;
int n;
int cnt;
const int maxn=2e4+10;



struct edge
{
    int x,y;
    double w;
}e[maxn];
struct node
{
    int x;
    int y;
}nd[203];
double dist(const node& a,const node& b)
{
    return sqrt((double)(a.x-b.x)*(a.x-b.x)+(double)(a.y-b.y)*(a.y-b.y));
}
bool cmp(const edge& a,const edge& b)
{
    return a.w<b.w;
}
int fa[maxn];
int find(int i)
{
    if(fa[i]==-1)
    {
        return i;
    }
    return fa[i]=find(fa[i]);    
}
bool bind(int i,int k)
{
    i=find(i);
    k=find(k);
    if(i!=k)
    {
        fa[i]=k;
        return true;    
    }
    return false;
}
double Kruskal()
{
    for(int i=0;i<cnt;i++)
    {
        if(bind(e[i].x,e[i].y))
        {
            if(find(1)==find(2))
            {
                return e[i].w;
            }
        }    
    }
}
int main()
{
    int kas=1;
    while(scanf("%d",&n)&&n)
    {
        cnt=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&nd[i].x,&nd[i].y);
            for(int k=1;k<i;k++)
            {
                e[cnt].x=i;
                e[cnt].y=k;
                e[cnt++].w=dist(nd[i],nd[k]);
            }
        }
        sort(e,e+cnt,cmp);
        memset(fa,-1,sizeof(fa));
        double ans=Kruskal();
        if(kas!=1)
        {
            printf("
");
        }
        printf("Scenario #%d
Frog Distance = %.3f
",kas++,ans);
    }
    return 0;
}