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

已于 2022-10-17 20:46:13 修改
阅读量325 收藏
点赞数 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
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACM比赛经验、刷题记录及模板库总结（更新中）
lordofadventure的博客
03-08 1744
文章目录前言第一部分 经验分享及感受第二部分 刷题记录一、基础算法&程序语言二、综合题（现场题）三、动态规划四、图论五、字符串算法六、数据结构七、数学八、网络流九、博弈十、随机算法十一、其他第三部分 专项题库第四部分 模板库附录A 题目索引附录B 常用平台参考文献 前言 本文所提及的部分题目代码，可以在https://github.com/volactina/ACM上找到 第一部分 经验分...
Autium钻孔文件(NC Drill Files)的生成
08-10
1.在Altium designle09中，选择菜单-Fabrication Outputs-NC Drill Files,2.确认一下随后弹出的钻孔数据对话框：3.然后就会自动生成NC Drill Files了4.同样的，生成的文件会在那个子目录里，将含有以上生成的文件的...
LeetCode 815. 公交路线
almost_afei的博客
06-28 119
难度：困难。 标签：广度优先搜索，数组，哈希表。 这个题之前做过，印象深刻，还记得怎么做。 重点是要将公交车作为广搜的节点。使用公交站的话会超时。 正确解法： 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 257
给定一幅无向带权连通图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 562
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))
九、十月刷题记录3
Artist's Garden
10-16 132
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 687
Preface 菜鸡HL终于狗来了他的省选停课，这次的时间很长，暂定停到一试结束，不过有机会二试的话还是可以搞到4月了 这段时间的学习就变得量大而且杂了，一般以刷薄弱的知识点和补一些新的奇怪技巧为主。 偶尔也会打一些比赛找找手感（比如HHHOJ的比赛，Luogu比赛，以及comet OJ上之前的CCPC题） CF和CC看情况，主要是我真的不太喜欢读英文题的恐怖感觉233 希望这段时间的努...
BZOJ刷题记录---提高组难度
mrcrack的博客
06-11 1603
BZOJ刷题记录---提高组难度 总目录详见https://blog.csdn.net/mrcrack/article/details/90228694 序号 题号 算法 思想难度 实现难度 总难度 推荐指数 1 1876 高精求GCD 18 33 51 2 2 2173 找规律 37 14...
洛谷P4768 [NOI2018]归程（克鲁斯卡尔重构树+最短路）
weixin_34202952的博客
09-20 68
传送门 前置技能，克鲁斯卡尔重构树 我们按道路的高度建一个最大生成树，然后建好克鲁斯卡尔重构树 那么我们需要知道一颗子树内到1点距离最近是多少（除此之外到子树内任何一个点都不需要代价） 可以一开始直接跑一个dijkstra（关于SPFA，他死了） 然后一遍树形dp就可以了 1 //minamoto 2 #include<iostream> 3 #i...
BZOJ_5415_[Noi2018]归程_kruscal重构树+倍增+最短路
08-05 67
BZOJ_5415_[Noi2018]归程_kruscal重构树+倍增 Description www.lydsy.com/JudgeOnline/upload/noi2018day1.pdf 好久不写题解了，趁着周末都更一下吧。 处理出以1为起点的最短路dis。 考虑每次只能走海拔大于p的边，用kruscal重构树维护一个以海拔为关键字的最大生成树。 这样我们每次能走的...
nc.zip_mat _matlab_nc文件_nc生成 mat_批量读取mat
09-23
批量读写MAT，可以快速的将NC文件进行读取，并存为.MAT格式的文件，节省时间，提高效率。
nc.rar_Fortran nc_G代码提取_nc文件_数控加工_生成G代码
09-14
读取数控加工生成G代码信息,可以提取任何你所需要的文件信息，里面有操作说明
UAP树形参照代码文件（NC65）
01-11
UAP树形参照 package nc.ui.train.pub.ref; import nc.ui.bd.ref.AbstractRefTreeModel; public class CustClassRefModel extends AbstractRefTreeModel { public CustClassRefModel() { super(); } @...
UAP ,NC65树表型参照
04-23
UAP ,NC65树表型参照
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 415
【代码】力扣LCP 08.剧情触发时间。
排序——希尔排序
2301_80662872的博客
06-16 384
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
代码随想录二刷DAY1~3
最新发布
illuosion7的博客
06-16 472
没做出来，发现问题了，滑动的应当是右指针for()里面填，这样一来，sum的初始化应当放到for的外面。//这句初始化很重要，我们要让反转后的最后一个元素指向nullptr，那么head的pre自然应该初始化为nullptr。题面：在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留。//条件也重要呀，不用判它的next，手写模拟就知道了。这题有难度，要求重复的节点不保留，显然需要三指针了。// 如果是最长，一发现不符合，就扩。//如果是最长，一发现不符合，就扩。
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 319
给定二叉树的根节点 root ，返回所有左叶子之和。
python处理nc数据求平均
11-21
Python可以使用NetCDF4库来处理nc数据，并求取平均值。 首先，我们需要使用NetCDF4库打开.nc文件，并读取其中的数据。可以使用如下代码： ``` import netCDF4 as nc # 打开.nc文件 dataset = nc.Dataset('data.nc...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值