[HNOI2005] 狡猾的商人

---

题目描述

　　刁姹接到一个任务，为税务部门调查一位商人的账本，看看账本是不是伪造的。账本上记录了n个月以来的收入情况，其中第i 个月的收入额为Ai(i=1,2,3…n-1,n)， 。当 Ai大于0时表示这个月盈利Ai 元，当 Ai小于0时表示这个月亏损Ai 元。所谓一段时间内的总收入，就是这段时间内每个月的收入额的总和。
　　刁姹的任务是秘密进行的，为了调查商人的账本，她只好跑到商人那里打工。她趁商人不在时去偷看账本，可是她无法将账本偷出来，每次偷看账本时她都只能看某段时间内账本上记录的收入情况，并且她只能记住这段时间内的总收入。
　　现在，刁姹总共偷看了m次账本，当然也就记住了m段时间内的总收入，你的任务是根据记住的这些信息来判断账本是不是假的。

---

输入格式

第一行为一个正整数w，其中w < 100，表示有w组数据，即w个账本，需要你判断。每组数据的第一行为两个正整数n和m，其中n < 100，m < 1000，分别表示对应的账本记录了多少个月的收入情况以及偷看了多少次账本。接下来的m行表示刁姹偷看m次账本后记住的m条信息，每条信息占一行，有三个整数s，t和v，表示从第s个月到第t个月（包含第t个月）的总收入为v，这里假设s总是小于等于t。

---

输出格式

包含w行,每行是true或false,其中第i行为true当且仅当第i组数据，即第i个账本不是假的；第i行为false当且仅当第i组数据，即第i个账本是假的。

---

样例数据

样例输入

2
3 3
1 2 10
1 3 -5
3 3 -15
5 3
1 5 100
3 5 50
1 2 51

样例输出

true
false

---

题目分析

差分约束水题，也可以用并查集做。
对于每一个账本x,y,v，可得

Sy−Sx−1=v

$$S_y-S_{x-1}= v$$
即为不等式：
$$S_y-S_{x-1}\le v$$
$$S_{x-1}-S_y\le -v$$
差分约束SPFA判负环即可

---

源代码

#include<algorithm>
#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
using namespace std;
inline const int Get_Int() {
    int num=0,bj=1;
    char x=getchar();
    while(x<'0'||x>'9') {
        if(x=='-')bj=-1;
        x=getchar();
    }
    while(x>='0'&&x<='9') {
        num=num*10+x-'0';
        x=getchar();
    }
    return num*bj;
}
const int maxn=5005;
struct Edge {
    int from,to,dist;
};
struct Difference_Constraints { //差分约束系统 
    int n,m;
    vector<Edge>edges;
    vector<int>G[maxn];
    bool inque[maxn];
    int dist[maxn],used[maxn];
    int ans[maxn]; //ans表示不等式组答案 
    void init(int n) {
        this->n=n;
        edges.clear();
        for(int i=0; i<=n; i++)G[i].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);
    }
    void insert(int x,int y,int v,bool flag) { //x-y<=v (flag=0),x-y>=v (flag=1)
        if(flag==0)AddEdge(y,x,v);
        if(flag==1)AddEdge(y,x,-v);
    }
    bool spfa(int s) {
        for(int i=0; i<=n; i++)dist[i]=0x7fffffff/2;
        memset(inque,0,sizeof(inque));
        memset(used,0,sizeof(used));
        deque<int>Q;
        Q.push_back(s);
        dist[s]=0;
        inque[s]=1;
        used[s]++;
        while(!Q.empty()) {
            int Now=Q.front();
            Q.pop_front();
            inque[Now]=0;
            for(int i=0; i<G[Now].size(); i++) {
                Edge& e=edges[G[Now][i]];
                int Next=e.to;
                if(dist[Next]>dist[Now]+e.dist) {
                    dist[Next]=dist[Now]+e.dist;
                    if(!inque[Next]) {
                        used[Next]++;
                        if(used[Next]>n+1)return false; //负权回环
                        if(!Q.empty()&&dist[Next]<dist[Q.front()])Q.push_front(Next); //SLF优化
                        else Q.push_back(Next);
                        inque[Next]=1;
                    } 
                }
            }
        }
        return true;
    }
    bool main(int Start,bool flag) { //求出正整数解 
        if(spfa(Start)==0)return false;
        int Min=0x7fffffff/2;
        if(flag==1) { //最长路 
            for(int i=0; i<=n; i++)dist[i]*=-1;
        }
        for(int i=0; i<=n; i++)Min=min(Min,dist[i]); //转为正数 
        for(int i=0; i<=n; i++)ans[i]=dist[i]-Min;
        return true;
    }
    void Output() {
        for(int i=0; i<=n; i++)printf("%d\n",ans[i]);
    }
};
Difference_Constraints dc;
int t,n,m;
int main() {
    t=Get_Int();
    while(t--) {
        n=Get_Int();
        m=Get_Int();
        dc.init(n);
        for(int i=1; i<=m; i++) {
            int x=Get_Int(),y=Get_Int(),v=Get_Int();
            dc.insert(y,x-1,v,0);
            dc.insert(x-1,y,-v,0);
        }
        if(dc.spfa(0))puts("true");
        else puts("false");
    }
    return 0;
}

---