[POJ1364] 国王king

---

题目描述

从前有一个王国，那里的皇后怀孕了。皇后祈祷说：“如果我的孩子是男孩并且能够成为一位好国王该多好。”九个月后，她的孩子降生了，她的确生了一个优秀的儿子。
　　不幸的是，就如皇室里经常发生的一样，她的儿子有一点迟钝。在学习了很多年以后，他仅仅学会了整数加法，并将结果与已知的某个整数比较大小。除此之外，这些数字必须写成一个序列，而他只能对序列中的连续多个整数求和。
　　老国王对他的儿子感到很不高兴。但是他已经做好准备让他的儿子在他死后统治王国。
　　考虑到儿子的能力，他决定每一个需要由国王决定的问题必须以有限整数序列的形式呈递，并且这些问题能够通过对整数序列和的限制（大于或小于的限制）解决。这样至少他的儿子能够做出一些决定。
　　老国王死后，年轻的国王继位了。但是很快，许多人对他的决定很不满意并且想要罢免他。他们试图证明他的决定是错误的。
　　因此一些阴谋者向年轻的国王呈递了一些问题。这些问题的形式为序列S={A1,A2, …, An}的子序列Si={Asi, Asi+1, …, Asi+ni}。国王考虑了一下并做出了决定。比如说，他给每一个子序列的和Si设定了限制ki（比如说，aSi + aSi+1 + … + aSi+ni < ki 或者 aSi + aSi+1 + … + aSi+ni > ki），并且将这些限制作为他的决定。
　　不久他发现他的一些决定是错误的。他不能撤销已经设定的限制，而是试图拯救自己。他决定伪造所呈递的序列。他命令他的顾问找到这样的一个序列S满足他所设定的限制。帮国王的顾问写一个程序考察这样的序列是否存在。

---

输入格式

输入包含多组数据。除最后一组数据外均描述了国王的问题和决定。每组数据的第一行有整数n和m，0 < n <= 100表示序列S的长度，0 < m <= 100表示子序列的数目。接下来m行每行用4部分描述了国王的决定，si，ni，oi，ki，oi为“ gt ”表示符号“>”，oi为“lt”表示符号“<”。最后一组数据仅包含一行一个0。

---

输出格式

对每一组数据输出一行，若序列不存在输“successful conspiracy”，若存在输出“lamentable kingdom”。最后一组数据不输出。

---

样例数据

样例输入

4 2
1 2 gt 0
2 2 lt 2
1 2
1 0 gt 0
1 0 lt 0
0

样例输出

lamentable kingdom
successful conspiracy

---

题目分析

一定要认真读5遍题目。
坑点1：是严格小于大于符而不是小于等于
坑点2：有解输出”可悲的王国“，而无解输出”成功的阴谋“。。。
坑点3：图可能不连通
那么如何转化为差分约束呢？
因为此题只可能是整数，所以小于x可以变为小于等于x-1，大于同理
因为图可能不联通，因此需要一个超级源点连接所有点，边权为0
此题其实用不着spfa，bellman-ford判负环即可。
一定要把used清零啊！！！

---

源代码

#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];
    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);
    }
    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]==edges.size())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) { //求出正整数解 
        if(spfa(Start)==0)return false;
        return true;
    }
};
Difference_Constraints dc;
int n,m;
int main() {
    while(scanf("%d",&n)) {
        if(n==0)break;
        scanf("%d",&m);
        dc.init(n+5);
        int Start=n+1;
        for(int i=0; i<=n; i++)dc.AddEdge(Start,i,0);
        for(int i=1; i<=m; i++) {
            int x,y,v;
            string bj;
            cin>>x>>y>>bj>>v;
            int a=x-1,b=x+y;
            if(bj=="gt")dc.AddEdge(b,a,-v-1);
            else dc.AddEdge(a,b,v-1);
        }
        if(dc.main(Start))puts("lamentable kingdom");
        else puts("successful conspiracy");
    }
    return 0;
}

---