洛谷——【普及】最短路专项训练

最新推荐文章于 2024-06-16 20:54:56 发布
最新推荐文章于 2024-06-16 20:54:56 发布
阅读量260 收藏 1
点赞数 2
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengtaigu111/article/details/137115662
版权

堆优化的dijkstra

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 1e5+10,M=2*N;
int h[N],e[M],ne[M],w[M],idx;
int n,m,s;
int dist[M],st[M];

void add(int a,int b,int c)
{
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}

void dij()
{
    memset(dist,0x3f,sizeof(dist));
    dist[s]=0;

    priority_queue<PII,vector<PII>,greater<PII> > heap;
    heap.push({0,s});

    while(heap.size())//
    {
        auto t=heap.top();
        heap.pop();

        int vec=t.second;
        if(st[vec])continue;//
        st[vec]=1;

        for (int i = h[vec]; i!=-1; i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[vec]+w[i])//
            {
                dist[j]=dist[vec]+w[i];
                heap.push({dist[j],j});
            }
        }
    }

}
int main()
{
    memset(h, -1, sizeof h);
    cin>>n>>m>>s;
    while (m -- ){
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    dij();
    for (int i = 1; i <= n; i ++ )
    {
        cout<<dist[i]<<" ";
    }
    return 0;
}

P1629 邮递员送信 

求从1到其他点的最小距离和其他点到1的最小距离，对于后者我们需要进行反向建图，之后按照模板再改一遍。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N=100010 , M=500010;
typedef long long ll;
typedef pair<int,int> pii;
int dist[N];
int h[N],e[M],ne[M],idx,w[M];
int hr[N];
void add(int h[],int a,int b,int c)
{
	e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
int n,m,s;
bool st[N];
void dijkstra()
{
	memset(dist,0x3f,sizeof dist);
	dist[1]=0;
	priority_queue<pii,vector<pii>,greater<pii> >q;
	q.push({0,1});
	while(q.size())
	{
   
		pii t=q.top();
		q.pop();
		int ver=t.second,dis=t.first;
		if(st[ver])	continue;
		st[ver]=true;
		for(int i=h[ver];~i;i=ne[i])
		{
			int j=e[i];
			if(dist[j]>dist[ver]+w[i]){
   
				dist[j]=dist[ver]+w[i];
				q.push({dist[j],j});
			}
		}
	}
	
	ll res=0;
	for(int i=1;i<=n;i++)
		res+=dist[i];
	
	memset(dist,0x3f,sizeof dist);
	dist[1]=0;
	priority_queue<pii,vector<pii>,greater<pii> >qq;
	qq.push({0,1});
	memset(st,0,sizeof st);
	while(qq.size())
	{
		pii t=qq.top();
		qq.pop();
		int ver=t.second,dis=t.first;
		if(st[ver])	continue;
		st[ver]=true;
		for(int i=hr[ver];~i;i=ne[i])
		{
   
			int j=e[i];
			if(dist[j]>dist[ver]+w[i]){
   
				dist[j]=dist[ver]+w[i];
				qq.push({dist[j],j});
			}
		}
	}
	for(int i=1;i<=n;i++)
		res+=dist[i];
	cout<<res<<endl;
	return;
}

int main()
{
	memset(h,-1,sizeof h);
	memset(hr,-1,sizeof hr);
	cin>>n>>m;
	while(m--)
	{
		int a,b,c;
		cin>>a>>b>>c;
		add(h,a,b,c);
		add(hr,b,a,c);
	}
	
	dijkstra();
}

 

SPFA

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 1e5+10,M=2*N;
int h[N],e[M],ne[M],w[M],idx;
int n,m,s;
int dist[M],st[M];

void add(int a,int b,int c)
{
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}

void spfa()
{

   memset(dist,0x3f,sizeof dist);
   dist[s]=0;
   st[s]=1;

   queue<int> q;
   q.push(s);

   while(q.size())
   {

       auto t=q.front();
       q.pop();
       st[t]=0;

       for (int i = h[t]; i != -1; i = ne[i] )
       {
           int j=e[i];
           if(dist[j]>dist[t]+w[i])
           {
               dist[j]=dist[t]+w[i];
               if(!st[j])
               {
                   q.push(j);
                   st[j]=1;
               }
           }
       }
   }
}
int main()
{
    memset(h, -1, sizeof h);
    cin>>n>>m>>s;
    while (m -- ){
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    spfa();
    for (int i = 1; i <= n; i ++ )
    {
        cout<<dist[i]<<" ";
    }
    return 0;
}

 P1744 采购特价商品

 

模板题，就是注意距离带有小数点。 

#include <bits/stdc++.h>
using namespace std;
#define debug(a) cout<<#a<<"="<<a<<endl;
#define all(a) begin(a), end(a)
#define pb(x) push_back(x)
typedef long long ll;
typedef pair<int,int> PII;
const int N=2000;
int t,n,m,ans,s=1;
int a[N],b[N];
int e[N],ne[N],h[N],idx;
double w[N],d[N];
int sa,en;
bool st[N];
void add(int a,int b,double c)
{
    e[idx]=b;ne[idx]=h[a];w[idx]=c;h[a]=idx++;
}
void spfa()
{
    for(int i=1;i<=n;i++)
    {
        d[i]=10000000;
    }
    queue<int> q;
    d[sa]=0;
    q.push(sa);
    st[sa]=true;
    
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        
        st[t]=false;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[t]+w[i])
            {
                d[j]=d[t]+w[i];
                if(st[j]==false)
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    memset(h,-1,sizeof h);
    
    cin>>n;
	for(int i=1;i<=n;i++)
	{
	    cin>>a[i]>>b[i];
	}
	cin>>m;
	while(m--)
	{
	    int x,y;
	    cin>>x>>y;
	    double dd=sqrt((a[x]-a[y])*(a[x]-a[y])+(b[x]-b[y])*(b[x]-b[y]));
	    add(x,y,dd);add(y,x,dd);
	}
	cin>>sa>>en;
    spfa();
    printf("%.2f",d[en]);
    return 0;
}

 P1807 最长路

 对于求最长路，我们把带权边的权值取反，然后用SPFA来跑，最后把答案取反

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 5e5+10,M=2*N;
int h[N],e[M],ne[M],w[M],idx;
int n,m,s=1;
int dist[M],st[M];
void add(int a,int b,int c)
{
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}
void spfa()
{
   memset(dist,0x3f,sizeof dist);
   dist[s]=0;
   st[s]=1;

   queue<int> q;
   q.push(s);

   while(q.size())
   {
       auto t=q.front();
       q.pop();
       st[t]=0;

       for (int i = h[t]; i != -1; i = ne[i] )
       {
           int j=e[i];
           if(dist[j]>dist[t]+w[i])
           {
               dist[j]=dist[t]+w[i];
               if(!st[j])
               {
                   q.push(j);
                   st[j]=1;
               }
           }
       }
   }
}
int main()
{
    memset(h, -1, sizeof h);
    cin>>n>>m;
    while (m -- ){
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, -c);
    }
    spfa();
//    for (int i = 1; i <= n; i ++ )
//    {
//        cout<<dist[i]<<" ";
//    }
	if(dist[n]==0x3f3f3f3f)
		cout<<"-1";
	else cout<<-dist[n];
    return 0;
}

Floyd

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int M = 210,INF=1e9;
int g[M][M],dp[M][M];
int n,m,k;

void floyd(){
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ ){
                g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
            }
}

int main()
{
    cin>>n>>m>>k;

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) g[i][j] = 0;
            else g[i][j] = INF;

    while (m -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
    }

    floyd();

    while(k--){
        int x,y;
        cin>>x>>y;
        int t=g[x][y];
        if (t > INF / 2) puts("impossible");
        else printf("%d\n", t);
    }
    return 0;
}

       

P2910 [USACO08OPEN] Clear And Present Danger S

 很明显的多源最短路

#include <bits/stdc++.h>
using namespace std;
#define debug(a) cout<<#a<<"="<<a<<endl;
#define all(a) begin(a), end(a)
#define pb(x) push_back(x)
typedef long long ll;
typedef pair<int,int> PII;
const int N=1e5+10,M=2*N;
int t,n,m,ans=0,s=1;
int a[N],dist[110][110];
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin>>n>>m;
		
    for(int i=1;i<=m;i++)cin>>a[i];
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			cin>>dist[i][j];
			
	for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

	
	for(int i=1;i<m;i++)
	{
		int x=a[i],y=a[i+1];
		ans+=dist[x][y];
	}
	cout<<ans;
    return 0;
}

P3905 道路重建

#include <bits/stdc++.h>
using namespace std;
#define debug(a) cout<<#a<<"="<<a<<endl;
#define all(a) begin(a), end(a)
#define pb(x) push_back(x)
typedef long long ll;
typedef pair<int,int> PII;
const int N=1e5+10,M=2*N;
int t,n,m,ans=0,s=1;
int h[110][110],d[110][110];
void fd() {
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                h[i][j] = min(h[i][j], h[i][k] + h[k][j]);
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    	for(int j=1;j<=n;j++)
    	{
    		if(i==j)h[i][j]=0;
    		else h[i][j]=0x3f3f3f3f;
		}
		
    for(int i=1;i<=m;i++)
	{
		int x,y;cin>>x>>y;
		cin>>d[x][y];
		d[y][x]=d[x][y];
		h[x][y]=h[y][x]=0;
	}
	int k;
	cin>>k;
	for(int i=1;i<=k;i++)
	{
		int s,e;
		cin >> s >> e;
		h[s][e]=h[e][s]=d[s][e];
	}
	
	fd();
	
	int x,y;
	cin>>x>>y;
	cout<<h[x][y];

    return 0;
}

 P2888 [USACO07NOV] Cow Hurdles S

//对于Floyd进行了一点小小的优化
#include<bits/stdc++.h>
using namespace std;
int n,m,t,dis[1000][1000],a,b,c,x,y;
int main(){
	cin>>n>>m>>t;
	memset(dis,0x3f,sizeof(dis));
	for(int i=1;i<=m;i++){
		cin>>a>>b>>c;
		dis[a][b]=c;
	}
	for(int k=1;k<=n;k++){	
		for(int i=1;i<=n;i++){
		    
			for(int j=1;j<=n;j++){
				int s=max(dis[i][k],dis[k][j]);
				if(s!=0x3f3f3f3f&&s<dis[i][j]){	 
					dis[i][j]=s;
				}
			}
		}
	}
	for(int i=1;i<=t;i++){
		cin>>x>>y;
		if(dis[x][y]==0x3f3f3f3f){
			cout<<-1<<endl;
			continue;
		}
		cout<<dis[x][y]<<endl;
	}
	return 0;
}

 

mengtaigu111
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
洛谷题单【图论2-2】最短路
Tracy_yi的博客
09-25 210
洛谷题单【图论2-2】最短路
dijkstra堆优化 详解（洛谷模板题）
spencer12138的博客
11-09 986
一、算法概况  dijkstra是一种稳定的求单源最短路的算法，时间复杂度O((m+n)logn)  ,m表示边数，n表示点数。 二、算法过程 1.将源点以及和他相连的点加入堆 2.选出堆顶元素A（代价最小的元素），将他从堆中删除，然后调整堆 3. 处理与u相邻的，未被访问过的，满足三角不等式的顶点     1):若该点在堆里，更新距离，并调整该元素在堆中的位置。     2):
洛谷 P5651 基础最短路练习题
2301_78981471的博客
12-10 936
定义一条简单路径的权值为路径上所有边边权的异或和。本题就是让我们求两点之间异或值最小的那一条路。中不存在简单环使得边权异或和不为。保证没有重边和自环。保证没有重边和自环。行，一行一个整数表示答案。条边的简单无向连通图。行，一行三个非负整数。异或(xor)的性质。
洛谷 P1144 最短路计数（bfs模板题，稍加修改）
bunny_1024的博客
11-14 1138
题目链接： 最短路计数 - 洛谷https://www.luogu.com.cn/problem/P1144 思路： 基本上是一个模板题，只不过要输出的不是最短路距离，而是最短路数量，所以需要一个cnt数组，如果当前是更短的最短路，cnt重新计数，等于到上个点的cnt值，如果当前是和之前长度相等的最短路，cnt和之前累加。注意答案取模。 当时做这道题没有什么感觉，套完模板稀里糊涂的就ac了，写完之后总结了一下感觉收获不少。最短路问题中，dist数组和vis数组是必不可少的，dist数组用来记录最短.
最短路算法——Floyd-Warshall
指北针_N的博客
04-15 5846
在更多的应用场景中，需要用不同的算法来解决。下表总结了一些经典算法，除了贪心最优搜索之外，其他都是最优性算法，即得到的解是最短路径。表中的 m 是边的数量，n 是点的数量。 一、BFS BFS 也是一种很不错的最短路算法。但 BFS 只适合一种场景：任意的相邻两点之间距离相等，一般把这个距离看成 1，称为“1跳”，从起点到终点的路径长度就是多少个“跳数”。在这种场景下，查找一个起点到一个终点的最有短距离，BFS 是最优的最短路径算法，计算复杂度是 O(n)，n 是图上点的...
【图论-最短路】洛谷官方题单刷题总结
qq_43627100的博客
03-20 1920
图论 图在线生成器 图论题目，数据量是选择算法的重要依据。 一、图的存储 不同问题使用的存储方式不同，比如区分有向图和无向图，顶点数是否多，图是否稠密等。 邻接矩阵 二维数组保存图 ，行数i与列数j是否有通路、权值大小。 int graph[NUM][NUM]; //初始化 //有向图 //无向图 适用于顶点数较少，稠密图 邻接表 1.数组模拟 #include<bits/stdc++.h> using namespace std; #define NUM 10010 int next_[NU
最短路问题——（最短路径）
博客
03-19 7743
一、只有五行的算法——Floyd-Warshall 下图中有4个城市8条公路，公路上的数字表示这条公路的长短。注意公路是单向的。我们需要求出任意两个城市之间的最短路程，即任意两点之间的最短路径。 首先，我们建立一个数据结构来存储图的信息，使用一个4*4的矩阵（二维数组e）来存储。例如1号城市到2号城市的路程为2，则使e[1][2]的值为2。2号城市无法到达4号城市，则设置e[2][4...
图论 ——五种最短路算法
qq_46056407的博客
03-29 8834
文章目录 前言 一、最短路是什么？ 二、朴素Dijkstra算法 三、堆优化版Dijkstra算法 四、Bellman-Ford算法 五、Spfa算法 六、Floyd算法 总结 前言 本篇文章讲的是图论里的最短路问题，如果你还没有图论的基础知识，可以看看我之前的文章： DFS（深度优先算法）BFS(广度优先算法）邻接表和邻接矩阵、树的遍历 （DFS和BFS） 这些都是关于图论的基本知识。 一、最短路是什么？ 最短路径： 从某个点A（位置）到另一个点B(位置)的最..
数学建模学习笔记（七）——图论最短路问题
striveAgain丶的博客
08-08 1949
文章目录一、综述二、图论最短路问题三、几个简单的作图方法四、Dijkstra（迪杰斯特拉）算法五、Bellman-Ford算法六、总结 一、综述 本文主要根据图论的基本概念，介绍图论中常见的建模问题——最短路问题。同时，介绍了解决图论最短路问题的两种算法：Dijkstra（迪杰斯特拉）算法和Bellman-Ford（贝尔曼-福特）算法。 在此之前，需要具备基本的图论知识哦~~~ 二、图论最短路问题 图论最短路问题指的是在带权重的图中，求出一条从一点节点到另一个节点的路径，使这条路径上的权重之和最小。 三、几
洛谷P1354 房间最短路问题——floyd
zhaohaibo的博客
05-12 2041
题目描述 在一个长宽均为10，入口出口分别为（0，5）、（10，5）的房间里，有几堵墙，每堵墙上有两个缺口，求入口到出口的最短路经。 输入输出格式 输入格式： 第一排为n(n&lt;=20)，墙的数目。 接下来n排，每排5个实数x，a1，b1，a2，b2。 x表示墙的横坐标（所有墙都是竖直的），a1-b1和a2-b2之间为空缺。 a1、b1、a2、b2保持递增，x1-xn也...
用matlab实现寻找最短路.docx
11-15
"用matlab实现寻找最短路" 本文档介绍了如何使用matlab来实现寻找最短路问题的解决方案。最短路问题是图论理论中的经典问题，它在many real-world applications中都有重要的应用价值。 图论是应用数学的一个分支，...
matlab最短路.txt
08-11
matlab最短路.txt
最短路问题及其应用.pdf
03-30
最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf
TSP TS_最短路
09-25
求解旅行商问题 用了图神经网路 优化路径
基于MATLAB的 Floyd最短路算法.zip
04-20
基于MATLAB的 Floyd最短路算法.zip
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 419
【代码】力扣LCP 08.剧情触发时间。
排序——希尔排序
2301_80662872的博客
06-16 414
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
代码随想录二刷DAY1~3
最新发布
illuosion7的博客
06-16 477
没做出来，发现问题了，滑动的应当是右指针for()里面填，这样一来，sum的初始化应当放到for的外面。//这句初始化很重要，我们要让反转后的最后一个元素指向nullptr，那么head的pre自然应该初始化为nullptr。题面：在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留。//条件也重要呀，不用判它的next，手写模拟就知道了。这题有难度，要求重复的节点不保留，显然需要三指针了。// 如果是最长，一发现不符合，就扩。//如果是最长，一发现不符合，就扩。
POJ 2253 ——Frogger——————【最短路、Dijkstra、最长边最小化】
05-29
好的，这是一道经典的最短路问题，题目大意是有一只青蛙要从起点跳到终点，有一些石头可以跳，每个石头有一个固定的位置和耗费，青蛙可以在石头之间跳跃，但是跳跃的距离不能超过石头的耗费，求青蛙从起点到终点的最短距离。 这道题可以使用Dijkstra算法来解决，我们可以将石头看作图中的点，石头之间的跳跃看作图中的边，每个石头的位置和耗费可以看作点的权值。 具体来说，我们可以先将起点加入到一个优先队列中，起点的距离为0。然后我们每次从优先队列中取出距离起点最近的点进行松弛操作，即对于每个相邻的石头，如果从当前点到该石头的距离小于该石头的当前最短距离，则更新该石头的最短距离并将其加入到优先队列中。最后，当我们取出终点时，其最短距离即为答案。 需要注意的是，这道题中跳跃的距离不能超过石头的耗费，因此我们可以将跳跃的距离看作边的权值，求最短路时，可以将边权取相反数，这样Dijkstra算法求出的最短路即为跳跃的耗费之和。 代码实现如下：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值