3259Wormholes

Bellman-Ford算法--从边的角度出发

SPFA算法--从顶点出发，用队列优化，用一个count记录这个顶点压入队列多少次来决定他是不是存在负权

Bellman-ford算法浪费了许多时间做无必要的松弛，SPFA算法用队列进行了优化，效果十分显著，高效难以想象,Dijkstra算法无法判断负权回路，所以遇到负权还是要用Bellman-Ford，或者是SPFA

 

2，电脑真的是可以拿来修身养性的啊，它就是一小孩，坑爹啊，很直白，就是错了也很直白，所以打代码时得有心理准备，不会一次性通过的，如果通过了，一般都是水题来的

3.模拟题目，也许这种思考方式不行，我们可以换种思考方式，但要时刻提醒自己，感觉这样不对劲，都要思考为什么不对。

4.输出没有达到自己想要的结果，那就是我们错了，电脑是不会出错的

5.这道题目还没有通过

#include "iostream"
#include "string.h"
#include "queue"
using namespace std;
struct {
  int s,e,t;
}list[1000];
int main(){
  int Case,n,m,w,i,j;
  int time[1000],set[1000],set1[1000];
  queue<int> Q;
  memset(time,0,sizeof(time));
  memset(set,0,sizeof(set));
  cin>>Case;
  while(Case--){
    cin>>n>>m>>w;

    for(i=0;i<m;i++){
      int pos=(i<<1);
      cin>>list[pos].s>>list[pos].e>>list[pos].t;
      list[pos+1].s=list[pos].e;
      list[pos+1].e=list[pos].s;
      list[pos+1].t=list[pos+1].t;
    }
    for(i=2*m;i<2*m+w;i++){
      cin>>list[i].s>>list[i].e>>list[i].t;
      list[i].t=0-list[i].t;
    }

   for(i=1;i<=n;i++){
     memset(time,0,sizeof(time));
     memset(set1,0,sizeof(time));
     time[i]=0;
     set[i]=1;
     Q.push(i);
     while(!Q.empty()){
       int flag=Q.front();
       Q.pop();
       set[flag]=0;
       for(j=0;j<2*m+w;j++){
         if(time[list[j].e]>time[list[j].s]+list[j].t&&list[j].s==flag){
           time[list[j].e]=time[list[j].s]+list[j].t;
           if(!set[list[j].e]){
              Q.push(list[j].e);
              set[list[j].e]=1;
              set1[list[j].e]=1;
            }
         }
         for(int k=0;k<2*m+w;k++)
          if(list[k].e==i&&set1[list[k].s]){
           if(time[list[k].s]+list[k].t<0){cout<<"YES"<<endl;goto l1;}
        }
       }
     }
   }
   cout<<"NO"<<endl;
 l1:;
}
}