ZOJ-2770 Burn the Linked Camp

Burn the Linked Camp
Time Limit: 2 Seconds      Memory Limit: 65536 KB
It is well known that, in the period of The Three Empires, Liu Bei, the emperor of the Shu Empire, was defeated by Lu Xun, a general of the Wu Empire. The defeat was due to Liu Bei's
wrong decision that he divided his large troops into a number of camps, each of which had a group of armies, and located them in a line. This was the so-called "Linked Camps".
Let's go back to that time. Lu Xun had sent many scouts to obtain the information about his enemy. From his scouts, he knew that Liu Bei had divided his troops into n camps, all of which
located in a line, labeled by 1..n from left to right. The ith camp had a maximum capacity of Ci soldiers. Furthermore, by observing the activities Liu Bei's troops had been doing those days, Lu Xun could estimate the least total number of soldiers that were
lived in from the ith to the jth camp. Finally, Lu Xun must estimate at least how many soldiers did Liu Bei had, so that he could decide how many troops he should send to burn Liu Bei's Linked Camps.
Input:
There are multiple test cases! On the first line of each test case, there are two integers n (0<n<=1,000) and m (0<=m<=10,000). On the second line, there are n integers C1...Cn. Then
m lines follow, each line has three integers i, j, k (0<i<=j<=n, 0<=k<2^31), meaning that the total number of soldiers from the ith camp to the jth camp is at least k.
Output:
For each test case, output one integer in a single line: the least number of all soldiers in Liu Bei's army from Lu Xun's observation. However, Lu Xun's estimations given in the input
data may be very unprecise. If his estimations cannot be true, output "Bad Estimations" in a single line instead.
Sample Input:

3 2
1000 2000 1000
1 2 1100
2 3 1300
3 1
100 200 300
2 3 600

Sample Output:

1300

Bad Estimations————————————————————集训19.2的分割线————————————————————
思路：差分约束的入门。求最小值跑最长路。要想跑最长路，就要构造出一张需要松弛的图。需要松弛、那就是一组不等式，通过这些不等式之间的约束关系，可以求出（或者可以证明无解）最小值。
我们把军营当做区间，军营人数当做两个点之间的距离，可以得到——
S[i] - S[i-1] ≥ 0 且 S[i] - S[i-1] ≤ C[i] - C[i-1]
S[j] - S[i] ≥ k 且 S[j] - S[i] ≤ C[j] - C[i]
C[i]表示前i个军营的容量和。
代码如下：/*
ID: j.sure.1
PROG:
LANG: C++
*/
/****************************************/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <iostream>
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
/****************************************/
const int N = 1005, M = 25000;
int n, m, tot;
struct Node {
int v, w, next;
}edge[M];
int q
, head
, enq
, dis
, C
;
bool inq
;

void add(int u, int v, int w)
{
edge[tot] = (Node){v, w, head[u]};
head[u] = tot++;
}

bool spfa(int st)
{
for(int i = 0; i <= n; i++) {
dis[i] = -INF;
inq[i] = enq[i] = 0;
}
dis[st] = 0;
int fron = 0, rear = 1;
q[fron] = st;
inq[st] = true;
enq[st]++;
while(fron < rear) {
int u = q[fron%N]; fron++;
inq[u] = false;
for(int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if(dis[v] < dis[u] + edge[i].w) {
dis[v] = dis[u] + edge[i].w;
if(!inq[v]) {
q[rear%N] = v; rear++;
enq[v]++;
inq[v] = true;
if(enq[v] > n+1) return false;
}
}
}
}
return true;
}

int main()
{
#ifdef J_Sure
// freopen("000.in", "r", stdin);
// freopen(".out", "w", stdout);
#endif
while(~scanf("%d%d", &n, &m)) {
int t;
C[0] = 0; tot = 0;
memset(head, -1, sizeof(head));
for(int i = 1; i <= n; i++) {
scanf("%d", &t);
add(i, i-1, -t);
add(i-1, i, 0);
C[i] = C[i-1] + t;
}
int l, r, k;
while(m--) {
scanf("%d%d%d", &l, &r, &k);
l--;
add(l, r, k);
add(r, l, C[l] - C[r]);
}
if(!spfa(0)) puts("Bad Estimations");
else printf("%d\n", dis
);
}
return 0;
}