POJ1364:King——差分约束(Bellman_Ford)

题面

　　POJ1364

解析

　　 看到了多个不等式约束条件，差分约束是很容易想到的。

　　建图的话就用前缀和$S[i]$数组， 我这里的$S[i] = a[1] + a[2] + ... + a[i-1]$,  与平时习惯的不一样，我想避免出现0号节点(其实好像没必要)，差分约束是<= 或 >= ，因此还要转化一下， 转化的全部过程如下：

　　对于 lt: $a[l] + a[l+1] + ... + a[l+len] < c$  --> $S[l+len+1] - S[l] < c$ --> $S[l+len+1] - S[l] <=  c - 1$

　　对于 gt: $a[l] + a[l+1] + ... + a[l+len] > c$ -->   $S[l+len+1] - S[l] > c$ --> $S[l+len+1] - S[l] >=  c + 1$ --> $S[l] - S[l+len+1] <= -c - 1$

　　然后就是差分约束跑最短路了， 结果30min过去了，我依然没有AC，疯狂TLE

　　为什么呢？

　　真相只有一个——

　　SPFA！！！

　　我加了SLF优化后依然TLE， 于是我看了看别人的博客，删了所有的SPFA，开始学习Bellman_Ford最短路算法

　　Bellman_Ford就是不断进行松弛操作，因为一条边的起点的dis最多被其他所有点更新最多松弛n-1次，等价于SPFA中不存在负环时一个点最多入队n-1次， 所以外层循环n-1次(n是点数), 内层循环枚举边，对每一条边进行松弛操作，总时间复杂度是O(nm)的

　　那如何用Bellman_Ford判负环呢？

　　如果在进行完n-1次松弛操作后，依然存在可以松弛操作的边， 那就一定存在负环， 也就是相当于SPFA中进队次数大于等于n后就存在负环

　　改完后交一发， 结果AC了...

　　我对SPFA最后一点好感正在逐渐消失，这个题这么小的数据都可以卡SPFA，我是真的无语了，也许关于SPFA，它真的快死透了

　代码：

#include<cstdio>
#include<iostream>
#include<climits>
using namespace std;
const int maxn = 105, inf = INT_MAX;

int n, m, dis[maxn];

struct edge{
    int u, v, d;
}e[maxn];

bool B_F()
{
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; ++j)
            if(dis[e[j].u] + e[j].d < dis[e[j].v])
                dis[e[j].v] = dis[e[j].u] + e[j].d;
    for(int i = 1; i <= m; ++i)
        if(dis[e[i].u] + e[i].d < dis[e[i].v])
            return 1;
    return 0;
}

int main()
{
    while(scanf("%d", &n), n != 0)
    {
        scanf("%d", &m);
        for(int i = 1; i <= n; ++i)
            dis[i] = 0;
        for(int i = 1; i <= m ; ++i)
        {
            int x, y, z;
            scanf("%d%d", &x, &y);
            char opt[5];
            scanf("%s", opt);
            scanf("%d", &z);
            if(opt[0] == 'l')
                e[i] = (edge){x, x + y + 1, z - 1};
            else
                e[i] = (edge){x + y + 1, x, -z - 1};
        }
        printf("%s
", B_F()? "successful conspiracy": "lamentable kingdom");
    }
    return 0;
}