考研机试第七天

（6）拓扑排序
拓扑排序满足的三个条件：（1）有向无环图DAG（2）顶点排成线性队列（3）序列中U始终排在V的前面

问题13：有N个比赛队（1<=N<=500）,依次以编号1,2,3…N进行比赛，比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即P1赢P2，用P1，P2表示，排名时P1在P2之前。编程确定排名。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int MAXN = 500 + 10;
vector<int> graph[MAXN];//邻接链表，只需保存与其临接的结点编号即可，所以为int型
int inDegree[MAXN];//每个结点的入度
vector<int> TopologicalSort(int n){
vector<int> topology;
    priority_queue<int,vector<int>,greater<int>> node;//用小顶堆存储结点值不为0 的结点
    for(int i = 1;i <= n;++i){
       if(inDegree[i] == 0){
         node.push(i);
        }
      }
      while(!node.empty()){
           int u = node.top();
           node.pop();
           topology.push_back(u);
           for(int i = 0;i < graph[u].size();++i){
              int v = graph[u][i];
              inDegree[v]--;
              if(inDegree[v] == 0){
                 node.push[v];
              }
           }
        }
        return topology;
}

int main(){
    int n,m;
    while(scanf("%d%d",&n,&m) != EOF){
         memset(graph,0,sizeof(graph));
         memset(inDegree,0,sizeof(inDegree));
         while(m--){
             int from,to;
             scanf("%d%d",&from,&to);
             graph[from].push_back(to);
             inDegree[to]++;
          }
          vector<int> answer = TopologicalSort(n);
          for(int i = 0;i < answer.size();++i){
              if(i == 0){
                 printf("%d",answer[i]);
               }else{
                    printf(" %d",answer[i]);
               }
           }
           printf("\n");
     }
}

问题14：在一个QQ群里有许多师徒关系，如A是B的师傅，同时B是A的徒弟，一个师傅可能有许多徒弟，一个徒弟也可能许多不同的师傅。输入给出该群里所有的师徒关系，问是否存在这样一种非法的情况：以三个人为例，即A是B的师傅，B是C的师傅，C又反过来是A的师傅。若我们将该群里所有人都抽象成图上的结点，将所有的师徒关系抽象成有向边（由师傅指向徒弟），该实际问题就转化为一个数学问题——该图上是否存在一个环，即判断该图是否为有向无环图（DAG）。

无论何时，当判断某个图是否为DAG时，第一个想到的就是拓扑排序

#include<stdio.h>
#include<vector>
#include<queue>
using namespace std;
vector<int> edge[501];//邻接链表，因为不存在权值，只需保存编号即可
queue<int> Q;//保存入度为0的结点的队列
int main(){
    int inDegree[501];//结点入度
    int n,m;
    while(scanf("%d%d",&n,&m) != EOF){
         if(n ==0 &&m == 0) break;
         for(int i = 0;i < n;i++){
            inDegree[i] = 0;//初始化所有入度均为0
            edge[i].clear();//清空邻接链表
         }
         while(m--){
              int a,b;
              scanf("%d%d",&a,&b);//读入一个由a指向b的有向边
              inDegree[b]++;//又出现一条由弧头指向b的边，累加结点b的入度
              edge[a].push_back(b);//将b加入a的邻接链表
          }
          while(Q.empty() == false) Q.pop();//清空队列中所有的元素（可能为上一组遗留的数据）
          for(int i = 0;i < n;i++){
             if(inDegree[i] == 0) Q.push(i);//若结点入度为0，则将其放入队列
          }
          int cnt = 0;初始值为0，用于累加结点b的入度
          while(Q.empty() == false){
              int nowP = Q.front();//读出对头结点编号（若要求出确定的拓扑次序，则将该点紧接着放在已经确定的拓扑序列之后）
              Q.pop();
              cnt++;//被确定的结点个数加一
              for(int i = 0;i < deDegree[nowP].size();i++){//将该结点以及以其为弧尾的所有边去除
                 inDegree[edge[nowP][i]]--;//去除某条边后，该边所指后继结点入度减一
                 if(inDegree[edge[nowP][i]==0)[
                    Q.push(edge[nowP][i]);
                 }
               }
           }
           if(cnt == n) puts("YES");
           else puts("NO");
       }
       return 0;
}

时间复杂度为O(N+E)

（7）关键路径
AOV网：（1）不带权值有向无环图（2）用图中顶点表示活动
AOE网：（1）带有权值有向无环图（2）用图中边表示活动

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<cstring>
#include<climits>
using namespace std;
const int MAXN = 1000+1;
struct Edge{
     int to;
     int length;
     Edge(int t,int l):to(t),length(l){}
};

vector<Edge> graph[MAXN];
int earliest[MAXN];
int lastest[MAXN];
int inDegree[MAXN];

void CriticalPath(int n){
     vector<int> topology;
     queue<int> node;
     for(int i = 0;i < n;++i){
        if(inDegree[i] == 0){
           node.push[i];
           earliest[i] = 1;
         }
      }
      while(!node.empty()){
          int u = node.front();
          node.pop();
          topology.push_back(u);
          for(int  i = 0;i < graph[u].size();++i){
             int v = graph[u][i].to;
             int l = graph[u][i].length;
             earliest[v] = max(earliest[v],earliest[u] + l);
             inDegree[v]--;
             if(inDegree[v] == 0){
                node.push(v);
              }
            }
         }