小K的农场题解

看题发现可以根据数据建造一个图，利用查分的思想将每个描叙建立成一条边或两条边，
1. a,b,c时，可以建立a -> b 的一条边，权值为-c;
2.a,b,c时，可以建立b -> a 的的一条边，权值为c；
3.a,b时，可以建立a->b 和b ->a的两条边，权值为0；
然后求最短路，如果存在负权环，则最短路不存在，即No,否则Yes。
因此在建好图之后，就是利用SPFA判负环了，由于SPFA判负环有两种解法，
1） spfa 的 dfs 形式，判断条件是存在一点在一条路径上出现多次。
2） spfa 的 bfs 形式，判断条件是存在一点入队次数大于总顶点数。
下面这个程序便是用的第2种方法，没有注意到n,m最大到10000，当用第二种方法判负环，时间复杂度会退化为O(nm),也就自然TLE了，因此下面这个程序华丽丽的60分。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
int n,m;
struct node{
    int to,w,next;
};
node Edge[30005];
int head[10002],cnt;
bool flag;
queue<int>q;
int isQueue[10002],count[10002],d[10002];
void add(int u,int v,int w)
{
    Edge[++cnt].to = v; Edge[cnt].w = w; Edge[cnt].next = head[u];head[u] = cnt;
}
void spfa(int s)
{ 
    d[s]=0;    
    q.push(s);
    isQueue[s] = true;
    count[s]++;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        if(count[u]==n){ flag = true;return; }
        isQueue[u] = false;
        for(int i = head[u]; i;i= Edge[i].next)
        {
            int v = Edge[i].to;
            int w = Edge[i].w;
            if(d[v] > d[u] +w)
            {
                d[v] = d[u]+w;
                if(!isQueue[v])
                {
                    isQueue[v] = true;
                    q.push(v);
                    count[v]++;
                }
            }
        }
    }
}
int main()
{
    int f ,a,b,c;
    cin >> n >> m;
    for(int i= 1; i<= n; i++)
        add(0,i,0);
    for(int i=1 ;i<= m;i++)
    {
        cin >> f;
        if(f == 1)
        {
            scanf("%d%d%d",&a,&b,&c); 
            add(a,b,-c);
        }            
        else if(f==2)
        {
            scanf("%d%d%d",&a,&b,&c); 
            add(b,a,c);
        }
        else
        {
            scanf("%d%d",&a,&b);
            add(a,b,0);
            add(b,a,0);
        }
     } 
    memset(d,0x7f,sizeof(d));
    spfa(0);
    if(!flag)   //不是负环 
         printf("Yes\n");
    else 
        printf("No\n");
    return 0;
 } 

TLE必须提高判负环的效率，因此采用了dfs优化SPFA判负环，写法如下：

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
int n,m;
struct node{
    int to,w,next;
};
node Edge[30005];
int head[10002],cnt;
bool flag,vis[10002];
queue<int>q;
int count[10002],d[10002];
void add(int u,int v,int w){
    Edge[++cnt].to = v; Edge[cnt].w = w; Edge[cnt].next = head[u];head[u] = cnt;
}
void dfsSPFA(int s){
    if(flag == true)
        return;
    for(int i = head[s]; i;i= Edge[i].next) {
        int v = Edge[i].to;
        int w = Edge[i].w;
        if(d[v] > d[s] +w){
            if(vis[v]){
                flag = true;
                return;
            }
            d[v] = d[s]+w;
            vis[v] = true;
            dfsSPFA(v);
            vis[v] = false;
        }
    }
 } 
int main()
{
    int f ,a,b,c;
    cin >> n >> m;
    for(int i= 1; i<= n; i++)
        add(0,i,0);
    for(int i=1 ;i<= m;i++){
        cin >> f;
        if(f == 1){
            scanf("%d%d%d",&a,&b,&c); 
            add(a,b,-c);
        }           
        else if(f==2){
            scanf("%d%d%d",&a,&b,&c); 
            add(b,a,c);
        }
        else{
            scanf("%d%d",&a,&b);
            add(a,b,0);
            add(b,a,0);
        }
     } 
    memset(d,0x7f,sizeof(d));
    d[0]=0;
    dfsSPFA(0);
    if(!flag)   //不是负环 
        printf("Yes\n");
    else 
        printf("No\n");
    return 0;
 }