最短路径（2.19）

news2024/9/24 6:41:59

目录

1.网络延迟时间

弗洛伊德算法

迪杰斯特拉算法

2. K 站中转内最便宜的航班

3.从第一个节点出发到最后一个节点的受限路径数

4.到达目的地的方案数

1.网络延迟时间

有 n 个网络节点，标记为 1 到 n。

给你一个列表 times，表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi)，其中 ui 是源节点，vi 是目标节点， wi 是一个信号从源节点传递到目标节点的时间。

现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1 。

示例 1：

​

输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出：2

示例 2：

输入：times = [[1,2,1]], n = 2, k = 1
输出：1

示例 3：

输入：times = [[1,2,1]], n = 2, k = 2
输出：-1

提示：

  • 1 <= k <= n <= 100
  • 1 <= times.length <= 6000
  • times[i].length == 3
  • 1 <= ui, vi <= n
  • ui != vi
  • 0 <= wi <= 100
  • 所有 (ui, vi) 对都 互不相同（即，不含重复边）

分析：要求最快能到达所有点，就是要找到这个点到达所有点的最短路径的最大值，用弗洛伊德算法的话就是比较暴力了，算出来所有的以后在需要的顶点找最大值，但是迪杰斯特拉算法少一层循环，只要这个顶点到记录到所有顶点的最小距离就好 

弗洛伊德算法用邻接矩阵的时候，可以直接在邻接矩阵上操作，不用再利用结构体去建图

弗洛伊德算法

分析：要更新邻接矩阵，需要一个中间点，写在三层循环的最外层

#include <bits/stdc++.h>
using namespace std;
main()
{
    //接受数据
    int arc,n;
    cin>>n>>arc;
    int i,j,s[n][n];
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
        {
            if(j!=i) s[i][j]=99999;
            else s[i][j]=0;
        }
    int a,b,c;
    for(i=0; i<arc; i++)
    {
        cin>>a>>b>>c;
        s[a-1][b-1]=c;
    }
    cin>>a;
    a=a-1;
    //三层循环
    for(b=0; b<n; b++)
    {
        for(i=0; i<n; i++)
        {
            for(j=0; j<n; j++)
                s[i][j]=min(s[i][j],s[i][b]+s[b][j]);
        }
    }
    int ans=0;
    for(i=0; i<n; i++)
        ans=max(ans,s[a][i]);
//    for(i=0; i<n; i++)
//    {
//        for(j=0; j<n; j++)
//            cout<<s[i][j]<<" ";
//        cout<<endl;
//    }
    ans=ans>9999?-1:ans;
    cout<<ans;

}

迪杰斯特拉算法

分析：找到了一个讲迪杰斯特拉算法的文章，讲的挺详细的【C++】Dijkstra算法_dijkstra c++-CSDN博客

先从邻接矩阵开始写，要设置好visit[]（做标记）和dist[]（记录最短距离），从0开始循环n遍，保证每个点都可以做一次中间点，找到最短的且未被标记的，然后以她作为中间点更新

#include <bits/stdc++.h>
using namespace std;
main()
{
    //接收数据
    int arc,n;
    cin>>n>>arc;
    int i,j,k,s[n][n];
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
        {
            if(j!=i) s[i][j]=99999;
            else s[i][j]=0;
        }

    int a,b,c;
    for(i=0; i<arc; i++)
    {
        cin>>a>>b>>c;
        s[a-1][b-1]=c;
    }
        for(i=0; i<n; i++)
    {
        for(j=0; j<n; j++)
        {
            cout<<s[i][j]<<" ";
        }
        cout<<endl;
    }
    cin>>a;
    //迪杰斯特拉
    int visit[n],dist[n];
    memset(visit,0,sizeof(visit));
    memset(dist,9999,sizeof(dist));
    dist[a-1]=0;
    dist[-1]=9999;
    //循环n遍
    for(i=0; i<n; i++)
    {
        j=-1;
        //计算最小
        for(k=0; k<n; k++)
        {
            if(!visit[k]&&dist[k]<=dist[j])
                j=k;
        }
        //做标记
        visit[j]=1;
        //更新路径
        for(k=0; k<n; k++)
        {
            dist[k]=min(dist[k],dist[j]+s[j][k]);
        }
        for(k=0;k<n;k++) cout<<dist[k]<<" ";
        cout<<endl;
    }
    int ans=0;
    for(i=0; i<n; i++)
    {
        ans=max(ans,dist[i]);
    }
    ans=ans>9999?-1:ans;
    cout<<ans;



}

2. K 站中转内最便宜的航班

有 n 个城市通过一些航班连接。给你一个数组 flights ，其中 flights[i] = [fromi, toi, pricei] ，表示该航班都从城市 fromi 开始，以价格 pricei 抵达 toi。

现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，你的任务是找到出一条最多经过 k 站中转的路线，使得从 src 到 dst 的 价格最便宜 ，并返回该价格。 如果不存在这样的路线，则输出 -1。

示例 1：

输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
输出: 200
解释: 
城市航班图如下
​

从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200，如图中红色所示。

示例 2：

输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 0
输出: 500
解释: 
城市航班图如下
​

从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500，如图中蓝色所示。

提示：

  • 1 <= n <= 100
  • 0 <= flights.length <= (n * (n - 1) / 2)
  • flights[i].length == 3
  • 0 <= fromi, toi < n
  • fromi != toi
  • 1 <= pricei <= 104
  • 航班没有重复，且不存在自环
  • 0 <= src, dst, k < n
  • src != dst

分析：我想到的时用迪杰斯特拉算法，在计算的过程中记录中转次数进行剪枝,比较容易出错的点就是可以中专k次，但是直接到达的算是中转0次，但是如果是原点和终点在同一个地方的话要比0次少一次，那就是-1次，但是我设置的是从原点到原点是0次，所以可以理解成到达某个地方需要乘坐几次航班，那就是乘坐k+1次时才算中转k次，这里比较容易出错

#include <bits/stdc++.h>
using namespace std;
main()
{
    int arc,n;
    cin>>n>>arc;
    int i,j,k,s[n][n];
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
        {
            if(j!=i) s[i][j]=99999;
            else s[i][j]=0;
        }

    int a,b,c;
    for(i=0; i<arc; i++)
    {
        cin>>a>>b>>c;
        s[a][b]=c;
    }
//    for(i=0; i<n; i++)
//    {
//        for(j=0; j<n; j++)
//        {
//            cout<<s[i][j]<<" ";
//        }
//        cout<<endl;
//    }
    cin>>a>>b>>c;
    int visit[n],dist[n],ans[n];
    memset(visit,0,sizeof(visit));
    memset(dist,9999,sizeof(dist));
    memset(ans,0,sizeof(ans));
    dist[a]=0;
    dist[-1]=9999;
    for(i=0;i<n;i++)
    {
        j=-1;
        for(k=0;k<n;k++)
        {
            if(!visit[k]&&dist[k]<=dist[j]) j=k;
        }
        visit[j]=1;
        for(k=0;k<n;k++)
        {
            if(dist[k]>dist[j]+s[j][k] && ans[j]+1<=c+1)
            {
                ans[k]=ans[j]+1;
                dist[k]=dist[j]+s[j][k];
            }
        }
    }
 //   for(i=0;i<n;i++) cout<<ans[i]<<" ";
    cout<<dist[b];
}

3.从第一个节点出发到最后一个节点的受限路径数

现有一个加权无向连通图。给你一个正整数 n ，表示图中有 n 个节点，并按从 1 到 n 给节点编号；另给你一个数组 edges ，其中每个 edges[i] = [ui, vi, weighti] 表示存在一条位于节点 ui 和 vi 之间的边，这条边的权重为 weighti 。

从节点 start 出发到节点 end 的路径是一个形如 [z0, z1, z2, ..., zk] 的节点序列，满足 z0 = start 、zk = end 且在所有符合 0 <= i <= k-1 的节点 zi 和 zi+1 之间存在一条边。

路径的距离定义为这条路径上所有边的权重总和。用 distanceToLastNode(x) 表示节点 n 和 x 之间路径的最短距离。受限路径 为满足 distanceToLastNode(zi) > distanceToLastNode(zi+1) 的一条路径，其中 0 <= i <= k-1 。

返回从节点 1 出发到节点 n 的 受限路径数 。由于数字可能很大，请返回对 109 + 7 取余 的结果。

示例 1：

​

输入：n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]
输出：3
解释：每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。三条受限路径分别是：
1) 1 --> 2 --> 5
2) 1 --> 2 --> 3 --> 5
3) 1 --> 3 --> 5

示例 2：

​

输入：n = 7, edges = [[1,3,1],[4,1,2],[7,3,4],[2,5,3],[5,6,1],[6,7,2],[7,5,3],[2,6,4]]
输出：1
解释：每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。唯一一条受限路径是：1 --> 3 --> 7 。

提示：

  • 1 <= n <= 2 * 104
  • n - 1 <= edges.length <= 4 * 104
  • edges[i].length == 3
  • 1 <= ui, vi <= n
  • ui != vi
  • 1 <= weighti <= 105
  • 任意两个节点之间至多存在一条边
  • 任意两个节点之间至少存在一条路径

分析：这个是要先算出各个点到n点的最短路径，这个的话就应该是迪杰斯特拉算法了，然后放在dist[]中记录，然后就要搜索所有的路径根据dist[]的要求去剪枝，这种搜索的话我想到的是回溯，如果这条路可以走的话进行剪枝，但是我看题解好像更多人用的是动态规划 ，直接用dp[]表示1到i的受限路径数，这样会简单很多，这样放一起来想的话，回溯更适合那种要求写出路径的，像这种只求路径数的更适合动态规划

#include <bits/stdc++.h>
using namespace std;
main()
{
    int arc,n;
    cin>>n>>arc;
    int i,j,k,s[n][n];
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
        {
            if(j!=i) s[i][j]=9999;
            else s[i][j]=0;
        }

    int a,b,c;
    for(i=0; i<arc; i++)
    {
        cin>>a>>b>>c;
        s[a-1][b-1]=c;
        s[b-1][a-1]=c;
    }
//    for(i=0; i<n; i++)
//    {
//        for(j=0; j<n; j++)
//        {
//            cout<<s[i][j]<<" ";
//        }
//        cout<<endl;
//    }
    int visit[n],dist[n],dp[n];
    memset(visit,0,sizeof(visit));
    memset(dist,9999,sizeof(dist));
    memset(dp,0,sizeof(dp));
    dist[n-1]=0;
    dist[-1]=9999;
    for(i=0;i<n;i++)
    {
        j=-1;
        for(k=0;k<n;k++)
        {
            if(!visit[k]&&dist[k]<=dist[j]) j=k;
        }
        visit[j]=1;
        for(k=0;k<n;k++)
        {

                dist[k]=min(dist[k],dist[j]+s[j][k]);

        }
    }
//    for(i=0;i<n;i++) cout<<dist[i]<<" ";
    cout<<endl;
    dp[0]=1;
    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(s[i][j]!=9999 && dist[i]>dist[j])
                dp[j]=dp[j]+dp[i];
        }
            for(k=0;k<n;k++) cout<<dp[k]<<" ";
            cout<<endl;
    }
//    for(i=0;i<n;i++) cout<<dp[i]<<" ";
    cout<<endl;
    cout<<dp[n-1];
//7 8
//1 3 1
//4 1 2
//7 3 4
//2 5 3
//5 6 1
//6 7 2
//7 5 3
//2 6 4

}

4.到达目的地的方案数

你在一个城市里，城市由 n 个路口组成，路口编号为 0 到 n - 1 ，某些路口之间有 双向 道路。输入保证你可以从任意路口出发到达其他任意路口，且任意两个路口之间最多有一条路。

给你一个整数 n 和二维整数数组 roads ，其中 roads[i] = [ui, vi, timei] 表示在路口 ui 和 vi 之间有一条需要花费 timei 时间才能通过的道路。你想知道花费 最少时间 从路口 0 出发到达路口 n - 1 的方案数。

请返回花费 最少时间 到达目的地的 路径数目 。由于答案可能很大，将结果对 109 + 7 取余 后返回。

示例 1：

​

输入：n = 7, roads = [[0,6,7],[0,1,2],[1,2,3],[1,3,3],[6,3,3],[3,5,1],[6,5,1],[2,5,1],[0,4,5],[4,6,2]]
输出：4
解释：从路口 0 出发到路口 6 花费的最少时间是 7 分钟。
四条花费 7 分钟的路径分别为：
- 0 ➝ 6
- 0 ➝ 4 ➝ 6
- 0 ➝ 1 ➝ 2 ➝ 5 ➝ 6
- 0 ➝ 1 ➝ 3 ➝ 5 ➝ 6

示例 2：

输入：n = 2, roads = [[1,0,10]]
输出：1
解释：只有一条从路口 0 到路口 1 的路，花费 10 分钟。

提示：

  • 1 <= n <= 200
  • n - 1 <= roads.length <= n * (n - 1) / 2
  • roads[i].length == 3
  • 0 <= ui, vi <= n - 1
  • 1 <= timei <= 109
  • ui != vi
  • 任意两个路口之间至多有一条路。
  • 从任意路口出发，你能够到达其他任意路口。

分析：我刚开始只想到了要用迪杰斯特拉算法计算出最小路径，然后再用动态规划计算路径数目，但是到计算路径数目的时候被难到了，总想着要用回溯去找路径，后来看了别人的题解才的发现有一个性质是：如果是合法路径，那么在途中经过的每一个点都是以最短路径的方式到达的，也就是说，走到这里消费的时间其实就是dist[i]

那么就可以用dp[i]记录走到这里等于dist[i]的数目，然后更新dp[i]

#include <bits/stdc++.h>
using namespace std;
main()
{
    int arc,n;
    cin>>n>>arc;
    int i,j,k,s[n][n];
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
        {
            if(j!=i) s[i][j]=9999;
            else s[i][j]=0;
        }

    int a,b,c;
    for(i=0; i<arc; i++)
    {
        cin>>a>>b>>c;
        s[a][b]=c;
        s[b][a]=c;
    }
//    for(i=0; i<n; i++)
//    {
//        for(j=0; j<n; j++)
//        {
//            cout<<s[i][j]<<" ";
//        }
//        cout<<endl;
//    }
    int visit[n],dist[n],dp[n];
    memset(visit,0,sizeof(visit));
    memset(dist,9999,sizeof(dist));
    memset(dp,0,sizeof(dp));
    dist[0]=0;
    dist[-1]=9999;
    for(i=0;i<n;i++)
    {
        j=-1;
        for(k=0;k<n;k++)
        {
            if(!visit[k]&&dist[k]<=dist[j]) j=k;
        }
        visit[j]=1;
        for(k=0;k<n;k++)
        {

                dist[k]=min(dist[k],dist[j]+s[j][k]);

        }
    }
//    for(i=0;i<n;i++) cout<<dist[i]<<" ";
    cout<<endl;
    dp[0]=1;
    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(s[i][j]!=9999 && dist[j]==dist[i]+s[i][j])
                dp[j]=dp[j]+dp[i];
        }
//            for(k=0;k<n;k++) cout<<dp[k]<<" ";
//            cout<<endl;
    }
//    for(i=0;i<n;i++) cout<<dp[i]<<" ";
    cout<<endl;
    cout<<dp[n-1];
//7 10
//0 6 7
//0 1 2
//1 2 3
//1 3 3
//6 3 3
//3 5 1
//6 5 1
//2 5 1
//0 4 5
//4 6 2

}

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

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

相关文章

3、JavaWeb-Ajax/Axios-前端工程化-Element

3、JavaWeb-Ajax/Axios-前端工程化-Element

P34 Ajax介绍 Ajax:Asynchroous JavaScript And XML&#xff0c;异步的JS和XML JS网页动作&#xff0c;XML一种标记语言&#xff0c;存储数据&#xff0c; 作用&#xff1a; 数据交换&#xff1a;通过Ajax给服务器发送请求&#xff0c; 并获取服务器响应的数据 异步交互&am…
阅读更多...
C++ //练习 10.24 给定一个string，使用bind和check_size在一个int的vector中查找第一个大于string长度的值。

C++ //练习 10.24 给定一个string，使用bind和check_size在一个int的vector中查找第一个大于string长度的值。

C Primer&#xff08;第5版&#xff09; 练习 10.24 练习 10.24 给定一个string&#xff0c;使用bind和check_size在一个int的vector中查找第一个大于string长度的值。。 环境&#xff1a;Linux Ubuntu&#xff08;云服务器&#xff09; 工具&#xff1a;vim 代码块 /*****…
阅读更多...
VsCode配置PCL、Open3D自动补全

VsCode配置PCL、Open3D自动补全

写在前面 本文内容 在VsCode上开发PCL、Open3D相关代码&#xff0c;代码自动补全 Open3D、PCL的安装使用见各个版本的Open3D、PCL的编译、使用教程 平台/环境 windows11(windows10): visual studio 2022&#xff1b;cmake 3.22; VsCode 通过cmake构建项目&#xff1b; 转载请…
阅读更多...
基于Springboot免费搭载轻量级阿里云OSS数据存储库（将本地文本、照片、视频、音频等上传云服务保存）

基于Springboot免费搭载轻量级阿里云OSS数据存储库（将本地文本、照片、视频、音频等上传云服务保存）

一、注册阿里云账户 打开https://www.aliyun.com/&#xff0c;申请阿里云账户并完成实名认证&#xff08;个人&#xff09;。这种情况就是完成了&#xff1a; 二、开通OSS服务 点击立即开通即可。 三、创建Bucket 申请id和secert&#xff1a; 进去创建一个Accesskey就会出现以…
阅读更多...
【软考】数据库的三级模式

【软考】数据库的三级模式

目录 一、概念1.1 说明1.2 数据库系统体系结构图 二、外模式三、概念模式四、内模式 一、概念 1.1 说明 1.数据的存储结构各不相同&#xff0c;但体系结构基本上具有相同的特征&#xff0c;采用三级模式和两级镜像 2.数据库系统设计员可以在视图层、逻辑层和物理层对数据进行抽…
阅读更多...
C语言：预处理

C语言：预处理

C语言&#xff1a;预处理 预定义符号#define定义常量定义宏宏与函数对比 #操作符##操作符条件编译头文件包含库文件包含本地文件包含嵌套文件包含 预定义符号 C语⾔设置了⼀些预定义符号&#xff0c;可以直接使⽤&#xff0c;预定义符号也是在预处理期间处理的。 __FILE__ //…
阅读更多...
惠普GT5810打印机报错E9的处理方法

惠普GT5810打印机报错E9的处理方法

当打印机检测到供墨系统需要维护时&#xff0c;将会出现 E9 错误。 吴中函 打印出的带错误的供墨系统维护页包含解决该错误的说明。 出现 E9 警告时维持 HP Ink Tank 打印机的打印质量&#xff0c;出现 E9 警告时如何维持 HP Ink Tank 打印机的打印质量。 惠普5810报错E9通常…
阅读更多...
UE 打包窗口及鼠标状态设置

UE 打包窗口及鼠标状态设置

UE 打包窗口及鼠标状态设置 打包后鼠标不锁定 显示鼠标图标 打包后设置窗口模式 找到打包路径下的配置文件GameUserSettings&#xff0c;设置相关项目 FullscreenMode0表示全屏模式&#xff0c;1表示窗口全屏模式&#xff0c;2表示窗口模式
阅读更多...
Spring的Bean的生命周期 | 有图有案例

Spring的Bean的生命周期 | 有图有案例

Spring的Bean的生命周期 Spring的Bean的生命周期整体过程实例化初始化服务销毁循环依赖问题 完整生命周期演示 Spring的Bean的生命周期 Spring Bean的生命周期&#xff1a;从Bean的实例化之后&#xff0c;通过反射创建出对象之后&#xff0c;到Bean称为一个完整的对象&#xf…
阅读更多...
位运算---求n的二进制表示中第k位是1还是0 (lowbit)

位运算---求n的二进制表示中第k位是1还是0 (lowbit)

操作&#xff1a; 先把第k位移到最后一位&#xff08;右边第一位&#xff09; 看个位是1还是0 lowbit(x)&#xff1a;返回x的最右边的1。 原理&#xff1a; 其中 &#xff0c;意思是 是 的补码。 就可以求出最右边的一位1。 应用&#xff1a; 当中 的个数。 int re…
阅读更多...
案例介绍：汽车维修系统的信息抽取技术与数据治理应用(开源)

案例介绍：汽车维修系统的信息抽取技术与数据治理应用(开源)

一、引言 在当今汽车产业的快速发展中&#xff0c;软件已经成为提升车辆性能、安全性和用户体验的关键因素。从车载操作系统到智能驾驶辅助系统&#xff0c;软件技术的进步正在重塑我们对汽车的传统认知。我有幸参与了一个创新项目&#xff0c;该项目专注于开发和集成先进的汽…
阅读更多...
分布式ID生成算法｜雪花算法 Snowflake | Go实现

分布式ID生成算法｜雪花算法 Snowflake | Go实现

写在前面 在分布式领域中&#xff0c;不可避免的需要生成一个全局唯一ID。而在近几年的发展中有许多分布式ID生成算法&#xff0c;比较经典的就是 Twitter 的雪花算法(Snowflake Algorithm)。当然国内也有美团的基于snowflake改进的Leaf算法。那么今天我们就来介绍一下雪花算法…
阅读更多...
2024年智能驾驶年度策略：自动驾驶开始由创造型行业转向工程型行业

2024年智能驾驶年度策略：自动驾驶开始由创造型行业转向工程型行业

感知模块技术路径已趋于收敛&#xff0c;自动驾驶从创造型行业迈向工程型行业。在特斯拉的引领下&#xff0c;国内主机厂2022年以来纷纷跟随特斯拉相继提出“重感知、轻地图”技术方案&#xff0c;全球自动驾驶行业感知模块技术路径从百花齐放开始走向收敛。我们认为主机厂智能…
阅读更多...
光学遥感卫星分辨率的奥秘 ！！

光学遥感卫星分辨率的奥秘 ！！

文章目录 前言 1、光学遥感卫星分辨率的多维视角 &#xff08;1&#xff09;空间分辨率 &#xff08;2&#xff09;光谱分辨率 &#xff08;3&#xff09;辐射分辨率 &#xff08;4&#xff09;时间分辨率 2、光学遥感分辨率的重要性 3、遥感分辨率的挑战与进步 4、未来展望 总…
阅读更多...
Git推送本地仓库至阿里云仓库

Git推送本地仓库至阿里云仓库

Git推送本地仓库至阿里云仓库 1.安装Git 参考Git安装详解 2.生成 SSH 密钥 基于RSA算法SSH 密钥 1.管理员权限运行Git Bash 2.输入生成密钥指令点击回车&#xff0c;选择 SSH 密钥生成路径。 $ ssh-keygen -t rsa -C "2267521563qq.com"3.以 RSA算法为例&…
阅读更多...
ABAP - SALV教程17 弹窗ALV

ABAP - SALV教程17 弹窗ALV

SALV可以通过弹窗形式打开在生成SALV实例对象后调用set_screen_popup方法设置成弹出模式 "设置为弹窗模式 go_alv->set_screen_popup( start_column 10end_column 110start_line 5end_line 15). 显示效果 完整代码 SELECT *FROM ekkoINTO TABLE DATA(gt_dat…
阅读更多...
C++自学精简实践教程

C++自学精简实践教程

一、介绍 1.1 教程特点 一篇文章从入门到就业有图有真相&#xff0c;有测试用例&#xff0c;有作业&#xff1b;提供框架代码&#xff0c;作业只需要代码填空规范开发习惯&#xff0c;培养设计能力 1.2 参考书 唯一参考书《C Primer 第5版》​参考书下载&#xff1a; 蓝奏云…
阅读更多...
如何自己系统的学python

如何自己系统的学python

学习Python是一项很好的投资&#xff0c;因为它是一种既强大又易于学习的编程语言&#xff0c;适用于多种应用&#xff0c;如数据分析、人工智能、网站开发等。下面是一个系统学习Python的步骤建议&#xff1a; 基础准备 安装Python&#xff1a; 访问Python官网下载最新版本的…
阅读更多...
代码随想录第45天|● 198.打家劫舍 ● 213.打家劫舍II ● 337.打家劫舍III

代码随想录第45天|● 198.打家劫舍 ● 213.打家劫舍II ● 337.打家劫舍III

文章目录 ● 198.打家劫舍思路代码1.dp数组两个变量 ● 213.打家劫舍II思路&#xff1a;代码 ● 337.打家劫舍III思路代码&#xff1a; ● 198.打家劫舍 思路 代码 1.dp数组 class Solution {public int rob(int[] nums) {if(nums.length1)return nums[0];int[] dpnew int[nu…
阅读更多...
CentOS下安装Kafka3

CentOS下安装Kafka3

kafka是分布式消息队列&#xff0c;本文讲述其在centos&#xff08;centos 7.5&#xff09;下的安装。安装过程可以参考其官方文档https://kafka.apache.org/36/documentation.html 首先在官网 https://kafka.apache.org/downloads 下载Kafka二进制文件&#xff08;官网的压缩包…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023