PTA 7-9 旅游规划 (25 分)

最新推荐文章于 2024-12-01 10:21:49 发布

子夜ザ

最新推荐文章于 2024-12-01 10:21:49 发布

阅读量372

点赞数 3

文章标签：图论

本文链接：https://blog.csdn.net/qq_51605889/article/details/120891354

版权

这篇博客介绍了三种解决图中求两点之间最短路径问题的算法：Floyd算法、Dijkstra算法和SPFA算法。通过C++代码展示了每种算法的实现细节，适用于解决带有距离和费用的图的最短路径问题。Floyd算法利用动态规划求解所有点对之间的最短路径，Dijkstra算法采用优先队列求单源最短路径，而SPFA是Bellman-Ford算法的一种优化，用于处理负权边的情况。

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

求两点之间最短路径问题
Floyd算法

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e2+5;
const int inf=0x3f3f3f3f;
typedef long long ll;
int G[maxn][maxn];
int d[maxn][maxn];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,m,s,D;
    cin>>n>>m>>s>>D;
    memset(G,inf,sizeof(G));
    memset(d,inf,sizeof(d));
    for(int i=0;i<n;i++)
    {
        d[i][i]=0;
        G[i][i]=0;
    }
    for(int i=0;i<m;i++)
    {
        int x,y,s,w;
        cin>>x>>y>>s>>w;
        G[x][y]=min(G[x][y],s);
        G[y][x]=min(G[y][x],s);
        d[x][y]=min(d[x][y],w);
        d[y][x]=min(d[y][x],w);
    }
    for(int k=0;k<n;k++)
    {
        for(int i=0;i<n;i++)
        {
            {
                for(int j=0;j<n;j++)
                {
                    if(G[i][j]>G[i][k]+G[k][j]||(G[i][j]==G[i][k]+G[k][j]&&d[i][j]>d[i][k]+d[k][j]))
                    {
                        G[i][j]=G[i][k]+G[k][j];
                        d[i][j]=d[i][k]+d[k][j];
                    }
                }
            }
        }
    }
    cout<<G[s][D]<<" "<<d[s][D];
}

Dijkstra算法

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e3+5;
const int inf=0x3f3f3f3f;
typedef long long ll;
int d[maxn],p[maxn];
bool vis[maxn];
struct Edge
{
    int from,to,dist,money;
};

vector<Edge>edges;
vector<int>G[maxn];
void init(int n)
{
    for(int i=0;i<n;i++)
        G[i].clear();
    edges.clear();
}

void add(int from,int to,int dist,int money)
{
    edges.push_back((Edge){from,to,dist,money});
        int m=edges.size();
    G[from].push_back(m-1);
    edges.push_back({to,from,dist,money});
        m=edges.size();
    G[to].push_back(m-1);
}

struct HeapNode
{
    int d,p,u;
    bool operator <(const HeapNode &rhs)const{
        if(d==rhs.d)
            return p>rhs.p;
        return d>rhs.d;
    }
};

int main()
{
    priority_queue<HeapNode>Q;
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,m,s,D;
    cin>>n>>m>>s>>D;
    init(n);
    memset(vis,false,sizeof(vis));
    memset(d,inf,sizeof(d));
    memset(p,inf,sizeof(p));
    for(int i=0;i<m;i++)
    {
        int a,b,c,e;
        cin>>a>>b>>c>>e;
        add(a,b,c,e);
    }
    d[s]=0;
    p[s]=0;
    Q.push({d[s],p[s],s});
    while(!Q.empty())
    {
        HeapNode temp=Q.top();
        Q.pop();
        int u=temp.u;
        if(u==D)
            break;
        if(vis[u]==true)
            continue;
        vis[u]=true;
        for(int i=0;i<G[u].size();i++)
        {
            Edge e=edges[G[u][i]];
            if(d[e.to]>d[u]+e.dist||(d[e.to]==d[u]+e.dist&&p[e.to]>p[u]+e.money))
            {
                d[e.to]=d[u]+e.dist;
                p[e.to]=p[u]+e.money;
                Q.push((HeapNode){d[e.to],p[e.to],e.to});
            }
        }
    }
    cout<<d[D]<<" "<<p[D];
}

spfa算法

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e2+5;
const int inf=0x3f3f3f3f;
typedef long long ll;
vector<int>G[maxn];
int dist[maxn][maxn];
int ans1[maxn],ans2[maxn];
int M[maxn][maxn];
bool vis[maxn];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,m,s,D;
    queue<int>q;
    memset(dist,inf,sizeof(dist));
    memset(M,inf,sizeof(M));
    memset(vis,false,sizeof(vis));
    memset(ans1,inf,sizeof(ans1));
    memset(ans2,inf,sizeof(ans2));
    cin>>n>>m>>s>>D;
    for(int i=0;i<m;i++)
    {
        int a,b,c,z;
        cin>>a>>b>>c>>z;
        G[a].push_back(b);
        G[b].push_back(a);
        dist[a][b]=dist[b][a]=c;
        M[a][b]=M[b][a]=z;
    }

    for(int i=0;i<n;i++)
    {
        M[i][i]=0;
        dist[i][i]=0;
    }

    q.push(s);
    vis[s]=true;//记录一下起点放进去
    ans1[s]=0;
    ans2[s]=0;
    while(!q.empty())
    {
        int temp=q.front();
        q.pop();
        vis[temp]=false;//记录一下队首已被踢出去
        for(int i=0;i<G[temp].size();i++)
        {
            int v=G[temp][i];
            if(ans1[v]>ans1[temp]+dist[temp][v]||(ans1[v]==ans1[temp]+dist[temp][v]&&ans2[v]>ans2[temp]+M[temp][v]))
            {
                ans1[v]=ans1[temp]+dist[temp][v];
                ans2[v]=ans2[temp]+M[temp][v];
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
     cout<<ans1[D]<<" "<<ans2[D];
}