CF1422D Returning Home

• 题目链接：https://codeforces.com/problemset/problem/1422/D
• 稍微思考一下可以很直接的得到，最后的答案无非两种情况：
  1. 从瞬移点普通的走到终点
  2. 从起点普通的走到终点
• 由此我们可以转换问题，我们只需要求出起点到所有瞬移点的最小距离就好了
• 这里可以发现，从一个点到一个点和两个点之间纵坐标，横坐标的差值相关，这里我们把每个点拆成3个，一个点代表瞬移点的横坐标，一个点作为瞬移点的纵坐标，然后横纵坐标都链接瞬移点。瞬移点链接终点，起点链接瞬移点横坐标，瞬移点纵坐标，求一次最短路即可。

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 2e5 + 5;
int n , m;
ll sx, sy, ex, ey;
int st , ed;
struct Node {
    int x, y;
}po[N];
int x[N], y[N];
int head[N*10] , cnt;
struct Edge {
    int t, w, next;
}edge[N*20];
void add (int f, int t, int w)
{
    edge[cnt].t = t;
    edge[cnt].w = w;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
struct node
{
    int v;
    ll value;
    node(int a, ll b):v(a),value(b){};
    //在堆中这样代表从小到大排序
    bool operator < (const node& no) const {
        return value > no.value;
    }
};
ll dis[N*10];
void dijkstra(int s)
{
    mem(dis,INF);
    p_queue <node> q;
    dis[s] = 0;
    q.push(node(s,0));
    while(!q.empty())
    {
        node no = q.top();
        q.pop();
        int u = no.v;
        for(int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].t , w = edge[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                q.push(node(v,dis[v]));
            }
        }
    }
}
int main ()
{
    mem (head,-1);
    read (n, m);
    ed = 3 * m + 1;
    read (sx, sy, ex, ey);
    for (int i = 1 ; i <= m ; i ++)
    {
        read(po[i].x, po[i].y);
        x[i] = po[i].x, y[i] = po[i].y;
    }
    sort (x + 1,x + 1 + m);
    sort (y + 1, y + 1 + m);

    for (int i = 1 ; i <= m ; i ++)
    {
        add (st, i + m , abs (sx - x[i]));
        add (st, i + 2 * m , abs (sy - y[i]));
    }
    for (int i = 2 ; i <= m ; i ++)
    {
        add (i - 1 + m , i + m , abs (x[i]-x[i-1]));
        add (i + m , i - 1 + m , abs (x[i]-x[i-1]));
        add (i - 1 + 2 * m , i + 2 * m , abs (y[i]-y[i-1]));
        add (i + 2 * m , i - 1 + 2 * m , abs (y[i]-y[i-1]));
    }
    for (int i = 1 ; i <= m ; i ++)
    {
        add (i , ed, abs(ex-po[i].x) + abs(ey-po[i].y));

        int xx = lower_bound(x+1, x+1+m, po[i].x) - x;
        int yy = lower_bound(y+1, y+1+m, po[i].y) - y;
        add(i, xx + m, 0), add(xx + m, i, 0);
        add(i, yy + 2 * m, 0), add(yy + 2 * m, i, 0);
    }
    dijkstra(0);
    write(min(abs(sx-ex)+abs(sy-ey),dis[3 * m + 1])),LF;

}