倍增DP | P1613 跑路

题目来源

题目描述

小 A 的工作不仅繁琐，更有苛刻的规定，要求小 A 每天早上在 6:00 之前到达公司，否则这个月工资清零。可是小 A 偏偏又有赖床的坏毛病。于是为了保住自己的工资，小 A 买了一个空间跑路器，每秒钟可以跑 2^k 千米（k 是任意自然数）。当然，这个机器是用 longint 存的，所以总跑路长度不能超过 maxlongint 千米。小 A 的家到公司的路可以看做一个有向图，小 A 家为点 1，公司为点 n，每条边长度均为一千米。小 A 想每天能醒地尽量晚，所以让你帮他算算，他最少需要几秒才能到公司。数据保证 1 到 n 至少有一条路径。

输入格式

第一行两个整数 n,m，表示点的个数和边的个数。

接下来 m 行每行两个数字 u,v，表示一条 u 到 v 的边。

输出格式

一行一个数字，表示到公司的最少秒数。

题目很明显一看就是最短路问题，但是这题绝对不能直接求最短路，因为跑路器中k是任意的。

因为我们每一次移动的距离是2^k，所有只要两个点之间存在一条距离为2^k(k为任意整数)的路线，那么这条路线需要的时间就是1s。

我们用dist[i][j]表示i到j需要多少s，这道题就是处理好dist数组后，再求dist的最短路即可。

现在我们来预处理dist数组。

如果按照题目直接给的数据，比如直接给了a到b有边，c到d有边，那跑这些路的时间是1s

假如a到b距离为2，b到c距离也为2，那么a到c需要的时间也为1s，因为a到c的距离是2的k次方。

我们需要将这些情况处理，这是题目没有直接给出的。

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

const int INF = INT_MAX; // 使用一个足够大的值表示无穷大
int dis[60][60]; // dist[i][j]表示i到j的需要的最短时间
bool reach[60][60][65]; // reach[i][j][k]表示i到j存在一段2^k次方的路径

void floyd(int n) {
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (dis[i][k] < INF && dis[k][j] < INF) { // 防止整数溢出
                    dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
                }
            }
        }
    }
}

int main() {
    int n, m;
    cin >> n >> m;

    // 初始化dist数组和reach数组
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j) dis[i][j] = 0; 
            else dis[i][j] = INF; 
        }
    }

    // 读取边的信息
    while (m--) {
        int u, v;
        cin >> u >> v;
        reach[u][v][0] = true; // 2^0 = 1, 初始的距离为1
        dis[u][v] = 1;
    }

    // 计算所有2^k的路径
    for (int k = 1; k <= 64; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                for (int h = 1; h <= n; h++) {
                    if (reach[i][j][k-1] && reach[j][h][k-1]) {//如果i到j有一条2^(k-1)的路线，j到k也有一条的话，那么i到k可以有一条2^k的路线，就是这两段路线连起来
                        reach[i][h][k] = true;
                        dis[i][h] = 1;
                    }
                }
            }
        }
    }

    // 使用Floyd算法计算最短路径
    floyd(n);

    
    cout << dis[1][n];
    

    return 0;
}