POJ 1511 SPFA

本文介绍使用SPFA算法解决从指定起点到其他各点的最短路径问题,并通过两次计算来找到总路径长度。文章包含完整的C++实现代码,展示了如何构建邻接表并进行SPFA算法的具体步骤。

题目链接

题意:要求1号点到各点的最短路之和,然后再求各点到1号点的最短路之和。

SPFA邻接表存储

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
const int N = 10000010, M = 10000010;
int head[N], ver[M], edge[M], Next[M], d[N], vis[N];
int xx[N], yy[N], zz[N];
int n, m, tot;
queue<int> q;
bool v[N];
void add(int x, int y, int z) {
    ver[++tot] = y, edge[tot] = z, Next[tot] = head[x], head[x] = tot;
}
bool spfa(int s) {
    memset(d, 0x4f, sizeof d);
    memset(v, 0, sizeof v);
    memset(vis, 0, sizeof vis);
    while(!q.empty())
        q.pop();
    d[s] = 0;
    v[s] = 1;
    q.push(s);
    while(q.size()) {
        int x = q.front();
        q.pop();
        v[x] = 0;
        for(int i = head[x]; i; i = Next[i]) {
            int y = ver[i], z = edge[i];
            if(d[y] > d[x] + z) {
                d[y] = d[x] + z;
                if(!v[y]) {
                    q.push(y), v[y] = 1;
                    vis[y]++;
                    if(vis[y] >= n)
                        return false;
                }
            }
        }
    }
    return true;
}
int main() {
    int T;
    cin >> T;
    while(T--) {
        memset(head, 0, sizeof head);
        memset(ver, 0, sizeof ver);
        memset(edge, 0, sizeof edge);
        memset(Next, 0, sizeof Next);
        tot = 0;
        cin >> n >> m;
        long long ans = 0;
        for(int i = 1; i <= m; i++) {
            scanf("%d%d%d", &xx[i], &yy[i], &zz[i]);
            add(xx[i], yy[i], zz[i]);
        }
        spfa(1);
        for(int i = 2; i <= n; i++)
            ans += d[i];
        memset(head, 0, sizeof head);
        memset(ver, 0, sizeof ver);
        memset(edge, 0, sizeof edge);
        memset(Next, 0, sizeof Next);
        tot = 0;
        for(int i = 1; i <= m; i++) {
            if(xx[i] == 1 && yy[i] == 1)
                continue;
            if(xx[i] == 1) {
                add(yy[i], 0, zz[i]);
                continue;
            }
            if(yy[i] == 1) {
                add(0, xx[i], zz[i]);
                continue;
            }
            add(yy[i], xx[i], zz[i]);
        }
        spfa(0);
        for(int i = 2; i <= n; i++)
            ans += d[i];
        cout << ans << endl;
    }
    return 0;
}

 

基于模拟退火的计算器 在线运行 访问run.bcjh.xyz。 先展示下效果 https://pan.quark.cn/s/cc95c98c3760 参见此仓库。 使用方法(本地安装包) 前往Releases · hjenryin/BCJH-Metropolis下载最新 ,解压后输入游戏内校验码即可使用。 配置厨具 已在2.0.0弃用。 直接使用白菜菊花代码,保留高级厨具,新手池厨具可变。 更改迭代次数 如有需要,可以更改 中39行的数字来设置迭代次数。 本地编译 如果在windows平台,需要使用MSBuild编译,并将 改为ANSI编码。 如有条件,强烈建议这种本地运行(运行可加速、可多次重复)。 在 下运行 ,是游戏中的白菜菊花校验码。 编译、运行: - 在根目录新建 文件夹并 至build - - 使用 (linux) 或 (windows) 运行。 最后在命令行就可以得到输出结果了! (注意顺序)(得到厨师-技法,表示对应新手池厨具) 注:linux下不支持多任务选择 云端编译已在2.0.0弃用。 局限性 已知的问题: - 无法得到最优解! 只能得到一个比较好的解,有助于开阔思路。 - 无法选择菜品数量(默认拉满)。 可能有一定门槛。 (这可能有助于防止这类辅助工具的滥用导致分数膨胀? )(你问我为什么不用其他语言写? python一个晚上就写好了,结果因为有涉及json读写很多类型没法推断,jit用不了,算这个太慢了,所以就用c++写了) 工作原理 采用两层模拟退火来最大化总能量。 第一层为三个厨师,其能量用第二层模拟退火来估计。 也就是说,这套方法理论上也能算厨神(只要能够在非常快的时间内,算出一个厨神面板的得分),但是加上厨神的食材限制工作量有点大……以后再说吧。 (...
03-13
### 关于 POJ 2092 的问题分析 POJ 平台上的题目通常涉及算法设计与实现,而编号为 2092 的具体题目并未在提供的引用中明确提及。然而,可以通过已知的相关资源和经验推测其可能的解决方法。 #### 差分约束系统的应用 如果假设 POJ 2092 类似于其他差分约束类问题,则可以参考类似的解决方案[^3]。这类问题的核心在于通过构建不等式组来表示变量之间的关系,并将其转化为图论中的最短路径或最长路径问题。例如: - 对于条件 \( P \),\( A - B = X \) 可以被分解为两个不等式: \( A - B \geq X \) 和 \( A - B \leq X \)[^3]。 - 对于条件 \( V \),则有 \( A - B \geq 1 \)。 这些不等式可以用边的形式表示在一个加权图中,随后运行 SPFA 或 Bellman-Ford 算法检测是否存在满足所有约束的解集。特别需要注意的是引入一个超级源点连接到所有节点,从而保证整个图连通性。 #### 动态规划 vs 常规方法对比 针对某些特定类型的优化问题,动态规划 (Dynamic Programming, DP) 方法能够显著提高效率并减少冗余计算量。相比之下,传统方式可能会因为重复子问题而导致性能瓶颈。尽管当前讨论未直接指向 POJ 2092 是否适用此技术路线,但从更广泛意义上看,DP 是处理复杂状态转移的有效工具之一[^2]。 以下是基于上述理论框架的一个简单 Python 实现例子用于验证可行性: ```python from collections import deque def spfa(n, edges): INF = float('inf') dist = [-INF] * n in_queue = [False] * n q = deque() s = 0 # Super source node index. # Initialize distances from super-source to all nodes as zero. for i in range(n): if not in_queue[i]: q.append(i) in_queue[i] = True while q: u = q.popleft() in_queue[u] = False for v, w in edges.get(u, []): if dist[v] < dist[u] + w: dist[v] = dist[u] + w if not in_queue[v]: q.append(v) in_queue[v] = True return any(dist[i] >= INF / 2 for i in range(1,n)) # Example usage with dummy data representing constraints... if __name__ == "__main__": N = 5 # Number of variables plus one extra 'super' start point. E = {0:[(i,0)for i in range(1,N)]} # Connects every variable directly via weight-zero links. result = spfa(N,E) print("Positive cycle exists:",result) ``` 以上代码片段展示了如何运用队列辅助广度优先搜索(SPFA)寻找潜在正向循环逻辑链路结构。这一步骤对于判定是否有可行方案至关重要。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值