判断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 =  + ;
 const int INF = <<;
 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=; 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=; i<n; ++i)
         for(j=; j<m; ++j)
             relax(g[j].u,g[j].v,g[j].weight);

     for(i=; 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== && m==)
             break;
         init(n);
         for(i=; i<m; ++i)
         {
             scanf("%d%d",&g[i].u,&g[i].v);
             g[i].weight = -;//把权值全部改为负的，然后判断是不是存在负环
             if(g[i].u==)
                 dist[g[i].v] = -;
         }
         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 =  + ;
 vector<int> g[N];
 int start;
 bool vis[N],flag;
 void dfs(int u)
 {
     if(flag)
         return;
     for(int i=;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== && m==)
             break;
         for(i=; i<n; ++i)
             g[i].clear();
         for(i=; i<m; ++i)
         {
             scanf("%d%d",&u,&v);
             g[u].push_back(v);
         }
         flag = false;
         for(i=; i<n; ++i)
         {
             memset(vis,,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 =  + ;
 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=; i<=n; ++i)
         if(in[i]==)
             st.push(i);
     while(!st.empty())
     {
         u = st.top();
         cnt++;
         st.pop();
         for(i=; i<g[u].size(); ++i)
         {
             --in[g[u][i]];
             if(in[g[u][i]]==)
                 st.push(g[u][i]);

         }
     }
 }
 void init(int n)
 {
     cnt = ;
     for(int i=; i<=n; ++i)
     {
         g[i].clear();
         add[i] = in[i] = ;
     }
 }
 int main()
 {
     int n,m,i,u,v;
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         if(n== && m==)
             break;
         init(n);
         for(i=; 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");
     }
 }