有向图的强连通分量之：【强连通分量代替差分约束的条件：分量中正边】【强连通分量如何判断是否存在正环(靠分量中边的权重是否大于0)】【有正环表示无解】

 

 

 

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=100010;
/*边数建多少呢？
上述的M是十万级别的，
一共有 M 个关系，每个关系呢，要建立两条边，
所以是  二十万，
再加上0号点向每个点连的一条边
所以总共会有  三十万条边 
*/
//const int M=300010;
//由于我们要建两遍图，第一遍是原图，第二遍是拓扑图（为了跑最长路），所以应该再上述的基础上开两倍
const int M=600010;
int n,m;
int e[M],ne[M],h[N],hs[N],w[M],idx;
int dfn[N],low[N],timestamp;
int stk[N],top;
bool in_st[N];
int id[N],scc_cnt;
int siz[N];
int dist[N];


void add(int h[],int a,int b,int c)
{
    e[idx]=b;
    ne[idx]=h[a];
    w[idx]=c;
    h[a]=idx++;
}


void tarjan(int u)
{
    dfn[u]=low[u]=++timestamp;
    stk[++top]=u;
    in_st[u]=true;

    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!dfn[j])
        {
            tarjan(j);
            low[u]=min(low[u],low[j]);
        }
        else if(in_st[j])
        {
            low[u]=min(low[u],dfn[j]);
        }
    }

    if(dfn[u]==low[u])
    {
        ++scc_cnt;
        int y;

        do
        {
            y=stk[top--];
            in_st[y]=false;
            id[y]=scc_cnt;
            siz[scc_cnt]++;
        }while(y!=u);
    }
}


int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    memset(hs,-1,sizeof hs);

    for(int i=1;i<=n;i++)
    {
        add(h,0,i,1);
    }

    while(m--)
    {
        int t,a,b;
        scanf("%d%d%d",&t,&a,&b);
        if(t==1) add(h,b,a,0),add(h,a,b,0);
        else if(t==2) add(h,a,b,1);
        else if(t==3) add(h,b,a,0);
        else if(t==4) add(h,b,a,1);
        else if(t==5) add(h,a,b,0);

    }


    tarjan(0);


    //记住了，我们这里的图要算0号点
    bool success=true;  
    //判断一下有无解，用边是否为正来判断 ，意味着存在正环无解
    for(int i=0;i<=n;i++)
    {
        for(int j=h[i];j!=-1;j=ne[j])
        {
            int k=e[j];
            int a=id[i];
            int b=id[k];
            if(a==b)
            {
                if(w[j]>0)
                {
                success=false; //表示存在正环
                break;
                }
            }
            else if(a!=b)
            {
                add(hs,a,b,w[j]);
            }
        }
        if(!success) break;
    }

    if(!success) puts("-1");
    else
    {
        //根据拓扑序递推来实现 DP

        for(int i=scc_cnt;i;i--)
        for(int j=hs[i];j!=-1;j=ne[j])
        {
            int k=e[j];
            dist[k]=max(dist[k],dist[i]+w[j]);
        }


        LL res=0;
        for(int i=1;i<=scc_cnt;i++)
        {
            res+=(LL)dist[i]*siz[i];
        }


        printf("%lld\n",res);
    }


    return 0;
}