Codeforces 1422D Returning Home（最短路）

题目链接：Returning Home

题意，个给定出发点和终点以及m个传送点，每次往四个方向走一步耗时1min，当与某个传送点的x或y坐标相同时可直接传送到传送点，问从出发点到终点最短时间

题解：这是一道最短路的题，这道题主要难在建图上，首先最容易想到的一种方案就是从出发点直接走到终点，连一条边从出发点到终点，权值是二者x，y差的绝对值的和，因为传送点不和出发点以及终点重合，需要把出发点和每个传送点以及传送点和终点间连边，传送门到终点因为只能一步步走，所以的边权同上，但出发点到传送门因为可以传送，所以边权为二者x,y差的绝对值中较小的一个，其次我们可以发现，传送点间所耗权值应当也是x，y差的绝对值中较小的一个，但是直接连边肯定是不行的，我们可以把传送阵按x排序后把相邻点相连，再按y排序后把相邻点相连,因为如果某个点a能更到点c的最短距离，那么a在按x或y排序后一定和c相邻，否则a一定能更新和x相邻的点，看如下图：

如果a能更新c的值，那么就一定能更新b或d的值，然后b或d再更新c,

这样我们就快速完成了建边，剩下的就是很普通的最短路了（一定一定要开ll不然。。。。）

老规矩，细节和不懂的看代码和注释

//  CF 
#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif */
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll N=2e5+100;
const ll mod=1e9+7;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll w,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=w;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
		b/=2;
	}
	return res;
}
ll fac[MAXN+10],inv[MAXN+10]
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m-n]%mod)%mod;
}
fac[0]=1;inv[0]=1;
for(ll i=1;i<=MAXN;i++){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
	set<int>::iterator it=st.begin();
*/
//emplace_back()  等于push_back(),但效率更高,传输pair时emplace_back(i,j)==push_back({i,j}) 
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
  //emplace_back() 
struct point{
	ll x,y,p;
};
point a[N];
ll n,m;
vector<pair<int,ll>>edge[N];
void add(int u,int v,ll w){
	edge[u].emplace_back(v,w);
	edge[v].emplace_back(u,w);
}
bool compx(point v1,point v2){//按x升序
	return v1.x<v2.x;
}
bool compy(point v1,point v2){//按y升序
	return v1.y<v2.y;
}
ll dis[N];
int vis[N];
struct comp{
	public:
		bool operator()(pair<ll,int> v1,pair<ll,int> v2){
			return v1.first>v2.first;
		}
};
ll dist(int s,int t){//迪杰斯特拉求最短路
	for(int i=0;i<=m+1;i++){
		dis[i]=1e18;
	}
	priority_queue<pair<ll,int>,vector<pair<ll,int>>,comp>q;
	dis[s]=0;
	q.push({0,s});
	while(q.size()){
		pair<ll,int> f=q.top();
		q.pop();
		if(vis[f.second]){
			continue;
		}
		vis[f.second]=1;
		for(int i=0;i<edge[f.second].size();i++){
			pair<int,ll> tmp=edge[f.second][i];
			if(f.first+tmp.second<dis[tmp.first]){
				dis[tmp.first]=f.first+tmp.second;
				q.push({dis[tmp.first],tmp.first});
			}
		}
	}
	return dis[t];
}
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
	ll s,t,sx,sy,tx,ty;
	cin>>n>>m;
	s=0;t=m+1;
	cin>>sx>>sy>>tx>>ty;
	add(s,t,abs(tx-sx)+abs(ty-sy));//出发点和终点连边
	for(int i=1;i<=m;i++){
		cin>>a[i].x>>a[i].y;
		a[i].p=i;
		add(s,i,min(abs(a[i].x-sx),abs(a[i].y-sy)));//出发点到传送门建边
		add(i,t,abs(a[i].x-tx)+abs(a[i].y-ty));//传送门到终点建边
	}
	sort(a+1,a+m+1,compx);
	for(int i=2;i<=m;i++){//按x排序后建边
		add(a[i].p,a[i-1].p,min(abs(a[i].x-a[i-1].x),abs(a[i].y-a[i-1].y)));
	}
	sort(a+1,a+m+1,compy);
	for(int i=2;i<=m;i++){//按y排序后建边
		add(a[i].p,a[i-1].p,min(abs(a[i].x-a[i-1].x),abs(a[i].y-a[i-1].y)));
	}
	cout<<dist(s,t)<<endl;
	return 0;
}