最短路径（2.19）

目录

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

}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

数据结构与算法----复习Part 12 （字符串初步）

数据结构与算法----复习Part 12 （字符串初步）

本系列是算法通关手册LeeCode的学习笔记 算法通关手册&#xff08;LeetCode&#xff09; | 算法通关手册&#xff08;LeetCode&#xff09; (itcharge.cn) 目录 一&#xff0c;字符串&#xff08;String&#xff09; 二&#xff0c;字符串的比较 三&#xff0c;字符串的存储…
阅读更多...
AI算法的调优流程

AI算法的调优流程

AI算法的调优是提高模型性能和效率的关键步骤之一。以上流程是一个通用的AI算法调优流程&#xff0c;具体应用时可能需要根据问题类型、数据特征和业务需求进行调整和扩展。北京木奇移动技术有限公司&#xff0c;专业的软件外包开发公司&#xff0c;欢迎交流合作。 1. 确定性能…
阅读更多...
回归预测 | Matlab实现RIME-BP霜冰算法优化BP神经网络多变量回归预测

回归预测 | Matlab实现RIME-BP霜冰算法优化BP神经网络多变量回归预测

回归预测 | Matlab实现RIME-BP霜冰算法优化BP神经网络多变量回归预测 目录 回归预测 | Matlab实现RIME-BP霜冰算法优化BP神经网络多变量回归预测预测效果基本描述程序设计参考资料 预测效果 基本描述 1.Matlab实现RIME-BP霜冰算法优化BP神经网络多变量回归预测&#xff08;完整…
阅读更多...
2024第二届化学工程、材料与能源科学国际会议(ICCEMES2024)

2024第二届化学工程、材料与能源科学国际会议(ICCEMES2024)

2024第二届化学工程、材料与能源科学国际会议(ICCEMES2024) 一、【会议简介】 2024第二届化学工程、材料与能源科学国际会议(ICCEMES2024)将于2024年在美丽的三亚市举行。本次会议旨在汇聚全球化学工程、材料与能源科学领域的专家学者&#xff0c;共同探讨和交流相关领域的最…
阅读更多...
第二篇【传奇开心果系列】Python的自动化办公库技术点案例示例：深度解读Pandas金融数据分析

第二篇【传奇开心果系列】Python的自动化办公库技术点案例示例：深度解读Pandas金融数据分析

传奇开心果博文系列 系列博文目录Python的自动化办公库技术点案例示例系列 博文目录前言一、Pandas 在金融数据分析中的常见用途和功能介绍二、金融数据清洗和准备示例代码三、金融数据索引和选择示例代码四、金融数据时间序列分析示例代码五、金融数据可视化示例代码六、金融数…
阅读更多...
易语言源代码5000例

易语言源代码5000例

仅供学习研究交流使用 加群下载
阅读更多...
MySQL8安装切换密码验证方式

MySQL8安装切换密码验证方式

一、MySQL8中新增了一种密码验证方式&#xff1a;caching_sha2_password&#xff0c;如果安装时选择了如下方式&#xff1a; 则数据库使用新的caching_sha2_password密码验证方式。 二、如果安装时选择了caching_sha2_password验证方式&#xff0c;而安装后想发回传统的mysql_…
阅读更多...
医学大数据|统计基础|医学统计学（笔记）：开学说明与目录

医学大数据|统计基础|医学统计学（笔记）：开学说明与目录

开始学习统计基础&#xff0c;参考教材&#xff1a;医学统计学第五版 点点关注一切来学习吧 责任编辑&#xff1a;医学大数据刘刘老师&#xff1a;头部医疗大数据公司医学科学部研究员 邮箱&#xff1a;897282268qq.com 久菜盒子工作室 我们是&#xff1a;985硕博/美国全奖…
阅读更多...
【EI会议征稿通知】第四届能源工程、新能源材料与器件国际学术会议（NEMD 2024）

【EI会议征稿通知】第四届能源工程、新能源材料与器件国际学术会议（NEMD 2024）

第四届能源工程、新能源材料与器件国际学术会议&#xff08;NEMD 2024&#xff09; 2024 4th International Academic Conference on Energy Engineering, new energy materials and devices 第四届能源工程、新能源材料与器件国际学术会议&#xff08;NEMD 2024&#xff09…
阅读更多...
免费在线Axure终于找到了，赶紧试试！

免费在线Axure终于找到了，赶紧试试！

Axure作为一种功能强大的原型设计工具&#xff0c;一直受到设计师的青睐。然而&#xff0c;其高昂的价格可能成为一个门槛&#xff0c;限制了一些设计师的选择。但别担心&#xff0c;现在有一个免费的Axure在线工具即时设计&#xff0c;功能更齐全&#xff0c;性价比更高&#…
阅读更多...
用BIO实现tomcat

用BIO实现tomcat

一、前言 本课程的难度较高&#xff0c;需要将Servlet原理和IO课程全部学完。 二、当前项目使用方式 (1).自定义servlet 自定义servlet需要实现WebServlet并且实现name和urlMapping 重启进行访问 http://localhost:8090/myServlet (2).自定义html 重启进行访问 http://loc…
阅读更多...
幂等性设计

幂等性设计

目录 前言 幂等性设计 幂等性设计处理流程 HTTP 幂等性 消息队列幂等性 基于kafka 前言 幂等性设计&#xff0c;就是说&#xff0c;一次和多次请求某一个资源应该具有同样的副作用。为什么我们要有幂等性操作&#xff1f;说白了&#xff0c;就两点&#xff1a;1、网络的…
阅读更多...
Vue-03

Vue-03

Vue指令 v-bind 作用&#xff1a;动态设置html的标签属性&#xff08;src url title…&#xff09; 语法&#xff1a;v-bind:属性名"表达式" 举例代码如下&#xff1a; 实现效果如下&#xff1a; 案例&#xff1a;图片切换 实现代码如下&#xff1a; 实现的效果…
阅读更多...
072：vue+cesium 实现下雪效果

072：vue+cesium 实现下雪效果

第072个 点击查看专栏目录 本示例的目的是介绍如何在vue+cesium中实现下雪效果，这里使用着色器来实现实例特效。 直接复制下面的 vue+cesium源代码，操作2分钟即可运行实现效果. 文章目录 示例效果配置方式示例源代码（共120行）着色代码实现心得：专栏目标示例效果
阅读更多...
基于springboot+vue的健身房管理系统

基于springboot+vue的健身房管理系统

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、阿里云专家博主、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战&#xff0c;欢迎高校老师\讲师\同行交流合作 ​主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Pyt…
阅读更多...
JavaScript基础1之变量的var、const、let和数据类型的原始类型、对象类型、内存空间、拷贝

JavaScript基础1之变量的var、const、let和数据类型的原始类型、对象类型、内存空间、拷贝

JavaScript基础 变量var关键字var声明的作用域var 定义多个变量变量提升 let关键字暂时性死区let不是Windows的属性 const关键字 数据类型原始类型对象类型内存空间拷贝拷贝原始类型拷贝引用数据类型比较 变量 ECMAScript变量&#xff1a;松散类型的 >变量可以保存任何类型…
阅读更多...
EdgeX Foundry 安装部署

EdgeX Foundry 安装部署

文章目录 一、概述1.官方文档2.Docker Compose 生成器3.创建 docker-compose 文件 二、安装准备1. 克隆服务器2.安装 Docker3.安装 docker-compose 三、非安全模式部署1.docker-comepse2.启动 EdgeX Foundry3.访问 UI3.1. consul3.2. EdgeX Console EdgeX Foundry # EdgeX Fou…
阅读更多...
AI：144-通过机器学习预测股票市场趋势

AI：144-通过机器学习预测股票市场趋势

🚀点击这里跳转到本专栏，可查阅专栏顶置最新的指南宝典~ 🎉🎊🎉 你的技术旅程将在这里启航！ 从基础到实践，深入学习。无论你是初学者还是经验丰富的老手，对于本专栏案例和项目实践都有参考学习意义。 ✨✨✨ 每一个案例都附带关键代码，详细讲解供大家学习，希望…
阅读更多...
IO 与 NIO

IO 与 NIO

优质博文&#xff1a;IT-BLOG-CN 一、阻塞IO / 非阻塞NIO 阻塞IO&#xff1a;当一条线程执行read()或者write()方法时&#xff0c;这条线程会一直阻塞直到读取到了一些数据或者要写出去的数据已经全部写出&#xff0c;在这期间这条线程不能做任何其他的事情。 非阻塞NIO&…
阅读更多...
大数据技术（一）

大数据技术（一）

大数据技术概述 大数据技术层面及其功能 数据采集与预处理 利用ETL(extract-transform-load)工具将分布的、异构数据源中的数据&#xff0c;如关系数据、平面数据文件等&#xff0c;抽取到临时中间层后进行清洗、转换、集成&#xff0c;最后加载到数据仓库或数据集市中&…
阅读更多...
最新文章

Copyright @ 2022~2023