poj 1364差分约束


King

Time Limit: 1000MS   Memory Limit: 10000K
Total Submissions: 10206   Accepted: 3777

Description

Once, in one kingdom, there was a queen and that queen was expecting a baby. The queen prayed: ``If my child was a son and if only he was a sound king.‘‘ After nine months her child was born, and indeed, she gave birth to a nice son.

Unfortunately, as it used to happen in royal families, the son was a little retarded. After many years of study he was able just to add integer numbers and to compare whether the result is greater or less than a given integer number. In addition, the numbers
had to be written in a sequence and he was able to sum just continuous subsequences of the sequence.

The old king was very unhappy of his son. But he was ready to make everything to enable his son to govern the kingdom after his death. With regards to his son‘s skills he decided that every problem the king had to decide about had to be presented in a form
of a finite sequence of integer numbers and the decision about it would be done by stating an integer constraint (i.e. an upper or lower limit) for the sum of that sequence. In this way there was at least some hope that his son would be able to make some decisions.

After the old king died, the young king began to reign. But very soon, a lot of people became very unsatisfied with his decisions and decided to dethrone him. They tried to do it by proving that his decisions were wrong.

Therefore some conspirators presented to the young king a set of problems that he had to decide about. The set of problems was in the form of subsequences Si = {aSi, aSi+1, ..., aSi+ni} of a sequence S = {a1, a2, ..., an}. The king thought a minute and then
decided, i.e. he set for the sum aSi + aSi+1 + ... + aSi+ni of each subsequence Si an integer constraint ki (i.e. aSi + aSi+1 + ... + aSi+ni < ki or aSi + aSi+1 + ... + aSi+ni > ki resp.) and declared these constraints as his decisions.

After a while he realized that some of his decisions were wrong. He could not revoke the declared constraints but trying to save himself he decided to fake the sequence that he was given. He ordered to his advisors to find such a sequence S that would satisfy
the constraints he set. Help the advisors of the king and write a program that decides whether such a sequence exists or not.

Input

The input consists of blocks of lines. Each block except the last corresponds to one set of problems and king‘s decisions about them. In the first line of the block there are integers n, and m where 0 < n <= 100 is length of the sequence S and 0 < m <= 100
is the number of subsequences Si. Next m lines contain particular decisions coded in the form of quadruples si, ni, oi, ki, where oi represents operator > (coded as gt) or operator < (coded as lt) respectively. The symbols si, ni and ki have the meaning described
above. The last block consists of just one line containing 0.

Output

The output contains the lines corresponding to the blocks in the input. A line contains text successful conspiracy when such a sequence does not exist. Otherwise it contains text lamentable kingdom. There is no line in the output corresponding to the last ``null‘‘
block of the input.

Sample Input

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

Sample Output

lamentable kingdom
successful conspiracy

Source

Central Europe 1997

[Submit]   [Go Back]   [Status]  
[Discuss]

存.....

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<string>
#include<queue>
#include<map>
#include<cmath>
#include<cstring>
using namespace std;
#define INF 1e8
const int maxn= 105;
typedef long long LL;
int d[maxn],cnt[maxn];
bool inq[maxn];

struct Edge
{
    int from,to,w;
};
vector<Edge>edges[maxn];

int n,m;
void addEdge(int u,int v,int w)
{
    edges[u].push_back((Edge)
    {
        u,v,w
    });
}

bool spfa()
{
    for(int i=0; i<=n; i++)d[i]=INF;
    d[n+1]=0;
    memset(inq,0,sizeof(inq));
    memset(cnt,0,sizeof(cnt));

    queue<int>q;
    q.push(n+1);

    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        inq[u]=false;
        for(vector<Edge>::iterator it=edges[u].begin(); it!=edges[u].end(); ++it)
        {
            Edge &e=*it;
            if(d[e.to]>d[u]+e.w)
            {
                d[e.to]=d[u]+e.w;
                if(!inq[e.to])
                {
                    cnt[e.to]++;
                    if(cnt[e.to]>n)return true;
                    q.push(e.to);
                    inq[e.to]=true;
                }
            }
        }
    }
    return false;
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        scanf("%d",&m);
        for(int i=0; i<=n; i++)edges[i].clear();

        char cmd[5];
        int x,y,w;
        for(int i=0; i<=n; i++)addEdge(n+1,i,0);
        while(m--)
        {

            scanf("%d%d%s%d",&x,&y,cmd,&w);
            if(cmd[0]=='l')
                addEdge(x-1,x+y,w-1);
            else
                addEdge(x+y,x-1,-w-1);
        }

        if(spfa())puts("successful conspiracy");
        else puts("lamentable kingdom");
    }
    return 0;
}
时间: 2024-11-04 10:59:39

poj 1364差分约束的相关文章

POJ 1364[差分约束]

题目链接:[http://poj.org/problem?id=1364] 晕死了.但是也长知识了 题意:一个长度为n的序列:a[1].a[2].a[3]...a[n],然后给你一些约束条件:si.ni.gt||lt.ki表示:a[si].a[si+1]....a[si+ni]<or>ki,问你满足这些约束条件,字符串是否存在.存在输出:lamentable kingdom,否则输出:successful conspiracy 题解:对序列求前缀和,将约束条件改为:sum[si+ni]-sum

poj 3169 差分约束

3169 差分约束的是满足多组形如xi-yj<=bk{i,j<n k<m}不等式极值问题,可以转化为单源最短路来求. 在最短路中 d[v]<=d[u]+w(u,v) 可以看出跟上面的不等式很像 通常有两种一种是求满足所有不等式的最大值,还有是最小值. 这篇博客可以参考一下 分析: 题目给出了两种不等式  d[u]+dl >=d[v]       d[u]+dd<=d[v]  要求的是最大值,也就是最短路 对于d[u]+dl>=d[v] 建边(u,vdl) 对于d[

POJ 3159[差分约束]

题目链接:[http://poj.org/problem?id=3159] 题意:有N个小朋友,编号为1-N,每个小朋友将分的一些糖果,给出一些关系A.B.C .表示B最多比A多C个,然后问你盆友1和盆友N的糖果数最大差多少.保证有解. 题解:差分约束求最短距离:DIJ+对优化||SPAF+栈优化 #include<queue> #include<cstdio> #include<cstring> #include<algorithm> using name

hdu 1364(差分约束)

King Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 12056   Accepted: 4397 Description Once, in one kingdom, there was a queen and that queen was expecting a baby. The queen prayed: ``If my child was a son and if only he was a sound kin

poj 1201(差分约束)

Intervals Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 24948   Accepted: 9491 Description You are given n closed, integer intervals [ai, bi] and n integers c1, ..., cn. Write a program that: reads the number of intervals, their end po

poj 1201 差分约束+spfa

非常经典的差分约束系统的建模.求最小值需要转化为求最长路. 1 #include <algorithm> 2 #include <iostream> 3 #include <cstring> 4 #include <cstdio> 5 using namespace std; 6 7 const int INF = 99999999; 8 const int N = 50002; 9 const int M = 200000; 10 int head[N];

poj 3159 差分约束+spfa

由于此题数据特殊,队列优化的spfa会超时,可以改成用栈来优化. 1 #include <algorithm> 2 #include <iostream> 3 #include <cstring> 4 #include <cstdio> 5 using namespace std; 6 7 const int INF = 9999999; 8 const int N = 30001; 9 const int M = 150000; 10 int head[N

POJ 1364 King --差分约束第一题

题意:求给定的一组不等式是否有解,不等式要么是:SUM(Xi) (a<=i<=b) > k (1) 要么是 SUM(Xi) (a<=i<=b) < k (2) 分析:典型差分约束题,变换,令Ti = SUM(Xj) (0<=j<=i).  则表达式(1)可以看做T(a+b)-T(a-1) > k,也就是T(a-1)-T(a+b) < -k,又因为全是整数,所以T(a-1)-T(a+b) <= -k-1.  同理,(2)看做T(a+b)-T(

POJ 1364 King 差分约束 找负环

嘛,虽然是一道水题+模板题,不过还是学到了很多东西的,记录一下. 首先题目给出的不等式是小于,但是差分约束系统只能处理小于等于的情况,所以要转化成小于等于的进行处理.对于整数处理方法非常简单= = 然后是找负环的情况,其实不需要考虑图连不连通,只要一开始就把所有的点的d置成0,然后都push进队列里面就好了. PS:这种方法同样可以用在处理多源点最短路问题上. #include <cstdio> #include <cstring> #include <cmath> #