C/C++程序之根据有向图、无向图求通路、回路、可达矩阵

最新推荐文章于 2023-12-02 18:46:01 发布
最新推荐文章于 2023-12-02 18:46:01 发布
阅读量4.3k 收藏 31
点赞数 5
分类专栏： C C++ 文章标签： c++ 指针 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43634664/article/details/106375437
版权
C++ 同时被 2 个专栏收录
9 篇文章 0 订阅
订阅专栏
C
7 篇文章 0 订阅
订阅专栏

C/C++ 求邻接矩阵的通路、回路，和对应的可达矩阵

前言

最近《离散数学》老师突发奇想，让我们用程序完成课本作业……总体而言，其实蛮简单，只要理清解题过程即可，根本没用到什么特殊的算法……无非也就动态分配数组。

要算的，就算出不同长度下的通路、回路个数，或者可达矩阵，如果后期要再加上什么，我会再补充修改的。

!!! 注意，一定要看变量或函数的英文意思，因为有时候我写多了，感觉注释太多就删掉了注释，英文名是最好的注释！！ TK

有几个变量通常不会改变，比如**matrixArray，指的是设置的矩阵，matrixSize指的是矩阵的阶数。

题目分析

题目就一个有向图、无向图，那么怎么计算通路或回路个数呢？很简单。

  1. 对于有向图，假设从a点到c点有一条指向的单一通路，那么对于坐标(a,c)就是1，若c到a也有一条单一指向的通路，那么对于坐标(c,a)也是1，若没有，就是0；
  2. 对于无向图，也是如此，不同点在于，因为无向图没有指向，所以对于a点到c点是1，假设又有一条路从c到a(不是上一条路)，即a点和c点处于一个圆上，那么这(a,c)为2，且(c,a)也为2；
  3. 下面拿个例子分析，具体的自己找规律：
    无向图
    如图为一个无向图，(a,b) = 1, (b,a) = 1, (b,b) = 1, (b,c) = 1, (c,b) = 1, (c,d) = 2, (d,c) = 2, (d,e) = 1, (e,d) = 1，所以得到的邻接矩阵如下：
    _ | a | b | c | d | e | f
    a-| 0 | 1 | 0 | 0 | 0 | 0
    b-| 1 | 1 | 1 | 0 | 0 | 0
    c-| 0 | 1 | 0 | 2 | 0 | 0
    d-| 0 | 0 | 2 | 0 | 1 | 0
    e-| 0 | 0 | 0 | 1 | 0 | 0
    f -| 0 | 0 | 0 | 0 | 0 | 0
  4. 假设矩阵如上所示，则无向图中的b点到c点的通路就是矩阵(b,c) = 1，而回路个数则是无向图中的某点到自身的值，即(b,b) = 1。
  5. 长度，最简单的说，就是矩阵自乘多少次，n个长度的(i,j)点通路，就是该矩阵A的n次方后，(i,j)的值是多少就是多少。
  6. 可达矩阵，求法就是在邻接矩阵的基础上不断将每个长度的矩阵求和，最后对角线全部置1，非对角线上的每个非0元素置1。假设可达矩阵R，矩阵阶数为n，则Rt = A ^1 + A ^2 + A ^3 + … + A ^(n-1)，然后再把Rt的对角线每个点置1，非对角线每个非零元素置1，即可得到可达矩阵R。
  7. 题目中有几个问题，一个是求a点到d点长度分别为1，2，3，4，5的通路各有多少，一个是求a点到d点长度小于等于3的通路有多少条。可知，前一个求的必须是个数组，返回不同的结果的数组，而后者则是每个长度下的矩阵的那个(a,d)的值之和，返回一个int。

流程图

程序流程图
说是这么说，实际我并不全这么写，比如为了省事，我把“再次选择计算方式”的循环去掉了。

另外，为什么所有计算方法都指向一个矩阵乘积的函数呢？
因为，这个函数决定了绝大部分的内容，不同的计算方式都通过该函数得到想要的那个长度下的矩阵，接着才对得到的矩阵进行求和、统计、拆分之类的功能。

为什么矩阵乘积函数返回的是空值void？
因为在几乎每个计算函数里面都初始化了一个二维指针数组，这个是临时的指针，动态分配的数组，这个指针用于传递给矩阵乘积函数，矩阵乘积函数直接就可以修改指针指向的值，而不需要返回任何东西，所以这个矩阵乘积函数的返回值是void。同样的，有的函数甚至还设置了接收指针，这些指针的作用也是一样的，或者说是类似的，凑合着听懂就行。

函数方法分析

主函数：没啥用（其实用处SuperSuper大），略过。

其实，就是用于设置循环啊、矩阵阶数等一些最基本的东西。

设置初始矩阵的函数setMatrixArray()

/*
* @description 初始化矩阵
* @param matrixArray 初始矩阵，调用方指针、接收结果矩阵的调用方指针
* @param matrixSize 矩阵尺度
*/
void setMatrixArray(int** matrixArray, int matrixSize);

void setMatrixArray(int** matrixArray, int matrixSize)
{
	std::cout << "Please input matrix: (Space off) " << std::endl;
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			scanf_s("%d", &matrixArray[i][j]);
		}
	}
}

矩阵乘积函数multiplicineMatrixCalculate()

/*
* @description 矩阵乘积计算
* @param **matrixArray 调用方矩阵
* @param **aheadMatrixArray 前矩阵
* @param **afterMatrixArray 后矩阵
* @param matrixSize 矩阵尺度
* @param **acceptCalculateMatrix 接收矩阵的调用方指针
*/
void multiplicineMatrixCalculate(int** aheadMatrixArray, int** afterMatrixArray, int matrixSize, int** acceptCalculateMatrix);


void multiplicineMatrixCalculate(int** aheadMatrixArray, int** afterMatrixArray, int matrixSize, int** acceptCalculateMatrix)
{
	// 前行×后列之和
	int mulOrderSum = 0;
	int** calculateTemporMatrix = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
	}

	// 矩阵阶乘
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			mulOrderSum = 0;
			for (int k = 0; k < matrixSize; k++)
			{
				mulOrderSum = mulOrderSum + aheadMatrixArray[i][k] * afterMatrixArray[k][j];
				calculateTemporMatrix[i][j] = mulOrderSum;
			}
		}
	}

	// 传递计算结果值给调用方指针
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			acceptCalculateMatrix[i][j] = calculateTemporMatrix[i][j];
		}
	}

	// Free
	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrix[i]);
	}
	free(calculateTemporMatrix);
}

获得指定长度的矩阵multiplicineMatrixResult()

注意，使用该函数会直接改变传入的矩阵指针。

/*
* @description 计算某个距离长度的矩阵（注意该方法会直接修改传入的矩阵）
* @param **matrixArray 初始矩阵、接收矩阵的调用方指针
* @param matrixSize 矩阵尺度
* @param setLength 距离长度
*/
void multiplicineMatrixResult(int** matrixArray, int matrixSize, int setLength);

void multiplicineMatrixResult(int** matrixArray, int matrixSize, int setLength)
{
	int** calculatedMatrix = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculatedMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculatedMatrix[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 0; i < setLength - 1; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculatedMatrix, matrixSize, calculatedMatrix);
	}

	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			matrixArray[i][j] = calculatedMatrix[i][j];
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculatedMatrix[i]);
	}
	free(calculatedMatrix);
}

求可达矩阵getReachableMatrix()

/*
* @description 根据有向图、无向图计算可达矩阵
* @param **matrixArray 初始普通矩阵
* @param matrixSize 矩阵尺度
* @param reachableMatrix 调用方接收的可达矩阵指针
*/
void getReachableMatrix(int** matrixArray, int matrixSize, int** reachableMatrix);

void getReachableMatrix(int** matrixArray, int matrixSize, int** reachableMatrix)
{
	int** calculatedMatrix = (int**)malloc(matrixSize * sizeof(int*));
	int** temporMatrix = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculatedMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
		temporMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculatedMatrix[i][j] = matrixArray[i][j];
			temporMatrix[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 1; i < matrixSize - 1; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculatedMatrix, matrixSize, calculatedMatrix);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				temporMatrix[m][n] = temporMatrix[m][n] + calculatedMatrix[m][n];
			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			if (j == i)
			{
				temporMatrix[i][j] = 1;
			}
			else if (temporMatrix[i][j] != 0)
			{
				temporMatrix[i][j] = 1;
			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			reachableMatrix[i][j] = temporMatrix[i][j];
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(temporMatrix[i]);
		free(calculatedMatrix[i]);
	}
	free(temporMatrix);
	free(calculatedMatrix);
}

求某长度某点的值getPointSetLength()

/*
* @description 求某个点某长度的值（即通路或回路数）
* @param **matrixArray 初始矩阵指针
* @param matrixSize 矩阵尺度
* @param setLength 自定义长度
* @param pointRow 自定义点横坐标
* @param pointLine 自定义点的纵坐标
* @param pointValue 某个点某长度的值（即通路或回路数）
*/
int getPointSetLength(int** matrixArray, int matrixSize, int setLength, int pointRow, int pointLine);

int getPointSetLength(int** matrixArray, int matrixSize, int setLength, int pointRow, int pointLine)
{
	int pointValue = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 1; i < setLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
	}
	pointValue = calculateTemporMatrixArray[pointRow - 1][pointLine - 1];

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);
	return pointValue;
}

求多个长度的通路数getArrayCustomMultiLength()

/*
* @description 计算自定义距离长度下矩阵的自定义点通路或回路个数，当且仅当pointRow == pointLine
* @param **matrixArray 初始矩阵指针
* @param matrixSize 矩阵尺度
* @param *customLengthArray 自定义长度数组
* @param getLenArraySize 自定义长度尺度
* @param pointRow 自定义点横坐标
* @param pointLine 自定义点的纵坐标
* @param *acceptResultArray 自定义长度的自定义点通路或回路个数、调用方接收结果数组的指针
*/
void getArrayCustomMultiLength(int** matrixArray, int matrixSize, int* customLengthArray, int customLengthSize, int pointRow, int pointLine, int* acceptResultArray);


void getArrayCustomMultiLength(int** matrixArray, int matrixSize, int* customLengthArray, int customLengthSize, int pointRow, int pointLine, int* acceptResultArray)
{
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	// 获取自定义长度数组里面最长的长度 -- 获取到最大长度后只需要不断阶乘到该长度，获取想要的序号即可
	int maxCustomLength = 1;
	for (int i = 0; i < customLengthSize; i++)
	{
		if (maxCustomLength < customLengthArray[i])
		{
			maxCustomLength = customLengthArray[i];
		}
	}
	int* calculateTemporLengthArray = (int*)malloc(customLengthSize * sizeof(int));

	for (int i = 0; i < maxCustomLength; i++)
	{
		calculateTemporLengthArray[i] = calculateTemporMatrixArray[pointRow - 1][pointLine - 1];
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
	}

	// 遍历用户自定义长度数组 -- 并把calculateTemporLengthArray[customLengthArray[i]]传给acceptResultArray[i]
	for (int i = 0; i < customLengthSize; i++)
	{
		acceptResultArray[i] = calculateTemporLengthArray[customLengthArray[i] - 1];
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);
	free(calculateTemporLengthArray);
}

求某范围内的某点的通路数getCountPointRangeLength()

/*
* @description 统计某范围长度内自定义点的通路或回路之和，当且仅当pointRow == pointLine
* @param **matrixArray 初始矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @param pointRow 自定义点的横坐标
* @param pointLine 自定义点的纵坐标
* @return sumRangeLengthArray 某范围长度内自定义点的通路或回路之和
*/
int getCountPointRangeLength(int** matrixArray, int matrixSize, int maxLength, int pointRow, int pointLine);


int getCountPointRangeLength(int** matrixArray, int matrixSize, int maxLength, int pointRow, int pointLine)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[pointRow - 1][pointLine - 1];
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}

求范围内所有点的通路数（包括回路）getAllPointRangeLengthAccess_HaveLoop()

/*
* @description 求某长度内所有点即通路和回路之和
* @param **matrixArray 调用方矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @return sumRangeLengthArray 某长度内所有点即通路和回路之和
*/
int getAllPointRangeLengthAccess_HaveLoop(int** matrixArray, int matrixSize, int maxLength);

int getAllPointRangeLengthAccess_HaveLoop(int** matrixArray, int matrixSize, int maxLength)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int m = 0; m < matrixSize; m++)
	{
		for (int n = 0; n < matrixSize; n++)
		{
			sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
		}
	}
	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}

求范围内所有点的通路数（不包括回路）getAllPointRangeLengthAccess_NotLoop()

/*
* @description 求某长度内所有通路之和（不包括回路）
* @param **matrixArray 调用方矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @return sumRangeLengthArray 某长度内所有通路之和（不包括回路）
*/
int getAllPointRangeLengthAccess_NotLoop(int** matrixArray, int matrixSize, int maxLength);

int getAllPointRangeLengthAccess_NotLoop(int** matrixArray, int matrixSize, int maxLength)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int m = 0; m < matrixSize; m++)
	{
		for (int n = 0; n < matrixSize; n++)
		{
			if (n != m)
			{
				sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
			}
		}
	}
	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				if (n != m)
				{
					sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
				}
				
			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}

求范围内所有点的回路数getAllPointRangeLengthLoop()

/*
* @description 求某长度内所有回路之和
* @param **matrixArray 调用方矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @return sumRangeLengthArray 某长度内所有回路之和
*/
int getAllPointRangeLengthLoop(int** matrixArray, int matrixSize, int maxLength);

int getAllPointRangeLengthLoop(int** matrixArray, int matrixSize, int maxLength)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int m = 0; m < matrixSize; m++)
	{
		for (int n = 0; n < matrixSize; n++)
		{
			if (n == m)
			{
				sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
			}
		}
	}
	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				if (n == m)
				{
					sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
				}

			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}

总代码

CalculateGraphicMatrix.h

/**************************************************************************
//
// Copyright:THDMI
//
// Author: HDM
//
// Date:2020-05-24
//
// Description:Calculate the Graphic according with Matrix and Length
//
**************************************************************************/

#pragma once

/*
* @description 求某个点某长度的值（即通路或回路数）
* @param **matrixArray 初始矩阵指针
* @param matrixSize 矩阵尺度
* @param setLength 自定义长度
* @param pointRow 自定义点横坐标
* @param pointLine 自定义点的纵坐标
* @param pointValue 某个点某长度的值（即通路或回路数）
*/
int getPointSetLength(int** matrixArray, int matrixSize, int setLength, int pointRow, int pointLine);


/*
* @description 计算自定义距离长度下矩阵的自定义点通路或回路个数，当且仅当pointRow == pointLine
* @param **matrixArray 初始矩阵指针
* @param matrixSize 矩阵尺度
* @param *customLengthArray 自定义长度数组
* @param getLenArraySize 自定义长度尺度
* @param pointRow 自定义点横坐标
* @param pointLine 自定义点的纵坐标
* @param *acceptResultArray 自定义长度的自定义点通路或回路个数、调用方接收结果数组的指针
*/
void getArrayCustomMultiLength(int** matrixArray, int matrixSize, int* customLengthArray, int customLengthSize, int pointRow, int pointLine, int* acceptResultArray);



/*
* @description 统计某范围长度内自定义点的通路或回路之和，当且仅当pointRow == pointLine
* @param **matrixArray 初始矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @param pointRow 自定义点的横坐标
* @param pointLine 自定义点的纵坐标
* @return sumRangeLengthArray 某范围长度内自定义点的通路或回路之和
*/
int getCountPointRangeLength(int** matrixArray, int matrixSize, int maxLength, int pointRow, int pointLine);



/*
* @description 求某长度内所有点即通路和回路之和
* @param **matrixArray 调用方矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @return sumRangeLengthArray 某长度内所有点即通路和回路之和
*/
int getAllPointRangeLengthAccess_HaveLoop(int** matrixArray, int matrixSize, int maxLength);



/*
* @description 求某长度内所有通路之和（不包括回路）
* @param **matrixArray 调用方矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @return sumRangeLengthArray 某长度内所有通路之和（不包括回路）
*/
int getAllPointRangeLengthAccess_NotLoop(int** matrixArray, int matrixSize, int maxLength);



/*
* @description 求某长度内所有回路之和
* @param **matrixArray 调用方矩阵指针
* @param matrixSize 矩阵尺度
* @param maxLength 最大距离长度
* @return sumRangeLengthArray 某长度内所有回路之和
*/
int getAllPointRangeLengthLoop(int** matrixArray, int matrixSize, int maxLength);



/*
* @description 初始化矩阵
* @param matrixArray 初始矩阵，调用方指针、接收结果矩阵的调用方指针
* @param matrixSize 矩阵尺度
*/
void setMatrixArray(int** matrixArray, int matrixSize);



/*
* @description 矩阵乘积计算
* @param **matrixArray 调用方矩阵
* @param **aheadMatrixArray 前矩阵
* @param **afterMatrixArray 后矩阵
* @param matrixSize 矩阵尺度
* @param **acceptCalculateMatrix 接收矩阵的调用方指针
*/
void multiplicineMatrixCalculate(int** aheadMatrixArray, int** afterMatrixArray, int matrixSize, int** acceptCalculateMatrix);



/*
* @description 计算某个距离长度的矩阵（注意该方法会直接修改传入的矩阵）
* @param **matrixArray 初始矩阵、接收矩阵的调用方指针
* @param matrixSize 矩阵尺度
* @param setLength 距离长度
*/
void multiplicineMatrixResult(int** matrixArray, int matrixSize, int setLength);



/*
* @description 根据有向图、无向图计算可达矩阵
* @param **matrixArray 初始普通矩阵
* @param matrixSize 矩阵尺度
* @param reachableMatrix 调用方接收的可达矩阵指针
*/
void getReachableMatrix(int** matrixArray, int matrixSize, int** reachableMatrix);

CalculateGraphicMatrix.cpp

/**************************************************************************
//
// Copyright:THDMI
//
// Author: HDM
//
// Date:2020-05-24
//
// Description:Calculate the Graphic according with Matrix and Length
//
**************************************************************************/

#include "CalculateGraphicMatrix.h"
#include <malloc.h>
#include <iostream>


/************************************* 已验证 ****************************************/

int getPointSetLength(int** matrixArray, int matrixSize, int setLength, int pointRow, int pointLine)
{
	int pointValue = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 1; i < setLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
	}
	pointValue = calculateTemporMatrixArray[pointRow - 1][pointLine - 1];

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);
	return pointValue;
}


/************************************* 已验证 ****************************************/

void getArrayCustomMultiLength(int** matrixArray, int matrixSize, int* customLengthArray, int customLengthSize, int pointRow, int pointLine, int* acceptResultArray)
{
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	// 获取自定义长度数组里面最长的长度 -- 获取到最大长度后只需要不断阶乘到该长度，获取想要的序号即可
	int maxCustomLength = 1;
	for (int i = 0; i < customLengthSize; i++)
	{
		if (maxCustomLength < customLengthArray[i])
		{
			maxCustomLength = customLengthArray[i];
		}
	}
	int* calculateTemporLengthArray = (int*)malloc(customLengthSize * sizeof(int));

	for (int i = 0; i < maxCustomLength; i++)
	{
		calculateTemporLengthArray[i] = calculateTemporMatrixArray[pointRow - 1][pointLine - 1];
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
	}

	// 遍历用户自定义长度数组 -- 并把calculateTemporLengthArray[customLengthArray[i]]传给acceptResultArray[i]
	for (int i = 0; i < customLengthSize; i++)
	{
		acceptResultArray[i] = calculateTemporLengthArray[customLengthArray[i] - 1];
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);
	free(calculateTemporLengthArray);
}


/************************************* 已验证 ****************************************/

int getCountPointRangeLength(int** matrixArray, int matrixSize, int maxLength, int pointRow, int pointLine)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[pointRow - 1][pointLine - 1];
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}


/************************************* 已验证 ****************************************/

int getAllPointRangeLengthAccess_HaveLoop(int** matrixArray, int matrixSize, int maxLength)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int m = 0; m < matrixSize; m++)
	{
		for (int n = 0; n < matrixSize; n++)
		{
			sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
		}
	}
	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}


/************************************* 已验证 ****************************************/

int getAllPointRangeLengthAccess_NotLoop(int** matrixArray, int matrixSize, int maxLength)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int m = 0; m < matrixSize; m++)
	{
		for (int n = 0; n < matrixSize; n++)
		{
			if (n != m)
			{
				sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
			}
		}
	}
	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				if (n != m)
				{
					sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
				}
				
			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}


/************************************* 已验证 ****************************************/

int getAllPointRangeLengthLoop(int** matrixArray, int matrixSize, int maxLength)
{
	int sumRangeLengthArray = 0;
	int** calculateTemporMatrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculateTemporMatrixArray[i][j] = matrixArray[i][j];
		}
	}

	for (int m = 0; m < matrixSize; m++)
	{
		for (int n = 0; n < matrixSize; n++)
		{
			if (n == m)
			{
				sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
			}
		}
	}
	for (int i = 1; i < maxLength; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculateTemporMatrixArray, matrixSize, calculateTemporMatrixArray);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				if (n == m)
				{
					sumRangeLengthArray = sumRangeLengthArray + calculateTemporMatrixArray[m][n];
				}

			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrixArray[i]);
	}
	free(calculateTemporMatrixArray);

	return sumRangeLengthArray;
}


/************************************* 已验证 ****************************************/

void setMatrixArray(int** matrixArray, int matrixSize)
{
	std::cout << "Please input matrix: (Space off) " << std::endl;
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			scanf_s("%d", &matrixArray[i][j]);
		}
	}
}


/************************************* 已验证 ****************************************/

void multiplicineMatrixCalculate(int** aheadMatrixArray, int** afterMatrixArray, int matrixSize, int** acceptCalculateMatrix)
{
	// 前行×后列之和
	int mulOrderSum = 0;
	int** calculateTemporMatrix = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculateTemporMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
	}

	// 矩阵阶乘
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			mulOrderSum = 0;
			for (int k = 0; k < matrixSize; k++)
			{
				mulOrderSum = mulOrderSum + aheadMatrixArray[i][k] * afterMatrixArray[k][j];
				calculateTemporMatrix[i][j] = mulOrderSum;
			}
		}
	}

	// 传递计算结果值给调用方指针
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			acceptCalculateMatrix[i][j] = calculateTemporMatrix[i][j];
		}
	}

	// Free
	for (int i = 0; i < matrixSize; i++)
	{
		free(calculateTemporMatrix[i]);
	}

	free(calculateTemporMatrix);
}


/************************************* 已验证 ****************************************/

void multiplicineMatrixResult(int** matrixArray, int matrixSize, int setLength)
{
	int** calculatedMatrix = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculatedMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculatedMatrix[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 0; i < setLength - 1; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculatedMatrix, matrixSize, calculatedMatrix);
	}

	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			matrixArray[i][j] = calculatedMatrix[i][j];
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(calculatedMatrix[i]);
	}
	free(calculatedMatrix);
}


/************************************* 已验证 ****************************************/

void getReachableMatrix(int** matrixArray, int matrixSize, int** reachableMatrix)
{
	int** calculatedMatrix = (int**)malloc(matrixSize * sizeof(int*));
	int** temporMatrix = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		calculatedMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
		temporMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			calculatedMatrix[i][j] = matrixArray[i][j];
			temporMatrix[i][j] = matrixArray[i][j];
		}
	}

	for (int i = 1; i < matrixSize - 1; i++)
	{
		multiplicineMatrixCalculate(matrixArray, calculatedMatrix, matrixSize, calculatedMatrix);
		for (int m = 0; m < matrixSize; m++)
		{
			for (int n = 0; n < matrixSize; n++)
			{
				temporMatrix[m][n] = temporMatrix[m][n] + calculatedMatrix[m][n];
			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			if (j == i)
			{
				temporMatrix[i][j] = 1;
			}
			else if (temporMatrix[i][j] != 0)
			{
				temporMatrix[i][j] = 1;
			}
			{

			}
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			reachableMatrix[i][j] = temporMatrix[i][j];
		}
	}

	for (int i = 0; i < matrixSize; i++)
	{
		free(temporMatrix[i]);
		free(calculatedMatrix[i]);
	}
	free(temporMatrix);
	free(calculatedMatrix);
}

/*
  a b c d e f
a 0 1 0 0 0 0
b 1 1 1 0 0 0
c 0 1 0 2 0 0
d 0 0 2 0 1 0
e 0 0 0 1 0 0
f 0 0 0 0 0 0
*/

/*
				a     b     c     d     e
		  a   (1,1) (1,2) (1,3) (1,4) (1,5)
		  b   (2,1) (2,2) (2,3) (2,4) (2,5)
		  c   (3,1) (3,2) (3,3) (3,4) (3,5)
		  d   (4,1) (4,2) (4,3) (4,4) (4,5)
		  e   (5,1) (5,2) (5,3) (5,4) (5,5)
*/
int main(int argc, char** argv[], char** env[])
{
	// -------------------------- 设置矩阵阶数 -------------------------- //
	int matrixSize = 0;
	std::cout << "设置矩阵的阶数：";
	scanf_s("%d", &matrixSize);

	// -------------------------- 初始化矩阵数组(动态分配二维数组) -------------------------- //
	int** matrixArray = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		matrixArray[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	setMatrixArray(matrixArray, matrixSize);

	// ---------------------------------------- Test:求长度为3的矩阵 ---------------------------------------- //
	//multiplicineMatrixResult(matrixArray, matrixSize, 2);

	// ---------------------------------------- Test:求长度范围为0-3，点(1,4)的通路之和 ---------------------------------------- //
	std::cout << getCountPointRangeLength(matrixArray, matrixSize, 3, 1, 4) << std::endl;

	// ---------------------------------------- Test:求长度为3的通路（即某点的值） ---------------------------------------- //
	std::cout << getPointSetLength(matrixArray, matrixSize, 3, 1, 4) << std::endl;

	// ---------------------------------------- Test:求自定义的多个长度的通路或回路 ---------------------------------------- //
	int testLengthSize = 4;
	int testLength[4] = { 1,2,3,4 };
	int* acceptArray = (int*)malloc(testLengthSize * sizeof(int));	
	getArrayCustomMultiLength(matrixArray, matrixSize, testLength, testLengthSize, 1, 1, acceptArray);
	for (int i = 0; i < testLengthSize; i++)
	{
		std::cout << i << ":" << acceptArray[i] << std::endl;;
	}
	free(acceptArray);

	// ---------------------------------------- Test:求长度内所有通路或回路（包括或不包括回路） ---------------------------------------- //
	std::cout << "Access of Include Loop: " << getAllPointRangeLengthAccess_HaveLoop(matrixArray, matrixSize, 5) << std::endl;

	std::cout << "Access of Not Include Loop: " << getAllPointRangeLengthAccess_NotLoop(matrixArray, matrixSize, 5) << std::endl;
	
	std::cout << "All of Loop : " << getAllPointRangeLengthLoop(matrixArray, matrixSize, 5) << std::endl;

	// ---------------------------------------- Test:求某个矩阵的可达矩阵 ---------------------------------------- //
	std::cout << std::endl;
	int** testResultMatrix = (int**)malloc(matrixSize * sizeof(int*));
	for (int i = 0; i < matrixSize; i++)
	{
		testResultMatrix[i] = (int*)malloc(matrixSize * sizeof(int));
	}
	getReachableMatrix(matrixArray, matrixSize, testResultMatrix);
	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			std::cout << testResultMatrix[i][j] << " ";
		}
		printf("\n");
	}
	for (int i = 0; i < matrixSize; i++)
	{
		free(testResultMatrix[i]);
	}
	free(testResultMatrix);

	// ----------------------------- Free ----------------------------- //
	for (int i = 0; i < matrixSize; i++)
	{
		free(matrixArray[i]);
	}
	free(matrixArray);

	return 0;
}

Github

工程下载：
https://github.com/sks853/GraphicMatrix
工程配置：VS 2019 Pro

◎天启疯车℡
关注
专栏目录
C/C++ hamiltons cycle哈密尔顿环算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-17 6558
哈密尔顿环算法（Hamiltonian cycle algorithm）是一种用于寻找图中存在的哈密尔顿环的算法。哈密尔顿环是指一个简单回路，经过图中每个顶点一次且仅一次。该算法的目标是找到图中的一个哈密尔顿环，或者确定不存在哈密尔顿环。
【离散数学】无向欧拉图的判定 （c++）
weixin_51014226的博客
12-09 5328
实验要求： 1.给定一非负整数序列（例如：(4,2,2,2,2)）。 2.判断此非负整数序列是否是可图化的，是否是可简单图化的。 3.如果是可简单图化的，根据Havel定理过程求出对应的简单图，并输出此简单图的相邻矩阵（默认第i行对应顶点vi）。 4.判断此简单图是否是连通的。 5.如果是连通图，判断此图是否是欧拉图。如果是欧拉图，请输出一条欧拉回路（输出形式如：v2->v1->v5->v3->v4->v5->v2）。 --------------------------
可达矩阵求法
09-17
VC编写的可达矩阵求法 动态分配一维数组 去掉字符串中的空格和回车 将字符型转换成整型
怎么通过邻接矩阵求图的通路总数和回路总数？
最新发布
naozibuok的博客
12-02 3100
通路总数 = 邻接矩阵所有元素的之和。回路总数 = 邻接矩阵对角线元素之和。
懒癌晚期学图论的时候自己用C语言写了个求可达性矩阵的算法~
weixin_30888027的博客
11-06 287
可达性矩阵算法~ 直接上代码 #include <iostream> #include <cstring> using namespace std; #define n 5 void print(int a[n][n]); void print1(int a[n][n]); void multiply(int a[n][n],int b[n][n],int c[n][n])...
C语言由邻接矩阵求可达矩阵算法,邻接矩阵与可达矩阵计算.pdf
weixin_42398171的博客
05-23 3963
暨南大学应急管理学院1. 邻接矩阵本部分内容出自 《离散数学》图论章节1. 邻接矩阵 邻接矩阵的定义设G＝是一个简单图，它有n个结点V ＝{v ，v ，…，v }，则n阶方阵A(G) ＝1 2 n(a )称为G的邻接矩阵。ij1 V 与V 之间存在关系；i jaij0 V 与V 之间没有关系或者相同；i j1. 邻...
离散数学期末复习-邻接矩阵求通路回路数
热门推荐
博客地址 www.sec0nd.top
07-01 1万+
文章目录无向图的关联矩阵定义性质举例有向图的关联矩阵定义举例和性质有向图的邻接矩阵定义和性质举例![在这里插入图片描述](https://img-blog.csdnimg.cn/20210701182811543.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjQ0NDA0NQ==,size_16,color_FFFFFF,t
JAVA实现求矩阵表示的无向图的欧拉通路、回路及欧拉图判定
09-25
本话题主要探讨如何使用Java编程语言处理矩阵表示的无向图，判断是否存在欧拉通路和欧拉图，并找到欧拉回路。 首先，让我们了解什么是欧拉通路和欧拉回路。在无向图中，如果可以从任意一个顶点出发，经过图中所有的...
邻接矩阵 有向图 判断是否有环 是否连通 DFS C实现~
Unyielding will
08-05 7079
通过 对DFS 搜索 修改 实现 了 根据有无（反向边）判断是否 有环 ， 并且可以计算连通分量个数 并判断 是否连通。
NOIP普及讲座7-图的基本知识(C++版).ppt
11-15
奇点和偶点是根据度的奇偶性来划分的，一个无向图中，所有顶点的度数之和是边数的两倍，而有向图的入度之和等于出度之和。 最后，课程通过小练习加深对这些概念的理解，比如判断图是否具有欧拉路径或哈密尔顿回路，...
计算可达矩阵
02-14
通过定义，在已知连接矩阵的前提下，计算可达矩阵。理解简单，但计算负责都较高。
无向图的连通性
07-18
图文并茂地介绍了割点，桥，双连通子图，双连通分支，最近公共祖先（LCA）， 其中穿插着例题与习题，每个知识点均有模板。
欧拉回路C++程序（随机给图求欧拉回路）
04-17
欧拉回路C++程序 随机输入任意点数，给出图中存在的欧拉回路
快速求解邻接矩阵对应的可达矩阵
03-09
该代码是通过C语言编程实现，主要是为了快速求解邻接矩阵对应的可达矩阵，邻接矩阵和可达矩阵是系统工程中表征系统元素之间关系的重要工具之一
已知邻接矩阵，求可达矩阵
01-17
已知邻接矩阵，求可达矩阵的MATLAB代码
[C++]有向图的简单路径
m0_46401512的博客
06-11 4057
一、题目描述 (1).求出有向图中从起点到终点的所有简单路径。其中起点和终点可以由用户自行设定。 (2).求出有向图中从起点到终点的指定长度（如K）的所有简单路径。其中起点和终点可以由用户自行设定。 二、解决方案 1.任务定义和问题分析 首先建立图的邻接矩阵来表示图,0表示无边，非0的n代表边的权值(边的长度); 用vector < int > path储存路径(path记录图的点来表示路径); 采用BFS(深度遍历)的方法来遍历所有的路径，符合的路径则进path并输出; 2.详细设计 a.
利用关系矩阵求图的通路和回路个数（离散数学课程报告）
m0_73739116的博客
06-03 864
【代码】利用关系矩阵求图的通路和回路个数（离散数学课程报告）
C/C++ 图中两个顶点的通路数
JunfuChang
06-16 692
推荐阅读：Python基础自学实用笔记（总和篇）-By Ryan_3610 6、题目：图中两个顶点的通路数 6.1代码 #include <iostream> #include <stdio.h> using namespace std; int main() { //输入 int n; int num1[10][10]={0}; int num[10][10]; cin>>n; for(int i=0;i<n;i++)
【创】C/C++无向图-邻接矩阵表示法 & DFS & BFS & 连通图 & 回路
ChristinaXinny的博客
06-04 1557
创建一个邻接矩阵表示法表示的无向图 算法如下： 按照输入顺序，依次将顶点存入顶点表中。 创建邻接矩阵（假设顶点信息唯一） 1 将临界矩阵初始化为0 2 根据输入的一条边的两个顶点u和v，确定u和v在顶点表中的位置i和j 3 将临界矩阵中第i行第j列和第j行第i列的值置为1 4 重复2.2-2.3直至所有边处理完毕 输入要求 输入有三部分组成 第一部分是2个整数n和m，表示图的定点数和边数 第二部分是由空格分割n个字符，表示n个顶点的信息。 第三部分由m行数据组成，每行数据是空格分割的2个字符，表示图中一
C++实现：邻接矩阵与邻接表的无向图/有向图构造与输出
本篇文档提供了针对C++初学者的实例代码，主要讲解如何在C++中建立并输出四种类型的图：无向图、有向图、无向网和有向网。以下是详细的知识点解析： 1. **邻接矩阵**： 邻接矩阵是一种用二维数组表示图的方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值