数据结构之图的最短路径和拓扑排序及应用

一、图的最短路径

1. 图的最短路径问题指的是从给定顶点到其余各顶点的最短路径，常用迪杰斯特拉算法求解。
2. 例题：

DS图—图的最短路径

题目描述
给出一个图的邻接矩阵，输入顶点v，用迪杰斯特拉算法求顶点v到其它顶点的最短路径。
输入
第一行输入t，表示有t个测试实例
第二行输入顶点数n和n个顶点信息
第三行起，每行输入邻接矩阵的一行，以此类推输入n行
第i个结点与其它结点如果相连则为距离，无连接则为0，数据之间用空格
隔开。第四行输入v0，表示求v0到其他顶点的最短路径距离
以此类推输入下一个示例
输出
对每组测试数据，输出：
每行输出v0到某个顶点的最短距离和最短路径
每行格式：v0编号-其他顶点编号-最短路径值----[最短路径]。没有路径输出：v0编号-其他顶点编号–1。具体请参考示范数据
样例输入
2
5 0 1 2 3 4
0 5 0 7 15
0 0 5 0 0
0 0 0 0 1
0 0 2 0 0
0 0 0 0 0
0
6 V0 V1 V2 V3 V4 V5
0 0 10 0 30 100
0 0 5 0 0 0
0 0 0 50 0 0
0 0 0 0 0 10
0 0 0 20 0 60
0 0 0 0 0 0
V0
样例输出
0-1-5----[0 1 ]
0-2-9----[0 3 2 ]
0-3-7----[0 3 ]
0-4-10----[0 3 2 4 ]
V0-V1–1
V0-V2-10----[V0 V2 ]
V0-V3-50----[V0 V4 V3 ]
V0-V4-30----[V0 V4 ]
V0-V5-60----[V0 V4 V3 V5 ]

• 代码：

#include<iostream>
using namespace std;
 
#define MaxWeight 1000
 
class Map{
    int vertexNum;
    int **matrix;
    string *vertex;
public:
    Map();
    ~Map();
    void Dijkstra(string start);
};
Map::Map(){
    cin >> vertexNum;
    vertex = new string[vertexNum];
    for(int i=0; i<vertexNum; i++){
        cin >> vertex[i];
    }
    matrix = new int*[vertexNum];
    for(int i=0; i<vertexNum; i++){
        matrix[i] = new int[vertexNum];
        for(int j=0; j<vertexNum; j++){
            cin >> matrix[i][j];
             
            if(matrix[i][j] == 0){
                matrix[i][j] = MaxWeight;
            }
        }
    }
}
Map::~Map(){
    delete[] vertex;
    for(int i=0; i<vertexNum; i++){
        delete[] matrix[i];
    }
    delete[] matrix;
}
void Map::Dijkstra(string start){
    int p1;
    for(int i=0; i<vertexNum; i++){
        if(vertex[i] == start){
            p1 = i;
            break;
        }
    }
     
    bool *visited = new bool[vertexNum];
    string *path = new string[vertexNum];
    int *D = new int[vertexNum];
    int min, p2;
     
    for(int i=0; i<vertexNum; i++){
        visited[i] = false;
        path[i] = start + " "; //路径初始化
        D[i] = MaxWeight;
        if(matrix[p1][i] < MaxWeight){
            D[i] = matrix[p1][i];
            path[i] += vertex[i] + " ";
        }
    }
     
    visited[p1] = true;
     
    for(int i=0; i<vertexNum-1; i++){
        min = MaxWeight;
        for(int j=0; j<vertexNum; j++){
            if(visited[j] == false && D[j] < min){
                p2 = j;
                min = D[j];
            }
        }
        visited[p2] = true;
         
        for(int j=0; j<vertexNum; j++){
            if(visited[j] == false && matrix[p2][j] + D[p2] < D[j]){ 
            	//注意是起点到p2的距离加上p2到该点的距离进行比较
                D[j] = matrix[p2][j] + D[p2];
                path[j] = path[p2] + vertex[j] + " ";
            }
        }
    }
     
    for(int i=0; i<vertexNum; i++){
        if(i == p1){
            continue;
        }else{
            if(D[i] == MaxWeight){
                cout << vertex[p1] << "-" << vertex[i] << "--" << 1 << endl;
            }else{
                cout << vertex[p1] << "-" << vertex[i] << "-" << D[i] << "----[" << path[i] << "]" << endl;               
            }
        }
    }
}
 
int main(){
    int t;
    cin >> t;
    while(t--){
        Map m;
        string s;
        cin >> s;
        m.Dijkstra(s);
    }
     
    return 0;
}

二、拓扑排序

1. 有向无环图的拓扑序列是唯一的，常用队列进行拓扑排序。
2. 例题：

图综合练习–拓扑排序

题目描述
已知有向图，顶点从0开始编号，求它的拓扑有序序列。
拓扑排序算法：给出有向图邻接矩阵
1.逐列扫描矩阵，找出入度为0且编号最小的顶点v
2.输出v，并标识v已访问
3.把矩阵第v行全清0
重复上述步骤，直到所有顶点输出为止
–程序要求–
若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio
不允许使用第三方对象或函数实现本题的要求

输入
第一行输入一个整数t，表示有t个有向图
第二行输入n，表示图有n个顶点
第三行起，输入n行整数，表示图对应的邻接矩阵
以此类推输入下一个图的顶点数和邻接矩阵
输出
每行输出一个图的拓扑有序序列
样例输入
2
5
0 1 0 1 1
0 0 1 0 0
0 0 0 0 1
0 0 1 0 0
0 0 0 0 0
7
0 0 0 0 0 0 0
1 0 1 1 0 0 0
1 0 0 0 0 0 0
1 0 1 0 0 0 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 0 0 1 0 1 0
样例输出
0 1 3 2 4
4 6 5 1 3 2 0

• 代码：

#include<iostream>
using namespace std;
 
struct Node{
    int index;
    Node *next;
    Node(){
        next = NULL;
    }
};
 
class queue{
    Node *head;
public:
    queue(){
        head = new Node;
    }
    ~queue(){
    	Node *p, *s;
    	p = head;
    	while(p){
    		s = p->next;
    		delete p;
    		p = s;
    	}
    }
    void push(int i){
        Node *p = head;
        Node *s = new Node;
        s->index = i;
         
        while(p->next){
            p = p->next;
        }
         
        p->next = s;
    }
    int front(){
        return head->next->index;
    }
    void pop(){
        Node *p = head->next;
        head->next = p->next;
        delete[] p;
    }
    bool isEmpty(){
        if(head->next == NULL){
            return true;
        }else{
            return false;
        }
    }
};
 
class Map{
    int vertexNum;
    int **matrix;
    string *vertex;
    int *inD;
public:
    Map();
    ~Map();
    void TopoLogicalSort();
};
Map::Map(){
    cin >> vertexNum;
    matrix = new int*[vertexNum];
    inD = new int[vertexNum]();
     
    for(int i=0; i<vertexNum; i++){
        matrix[i] = new int[vertexNum];
        for(int j=0; j<vertexNum; j++){
            cin >> matrix[i][j];
             
            if(matrix[i][j] != 0){
                inD[j]++;
            }
        }
    }
}
Map::~Map(){
    for(int i=0; i<vertexNum; i++){
        delete[] matrix[i];
    }
    delete[] matrix;
    delete[] inD;
}
void Map::TopoLogicalSort(){
    queue Q;
    int *visited = new int[vertexNum]();
     
    for(int i=0; i<vertexNum; i++){
        if(inD[i] == 0){
            Q.push(i);
            visited[i] = 1;
        }
    }
     
    int v;
    while(!Q.isEmpty()){
        v = Q.front();
        Q.pop();
         
        cout << v << ' ';
         
        for(int i=0; i<vertexNum; i++){
            if(matrix[v][i]){
                inD[i]--;
            }
            if(inD[i] == 0 && visited[i] == 0){
                Q.push(i);
                visited[i] = 1;
            }
        }
    }
     
    cout << endl;
    delete[] visited;
}
 
int main(){
    int t;
    cin >> t;
    while(t--){
        Map m;
        m.TopoLogicalSort();
    }
     
    return 0;
}