kuangbin专题-最短路练习

已于 2022-02-25 21:43:26 修改
阅读量349 收藏 2
点赞数 2
分类专栏： 笔记 文章标签： dijkstra
于 2021-04-05 14:31:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/small_whl/article/details/115441972
版权

kuangbin专题题目一
本文是kuangbin专题的最短路练习题解，题解可能写的不是很清晰，不过不重要，代码还是很容易理解的。
做题顺序
Dijkstra 1 7 4 10 3 2 16
spfa 14 12 13 5 15 18
floyd 8 6 9
附上题目链接
kuangbin专题链接
1 Til the Cows Come Home

#include<iostream>
#include<map>
#include<queue>
#include<algorithm>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 5005;
struct node
{
    int v,next,w;
}edge[maxn];
int cnt;
bool vis[maxn];
int dis[maxn],head[maxn];
int done[maxn];
int pre[maxn];
struct s_node{
	int x,x_dis;
	s_node(int b,int c){x=b;x_dis=c;}
	bool operator<(const s_node &a) const
	{return x_dis > a.x_dis;}
};
void add(int u,int v,int w)//起点，终点，距离,链式前向星建图
{
    edge[cnt].w=w;
    edge[cnt].v=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void dijkstra(int n)
{
    int s=1;
	priority_queue<s_node>Q;
    memset(dis,inf,sizeof dis);
    memset(done,0,sizeof done);
	Q.push(s_node(s,dis[s]));
	dis[s]=0;
	while(!Q.empty())
	{
		s_node u = Q.top();
		Q.pop();
		if(done[u.x]) continue;//丢弃已经找到最短路径的结点
		done[u.x]=true;
		for(int i=head[u.x];~i;i=edge[i].next)
		{
			int v=edge[i].v;
            if(dis[v]>dis[u.x]+edge[i].w)//松弛操作
            {
                dis[v]=dis[u.x]+edge[i].w;
                Q.push(s_node(v,dis[v]));//把新遍历的点加到堆中
                pre[v]=u.x;
            }
    	}
    }
    cout<<dis[n]<<endl;
    //print_pre(s,n);
}
int main()
{
    int n,m,u,v,w;
    cin>>m>>n;
    memset(head,-1,sizeof(head));
    for(int i = 0;i<m;i++)
    {
        cin>>u>>v>>w;
        add(u,v,w);
        add(v,u,w);
    }
    dijkstra(n);
    //for(int i=1;i<=n;i++) cout<<dis[i]<<endl;
    return 0;
}
/*
    测试数据
    6 9
	1 2 1
	1 3 12
	2 3 9
	2 4 3
	3 5 5
	4 3 4
	4 5 13
	4 6 15
	5 6 4*/

7 MPI Maelstrom

#include<iostream>
#include<cstring>
#include<map>
#include<queue>
#define MAX 105
using namespace std;
int inf=1<<30;
int N,T,S,D;
int mp[MAX][MAX];
int dis[MAX];
int vis[MAX];
int turn(string s)
{
    int f=0;
    for(int i=0;i<s.size();i++)
    {
        int t=s[i]-'0';
        f=f*10+t;
    }
    return f;
}
void input()
{
    cin>>N;S=1;D=N;
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
            if(i==j)
                mp[i][j]=0;
            else
                mp[i][j]=inf;
        }
    }


    for(int i=2;i<=N;i++)
    {
        for(int j=1;j<i;j++)
        {
            string str;cin>>str;int c;
            if(str=="x")
            {
                continue;
            }
            else
            {
                c=turn(str);
                if(mp[i][j]!=0&&mp[i][j]!=inf)
                {
                    mp[i][j]=min(mp[i][j],c);
                    mp[j][i]=mp[i][j];
                }
                else
                {
                    mp[i][j]=c;
                    mp[j][i]=c;
                }
            }
        }
    }


    for(int i=1;i<=N;i++)
    {
        dis[i]=inf;
        vis[i]=0;
    }
    vis[S]=1;
    dis[S]=0;
}
void Dijkstra()
{
    for(int i=1;i<=N;i++)
    {
        int min_dis=inf;
        int min_sign=S;
        for(int j=1;j<=N;j++)
        {
            if(dis[j]<min_dis&&!vis[j])
            {
                min_sign=j;
                min_dis=dis[j];
            }
        }
        vis[min_sign]=1;
        for(int j=1;j<=N;j++)
        {
            if(!vis[j])
            {
                if(dis[j]>mp[j][min_sign]+dis[min_sign])
                {
                    dis[j]=mp[j][min_sign]+dis[min_sign];
                }
            }
        }
    }
}
int main()
{
    input();
    Dijkstra();
    int min_ans=-1;
    for(int i=2;i<=N;i++)
        min_ans=max(min_ans,dis[i]);
    cout<<min_ans<<endl;
}

/*
5 8
2 1 50
3 1 30
3 2 5
4 1 100
4 2 20
4 3 50
5 1 10
5 4 10
*/

4 Silver Cow Party

#include<iostream>
#include<cstring>
#include<queue>
#include<map>
#define MAX 1005
using namespace std;
int inf = 1<<30;
int mp[MAX][MAX];
int N,X,M;
int vis[MAX];
int dis1[MAX];
int dis2[MAX];
void judge()
{
    cin>>N>>M>>X;
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
                mp[i][j]=inf;
                mp[j][i]=inf;
        }
        dis1[i]=inf;
        dis2[i]=inf;
        vis[i]=0;
    }
}
void input()
{
    for(int i=0;i<M;i++)
    {
        int a,b,c;cin>>a>>b>>c;
        if(mp[a][b]!=0&&mp[a][b]!=inf)
        {
            mp[a][b]=min(mp[a][b],c);
        }
        else
            mp[a][b]=c;
    }
}
void Dijkstra()
{
    int min_sign=X;
    int min_dis=inf;
    vis[X]=1;
    dis1[X]=0;
    for(int i=1;i<=N;i++)
    {
        min_sign=X;
        min_dis=inf;
        for(int j=1;j<=N;j++)
        {
            if(!vis[j]&&dis1[j]<min_dis)
            {
                min_sign=j;
                min_dis=dis1[j];
            }
        }
        vis[min_sign]=1;
        for(int j=1;j<=N;j++)
        {
            if(!vis[j])
            {
                if(dis1[j]>dis1[min_sign]+mp[min_sign][j])
                {
                    dis1[j]=dis1[min_sign]+mp[min_sign][j];
                }
            }
        }
    }
    memset(vis,0,sizeof vis);
    vis[X]=1;
    dis2[X]=0;
    for(int i=1;i<=N;i++)
    {
        min_sign=X;
        min_dis=inf;
        for(int j=1;j<=N;j++)
        {
            if(!vis[j]&&dis2[j]<min_dis)
            {
                min_sign=j;
                min_dis=dis2[j];
            }
        }
        vis[min_sign]=1;
        for(int j=1;j<=N;j++)
        {
            if(!vis[j])
            {
                if(dis2[j]>dis2[min_sign]+mp[j][min_sign])
                {
                    dis2[j]=dis2[min_sign]+mp[j][min_sign];
                }
            }
        }
    }
}
int main()
{
    judge();
    input();
    Dijkstra();
    int mans=-1;

    /*
    for(int i=1;i<=N;i++)
        cout<<dis1[i]<<" ";
    cout<<endl;

    for(int i=1;i<=N;i++)
        cout<<dis2[i]<<" ";
    cout<<endl;
*/

    for(int i=1;i<=N;i++)
    {
        mans=max(mans,dis1[i]+dis2[i]);
    }
    cout<<mans<<endl;
}

10 Invitation Cards

#include<iostream>
#include<queue>
#include<map>
#include<cstring>
#include<cstdio>
#include<vector>
using namespace std;
const long long inf=0x3f3f3f3f3f3f3f3f;
const int MAX=1000000+10;
int N,M,T;
struct Edge{
    int v;
    int w;
    int next;
}fp[MAX];
int cnt;
int head[MAX];
long long dis[MAX];
int temp[MAX][3];
int vis[MAX];
inline int read()
{
	char ch = getchar();
	int x = 0, f = 1;
	while(ch < '0' || ch > '9'){
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while('0' <= ch && ch <= '9'){
		x = x * 10 + ch - '0';
		ch = getchar();
	}
	return x * f;
}

inline void write(int x){
	if (x < 0) x = ~x + 1, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
void add(int a,int b,int c)
{
    fp[cnt].v=b;
    fp[cnt].w=c;
    fp[cnt].next=head[a];
    head[a]=cnt++;
}
void op1()
{
    cnt=0;
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
    for(int i=1;i<=N;i++)
    {
        dis[i]=inf;
        vis[i]=0;
        head[i]=-1;
    }
}
struct cmp{
    bool operator() (const int a,const int b)
    {
        return dis[a]>dis[b];
    }

};
long long Dijkstra()
{
    priority_queue<int,vector<int>,cmp>q;
    q.push(1);
    dis[1]=0;
    while(!q.empty())
    {
        int r=q.top();
        q.pop();
        //if(vis[r]) continue;
        vis[r]=1;
        for(int i=head[r];~i;i=fp[i].next)
        {
            int v=fp[i].v;
            int w=fp[i].w;
            if(!vis[v]&&dis[v]>dis[r]+w)
            {
                dis[v]=dis[r]+w;
                q.push(v);
            }
        }
    }
    long long ans=0;
    for(int i=1;i<=N;i++)
        ans+=dis[i];
    return ans;
}
int main()
{
    T=read();
    while(T--)
    {
        //cin>>N>>M;
        N=read();
        M=read();
        long long ans=0;
        op1();
        for(int i=0;i<M;i++)
        {
            //scanf("%d%d%d",&temp[i][0],&temp[i][1],&temp[i][2]);
            //cin>>temp[i][0]>>temp[i][1]>>temp[i][2];
            temp[i][0]=read();
            temp[i][1]=read();
            temp[i][2]=read();
            add(temp[i][0],temp[i][1],temp[i][2]);
        }
        ans+=Dijkstra();
        op1();
        for(int i=0;i<M;i++)
        {
            add(temp[i][1],temp[i][0],temp[i][2]);
        }
        ans+=Dijkstra();
        //write(ans);
        cout<<ans<<endl;
    }
    return 0;
}

8 Cow Contest

#include<iostream>
#include<map>
#include<queue>
#include<algorithm>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 205;
int mp[maxn][maxn];
int n,m;
void floyd()
{
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(mp[i][k]&&mp[k][j]) mp[i][j]=1;
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++){
            int c=0;
        for(int j=1;j<=n;j++){
            if(mp[i][j]||mp[j][i]) c++;
        }
    if(c==n-1) ans++;
    }
    cout<<ans<<endl;
}
int main()
{
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int u,v;cin>>u>>v;
        mp[u][v]=1;
    }
    floyd();
}
/*
    测试数据
    6 9
	1 2 1
	1 3 12
	2 3 9
	2 4 3
	3 5 5
	4 3 4
	4 5 13
	4 6 15
	5 6 4*/

6 Wormholes

#include<iostream>
#include<map>
#include<queue>
#include<algorithm>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 505;
int mp[maxn][maxn];
int n,m,w;
void floyd()
{
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(mp[i][j]>mp[i][k]+mp[k][j]) mp[i][j]=mp[i][k]+mp[k][j];
            }
            if(mp[i][i]<0){
                cout<<"YES"<<endl;
                return ;
            }
        }
    }
    cout<<"NO"<<endl;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int F;cin>>F;
    while(F--){
        cin>>n>>m>>w;
        memset(mp,inf,sizeof mp);
        for(int i=1;i<=n;i++)
            mp[i][i]=0;
        for(int i=0;i<m;i++){
            int u,v,p;cin>>u>>v>>p;
            if(p<mp[u][v])
            mp[u][v]=mp[v][u]=p;
        }
        for(int i=0;i<w;i++){
            int u,v,p;cin>>u>>v>>p;
            mp[u][v]=-p;
        }
        floyd();
    }
}
/*
    ВтЪдЪ§Он
    6 9
	1 2 1
	1 3 12
	2 3 9
	2 4 3
	3 5 5
	4 3 4
	4 5 13
	4 6 15
	5 6 4*/
WlH__
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（kuangbin）邝斌的ACM模板
12-25
邝斌的ACM模板，
kuangbin专题
逐梦者
09-25 6082
https://vjudge.net/article/371 专题一简单搜索 专题四 最短路练习 专题五 并查集 专题六 最小生成树 专题十六 KMP & 扩展KMP & Manacher 专题十七 AC自动机 ...
KuangBin刷题专题一----简单搜索
锵锵锵锵蒋的博客
11-06 353
文章目录1、棋盘问题 【POJ - 1321 】2、Dungeon Master【POJ2251】 1、棋盘问题 【POJ - 1321 】 题意 代码 //#include<bits/stdc++.h> #include<iostream> #include<cstdio> #include<cstring> using namespace st...
kuangbin带你飞专题合集
繁凡さん的博客
05-28 2137
[kuangbin带你飞]专题一 简单搜索 [kuangbin带你飞]专题二 搜索进阶...
kuangbin专题 搜索
wyxxzsy的博客
07-18 945
E 醉了，说有100位的十进制数，我想那会炸的啊，没想到啊，所有的答案都在long long范围内，那时候应该打个表看看 F bfs 水题 G 模拟题 怎么就搜索了？？没做 H bfs + 记录路径 怎么记录路径？记录每个点的前驱，像并查集那样向上跳，就是所求的路径。 但这里有一个问题，它要准确打印操作是什么 （我猜）就两个解决方法 1：记录下来  就结构体里多加点东西咯 ...
kuangbin模板(2014-5)
08-08
kuangbin模板(2014年5月更新的），雷锋不要积分~~~~凑齐50字~~~~~~~~~~~~~~~~~~
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
kuangbin的ACM模板动态规划计算几何：线与线求交，线与面求交，求凸包，半平面求交等若干图论问题：最小生成树 最短路 强连通分量、桥和割点 等
[kuangbin带你飞]专题四 最短路练习
fisty
01-28 1525
A - Til the Cows Come Home 最短路模板，从终点到起点，双向建边 /*********************************************** * Author: fisty * Created Time: 2015/1/28 20:55:21 * File Name : 4_A.cpp *************************
Kuangbin最短路专题
qq_62338494的博客
04-21 483
菜鸡第一篇博客 整理一下kuangbin的最短路专题（主要是ide出问题了没事干 目录 一、POJ 2387 Till the Cows HomeSPFA板子 二、POJ 2253 FroggerDij最大边最短路 三.POJ 1797 Heavy TranspotationDij最小边最长路 四、POJ 3268 Sliver Cow Party反向建图 五、POJ 1860 Currency ExchangeSPFA判正环 六、POJ 3259 Wormhole...
kuangbin 最短路集合
千摆渡
12-11 98
Til the Cows Come Home poj-2387 #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<cmath> #include<cstdlib> #include<queue&...
kuangbin专题-简单搜索
small_whl的博客
04-03 1350
kuangbin专题题目一 11 迷宫问题 #include<iostream> #define MAX 105 using namespace std; struct node{ int x; int y; int pre; }fp[MAX]; int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}}; int g[MAX][MAX]; int a[MAX][MAX]; int m=0; int pos=0; void bfs() {
kuangbin最短路专题
HigcMadoka的博客
05-29 204
青蛙POJ2253 传送门 在二维平面上有 n个石头。 第一个石头上有一个青蛙，第二个石头上也有一个青蛙。 第一个石头上的青蛙要到第二个石头上找另一个青蛙玩耍。 它可以直接跳到第二个石头上，也可以经过一系列中间石头，然后再跳到第二个石头上。 这只青蛙希望，它的跳跃过程中，单次跳跃的最长距离尽可能短。 请你计算并输出这个最长距离的最小可能值。 输入格式 输入包含多组测试数据。 每组数据第一行包含一个整数 n。 接下来 n行，第 i 行包含两个整数 xi,yi，表示第 i个石头的位置坐标。 每组数据输入完毕后，
kuangbin专题一 简单搜索
weixin_45539557的博客
03-06 409
基础确实不扎实…拿了3天的时间写了一下kuangbin的第一个专题，在此自己总结一下，讲几道记忆深刻的题，首先记住，搜索问题中对于状态的抽离与遍历非常重要！ 1.POJ 2251 Dungeon Master 与一般bfs的区别不大，就一个3维地图，6个方向， #include<iostream> #include<cstdio> #include<queue>...
基础搜索（kuangbin专题）
qq_51537972的博客
10-12 619
目录棋盘问题 （POJ-1321）Dungeon Master （POJ-2251）Catch That Cow (POJ-3278)Fliptile （POJ-3279） 棋盘问题 （POJ-1321） 题目链接：传送门 题意：给定一个n*n的不规则棋盘，要求放入k个棋子，其中“#”能放棋子，“.”空白不能放棋子，且对于已经放了的棋子不能再放入同一行、同一列，求出有多少种放棋子的方案 其实不难，就是一个深度遍历加上回溯 #ifndef _GLIBCXX_NO_ASSERT #include <cas
kuangbin专题 专题1 简单搜索
最新发布
YeYuShengFan_的博客
06-12 178
kuangbin专题

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值