poj 1364 King

题意：已知一个序列a[1], a[2], ......, a[n]，给出它的若干子序列以及对该子序列的约束条件，例如a[si], a[si+1], a[si+2], ......, a[si+ni]，且a[si]＋a[si+1]＋a[si+2]＋......＋a[si+ni] < or > ki。

转化：a[a] + a[a+1] + …… + a[b] < c 可以转化成前n项和sum[b] - sum[a - 1] < c，为了能用Bellman_Ford,即将< 转化成 <= ，sum[b] - sum[a - 1] <= c - 1。

注意：1，松弛时一共有N+1次，因为这个N与bellman——ford里面的n不是同一个，在虚拟加入了一个x0后，应该有N+1个顶点。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

struct Edge
{
    int s,e;
    int val;
}edge[210];

int pe;
int N,M;
int dis[110];

bool bellman_ford()
{
    bool sign;

    for(int j=0;j<N+1;j++)
    {
        sign=false;
        for(int i=0;i<pe;i++)
            if(dis[edge[i].e] > dis[edge[i].s] + edge[i].val)
            {
                dis[edge[i].e] = dis[edge[i].s] + edge[i].val;
                sign=true;
            }
        if(!sign)
            break;
    }
    if(sign)
        return false;//存在负环
    else
        return true;
}

int main()
{
    while(scanf("%d",&N) && N)
    {
        scanf("%d",&M);
        memset(dis,0,sizeof(dis));//虚拟出一个x0，xi-x0<=0
        pe=0;

        char op[3];
        int a,b,x;

        for(int i=0;i<M;i++)
        {
            getchar();
            scanf("%d%d%s%d",&a,&b,&op,&x);
            if(op[0]=='l')
            {
                edge[pe].s=a-1;
                edge[pe].e=a+b;
                edge[pe++].val=x-1;
            }
            else
            {
                edge[pe].s=a+b;
                edge[pe].e=a-1;
                edge[pe++].val=-x-1;
            }
        }
        if(bellman_ford())
            puts("lamentable kingdom");
        else
            puts("successful conspiracy");
    }
    return 0;
}