最短路入门练习 解题报告

题目链接

A - Frogger

    给你若干个点，要求第一个点到第二个点的所有路径中最大边的最小值。

       这种题目在以后会经常碰到，最大的最小，或是最小的最大，首先可以想到的方法是二分，但是这道题也有不用二分的方法，我这里就把两种都介绍下吧。

       解法1：

               假设你规定距离小于等于X的点之间才能通行，那么此时如果你还能从1走到2，说明X有可能是你要求的答案，那么我们尝试着继续缩小X，然后继续判断1是否还能走到2，一直到不能缩小为止，这时的X就是答案！

              说白了，这里有一个单调性，X越大，从1出发走到2的路径数量不会减少，通俗的讲就是1越容易走到2。所以我们可以二分枚举X,每次枚举一个X之后，求一次最短路去验证1是否能走到2，如果能，我们继续缩小X。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using std::fill;
const int N = 210;
const double eps = 1e-6;
const double inf = 1e10;
double dis[N][N];
double x[N] , y[N];
double Get_Distance(int i,int j)
{
	return sqrt((x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]));
}
bool deleted[N];
double d[N];
bool Dijkstra(int n)
{
	fill(d,d+n,inf);
	fill(deleted,deleted+n,false);
	d[0] = 0;
	while(true)
	{
		int decided = -1;
		for(int i = 0; i < n; i++) if(d[i]!=inf&&!deleted[i])
		{
			if(decided== -1 || d[i] - d[decided] < -eps)
			{
				decided = i;
			}
		}
		if(decided == -1) break;
		for(int i = 0; i < n; i++) if(!deleted[i])
		{
			if(d[decided] + dis[decided][i] < d[i])
			{
				d[i] = d[decided] + dis[decided][i];
			}
		}
		deleted[decided] = true;
	}
	return d[1] < inf;
}
bool Judge(double mid,int n)
{
	for(int i = 0; i < n; i++)
	{
		dis[i][i] = 0;
		for(int j = i+1; j < n; j++)
		{
			double d = Get_Distance(i,j);
			if(d - mid > eps) dis[i][j] = dis[j][i] = inf;
			else dis[i][j] = dis[j][i] = d;
		}
	}
	return Dijkstra(n);
}
int main()
{
	int n,ca=1;
	while(scanf("%d",&n),n)
	{
		for(int i = 0; i < n; i++)
		{
			scanf("%lf%lf",&x[i],&y[i]);
		}
		double l = 0, r = 1e10 , best= - 1;
		while(fabs(l-r)>eps)
		{
			double mid = (l + r) / 2;
			if(Judge(mid,n))
			{
				best = mid;
				r = mid;
			}
			else 
			{
				l = mid;
			}
		}
		printf("Scenario #%d\n",ca++);
		printf("Frog Distance = %.3f\n\n",best);
	}
	return 0;
}

               解法2： 利用最短路的变形。

            我们可以重新定义一下我们的d数组的含义，d[i]表示从起点走到i的最长距离的最小值，那么假设我们现在确定了一个点u的最短路，我们尝试着去更新一下周边的点v，那是不是可以用d[u]跟u v之间的边权的最大值去更新d[v]，所以普通最短路的代码在更新的地方稍作修改便可以AC此题。

           

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using std::fill;
using std::min;
using std::max;
const int N = 210;
const double eps = 1e-6;
const double inf = 1e10;
double dis[N][N];
double x[N] , y[N];
double Get_Distance(int i,int j)
{
	return sqrt((x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]));
}
bool deleted[N];
double d[N];
double Dijkstra(int n)
{
	fill(d,d+n,inf);
	fill(deleted,deleted+n,false);
	d[0] = 0;
	while(true)
	{
		int decided = -1;
		for(int i = 0; i < n; i++) if(d[i]!=inf&&!deleted[i])
		{
			if(decided== -1 || d[i] - d[decided] < -eps)
			{
				decided = i;
			}
		}
		if(decided == -1) break;
		for(int i = 0; i < n; i++) if(!deleted[i])
		{
		    d[i] = min(d[i],max(dis[decided][i],d[decided]));
		}
		deleted[decided] = true;
	}
	return d[1] ;
}

int main()
{
	int n,ca=1;
	while(scanf("%d",&n),n)
	{
		for(int i = 0; i < n; i++)
		{
			scanf("%lf%lf",&x[i],&y[i]);
		}
		for(int i = 0; i < n; i++)
		{
			dis[i][i] = 0;
			for(int j = i + 1; j < n; j++)
			{
				dis[i][j] = dis[j][i] = Get_Distance(i,j);
			}
		}
		printf("Scenario #%d\n",ca++);
		printf("Frog Distance = %.3f\n\n",Dijkstra(n));
	}
	return 0;
}

    B题有负环，需要用其他专门的算法。先跳过

C题：

主要思想是对于题目输入的每两个国家建立汇率联系，然后从每个点开始走最长路，如果某个点走回自己的时候汇率>1就表示成功了。

 懒得写了，直接拉一份网上的代码好了。http://paste.ubuntu.com/5938912/

D - 昂贵的聘礼

题意：好好看题吧。。

酋长的等级是lev[1]，那么中间经过的所有点的等级都要在lev[1] - m , lev[1] + m之间，但是，但是,，中间的人之间的差距也不能超过m，怎么办怎么办，其实画了画图就会发现，从第一次交易开始一直到最后一次交易（到达酋长那里），所有人的等级的最大值与最小值之差不会超过m，所以，我们就这么搞。。

解法： 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
const int inf = 1000000000;
int lev[110],p[110];
int  map[110][110];
int vis[110];
int dis[110];
int dijkstra(int cost[][110],int n,int x,int m)
{
    int i,j,k,minc;
    memset(vis,0,sizeof(vis));
    std::fill(dis,dis+n+1,inf);
    dis[0]=0;
    for(i=1;i<=n;i++)
    {
        minc=inf;
        for(j=0;j<=n;j++)
            if(!vis[j]&&dis[j]<minc)
            {
                minc=dis[j];
                k=j;
            }
            if(minc==inf) break;
            vis[k]=1;
            for(j=0;j<=n;j++)
                if(!vis[j]&&dis[j]>dis[k]+cost[k][j]&&lev[k]>=x&&lev[k]<=x+m)
                    dis[j]=dis[k]+cost[k][j];
    }
    return dis[1];
}
int main()
{
    int m,n;
    int i,j,k,x,price,id;

    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(i=0;i<=100;i++)
        {
            map[i][i]=0;
            for(j=i+1;j<=100;j++)
            {
                map[i][j]=map[j][i]=inf;
            }
        }
        for(i=1;i<=n;i++)
        {
            scanf("%d%d%d",&p[i],&lev[i],&x);
            for(j=1;j<=x;j++)
            {
                scanf("%d%d",&id,&price);
                map[id][i]=price;
            }
        }
        for(i=1;i<=n;i++)
            map[0][i]=p[i];
        lev[0]=lev[1];
        int low=lev[1]-m;
        int ans=inf;
        for(i=low;i<=lev[1];i++)
        {
             int tmp=dijkstra(map,n,i,m);
             if(tmp<ans)
                 ans=tmp;
        }
        printf("%d\n",ans);
    }
    return 0;
}

E:

还是最短路的变形，二维最短路，加一维状态就好了。参考代码。

d[i][j]表示 到达第i点花费j的代价

代码可以自己写写看，改天有空再贴。。。。