P1807 最长路【spa||拓扑排序】_最长路拓扑排序-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43653111/article/details/103469309

本文详细解析了P1807最长路问题的解决方案，对比了Dijkstra算法与Bellman-Ford、Spa算法的区别，阐述了如何通过拓扑排序更新dis数组来解决DAG类型的最长路问题，提供了具体的C++代码实现。

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

P1807 最长路【spa||拓扑排序】

题意： 求1-n的最长路，不能到达，输出-1；
误解： 首先想到的是Dijkstra改松弛条件（WA）,变负权值跑最短路（WA），但是发现一个事,首先如果我们改松弛条件，按Dijkstra算法，找第一个距离源点S最远的点时，找到的是与S直接相连的点A，这个距离在以后就不会改变了（因为已经标记为访问过状态）。但A与S的最远距离一般不是直连。而且Dijkstra不能跑带有负边权的路，所以你变负边权求肯定是错的。
正解：上面提到了改负权值跑最短路，这个思想是对的，但是我们可以用Bellman-Ford或者Spa求，那么可不可以改spa松弛条件呢？答案是肯定的，spa类似于bfs,每条边都会跑一遍，肯定会使dis数组更新为最大。还有一种DP的思想，如果不是DAG,我们可以跑一个树形DP,而DAG要用一个拓扑排序更新dis数组，初始化,将到到达节点1的距离设为最大值(确保是从节点1到达节点N)。

在这里插入图片描述
SPA:

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e3+505;
const int INF=1e8;
typedef long long ll;
struct EDGE
{
    int to,next;
    int w;
} edge[50005];
int vis[maxn],n,m,pre[maxn],head[maxn],cnt=0;
int dis[maxn];
void add(int u,int v,int w)
{
    edge[++cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].w=w;
    head[u]=cnt;
}
void init()
{
    memset(head,-1,sizeof head);
    cnt=0;
}
void spa(int st)
{
    queue<int>q;
    for(int i=1; i<=n; i++)
        dis[i]=-INF,vis[i]=0;
    q.push(st);
    dis[st]=0;
    vis[st]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u]; ~i; i=edge[i].next)
        {
            int v=edge[i].to;
            int w=edge[i].w;
            if(dis[v]<dis[u]+w)
            {
                dis[v]=dis[u]+w;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}
int main()
{
    init();
    scanf("%d%d",&n,&m);
    for(int i=1; i<=m; i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    }
    spa(1);
    if(dis[n]==-INF)
        printf("-1\n");
    else
        printf("%d\n",dis[n]);
}

TopSort:

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e3+505;
const int INF=1e8;
const int maxm=5e4+5;
struct node
{
    int w,to;
    int next;
} edge[maxm];
int indeg[maxn],head[maxn],dis[maxn],vis[maxn],cnt=0,n,m;
void add(int u,int v,int w)
{
    edge[++cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].w=w;
    head[u]=cnt;
}
void topsort()
{
    dis[n]=0;
    queue<int>q;
    for(int i=1; i<=n; i++)
        if(indeg[i]==0)
            q.push(i);
    dis[1]=INF;        
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=edge[i].next)
        {
            int v=edge[i].to;
            int w=edge[i].w;
            indeg[v]--;
            if(dis[v]<dis[u]+w)
            {
                dis[v]=dis[u]+w;
            }
            if(indeg[v]==0)
                q.push(v);
        }
    }
}
int main()
{
    memset(head,-1,sizeof head);
    scanf("%d%d",&n,&m);
    for(int i=1; i<=m; i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
        indeg[v]++;
    }
    topsort();
    printf("%d\n",dis[n]==0?-1:dis[n]-INF);
}