算法总结——Bellman_ford

Bellman_ford:

复杂度：O（VE）  边数

用途：一条路，钱币的互换，寻找最小正权环，即一圈后能回到自己并且比自己大或者小，如果是大，d数组就开0，否则开inf

适用条件：从源点到它的所有节点,适用于稀疏图（顶点多，边数少）

原理：利用该顶点判断操作之后与操作之前的比较

步骤：1.开一个d数组，以d[s]记录初始值   2.n-1次松弛 3.判断每一个条件下是否盈利 4.如果每一个结点都盈利说明成功，否则说明存在负权环 

模板：（main函数可忽略~只是为了方便了解各个参数如何得到） 

n-1次原因：

a->b, b->c, c->d这三条路径

假设每一步都是最短路

显然a->d是图中最短路径，最坏的情况是遍历的边先是c->d这条边，发现此时并不知道b->c是可以被用的，然后b->c, a->b

这样一次循环结束，发现并没有得到最短路，然后现在已经得到d点是从c点过来最优，c点是从b点过来最优，b点是从a点过来最优

那么假设又是最坏情况，仍旧是c->d, b->c, a->b， 此时结束后可以得到d点是从b点过来最优，c点是从a点过来最优

第二次循环结束，第三次循环开始，就知道了d是从a过来最优，显然三次循环

如果是最优的情况，即a->b, b->c, c->d

第一次循环中就知道b是从a过来最优， c是从a过来最优， d是从a过来最优

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct edge{
    int u;
    int v;
    int rate;
}a[300];
int s;
int d[300];
int n,m;
bool bellman_ford(int s)
{
    for(int i = 1; i <= n ;i++)
        d[i] = 0;
    d[s] = 1;//第s种为单位1
    for(int i = 1; i <= n - 1 ; i++){//松弛n-1次,单纯循环
          int   flag = 1;
       for(int j = 1; j <= m ; j++){//一共就这么多交易规则
            if(d[a[j].v] < d[a[j].u]*a[j].rate){//如果盈利那么更新
                    flag = 0;
              d[a[j].v] = d[a[j].u]*a[j].rate;
            }
       }
       if(flag) return true;//如果对于每一个交易规则，a[d[j].v]一直等于d[a[j].u]*d[j].rate，说明没有负环的存在，如果仅仅存在一个在接下来的交易中会把负环的接口补上
    }
    return false;//如果仍旧这样，说明存在了负环补不上，使得d[a[j].v]又减小了。
}
int main()
{
    char temp[300][300];
    char  temp1[300],temp2[300];
    scanf("%d",&n);//一共n种货币
    for(int i = 1; i <= n ; i++)
        scanf("%s",temp[i]);
        scanf("%d",&m);//一共m种交易情况
    for(int i = 1; i <= m ; i++){
        scanf("%s%s%d",&temp1[i],&temp2[i],&a[i].rate);
       for(int j = 1; j <= n; j++){
           if(strcmp(temp[j],temp1) == 0)
            a[i].u = j;
           if(strcmp(temp[j],temp2) == 0)
            a[i].v = j;
        }
     }
     int flag1 = 0;
     for(int i = 1; i <= n ; i++)//任意一种钱出发
     if(bellman_ford(i)==0){
            flag1 = 1;
          printf("NO\n");
     }
    if(!flag1)
        printf("YES\n");
   return 0;
}