与SPFA的那些事【二】：进阶题目

最新推荐文章于 2024-03-27 19:28:00 发布
原创 最新推荐文章于 2024-03-27 19:28:00 发布 · 240 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了SPFA算法在复杂场景下的应用，包括结合二分查找、Floyd算法及图论技巧解决路径寻优问题，通过代码示例详细解析算法实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

下面给出的主要是灵活运用SPFA的例子，与其他算法相结合，可能会有或多或少的难度。

进阶题目1：Lg P1462 通往奥格瑞玛的道路SPFA+二分答案【提高】

#include <bits/stdc++.h>
#define inf 1000000001
using namespace std;
const int maxn=10001;
const int maxm=100001;

struct EDGE
{
	long long u,v,w,nxt;
}edge[maxm];
long long size=0,n,m,b,l,r,ans;
long long dis[maxn],tot[maxn],head[maxn],f[maxn],used[maxn];
void add(long long u,long long v,long long w)
{
	edge[size].u=u;
	edge[size].v=v;
	edge[size].w=w;
	edge[size].nxt=head[u];
	head[u]=size++;
}


inline long long read()
{
    int x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}

void spfa(long long mid)
{
	deque<int>q;
	for(int i=1;i<=maxn-1;i++)dis[i]=inf,used[i]=0,tot[i]=0;
	q.push_back(1);
	dis[1]=0,used[1]=1,tot[1]=1;
	while(!q.empty())
	{
		int u=q.front();q.pop_front();
		used[u]=0;
		for(long long i=head[u];~i;i=edge[i].nxt)
		{

			long long v=edge[i].v,w=edge[i].w;
			if(f[v]<=mid && dis[v]>dis[u]+w)
			{
				dis[v]=dis[u]+w;
				if(!used[v])
				{
					used[v]=1;
					if(!q.empty())
					{
						if(dis[v]<dis[q.front()])q.push_front(v);
						else q.push_back(v);
					}
					else q.push_back(v);
				}
			}
		}
	}
}

bool judge(long long mid)
{
	spfa(mid);
    if(dis[n]>b) return false;
    return true;
}

void init()
{
	freopen("Lg P1462.in","r",stdin);
}

void readdata()
{
	memset(head,-1,sizeof(head));
	n=read(),m=read(),b=read();
	l=-1000000000,r=1000000000;
    for(int i=1;i<=n;i++) f[i]=read();
	for(int i=1;i<=m;i++)
	{
		int u=read(),v=read(),w=read();
		add(u,v,w);
		add(v,u,w);
	}
}

void work()
{
	spfa(r);
	if(dis[n]==inf || dis[n]>b)	printf("AFK"),exit(0);
	while(l<=r)
	{
		long long mid=(l+r)>>1;
		if(judge(mid))
		{
			r=mid-1;
		}
		else
		{
			l=mid+1;
		}
	}
	printf("%lld",l);
}
int main()
{
	init();
	readdata();
	work();
	return 0;
}

进阶题目2：MZOJ1385: 小奇回地球：floyd+SPFA+二分答案【提高+】

大致思路：

1.二分答案Δdelta，并且每次判断
2.用一次floyd求出两点之间是否连通
3.SPFA+双端队列+判定负环
4.一个大优化：用抽屉原理：具体见代码
用时：84MS

#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define inf 1e9
using namespace std;
const int maxn=200;
const int maxm=maxn*maxn;
int t,n,m,l,r,ans;
struct EDGE
{
	int u,v,w,nxt;
}edge[maxm];
int size=0;
int head[maxn],vis[maxn][maxn],dis[maxn],used[maxn],tot[maxn];

void add(int u,int v,int w)
{
	edge[size].u=u;
	edge[size].v=v;
	edge[size].w=w;
	edge[size].nxt=head[u];
	head[u]=size++;
}
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}

inline void floyd()
{
    for(int i=1;i<=n;i++)vis[i][i]=1;
    for(int k=1;k<=n;k++)
      for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        vis[i][j]=vis[i][j]|(vis[i][k]&vis[k][j]);
         
}

void init()
{
	freopen("MZOJ1385.in","r",stdin);
}

inline void initdata()
{
    size=0;
    for(int i=1;i<=maxn-1;i++)
    head[i]=-1,used[i]=0,tot[i]=0;
    memset(edge,sizeof(edge),0);
    memset(vis,sizeof(vis),0);
}

inline bool spfa(int mid)
{
    deque<int>q;
    for(int i=1;i<=maxn-1;i++)
    dis[i]=inf,used[i]=0,tot[i]=0;
    dis[1]=0;
    tot[1]=1;
    q.push_back(1);
    used[1]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop_front();
        used[u]=0;
        for(int i=head[u];~i;i=edge[i].nxt)
        {
            int v=edge[i].v,w=edge[i].w+mid;
            if(dis[v]>dis[u]+w && vis[v][n])
            {
                dis[v]=dis[u]+w;
                tot[v]++;
                if(tot[v]>n){return false;}
                if(!used[v])
                {
					if(!q.empty())
					{
						if(dis[v]<dis[q.front()])q.push_front(v);
						else q.push_back(v); 
					}
					else q.push_back(v); 
					used[v]=1;
                }
            }
        }
    }
    return true;
}

bool judge(int mid)
{
	if(!spfa(mid))return false;
	if(dis[n]<0)return false;
	if(dis[n]==inf)return false;
	return true;
}

void readdata()
{
	t=read();
    while(t--)
    {
        n=read(),m=read();
        initdata();
        for(int i=1;i<=m;i++)
        {
            int u=read(),v=read(),w=read();
            add(u,v,w);
            vis[u][v]=1;
        }
        floyd();
        if(!vis[1][n])
        {
            printf("-1\n");
            continue;
        }
        l=-1000000,r=1000000;
        ans=-1;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            if(judge(mid))
			{
				r=mid-1,ans=dis[n];
			}
            else l=mid+1;
        }
        printf("%d\n",ans);
    }
}

int main()
{
	init();
	readdata();
	return 0;
}

进阶题目3：P3275 [SCOI2011]糖果：SPFA+建图【提高+】

大致思路：

建图方式很特别
在这里插入图片描述
在这里插入图片描述
via. 浅色调 

#include <bits/stdc++.h>
#define inf 1e15+7
using namespace std;
const int maxm=1000000;
const int maxn=100005;
struct EDGE
{
	int u,v,w,nxt;
}edge[maxm];
int n,k,size=0;
int head[maxn];
long long dis[maxn],used[maxn],tot[maxn];
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}
void add(int u,int v,int w)
{
	edge[size].u=u;
	edge[size].v=v;
	edge[size].w=w;
	edge[size].nxt=head[u];
	head[u]=size++;
}

void spfa()
{
	deque<int>q;
	q.push_back(0);
	dis[0]=0,used[0]=1;
	while(!q.empty())
	{
		int u=q.front();q.pop_front();
		used[u]=0;
		if(tot[u]==n-1){printf("-1"),exit(0);}
		tot[u]++;
		for(int i=head[u];~i;i=edge[i].nxt)
		{
			int v=edge[i].v,w=edge[i].w;
			if(dis[v]<dis[u]+w)
			{
				dis[v]=dis[u]+w;
				if(!used[v])
				{
					used[v]=1;
					if(!q.empty())
					{
						if(dis[v]<dis[q.front()]) q.push_front(v);
						else q.push_back(v); 
					}
					else q.push_back(v); 
				
			//	q.push(v);
				}
			}
		}
	}
}

void init()
{
	freopen("Lg P3275.in","r",stdin);
}

void readdata()
{
	memset(head,-1,sizeof(head));
	n=read(),k=read();
	for(int i=1;i<=k;i++)
	{
		int flag=read(),u=read(),v=read();
		if(flag==1)add(u,v,0),add(v,u,0);
		if(flag==2)
		{
			if(u==v){printf("-1");exit(0);}
			add(u,v,1);
		}
		if(flag==3)add(v,u,0);
		if(flag==4)
		{
			if(u==v){printf("-1");exit(0);}
			add(v,u,1);
		}
		if(flag==5)add(u,v,0);
	}
	for(int i=n;i>=1;i--)add(0,i,1);
}

void work()
{
	spfa();
	long long ans=0;
	for(int i=0;i<=n;i++)
	{
		ans+=dis[i];
	}
	printf("%lld",ans);
}

int main()
{
	init();
	readdata();
	work();
	return 0;
}

进阶题目4：MZOJ1389行动！行动！：SPFA+分类讨论【提高】

我们设dis（i,j）表示i节点用了j个药包的最小代价
分当前点用药包和当前点不用药包讨论
下面给出三组代码
代码1：

SPFA+优先队列优化
#include <bits/stdc++.h>
#define inf 1e8+7
using namespace std;
const int maxm=1000005;
const int maxn=100005;
struct EDGE
{
    int u,v,w,nxt;
}edge[maxm];
int n,m,k,s,e,size;
int head[maxn],dis[maxn][15],used[maxn];
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}
 
void add(int u,int v,int w)
{
    edge[size].u=u;
    edge[size].v=v;
    edge[size].w=w;
    edge[size].nxt=head[u];
    head[u]=size++;
}
 
struct node
{
    int city,used;
    node():city(0),used(0){}
    node(int a,int b):city(a),used(b){}
    bool operator <(node x)const
    {
        return dis[city][0]>dis[x.city][0];
    }
};
 
void SPFA(int s)
{
    priority_queue<node> q;
    for(int i=1;i<=n;i++)for(int j=0;j<=k;j++)dis[i][j]=inf;
    q.push(node(s,0));
    for(int i=0;i<=k;i++)dis[s][i]=0;
    while(!q.empty())
    {
        node u=q.top();
        q.pop();
        for(int i=head[u.city];~i;i=edge[i].nxt)
        {
            int v=edge[i].v,w=edge[i].w;
            if(dis[v][u.used]>dis[u.city][u.used]+w)
            {
                dis[v][u.used]=dis[u.city][u.used]+w;
                q.push(node(v,u.used));
            }
            if(u.used<k && dis[v][u.used+1]>dis[u.city][u.used])
            {
                dis[v][u.used+1]=dis[u.city][u.used];
                q.push(node(v,u.used+1));
            }
        }
    }
}
 
void init()
{
    freopen("A.in","r",stdin);
}
 
void readdata()
{
    memset(head,-1,sizeof(head));
    n=read(),m=read(),k=read(),s=read()+1,e=read()+1;
    for(int i=1;i<=m;i++)
    {
        int u=read()+1,v=read()+1,w=read();
        add(u,v,w);
        add(v,u,w);
    }
}
 
void work()
{
    SPFA(s);
    int ans=inf;
    for(int i=0;i<=k;++i)
    {
        ans=min(ans,dis[e][i]);
    }
    printf("%d\n",ans);
} 
 
int main()
{
    //init();
    readdata();
    work();
    return 0;
}
/**************************************************************
    Problem: 1389
    User: mzg1811
    Language: C++
    Result: 正确
    Time:136 ms
    Memory:23992 kb
****************************************************************/

注意重载运算符，将优先队列设为小根堆的语法
代码2：

SPFA+双端队列优化
#include <bits/stdc++.h>
#define inf 1e8+7
using namespace std;
const int maxm=1000005;
const int maxn=100005;
struct EDGE
{
    int u,v,w,nxt;
}edge[maxm];
int n,m,k,s,e,size;
int head[maxn],dis[maxn][15],used[maxn];
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}
 
void add(int u,int v,int w)
{
    edge[size].u=u;
    edge[size].v=v;
    edge[size].w=w;
    edge[size].nxt=head[u];
    head[u]=size++;
}
 
struct node
{
    int city,used;
    node():city(0),used(0){}
    node(int a,int b):city(a),used(b){}
};
 
void SPFA(int s)
{
    deque<node>q;
    for(int i=1;i<=n;i++)for(int j=0;j<=k;j++)dis[i][j]=inf;
     
    q.push_back(node(s,0));
    for(int i=0;i<=k;i++)dis[s][i]=0;
    while(!q.empty())
    {
        node u=q.front();
        q.pop_front();
        for(int i=head[u.city];~i;i=edge[i].nxt)
        {
            int v=edge[i].v,w=edge[i].w;
            if(dis[v][u.used]>dis[u.city][u.used]+w)
            {
                dis[v][u.used]=dis[u.city][u.used]+w;
                if(!q.empty())
                {
                    node x=q.front();
                    if(dis[v][u.used]<dis[x.city][x.used])q.push_front(node(v,u.used));
                    else q.push_back(node(v,u.used));
                }
                else q.push_back(node(v,u.used));
 
            }
            if(u.used+1<=k && dis[v][u.used+1]>dis[u.city][u.used])
            {
                dis[v][u.used+1]=dis[u.city][u.used];
                if(!q.empty())
                {
                    node x=q.front();
                    if(dis[v][u.used+1]<dis[x.city][x.used])q.push_front(node(v,u.used+1));
                    else q.push_back(node(v,u.used+1));
                }
                else q.push_back(node(v,u.used+1));
            }
        }
    }
}
 
void init()
{
    freopen("A.in","r",stdin);
}
 
void readdata()
{
    memset(head,-1,sizeof(head));
    n=read(),m=read(),k=read(),s=read()+1,e=read()+1;
    for(int i=1;i<=m;i++)
    {
        int u=read()+1,v=read()+1,w=read();
        add(u,v,w);
        add(v,u,w);
    }
}
 
void work()
{
    SPFA(s);
    int ans=inf;
    for(int i=0;i<=k;++i)
    {
        ans=min(ans,dis[e][i]);
    }
    printf("%d\n",ans);
} 
 
int main()
{
    //init();
    readdata();
    work();
    return 0;
}
/**************************************************************
    Problem: 1389
    User: mzg1811
    Language: C++
    Result: 正确
    Time:276 ms
    Memory:23992 kb
****************************************************************/

代码3：

dijkstra
#include <bits/stdc++.h>
using namespace std;
 
const int INF=1e9+7;
const int MAXN=100005;
const int MAXM=100005;
const int MAXK=15;
int n,m,k,s,t,ans=INF;
int dis[MAXN][MAXK];
bool used[MAXN][MAXK];
 
int size=0;
int head[MAXN];
struct Edge
{
    int u;
    int v;
    int w;
    int next;
}edge[MAXM<<1];
 
struct node
{
    int city;
    int dis;
    int bag;
    bool operator <(const node &x) const
    {
        return dis>x.dis;
    }
};
 
inline int read()
{
    int X=0; bool flag=1;
    char ch=getchar();
    while(ch<'0'||ch>'9') {if(ch=='-') flag=0; ch=getchar();}
    while(ch>='0'&&ch<='9') {X=(X<<1)+(X<<3)+ch-'0'; ch=getchar();}
    if(flag) return X;
    return ~(X-1);
}
 
inline void add(int u,int v,int w)
{
    edge[size].u=u;
    edge[size].v=v;
    edge[size].w=w;
    edge[size].next=head[u];
    head[u]=size++;
}
 
void readdata()
{
    memset(head,-1,sizeof(head));
    n=read(); m=read(); k=read(); s=read(); t=read();
    for(int i=1;i<=m;i++) 
    {
        int u=read(), v=read(), w=read();
        add(u,v,w);
        add(v,u,w);
    }
}
 
priority_queue <node> q;
void dijkstra()
{
    for(int i=0;i<n;i++) 
        for(int j=0;j<=k;j++) 
        {
            dis[i][j]=INF;
            used[i][k]=0;
        }
    dis[s][0]=0;
    q.push((node){s,0,0});
    while(!q.empty())
    {
        node now=q.top(); q.pop();
        int u=now.city,bag=now.bag;
        if(used[u][bag]) continue;
        used[u][bag]=1;
        for(int i=head[u];~i;i=edge[i].next)
        {
            int v=edge[i].v;
            if(dis[v][bag]>dis[u][bag]+edge[i].w)
            {
                dis[v][bag]=dis[u][bag]+edge[i].w;
                q.push((node){v,dis[v][bag],bag});
            }
            if(bag<k && dis[v][bag+1]>dis[u][bag])
            {
                dis[v][bag+1]=dis[u][bag];
                q.push((node){v,dis[v][bag+1],bag+1});
            }
        }
    }
}
 
void work()
{
    dijkstra();
    for(int i=0;i<=k;i++) ans=min(ans,dis[t][i]);
    printf("%d",ans);
}
 
int main()
{
//  freopen("input.txt","r",stdin);
    readdata();
    work();
    return 0;
}
/**************************************************************
    Problem: 1389
    User: mzg1812
    Language: C++
    Result: 正确
    Time:136 ms
    Memory:12564 kb
****************************************************************/
最短路-Spfa 配题（HDU 3790）
猫ER
09-07 346
Spfa最短路算法，属于单源最短路，可以存在负权边，可以判断负环。 Spfa的算法思想从源点层层松弛，达到全图的单源最短。 题目：HDU 3790（题意很简单） 注意：输入边的信息的时候，用scanf，别用cin，会超时。 #include<iostream> #include<cstring> #include<vector> #include&lt...
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-
头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
08-05 6292
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-树三大遍历】、高级算法【枚举/回溯/递归/分治/动规/贪心】)、问题为导向的十大类刷题算法总结之详细攻略 目录 相关文章 数据结构思维导图 基本术语 一、数据结构的概述 二、数据的逻辑结构 三、数据的物理结构 四、数据的运算
蓝桥杯每日一题（SPFA）
qq_61369552的博客
03-27 270
用另外一个数组存杂交结果，初始结点都为0，遍历所有杂交结果，只要可以减小就加入到队列中。if条件是距离小于两个max，因为必须要保证其父辈已经产生。另外注意使用普通队列即可；和dijkstra中的st数组不同，这里只用来判断是否是在q中。所以所有的初始结点都要st为1，pop的时候将结点st置为0.
SPFA几道经典题目
1292765944的专栏
04-12 1308
HDU 4360 #include #include #include #include #include #include #include #include #include #define eps 1e-5 #define MAXN 2222 #define MAXM 95555 #define INF 200000000000000LL using namespace
SPFA例题
weixin_45724872的博客
11-19 596
引入 SPFA的核心思想是优化dist[a]=min(dist[a],dist[b]+w)这个式子； 不难想到，如果我们想要优化dist[a]，那么只能从dist[b]+w这个式子转移过来； 也就是说，只有dist[b]变小了，才有可能优化dist[a]； 即只有一个点被更新过后，我们才拿这个点更新其他点； 基于这个思想，我们来实现SPFA； 注意 带有负边权的图只能用SPFA 时间复杂度 一般为O(kE)，k是常数O(kE)，k是常数O(kE)，k是常数； 最坏情况下是O(VE)O(VE)O(VE) 例
SPFA练习题
qq_45895217的博客
10-26 353
我好牛逼，我爱我自己！！！ 题目 就是SPFA的模板题。 SPFA算法： 1.需要队列和超级源点0 2.图用链式前向星存，别忘了超级源点0和其他点n条边。 3.添加n条超级源点和n个点相连权值为0的边。再添加需要添加的边。 4.SPFA算法从超级源点0开始遍历，0先入队，队不空时循环：取队首元素front,设置入队标志vis[front] = 0，找以0为起点的所有边即链式前向星搜边，如果边的终点满足dis[e[i].to] > dis[e[i].from] + e[i].w，则替换之。再看这个点.
与SPFA的那些事【一】：优化及模版题
EPSILON的博客
02-16 295
SPFA中的优化及题目 SPFA是图论中的重要内容，主要可以用来找最短路最长路，可以和二分，floyd等其他算法组合成相对难点的题目 最最普通的SPFA P3371 单源最短路径（弱化版）无任何优化的SPFA #include &amp;amp;amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;amp;amp;gt; using namespace std; const int maxm=1000005; const int maxn=1000.
最短路径算法深度解析：Bellman-Ford与SPFA
本资源是一份关于最短路径算法进阶的详细讲解文档，主要聚焦于贝尔曼-福特算法（Bellman-Ford Algorithm）和其优化版本，以及如何处理带有负权边的情况。文档首先回顾了三种常见的最短路径算法，其中重点介绍了...
图论核心算法与模型解析：涵盖最短路、最小生成树及网络流等内容
最新发布
02-01
首先介绍了图的基本概念和常见的存储形式（邻接矩阵与邻接表），随后详述了几种常见最短路径算法（如Dijkstra, Bellman-Ford, SPFA及Floyd-Warshall）以及它们各自的适用条件和复杂度。最小生成树则以Kruskal和Prim...
图论算法进阶：蓝桥杯图论高级问题的解决方法
# 1. 蓝桥杯图论高级问题概述 ## 什么是蓝桥杯 蓝桥杯是中国著名的IT技术竞赛，旨在选拔和培养高中和大学生的计算机科学技术人才。比赛内容涵盖算法、数据结构、编程思维等多个方面，图论算法是其中的重要组成部分...
#46-【SPFA】MLH的一天（SPFA模板题）
2017gdgzoi999的博客
07-20 781
题目描述 一天，体格健壮的MLH（什么鬼）又开始了马拉松的锻炼，可是有一天MLH跑得太远了，回去要很长的一段时间。他要从第1个路口走回第n个路口。他找到了你，求你帮他找到最快的路径，使他可以最快的回到家。 输入 输入共m+1行，第一行包括三个数，n，m，即路口个数，路径个数。 接下来m行，每行三个整数，x，y，v，即从第x个路口到第y个路口要花v的时间(每条路是单向的)。 输出 输...
poj 1511 spfa 模板题
DK
02-25 650
Invitation Cards Time Limit: 8000MS   Memory Limit: 262144K Total Submissions: 26478   Accepted: 8790 Description In the age of television, not many people attend theater
Spfa
Running Bit.
07-19 1000
判断是否存在负环 求带有负边权的最短路 当某个点入队大于N次，一定存在负环。 其他 一直纠结能否把判断一个点被更新N次作为判断依据 临接表不行因为数据可能两个点之间有大于N条边，而且每条边是降序排列 临接矩阵不知道行不行（POJ3259可以过） 模板 using namespace std; int inf = 0x3f3f3f3f; struct ac{ int v,...
hdu 2680 最短路基础题 spfa实现 算法总结
liujc_的专栏
04-13 1093
题目链接http://acm.hdu.edu.cn/showproblem.php?pid=2680 题目大意，就是一个人可以从多个起点开始出发，看到终点的最短路是多少。。只有可以运用和hdu2066一样的思想，对于每个起点可以看成是跟最最开始的点之间有一条权值为0的边。可以把最开始的点记做0点。那这样就可以使用单源最短路了。之前都没有用过spfa，今天来运用了一下。 算法大致流程是用
POJ1511 SPFA经典题目
muxi@Achilles的专栏
08-22 1627
Orz，做这道题对我这个初学者来说真是呕心沥血了！写了一上午，然后调试了一下午。然后WA了3次！哇靠，就是因为坑爹的POJ数据，题目明白说了price的sum不会超int的 但最后还是要用long long 才过！奶娘的！ 在这里感谢羽哥的数据还有long long的提醒。   题目大意：发传单！怎么样选择路线 使得Acmers们在去  和回的过程 花掉的车费最少。 思路：因为每个人负责一
SPFA算法+例题 ：问题 A: 黑暗城堡
Spidy_harker的博客
06-08 623
SPFA算法 算法思想： 1） 三角形中的性质：同一三角形内两边之和大于第三边。 2）由上面那一条性质，我们可以想出一个方法来更新源点到其他点的最短的路径：用中间节点k松弛u->k->v，来更新u->v的最短路径（思想和Floy算法相似），也就是说，我们实际上每次都是在判断这条路径符不符合三角形不等式dis[v]<dis[u]+dis[u->v]，若不符合，我们就将原...
POJ2387 最短路入门题 [spfa,dijstra+heap]
Aszxqw
08-25 1860
思路： 最短路入门题。 很久前做的题目，今天重写了一下，算是复习了一下最短路，整理一下spfa代码模板和dijstra+heap的代码。 SPFA:32ms #include #include #include #include #include #define llong long long #define Abs(a) ((a)>0?(a):-(a)) #define Mod(a,
hihocoder 1093：最短路（SPFA）
FlyingJack
02-12 242
hihocoder 1093 题解：spfa裸题目，存在重复的边和环没关系。 代码： #include &lt;bits/stdc++.h&gt; using namespace std; typedef pair&lt;int,int&gt;pii; int const inf = 0x7f7f7f7f; int const N = 100000 + 10; int const M = ...
spfa算法（洛谷模板题）
spencer12138的博客
11-08 1063
一、概况  SPFA算法是常用的最短路算法之一，复杂度还是非常可观的。  但缺点在于遇到稠密图或者某些奇特的图时可能会变慢。  SPFA算法是一种单元算法，选择一个出发点，计算它与其他点的最短距离。通过更新边来不断更新最短路。在图论的最短路题中应用十分广泛。  二、过程  1.初始化每个节点到第一个点的距离  其他点到第一个点的距离赋个大数（such as 19260817)方便此后进
SPFA算法优化探索：应用与动态规划的结合
此外，SPFA还可以与Johnson算法等其他最短路径算法结合，解决带有负权边的图的最短路径问题。在实际应用中，注意对无用状态进行裁剪，可以进一步提高算法效率。 SPFA算法不仅在理论上有重要的地位，而且在解决实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值