51nod_1459 最短路 dijkstra 特调参数

好多基础知识都没补完，只好看到、用到一个赶紧补全一个，并且保证下次需要的时候直接用，不用回来再补；

其实这个算法是在补同余最短路的时候用到的，当时突然发现理解算法导论上的原理甚至有效性证明，但是就是没办法写出来合适的代码。。于是到处寻找可以用来试验最短路径算法的试验场（当时学矩阵快速米的时候也是找了51nod上面的一到基础题作为测试的）来熟悉和不全最短路相关基础知识。

首先是DIJKSTRA

对于DIJKSTRA首先是个贪心算法，每次从集合中选择一条没有走过的最短路径来作为新的边，到达新的节点。在以当前找到的这条边更新所有可达的边——所谓的松弛操作。

可以证明，在n次这样的松弛操作之后，可以求得单元最短路（具体证明见算法导论）

这题的要求比单元最短路相对更高些，他要求找到最短路且权重最高的路径。因而应当在每次进行松弛操作时进行更新——当且仅当路径长度相同时选择更大的权重，其他时候选择更短的边的权重。

DIJKSTRA如下：

 #include<bits/stdc++.h>
 using namespace std;

 const long long INF=1e12+;
 const long long MAXN=1e3+;
 long long dp[MAXN];
 long long point[MAXN];
 long long mon[MAXN];
 long long path[MAXN][MAXN];
 long long n,m,start,end;

 void init()
 {
     cin>>n>>m>>start>>end;
     memset(mon,,sizeof(mon));
     for(int i=;i<MAXN;++i)
         for(int j=;j<MAXN;++j)path[i][j]=INF;
     for(int i=;i<n;++i)
     {
         cin>>point[i];
         dp[i]=INF;
     }
     for(int i=;i<m;++i)
     {
         int a,b,p;
         cin>>a>>b>>p;
         path[a][b]=p;
         path[b][a]=p;
     }
 }
 int v[MAXN];
 void dijkstra()
 {
     memset(v,,sizeof(v));
     int x=start;
     mon[start]=point[start];
     dp[start]=;        //dijkstra初始化，应当以最起始点为0点
     for(int i=;i<n;++i)
     {
         long long mini=INF;
         for(int j=;j<n;++j)
         {
             if(!v[j]&&dp[j]<mini)
             {
                 x=j;
                 mini=dp[j];
             }
         }v[x]=;        //标记出现过的点
         for(int j=;j<n;++j)
         {
             if(!v[j]&&dp[j]>dp[x]+path[x][j])
             {

                 mon[j]=mon[x]+point[j];
             }if(!v[j]&&dp[j]==dp[x]+path[x][j])//注意更新时确保该点没有被走到，否则可能出现重复更新
             {
                 mon[j]=max(mon[j],mon[x]+point[j]);
             }

             dp[j]=min(dp[x]+path[x][j],dp[j]);
         }
     }cout<<dp[end]<<" "<<mon[end]<<endl;
 }
 int main()
 {
     cin.sync_with_stdio(false);
     init();
     dijkstra();
     return ;
 }

堆优化的dijkstra，来自刘汝佳的蓝书，同样要注意简要修改下。

 #include<bits/stdc++.h>
 using namespace std;

 const long long MAXN=+;
 const long long INF=1e7+;

 class Edge
 {
     public:
         long long from,to,dist;
 };

 class HeapNode
 {
     public:
         long long d,u;
         bool operator < (const HeapNode& h1)const
         {
             return this->d>h1.d;
         }
 };

 long long mon[MAXN];
 long long point[MAXN];
 long long n1,m1,start,end;

 struct Dijkstra
 {
     long long n,m;
     vector<Edge> edges;
     vector<long long> G[MAXN];
     bool done[MAXN];
     long long d[MAXN];
     long long p[MAXN];

     void init(long long n)
     {
         this->n=n;
         for(long long i=;i<n;++i)
         {
             G[i].clear();
         }edges.clear();
     }

     void AddEdge(long long from,long long to,long long dist)
     {
         edges.push_back((Edge){from,to,dist});
         m=edges.size();
         G[from].push_back(m-);
     }

     void dijkstra(long long s)
     {
         priority_queue<HeapNode> Q;
         for(long long i=;i<n;++i)d[i]=INF;
         d[s]=;
         memset(done,,sizeof(done));
         Q.push((HeapNode){,s});
         mon[s]=point[s];
         while(!Q.empty())
         {
             HeapNode x=Q.top();Q.pop();
             long long u=x.u;
             if(done[u])continue;
             done[u]=true;
             for(long long i=;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]=G[u][i];
                     Q.push((HeapNode){d[e.to],e.to});
                     mon[e.to]=mon[u]+point[e.to];
                 }else if(d[e.to]==d[u]+e.dist)
                 mon[e.to]=max(mon[u]+point[e.to],mon[e.to]);
             }
         }
     }
 };

 int main()
 {
     cin.sync_with_stdio(false);
     Dijkstra d1;
     cin>>n1>>m1>>start>>end;
     for(long long i=;i<n1;++i)cin>>point[i];
     d1.init(n1);
     for(long long i=;i<m1;++i)
     {
         long long a,b,p;cin>>a>>b>>p;
         d1.AddEdge(a,b,p);
         d1.AddEdge(b,a,p);
     }
     d1.dijkstra(start);

     cout<<d1.d[end]<<" "<<mon[end]<<endl;

     return ;
 }

Bellman_Ford算法：
首先，算法思路：设定某有向图中，不存在负环，则对于每条最短路，都会在每一轮松弛中，得到至少一条最短路。

若有向图G中，有一条最短路：A->B->C->D->E，那么因为起始节点为A，则A->B的最短路径会在第一轮松弛操作时被找到。而后操作也是同理。接下来的每个最短路元素都会在未来的某一次松弛操作中被找到。因为每轮松弛操作都至少找到一个元素，所以我们应当认为