zoj2770 差分约束系统

zoj1770 

x1- x2 <= t1

x3 - x5 <= t2

x2 - x3 <= t3

....

可以用最短路的方法来求的解。

最短路的松弛操作，和这些式子很相近。

如果无答案，那么说明存在负环。不然就有解，但是解不是唯一的，因为任意一组解加上k就又是一组解。

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

方法:

这题有许多条件。最明显的就是i~j至少有k人。那么 1）s[j]-s[i-1]>=k一组方程；

然后对于每一个ci>=0又是一组方程。i~j人数最多不能超过最大上限,s[j]-s[i-1]<=sum[j]-s[i-1]；又是一组。还有最后一组方程就是每一个兵营人数不能超过上限，s[i]-s[i-1]<=ci;

根据这些方程建图，跑spfa，如果一个点进入队列的次数多于n次，说明出现了环。

代码：

#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<algorithm>
#define INF 100000007
#define ll long long
using namespace std;
const int MAXN = ;
struct node
{
        int to;
        int val;
        int next;
}edge[MAXN*MAXN/];
int pre[MAXN],vis[MAXN],ind,n,m;
ll a[MAXN];
ll k,sum[MAXN],in[MAXN];
void add(int x,int y,int z)
{
        edge[ind].to = y;
        edge[ind].val = z;
        edge[ind].next = pre[x];
        pre[x] = ind ++;
}
ll spfa()
{
        ll dis[MAXN];
        queue<int>q;
        for(int i = ; i <= n; i++){
                dis[i] = INF;
                vis[i] = ;
        }
        in[] = ;
        dis[] = ;
        vis[] = ;
        q.push();
        while(!q.empty()){
                int tp = q.front();
                q.pop();
                vis[tp] = ;
                for(int i = pre[tp]; i != -; i = edge[i].next){
                        int t = edge[i].to;
                        if(dis[t] > dis[tp] + edge[i].val){
                                dis[t] = dis[tp] + edge[i].val;
                                if(!vis[t]){
                                        in[t] ++;
                                        if(in[t] > n){
                                                return -;
                                        }
                                        q.push(t);
                                }
                        }
                }
        }
        return dis[n];
}
int main()
{
        while(scanf("%d%d",&n,&m) != EOF){
                ind = ;
                memset(pre,-,sizeof(pre));
                memset(sum,,sizeof(sum));
                for(int i = ; i <= n; i++){
                        scanf("%lld",&a[i]);
                        add(i,i-,a[i]);
                        add(i-,i,);
                        sum[i] = sum[i - ] + a[i];
                }
                for(int i = ; i <= m; i++){
                        ll x,y,z;
                        scanf("%lld%lld%lld",&x,&y,&z);
                        add(y,x-,sum[y]-sum[x-]);
                        add(x-,y,-z);
                }
                memset(in,,sizeof(in));
                ll ans = spfa();
                if(ans == -){
                        cout<<"Bad Estimations"<<endl;
                }
                else {
                        cout<<-ans<<endl;
                }
        }
        return ;
}