hdu 5636 Shortest Path【floyd+思维】

最新推荐文章于 2021-05-23 08:20:46 发布

原创最新推荐文章于 2021-05-23 08:20:46 发布 · 605 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#hdu 5636 #杭电 2636

最短路及其拓展专栏收录该内容

166 篇文章

订阅专栏

针对大规模路径图，本文介绍了一种通过预处理特定节点间最短路径以优化查询效率的方法。该方法避免了直接使用Floyd算法所带来的超时问题，特别适用于包含额外边的大规模图。

Shortest Path

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 528 Accepted Submission(s): 171

Problem Description

There is a path graph

G=(V,E) with

n vertices. Vertices are numbered from

1 to

n and there is an edge with unit length between

i and

i+1

(1≤i<n). To make the graph more interesting, someone adds three more edges to the graph. The length of each new edge is

1.

You are given the graph and several queries about the shortest path between some pairs of vertices.

Input

There are multiple test cases. The first line of input contains an integer

T, indicating the number of test cases. For each test case:

The first line contains two integer

n and

(1≤n,m≤105) -- the number of vertices and the number of queries. The next line contains 6 integers

a1,b1,a2,b2,a3,b3

(1≤a1,a2,a3,b1,b2,b3≤n), separated by a space, denoting the new added three edges are

(a1,b1),

(a2,b2),

(a3,b3).

In the next

m lines, each contains two integers

si and

(1≤si,ti≤n), denoting a query.

The sum of values of

m in all test cases doesn't exceed

106.

Output

For each test cases, output an integer

S=(∑i=1mi⋅zi) mod (109+7), where

zi is the answer for

i-th query.

Sample Input
1
10 2
2 4 5 7 8 10
1 5
3 1

Sample Output
7

N非常大，floyd直接写会超时，这里我们需要技巧来floyd、

除了新建立起来的三个点，我们的图保证任何相邻两个点的距离为1，我们新建三个点之后，我们不必要floyd整个图，因为有很多操作是不必要的、我们这里挑出这三个点来讨论、

我们可以做出这三个点所影响的路径的最短路，例如用样例来说：

我们做出2-4、2-5、2-7、2-8、2-10、4-2、4-5、4-7、4-8、4-10..................的最短路。然后假如我们需要求从1-5的最短路的时候，我们枚举i，j点对，使得从起点到终点的路径经过每一条最短路，挑出最小的值，就是从1-5的最短路。

我们这里口述可能说的比较乱，我们对应代码理解：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
#define ll long long int
const int mod=1000000007;
int n,m,a[3][2];
int dis[6][6];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<3;i++)
        {
            scanf("%d%d",&a[i][0],&a[i][1]);
        }
        for(int i=0;i<6;i++)//建立以这六个节点构成的图、
        {
            for(int j=0;j<6;j++)
            {
                if(j!=i)
                {
                    if(i/2==j/2)dis[i][j]=1;
                    else
                    {
                        dis[i][j]=abs(a[i/2][i%2]-a[j/2][j%2]);
                    }
                }
                else
                {
                    dis[i][j]=0;
                }
            }
        }
        ////////////////////////
        for(int i=0;i<6;i++)//求这个图的最短路
        {
            for(int j=0;j<6;j++)
            {
                for(int k=0;k<6;k++)
                {
                    dis[j][k]=min(dis[j][k],dis[j][i]+dis[i][k]);
                }
            }
        }
        int ans=0;
        for(int i=0;i<m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int minn=abs(u-v);
            for(int i=0;i<6;i++)
            {
                for(int j=0;j<6;j++)//枚举所有这六个节点所形成的最短路、
                {
                    int uu=abs(u-a[i/2][i%2]);//从起点到最短路的起点的距离
                    int vv=abs(v-a[j/2][j%2]);//从终点到最短路的终点的距离
                    minn=min(minn,uu+vv+dis[i][j]);//最后加上最短路的距离、枚举之后一定能得到最短路
                }
            }
            ans+=((long long int )minn*(long long int )(i+1))%mod;
            if(ans>=mod)ans-=mod;
        }
        printf("%d\n",ans);
    }
}