代码随想录算法训练营 Day60 图论Ⅹ Bellmen_ford 系列算法

news2025/6/1 15:31:08

图论

题目

94. 城市间货物运输 I
Bellmen_ford 队列优化算法 SPFA
大家可以发现 Bellman_ford 算法每次松弛 都是对所有边进行松弛。
但真正有效的松弛，是基于已经计算过的节点在做的松弛。
本图中，对所有边进行松弛，真正有效的松弛，只有松弛边（节点1->节点2） 和边（节点1->节点3） 因此只要记录上一次松驰过的边即可
模拟过程
我们依然使用minDist数组来表达起点到各个节点的最短距离，例如minDist[3] = 5 表示起点到达节点3 的最小距离为5初始化，起点为节点1，起点到起点的最短距离为0，所以minDist[1] 为 0。将节点1 加入队列 （下次松弛从节点1开始）
在这里插入图片描述

从队列里取出节点1，松弛节点1 作为出发点连接的边（节点1 -> 节点2）和边（节点1 -> 节点3）
边：节点1 -> 节点2，权值为1 ，minDist[2] > minDist[1] + 1 ，更新 minDist[2] = minDist[1] + 1 = 0 + 1 = 1 。边：节点1 -> 节点3，权值为5 ，minDist[3] > minDist[1] + 5，更新 minDist[3] = minDist[1] + 5 = 0 + 5 = 5。将节点2、节点3 加入队列
在这里插入图片描述

从队列里取出节点2，松弛节点2 作为出发点连接的边（节点2 -> 节点4）和边（节点2 -> 节点5）
边：节点2 -> 节点4，权值为1 ，minDist[4] > minDist[2] + (-3) ，更新 minDist[4] = minDist[2] + (-3) = 1 + (-3) = -2 。边：节点2 -> 节点5，权值为2 ，minDist[5] > minDist[2] + 2 ，更新 minDist[5] = minDist[2] + 2 = 1 + 2 = 3 。将节点4，节点5 加入队列
在这里插入图片描述

从队列里出去节点3，松弛节点3 作为出发点连接的边。
因为没有从节点3作为出发点的边，所以这里就从队列里取出节点3就好，不用做其他操作，如图：
在这里插入图片描述

从队列中取出节点4，松弛节点4作为出发点连接的边（节点4 -> 节点6）边：节点4 -> 节点6，权值为4 ，minDist[6] > minDist[4] + 4，更新 minDist[6] = minDist[4] + 4 = -2 + 4 = 2。将节点6加入队列
在这里插入图片描述

从队列中取出节点5，松弛节点5作为出发点连接的边（节点5 -> 节点3），边（节点5 -> 节点6）
边：节点5 -> 节点3，权值为1 ，minDist[3] > minDist[5] + 1 ，更新 minDist[3] = minDist[5] + 1 = 3 + 1 = 4。边：节点5 -> 节点6，权值为-2 ，minDist[6] > minDist[5] + (-2) ，更新 minDist[6] = minDist[5] + (-2) = 3 - 2 = 1。如图，将节点3加入队列，因为节点6已经在队列里所以不用重复添加
在这里插入图片描述

所以我们在加入队列的过程可以有一个优化，用visited数组记录已经在队列里的元素，已经在队列的元素不用重复加入，从队列中取出节点6，松弛节点6 作为出发点连接的边。节点6作为终点，没有可以出发的边。同理从队列中取出节点3，也没有可以出发的边，所以直接从队列中取出。
在这里插入图片描述

这样我们就完成了基于队列优化的bellman_ford的算法模拟过程。大家可以发现基于队列优化的算法，要比bellman_ford 算法减少很多无用的松弛情况，特别是对于边数众多的大图优化效果明显。
代码实现类似于 dijkstra 的优化版本，需要将图以邻接表的形式构建

#include <iostream>
#include <vector>
#include <list>
#include <queue>
#include <climits>

using namespace std;

struct Edge {
    int to;
    int val;

    Edge(int t, int w): to(t), val(w) {}
};

int main() {
    int n, m, x, y, val;
    cin >> n >> m;
    
    vector<list<Edge>> grid(n+1);
    vector<bool> isInQueue(n+1);
    
    // 构造邻接表
    for (int i = 0; i < m; ++i) {
        cin >> x >> y >> val;
        grid[x].push_back({Edge(y, val)});
    }

    int start = 1;
    int end = n;

    vector<int> minDist(n+1, INT_MAX);
    minDist[start] = 0;

    queue<int> que;
    que.push(start);

    // 使用队列
    while (!que.empty()) {
        int cur = que.front();
        // 从队列里取出的时候，要取消标记，我们只保证已经在队列里的元素不用重复加入
        isInQueue[cur] = false;
        que.pop();
        for (Edge e : grid[cur]) {
            int from = cur;
            int to = e.to;
            int price = e.val;
            if (minDist[to] > minDist[from] + price) {
                minDist[to] = minDist[from] + price;
                // 不再添加to这个下标元素 相当于已经访问过
                if (isInQueue[to] == false) {
                    que.push(to);
                    isInQueue[to] = true;
                }
            }
        }
    }

    if(minDist[end] == INT_MAX) cout << "unconnected" << endl;
    else cout << minDist[end] << endl;

    return 0;
}

95. 城市间货物运输 II
涉及到负权回路的情况（存在环路，权值为负，会导致无限循环值越来越小）
非负权回路，松弛 n-1 次以上不会有变换，但是设计负权回路就会越来越小
在这里插入图片描述
那么解决本题的核心思路，就是在 kama94.城市间货物运输I 的基础上，再多松弛一次，看minDist数组是否发生变化。 如果再松弛一次结果变换则存在负权回路

// Bellman_ford 算法实现
#include <iostream>
#include <vector>
#include <climits>

using namespace std;

int main() {
    int n, m, x, y, val;
    cin >> n >> m;
    vector<vector<int>> grid;
    vector<int> minDist(n+1, INT_MAX);

    for (int i = 0; i < m; ++i) {
        cin >> x >> y >> val;
        grid.push_back({x, y, val});
    }

    int start = 1;
    int end = n;
    bool isCircle = false;
    minDist[start] = 0;

    // 多做一次负权回路
    for (int i = 1; i <= n; ++i) {
        
        for (vector<int>& edge : grid) {
            int from = edge[0];
            int to = edge[1];
            int price = edge[2];
            if (i < n) {
                if (minDist[from] != INT_MAX && minDist[to] > minDist[from] + price) {
                    minDist[to] = minDist[from] + price;
                }
            }
            else {
                if (minDist[from] != INT_MAX && minDist[to] > minDist[from] + price) isCircle = true;
            }
        }
    }

    if (isCircle) cout << "circle" << endl;
    else if (minDist[end] == INT_MAX) cout << "unconnected" << endl;
    else cout << minDist[end] << endl;

    return 0;
}

// Bellman_ford 队列优化版本 SPFA 实现
#include <iostream>
#include <vector>
#include <queue>
#include <list>
#include <climits>
using namespace std;

struct Edge { //邻接表
    int to;  // 链接的节点
    int val; // 边的权重

    Edge(int t, int w): to(t), val(w) {}  // 构造函数
};


int main() {
    int n, m, p1, p2, val;
    cin >> n >> m;

    vector<list<Edge>> grid(n + 1); // 邻接表

    // 将所有边保存起来
    for(int i = 0; i < m; i++){
        cin >> p1 >> p2 >> val;
        // p1 指向 p2，权值为 val
        grid[p1].push_back(Edge(p2, val));
    }
    int start = 1;  // 起点
    int end = n;    // 终点

    vector<int> minDist(n + 1 , INT_MAX);
    minDist[start] = 0;

    queue<int> que;
    que.push(start); // 队列里放入起点 
    
    vector<int> count(n+1, 0); // 记录节点加入队列几次
    count[start]++;

    vector<bool> isInQueue(n+1, false);
    isInQueue[start] = true;

    bool flag = false;
    while (!que.empty()) {

        int node = que.front(); que.pop();
        isInQueue[node] = false;

        for (Edge edge : grid[node]) {
            int from = node;
            int to = edge.to;
            int value = edge.val;
            if (minDist[to] > minDist[from] + value) { // 开始松弛
                minDist[to] = minDist[from] + value;
                if (!isInQueue[to]) {
                    que.push(to);
                    isInQueue[to] = true;
                    count[to]++; 
                    if (count[to] == n) {// 如果加入队列次数超过 n-1次 就说明该图与负权回路
                        flag = true;
                        while (!que.empty()) que.pop();
                        break;
                    }
                }
                
            }
        }
    }

    if (flag) cout << "circle" << endl;
    else if (minDist[end] == INT_MAX) {
        cout << "unconnected" << endl;
    } else {
        cout << minDist[end] << endl;
    }

}

96. 城市间货物运输 III
给出尽可能路过最多城市的最短路径
本题是最多经过 k 个城市， 那么是 k + 1条边相连的节点。 这里可能有录友想不懂为什么是k + 1，来看这个图
节点1 最多已经经过2个节点 到达节点4，那么中间是有多少条边呢，是 3 条边对吧。
所以本题就是求：起点最多经过k + 1 条边到达终点的最短距离。
对所有边松弛一次，相当于计算起点到达与起点一条边相连的节点的最短距离，那么对所有边松弛 k + 1次，就是求起点到达与起点k + 1条边相连的节点的最短距离。 理解以上内容，其实本题代码就很容易了，bellman_ford 标准写法是松弛 n-1 次，本题就松弛 k + 1次就好。
但是松弛 k + 1次代码有错，具体分析如下
起点为节点1，起点到起点的距离为0，所以 minDist[1] 初始化为0 ，如图
在这里插入图片描述

其他节点对应的minDist初始化为max，因为我们要求最小距离，那么还没有计算过的节点默认是一个最大数，这样才能更新最小距离。当我们开始对所有边开始第一次松弛：边：节点1 -> 节点2，权值为-1 ，minDist[2] > minDist[1] + (-1)，更新 minDist[2] = minDist[1] + (-1) = 0 - 1 = -1
在这里插入图片描述

边：节点2 -> 节点3，权值为1 ，minDist[3] > minDist[2] + 1 ，更新 minDist[3] = minDist[2] + 1 = -1 + 1 = 0 ，如图
在这里插入图片描述

边：节点3 -> 节点1，权值为-1 ，minDist[1] > minDist[3] + (-1)，更新 minDist[1] = 0 + (-1) = -1 ，如图：
在这里插入图片描述

边：节点3 -> 节点4，权值为1 ，minDist[4] > minDist[3] + 1，更新 minDist[4] = 0 + 1 = 1 ，如图：
在这里插入图片描述

理论上来说，对所有边松弛一次，相当于计算 起点到达 与起点一条边相连的节点 的最短距离。
而且对所有边的后面几次松弛，同样是更新了所有的节点，说明至多经过k 个节点这个限制根本没有限制住，每个节点的数值都被更新了。
这是为什么？
在上面画图距离中，对所有边进行第一次松弛，在计算边（节点2 -> 节点3） 的时候，更新了节点3。
在这里插入图片描述

理论上来说节点3 应该在对所有边第二次松弛的时候才更新。 这因为当时是基于已经计算好的 节点2（minDist[2]）来做计算了。minDist[2]在计算边：（节点1 -> 节点2）的时候刚刚被赋值为 -1。
这样就造成了一个情况，即：计算minDist数组的时候，基于了本次松弛的 minDist数值，而不是上一次松弛时候minDist的数值。所以在每次计算 minDist 时候，要基于 对所有边上一次松弛的 minDist 数值才行，所以我们要记录上一次松弛的minDist。
具体代码添加了 minDist 的 copy

// 朴素 Bellman_ford方法
#include <iostream>
#include <vector>
#include <climits>

using namespace std;

int main() {
    int n, m, x, y, val, src, dst, k;
    cin >> n >> m;
    vector<vector<int>> grid;
    vector<int> minDist(n+1, INT_MAX);
    vector<int> minDistCopy(n+1);
    
    for (int i = 0; i < m; ++i) { 
        cin >> x >> y >> val;
        grid.push_back({x, y, val});
    }

    cin >> src >> dst >> k;

    minDist[src] = 0;
    // 最多经过k个城市，最多走过k+1条边
    for (int i = 1; i <= k + 1; ++i) {
        // 获取上一次计算结果
        minDistCopy = minDist;
        for (vector<int>& side : grid) {
            int from = side[0];
            int to = side[1];
            int price = side[2];
            // 使用上一次copy计算
            if (minDistCopy[from] != INT_MAX && minDist[to] > minDistCopy[from] + price) {
                minDist[to] = minDistCopy[from] + price;
            }
        }
    }

    if (minDist[dst] == INT_MAX) cout << "unreachable" << endl;
    else cout << minDist[dst] << endl;
}

// bellman_ford 队列优化 SPFA
#include <iostream>
#include <vector>
#include <queue>
#include <list>
#include <climits>

using namespace std;

struct Edge {
    int to;
    int val;
    
    Edge(int t, int w) : to(t), val(w) {}
};

int main() {
    int n, m, x, y, val, src, dst, k;
    cin >> n >> m;
    vector<list<Edge>> grid(n+1);
    vector<int> minDist(n+1, INT_MAX);
    vector<int> minDistCopy(n+1);

    for (int i = 0; i < m; ++i) {
        cin >> x >> y >> val;
        grid[x].push_back(Edge(y, val));
    }

    cin >> src >> dst >> k;
    k++; // k+1
    minDist[src] = 0;

    queue<int> que;
    que.push(src);

    // k控制松弛次数
    int qSize = 0;
    while (k-- && !que.empty()) {
        // 开启新的队列
        vector<bool> isInQueue(n+1, false);
        minDistCopy = minDist;
        qSize = que.size();
        // 后--保证执行完全
        while (qSize--) {
            int cur = que.front();
            que.pop();
            isInQueue[cur] = false;
            for (Edge e : grid[cur]) {
                int from = cur;
                int to = e.to;
                int price = e.val;
                if (minDist[to] > minDistCopy[from] + price) {
                    minDist[to] = minDistCopy[from] + price;
                    if (!isInQueue[to]) {
                        que.push(to);
                        isInQueue[to] = true;
                    }
                }
            }
        }
    }

    if (minDist[dst] == INT_MAX) cout << "unreachable" << endl;
    else cout << minDist[dst] << endl;
}

边的顺序会影响每一次扩展的结果，给出边的顺序为
我上面讲解中，给出的示例是这样的：

4 4
1 2 -1
2 3 1
3 1 -1
3 4 1
1 4 3

我将示例中边的顺序改一下，给成：

4 4
3 1 -1
3 4 1
2 3 1
1 2 -1
1 4 3

相同的图就会有不同的结果
在这里插入图片描述

在这里插入图片描述

推理一遍，初始化
在这里插入图片描述
边：节点3 -> 节点1，权值为-1 ，节点3还没有被计算过，节点1 不更新。
边：节点3 -> 节点4，权值为1 ，节点3还没有被计算过，节点4 不更新。
边：节点2 -> 节点3，权值为 1 ，节点2还没有被计算过，节点3 不更新。
边：节点1 -> 节点2，权值为 -1 ，minDist[2] > minDist[1] + (-1)，更新 minDist[2] = 0 + (-1) = -1
在这里插入图片描述

可以发现 同样的图，边的顺序不一样，使用版本一的代码 每次松弛更新的节点也是不一样的。
而边的顺序是随机的，是题目给我们的，所以本题我们才需要 记录上一次松弛的minDist，来保障 每一次对所有边松弛的结果。
为什么必须使用 copy？
94.城市间货物运输I，是没有负权回路的，那么多松弛多少次，对结果都没有影响。求节点1 到 节点n 的最短路径，松弛n-1 次就够了，松弛 大于 n-1次，结果也不会变。 那么在对所有边进行第一次松弛的时候，如果基于本次计算的 minDist 来计算 minDist （相当于多做松弛了），也是对最终结果没影响。
95.城市间货物运输II 是判断是否有负权回路，一旦有负权回路，对所有边松弛 n-1 次以后，在做松弛 minDist 数值一定会变，根据这一点来判断是否有负权回路。所以，95.城市间货物运输II 只需要判断minDist数值变化了就行，而 minDist 的数值对不对，并不是我们关心的。
其关键在于本题的两个因素：
本题可以有负权回路，说明只要多做松弛，结果是会变的。
本题要求最多经过 k 个节点，对松弛次数是有限制的。
可以使用 dijkstra 吗？不可以因为 dijkstra 贪心策略导致找不到
参考：代码随想录

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2393000.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

独立机构软件第三方检测：流程、需求分析及电商软件检验要点？

独立机构软件第三方检测：流程、需求分析及电商软件检验要点？

独立机构承担着对软件进行第三方检测的任务&#xff0c;这一环节对于提升软件的质量和稳定性起到了极其关键的作用。检测过程拥有一套完善的流程&#xff0c;目的在于确保检测结果的精确性&#xff0c;并保障软件达到高标准。 需求分析 确保软件测试需求清晰十分关键。我们需…
阅读更多...
华为FreeArc能和其他华为产品共用充电线吗？

华为FreeArc能和其他华为产品共用充电线吗？

最近刚买的FreeArc终于到手啦&#xff0c;看到网上有朋友说&#xff0c;这次的耳机是不附带充电线&#xff0c;开箱后发现果真如此&#xff0c;那FreeArc到底用什么规格的充电线&#xff0c;能不能和华为的Type-C数据线通用&#xff0c;我来给大家解答一下吧&#xff01; Free…
阅读更多...
[网页五子棋][匹配模式]创建房间类、房间管理器、验证匹配功能，匹配模式小结

[网页五子棋][匹配模式]创建房间类、房间管理器、验证匹配功能，匹配模式小结

文章目录 创建房间类创建房间类实现房间管理器 实现匹配器(3)验证匹配功能问题&#xff1a;匹配按钮不改变验证多开 小结 创建房间类 LOL&#xff0c;通过匹配的方式&#xff0c;自动给你加入到一个房间&#xff0c;也可手动创建游戏房间 这一局游戏&#xff0c;进行的“场所…
阅读更多...
实验设计与分析（第6版，Montgomery)第3章单因子实验：方差分析3.11思考题3.7 R语言解题

实验设计与分析（第6版，Montgomery)第3章单因子实验：方差分析3.11思考题3.7 R语言解题

本文是实验设计与分析&#xff08;第6版&#xff0c;Montgomery著&#xff0c;傅珏生译) 第3章单因子实验&#xff1a;方差分析3.11思考题3.7 R语言解题。主要涉及单因子方差分析&#xff0c;正态性假设检验&#xff0c;残差与拟合值的关系图&#xff0c;平方根变换。 X<-c(…
阅读更多...
【知识点】第2章：Python程序实例解析

【知识点】第2章：Python程序实例解析

文章目录 知识点整理Python程序语法元素分析 练习题判断题填空题选择题 知识点整理 Python程序语法元素分析 Python程序包括格式框架、注释、变量、表达式、分支语句、循环语句、函数等语法元素。 程序的格式框架 Python语言采用严格的 “缩进” 来表明程序的格式框架。缩进…
阅读更多...
每日Prompt：指尖做画

每日Prompt：指尖做画

提示词 微缩景观&#xff0c;微距摄影&#xff0c;俯瞰角度&#xff0c;特写&#xff0c;硕大食指手指甲&#xff0c;一个小小的人正在做画&#xff0c;小人右手拿画笔&#xff0c;小人左手拿调色盘&#xff0c;在指甲上作画&#xff0c;画的是中国古代山水画&#xff0c;背景…
阅读更多...
redis未授权(CVE-2022-0543)

redis未授权(CVE-2022-0543)

概述 Redis 默认绑定在 0.0.0.0:6379&#xff0c;在未配置防火墙或访问控制的情况下会将服务暴露在公网上。若未设置访问密码&#xff08;默认通常为空&#xff09;&#xff0c;攻击者可直接未授权访问 Redis。利用 Redis 提供的 CONFIG 命令&#xff0c;攻击者可修改配置并将…
阅读更多...
【运维实战】Linux 中su和sudo之间的区别以及如何配置sudo!

【运维实战】Linux 中su和sudo之间的区别以及如何配置sudo!

Linux 系统相比其他操作系统具有更高的安全性&#xff0c;其安全机制的核心之一在于用户管理策略和权限控制--普通用户默认无权执行任何系统级操作。 若普通用户需要进行系统级变更&#xff0c;必须通过su或sudo命令提权。 1.su与sudo的本质区别 su 要求直接共享 root 密码&…
阅读更多...
浏览器之禁止打开控制台【F12】

浏览器之禁止打开控制台【F12】

前言 在有时我们的日常开发工作中&#xff0c;有些项目要求我们增加禁用控制台的要求&#xff0c;这种虽然很鸡肋&#xff0c;但是它确实存在&#xff0c;并且会让哈哈心里觉得很有成就感。 所以今天他来了。 文章目录 前言无限debugger实现思路&#xff1a;效果如下&#xff1…
阅读更多...
GEARS以及与基础模型结合

GEARS以及与基础模型结合

理解基因扰动的反应是众多生物医学应用的核心。然而&#xff0c;可能的多基因扰动组合数量呈指数级增长&#xff0c;严重限制了实验探究的范围。在此&#xff0c;图增强基因激活与抑制模拟器&#xff08;GEARS&#xff09;&#xff0c;将深度学习与基因-基因关系知识图谱相结合…
阅读更多...
计算机网络 | 1.1 计算机网络概述思维导图

计算机网络 | 1.1 计算机网络概述思维导图

附大纲&#xff1a; 计算机网络的概念 一个通过通信设备与线路把不同计算机系统连接起来&#xff0c;实现资源共享和信息传递的系统 计算机网络的组成 从组成成分上 硬件&#xff1a;主机、通信链路、交换设备、通信处理机软件&#xff1a;网络操作系统、聊天软件等协议&…
阅读更多...
最悉心的指导教程——阿里云创建ECS实例教程+Vue+Django前后端的服务器部署（通过宝塔面板）

最悉心的指导教程——阿里云创建ECS实例教程+Vue+Django前后端的服务器部署（通过宝塔面板）

各位看官老爷们&#xff0c;点击关注不迷路哟。你的点赞、收藏&#xff0c;一键三连&#xff0c;是我持续更新的动力哟&#xff01;&#xff01;&#xff01; 阿里云创建ECS实例教程 注意&#xff1a; 阿里云有300元额度的免费适用期哟 白嫖~~~~ 注册了阿里云账户后&#x…
阅读更多...
windows中Redis、MySQL 和 Elasticsearch启动并正确监听指定端口

windows中Redis、MySQL 和 Elasticsearch启动并正确监听指定端口

Redis&#xff1a;在 localhost 上启动&#xff0c;并监听端口 6379 MySQL&#xff1a;在 localhost 上启动&#xff0c;并监听端口 3306 Elasticsearch&#xff1a;在 127.0.0.1 上启动&#xff0c;并监听端口 9300 1. Redis 确保 Redis 在 localhost 上启动并监听端口 6379…
阅读更多...
学者观察 | Web3.0的技术革新与挑战——北京理工大学教授沈蒙

学者观察 | Web3.0的技术革新与挑战——北京理工大学教授沈蒙

导语 沈蒙老师认为Web3.0正推动形成新型数据基础设施架构和数据要素流通机制&#xff0c;有望在数字经济时代发挥重要作用&#xff0c;对我国经济发展和社会进步将产生深远影响。AI在推动Web3.0发展方面具有巨大的潜力&#xff0c;但在隐私保护、公平性与安全性等方面也存在“…
阅读更多...
pycharm终端遇不显示虚拟环境的问题

pycharm终端遇不显示虚拟环境的问题

大部分我们用pycharm会配合我们的anaconda来使用&#xff0c;但是配置好后&#xff0c;可能会出现pycharm终端不显示虚拟环境的问题。 首先是确定不显示环境&#xff0c;下图中如果没有这个方框&#xff0c;就是不显示虚拟环境。此时用pip或者conda的命令是会提示不是 “不是内…
阅读更多...
聊聊网络变压器的浪涌等级标准是怎样划分的呢？

聊聊网络变压器的浪涌等级标准是怎样划分的呢？

Hqst盈盛&#xff08;华强盛&#xff09;电子导读&#xff1a;聊聊网络变压器的浪涌等级标准是怎样划分的呢&#xff1f; 在和做防雷产品的客户的深度沟通网络变压器产品选型中发现&#xff1a;客户对网络变压器的浪涌等级划分也很希望有更深的了解&#xff0c;今天就这个问题和…
阅读更多...
2025年Google I/O大会上，谷歌展示了一系列旨在提升开发效率与Web体验的全新功能

2025年Google I/O大会上，谷歌展示了一系列旨在提升开发效率与Web体验的全新功能

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
ONLYOFFICE文档API：编辑器的品牌定制化

ONLYOFFICE文档API：编辑器的品牌定制化

在当今数字化办公时代&#xff0c;文档编辑器已成为各类企业、组织和开发者不可或缺的工具之一。ONLYOFFICE 文档提供的功能丰富且强大的文档编辑 API&#xff0c;让开发者能够根据自己的产品需求和品牌特点&#xff0c;定制编辑器界面&#xff0c;实现品牌化展示&#xff0c;为…
阅读更多...
HTTP/HTTPS与SOCKS5三大代理IP协议，如何选择最佳协议？

HTTP/HTTPS与SOCKS5三大代理IP协议，如何选择最佳协议？

在复杂多变的网络环境中&#xff0c;代理协议的选择直接影响数据安全、访问效率和业务稳定性。HTTP、HTTPS和SOCKS5作为三大主流代理协议&#xff0c;各自针对不同场景提供独特的解决方案。本文将从协议特性、性能对比到选型策略&#xff0c;为您揭示如何根据业务需求精准匹配最…
阅读更多...
远程调用 | OpenFeign+LoadBalanced的使用

远程调用 | OpenFeign+LoadBalanced的使用

目录 RestTemplate 注入 OpenFeign 服务 LoadBalanced 服务 LoadBalanced 注解 RestTemplate 注入 创建 配置类&#xff0c;这里配置后 就不用再重新new一个了&#xff0c;而是直接调用即可 import org.springframework.cloud.client.loadbalancer.LoadBalanced; import …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023