西工大数据结构实验NOJ参考代码和分析合集_西工大noj

实验1.1 合并有序数组

//001合并有序数组
#include <bits/stdc++.h>
#define MAXSIZE 20 //数组的最大长度为20
typedef struct	   //定义线性表的顺序存储结构
{
	int elem[MAXSIZE];
	int last = -1;
} SeqList;
 
void inputList(SeqList *la, SeqList *lb) //输入两个线性表
{
	int n, m;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &la->elem[i]);
		la->last++;
	}
	scanf("%d", &m);
	for (int i = 0; i < m; i++)
	{
		scanf("%d", &lb->elem[i]);
		lb->last++;
	}
}
 
void mergeList(SeqList *la, SeqList *lb, SeqList *lc) //合并数组
{
	int ia, ib, ic; //三个数分别指向三个线性表中正在进行数据处理的位置
	ia = 0;
	ib = 0;
	ic = 0;									 //从头开始处理
	while (ia <= la->last && ib <= lb->last) //两个数组都没有处理完数据时
	{
		if (la->elem[ia] <= lb->elem[ib]) //比较当前的两个数，将较小数放入lc中
		{
			lc->elem[ic] = la->elem[ia];
			ia++;
			ic++;
		}
		else
		{
			lc->elem[ic] = lb->elem[ib];
			ib++;
			ic++;
		}
	}
	while (ia <= la->last) //当有一个或两个数组完成了对所有数据的处理，则将没有完成数据处理的数组中剩余的元素依次放入lc中
	{
		lc->elem[ic] = la->elem[ia];
		ia++;
		ic++;
	}
	while (ib <= lb->last)
	{
		lc->elem[ic] = lb->elem[ib];
		ib++;
		ic++;
	}
	lc->last = la->last + lb->last + 1;
}
 
void printList(int length, SeqList *L) //打印线性表
{
	for (int i = 0; i < length; i++)
		printf("%d\n", L->elem[i]);
}
 
int main()
{
	SeqList la, lb, lc;
	inputList(&la, &lb);
	mergeList(&la, &lb, &lc);
	printList(la.last + lb.last + 2, &lc);
	return 0;
}

实验1.2 高精度计算PI值

//002高精度计算PI值
#include <bits/stdc++.h>
 
typedef struct list //定义双向链表
{
    int data;
    struct list *next;
    struct list *prior;
} list;
 
list *Initlist() //初始化双向链表
{
    list *head;
    head = (list *)malloc(sizeof(list));
    head->next = head->prior = head;
    return head;
}
list *Creatlist(list *head) //建立链表
{
    int i;
    list *p;
    p = head;
    for (i = 0; i < 1000; i++)
    {
        list *q = (list *)malloc(sizeof(list));
        q->data = 0;
        q->prior = p;
        p->next = q;
        q->next = head; //第一次循环时此时的head和p是一个东西，目的为把链表画成一个圈
        head->prior = q;
        p = p->next;
    }
    return head;
}
int main()
{
    int n, i, a, b;
    scanf("%d", &n);
    list *number, *sum;
    list *p, *q, *x;
    number = Initlist();
    sum = Initlist();
    number = Creatlist(number);
    sum = Creatlist(sum);
    number->next->data = 2;    //第一位储存2，即2*R(1)=2
    sum->next->data = 2;       //与上同理
    a = 0, b = 0;              //分别是用来暂时存储进位和余数
    for (i = 1; i < 2500; i++) //循环两千次，确保精确度
    {
        p = number->prior;  //做大数乘法时从链表的后方开始
        while (p != number) //大于10则把10位的数字给b，个位数字放入data域中。
        {
            a = p->data * i + b;
            p->data = a % 10;
            b = a / 10;
            p = p->prior;
        }
        b = 0;              //清空b,为除法做准备
        p = p->next;        //大数除法从链表的前方开始
        while (p != number) //若计算出的数字为自然数，则直接放入data域；若等于0,或为小数，则要计算余数并给b。
        {
            a = p->data + b * 10;
            p->data = a / (2 * i + 1);
            b = a % (2 * i + 1);
            p = p->next;
        }
        b = 0;             //清零
        p = number->prior; //大数加法均从末尾开始
        q = sum->prior;
        while (p != number) //大于10进位，并储存个位数，进位数字赋给b。
        {
            a = p->data + q->data + b;
            q->data = a % 10;
            b = a / 10;
            p = p->prior;
            q = q->prior;
        }
    }
    printf("3.");
    x = sum->next->next; //从小数开始输出。
    for (i = 0; i < n; i++)
    {
        printf("%d", x->data);
        x = x->next;
    }
    return 0;
}

实验2.1 稀疏矩阵转置

//003稀疏矩阵转置：一次定位快速转置法
#include <bits/stdc++.h>
#define MAXSIZE 2000
 
typedef struct triple
{				 //定义三元组
	int r, c, e; //三元组的坐标和元素值
} triple;
 
typedef struct matrix
{						  //定义稀疏矩阵
	int m, n, t;		  //稀疏矩阵的行列数和非零元素个数
	triple data[MAXSIZE]; //该稀疏矩阵中的三元组信息  从下标1开始
} matrix;
 
void initMatrixA(matrix *M) //初始化矩阵A
{
	scanf("%d%d", &M->m, &M->n); //输入矩阵信息
	M->t = 0;
	int temp_r, temp_c, temp_e;
	while (true) //输入三元组信息
	{
		scanf("%d", &temp_r);
		getchar();
		scanf("%d", &temp_c);
		getchar();
		scanf("%d", &temp_e);
		getchar();
		if (temp_r == 0 && temp_c == 0 && temp_e == 0)
		{
			break;
		}
		M->t++;
		M->data[M->t].r = temp_r;
		M->data[M->t].c = temp_c;
		M->data[M->t].e = temp_e;
	}
}
 
void initMatrixB(matrix *M, int m, int n, int t) //初始化B矩阵
{
	M->m = n;
	M->n = m;
	M->t = t;
}
 
void transposeMatrix(matrix A, matrix *B) //转置函数
{
	int num[MAXSIZE], pos[MAXSIZE]; //num存储A中每一列非零元素个数，pos记录不同列号对应的开始位置
	for (int col = 0; col < A.n; col++)
	{
		num[col] = 0;
	}
	for (int t = 1; t <= A.t; t++) //统计每一个列号对应的三元组个数
	{
		num[A.data[t].c]++;
	}
	pos[0] = 1;
	for (int col = 1; col < A.n; col++) //计算不同列号对应的开始位置
	{
		pos[col] = pos[col - 1] + num[col - 1];
	}
	for (int p = 1; p <= A.t; p++) //完成转置
	{
		int col = A.data[p].c;
		int q = pos[col];
		B->data[q].r = A.data[p].c;
		B->data[q].c = A.data[p].r;
		B->data[q].e = A.data[p].e;
		pos[col]++;
	}
}
 
void printResult(matrix M) //输出矩阵三元组
{
	for (int i = 1; i <= M.t; i++)
	{
		printf("%d %d %d\n", M.data[i].r, M.data[i].c, M.data[i].e);
	}
}
 
int main()
{
	matrix A, B; //定义待转置矩阵A和输出矩阵B
	initMatrixA(&A);
	initMatrixB(&B, A.m, A.n, A.t);
	transposeMatrix(A, &B);
	printResult(B);
	return 0;
}

实验2.2 稀疏矩阵加法，实现C=A+B

//004 稀疏矩阵加法
#include <bits/stdc++.h>
#define MAXSIZE 20000
using namespace std;
 
typedef struct triple
{
	int x, y; //非零元素的坐标
	int e;	  //非零元素的值
} triple;
 
typedef struct matrix
{
	int row, col, t;	  //定义矩阵的长宽和非零元素个数
	triple data[MAXSIZE]; //存储矩阵的三元组
} matrix;
 
void inputTriple(matrix *A, matrix *B) //输入矩阵三元组
{
	for (int i = 0; i < A->t; i++)
	{
		scanf("%d%d%d", &A->data[i].x, &A->data[i].y, &A->data[i].e);
	}
	for (int i = 0; i < B->t; i++)
	{
		scanf("%d%d%d", &B->data[i].x, &B->data[i].y, &B->data[i].e);
	}
}
 
void addMatrix(matrix *A, matrix *B) //矩阵相加
{
	for (int i = 0; i < B->t; i++)
	{
		for (int j = 0; j < A->t; j++)
		{
			if (A->data[j].x == B->data[i].x && A->data[j].y == B->data[i].y) //相同位置有非零元素
			{
				A->data[j].e += B->data[i].e;
				B->data[i].x = -1; //标记已经用过的三元组
			}
			if (A->data[j].e == 0) //排除相加后为0的三元组
			{
				A->data[j].x = -1;
			}
		}
	}
	for (int i = 0; i < B->t; i++) //对于B中没有用过的三元组进行遍历
	{
		if (B->data[i].x == -1)
			continue;
		A->data[A->t].x = B->data[i].x;
		A->data[A->t].y = B->data[i].y;
		A->data[A->t].e = B->data[i].e; //新建A的三元组
		A->t++;
	}
}
 
void sortTriple(matrix *A) //对A中三元组按照行递增和行内列递增的顺序进行排列
{
	for (int i = 0; i < A->t; i++) //行列递增排序
	{
		for (int j = 0; j < A->t - i - 1; j++)
		{
			if (A->data[j].x > A->data[j + 1].x || (A->data[j].x == A->data[j + 1].x && A->data[j].y > A->data[j + 1].y))
			{
				triple t = A->data[j];
				A->data[j] = A->data[j + 1];
				A->data[j + 1] = t;
			}
		}
	}
}
 
void printMatrix(matrix A)
{
	for (int i = 0; i < A.t; i++)
	{
		if (A.data[i].x == -1)
			continue;
		printf("%d %d %d\n", A.data[i].x, A.data[i].y, A.data[i].e);
	}
}
 
int main()
{
	matrix A, B;
	scanf("%d%d%d%d", &A.row, &A.col, &A.t, &B.t);
	B.row = A.row;
	B.col = A.col;
	inputTriple(&A, &B);
	addMatrix(&A, &B);
	sortTriple(&A);
	printMatrix(A);
	return 0;
}

实验2.3 稀疏矩阵加法，用十字链表实现C=A+B

//005 以十字链表为存储结构实现矩阵相加
#include <bits/stdc++.h>
 
typedef struct Node
{
    int x, y, e;
    Node *right, *down;
} Node;
 
typedef struct Matrix
{
    Node **rhead, **chead;
    int m, n, t;
} Matrix;
 
void initMatrix(Matrix *A, Matrix *B)
{
    scanf("%d%d%d%d", &A->m, &A->n, &A->t, &B->t);
    B->m = A->m;
    B->n = A->n;
}
 
void insertNode(Matrix *L, Node *P) //插入节点
{
    Node *temp, *N;
    N = (Node *)malloc(sizeof(Node)); //新建待插入节点
    N->y = P->y;
    N->x = P->x;
    N->e = P->e;                                            //装载节点信息
                                                            //插入行指针
    if (L->rhead[N->x] == NULL || L->rhead[N->x]->y > N->y) //需要插在头结点的情况
    {
        N->right = L->rhead[N->x];
        L->rhead[N->x] = N;
    }
    else
    {
        for (temp = L->rhead[N->x]; temp->right && temp->right->y < N->y; temp = temp->right)
            ; //不断向右遍历找到正确插入位置
        N->right = temp->right;
        temp->right = N;
    }
    //插入列指针
    if (L->chead[N->y] == NULL || L->chead[N->y]->x > N->x)
    {
        N->down = L->chead[N->y];
        L->chead[N->y] = N;
    }
    else
    {
        for (temp = L->chead[N->y]; temp->down && temp->down->x < N->x; temp = temp->down)
            ;
        N->down = temp->down;
        temp->down = N;
    }
}
 
void createMatrix(Matrix *M)
{
    Node *p, q;
    M->rhead = (Node **)malloc((M->m + 1) * sizeof(Node));
    M->chead = (Node **)malloc((M->n + 1) * sizeof(Node)); //创建行列指针表
    for (int i = 1; i <= M->m; i++)                        //初始化行列指针
        M->rhead[i] = NULL;
    for (int i = 1; i <= M->n; i++)
        M->chead[i] = NULL;
    for (int i = 1; i <= M->t; i++) //开辟节点并装在数据域和插入十字链表
    {
        p = (Node *)malloc(sizeof(Node));
        scanf("%d%d%d", &p->x, &p->y, &p->e);
        insertNode(M, p);
    }
}
 
void addMatrix(Matrix *A, Matrix *B)
{
    Node *p, *temp1, *temp2;
    for (int i = 1; i <= B->m; i++) //枚举每一行的头指针
    {
        if (B->rhead[i] == NULL) //如果B矩阵的该行没有元素，直接跳过，不需要执行加法
            continue;
        else
        {
            if (A->rhead[i] == NULL) //如果B该行不空，但A空，问题转化为将B中节点插入A中
            {
                temp2 = B->rhead[i];
                while (temp2)
                {
                    insertNode(A, temp2);
                    temp2 = temp2->right;
                }
            }
            else //如果A该行和B该行都不空
            {
                for (temp2 = B->rhead[i];; temp2 = temp2->right)
                {
                    for (temp1 = A->rhead[i];; temp1 = temp1->right) //对于该行某个B节点，枚举所有A节点
                    {
                        if (temp2->y == temp1->y) //如果两个节点位置重合，直接相加
                        {
                            temp1->e += temp2->e;
                            break;
                        }
                        //如果位置不重合
                        else if ((temp2->y < temp1->y) || temp1->right == NULL) //如果temp2的列已经大于temp1的列，说明temp2没有遇到相同列数的temp1
                        {                                                       //又或者已经遍历到尽头都没有相同列数
                            insertNode(A, temp2);                               //说明该列不可能存在相同位置了，直接插入
                            break;
                        }
                        else if (temp2->y > temp1->y && temp2->y < temp1->right->y) //如果temp2正好介于两者之间
                        {
                            insertNode(A, temp2);
                            break;
                        }
                    }
                    if (temp2->right == NULL)
                        break;
                }
            }
        }
    }
}
 
void printMatrix(Matrix *L)
{
    int i;
    Node *p;
    for (i = 1; i <= L->m; i++)
    {
        p = L->rhead[i];
        while (p != NULL)
        {
            if (p->e != 0)
                printf("%d %d %d\n", p->x, p->y, p->e);
            p = p->right;
        }
    }
}
 
int main()
{
    Matrix A, B;
    initMatrix(&A, &B);
    createMatrix(&A);
    createMatrix(&B);
    addMatrix(&A, &B);
    printMatrix(&A);
    return 0;
}
/*
3 4 3 2
1 1 1
1 3 1
2 2 2
1 2 1
2 2 3
*/

实验2.4 稀疏矩阵的乘法 

//006 稀疏矩阵的乘法
#include <bits/stdc++.h>
#define MAXSIZE 2000
 
typedef struct triple
{				 //定义三元组
	int r, c, e; //三元组的坐标和元素值
} triple;
 
typedef struct matrix
{						  //定义稀疏矩阵
	int m, n, t;		  //稀疏矩阵的行列数和非零元素个数
	triple data[MAXSIZE]; //该稀疏矩阵中的三元组信息  从下标1开始
} matrix;
 
void initMatrix(matrix *M) //初始化稀疏矩阵
{
	scanf("%d", &M->m);
	getchar();
	scanf("%d", &M->n);
	while (true)
	{
		triple *p = (triple *)malloc(sizeof(triple));
		scanf("%d", &p->r);
		getchar();
		scanf("%d", &p->c);
		getchar();
		scanf("%d", &p->e);
		if (!p->c)
			break;
		M->t++;
		M->data[M->t].r = p->r;
		M->data[M->t].c = p->c;
		M->data[M->t].e = p->e;
	}
}
 
void multiplyMatrix(matrix A, matrix B, matrix *C)
{
	int temp = 0; //temp用于累加当前行列相乘所得到的结果
	for (int i = 1; i <= A.m; i++)
	{
		for (int j = 1; j <= B.n; j++) //外两层循环是分别遍历第一个矩阵的行号和第二个矩阵的列号，排列组合
		{
			for (int p = 1; p <= A.t; p++)
			{
				for (int q = 1; q <= B.t; q++) //内两层循环是遍历所有元素，找到能进行乘法的元素数对
				{
					if (A.data[p].r == i && B.data[q].c == j && A.data[p].c == B.data[q].r)
					{
						temp += A.data[p].e * B.data[q].e;
					}
				}
			}
			if (!temp)
				continue;
			else
			{
				C->t++;
				C->data[C->t].r = i;
				C->data[C->t].c = j;
				C->data[C->t].e = temp;
				temp = 0;
			}
		}
	}
}
 
void printMatrix(matrix M) //输出矩阵三元组
{
	for (int i = 1; i <= M.t; i++)
	{
		printf("%d %d %d\n", M.data[i].r, M.data[i].c, M.data[i].e);
	}
}
 
int main()
{
	matrix A, B, C;
	initMatrix(&A);
	initMatrix(&B);
	C.m = A.m;
	C.n = B.n;
	multiplyMatrix(A, B, &C);
	printMatrix(C);
	return 0;
}

实验3.1 哈夫曼编/译器 

//007 哈夫曼编/译码器
#include <bits/stdc++.h>
#define N 100		//叶子结点最大数量
#define M 2 * N - 1 //所有结点最大数量
 
typedef struct HTNode //结点
{
	int weight;					//权重
	int parent, lchild, rchild; //双亲、左右孩子结点
	char data;					//字符
} HTNode, HT[M + 1];
HT ht;
 
typedef struct HCNode
{
	int bit[200]; //编码
	int start;	  //该编码的末尾位置
} HCNode, HC[100];
HC hc;
 
int str[1000] = {0};
int len = 0;
 
void select(int pos, int *x1, int *x2)
{
	int min = 100000;
	for (int i = 1; i <= pos; i++)
	{
		if (ht[i].weight < min && ht[i].parent == 0) //注意判断该节点必须没有双亲节点
		{
			min = ht[i].weight;
			*x1 = i;
		}
	}
	min = 100000;
	for (int i = 1; i <= pos; i++)
	{
		if (i == *x1)
			continue;
		if (ht[i].weight < min && ht[i].parent == 0) //注意判断该节点必须没有双亲节点
		{
			min = ht[i].weight;
			*x2 = i;
		}
	}
}
 
void initTree(int n)
{
	int x1, x2;
	for (int i = 1; i <= 2 * n - 1; i++) //对所有结点初始化
	{
		ht[i].weight = 0;
		ht[i].parent = 0;
		ht[i].lchild = 0;
		ht[i].rchild = 0;
	}
	for (int i = 1; i <= n; i++) //叶子结点的data域
	{
		getchar();
		scanf("%c", &ht[i].data);
	}
	for (int i = 1; i <= n; i++) //叶子结点的weight域
	{
		scanf("%d", &ht[i].weight);
	}
	for (int i = n; i < 2 * n - 1; i++)
	{
		select(i, &x1, &x2); //找到序号为i的结点之前的两个最小权重结点
		//两个最小权重结点组成一棵树，以i处的结点为根节点，直至循环结束所有结点组成一棵树
		ht[i + 1].weight = ht[x1].weight + ht[x2].weight;
		ht[x1].parent = i + 1;
		ht[x2].parent = i + 1;
		ht[i + 1].lchild = x1;
		ht[i + 1].rchild = x2;
	}
}
 
void encode(int n)
{
	for (int i = 1; i <= n; i++)
	{
		hc[i].start = n;	  //编码长度最多为n
		int c = i;			  //当前叶子结点序号
		int p = ht[c].parent; //叶子结点双亲序号
		while (p)
		{
			if (ht[p].lchild == c)
				hc[i].bit[hc[i].start] = 0;
			else
				hc[i].bit[hc[i].start] = 1;
			hc[i].start--;	  //准备录入下一位编码
			c = p;			  //上溯
			p = ht[c].parent; //上溯，直到while循环结束
		}
		hc[i].start++; //while循环中，start多退了一位。
	}
}
 
void printCode(int n)
{
	len = 0;
	char code[1000];
	scanf("%s", code);
	for (int i = 0; i < strlen(code); i++)
	{
		for (int j = 1; j <= n; j++)
		{
			if (code[i] == ht[j].data)
			{
				for (int k = hc[j].start; k <= n; k++)
				{
					printf("%d", hc[j].bit[k]);
					str[len] = hc[j].bit[k]; //存储待破解编码
					len++;
				}
			}
		}
	}
	printf("\n");
}
 
void decode(int n) //译码并输出
{
	int t;
	for (int i = 0; i < len;)
	{
		t = 2 * n - 1;								   //根节点
		while (ht[t].lchild != 0 && ht[t].rchild != 0) //当找到叶子节点时，退出循环
		{
			if (str[i] == 0)
				t = ht[t].lchild;
			else
				t = ht[t].rchild;
			i++;
		}
		printf("%c", ht[t].data);
	}
}
 
int main()
{
	int n;
	scanf("%d", &n);
	initTree(n);
	encode(n);
	printCode(n);
	decode(n);
	return 0;
}

实验4.1 求赋权图中一个结点到所有结点的最短路径的长度 

//求赋权图中一个结点到所有结点的最短路径长度
#include <bits/stdc++.h>
#define MAXSIZE 105
#define INF 10000
 
int ans[MAXSIZE] = {0};
 
typedef struct Graph
{
	int data[MAXSIZE];
	int arc[MAXSIZE][MAXSIZE];
	int Vnum, Anum;
} Graph;
 
typedef struct dijkstra
{
	bool visited[MAXSIZE];
	int length[MAXSIZE];
} Dij;
 
void initGraph(Graph *G)
{
	scanf("%d", &G->Vnum);
	for (int i = 0; i < G->Vnum; i++)
	{
		for (int j = 0; j < G->Vnum; j++)
		{
			scanf("%d", &G->arc[i][j]);
		}
	}
}
 
void initDij(Graph *G, Dij *D)
{
	for (int i = 0; i < G->Vnum; i++)
	{
		D->visited[i] = 0;
		D->length[i] = INF;
	}
	D->visited[0] = 1;
	D->length[0] = 0;
	for (int i = 0; i < G->Vnum; i++)
	{
		if (G->arc[0][i] != 10000)
		{
			D->length[i] = G->arc[0][i];
		}
	}
}
 
int searchMinLengthV(Graph *G, Dij *D)
{
	int min = 10000;
	int r;
	for (int i = 0; i < G->Vnum; i++)
	{
		if (!D->visited[i] && D->length[i] < min)
		{
			min = D->length[i];
			r = i;
		}
	}
	D->visited[r] = true;
	return r;
}
 
bool judgeFinished(Graph *G, Dij *D)
{
	for (int i = 0; i < G->Vnum; i++)
	{
		if (!D->visited[i])
			return false;
	}
	return true;
}
 
int min(int a, int b)
{
	return a > b ? b : a;
}
 
void updateArcV(int V0, Graph *G, Dij *D)
{
	for (int i = 0; i < G->Vnum; i++)
	{
		if (G->arc[V0][i] != 10000 && !D->visited[i])
		{
			D->length[i] = min(D->length[i], D->length[V0] + G->arc[V0][i]);
		}
	}
}
 
void findMinPath(Graph *G, Dij *D)
{
	initDij(G, D);
	for (int i = 0; i < G->Vnum - 1; i++)
	{
		int t = searchMinLengthV(G, D);
		if (judgeFinished(G, D))
			return;
		updateArcV(t, G, D);
	}
}
 
void printPath(Graph *G, Dij *D)
{
	for (int i = 0; i < G->Vnum; i++)
	{
		printf("%d\n", D->length[i]);
	}
}
 
int main()
{
	Graph G;
	Dij D;
	initGraph(&G);
	int ans[MAXSIZE] = {0};
	findMinPath(&G, &D);
	printPath(&G, &D);
	return 0;
}
/*
6
0 1 4 10000 10000 10000
1 0 2 7 5 10000
4 2 0 10000 1 10000
10000 7 10000 0 3 2
10000 5 1 3 0 6
10000 10000 10000 2 6 0
*/

实验4.2 用迪杰斯特拉算法求赋权图中的最短路径 

/*实验4.2：用迪杰斯特拉算法求赋权图中的最短路径
核心：
1.与上一题一样更新完成最短路径图
2.从目标结点向前寻找最短路径：按照结点的length递减的顺序；验证length-边长?=上一个结点length
*/
#include <bits/stdc++.h>
using namespace std;
#define MAXSIZE 105
 
typedef struct Graph
{
    int Vnum;
    int arc[MAXSIZE][MAXSIZE];
} Graph;
 
typedef struct Dij
{
    bool visited[MAXSIZE];
    int length[MAXSIZE];
} Dij;
 
typedef struct Stack
{
    int top;
    int data[MAXSIZE];
} Stack;
 
void push_stack(Stack *S, int e)
{
    S->top++;
    S->data[S->top] = e;
}
 
int pop_stack(Stack *S)
{
    S->top--;
    return S->data[S->top + 1];
}
 
void init(Graph *G, Dij *D, Stack *S)
{
    scanf("%d", &G->Vnum);
    for (int i = 0; i < G->Vnum; i++)
    {
        for (int j = 0; j < G->Vnum; j++)
        {
            scanf("%d", &G->arc[i][j]);
        }
    }
    for (int i = 0; i < G->Vnum; i++)
    {
        D->visited[i] = 0;
        D->length[i] = G->arc[0][i];
    }
    D->visited[0] = 1;
    S->top = -1;
}
 
bool is_finished(Graph *G, Dij *D)
{
    for (int i = 0; i < G->Vnum; i++)
    {
        if (!D->visited[i])
        {
            return false;
        }
    }
    return true;
}
 
int find_minlength_V(Graph *G, Dij *D)
{
    int min = 10005;
    int min_V;
    for (int i = 0; i < G->Vnum; i++)
    {
        if (!D->visited[i] && D->length[i] < min)
        {
            min = D->length[i];
            min_V = i;
        }
    }
    return min_V;
}
 
void update_arc_V(Graph *G, Dij *D, int v)
{
    D->visited[v] = true;
    for (int i = 0; i < G->Vnum; i++)
    {
        if (!D->visited[i] && D->length[v] + G->arc[i][v] < D->length[i])
        {
            D->length[i] = D->length[v] + G->arc[i][v];
        }
    }
}
 
void caculate_minlength_for_each_V(Graph *G, Dij *D)
{
    for (int i = 0; i < G->Vnum; i++)
    {
        if (is_finished(G, D))
        {
            return;
        }
        int v = find_minlength_V(G, D);
        update_arc_V(G, D, v);
    }
}
 
void find_path(Graph *G, Dij *D, Stack *S)
{
    int start, end;
    scanf("%d%d", &start, &end);
    push_stack(S, end);
    while (end != start)
    {
        for (int i = 0; i < G->Vnum; i++)
        {
            if (G->arc[i][end] != 10000 && D->length[i] < D->length[end] && D->length[i] + G->arc[i][end] == D->length[end])
            {
                push_stack(S, i);
                end = i;
            }
        }
    }
}
 
void print_path(Stack *S)
{
    while (S->top > -1)
    {
        printf("%d\n", pop_stack(S));
    }
}
 
int main()
{
    Graph G;
    Dij D;
    Stack S;
    init(&G, &D, &S);
    caculate_minlength_for_each_V(&G, &D);
    int path[MAXSIZE];
    find_path(&G, &D, &S);
    print_path(&S);
    return 0;
}
 
/*
4
0 2 10 10000
2 0 7 3
10 7 0 6
10000 3 6 0
0 2
*/

实验4.3 用弗洛伊德算法求赋权图的两点间的最短路径的长度

//010用弗洛伊德算法求赋权图的两点间的最短路径长度
#include <bits/stdc++.h>
#define MAXSIZE 105
#define INF 10000
using namespace std;
 
typedef struct Graph
{
    int vnum;
    int arc[MAXSIZE][MAXSIZE];
    int path[MAXSIZE][MAXSIZE];
} Graph;
 
void init_Graph(Graph *G)
{
    scanf("%d", &G->vnum);
    for (int i = 0; i < G->vnum; i++)
    {
        for (int j = 0; j < G->vnum; j++)
        {
            scanf("%d", &G->arc[i][j]);
            G->path[i][j] = -1;
        }
    }
}
 
void floyd(Graph *G)
{
    for (int m = 0; m < G->vnum; m++)
        for (int a = 0; a < G->vnum; a++)
            for (int b = 0; b < G->vnum; b++)
            {
                if (G->arc[a][b] > G->arc[a][m] + G->arc[m][b])
                {
                    G->arc[a][b] = G->arc[a][m] + G->arc[m][b];
                    G->path[a][b] = m;
                }
            }
}
 
void print_result(Graph *G)
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", G->arc[a][b]);
    }
}
 
int main()
{
    Graph G;
    init_Graph(&G);
    floyd(&G);
    print_result(&G);
    return 0;
}
 
/*
4
0 2 10 10000
2 0 7 3
10 7 0 6
10000 3 6 0
2
0 2
3 0
*/

实验4.4 用弗洛伊德算法求赋权图中任意两点间的最短路径 

//011用弗洛伊德算法求赋权图任意两点间的最短路径
#include <bits/stdc++.h>
#define MAXSIZE 105
#define INF 10000
using namespace std;
 
typedef struct Graph
{
    int vnum;
    int arc[MAXSIZE][MAXSIZE];
    int path[MAXSIZE][MAXSIZE];
} Graph;
 
typedef struct Stack
{
    int top;
    int data[MAXSIZE];
} Stack;
 
void init_Stack(Stack *S)
{
    S->top = -1;
}
 
void push_Stack(Stack *S, int e)
{
    S->top++;
    S->data[S->top] = e;
}
 
int pop_Stack(Stack *S)
{
    S->top--;
    return S->data[S->top + 1];
}
 
void init_Graph(Graph *G)
{
    scanf("%d", &G->vnum);
    for (int i = 0; i < G->vnum; i++)
    {
        for (int j = 0; j < G->vnum; j++)
        {
            scanf("%d", &G->arc[i][j]);
            G->path[i][j] = -1;
        }
    }
}
 
void floyd(Graph *G)
{
    for (int m = 0; m < G->vnum; m++)
        for (int a = 0; a < G->vnum; a++)
            for (int b = 0; b < G->vnum; b++)
            {
                if (G->arc[a][b] > G->arc[a][m] + G->arc[m][b])
                {
                    G->arc[a][b] = G->arc[a][m] + G->arc[m][b];
                    G->path[a][b] = m;
                }
            }
}
 
void find_path(Graph *G, Stack *S, int a, int b)
{
    push_Stack(S, b);
    if (G->path[a][b] == -1)
    {
        push_Stack(S, a);
        return;
    }
    else
    {
        find_path(G, S, a, G->path[a][b]);
    }
}
 
void print_result(Graph *G, Stack *S)
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        init_Stack(S);
        find_path(G, S, a, b);
        while (S->top > -1)
        {
            printf("%d\n", pop_Stack(S));
        }
    }
}
 
int main()
{
    Graph G;
    Stack S;
    init_Graph(&G);
    floyd(&G);
    print_result(&G, &S);
    return 0;
}
 
/*
4
0 2 10 10000
2 0 7 3
10 7 0 6
10000 3 6 0
2
0 2
3 0
*/