算法学习笔记（二）拓扑排序

一、什么是拓扑排序

对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。

即所排成的线性序列满足下列条件：

        1.每个顶点只出现一次；

        2.若无向图中存在一条由u到v的路径，那么在序列中u在v的前面。

只有有向无环图才存在拓扑排序，对于有环图，会存在无限循环排序的情况。例如下面这种：

如图是一个有向无环图，我们可以采用如下的方法来写出它的拓扑排序 ：

1.从图中选择一个入度为0的点并输出

2.删除该点和以它为起点的边

3.重复1 2的过程直到图为空或不存在度为0的点（后者可以判断有无环）

很显然  这张图我们可以得到的拓扑排序后得结果为{1,2,4,3,5,6}。

一个无向图中可以有一个或多个拓扑排序序列，比如我们将上图4→3的边删掉

就会发现  出现了两种拓扑排序分别为{1,3}和{1,2,4,6}。

二、拓扑排序的实现 

首先我们要维护一个入度为0的顶点集合

存储图  我们可以用邻接表和邻接矩阵

邻接表方式

#include<iostream>
#include <list>
#include <queue>
using namespace std;

/************************类声明************************/
class Graph
{
    int V;             // 顶点个数
    list<int> *adj;    // 邻接表
    queue<int> q;      // 维护一个入度为0的顶点的集合
    int* indegree;     // 记录每个顶点的入度
public:
    Graph(int V);                   // 构造函数
    ~Graph();                       // 析构函数
    void addEdge(int v, int w);     // 添加边
    bool topological_sort();        // 拓扑排序
};

/************************类定义************************/
Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];

    indegree = new int[V];  // 入度全部初始化为0
    for(int i=0; i<V; ++i)
        indegree[i] = 0;
}

Graph::~Graph()
{
    delete [] adj;
    delete [] indegree;
}

void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w); 
    ++indegree[w];
}

bool Graph::topological_sort()
{
    for(int i=0; i<V; ++i)
        if(indegree[i] == 0)
            q.push(i);         // 将所有入度为0的顶点入队

    int count = 0;             // 计数，记录当前已经输出的顶点数 
    while(!q.empty())
    {
        int v = q.front();      // 从队列中取出一个顶点
        q.pop();

        cout << v << " ";      // 输出该顶点
        ++count;
        // 将所有v指向的顶点的入度减1，并将入度减为0的顶点入栈
        list<int>::iterator beg = adj[v].begin();
        for( ; beg!=adj[v].end(); ++beg)
            if(!(--indegree[*beg]))
                q.push(*beg);   // 若入度为0，则入栈
    }

    if(count < V)
        return false;           // 没有输出全部顶点，有向图中有回路
    else
        return true;            // 拓扑排序成功
}

邻接矩阵方式

mp[i][j]=0,表示节点i和j没有关联;mp[i][j]=1,表示存在边<i,j>,并且j的入度加1;
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#define MAX 100
#include<cstring> 
using namespace std;
//n:关联的边数，m:节点数
void toposort(int mp[MAX][MAX],int indegree[MAX],int m)
{
    int i,j,k;
    printf("该DAG的拓扑序列为：");
    for(i=1;i<=m;i++) //遍历m次
    {
        for(j=1;j<=m;j++) //找出入度为0的节点
        {
            if(indegree[j]==0)
            {
                indegree[j]--;
                
                cout<<j<<"  ";
                for(k=1;k<=m;k++) //删除与该节点关联的边
                {
                    if(mp[j][k]==1)
                    {
                        indegree[k]--;
                    }
                }
                break;
            }
        }
    }
}
int main()
{
    int n,m; //n:关联的边数，m:节点数
    while(scanf("%d %d",&n,&m)==2&&n!=0)
    {
        int i;
        int x,y;
        int mp[MAX][MAX]; //邻接矩阵
        int indegree[MAX]; //入度
        memset(mp,0,sizeof(mp));
        memset(indegree,0,sizeof(indegree));
        for(i=1;i<=n;i++)
        {
            scanf("%d %d",&x,&y);
            if(!mp[x][y])
            {
                mp[x][y]=1;
                indegree[y]++;
            }
        }
        toposort(mp,indegree,m);
    }
    return 0;
}

例题

hdu1285

Problem Description
有N个比赛队（1<=N<=500），编号依次为1，2，3，。。。。，N进行比赛，比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即P1赢P2，用P1，P2表示，排名时P1在P2之前。现在请你编程序确定排名。
Input
输入有若干组，每组中的第一行为二个数N（1<=N<=500），M；其中N表示队伍的个数，M表示接着有M行的输入数据。接下来的M行数据中，每行也有两个整数P1，P2表示即P1队赢了P2队。
Output
给出一个符合要求的排名。输出时队伍号之间有空格，最后一名后面没有空格。
其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。
Sample Input
4 3
1 2
2 3
4 3
Sample Output
1 2 4 3

题意：  给N个比赛结果，比赛结果呈现为有向图，输出拓扑排名

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#define MAX 100
#include<cstring> 
using namespace std;
//n:关联的边数，m:节点数
void toposort(int mp[MAX][MAX],int indegree[MAX],int m)
{
    int i,j,k;
    
    for(i=1;i<=m;i++) //遍历m次
    {
        for(j=1;j<=m;j++) //找出入度为0的节点
        {
            if(indegree[j]==0)
            {
                indegree[j]--;
                
                cout<<j<<" ";
                for(k=1;k<=m;k++) //删除与该节点关联的边
                {
                    if(mp[j][k]==1)
                    {
                        indegree[k]--;
                    }
                }
                break;
            }
        }
    }
}
int main()
{
    int n,m; 
  	 scanf("%d %d",&n,&m);
        int i;
        int x,y;
        int mp[MAX][MAX]; //邻接矩阵
        int indegree[MAX]; //入度
        memset(mp,0,sizeof(mp));
        memset(indegree,0,sizeof(indegree));
        for(i=1;i<=m;i++)
        {
            scanf("%d %d",&x,&y);
            if(!mp[x][y])
            {
                mp[x][y]=1;
                indegree[y]++;
            }
        }
        toposort(mp,indegree,n);
    
    return 0;
}