bzoj2330: [SCOI2011]糖果——差分约束+Tarjan

Description

幼儿园里有N个小朋友，lxhgww老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候，lxhgww需要满足小朋友们的K个要求。幼儿园的糖果总是有限的，lxhgww想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋友们所有的要求。

Input
输入的第一行是两个整数N，K。

接下来K行，表示这些点需要满足的关系，每行3个数字，X，A，B。

如果X=1， 表示第A个小朋友分到的糖果必须和第B个小朋友分到的糖果一样多；

如果X=2， 表示第A个小朋友分到的糖果必须少于第B个小朋友分到的糖果；

如果X=3， 表示第A个小朋友分到的糖果必须不少于第B个小朋友分到的糖果；

如果X=4， 表示第A个小朋友分到的糖果必须多于第B个小朋友分到的糖果；

如果X=5， 表示第A个小朋友分到的糖果必须不多于第B个小朋友分到的糖果；

Output
输出一行，表示lxhgww老师至少需要准备的糖果数，如果不能满足小朋友们的所有要求，就输出-1。

Sample Input
5 7

1 1 2

2 3 2

4 4 1

3 4 5

5 4 5

2 3 5

4 5 1

Sample Output

11

HINT
【数据范围】

对于30%的数据，保证 N<=100


对于100%的数据，保证 N<=100000

对于所有的数据，保证 K<=100000，1<=X<=5，1<=A, B<=N

---

这道题显然是差分约束题，基本思路就是用差分约束建图，再找环。

我们先考虑建图，我们采用‘<’建图。如果A< B,则在A向B间建造一条长为1的边。如果A>B，则在B向A建造一条长为1的边。（因为至少大1，所以建权值为1的边）；同理，若A<=B，则在A向B造一条为0的边。若A=B，则建一条双向权值为0的边。即如图（图为样例）

对于这张图，我们只要从入度为0的点开始，做一遍SPFA即可。

但对与这种做法，存在一些漏洞，我们看下面图：

这张图没有入度为0的点，对此我们只能每个点做一遍SPFA，才能算出答案，但如果图是十万个点的一条链，如果从1到所有点顺序加边就会TLE。

所以有两种做法，一种是将所有点放入队列，做一遍SPFA即可,想学的可以点击这里，看这篇博客

还有一种做法，就是用Tarjan缩点，这样这张图就成为了DAG，所以就不存在没有入度为0的点。

Tarjan Code:

#include<bits/stdc++.h>
#include<vector>
#define ll long long
using namespace std;
ll read(){
    char c;ll x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
    while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
ll head[200005],nxt[200005],dfn[200005],low[200005],sta[200005],vis[200005],col[200005],in[200005];
ll co,ta,cnt,n,k,top,ans;
struct node{
    ll to,val;
}L[200005];
struct edge{
    ll sum,num,in,tot;
    vector<pair<ll,ll> > go;
}f[200005];
void add(ll x,ll y,ll c){
    L[cnt]=(node){y,c};
    nxt[cnt]=head[x];head[x]=cnt;cnt++;
}
void tarjan(ll x){
    low[x]=dfn[x]=++ta;
    vis[x]=1;sta[++top]=x;
    for(ll i=head[x];i!=-1;i=nxt[i]){
        ll to=L[i].to;
        if(!dfn[to]) tarjan(to),low[x]=min(low[x],low[to]);
        else if(vis[to]) low[x]=min(low[x],dfn[to]);
    }
    if(low[x]==dfn[x]){
        co++;ll now=0;
        while(now!=x){
            now=sta[top];
            top--;
            col[now]=co;
            vis[now]=0;
            f[co].tot++;
        }
    }
}
void dfs(ll x){
    for(ll i=0;i<f[x].go.size();i++){
        ll to=f[x].go[i].first;
        ll val=f[x].go[i].second;
        if(f[x].num+val>f[to].num){
            f[to].num=f[x].num+val;
            dfs(to);
        }
    }
}
int main()
{
    n=read();k=read();
    memset(head,-1,sizeof(head));
    for(ll i=1;i<=k;i++){
        ll x=read(),y=read(),z=read();
        if(x==1) add(y,z,0),add(z,y,0);
        if(x==2) add(y,z,1);
        if(x==3) add(z,y,0);
        if(x==4) add(z,y,1);
        if(x==5) add(y,z,0);
    }
    for(ll i=1;i<=n;i++)
        if(!dfn[i]) tarjan(i);
    for(ll i=1;i<=n;i++)
     for(ll j=head[i];j!=-1;j=nxt[j]){
        ll to=L[j].to;
        if(col[to]==col[i]) f[col[i]].sum+=L[j].val;
        else f[col[i]].go.push_back(make_pair(col[to],L[j].val)),in[col[to]]++;         
     }
    for(ll i=1;i<=co;i++)
       if(f[i].sum>0){
        puts("-1");
        return 0;
       }
    for(ll i=1;i<=co;i++)
       if(!in[i]){
        f[i].num=1;
        dfs(i);
       }
    for(ll i=1;i<=co;i++) ans+=f[i].num*f[i].tot;
    printf("%lld",ans);
    return 0;
}