拓扑排序

拓扑排序是将一个DAG图的所有顶点排成一个线性序列，使得图中任意一对顶点（u，v）
若存在边，则u在线性排列中出现在v之前的排列方式
(1)算法描述：

(a)从网中选择一个入度为零的顶点输出；

(b)删除该顶点及其于该点有关的所有边；

(c)是否还有入度为零的顶点？若有，执行(a)，否则结束。

用邻接矩阵时间复杂度为O(N*N)，邻接表的时间复杂度为O(E)

 http://acm.hdu.edu.cn/showproblem.php?pid=1285

即输出字典序最小的拓扑排序

#include <stdio.h>
#include <string.h>
#include <stack>
#include <algorithm>
using namespace std;
const int N = 555;
int g[N][N];
int ans[N],in[N];
void topSort(int n, int m)
{
    int i,j,k;
    for(i=1; i<=n; ++i)
        for(j=1; j<=n; ++j)
            if(g[i][j])
                in[j]++;//计算每个点的入度
    for(i=1; i<=n; ++i)
    {
        for(j=1; in[j]&&j<=n; ++j)//找到入度为0的点
                NULL;
        in[j] = -1;
        ans[i]=j;//记录
        for(k=1; k<=n; ++k)
            if(g[j][k])//删边
                in[k]--;
    }    
}
int main()
{
    int n,m,i,u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(g,0,sizeof(g));
        memset(in,0,sizeof(in));
        for(i=0; i<m; ++i)
        {
            scanf("%d%d",&u,&v);
            g[u][v] = 1;
        }
        topSort(n,m);
        for(i=1; i<=n; ++i)
        {
            if(i==1)
                printf("%d",ans[i]);
            else
                printf(" %d",ans[i]);
        }
        puts("");
    }
    return 0;
}

 http://acm.hdu.edu.cn/showproblem.php?pid=2647

给定n个人，m条边

边u->v表示  u的工资要比v高， 每个人的基础工资为888，问总共的工资最少是多少。

可以看做是这么一种情况，把整个图分为若干层，层内的工资相等，层与层之间的工资相差1.

u->v表示u的工资比v高，那么要先确定v才能确定u，那么可以反向建图。

#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();//u出栈，表示u的工资已经确定，那么可以推出u指向的顶点的工资
        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]);
            add[g[u][i]] = max(add[u]+1,add[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)
    {
        init(n);
        for(i=0; i<m; ++i)
        {
            scanf("%d%d",&u,&v);
            g[v].push_back(u);//反向建图
            in[u]++;
        }
        topSort(n,m);
        int ans = 0;
        if(cnt==n)
        {
            for(i=1; i<=n; ++i)
                ans += add[i] + 888;
            printf("%d
",ans);
        }
        else
            printf("-1
");
    }
}

 http://acm.hdu.edu.cn/showproblem.php?pid=2647

给定n个人，m条边

判断图是不是DAG图。 拓扑排序O(E)， bellman O(VE)   ， 使用邻接表的dfs O(V+E) ，floyd O(N*N*N)

其余代码见 http://www.cnblogs.com/justPassBy/p/4342599.html

#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");
    }
}

http://acm.hdu.edu.cn/showproblem.php?pid=1811

根据所给的信息判定能否确定唯一排名。

题目的难点在于=号的处理。  我们可以利用并查集将相等的结点并在一个集合里。然后再使用拓扑排序就可以了。

1、如果每次入栈的结点大于1个，那么拓扑排序不唯一。 这很好理解

2、如果出栈的顶点个数小于总顶点个数，那么存在回路。

#include <stdio.h>
#include <string.h>
#include <vector>
#include <stack>
using namespace std;
const int N = 10000 + 10;
int u[N],v[N];
int in[N],father[N];
char str[N][2];
vector<int> g[N];
stack<int> st;
int ans,cnt;
void init(int n)
{
    ans = cnt = 0;
    for(int i=0; i<=n; ++i)
    {
        in[i] = 0;
        father[i] = i;
        g[i].clear();
    }
}
int topSort(int n, int m)
{
    int i,tmp = 0,flag = 0,k = 0;
    for(i=0; i<n; ++i)
        if(father[i]==i)
        {
            cnt++;
            if(in[i]==0)
            {
                st.push(i);
                tmp++;
            }
            if(tmp>1)//如果一次入栈的结点大于1个，那么就说明拓扑排序不唯一
                flag = 2;
        }
    while(!st.empty())
    {
        int u = st.top();
        st.pop();
        k++;
        tmp = 0;
        for(i=0; i<g[u].size(); ++i)
        {
            int v = g[u][i];
            in[v]--;
            if(in[v]==0)
            {
                tmp++;
                st.push(v);
            }
        }
        if(tmp>1) flag = 2;
    }
    if(k < cnt) flag = 1;//存在回路
    return flag;
}
int find(int x)
{
    if(x == father[x])
        return x;
    return father[x] = find(father[x]);
}
int main()
{
    int n,m,i,ru,rv;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init(n);
        for(i=0; i<m; ++i)
        {    
            scanf("%d%s%d",&u[i],str[i],&v[i]);
            if(str[i][0]=='=')//将相等的结点并在一个集合里
            {
                ru = find(u[i]);
                rv = find(v[i]);
                if(ru!=rv)
                    father[ru] = rv;
            }
        }
        for(i=0; i<n; ++i) find(i);//这样就能用father[i]得到i的父亲
        for(i=0; i<m; ++i)
        {
            if(father[u[i]] == father[v[i]] && str[i][0]!='=')
            {
                ans = 1;
                break;
            }
            else if(str[i][0]=='>')
            {
                g[father[u[i]]].push_back(father[v[i]]);
                in[father[v[i]]]++;
            }    
            else if(str[i][0]=='<')
            {
                g[father[v[i]]].push_back(father[u[i]]);
                in[father[u[i]]]++;
            }
        }
        if(!ans) ans = topSort(n,m);
        if(!ans) puts("OK");
        else if(ans==1) puts("CONFLICT");
        else puts("UNCERTAIN");
    }
    return 0;
}

http://poj.org/problem?id=1094

给定n个点，m条边，

要我们逐步判断随着边的增加，能否确定唯一拓扑排序，或者是否有环。  否则就是不能确定

先判断有没有环，如果有环，输出有环

如果没有环，那么拓扑判断是否能确定唯一排序

#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int N = 30;
int g[N][N],start,n,m,in[N],ans[N];
bool vis[N],vis2[N],hasCircle,confirmSequeue;
void dfs(int u)
{
    for(int i=0; i<n; ++i)
    {
        if(g[u][i]==1)
        {
            if(start==i)
            {
                hasCircle = true;
                return;
            }
            if(!vis2[i])
            {
                vis2[i] = true;
                dfs(i);
            }
            
        }
    }
}
void topSort()
{
    int i,j,k;
    for(i=0; i<n; ++i)
        for(j=0; j<n; ++j)
            if(g[i][j])
                in[j]++;
    int cnt     = 0;
    for(j=0; j<n; ++j)
        if(in[j]==0)
            cnt++;
    if(cnt>1)//不能确定唯一拓扑排序
    {
        confirmSequeue = false;
        return;
    }
    for(i=0; i<n; ++i)
    {
        for(j=0;in[j]&&j<n;++j)
            NULL;
        in[j] = -1;
        ans[i] = j;
        cnt = 0;
        for(k=0; k<n; ++k)
        {
            if(g[j][k])
            {
                in[k]--;
                if(in[k]==0)
                cnt++;
            }    
            if(cnt>1)
            {
                confirmSequeue = false;
                return;
            }    
        }
    }
}
int main()
{
    int i,cnt,u,v,j;
    char str[5];
    while(true)
    {
        scanf("%d%d",&n,&m);
        if(n==0 && m==0) break;
        memset(vis,0,sizeof(vis));
        memset(g,0,sizeof(g));
        hasCircle = false;
        confirmSequeue = true;
        cnt = 0;
        for(i=0; i<m; ++i)
        {
            scanf("%s",str);
            u = str[0] - 'A';
            v = str[2] - 'A';
            g[u][v] = 1;
            if(!vis[u]) {vis[u] = true; cnt++;}
            if(!vis[v]) {vis[v] = true; cnt++;}
            for(j=0; j<n; ++j)//dfs判断是否有环
            {
                memset(vis2,0,sizeof(vis2));
                vis2[j] = true;
                start = j;
                dfs(j);
                if(hasCircle) break;
            }
            if(hasCircle) break;
            if(cnt==n)//有n个顶点的时候才进行拓扑排序
            {
                confirmSequeue = true;
                memset(in,0,sizeof(in));
                topSort();
                if(confirmSequeue)
                    break;
            }
        }
        if(cnt == n && confirmSequeue)
        {
            printf("Sorted sequence determined after %d relations: ",i+1);
            for(j=0; j<n; ++j)
                printf("%c",ans[j]+'A');
            puts(".");
        }    
        else if(hasCircle)
            printf("Inconsistency found after %d relations.
",i+1);
        else
            printf("Sorted sequence cannot be determined.
");
        for(i++;i<m; ++i) 
            scanf("%s",str);
    }
}