图论之拓扑排序

拓扑排序
1定义：根据一定的顺序进行排序，
2表示，邻接链表，邻接矩阵
3实现：
一：普通的方法每次寻找入度为一的点，然后输出
二：BFS实现
三：DFS实现
4性质：
性质
1、 拓扑排序在有向无环图中才能排出有效的序列，否则能判断该有向图有环。
2、如果输入的有向图中的点,不存在入度为0的点,则该有向图存在回路
3、如果存在的入度为0的点大于一个,则该有向图肯定不存在一个可以确定的拓扑序列但并不妨碍拓扑排序 
4.拓扑排序还有一个重要的功能就是判断节点是一条链，还是在某个节点出现了分叉
核心程序：
vector<int>g[N];//邻接表存储
int vis[N],topo[N],cnt;


bool dfs(int u)
{
    vis[u] = -1;//-1用来表示顶点u正在访问
    for(int i = 0 ; i < g[u].size() ; i ++)
    {
        if(vis[g[u][i]] == -1)//表示这个点进入了两次，肯定出现了环
            return false;
        else if(vis[g[u][i]] == 0)
        {
            dfs(g[u][i]);
        }
    }
    vis[u] = 1;
    topo[cnt++] = u;//放到结果数组里，输出的时候记得倒序输出，（回溯的原因）
    return true;
}


bool toposort(int n)
{
    memset(vis,0,sizeof(vis));
    for(int i = 1 ; i <= n ; i ++)
    {
        if(!vis[i])
        {
            if(!dfs(i)) return false;//huan
        }
    }
    return true;
}


非递归实现：
for(i=1;i<=n;i++)//外层循环n次，in[]数组用来记录每个点的入度
{
j=1;
while(in[j]!=0) j++;//从第一个节点开始找到一个节点入度为0的节点
ans[i]=j;//存储答案
in[j]=-1;//将该节点的入度更新为-1
for( k=1;k<=n;k++)//将所有与节点j相连的节点的入度值全部减1
if(vis[j][k]==1) in[k]--;

}

几个例题：

HDU1285

import java.util.Scanner;

//找到一个即可退出
public class Main {
static int N,M;
static boolean map[][]=new boolean [510][510];
static boolean used[]=new boolean[510];
static int inc[]=new int[510];
static int ans[];
static void init()
{
	for(int i=0;i<510;i++)
	{
		used[i]=false;
		inc[i]=0;
		for(int j=0;j<510;j++)
			map[i][j]=false;
	}
	
}

static void build()
{
	
	Scanner in=new Scanner(System.in);
	while(in.hasNext())
	{
		
		N=in.nextInt();
		M=in.nextInt();
		ans=new int[N];
		init();
		for(int i=1;i<=M;i++)
		{
			int a=in.nextInt();
			int b=in.nextInt();
			if(!map[a][b])
			{
				map[a][b]=true;
				inc[b]++;
			}
		}
		topo_sort();
		
	}
	
}

static void topo_sort()
	{
		
		int index=0;
		while(index<N)
		{
			int i;
			for( i=1;i<=N;i++)
			{
				if(inc[i]==0&&!used[i])
				{
					break;
				}
			}
			
			used[i]=true;
			ans[index]=i;
			index++;
			for(int j=1;j<=N;j++)
			{
				if(map[i][j])
					inc[j]--;
			}
		}
		
		for(int i=0;i<N-1;i++)
			System.out.print(ans[i]+" ");
		System.out.println(ans[N-1]);
	}
	public static void main(String[] args) {
		build();
	}
	
}

//============================================================================
// Name        : 拓扑排序模版.cpp
// Author      : xinge
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#define MAXN 501
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int topo[501];
int graph[501][501];
int a,b;
int n,m;
int toposort(int n,int mat[][MAXN],int* ret)
{
    int d[MAXN],i,j,k; 
    for (i=0;i<n;i++)
        for (d[i]=j=0;j<n;d[i]+=mat[j++][i]); 
    for (k=0;k<n;ret[k++]=i)
    {
        for (i=0;d[i]&&i<n;i++); 
        if (i==n)
            return 0;
        for (d[i]=-1,j=0;j<n;j++)
            d[j]-=mat[i][j];
    }
    return 1;
}
int main()
{
    while(cin>>n>>m)
    {
        memset(graph,0,sizeof graph);
        for(int i=1;i<=m;i++)
        {
            cin>>a>>b;
            graph[a-1][b-1]=1;
        }
        toposort(n,graph,topo);
        for(int i=0;i<n;i++)
        {
            if(i)
                cout<<' ';
            cout<<topo[i]+1;
        }
        cout<<endl;
    }
}

hdu2094

import java.util.Scanner;
import java.util.TreeMap;


public class Main {
	static int M;
	static int maxn=1010;
	static int inc[]=new int[maxn];
	static boolean map[][]=new boolean[maxn][maxn];
	static boolean used[]=new boolean[maxn];
	static void init()
	{
		for(int i=0;i<maxn;i++)
		{
			inc[i]=0;
			used[i]=false;
			for(int j=0;j<maxn;j++)
				map[i][j]=false;
		}
	}
	
	static void build()
	{
		Scanner in=new Scanner(System.in);
		while((M=in.nextInt())!=0)
		{
			init();
			TreeMap<String,Integer>lis=new TreeMap<String,Integer>();
			int index=1;
			for(int i=1;i<=M;i++)
			{
				String data1=in.next();
				String data2=in.next();
				if(!lis.containsKey(data1))
				{
					lis.put(data1, index);
					index++;
				}
				if(!lis.containsKey(data2))
				{
					lis.put(data2, index);
					index++;
				}
				int x=lis.get(data1);
				int y=lis.get(data2);
				if(!map[x][y])
				{
					inc[y]++;
					map[x][y]=true;
				}
			}
			int len=lis.size();
			if(topo_sort(len))
				System.out.println("Yes");
			else
				System.out.println("No");
			
		}
	}
	
	static boolean topo_sort(int len)
	{
		boolean flag=false;
			for(int i=1;i<=len;i++)
			{
				if(!used[i]&&inc[i]==0)
				{
					if(!flag)
					{
						flag=true;
					}else
					{
						return false;
					}
					
				}
			}
		return flag;
	}
	
public static void main(String[] args) {
	build();
}
}

注意事项

：一：当全部的点的关系依然确定时：
一定要注意在拓扑排序的过程中，一个图有下面几种情况，每一种都要注意
1.图的入度的点中若没有入度为0的点，则已成环
2.若入度为0的点数不只不止一个则，没有拓扑序
3.入度为0的点只有1个，则已形成
    二 ：当一个一个的输入然后判断时：
1.入度为0的点又不只 一个时，只能是不确定是否存在拓扑序
2.当没有入度为0的点时，则可以确定一定不存在，因为已经成环
3.只有一个入度为0的点时，则可以确定有拓扑序

PS：未完待续