BZOJ 2788 Festival 详解（差分约束 tarjan floyd）

2788: [Poi2012]Festival

Time Limit: 30 Sec Memory Limit: 64 MB
Description

有n个正整数X1,X2,…,Xn，再给出m1+m2个限制条件，限制分为两类：
1. 给出a,b (1<=a,b<=n)，要求满足Xa + 1 = Xb
2. 给出c,d (1<=c,d<=n)，要求满足Xc <= Xd
在满足所有限制的条件下，求集合{Xi}大小的最大值。

Input

第一行三个正整数n, m1, m2 (2<=n<=600, 1<=m1+m2<=100,000)。
接下来m1行每行两个正整数a,b (1<=a,b<=n)，表示第一类限制。
接下来m2行每行两个正整数c,d (1<=c,d<=n)，表示第二类限制。

Output

一个正整数，表示集合{Xi}大小的最大值。

如果无解输出NIE。

Sample Input

4 2 2

1 2

3 4

1 4

3 1

Sample Output

3

HINT

|X3=1, X1=X4=2, X2=3

这样答案为3。容易发现没有更大的方案。

思路：
跑多个式子的可行解考虑差分约束。

把Xa+1=Xb转化为Xa<=Xb-1，Xb<=Xa+1,建a到b边权为1的边，b到a权值为-1的边。我们可以把它当做双向边（1类边）。
把Xc<=Xd转化为 Xc-Xd<=0,建一条d到c边权为0的有向边。我们可以把它当做单向边（2类边）。

建图之后图中可能会有强联通分量。
那么连接强联通分量的边不可能是1类边（不然就联通起来了）所以只可能是A<=B（2类边）。
那么只要保证A点所在强联通分量中的最大值小于B点所在强联通分量中的最小值，就可以使不同权值最多。（没有重复）
那么我们只需要对每个强联通求出答案再累加起来就好了。
如果强联通分量中有2类边，那么它们一定是在一个环中的（不然就不是强连通了），由于它们是相互<=的（循环小于等于），那么只有当它们都是同一个权值是才有可能。

由于图中只有-1，0，1三种边，所以每个强联通分量中，权值种类最多就是最长路的绝对值的最大值+1。（最长路的两端一定是这个强连通分量里面的最大及最小值，因为如果不是的话，每两个点之间又是可以互相到达的，那么这就一定不是一条最长路。）
所以上面说的环的最长路跑出来是0。也是满足条件的，不会影响我们所求的答案（最长路上的边一定是1类边）。

因为点数n<=600那么floyd是可以的。（因为要限制只在一个强连通分量里面跑，所以选用枚举方式的floyd应该是很好写的）

怎么判无解呢？就是当出现正权环的时候。我们要求的是最长路，如果出现了正权环，那么我们就可以一直跑这个环，我们的ans就可以无限变大，而这肯定是不合法的（和求最短路判负环一样）

如何判断正权环呢?
只需要初始化把dis[i][i]=0，跑完floyd后看是否还是0即可。

#include <cmath>
#include <stack>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 1000
#define M 400010
#define INF 0x3f3f3f3f
using namespace std;

int n, m1, m2, idc, idx, top, cnt;
int head[N], dfn[N], low[N], ins[N], vis[N], place[N];
int dis[N][N];
stack <int> state;

struct Edge{
    int from, to, next;
}ed[M];

void init(){
    memset(head, 0, sizeof(head));
    idc = 0;
}

void adde(int u, int v){
    ed[++idc].from = u;
    ed[idc].to = v;
    ed[idc].next = head[u];
    head[u] = idc;
}

void tarjan(int u){
    dfn[u] = low[u] = ++idx;
    vis[u] = ins[u] = 1;
    state.push(u);
    for(int i=head[u]; i; i=ed[i].next){
        int v = ed[i].to;
        if( !vis[v] ){
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if( ins[v] ){
            low[u] = min(low[u], dfn[v]);
        }
    }
    if(dfn[u] == low[u]){
        cnt++; int t=-1;
        while(t != u){
            t = state.top();
            place[t] = cnt;//记录强连通分量 
            ins[t] = 0;
            state.pop();
        }
    }
}

int main(){
    init();
    scanf("%d%d%d", &n, &m1, &m2);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            dis[i][j] = -INF;
    for(int i=1; i<=n; i++) dis[i][i] = 0; 
    for(int i=1; i<=m1; i++){
        int a, b;
        scanf("%d%d", &a, &b);
        adde(a, b); adde(b, a);
        dis[a][b] = max(dis[a][b], 1);
        dis[b][a] = max(dis[b][a], -1);
        //a+1=b -> a+1<=b&&a+1>=b -> a<=b-1&&b<=a+1 -> ab.w=1&&ba.w=-1 
        //有矛盾情况时，不覆盖，取max让dis[i][i]不为0 
        //eg:a=b+1&&b=a+1 -> dis[a][b]=dis[b][a]=1 -> dis[a][a]=dis[b][b]=2(更新后)
    }
    for(int i=1; i<=m2; i++){
        int a, b;
        scanf("%d%d", &a, &b);
        adde(a, b);
        dis[a][b] = max(dis[a][b], 0);//b>=a -> a<=b+0
    }
    for(int i=1; i<=n; i++){
        if( !dfn[i] ) tarjan(i);
    }
    int ans = 0;
    for(int cc=1; cc<=cnt; cc++){//枚举每个强连通分量 
        int ret = 0;
        for(int k=1; k<=n; k++){//FLOYD 
            if(place[k] != cc) continue;
            for(int i=1; i<=n; i++){
                if(place[i] != cc || dis[i][k] == -INF) continue;
                for(int j=1; j<=n; j++){//枚举任意两个点 
                    if(place[j] != cc || dis[k][j] == -INF) continue;
                    dis[i][j] = max(dis[i][j], dis[i][k] + dis[k][j]);//更新最长路 
                }
            }
        }
        for(int i=1; i<=n; i++){
            if(place[i] != cc) continue;
            for(int j=1; j<=n; j++){
                if(place[j] != cc) continue;
                ret = max(ret, abs(dis[i][j]));//记录最长路的max 
            }
        }
        ans += ret + 1;//完成一个强连通分量的计算 
    }
    for(int i=1; i<=n; i++)
        if(dis[i][i] != 0){
            puts("NIE");
            return 0;
        }//有正权环，无解 
    printf("%d\n", ans);
    return 9;
}