CodeForces_1422D Returning Home(最短路)

Returning Home

time limit per test：2 seconds memory limit per test：256 megabytes

Problem Description

Yura has been walking for some time already and is planning to return home. He needs to get home as fast as possible. To do this, Yura can use the instant-movement locations around the city.

Let’s represent the city as an area of $n\times n$ square blocks. Yura needs to move from the block with coordinates $(s_x,s_y)$ to the block with coordinates $(f_x,f_y)$. In one minute Yura can move to any neighboring by side block; in other words, he can move in four directions. Also, there are $m$ instant-movement locations in the city. Their coordinates are known to you and Yura. Yura can move to an instant-movement location in no time if he is located in a block with the same coordinate $x$ or with the same coordinate $y$ as the location.

Help Yura to find the smallest time needed to get home.

Input

The first line contains two integers $n$ and $m$ — the size of the city and the number of instant-movement locations ($1\le n\le 10^9$,$0\le m\le 10^5$).

The next line contains four integers $s_x$ $s_y$ $f_x$ $f_y$ — the coordinates of Yura’s initial position and the coordinates of his home ($1\le s_x,s_y,f_x,f_y\le n$).

Each of the next m lines contains two integers $x_i$ $y_i$ — coordinates of the i-th instant-movement location $(1\le x_i,y_i\le n)$.

Output

In the only line print the minimum time required to get home.

Sample Input

5 3
1 1 5 5
1 2
4 1
3 3

Sample Output

5

题意

在一个n*n大小的地图中，初始在位置$(s_x,s_y)$,目标位置为$(f_x,f_y)$。每分钟可以向上下左右的地图内区域移动一格。在地图中有m个瞬移位置，当与这些位置处于同一行或同一列时，可以选择瞬间传送到该位置。求最快需要多久到达目标位置。

思路

最短路的最后一步一定是从初始位置或瞬移位置走到目标位置。
可以由瞬移位置的同行或同列瞬间传送至瞬移位置，所以额外建$2\ast m$个点，$m$个点代表$x=x_i$，$m$个点代表$y=y_i$(将代表$x=x_i$的m个点按升序排列，y同理)。
两个瞬移点之间的转移代价主要看其横纵坐标之差。

建图：
从 初始位置/瞬移位置连边 到 目标位置 ，代价为两点间的距离。
从 $x=x_i$ 到 $x=x_{i-1}$,$x=x_{i+1}$，代价为$x_i-x_{i-1}$，$x_{i+1}-x_i$。
从 初始位置 到 $x=x_i$，代价为$abs(s_x-x_i)$。
从 瞬移位置$j$ 到 $x=x_j$，代价为0。
$y=y_i$与$x=x_i$同理建边，同时都为双向边。

建完图后跑最短路即可。

#include<stdio.h>
#include<iostream>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<set>
#include<vector>
#include<queue>
#include<iterator>
#define dbg(x) cout<<#x<<" = "<<x<<endl;
#define INF 0x3f3f3f3f
#define LLINF 0x3f3f3f3f3f3f3f3f
#define eps 1e-6
  
using namespace std;
typedef long long LL;
typedef pair<double, int> P;
const int maxn = 300100;
const int mod = 1000000007;
struct node{
    int to, w;
    node(){}
    node(int a, int b):to(a),w(b){}
};
int x[maxn], y[maxn], a[maxn], b[maxn], dis[maxn];
vector<node> g[maxn];
int dijkstra(int n);
void add(int fr, int to, int w);

int main()
{
    int n, m, sx, sy, fx, fy, i, j, k;
    scanf("%d %d", &n, &m);
    scanf("%d %d %d %d", &sx, &sy, &fx, &fy);
    add(0, 3*m+1, abs(sx-fx)+abs(sy-fy));
    for(i=1;i<=m;i++){
        scanf("%d %d", &x[i], &y[i]);
        a[i] = x[i], b[i] = y[i];
    }
    sort(a+1, a+1+m);
    sort(b+1, b+1+m);
    for(i=1;i<=m;i++){
        add(0, i+m, abs(sx-a[i]));
        add(0, i+2*m, abs(sy-b[i]));
        if(i!=1){
            add(i+m, i+m-1, abs(a[i]-a[i-1]));
            add(i+2*m, i+2*m-1, abs(b[i]-b[i-1]));
        }
        if(i!=m){
            add(i+m, i+m+1, abs(a[i]-a[i+1]));
            add(i+2*m, i+2*m+1, abs(b[i]-b[i+1]));
        }
    }
    for(i=1;i<=m;i++){
        add(i, 3*m+1, abs(x[i]-fx)+abs(y[i]-fy));
        int pos = lower_bound(a+1, a+1+m, x[i])-a;
        add(i, pos+m, 0), add(pos+m, i, 0);
        pos = lower_bound(b+1, b+1+m, y[i])-b;
        add(i, pos+2*m, 0), add(pos+2*m, i, 0);
    }
    printf("%d\n", dijkstra(3*m+1));
    return 0;
}

void add(int fr, int to, int w)
{
    g[fr].push_back(node(to, w));
}

int dijkstra(int n)
{
    for(int i=0;i<=n;i++)
        dis[i] = 2e9;
    dis[0] = 0;
    priority_queue<P,vector<P>, greater<P> > que;
    que.push(P(dis[0], 0));
    while(!que.empty())
    {
        P p = que.top();que.pop();
        int u = p.second, v, w;
        if(p.first > dis[u])continue;
        for(int i=0;i<g[u].size();i++){
            v = g[u][i].to, w = g[u][i].w;
            if(dis[v] > dis[u]+w){
                dis[v] = dis[u]+w;
                que.push(P(dis[v], v));
            }
        }
    }
    return dis[n];
}