POJ 1364 差分约束

一直不知道差分约束是什么类型题目，最近在写最短路问题就顺带看了下，原来就是给出一些形如x-y<=b不等式的约束，问你是否满足有解的问题

好神奇的是这类问题竟然可以转换成图论里的最短路径问题，下面开始详细介绍下

比如给出三个不等式,b-a<=k1,c-b<=k2,c-a<=k3,求出c-a的最大值,我们可以把a,b,c转换成三个点，k1，k2，k3是边上的权，如图

由题我们可以得知，这个有向图中，由题b-a<=k1,c-b<=k2,得出c-a<=k1+k2,因此比较k1+k2和k3的大小，求出最小的就是c-a的最大值了

根据以上的解法，我们可能会猜到求解过程实际就是求从a到c的最短路径，没错的....简单的说就是从a到c沿着某条路径后把所有权值和k求出就是c -a<=k的一个

推广的不等式约束，既然这样，满足题目的肯定是最小的k，也就是从a到c最短距离...

理解了这里之后，想做题还是比较有困难的，因为题目需要变形一下，不能单纯的算..

首先以poj3159为例,这个比较简单，就是给出两个点的最大差，然后让你求1到n的最大差，直接建图后用bellman或者spfa就可以过了

稍微难点的就是poj1364，因为他给出的不等式不是x-y<=k形式，有时候是大于号，这样需要我们去变形一下，并且给出的还是>,<没有等于，都要变形

再有就是poj1201，他要求出的是最长距离，那就要把形式变换成x-y>=k的标准形式

注意点:

1. 如果要求最大值想办法把每个不等式变为标准x-y<=k的形式,然后建立一条从y到x权值为k的边,变得时候注意x-y<k =>x-y<=k-1

   如果要求最小值的话,变为x-y>=k的标准形式，然后建立一条从y到x的k边，求出最长路径即可

2.如果权值为正，用dj，spfa，bellman都可以，如果为负不能用dj，并且需要判断是否有负环，有的话就不存在

POJ 1364AC代码

//
//  main.cpp
//  POJ 1364 差分约束
//
//  Created by 郑喆君 on 8/8/14.
//  Copyright (c) 2014 itcast. All rights reserved.
//

#include<cstdio>
#include<cstring>
#include<iostream>
#include<iomanip>
#include<queue>
#include<cmath>
#include<stack>
#include<map>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
typedef long long LL;
const int int_max = 0x07777777;
const int int_min = 0x80000000;
const int maxn = 150;
struct Edge {
    int from, to, dist;
    Edge(int _from, int _to, int _dist):from(_from),to(_to),dist(_dist){}
};
vector<Edge> es;
vector<int> g[maxn];
int n,m;
bool inq[maxn];
int d[maxn];
int p[maxn];
int cnt[maxn];
void addedge (int from, int to, int dist){
    es.push_back(Edge(from, to, dist));
    int len = es.size();
    g[from].push_back(len-1);
}
bool negativeCycle (){
    queue<int> q;
    int limit=(int)sqrt(1.0*n);
    memset(inq, 0, sizeof(inq));
    memset(cnt, 0, sizeof(cnt));
    for(int i = 0; i <= n; i++) {d[i] = 0; inq[i] = 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 = es[g[u][i]];
            if(d[e.to] > d[e.from]+e.dist){
                d[e.to] = d[e.from] + 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;
}

int main(int argc, const char * argv[])
{
    while (scanf("%d", &n)!=EOF) {
        if(n==0) break;
        es.clear();
        for(int i = 0; i < maxn; i++) g[i].clear();
        scanf("%d", &m);
        for(int i = 0; i < m; i++){
            int u,v,w;
            char s[5];
            scanf("%d%d%s%d", &u,&v,s,&w);
            if(s[0]=='g') addedge(v+u, u-1, -w-1);
            else addedge(u-1, v+u, w-1);
        }
        if(negativeCycle()){
            printf("successful conspiracy\n");
        }else{
            printf("lamentable kingdom\n");
        }
    }
}