【PAT】1003 Emergency——单源最短路径算法（第二标尺）（Dijkstra,Bellman_ford,SPFA)

最新推荐文章于 2024-11-08 20:35:08 发布

fftx_00

最新推荐文章于 2024-11-08 20:35:08 发布

阅读量111

点赞数

分类专栏： PAT_advanced 图论文章标签：算法

本文链接：https://blog.csdn.net/fftx_00/article/details/120498334

版权

PAT_advanced 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

图论

10 篇文章 1 订阅

订阅专栏

//第一种方法：Dijkstra算法
#include <iostream>
#define MAXN 510
#define MAXDATA 1000000000
using namespace std;

int G[MAXN][MAXN];int weight[MAXN];
int N,M,C1,C2;

int collected[MAXN];
int dist[MAXN];int w[MAXN];int num[MAXN];
void Dijkstra(){
  fill(dist,dist+N,MAXDATA);
  dist[C1]=0;
  w[C1]=weight[C1];
  num[C1]=1;
  for(int k=0;k<N;k++){
    int minId=-1,minValue=MAXDATA;
    for(int i=0;i<N;i++){
      if(!collected[i] && dist[i]<minValue){
        minValue=dist[i];
        minId=i;
      }
    }
    if(minId==-1) break;
    collected[minId]=1;
    for(int j=0;j<N;j++){
      if(G[minId][j]!=MAXDATA && !collected[j]){//未被收录的邻接点
        if(dist[j]>dist[minId]+G[minId][j]){//若需要更新dist
          dist[j]=dist[minId]+G[minId][j];
          //1:点权和边权差不多,只是可能两者不能同时取得
          w[j]=w[minId]+weight[j];//1.1:当更新dist时,点权肯定变了,随之更新
          //2.1:当更新dist时,num肯定变了,此时minId到j的路径只有一条,j对于num没有贡献,只能继承minId的num
          num[j]=num[minId];
        }else if(dist[j]==dist[minId]+G[minId][j]){
          //2.2当dist不用更新,但是多了从minId通往j的路径方式,因此叠加num[minId]
          num[j]+=num[minId];
          if(w[j]<w[minId]+weight[j]){
            w[j]=w[minId]+weight[j];//1.2:当dist不用更新,但是点权可以更新时,更新点权
          }
        }
      }
    }
  }
}

int main(){
 scanf("%d %d %d %d",&N,&M,&C1,&C2);

 for(int i=0;i<N;i++){
   scanf("%d",&weight[i]);
 }

 for(int i=0;i<N;i++){
   for(int j=0;j<N;j++){
     G[i][j]=MAXDATA;
   }
 }

 int tmp1,tmp2,tmpl;
 for(int i=0;i<M;i++){
   scanf("%d %d %d",&tmp1,&tmp2,&tmpl);
   G[tmp1][tmp2]=tmpl;
   G[tmp2][tmp1]=tmpl;
 }

  Dijkstra();

  printf("%d %d",num[C2],w[C2]);

  return 0;
}

//第二种方法：Bellman_ford算法
//本题不需要判断负值环
#include <iostream>
#include <vector>
#include <set>
#define MAXN 510
#define MAXDATA 1000000000
using namespace std;
 
struct Node
{
    int v;//邻接顶点
    int dis;//邻接边权
    Node(int _v,int _dis):v(_v),dis(_dis){}
};
vector<Node> Adj[MAXN];//邻接表
int weight[MAXN];//点权
 
int N,M,C1,C2;
 
 
//1：无负值边时Dijkstra:dist[]中存放的时源点只经过已被收录过的点的最短距离,
//当前收录点只会影响其邻接点的距离
//未收录的距离不会影响已收录的
//2：有负值边时Bellman_ford:
//不是邻接点,中间跨几个点也可能影响,因此,每次遍历从当前点出发的所有边,
//又因为后更新的距离也会影响前面的距离,最多需要N-1次操作
int d[MAXN];int w[MAXN];
int num[MAXN];
set<int> pre[MAXN];//防止前驱重复
bool Bellman_ford(){
    //1：Initialize
    fill(d,d+N,MAXDATA);
    d[C1]=0;
    w[C1]=weight[C1];
    num[C1]=1;
    //2：main part
    for(int i=0;i<N-1;i++){//N-1轮操作
        for(int u=0;u<N;u++){//每次操作都遍历所有边
            for(int j=0;j<Adj[u].size();j++){//u的所有邻接边
                int v=Adj[u][j].v;
                int dis=Adj[u][j].dis;
                if(d[u]+dis<d[v]){
                    d[v]=d[u]+dis;
                    w[v]=w[u]+weight[v];
 
                    pre[v].clear();//原有前驱不够优，将原有前驱全部清空
                    pre[v].insert(u);//插入新前驱
 
                    num[v]=num[u];//继承新前驱的num
 
                }else if(d[u]+dis==d[v]){
                    if(w[u]+weight[v]>w[v]){
                        w[v]=w[u]+weight[v];
                    }
                    pre[v].insert(u);//多了一个前驱，将新前驱插入
 
                    num[v]=0;
                    //不确定u之前有没有在pre[v]里面,防止路径重复统计,只能重新计算所有前驱
                    set<int>::iterator it;
                    for(it=pre[v].begin();it!=pre[v].end();it++){
                        num[v]+=num[*it];
                        //统计每个前驱点的num相加,因为前驱点不同,路径一定不同了
                    }
                }
            }
        }
    }
}
 
int main(){
    scanf("%d %d %d %d",&N,&M,&C1,&C2);
    for(int i=0;i<N;i++){
        scanf("%d",&weight[i]);
    }
 
    int tmp1,tmp2,tmpl;
    for(int i=0;i<M;i++){
        scanf("%d %d %d",&tmp1,&tmp2,&tmpl);
        Node n1(tmp2,tmpl);
        Node n2(tmp1,tmpl);
        Adj[tmp1].push_back(n1);
        Adj[tmp2].push_back(n2);
    }
 
    Bellman_ford();
 
    printf("%d %d",num[C2],w[C2]);
 
    return 0;
}

//第三种方法：SPFA算法
//本题不需要判断负值环
#include <iostream>
#include <vector>
#include <queue>
#include <set>
#define MAXN 510
#define MAXDATA 1000000000
using namespace std;

struct Node
{
    int v;//邻接点
    int dis;//邻接边权
    Node(int _v,int _dis):v(_v),dis(_dis){}
};

vector<Node> Adj[MAXN];//邻接表
int nv,ne,C1,C2;

int team[MAXN];//点权

int d[MAXN],w[MAXN];
int num[MAXN];
int inq[MAXN];//在不在队列中
set<int> pre[MAXN];
void SPFA(){
    fill(d,d+nv,MAXDATA);
    d[C1]=0;
    w[C1]=team[C1];
    num[C1]=1;

    queue<int> q;
    q.push(C1);
    inq[C1]=1;
    while(!q.empty()){
        int cur=q.front();
        q.pop();
        inq[cur]=0;

        for(int u=0;u<Adj[cur].size();u++){
            int v=Adj[cur][u].v;
            int dis=Adj[cur][u].dis;
            if(d[v]>d[cur]+dis){
                d[v]=d[cur]+dis;                
                w[v]=w[cur]+team[v];
                
                pre[v].clear();
                pre[v].insert(cur);
                num[v]=num[cur];

                if(!inq[v]){
                    q.push(v);
                    inq[v]=1;
                }
            }else if(d[v]==d[cur]+dis){
                if(w[cur]+team[v]>w[v]){
                    w[v]=w[cur]+team[v];
                }
                
                pre[v].insert(cur);
                num[v]=0;
                set<int>::iterator it;
                for(it=pre[v].begin();it!=pre[v].end();it++){
                    num[v]+=num[*it];
                }
                if(!inq[v]){
                    q.push(v);
                    inq[v]=1;
                }
            }

        }
    }
}

int main(){
    scanf("%d %d %d %d",&nv,&ne,&C1,&C2);
    for(int i=0;i<nv;i++){
        scanf("%d",&team[i]);
    }

    int tmp1,tmp2,tmpl;
    for(int i=0;i<ne;i++){
        scanf("%d %d %d",&tmp1,&tmp2,&tmpl);
        Node tmpn1(tmp2,tmpl);
        Node tmpn2(tmp1,tmpl);
        Adj[tmp1].push_back(tmpn1);
        Adj[tmp2].push_back(tmpn2);
    }

    SPFA();

    printf("%d %d",d[C2],w[C2]);


    return 0;
}