[SinGuLaRiTy] 图论题目复习

[Vijos 1423] 最佳路线

题目描述

年久失修的赛道令国际汽联十分不满。汽联命令主办方立即对赛道进行调整，否则将取消其主办权。主办方当然必须马上开始行动。

赛道测评人员经过了三天三夜的数据采集，选出了若干可以使用的道路和各道路行驶所需的时间。这些道路包括若干直道和弯道，每个直道连接两个不同的弯道且为单向，两个弯道之间可能有多条直道，通过直道和弯道都需要一定的时间。主办方打算在这些可用道路中选出一部分作为赛道。赛道是由直道和弯道交替组成的一圈，赛道可多次经过同一条弯道，因为主办方可以通过架设立交桥的方法避免撞车。为了使比赛更加精彩，主办方希望选择一条单圈时间最短的赛道，由于观众席的位置在弯道1，所以赛道必须经过弯道1（赛道至少要包含一条直道）。

输入

第一行是两个整数n，m（1<=n<=200，1<=m<=100000），分别表示弯道数和直道数。接下来n行，第i行是一个整数ai（1<=ai<=1000），表示通过第i个弯道所消耗的时间。接下来m行，第j行是三个整数xj，yj，bj（1<=xj，yj<=n，1<=bj<=1000），表示从弯道xj到弯道yj有一条单向直道，且通过该直道所消耗的时间为bj。

输出

一个整数s，表示单圈时间最短的赛道的单圈时间，若无解则输出-1。

样例数据

样例输入	样例输入
3 6 1 1 2 1 2 3 2 3 5 3 1 1 3 2 1 2 1 10 1 3 15	13

解析

我用的是Floyd：t[i]表示第i个弯道时间，d[i][j]表示第i个弯道到第j个弯道时间，初始化INF。接着运用floyd求出各个弯道之间直道最短时间，记得要加上连接弯道的直道时间。题目要求要经过1弯道的最短路且必要有一直道路，说明必要有两个弯道连接而成加上直道，则枚举2到n所有点，取其d[1][i]+t[i]+d[i][1]+t[1]最小值。还需要判断是否存在解即判断与INF的关系。

如果数据再强一点的话，就该用两次Dijkstra（正向反向各一次），然后枚举中间点来选取答案。

Code

#include<iostream>

#include<cstring>

#include<cstdlib>

#include<cstdio>

#include<cmath>

#include<algorithm>

#define maxn 1010

#define INF 0x3f3f3f3f

int n,m,a,b,c;

int dist[maxn][maxn];

int ans=INF;

int t[maxn];

using namespace std;

int main()

{

    scanf("%d%d",&n,&m);

    for(int i=;i<=n;i++)

        scanf("%d",&t[i]);

    for(int i=;i<=m;i++)

        for(int j=i+;j<=n;j++)

            dist[i][j]=dist[j][i]=INF;

    for(int i=;i<=m;i++){

        scanf("%d%d%d",&a,&b,&c);

        dist[a][b]=min(c+t[a],dist[a][b]);

        }

    for(int i=;i<=n;i++)

        for(int j=;j<=n;j++)

            for(int k=;k<=n;k++)

                dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);

    for(int i=;i<=n;i++)

        ans=min(ans,dist[][i]+dist[i][]);

    if(ans<INF)

        printf("%d",ans);

    else

        puts("-1");

    return ;

}

[COCI 2011-2012 Contest #7] 总统演讲 (KAMPANJA)

题目描述

临近选举，总统要在城市1和城市2举行演讲。他乘汽车完成巡回演讲，从1出发，途中要经过城市2，最后必须回到城市1.特勤局对总统要经过的所有城市监控。为了使得费用最小，必须使得监控的城市最少。求最少要监控的城市。
一共有N个城市，有M条有向边。(0<=N,M<=200)
有N从1出发途中要经过2，最后要回到1的路线中最少要经过的点的数目。

输入

第一行包含2个整数N,M。N表示城市的数目，M表示有向边的数目。
接下来m行，每行两个数A,B，表示从A到B有一条有向边。

输出

最少要监控的城市的数量。

样例数据

样例输入	样例输出
6 7 1 3 3 4 4 5 5 1 4 2 2 6 6 3	6

解析

首先，对于任意两座城市，我们要算出distance[a][b]，即从城市a到城市b的距离，如果两座城市之间没有路径，我们就将distance设置为INF。对于这一操作，Floyd就可以解决了。
我们就可以用dp[a][b]来表示路径1->a->b->1上监控的最少城市数量(注意：a和b也可以相同)。接下来，我们就可以用以下式子来完成dp[a][b]到dp[x][y]的状态转移了:
dp[x][y]=dp[a][b]+distance[b][x]+distance[x][y]+distance[y][a]-1

如果我们使用Dijkstra对所有的(a,b)状态进行搜索，我们的目标状态就是dp[2][2]。

Code

#include<algorithm>

#include<cstdio>

#define MAXN 210

#define INF 1000000

using namespace std;

int g[MAXN][MAXN];

int dist[MAXN][MAXN];

int n, m;

char done[MAXN][MAXN];

int main()

{

    scanf("%d%d",&n,&m);

    for(int i=;i<n;i++)

        for(int j=;j<n;j++)

            g[i][j]= (i==j ?  : INF) ;

    for(int i=;i<m;i++)

    {

        int u,v;

        scanf("%d%d",&u,&v);

        g[--u][--v]=;

    }

    for(int k=;k<n;k++)

        for(int i=;i<n;i++)

            for(int j=;j<n;j++)

                g[i][j]=min(g[i][j],g[i][k]+g[k][j]);

    for(int i=;i<n;i++)

        for(int j=;j<n;j++)

        {

            dist[i][j]=INF;

            done[i][j]=;

        }

    dist[][]=;

    for(;;)

    {

        int a=-,b=-;

        for(int i=;i<n;i++)

            for(int j=;j<n;j++)

            {

                if(done[i][j])

                    continue;

                if(a==-||dist[i][j]<dist[a][b])

                {

                    a=i;

                    b=j;

                }

            }

        if(a==&&b==)

            break;

        done[a][b]=;

        for(int c=;c<n;c++)

            for(int d=;d<n;d++)

            {

                if(c==a||c==b||d==a||d==b)

                    continue;

                dist[c][d]=min(dist[c][d],dist[a][b]+g[b][c]+g[c][d]+g[d][a]-);

            }

    }

    printf("%d", dist[][]);

    return ;

}

[COCI 2011-2012 Contest #7] 送票 (SETNJA)

题目描述

Mirko要给朋友们送音乐会门票。朋友的家可表示为二维平面的网格。Mirko在行走时，可以朝8个方向移动，每次都是整数坐标。他每一步朝上、下、左、右以及4个对角方向走一格。
每个朋友的家可表示为平面上的点(x,y)。当Mirko到某朋友家送票时，朋友也可以走出来迎接他，也可以向8个方向行走。因此，Mirko和这个朋友最多可以在距离他家P步远的位置相遇。P随每个朋友不同。
Mirko的起始位置与终点位置都未知。

题目要求求出:Mirko送完所有票的最少移动步数。

输入

第1行：Mirko的朋友数N (2 ≤ N ≤ 200 000)
接下来N行，每行3个数，表示: x, y, and P (0 ≤ x, y, P ≤
200 000). 朋友按Mirko送票的顺序给出

输出

第1行：1个整数，表示Mirko必须走的最少移动步数

样例数据

样例输入	样例输出
3 3 10 2 8 4 2 2 5 2	4

解析

每一个Mirko的朋友都是由X,Y,P描述的。注意到，与一个朋友的可能的会合点形成了一个以(X,Y)为中心的正方形，更确切地说，是一个相对顶点在(X-P,Y-P)和(X+P,Y+P)的正方形。
那么，现在这个问题就被简化为寻找按顺序经过所有正方形的最短可能路线。
对于K (1<=K<=N)，我们考虑按顺序访问正方形1~K的所有可能的最短路径。设S(K)为这些路径的最终节点的集合，即我们以最佳策略访问前K个朋友后可以结束的所有位置。我们再设d(K)为这些最短路径的长度。
注意到，S(1)的点所组成的形状恰好是第一个朋友所对应的正方形，因为我们从这个正方形的任何点都可以开始(并结束)对这个朋友的访问,且当前的路径长度为0。
我们的程序要继续找到S(2)、S(3)......S(N)。我们会发现，所有的集合都是矩形。那么现在，我们就要看看怎样由S(K)找到S(K+1)。
令D表示S(K)中的任意一点到S(K+1)(即我们下一个要访问的人)的最短距离。那么d(K+1)=d(K)+D。
如果我们在四个方向上对矩形S(K)扩展D个单位，我们得到最佳访问前K个朋友再向任意方向移动D个单位后可以到达的所有点。因此，扩展的矩形与第(K+1)个朋友所对应的正方形的交集就是我们移动d(K)+D(根据D的定义，这个交集一定不是空集)个单位距离后能与第(K+1)个朋友会面的点。那么，这个交集就恰好是S(K+1)。由于这个交集是由一个矩形和一个正方形得到的(正方形和矩形的交点都与相同的轴对其)，这个交集就一定是一个矩形。(还是搞不懂?画画图吧)
最终的解就只是在寻找S(2),S(3),......,S(N)时获得的所有D值的和,这恰好就是d(N)。

Code

#include<cstdio>

#include<algorithm>

#include<iostream>

using namespace std;

struct rectangle

{

    int x1,x2,y1,y2;

    rectangle(){}

    rectangle(int x,int y,int p)

    {

        x1=x-p;

        x2=x+p;

        y1=y-p;

        y2=y+p;

    }

};

int main()

{

    int n;

    scanf("%d",&n);

    int x,y,p;

    scanf("%d%d%d",&x,&y,&p);

    rectangle S(x,y,p);

    long long ans=;

    for(int i=; i<n; ++i)

    {

        scanf("%d%d%d",&x,&y,&p);

        rectangle A(x,y,p );

        int D=max(max(A.x1-S.x2,S.x1-A.x2),max(A.y1-S.y2,S.y1-A.y2));

        if(D<)

            D=;

        ans+=D;

        S.x1-=D;

        S.x2+=D;

        S.y1-=D;

        S.y2+=D;

        rectangle Part;

        Part.x1=max(S.x1,A.x1);

        Part.x2=min(S.x2,A.x2);

        Part.y1=max(S.y1,A.y1);

        Part.y2=min(S.y2,A.y2);

        S=Part;

    }

    cout<<ans;

    return ;

}

[HDU 2196] 最长链 (Computer)

题目描述

给定一棵有n个节点的树，求每个节点到其他节点的最大距离。

输入

输入第一行是一个自然数n(n≤10000)；

接下来 (n−1) 行描述：第i行包含两个自然数 , 表示编号为i的节点连接到的节点编号和这条网线的长度..距离总长不会超过10^9. 每行中的两个数字用空格隔开。

输出

输出包含n行. 第i行表示对于离编号为i的节点最远的节点与该节点的距离Si(1≤i≤n)。

样例数据

样例输入

样例输出

1 1

1 2

数据规模

30% n≤100

100% n≤10000

解析

这道题是考试前一天课上讲的题目，如果我没记错的话应该是HDU 2196的原题。让我兴奋的是，尽管这道题没有被布置进作业当中，但我昨天就已经在HDU上AC了这道题，再打一遍代码也是相当的轻松，一种优越感油然而生......

下面，让我们来看看这道题的思路：对于任何一个节点M，我们可以将距离它最远的点的位置分为两类：①在以M为根节点的子树中，我们假设此种情况下的最远距离为maxdis_down；②在以M为根节点的子树之外,我们假设此种情况下的最远距离为maxdis_up。显而易见的是，此时这个点的最远距离ans[M]就为max(maxdis_down,maxdis_up)。我们重点看看第二种情况：maxdis_up=M到其父亲节点L的距离dis(M,L)+ans[L]。对此，我们可以定义一个dp[MAXN][3]的数组：

f[i][0]表示顶点为i的子树中，距离顶点i的最长距离（对应第一种情况）；

f[i][1]表示i到其父亲节点的距离+其父亲的最长距离（对应第二种情况）；

f[i][0]实际上不需要DP，dfs就可求解（本次dfs也求出次长距离）；对于f[i][1]，我们采取从父节点到子节点的策略。

假设有一L节点，它有n个子节点，我们用Vi来表示。

此时，我们又要分情况来讨论了：

①若Vi不是L的最长路径所经过节点，有f[Vi][1]=dis(Vi,L)+max(f[L][0],f[L][1])；

②若Vi是L的最长路径所经过节点，Vi的最长路径就不能再次被计算，我们就要“退而求其次”，使用第二长的路径Sec_dis，此时有f[Vi][1]=dis(Vi,L)+max(Sec_dis,f[L][1])。

<通过求树的直径解决>

树的直径是什么？就是在一棵树上存在的两点之间的最长距离所经过的路径。例如：

在该图中，树的直径，即距离最长的两点间路径为：7、5、2、1、3、6

在这里我们将用到一个结论：对于任意一个树中的节点来说，距离它最远的点一定是这棵树的直径的两个端点中的一个。【详细证明】

通过这个结论，我们就可以先对两点进行dfs求最远点，确定树的直径的两个端点，然后对树中的点进行dfs求出长度即可。

Code

#include<cstring>

#include<cstdio>

#include<algorithm>

#define MAXN 10010

using namespace std;

struct node_a

{

    int head;

}V[MAXN];

struct node_b

{

    int v;

    int w;

    int next;

}E[MAXN];

int top;

void init()

{

    memset(V,-,sizeof(V));

    top=;

}

void add_edge(int u,int v,int w)

{

    E[top].v=v;

    E[top].w=w;

    E[top].next=V[u].head;

    V[u].head=top++;

}

int dp[MAXN][];

void dfs1(int u)

{

    int biggest=,bigger=;

    for(int i=V[u].head;~i;i=E[i].next)

    {

        int v=E[i].v;

        dfs1(v);

        int tmp=dp[v][]+E[i].w;

        if(biggest<=tmp)

        {

            bigger=biggest;

            biggest=tmp;

        }

        else if(bigger<tmp)

        {

            bigger=tmp;

        }

    }

    dp[u][]=biggest;

    dp[u][]=bigger;

}

void dfs2(int u)

{

    for(int i=V[u].head;~i;i=E[i].next)

    {

        int v=E[i].v;

        dp[v][]=max(dp[u][],dp[v][]+E[i].w==dp[u][] ? dp[u][] : dp[u][])+E[i].w;

        dfs2(v);

    }

}

int main()

{int n;

    scanf("%d",&n);

    init();

    for(int v=;v<=n;v++)

    {

        int u,w;

        scanf("%d%d",&u,&w);

        add_edge(u,v,w);

    }

    dfs1();

    dp[][]=;

    dfs2();

    for(int i=;i<=n;i++)

    {

        printf("%d\n",max(dp[i][],dp[i][]));

    }

    return ;

}

[CQBZOJ 1550] 避开怪兽

题目描述

给出一个N行M列的地图，地图形成一个有N*M个格子的矩阵。地图中的空地用'.'表示。其中某些格子有怪兽，用'+'表示。某人要从起点格子'V'走到终点格子'J'，他可以向上、下、左、右四个方向行走。因此，起点和终点之间可以有许多条路径。注意：即使是有怪兽的格子，他也可以走上去。设路径上某个格子的坐标为(R,C)，某个怪兽的坐标为(A,B)，那么它们之间的曼哈顿距离定义为：|R-A| + |C-B| 显然，地图上可能有许多怪兽，路径上也可能途经许多格子，每个格子到每个怪兽都可以算出之间的曼哈顿距离。问整条路径中离怪兽的曼哈顿距离最小值最大为多少？

输入

第1行：2个整数N和M(1 ≤ N, M ≤ 500) 接下来N行，每行M个字符，可能是'.', '+', 'V', 'J'等. 数据保证仅包含1个'V' 和1个 'J' ，至少有1个'+'

输出

第1行：1个整数，表示最短曼哈顿距离的最大值

样例数据

样例输入1	样例输出1
4 4 +... .... .... V..J	3
样例输入2	样例输出2
4 5 ..... .+++. .+.+. V+.J+	0

解析

因为要求一条路使得怪兽最近的距离最远。
于是预处理出每一个点与怪兽的最近距离，因为走得越远与怪兽距离的最小值不会变大，具有单调性，然后跑dijsktra就行了。

Code

#include<cstdio>

#include<iostream>

#include<cstring>

#include<cmath>

#include<iostream>

#include<queue>

#define MAXN 250000

#define MAXM

#define INF 0x3f3f3f3f

typedef long long int LL;

using namespace std;

struct node

{

    int v;

    node *next;

}*adj[MAXN+],Edges[MAXN*],*New=Edges;

const int dir[][]={{-,},{,},{,-},{,}};

void addedges(int u,int v)

{

    node *p=++New;

    p->v=v;

    p->next=adj[u];

    adj[u]=p;

    p=++New;

    p->v=u;

    p->next=adj[v];

    adj[v]=p;

}

int id[][];

int weath[MAXN+];

struct point

{

    int x,y;

    point(){}

    point(int a,int b):x(a),y(b){}

};

int N,M;

int Sx,Sy,Tx,Ty;

queue<point>que1;

void bfs()

{

    point now;

    while(!que1.empty())

    {

        now=que1.front();que1.pop();

        int nx,ny;

        for(int i=;i<;++i)

        {

            nx=now.x+dir[i][],ny=now.y+dir[i][];

            if(nx<||ny<||nx>M||ny>N)

                continue;

            if(weath[id[nx][ny]]>weath[id[now.x][now.y]]+)

            {

                weath[id[nx][ny]]=weath[id[now.x][now.y]]+;

                que1.push(point(nx,ny));

            }

        }

    }

}

struct data

{

    int pos,w;

    data(){}

    data(int a,int b):pos(a),w(b){}

    bool operator < (const data &a)const

    {

        return w<a.w;

    }

};

int dist[MAXN+];

bool vis[MAXN+];

priority_queue<data>que2;

int dijkstra()

{

    memset(dist,0x3f,sizeof(dist));

    while(!que2.empty())que2.pop();

    int S=id[Sx][Sy],T=id[Tx][Ty];

    dist[S]=weath[S];

    que2.push(data(S,));

    data now;

    while(!que2.empty())

    {

        now=que2.top();que2.pop();

        if(vis[now.pos])

            continue;

        else

            vis[now.pos]=;

        if(now.pos==T)

            return dist[now.pos];

        for(node *p=adj[now.pos];p!=NULL;p=p->next)

            if(dist[p->v]>min(dist[now.pos],weath[p->v]))

            {

                dist[p->v]=min(dist[now.pos],weath[p->v]);

                que2.push(data(p->v,dist[p->v]));

            }

    }

    return -;

}

int main()

{

    scanf("%d%d",&M,&N);

    memset(weath,0x3f,sizeof(weath));

    char s[];

    for(int i=;i<=M;++i)

    {

        scanf("%s",s+);

        for(int j=;j<=N;++j)

        {

            id[i][j]=(i-)*N+j;

            if(s[j]=='+')

            {

                weath[id[i][j]]=;

                que1.push(point(i,j));

            }

            else if(s[j]=='V')

                Sx=i,Sy=j;

            else if(s[j]=='J')

                Tx=i,Ty=j;

        }

    }

    for(int i=;i<=M;++i)

        for(int j=;j<=N;++j)

        {

            if(j!=N)

                addedges(id[i][j],id[i][j+]);

            if(i!=M)

                addedges(id[i][j],id[i+][j]);

        }

    bfs();

    printf("%d\n",dijkstra());

    return ;

}

[BZOJ 1592] 路面修整 (Making the Grade)

题目描述

Farmer John打算好好修一下农场中某条凹凸不平的土路。按奶牛们的要求，修好后的路面高度应当单调上升或单调下降，也就是说，高度上升与高度下降的路段不能同时出现在修好的路中。整条路被分成了N段，N个整数A_1, ... , A_N (1 <= N <= 2,000)依次描述了每一段路的高度(0 <= A_i <= 1,000,000,000)。Farmer John希望找到一个恰好含N个元素的不上升或不下降序列B_1, ... , B_N，作为修过的路中每个路段的高度。由于将每一段路垫高或挖低一个单位的花费相同，修路的总支出可以表示为： |A_1 - B_1| + |A_2 - B_2| + ... + |A_N - B_N| 请你计算一下，Farmer John在这项工程上的最小支出是多少。Farmer John向你保证，这个支出不会超过2^31-1。

输入

第1行: 输入1个整数：N
第2..N+1行: 第i+1行为1个整数：A_i

输出

第1行: 输出1个正整数，表示FJ把路修成高度不上升或高度不下降的最小花费

样例数据

样例输入	样例输出
7 1 3 2 4 5 3 9	3

解析

把高度进行修改时，一定是把它修改成原数组中的数字是最优的。因为无论是将数字加减多少，总是当它和旁边的数字一样大是最优的。因为这样能刚好满足单调性（两数相等）并且改变的数值最小。有可能前面修改的数字在后面出现要变动的情况，所以它有可能取到原数组中的任何一个数字。然后预处理排序一下得到有序的数组b[]。于是可以写出dp方程：f[i][j]表示前i个数、末尾的数改成了第j大的数的最小代价，则f[i][j]=min(f[i-1][k])+abs(a[i]-b[j])，1<=k<=j。但是这样是n^3的，所以还要加上一个优化：我们计算min(f[i-1][k])是O(n)的，但是这个是上一步的状态，所以可以在上一步直接保存min(f[i-1][k])，用类似前缀和的方法。最后不能忘了把b[]颠倒一下求下降的。

Code

#include<cstdio>

#include<iostream>

#include<algorithm>

#include<cstring>

#define mod 1000007

#define INF 0x7fffffff

using namespace std;

int a[],s[];

int f[][];

int sav[][];

int from[];

int head[mod];

struct node

{

    int v,next;

}hashing[];

int cnt,len,ans=;

inline int read()

{

    int x=;char ch=getchar();

    while(ch<''||ch>'')ch=getchar();

    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}

    return x;

}

inline void ins(int u,int w)

{

    hashing[++cnt].v=w;

    hashing[cnt].next=head[u];

    head[u]=cnt;

}

int main()

{

    int n=read();

    for(int i=;i<=n;i++)

    {

        a[i]=read();

        int now=a[i]%mod;bool mark=;

        for(int j=head[now];j;j=hashing[j].next)

        {

            if(hashing[j].v==now)

            {

                mark=;

                break;

            }

        }

        if(mark)

            continue;

        ins(now,a[i]);

        s[++len]=a[i];

    }

    sort(s+,s+len+);

    for(int i=;i<=n;i++)

    {

        sav[i][]=;

        for(int j=;j<=len;j++)

        {

            f[i][j]=;

            int add=abs(a[i]-s[j]);

            f[i][j]=sav[i-][j]+add;

            sav[i][j]=min(sav[i][j-],f[i][j]);

        }

    }

    for(int i=;i<=len;i++)

        ans=min(f[n][i],ans);

    int rev[len+];

    for(int i=;i<=len;i++)

        rev[i]=s[len-i+];

    for(int i=;i<=len;i++)

        s[i]=rev[i];

    memset(f,,sizeof(f));

    for(int i=;i<=n;i++)

    {

        sav[i][]=;

        for(int j=;j<=len;j++)

        {

            f[i][j]=;

            int add=abs(a[i]-s[j]);

            f[i][j]=sav[i-][j]+add;

            sav[i][j]=min(sav[i][j-],f[i][j]);

        }

    }

    for(int i=;i<=len;i++)

        ans=min(f[n][i],ans);

    printf("%d",ans);

    return ;

}

[Baltic 02] 速度限制 (Speed)

题目描述

在这个繁忙的社会中，我们往往不再去选择最短的道路，而是选择最快的路线。开车时每条道路的限速成为最关键的问题。不幸的是，有一些限速的标志丢失了，因此你无法得知应该开多快。一种可以辩解的解决方案是，按照原来的速度行驶。你的任务是计算两地间的最快路线。你将获得一份现代化城市的道路交通信息。为了使问题简化，地图只包括路口和道路。每条道路是有向的，只连接了两条道路，并且最多只有一块限速标志，位于路的起点。两地A和B，最多只有一条道路从A连接到B。你可以假设加速能够在瞬间完成并且不会有交通堵塞等情况影响你。当然，你的车速不能超过当前的速度限制。

输入

第1行:3个空格分开的整数N，M和D(2<＝N<=150)，N表示路口的数目，用0..N-1标记。M是道路的总数，D表示你的目的地。接下来的M行，每行描述一条道路，每行有4个整数A(0≤A＜N)，B(0≤B＜N)，V(0≤V≤500)and L(1≤L≤500)，这条路是从A到B的，速度限制是V，长度为L。如果V是0，表示这条路的限速未知。如果V不为0，则经过该路的时间T=L/V。否则T=L/Vold，Vold是你到达该路口前的速度。开始时你位于0点，并且速度为70。

输出

仅一行整数，表示从0到D经过的城市。输出的顺序必须按照你经过这些城市的顺序，以0开始，以D结束。仅有一条最快路线。

样例数据

样例输入	样例输出
6 15 1 0 1 25 68 0 2 30 50 0 5 0 101 1 2 70 77 1 3 35 42 2 0 0 22 2 1 40 86 2 3 0 23 2 4 45 40 3 1 64 14 3 5 0 23 4 1 95 8 5 1 0 84 5 2 90 64 5 3 36 40	0 5 2 3 1

解析

这里，我们可以采取枚举出所有的情况，借助HASH来记录。
对于一个结点，我们需要记录的有到达这个结点的时间(Tips：并非当前最小时间)、当前速度。所以，我们构造一个求HASH值的式子：Hash=n(结点数)*v(到达这个结点的速度)+当前结点。通过Hash值我们也能很容易求得时间、速度。
或许我们会提出疑问，这样求HASH值可以吗?会不会不同的时间和结点编号却求得相同的HASH值。答案是肯定的，不会。
证明：1.若v相同，结点编号不同，因为结点编号小于n，所以HASH值一定不一样;
2.若结点编号相同，v不同，因为结点编号小于n，所以v最小差值1也不是能用编号差值弥补的，所以HASH值一定不一样;
3.若结点，v不同，因为结点编号小于n，所以v最小差值1也不是能用编号差值弥补的，所以HASH值一定不一样。
有了这个东西，我们就可以做Dijkstra了，当然，关键字依然是时间。一般在Dijkstra中，我们找寻最小的一个关键字都是用for，在这题里，这样做相当浪费时间，因为它并不只有150(n)个。我们考虑用小根堆来实现。
下面实现部分就比较容易了。

Code

#include<iostream>

#include<cstdio>

using namespace std;

const int maxv=;

const int maxn=;

const int INF=;

double T[maxv*maxn];

int A[maxv*maxn];

int pos[maxv*maxn];

int Size;

int g[maxn],rd[maxn][maxn],v[maxn][maxn],w[maxn][maxn];

int path[maxv*maxn],visit[maxv*maxn];

int n,m,D;

void heapup(int k)

{

    while (k> && T[A[k]]<T[A[k>>]])

    {

        swap(pos[A[k>>]],pos[A[k]]);

        swap(A[k>>],A[k]);

        k=k>>;

    }

}

void heapdown(int k)

{

    int lson,rson;

    int minest=k;

    do

    {

        k=minest;

        lson=k<<; rson=(k<<)|;

        if (lson<=Size && T[A[lson]]<T[A[minest]]) minest=lson;

        if (rson<=Size && T[A[rson]]<T[A[minest]]) minest=rson;

        swap(pos[A[k]],pos[A[minest]]);

        swap(A[k],A[minest]);

    }while(minest!=k);

}

void Insert(int Hash)

{

    Size++;

    A[Size]=Hash;

    pos[Hash]=Size;

    heapup(Size);

}

int getmin()

{

    int rt=A[];

    swap(pos[A[]],pos[A[Size]]);

    swap(A[],A[Size]);

    Size--;

    if(Size>)

        heapdown();

    return rt;

}

void print(int Hash)

{

    if(Hash==-)

        return;

    print(path[Hash]);

    int np=Hash%n;

    printf("%d ",np);

}

void dijkstra()

{

    int Hash;

    int shash,sv,sn,dhash,dv,dn;

    double dt;

    for (int i=;i<=n*maxv;i++)

    {

        T[i]=INF;

        visit[i]=;

    }

    Hash=n*+;

    T[Hash]=0.0;

    path[Hash]=-;

    Insert(Hash);

    while(Size!=)

    {

        shash=getmin();

        sn=shash%n;

        sv=shash/n;

        visit[shash]=;

        if(sn==D)

            break;

        for (int i=;i<=g[sn];i++)

        {

            dn=rd[sn][i];

            dv=v[sn][i]==?sv:v[sn][i];

            dhash=n*dv+dn;

            if (visit[dhash]<)

            {

                dt=T[shash]+(double)w[sn][i]/(double)dv;

                if (dt<T[dhash])

                {

                    T[dhash]=dt;

                    path[dhash]=shash;

                    if (visit[dhash]==)

                    {

                        Insert(dhash);

                        visit[dhash]=;

                    }

                    else

                        heapup(pos[dhash]);

                }

            }

        }

    }

    print(shash);

}

int main()

{

    int ad,bd;

    scanf("%d%d%d",&n,&m,&D);

    for (int i=;i<=m;i++)

    {

        scanf("%d%d",&ad,&bd);

        g[ad]++;

        rd[ad][g[ad]]=bd;

        scanf("%d%d",&v[ad][g[ad]],&w[ad][g[ad]]);

    }

    dijkstra();

    return ;

}

Time: 2017-07-20