判断DAG图

拓扑排序O(E)， bellman O(VE)   ， 使用邻接表的dfs O(V+E) ，floyd O(N*N*N)

bellman算法只能判断是否存在负环。

所以可以先把权值全部设为-1

#include <stdio.h>
#include <string.h>
#include <vector>
#include <stack>
using namespace std;
const int N = 10000 + 10;
const int INF = 1<<30;
struct node
{
    int u,v,weight;
}g[N+N];
int dist[N];
inline int max(const int &a, const int &b)
{
    return a < b ? b : a;
}

void init(int n)
{
    for(int i=0; i<=n; ++i)
    {
    
        dist[i] = INF;
    }
}

void relax(int u, int v, int weight)
{
    if(dist[v]  > dist[u] + weight)
        dist[v] = dist[u] + weight;    
}
bool bell(int n, int m)
{
    int i,j;
    for(i=1; i<n; ++i)
        for(j=0; j<m; ++j)
            relax(g[j].u,g[j].v,g[j].weight);
    
    for(i=0; i<m; ++i)
        if(dist[g[i].v] > dist[g[i].u] +g[i].weight)
            return true;
    return false;
}
int main()
{
    int n,m,i,u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0 && m==0)
            break;
        init(n);
        for(i=0; i<m; ++i)
        {
            scanf("%d%d",&g[i].u,&g[i].v);
            g[i].weight = -1;//把权值全部改为负的，然后判断是不是存在负环
            if(g[i].u==0)
                dist[g[i].v] = -1;
        }
        if(bell(n,m))
            puts("NO");
        else
            puts("YES");
    }
}

枚举起点进行dfs，如果能遇到顶点和起点相同，则存在环

#include <stdio.h>
#include <string.h>
#include <vector>
#include <stack>
using namespace std;
const int N = 10000 + 10;
vector<int> g[N];
int start;
bool vis[N],flag;
void dfs(int u)
{
    if(flag)
        return;
    for(int i=0;i<g[u].size(); ++i)
    {
        int v = g[u][i];
        if(v==start)
        {
            flag = true;//有环
            return;
        }
        if(!vis[v])
        {
            vis[v] = true;
            dfs(v);
        }
    }
}
int main()
{
    int n,m,i,u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0 && m==0)
            break;
        for(i=0; i<n; ++i)
            g[i].clear();
        for(i=0; i<m; ++i)
        {
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
        }
        flag = false;
        for(i=0; i<n; ++i)
        {
            memset(vis,0,sizeof(vis));
            vis[i] = true;
            start = i;
            dfs(i);
            if(flag)
                break;
        }
        if(flag)
            puts("NO");
        else
            puts("YES");
    }
}

拓扑排序如果能生成n个顶点序列，那么说明是GAG图

#include <stdio.h>
#include <string.h>
#include <vector>
#include <stack>
using namespace std;
const int N = 10000 + 10;
vector<int> g[N];
stack<int> st;
int in[N],add[N],cnt;
inline int max(const int &a, const int &b)
{
    return a < b ? b : a;
}
void topSort(int n, int m)
{    
    int u,i;
    for(i=1; i<=n; ++i)
        if(in[i]==0)
            st.push(i);
    while(!st.empty())
    {
        u = st.top();
        cnt++;
        st.pop();
        for(i=0; i<g[u].size(); ++i)
        {
            --in[g[u][i]];
            if(in[g[u][i]]==0)
                st.push(g[u][i]);
        
                
        }
    }
}
void init(int n)
{
    cnt = 0;
    for(int i=1; i<=n; ++i)
    {
        g[i].clear();
        add[i] = in[i] = 0;
    }
}
int main()
{
    int n,m,i,u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0 && m==0)
            break;
        init(n);
        for(i=0; i<m; ++i)
        {
            scanf("%d%d",&u,&v);
            u++;
            v++;
            g[u].push_back(v);
            in[v]++;
        }
        topSort(n,m);
        if(cnt==n)//能生成n个顶点的序列，说明是DAG图
        {
            puts("YES");
        }
        else
            puts("NO");
    }
}