银河（差分约束）

题目描述

银河中的恒星浩如烟海，但是我们只关注那些最亮的恒星。
我们用一个正整数来表示恒星的亮度，数值越大则恒星就越亮，恒星的亮度最暗是 1。
现在对于 N 颗我们关注的恒星，有 M 对亮度之间的相对关系已经判明。
你的任务就是求出这 N 颗恒星的亮度值总和至少有多大。

输入格式

第一行给出两个整数 N 和 M。
之后 M 行，每行三个整数 T, A, B，表示一对恒星(A, B)之间的亮度关系。恒星的编号从 1 开始。
如果 T = 1，说明 A 和 B 亮度相等。
如果 T = 2，说明 A 的亮度小于 B 的亮度。
如果 T = 3，说明 A 的亮度不小于 B 的亮度。
如果 T = 4，说明 A 的亮度大于 B 的亮度。
如果 T = 5，说明 A 的亮度不大于 B 的亮度。

输出格式

输出一个整数表示结果。
若无解，则输出 -1。

数据范围

N≤100000,M≤100000

输入样例
5 7
1 1 2
2 3 2
4 4 1
3 4 5
5 4 5
2 3 5
4 5 1
输出样例
11

题目分析

这可以算是差分约束的模板题了，差分约束的主要难点在于如何建图。
在这道题中，我们可以用边(u,v,0)表示v>=u，用边(u,v,1)表示v>u（即v>=u+1）。
这样我们就可以考虑建图了：
T=1 a=b //可以用边(a,b,0)和(b,a,0)表示（即a>=b && b>=a）
T=2 a<b //可以用边(a,b,1)表示
T=3 a>=b //可以用边(b,a,0)表示
T=4 a>b //可以用边(b,a,1) 表示
T=5 a<=b //可以用边(a,b,0) 表示
注意：题目还有一个条件，恒星的最小亮度为1。为了处理这个条件，我们可以设一个超级源点v0，v0与其它所有的点都相连，且边权为1。

这道题要求的是亮度和的最小值，因此我们要求图的最长路（差分约束问题中，求最小值一般用最长路，求最大值一般用最短路）。

然后，我们要再考虑一下什么情况时这道题无解：如果有一些不等式直接产生了矛盾（例如：a>b,b>c,c>a），那么无解。对应到图上之后，我们可以发现：当图上产生了正环的时候，此图无解。

因为这道题的数据范围较大，直接用spfa求环的话会超时。因此我们需要用一个优化：将spfa中的队列改为栈。这样可以帮助我们加快求换的速度。

代码如下

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <map>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <algorithm>
#define LL long long
#define ULL unsigned long long
#define PII pair<int,int>
#define x first
#define y second
using namespace std;
const int N=1e5+5,INF=0x3f3f3f3f;
int h[N],e[3*N],w[3*N],ne[3*N],idx;
LL dist[N],cnt[N];
bool st[N];
void add(int a,int b,int c)
{
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
bool spfa(int n)
{
    memset(dist,-0x3f,sizeof dist);		//求的是最长路，因此dist初始化为最大值
    stack<int> q;		//用栈替换队列
    dist[0]=0;
    q.push(0);
    st[0]=true;
    while(q.size())
    {
        int u=q.top();
        q.pop();
        st[u]=false;
        for(int i=h[u];~i;i=ne[i])
        {
            int v=e[i];
            if(dist[v]<dist[u]+w[i])		//比较原dist[v]与新的dist[v]的值
            {
                dist[v]=dist[u]+w[i];		//更新dist[v]
                cnt[v]=cnt[u]+1;			//更新迭代次数
                if(cnt[v]>=n+1) return false;//如果迭代次数大于n+1(加了一个超级源点v0)，则说明有环
                if(!st[v])
                {
                    q.push(v);
                    st[v]=true;
                }
            }
        }
    }
    return true;
}
int main()
{
    memset(h,-1,sizeof h);
    int n,m;
    scanf("%d %d",&n,&m);
    while(m--)				//建图
    {
        int a,b,x;
        scanf("%d %d %d",&x,&a,&b);
        if(x==1) add(a,b,0),add(b,a,0);		//上述的几种情况
        else if(x==2) add(a,b,1);
        else if(x==3) add(b,a,0);
        else if(x==4) add(b,a,1);
        else add(a,b,0);
    }
    for(int i=1;i<=n;i++) add(0,i,1);		//建立超级源点
    if(spfa(n))
    {
        LL ans=0;			//答案可能会爆int
        for(int i=1;i<=n;i++) ans+=dist[i];
        printf("%lld\n",ans);
    }
    else puts("-1");			//如果存在环，则输出-1
    return 0;
}