BZOJ 3436 小K的农场 差分约束

Description

背景

小K是个特么喜欢玩MC的孩纸。。。

描述

小K在MC里面建立很多很多的农场，总共n个，以至于他自己都忘记了每个农场中种植作物的具体数量了，他只记得

一些含糊的信息（共m个），以下列三种形式描述：农场a比农场b至少多种植了c个单位的作物，农场a比农场b至多

多种植了c个单位的作物，农场a与农场b种植的作物数一样多。但是，由于小K的记忆有些偏差，所以他想要知道存

不存在一种情况，使得农场的种植作物数量与他记忆中的所有信息吻合。

Input

第一行包括两个整数n和m，分别表示农场数目和小K记忆中的信息的数目接下来m行：如果每行的第一个数是1，接

下来有三个整数a,b,c，表示农场a比农场b至少多种植了c个单位的作物如果每行第一个数是2，接下来有三个整数a

，b，c，表示农场a比农场b至多多种植了c个单位的作物如果每行第一个数是3，接下来有两个整数a,b，表示农场a

种植的数量与b一样。1<=n,m,a,b,c<=10000

 

Output

如果存在某种情况与小K的记忆吻合，输出”Yes”，否则输出”No”

 

Sample Input

3 3
3 1 2
1 1 3 1
2 2 3 2

Sample Output

Yes

 

 

差分约束有一段时间没做了，又看了一遍，感觉比以前有了更好的认识。

接下来是证明：

然后，相等的情况，只需要连一条边，不然的话，相当于一个 0 的长度的环，又不能松弛，也不会死循环在里面，但是，在遍历邻接表的时候；

每次都做了无用的比较。

/**************************************************************
    Problem: 3436
    User: TreeDream
    Language: C++
    Result: Accepted
    Time:140 ms
    Memory:2220 kb
****************************************************************/
 
#include <bits/stdc++.h>
 
using namespace std;
 
const int maxn = 10010;
 
struct Edge
{
    int from,to,dist;
};
 
inline int getint()
{
    int w=0,q=0; char c=getchar();
    while((c<'0' || c>'9') && c!='-') c=getchar(); if(c=='-') q=1,c=getchar();
    while (c>='0' && c<='9') w=w*10+c-'0', c=getchar(); return q ? -w : w;
}
 
struct BellmanFord
{
    int n,m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool inq[maxn];
    int d[maxn];
    int p[maxn];
    int cnt[maxn];
 
    void init(int n)
    {
        this->n = n;
        for(int i=0; i<n; i++) G[i].clear();
        edges.clear();
    }
 
    void AddEdge(int from,int to,int dist)
    {
        edges.push_back((Edge)
        {
            from,to,dist
        });
        m = edges.size();
        G[from].push_back(m-1);
    }
 
    bool negativeCycle()
    {
        queue<int> Q;
        memset(inq,0,sizeof(inq));
        memset(cnt,0,sizeof(cnt));
        for(int i=0; i<n; i++)
        {
            d[i] = 0;
            inq[0] = true;
            Q.push(i);
        }
 
        while(!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            inq[u] = false;
            for(int i=0; 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];
                    if(!inq[e.to]) {
                        Q.push(e.to);
                        inq[e.to] = true;
                        if(++cnt[e.to]>n)
                            return true;
                    }
                }
            }
        }
        return false;
    }
 
};
 
BellmanFord sol;
 
int main()
{
    int n,m;
    n = getint();
    m = getint();
 
    sol.init(n+1);
    int a,b,c;
    int flag;
    while(m--)
    {
        flag = getint();
        //scanf("%d",&flag);
        if(flag==2)
        {
            a = getint();
            b = getint();
            c = getint();
            //scanf("%d%d%d",&a,&b,&c);
            sol.AddEdge(b,a,c);
        }
        else if(flag==1)
        {
            a = getint();
            b = getint();
            c = getint();
            //scanf("%d%d%d",&a,&b,&c);
            sol.AddEdge(a,b,-c);
        }
        else if(flag==3)
        {
            a = getint();
            b = getint();
            //scanf("%d%d",&a,&b);
            sol.AddEdge(a,b,0);
            //sol.AddEdge(b,a,0);
        }
    }
    for(int i=0; i<n; i++)
        sol.AddEdge(0,i,0);
 
    if(sol.negativeCycle())
    {
        puts("No");
    }
    else puts("Yes");
 
    return 0;
}