luogu_3645: 雅加达的摩天楼

Posted 2022-12-18 zxytxdy

雅加达的摩天楼

题意描述:

• 有\(N\)座摩天楼，从左到右依次编号为\(0\)到\(N-1\)。
• 有\(M\)个信息传递员，编号依次为\(0\)到\(M-1\)。编号为i的传递员最初在编号为\(B_i\)的摩天楼，邮递员可以在摩天楼之间跳跃(向前或者向后)，编号为\(i\)的传递员跳跃能力为\(P_i\)。
• 当传递员到达一个摩天楼他可以执行两种操作
  • 1: 跳跃到其他摩天楼上。
  • 2: 将消息传递给当前摩天楼的其他传递员。
• 最终要将编号为\(0\)的摩天楼信息传递到编号为\(1\)的摩天楼地方。

输入格式:

• 第一行输入\(N\)和\(M\)。\((1\leq n \leq 3*10^4,1\leq m \leq 3*10^4)\)
• 接下来第\(2\)到\(M+1\)，每行包含两个整数\(B_i\)和\(P_i\)。

输出格式:

• 输出一行，表示最小步数，如果无法到达则输出\(-1\)。

解题思路：

• 分析完题目后可以想到是最短路，对于每一个传递员都可以跳到别处，可以以此建立起点和终点，边权为1。
• 考虑暴力加边的做法，但是如果\(p\)很小的时候，最坏情况下有\(n^2\)条边，任何最短路算法都无法通过。
• 优化建图，采用分块的思想: 将\(n\)点合并为\(\sqrtn\)个块
  • 对于\(P_i\leq\sqrtn\)的传递员：
    • 对于某一栋摩天大楼，就把他从一个点转化为一栋真的摩天大楼。
    • 对于每栋楼建\(\sqrtn\)层，每层有\(n\)个点，第一层代表\(p=1\)的走法，第二层代表\(p=2\)的走法,....。其中第\(0\)代表原先的那个点。
    • 然后暴力加边。第\(i\)层代表\(P=i\)的情况，间距为\(i\)的点相互连长度为\(1\)的边。再把这些辅助点全部连向底边。
  • 对于每个\(P_i>\sqrtn\)的点向其能达到的所有点的第\(0\)层加边。
• 总边数不会超过\(N\sqrtN\)。
• 建图完毕，跑最短路。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = (3e4 + 10)*500;
const int maxm = (3e4 + 10)*500;
int n, m;
int s, t; //起点和终点
int B[maxn], P[maxn]; //起始于B, 跳跃能力为P
int block;

int head[maxn], nex[maxn<<1], ver[maxn<<1], edge[maxn<<1], tot;
inline void add_edge(int x, int y, int z)

    ver[++tot] = y; edge[tot] = z;
    nex[tot] = head[x]; head[x] = tot;


inline int get_block(int x, int y)
    return x*n + y;


int dist[maxn];
bool v[maxn];
void SPFA()

    memset(dist, 0x3f, sizeof(dist));
    dist[s] = 0; queue<int> q;
    q.push(s); v[s] = 1;

    while(q.size())
    
        int x = q.front(); q.pop();
        v[x] = 0;

        for(int i = head[x]; i; i = nex[i])
        
            int y = ver[i], z = edge[i];
            if(dist[y] > dist[x] + z)
            
                dist[y] = dist[x] + z;
                if(!v[y])
                
                    q.push(y);
                    v[y] = 1;
                
            
        
    
    printf("%d\n", dist[t] == 0x3f3f3f3f ? -1 : dist[t]);


int main()

    scanf("%d%d", &n, &m);
    for(int i = 1, x, y; i <= m; i++)
    
        scanf("%d%d", &x, &y);
        B[i] = x + 1, P[i] = y;
    
    
    //起始位置 终止位置 块的大小
    s = B[1], t = B[2]; block = min((int)sqrt(n), 100);
    
    //每一个点转化为一栋楼, 有sqrt(n)层 
    for(int i = 1; i <= block; i++)
        for(int j = 1; j <= n; j++)
    
        add_edge(get_block(i, j), j, 0); //楼底到每一层连边
        if(j <= n - i) //j条一次跳出范围了
        
            //每一层间隔为i的点 跳一次边权为1
            add_edge(get_block(i,j), get_block(i,j)+i, 1);
            add_edge(get_block(i,j)+i, get_block(i,j), 1);
        
    
    
    for(int i = 1; i <= m; i++) //考虑每一个doge的跳跃能力
    
        // 对于每一个传递员, 从楼底到Pi层对应连边
        if(P[i] <= block)
            add_edge(B[i], get_block(P[i], B[i]), 0); 
        else
           //如果大于一个块了 那就暴力加边 因为有sqrt个块 所以加sqrt条边
            for(int j = 1; B[i] + j * P[i] <= n; j++)
                add_edge(B[i], B[i] + j*P[i], j); //向前跳
            for(int j = 1; B[i] - j * P[i] >= 1; j++)
                add_edge(B[i], B[i] - j*P[i], j); //向后跳
         //这里最大可能加N*sqrt(N)条边 
     SPFA(); //优化后边数有 N*sqrt(N)的规模
    return 0;