刷题记录（NC17511 公交线路（求最短路），NC17509 挖沟（求最小生成树））

已于 2022-10-17 20:46:13 修改
阅读量346 收藏
点赞数 1
分类专栏： 刷题记录 文章标签： 算法 数据结构
于 2022-10-16 22:28:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60531106/article/details/127342318
版权

链式前向星（存边）：

void addedge(int x, int y, int l)
{
    edge[++cnt].l = l;
    edge[cnt].t = y;
    edge[cnt].next = head[x];
    head[x] = cnt;
}

NC17511 公交线路（求最短路）

题目链接

迪杰斯特拉算法：

思想：

1、dijkstra算法是求一个点到其他所有点的最短距离，以下设该点为s,即求s点到其他所有点的最短距离

2、用一个dis数组来记s到所有节点到的最短距离，首先先将该距离初始化为最大值，对于dis[s] = 0,到自己本身的距离就为0。首先先将所有与s有连边先更新dis值

3、用一个vis数组来标记当前点是否有访问过，每次从所有节点中找dis值最小且未访问过的节点x，将其当作中间节点，标记为访问过，即该点到s的最小距离已经求出，然后利用该最小距离作为中间节点，更新每个节点的dis值。即计算dis[x] + ve[x][k] < dis[k](k为任意一个节点)出现，就更新

4、优化：可以利用优先队列即最小堆来减少复杂度，因此每次都要从所有节点中找出dis值最小且未访问过的节点，那么我们可以将所有值的dis值存入优先队列中，每次取出dis值最小的（即队首元素），判断是否访问过，访问过则取下一个。这样直接取元素会更快

5、如果求s-k的最短距离：dis[k]

完整代码：

# include <bits/stdc++.h>
using namespace std;
int n, m, s, t;
struct ty1{
    int t, l, next;
}edge[20010];
struct ty2{
    int x, dis;
    bool operator < (const ty2 &a)const{
        return dis>a.dis;
    }
};
priority_queue<ty2> q;
int head[1010], dis[1010];
bool vis[1010];
int cnt = 100;
void addEdge(int x, int y, int l)
{
    edge[++cnt].l = l;
    edge[cnt].t = y;
    edge[cnt].next = head[x];
    head[x] = cnt;
}
int di(int s, int t)
{
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0;
    ty2 tmp;
    tmp.dis = 0, tmp.x = s;
    q.push(tmp);
    
    while (!q.empty())
    {
        ty2 tmp = q.top();
        q.pop();
//         cout<<tmp.dis<<endl;
        if (vis[tmp.x])
            continue;
        vis[tmp.x] = 1;
        for (int i=head[tmp.x]; i!=-1; i=edge[i].next)
        {
            int y = edge[i].t;
            if (vis[y]) continue;
            if (edge[i].l+dis[tmp.x]<dis[y])
            {
                dis[y] = edge[i].l+dis[tmp.x];
                ty2 tmp2;
                tmp2.x = y, tmp2.dis = dis[y];
                q.push(tmp2);
            }
        }
    }
    if (dis[t]>=0x3f3f3f3f)
        return -1;
    return dis[t];
}
int main()
{
    cin>>n>>m>>s>>t;
    memset(head, -1, sizeof(head));
    
    for (int i=1; i<=m; i++)
    {
        int x, y, l;
        cin>>x>>y>>l;
        addEdge(x, y, l);
        addEdge(y, x, l);
    }
    cout<<di(s, t)<<endl;
    
    
    return 0;
}

Bellman-Ford算法

思想：

1、与迪杰斯特拉算法相似，求一点到所有其他点的最小距离，设该起点为s，dis数组表示s到所有其他点的最小距离，同样的先初始化为最大值，且dis[s] = 0，。

2、枚举每个节点i，再枚举每个中间节点j，一旦中间节点可以使其更新dis值就更新，即

dis[j] + ve[j][i] < dis[i] （即s到j的最小距离+j到i的距离<s到i的最小距离）就更新dis值

3、如何判断所有节点均已算出与s的最短距离，即一旦所有节点的距离都无法更新时，则说明s到其他所有节点的最小距离均已算出，无法再进行更新。

4、优化：用队列，我们每次没必要都将所有点的边都看一遍，用一个队列，里面存放所有要进行迭代的点（作为中间节点），首先是放着初始点s，然后将s能更新的所有的点都放入队列中（不能重复放入节点），这样更新直到队列为空为止

5、如何判断是否为重复入队的节点，用一个vis数组，入队了就将其设为1，出队就设为0，这样就可以避免重复

6、答案s-k的最短距离即为dis[k]

完整答案：

# include <bits/stdc++.h>
using namespace std;
struct ty1{
    int t, l, next;
}edge[20010];
queue<int>q;
int cnt, n, m, s, t;
int head[10010], dis[1010];
bool vis[10100];
void addedge(int x, int y, int l)
{
    edge[++cnt].l = l;
    edge[cnt].t = y;
    edge[cnt].next = head[x];
    head[x] = cnt;
}
int spfa(int s, int t)
{
    memset(vis, 0, sizeof(vis));
    memset(dis, 0x3f, sizeof(dis));
    vis[s] = 1;
    dis[s] = 0;
    q.push(s);
    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        vis[x] = 0;
        for (int i=head[x]; i!=-1; i = edge[i].next)
        {
            int y = edge[i].t;
            if (dis[x] + edge[i].l < dis[y])
            {
                dis[y] = dis[x] + edge[i].l;
                if (!vis[y])
                {
                    q.push(y);
                    vis[y] = 1;
                }
            }
        }
    }
    if (dis[t] >= 0x3f3f3f3f)
        return -1;
    else
        return dis[t];
}
int main()
{
    memset(head, -1, sizeof(head));
    cin>>n>>m>>s>>t;
    for (int i=1; i<=m; i++)
    {
        int x, y, len;
        cin>>x>>y>>len;
        addedge(x, y, len);
        addedge(y, x, len);
    }
    cout<<spfa(s, t);
    
    
    return 0;
}

Floyd算法：

思想：

1、可以求两点间的最短距离，枚举两点，枚举中间节点

2、顺序：先枚举中间节点，再枚举两点

for (int k=1; k<=n; k++)

for (int i=1; i<=n; i++)

for (int j=1; j<=n; j++)

{
    if ((i!=j) && (j!=k) && (i!=k))
    {
        if (f[i][k] + f[k][j] <= f[i][j])
        {
            f[i][j] = f[i][k] + f[k][j]; 
        }
    }
}

NC17509 挖沟（求最小生成树）

题目链接

Prim算法：

思想：

1、从根节点开始，不断加入最小边，且加入的边仍能为树

2、用优先队列（最小堆），用一个vis数组表示该点是否已经加入树中，将所有要更新的节点放入队列。首先标记该根节点加入树，且初始队列里放根节点所有连接的边，每次从队列中取最短的边，取出该边所连接的点，更新最小距离。如果该点未加入树中，将该点所连接的边放入队列中，并标记已经加入树中，继续更新。

3、最后返回该最小距离即可

完整代码：

# include <bits/stdc++.h>
using namespace std;
struct ty1{
    int t, l, next;
}edge[500000*2+10];
struct ty2{
    int x, len;
    bool operator < (const ty2& a)const{
        return len>a.len;
    } 
};
int n, m, cnt;
int head[100000+10], vis[100000+10];
void addEdge(int a, int b, int len)
{
    edge[++cnt].l = len;
    edge[cnt].t = b;
    edge[cnt].next = head[a];
    head[a] = cnt;
}
priority_queue<ty2> q;
int prim()
{
    int ans = 0;
    vis[1] = 1;
    for (int i=head[1]; i!=-1; i=edge[i].next)
    {
        ty2 tmp;
        tmp.len = edge[i].l;
        tmp.x = edge[i].t;
        q.push(tmp);
    }
    while (!q.empty())
    {
        ty2 tmp = q.top();
        q.pop();
        int x = tmp.x;
        if (vis[x]) continue;
        vis[x] = 1;
        ans += tmp.len;
        for (int i = head[x]; i!=-1; i = edge[i].next)
        {
            int x = edge[i].t;
            if (vis[x]) continue;
            ty2 tmp;
            tmp.x = x, tmp.len = edge[i].l;
            q.push(tmp);
        }
    }
    return ans;
}
int main()
{
    cin>>n>>m;
    memset(head, -1, sizeof(head));
    for (int i=1; i<=m; i++)
    {
        int x, y, len;
        cin>>x>>y>>len;
        addEdge(x, y, len);
        addEdge(y, x, len);
    }
    cout<<prim();
    
    
    return 0;
}

4、优化：没必要将该点连接的所有结点均放入队列中，我们直接找最小边放入即可。即用一个dis数组，来记当前点所有边的最小距离，每次比较每次更新即可

完整代码：

# include <bits/stdc++.h>
using namespace std;
struct ty1{
    int t, l, next;
}edge[500000*2+10];
struct ty2{
    int x, len;
    bool operator < (const ty2& a)const{
        return len>a.len;
    } 
};
int n, m, cnt;
int head[100000+10], vis[100000+10];
void addEdge(int a, int b, int len)
{
    edge[++cnt].l = len;
    edge[cnt].t = b;
    edge[cnt].next = head[a];
    head[a] = cnt;
}
priority_queue<ty2> q;
int dis[100000+10];
int prim()
{
    int ans = 0;
    vis[1] = 1;
    memset(dis, 0x7f, sizeof(dis));
    for (int i=head[1]; i!=-1; i=edge[i].next)
    {
        ty2 tmp;
        tmp.len = edge[i].l;
        tmp.x = edge[i].t;
        dis[tmp.x] = tmp.len;
        q.push(tmp);
    }
    while (!q.empty())
    {
        ty2 tmp = q.top();
        q.pop();
        int x = tmp.x;
        if (vis[x]) continue;
        vis[x] = 1;
        ans += tmp.len;
        for (int i = head[x]; i!=-1; i = edge[i].next)
        {
            int x = edge[i].t;
            if (vis[x]) continue;
            if (dis[x]>edge[i].l)
            {
                ty2 tmp;
                dis[x] = edge[i].l;
                tmp.x = x, tmp.len = edge[i].l;
                q.push(tmp);
            }
        }
    }
    return ans;
}
int main()
{
    cin>>n>>m;
    memset(head, -1, sizeof(head));
    for (int i=1; i<=m; i++)
    {
        int x, y, len;
        cin>>x>>y>>len;
        addEdge(x, y, len);
        addEdge(y, x, len);
    }
    cout<<prim();
    
    
    return 0;
}

Kruskal算法

思想：

1、将所有的边从小到大排序，贪心的选取最小边加入树中，并且保证该边加入后不会在树中形成环

2、如何判断是否可以加入树中，利用并查集，每次加入边，先判断其两点的父亲结点是否相同，相同说明加入该边则会形成环，不相同就将两点连边

完整代码：

# include <bits/stdc++.h>
using namespace std;
int n, m;
int fa[100000+10];
struct ty{
    int x, y, z;
}t[500000+10];
bool cmp(ty t1, ty t2)
{
    return t1.z<t2.z;
}
int find(int x)
{
    return x == fa[x]? x: fa[x]=find(fa[x]);
}
int ans;
int main()
{
    cin>>n>>m;
    for (int i=1; i<=n; i++)
        fa[i] = i;
    for (int i=1; i<=m; i++)
    {
        int x, y, z;
        cin>>x>>y>>z;
        t[i].x = x;
        t[i].y = y;
        t[i].z = z;
    }
    sort(t+1, t+1+m, cmp);
    for (int i=1; i<=m; i++)
    {
        int fx = find(t[i].x), fy = find(t[i].y);
        if (fx!=fy)
        {
            ans += t[i].z;
            fa[fx] = fy;
        }
    }
    cout<<ans<<endl;
    
    
    return 0;
}

rootting
关注
专栏目录
[Spark版本更新]--Spark-2.4.0 发布说明
欢迎来到我的博客，一起探索代码里的世界！
11-09 6581
2018-11-02 Apache Spark 官方发布了 2.4.0版本，以下是 Release Notes，供参考：  Sub-task [ SPARK-6236 ] - 支持大于2G的缓存块 [ SPARK-6237 ] - 支持上传块&gt; 2GB作为流 [ SPARK-10884 ] - 支持针对回归和分类相关模型的单实例预测 [ SPARK-11239 ] - 用于ML线性...
LeetCode 815. 公交路线
almost_afei的博客
06-28 149
难度：困难。 标签：广度优先搜索，数组，哈希表。 这个题之前做过，印象深刻，还记得怎么做。 重点是要将公交车作为广搜的节点。使用公交站的话会超时。 正确解法： class Solution { public: int numBusesToDestination(vector<vector<int>>& routes, int source, int target) { if(source == target)return 0; // o
51nod 1443 路径和树 (最短路+最小生成树)
Evildoer_llc的博客
09-12 297
给定一幅无向带权连通图G = (V, E) (这里V是点集，E是边集)。从点u开始的最短路径树是这样一幅图G1 = (V, E1)，其中E1是E的子集，并且在G1中，u到所有其它点的最短路径与他在G中是一样的。 现在给定一幅无向带权连通图G和一个点u。你的任务是找出从u开始的最短路径树，并且这个树中所有边的权值之和要最小。   Input 单组测试数据。 第一行有两个整数n和m(1 ≤...
labuladong的一些刷题记录
Prince_H_23的博客
12-28 594
labuladong 岛屿问题 200. 岛屿数量 思路+解法： DFS O(mn) class Solution { public: int nr, nc; void dfs(vector<vector<char>>& g, int r, int c){ if(!(r >= 0 && r < nr)) return; if(!(c >= 0 && c < nc))
ACM比赛经验、刷题记录及模板库总结（更新中）
lordofadventure的博客
03-08 1915
文章目录前言第一部分 经验分享及感受第二部分 刷题记录一、基础算法&程序语言二、综合题（现场题）三、动态规划四、图论五、字符串算法六、数据结构七、数学八、网络流九、博弈十、随机算法十一、其他第三部分 专项题库第四部分 模板库附录A 题目索引附录B 常用平台参考文献 前言 本文所提及的部分题目代码，可以在https://github.com/volactina/ACM上找到 第一部分 经验分...
九、十月刷题记录3
Artist's Garden
10-16 183
cf600E dsu on tree模板 感觉就是树剖加强版。 // // Created by Artist on 2021/10/16. // #include<bits/stdc++.h> using namespace std; typedef long long ll; #define mkp make_pair #define fi first #define se second #define pb push_back #define all(x) x.begin(),x.en
ZJOI2019一轮停课刷题记录
weixin_30920597的博客
02-27 783
Preface 菜鸡HL终于狗来了他的省选停课，这次的时间很长，暂定停到一试结束，不过有机会二试的话还是可以搞到4月了 这段时间的学习就变得量大而且杂了，一般以刷薄弱的知识点和补一些新的奇怪技巧为主。 偶尔也会打一些比赛找找手感（比如HHHOJ的比赛，Luogu比赛，以及comet OJ上之前的CCPC题） CF和CC看情况，主要是我真的不太喜欢读英文题的恐怖感觉233 希望这段时间的努...
BZOJ刷题记录---提高组难度
mrcrack的博客
06-11 1755
BZOJ刷题记录---提高组难度 总目录详见https://blog.csdn.net/mrcrack/article/details/90228694 序号 题号 算法 思想难度 实现难度 总难度 推荐指数 1 1876 高精求GCD 18 33 51 2 2 2173 找规律 37 14...
洛谷P4768 [NOI2018]归程（克鲁斯卡尔重构树+最短路）
weixin_34228387的博客
09-20 68
传送门 前置技能，克鲁斯卡尔重构树 我们按道路的高度建一个最大生成树，然后建好克鲁斯卡尔重构树 那么我们需要知道一颗子树内到1点距离最近是多少（除此之外到子树内任何一个点都不需要代价） 可以一开始直接跑一个dijkstra（关于SPFA，他死了） 然后一遍树形dp就可以了 1 //minamoto 2 #include<iostream> 3 #i...
BZOJ_5415_[Noi2018]归程_kruscal重构树+倍增+最短路
08-05 80
BZOJ_5415_[Noi2018]归程_kruscal重构树+倍增 Description www.lydsy.com/JudgeOnline/upload/noi2018day1.pdf 好久不写题解了，趁着周末都更一下吧。 处理出以1为起点的最短路dis。 考虑每次只能走海拔大于p的边，用kruscal重构树维护一个以海拔为关键字的最大生成树。 这样我们每次能走的...
A*算法求最短路径 java 源码(拿来即可用）
abcd_d_的专栏
05-07 5491
偶然看到最短路劲问题，在游戏、导航等领域都有所应用，觉着挺有意思的，便打算自己也实现一版 。最后选择了高效简洁的A*算法。 A*确实是一个非常优秀的实现，比起迪杰特斯拉、best-first等算法，这里省去1万字的赞美…… A*算法简绍可以看该文： http://blog.csdn.net/pi9nc/article/details/8779503 A*的实现却并不复杂，关键过程在于判断当
语法工具箱：GLR解析算法的比较研究
理论计算机科学电子笔记110（2004）97-113www.elsevier.com/locate/entcs语法工具箱：GLR解析算法阿德里安...它是翻译器前端生成的生产工具。 在本文中，我们给GTB和它的同伴基于Java的动画工具PAT的概述。我们举例说明
OI做题总结
dingxingdi的博客
07-16 874
数学竞赛蓝书上与OI/ICPC有关内容也可阅读OI考前注意事项见川外团队骗分导论见腾讯微云。
算法基础-链表
August的专栏
11-05 205
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 223
100种算法【Python版】第51篇——希尔排序
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 307
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 276
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1873
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二分查找习题篇(上)
最新发布
zoelinkailuo的博客
11-07 552
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值