dij—— spfa ——floyd总结

#include <iostream>

using namespace std;

int main()
{   /*floyd
    int dp[i][j][k];//dp[i][j][k]表示从j到k只经过前i个点所得的最短路
    int g[][];
    int d[][];
    memset(d,0x3f,sizeof d);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
        d[i][j]=min(d[i][j],g[i][j])
        }
    }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            for(int k=1;k<=n;k++)
                d[j][k]=min(d[j][k],d[j][i]+d[i][k]);//预处理任意两点的最短路
            d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            for(int k=1;k<=n;k++)
                f[j][k]|=f[j][i]+f[i][k];//判断任意两点的可联通性
    */
    
    
    /*dij
    struct N{
        int x,w;
        N(int a=0,int b=0){
        x=a,w=b;
        }
        friend bool operator <(N a,N b){
        return a.w>b.w;
        }
    }
    priority_queue<N> pq;
    bool vis[N];
    int d[N];
    memset(d,0x3f,sizeof d);
    d[s]=0;
    pq.push(N(s,0));
    while(!pq.empty()){
        int x=pq.top().x;pq.pop();
        if(vis[x]) continue;
        vis[x]=1;
        for(int i=head[x];i;i=nxt[i]){
            if(d[to[i]]>d[x]+w[i]){
            d[to[i]]=d[x]+w[i];
            pq.push(N(to[i],d[to[i]]));
            }
        }
    }
    本质为贪心算法，毕竟单源最短路比如i到j的最短路，肯定是由另一个最短路转移过来
    */
    
    /*spfa
    queue<int> q;
    memset(d,0x3f,sizeof d);
    q.push(s);
    d[s]=0;
    bool inq[];//是否已经在队列中
    while(!q.empty()){
        int x=q.front();
        q.pop();
        inq[x]=0;
        for(int i=head[x];i;i=nxt[i]){
            if(d[to[i]]>d[x]+w[i]){
                d[to[i]]=d[x]+w[i];
                if(!inq[to[i]]){
                q.push(to[i]);
                inq[to[i]]=1;
                }
            }
        }
    }
    1.将源点（S）入队

            2.从队头中取出队头的点v，用源头到v的最短距离来更新源头到v相邻点的最短距离（松弛操作）

            3.将最短距离更新过且本身就不在队列中的点入队

            4.重复第2步知道队列为空

        时间复杂度为：O（(n+m) log (n+m)）//入队次数
        大部分情况下比dij快，但是在特殊构造中会退化为m^2,每个点都进队n-1次就会试这个复杂度变得很高
        如a——>b->c->...->z
        a->b->c->...->z
        |     |       |
        ________________
        a向每个加一条边，再在每个点下加一个inf的环

*/


    return 0;
}

spfa dfs形式  更快找到负环
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;
/*裸spfa模板题。
因为有负权边，所以不能用dijkstra（即使最近才知道了堆优化-。-）
*/
const int maxn=2501;
int m;
vector<pair<int,int> >G[maxn];
void add(int a,int b,int c)
{   G[a].push_back(make_pair(b,c));

}
bool vis[maxn];
int dis[maxn];
bool ffl;
 void spfa(int k)
{     if(ffl) return ;
      vis[k]=true;
      for(int i=0;i<G[k].size();i++)
      {   int w=G[k][i].first;
          int  v=G[k][i].second;
          if(dis[k]+v<dis[w])
            {  dis[w]=dis[k]+v;
                if(!ffl&&vis[w])
                {  //printf("YES\n");
                   ffl=true;
                   break;
                }
                else
                {  spfa(w);
                }
            }
      }
    vis[k]=false;//回溯
}
int main()
{  int t;
   int n,d;
     int a,b,c;
    scanf("%d",&t);
    while(t--)
    {   for(int i=0;i<2501;i++)
          G[i].clear();
        scanf("%d%d",&m,&n);
        int ans=~0u>>2;//这个和 ox3f3f3f3f差不多
        for(int i=1;i<=n;i++)
            {scanf("%d%d%d",&a,&b,&d);
             add(a,b,d);
             ans=min(d,ans);
            }
           if(ans>0){
             printf("%d\n",ans);
             continue;
           }
         for(int i=1;i<=m;i++){
            add(0,i,0);
         }
         ffl=false;
         memset(vis,false,sizeof(vis));
         for(int i=0;i<=m;i++)
             dis[i]=0x3f3f3f3f;
         vis[0]=true;
         dis[0]=0;
         spfa(0);
          if(!ffl){
             int sum=1e9+7;
             for(int i=1;i<=m;i++){
                sum=min(sum,dis[i]);
             }
             printf("%d\n",sum);
          }
          else
                printf("-inf\n");
    }
    return 0;
}