跑路 洛谷1613 倍增 floyd

本文介绍了一道有趣的算法题目,描述了如何使用一种特殊的空间跑路器来帮助角色尽可能晚起床的同时确保按时到达公司。通过构建有向图并利用Floyd算法优化路径,实现了从起点到终点的最短时间计算。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目描述


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

输入格式:


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

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

输出格式:


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

[数据范围]


50%的数据满足最优解路径长度<=1000;

100%的数据满足n<=50,m<=10000,最优解路径长度<=maxlongint

Solution


把能一次跳到的点连权为1的边然后floyd

Code


#include <stdio.h>
#include <string.h>
#define rep(i, st, ed) for (int i = st; i <= ed; i += 1)
#define fill(x, t) memset(x, t, sizeof(x))
#define N 101
#define L 32
using namespace std;
int rec[N][N][L], map[N][N];
inline int read(){
    int num = 0, v = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9'){
        if (ch == '-'){
            v = -1;
        }
        ch = getchar();
    }
    while (ch <= '9' && ch >= '0'){
        num = (num << 1) + (num << 3) + ch - '0';
        ch = getchar();
    }
    return num * v;
}
inline int floyd(const int &n){
    rep(k, 1, n){
        rep(i, 1, n){
            rep(j, 1, n){
                if (map[i][k] + map[k][j] < map[i][j]){
                    map[i][j] = map[i][k] + map[k][j];
                }
            }
        }
    }
    return map[1][n];
}
int main(void){
    fill(map, 63);
    int n = read(), m = read();
    rep(i, 1, m){
        int x = read(), y = read();
        rec[x][y][0] = 1;
        map[x][y] = 1;
    }
    rep(l, 1, 31){
        rep(i, 1, n){
            rep(k, 1, n){
                rep(j, 1, n){
                    if (rec[i][k][l - 1] && rec[k][j][l - 1]){
                        rec[i][j][l] = map[i][j] = 1;
                    }
                }
            }
        }
    }
    int ans = floyd(n);
    printf("%d\n", ans);
    return 0;
}
### 使用 Floyd-Warshall 算法求解 P2349 金字塔最长路径问题 对于给定的金字塔结构,可以将其视为一个有向无环图(DAG),其中每个节点代表金字塔中的一个位置。为了找到从顶部到底部的最长路径,可以通过转换最短路径算法来实现。 Floyd-Warshall 算法通常用于计算所有顶点对之间的最短路径长度,在此场景下稍作调整可用于查找最长路径: 1. 初始化距离矩阵 `dis` ,设起点到自身的距离为0,其他均为负无穷大表示不可达。 2. 对于每一对相邻节点 `(u,v)` 如果存在边,则设置初始值 `dis[u][v] = weight(u->v)` 表示该条边上权值。 3. 运行三重循环更新任意两点间最大可达权重: ```cpp for(k=1;k<=n;++k){ for(i=1;i<=n;++i){ for(j=1;j<=n;++j){ dis[i][j]=max(dis[i][j],dis[i][k]+dis[k][j]); } } } ``` 需要注意的是,由于本题属于DAG上的最长路径问题,也可以采用记忆化搜索或者拓扑排序后的动态规划方法更高效地解决问题[^1]。 #### 记忆化搜索版本代码如下所示: ```cpp #include<bits/stdc++.h> using namespace std; const int N=1e3+7; int n,a[N][N]; vector<int> g[N*N]; // dp[x][y] means the longest path from point (x,y) to bottom row. unordered_map<int,int> memo; bool inside(int x,int y){ return x>=1&&x<=n && y>=1&&y<=x; } void addEdge(int u,int v){ g[u].push_back(v); } int dfs(int pos){ if(memo.count(pos))return memo[pos]; int res=a[__builtin_popcount((pos)-1)+1][(pos)&(-pos)]; // get coordinates by bit manipulation for(auto& next:g[pos]){ res=max(res,dfs(next)); } return memo[pos]=res+a[__builtin_popcount((pos)-1)+1][(pos)&(-pos)]; } int main(){ cin>>n; for(int i=1;i<=n;++i) for(int j=1;j<=i;++j) cin>>a[i][j], addEdge(((1<<i)-1)+(j-1),(1<<(i+1))-1+(j*2-1)), addEdge(((1<<i)-1)+(j-1),(1<<(i+1))-1+j*2); cout << dfs(1)-(a[1][1]<<1)<<'\n'; } ``` 上述程序通过位运算技巧构建了邻接表形式存储的图,并利用深度优先遍历加缓存优化的方式实现了自底向上求解最长路径的过程。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值