FZU Problem 2243 Daxia like uber(最短路)

最新推荐文章于 2017-11-15 15:46:22 发布

queuelovestack

最新推荐文章于 2017-11-15 15:46:22 发布

阅读量621

点赞数 1

分类专栏： FZU 最短路文章标签： acm 最短路 dijkstra+堆优化

本文链接：https://blog.csdn.net/queuelovestack/article/details/52273761

版权

FZU 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

最短路

3 篇文章 0 订阅

订阅专栏

此文章可以使用目录功能哟↑(点击上方[+])

FZU Problem 2243 Daxia like uber

Accept: 0 Submit: 0
Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

daxia兼职开uber,现在接到一个两人拼车单.已知如下信息:

1. 地图上共有n个点,m条有向行驶通道.

2. daxia位于点s;

3. 客人一位于点x1,目的地为y1;

4. 客人二位于点x2,目的地为y2.

请帮daxia计算送完两个乘客的最短行驶路程.

Input

测试包含多组数据,每组数据第一行包含两个整数:n(1<=n<=1000),m(1<=m<=100000).

第二行包含五个整数:s,x1,y1,x2,y2(1<=s,x1,y1,x2,y2<=n).

接下来包含m行,每行三个整数:u,v,d(1<=u,v<=n,1<=d<=100).

Output

每组数据输出一行一个整数表示送完两个乘客的最短行驶路程,数据保证肯定能送到.

Sample Input

Sample Output

11

Hint

样例接送路线:(4)->2->(1)->(2)->1->(3)

Problem Idea

解题思路:

【题意】
daxia位于点s,现要将一位位于点x1的客人送到y1;要将位于点x2的客人送到y2

求送完两个乘客的最短行驶路程(注:两位客人可以同时在车上)

【类型】
最短路

【分析】
显然,此题是一道最短路问题,但问题的关键是,在整个行驶过程中,需要出现x1->y1,x2->y2这段路

也就是说只要有出现x1->y1,x2->y2这段路,其他的可以随便组合

那么行驶过程就有以下六种情况:

①s->x1->y1->x2->y2
②s->x1->x2->y1->y2
③s->x1->x2->y2->y1
④s->x2->y2->x1->y1
⑤s->x2->x1->y1->y2
⑥s->x2->x1->y2->y1

"a->b"表示从a到b的最短路

显然,要完成送客任务,只有这6种方案,我们只需要找一种路程最短的就可以了

而上述6种方案,只需要求5次最短路就能求得需要的最短路

因为只有5个不同起点,对于单源最短路,1次可以求得1个,故为5次

s->x1 s->x2
x1->y1 x1->x2 x1->y2
x2->y2 x2->x1 x2->y1
y1->x2 y1->y2
y2->y1 y2->x

【时间复杂度&&优化】
O(nlogn)

题目链接→FZU Problem 2243 Daxia like uber

Source Code

/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<bitset>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define eps 1e-9
#define LL long long
#define PI acos(-1.0)
#define bitnum(a) __builtin_popcount(a)
using namespace std;
const int N = 1005;
const int M = 100005;
const int inf = 1000000007;
const int mod = 1000000007;
struct edge
{
    int v,d,to;
}e[M];
struct node
{
    int v,d;
    bool operator < (const node &a) const
    {
       return d>a.d;//最小值优先
    }
    node(){}
    node(int _v,int _d):v(_v),d(_d){}
};
bool v[N];
int d[5][N],p,h[N],n;
void add_edge(int u,int v,int d)
{
    e[p].v=v;
    e[p].d=d;
    e[p].to=h[u];
    h[u]=p++;
}
void dijkstra(int s,int k)
{
    int i;
    node u;
    priority_queue<node> q;
    for(i=1;i<=n;i++)
        d[k][i]=inf;
    memset(v,false,sizeof(v));
    d[k][s]=0;
    q.push(node(s,0));
    while(!q.empty())
    {
        u=q.top();
        q.pop();
        if(v[u.v])
            continue;
        v[u.v]=true;
        for(i=h[u.v];i+1;i=e[i].to)
            if(!v[e[i].v])
            {
                d[k][e[i].v]=min(d[k][e[i].v],e[i].d+u.d);
                q.push(node(e[i].v,d[k][e[i].v]));
            }
    }
}
int main()
{
    int m,s,x1,y1,x2,y2,i,u,v,c,ans;
    while(~scanf("%d%d",&n,&m))
    {
        p=0;
        memset(h,-1,sizeof(h));
        scanf("%d%d%d%d%d",&s,&x1,&y1,&x2,&y2);
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&c);
            add_edge(u,v,c);
        }
        dijkstra(s,0);
        dijkstra(x1,1);
        dijkstra(y1,2);
        dijkstra(x2,3);
        dijkstra(y2,4);
        ans=min(d[0][x1]+d[1][y1]+d[2][x2]+d[3][y2],d[0][x1]+d[1][x2]+d[3][y1]+d[2][y2]);
        ans=min(ans,d[0][x1]+d[1][x2]+d[3][y2]+d[4][y1]);
        ans=min(ans,d[0][x2]+d[3][y2]+d[4][x1]+d[1][y1]);
        ans=min(ans,d[0][x2]+d[3][x1]+d[1][y1]+d[2][y2]);
        ans=min(ans,d[0][x2]+d[3][x1]+d[1][y2]+d[4][y1]);
        printf("%d\n",ans);
    }
    return 0;
}

菜鸟成长记