luogu3645 [Apio2015]雅加达的摩天大楼 (分块+dijkstra)

我们是想跑最短路的

我们有两种建图方式：

1.对于每个doge i，连向B[j]==B[i]+P[i]*k ,k=..,-2,-1,0,1,2,... ，边权=|k|，这样连的复杂度是$O(N\sum\limits_{i=1}^{m}\frac{1}{P[i]})$

2.对于每个楼i，建max(P[i])个点，表示可以有一个doge经过这个楼来跳j个距离，也就是说，给P[i][j]连向P[i-j][j]和P[i+j][j]，边权=1，而且还要给所有的P[i]连起来，边权是0.

这样连的复杂度是$O(N\sum\limits_{i=1}^{m}P[i])$，其中P[i]是互不相同的（相同就不加了）

然而都过不了

然后我们发现，复杂度一个是乘P[i]，一个是除以P[i]，这就启发我们采用分块的思想，对于P[i]大于$\sqrt{N}$的使用第1种建法，小于的使用第二种建法，整体的复杂度就变成$O(N\sqrt{N})$了

然而因为玄学的常数问题，我们需要：

1.让那个分块的边界取$min(\sqrt{N},100)$（我也不知道为什么）

2.在做最短路的时候再计算边，而不是提前都建好

3.深吸一口氧气（必要）

4.使用spfa而不是dijkstra（我也不知道为什么，但我还是用了dijkstra，然后就挂了...）

（代码写一年还写得巨丑）

 #include<bits/stdc++.h>
 #define pa pair<int,int>
 #define lowb(x) ((x)&(-(x)))
 #define REP(i,n0,n) for(i=n0;i<=n;i++)
 #define PER(i,n0,n) for(i=n;i>=n0;i--)
 #define MAX(a,b) ((a>b)?a:b)
 #define MIN(a,b) ((a<b)?a:b)
 #define CLR(a,x) memset(a,x,sizeof(a))
 #define rei register int
 using namespace std;
 typedef long long ll;
 const int maxn=,sqrtn=;

 inline ll rd(){
     ll x=;char c=getchar();int neg=;
     while(c<''||c>''){if(c=='-') neg=-;c=getchar();}
     while(c>=''&&c<='') x=x*+c-'',c=getchar();
     return x*neg;
 }

 struct Node{
     int x,y,d;bool isp;
     Node (int a,int b,int c,bool s){x=a,y=b,d=c,isp=s;}
 }S=Node(,,,);
 int N,SN,M,B[maxn],P[maxn];
 int dis[maxn*sqrtn],poi[maxn][],ph[maxn];
 bool flag[maxn*sqrtn];
 priority_queue<Node,vector<Node>,greater<Node> > q;

 bool operator > (Node a,Node b){return a.d>b.d;}
 inline int id(Node a){return a.isp?a.x:M++a.x+a.y*N;}
 inline void print(int x,Node a){printf("Node%d:%d %d %d %d\n",x,a.x,a.y,a.d,a.isp);}

 inline int dijkstra(){
     memset(dis,,sizeof(dis));
     dis[id(S)]=;q.push(S);
     while(!q.empty()){
         Node p=q.top();q.pop();
         if(((!p.isp)&&p.x==B[])||(p.isp&&p.x==)) return p.d;
         if(flag[id(p)]) continue;

         if(!p.isp){
             for(int i=ph[p.x];i!=-;i=poi[i][]){
                 if(P[poi[i][]]>SN){
                     if(dis[poi[i][]]<=p.d) continue;
                     dis[poi[i][]]=p.d;
                     q.push(Node(poi[i][],,p.d,));
                 }else if(P[poi[i][]]!=p.y){
                     Node x=Node(p.x,P[poi[i][]],p.d,);
                     if(dis[id(x)]<=p.d) continue;
                     dis[id(x)]=p.d;q.push(x);
                 }
             }
             if(p.y){
                 Node xx=Node(p.x+p.y,p.y,p.d+,);
                 if(p.x+p.y<N&&dis[id(xx)]>p.d+){
                     dis[id(xx)]=p.d+;
                     q.push(xx);
                 }xx.x=p.x-p.y;
                 if(p.x-p.y>=&&dis[id(xx)]>p.d+){
                     dis[id(xx)]=p.d+;
                     q.push(xx);
                 }
             }
         }
         else{
             for(int i=B[p.x]+P[p.x],j=;i<N;i+=P[p.x],j++){
                 Node a=Node(i,,p.d+j,);
                 if(dis[id(a)]>p.d+j){
                     dis[id(a)]=p.d+j;q.push(a);
                 }
             }
             for(int i=B[p.x]-P[p.x],j=;i>=;i-=P[p.x],j++){
                 Node a=Node(i,,p.d+j,);
                 if(dis[id(a)]>p.d+j){
                     dis[id(a)]=p.d+j;q.push(a);
                 }
             }
         }
         flag[id(p)]=;
     }return -;
 }

 int main(){
     //freopen(".in","r",stdin);
     rei i,j,k;
     N=rd(),M=rd();SN=min(,(int)sqrt(N));
     memset(ph,-,sizeof(ph));
     for(i=;i<M;i++){
         B[i]=rd(),P[i]=rd();
         poi[i][]=i;poi[i][]=ph[B[i]];ph[B[i]]=i;
     }S=Node(B[],,,);
     printf("%d\n",dijkstra());
     return ;
 }