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];
}