离散数学及其应用傅彦pdf_《离散数学及其应用》第二章 计算机课题

最新推荐文章于 2021-08-10 15:26:37 发布
最新推荐文章于 2021-08-10 15:26:37 发布
阅读量451 收藏
点赞数
文章标签： 离散数学及其应用傅彦pdf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36086687/article/details/112411596
版权

701ca4559e1902dc0258c695b62b23ab.png

C++实现：

由于标准库只支持定长位串，使用可变位串表示集合更加灵活，所以使用了C++的准标准库Boost库中的可变位串，用定长位串来代替也是可以的。

1.

#include <iostream>
#include <boost/dynamic_bitset.hpp>
#include <boost/utility.hpp>

using std::cout;
using std::endl;

using boost::dynamic_bitset;

int main()
{
	// 集合元素数
	const size_t n = 32;
	// 初始化A为n位的0...0011
	dynamic_bitset<> A(n, BOOST_BINARY(011));
	// 初始化A为n位的0...0110
	dynamic_bitset<> B(n, BOOST_BINARY(110));
	cout << "A的补集:" << ~A << endl;
	cout << "A与B的并集:" << (A | B) << endl;
	cout << "A与B的交集:" << (A & B) << endl;
	cout << "A与B的差集:" << (A - B) << endl;
	cout << "A与B的异或:" << (A ^ B) << endl;
    return 0;
}

2.

#include <iostream>
#include <map>
#include <set>
#include <string>

using std::cout;
using std::endl;
using std::set;
using std::map;
using std::string;

// 多重集合并集：
template<typename T>
void MultiSetAnd(map<T, size_t> &inputSet1, map<T, size_t> &inputSet2, map<T, size_t> &outputSet)
{
	outputSet.clear();
	// 遍历元素，进行或操作
	for (const auto &ele : inputSet1)
	{
		T key = ele.first;
		size_t cnt1 = inputSet1[key];
		size_t cnt2 = inputSet2[key];
		if (cnt1 < cnt2)
			outputSet[key] = cnt1;
		else
			outputSet[key] = cnt2;
	}
}

// 多重集合交集：
template<typename T>
void MultiSetOr(map<T, size_t> &inputSet1, map<T, size_t> &inputSet2, map<T, size_t> &outputSet)
{
	outputSet.clear();
	// 遍历元素，进行或操作
	for (const auto &ele : inputSet1)
	{
		T key = ele.first;
		size_t cnt1 = inputSet1[key];
		size_t cnt2 = inputSet2[key];
		if (cnt1 > cnt2)
			outputSet[key] = cnt1;
		else
			outputSet[key] = cnt2;
	}
}

// 多重集合差集：
template<typename T>
void MultiSetMinus(map<T, size_t> &inputSet1, map<T, size_t> &inputSet2, map<T, size_t> &outputSet)
{
	outputSet.clear();
	// 遍历元素，进行或操作
	for (const auto &ele : inputSet1)
	{
		T key = ele.first;
		size_t cnt1 = inputSet1[key];
		size_t cnt2 = inputSet2[key];
		// 防止无符号数溢出
		if (cnt1 <= cnt2)
			outputSet[key] = 0;
		else
			outputSet[key] = cnt1 - cnt2;
	}
}

// 多重集合和集：
template<typename T>
void MultiSetAdd(map<T, size_t> &inputSet1, map<T, size_t> &inputSet2, map<T, size_t> &outputSet)
{
	outputSet.clear();
	// 遍历元素，进行或操作
	for (const auto &ele : inputSet1)
	{
		T key = ele.first;
		outputSet[key] = inputSet1[key] + inputSet2[key];
	}
}

int main()
{
	// 指定全集元素
	const set<string> U{ "a","b","c","d" };
	// 使用map(键值对)分别来保存集合元素和元素个数
	map<string, size_t> A, B, C;
	// 给A和B分别赋值
	size_t cnt = 0;
	for (const auto &ele : U)
	{
		A[ele] = cnt;
		B[ele] = U.size() - cnt++;
	}
	// 检验赋值是否正确
	cout << "A：" << endl;
	for (const auto &ele : A)
		cout << ele.first << ":" << ele.second << endl;
	cout << "B：" << endl;
	for (const auto &ele : B)
		cout << ele.first << ":" << ele.second << endl;

	cout << "多重集合交集：" << endl;
	MultiSetOr(A, B, C);
	for (const auto &ele : C)
		cout << ele.first << ":" << ele.second << endl;
	cout << "多重集合并集：" << endl;
	MultiSetAnd(A, B, C);
	for (const auto &ele : C)
		cout << ele.first << ":" << ele.second << endl;
	cout << "多重集合差集：" << endl;
	MultiSetMinus(A, B, C);
	for (const auto &ele : C)
		cout << ele.first << ":" << ele.second << endl;
	cout << "多重集合和集：" << endl;
	MultiSetAdd(A, B, C);
	for (const auto &ele : C)
		cout << ele.first << ":" << ele.second << endl;

    return 0;
}

3.

#include <iostream>
#include <map>
#include <set>
#include <string>

using std::cout;
using std::endl;
using std::set;
using std::map;
using std::string;

// 模糊集合并集：
template<typename T>
void FuzzySetAnd(map<T, double> &inputSet1, map<T, double> &inputSet2, map<T, double> &outputSet)
{
	outputSet.clear();
	// 遍历元素，进行或操作
	for (const auto &ele : inputSet1)
	{
		T key = ele.first;
		double cnt1 = inputSet1[key];
		double cnt2 = inputSet2[key];
		if (cnt1 < cnt2)
			outputSet[key] = cnt1;
		else
			outputSet[key] = cnt2;
	}
}

// 模糊集合交集：
template<typename T>
void FuzzySetOr(map<T, double> &inputSet1, map<T, double> &inputSet2, map<T, double> &outputSet)
{
	outputSet.clear();
	// 遍历元素，进行或操作
	for (const auto &ele : inputSet1)
	{
		T key = ele.first;
		double cnt1 = inputSet1[key];
		double cnt2 = inputSet2[key];
		if (cnt1 > cnt2)
			outputSet[key] = cnt1;
		else
			outputSet[key] = cnt2;
	}
}

// 模糊集合补集：
template<typename T>
void FuzzySetComple(map<T, double> &inputSet, map<T, double> &outputSet)
{
	outputSet.clear();
	// 遍历元素，进行或操作
	for (const auto &ele : inputSet)
		outputSet[ele.first] = 1 - ele.second;
}


int main()
{
	// 指定全集元素
	const set<string> U{ "a","b","c","d" };
	// 使用map(键值对)分别来保存集合元素和元素个数
	map<string, double> A, B, C;
	// 给A和B分别赋值，并将其所有值归一化到0到1之间
	double cnt = 0;
	for (const auto &ele : U)
	{
		A[ele] = cnt / U.size();
		B[ele] = (U.size() - cnt++) / U.size();
	}
	// 检验赋值是否正确
	cout << "A：" << endl;
	for (const auto &ele : A)
		cout << ele.first << ":" << ele.second << endl;
	cout << "B：" << endl;
	for (const auto &ele : B)
		cout << ele.first << ":" << ele.second << endl;

	cout << "模糊集合交集：" << endl;
	FuzzySetOr(A, B, C);
	for (const auto &ele : C)
		cout << ele.first << ":" << ele.second << endl;
	cout << "模糊集合并集：" << endl;
	FuzzySetAnd(A, B, C);
	for (const auto &ele : C)
		cout << ele.first << ":" << ele.second << endl;
	cout << "A的补集：" << endl;
	FuzzySetComple(A, C);
	for (const auto &ele : C)
		cout << ele.first << ":" << ele.second << endl;
	return 0;
}

4、5和6题应该只需要根据定义，遍历映射关系即可实现判断。

7.

#include <iostream>
#include <vector>
#include <cstdint>
#include <stdexcept>

using std::cout;
using std::endl;
using std::vector;
using std::runtime_error;


/* 功能：矩阵乘法
 * 参数：matrix_left为矩阵乘法左侧的矩阵，matrix_right为矩阵乘法右侧的矩阵 类型均为vector<vector<double>>类型 
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<double>> Multi_Matrix(vector<vector<double>> matrix_left, vector<vector<double>> matrix_right)
{
	if (matrix_left.empty() || matrix_right.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	else if (matrix_left.at(0).empty() || matrix_right.at(0).empty())
	{
		throw runtime_error("Matrix Error!");
	}
	int32_t Row_matrix_left = matrix_left.size(), Col_matrix_left = matrix_left.at(0).size();
	int32_t Row_matrix_right = matrix_left.size(), Col_matrix_right = matrix_left.at(0).size();
	if (Col_matrix_left != Row_matrix_right)
	{
		throw runtime_error("Matrices cannot multiply!");
	}
	vector<double> init_vector(Col_matrix_right, 0);
	init_vector.shrink_to_fit();
	vector<vector<double>> Answer_matrix(Row_matrix_left, init_vector);
	Answer_matrix.shrink_to_fit();
	// 上面保证了结果矩阵的大小不会错
	for (int32_t row = 0; row < Row_matrix_left; ++row)
	{
		for (int32_t col = 0; col < Col_matrix_right; ++col)
		{
			for (int32_t cnt = 0; cnt < Col_matrix_left; ++cnt)
			{
				Answer_matrix[row][col] += matrix_left[row][cnt] * matrix_right[cnt][col];
			}
		}
	}
	return Answer_matrix;
}

int main()
{
	vector<double> col(9, 0);
	vector<vector<double>> matrix1(9, col), matrix2(9, col);
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			matrix1[i][j] = j + 9 * i;
		}
	}
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			if (i == j)
			{
				matrix2[i][j] = 1;
			}
		}
	}
	matrix2 = Multi_Matrix(matrix1, matrix2);
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			cout << matrix2[i][j] << " ";
		}
		cout << endl;
	}
	return 0;

8.

#include <iostream>
#include <vector>
#include <cstdint>
#include <stdexcept>

using std::cout;
using std::endl;
using std::vector;
using std::runtime_error;


/* 功能：矩阵乘法
 * 参数：matrix_left为矩阵乘法左侧的矩阵，matrix_right为矩阵乘法右侧的矩阵 类型均为vector<vector<double>>类型 
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<double>> Multi_Matrix(vector<vector<double>> matrix_left, vector<vector<double>> matrix_right)
{
	if (matrix_left.empty() || matrix_right.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	else if (matrix_left.at(0).empty() || matrix_right.at(0).empty())
	{
		throw runtime_error("Matrix Error!");
	}
	int32_t Row_matrix_left = matrix_left.size(), Col_matrix_left = matrix_left.at(0).size();
	int32_t Row_matrix_right = matrix_left.size(), Col_matrix_right = matrix_left.at(0).size();
	if (Col_matrix_left != Row_matrix_right)
	{
		throw runtime_error("Matrices cannot multiply!");
	}
	vector<double> init_vector(Col_matrix_right, 0);
	init_vector.shrink_to_fit();
	vector<vector<double>> Answer_matrix(Row_matrix_left, init_vector);
	Answer_matrix.shrink_to_fit();
	// 上面保证了结果矩阵的大小不会错
	for (int32_t row = 0; row < Row_matrix_left; ++row)
	{
		for (int32_t col = 0; col < Col_matrix_right; ++col)
		{
			for (int32_t cnt = 0; cnt < Col_matrix_left; ++cnt)
			{
				Answer_matrix[row][col] += matrix_left[row][cnt] * matrix_right[cnt][col];
			}
		}
	}
	return Answer_matrix;
}

/* 功能：方阵幂
 * 参数：matrix为方阵，类型为vector<vector<double>>类型,n为幂次数，类型为int32_t
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<double>> Power_Matrix(vector<vector<double>> matrix, int32_t n)
{
	if (matrix.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	int32_t Row_matrix = matrix.size(), Col_matrix = matrix.at(0).size();
	if (Row_matrix != Col_matrix)
	{
		throw runtime_error("Matrix is not square!");
	}
	vector<vector<double>> copy_matrix = matrix;
	for (int32_t cnt = 2; cnt < n; ++cnt)
	{
		matrix = Multi_Matrix(matrix, copy_matrix);
	}
	return matrix;
}

int main()
{
	vector<double> col(9, 0);
	vector<vector<double>> matrix1(9, col), matrix2(9, col);
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			matrix1[i][j] = j + 9 * i;
		}
	}
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			if (i == j)
			{
				matrix2[i][j] = 1;
			}
		}
	}
	// matrix2 = Multi_Matrix(matrix1, matrix2);
	matrix2 = Power_Matrix(matrix2, 20);
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			cout << matrix2[i][j] << " ";
		}
		cout << endl;
	}
	return 0;
}

9.

#include <iostream>
#include <vector>
#include <cstdint>
#include <stdexcept>


using std::cout;
using std::endl;
using std::vector;
using std::runtime_error;


/* 功能：矩阵乘法
 * 参数：matrix_left为矩阵乘法左侧的矩阵，matrix_right为矩阵乘法右侧的矩阵 类型均为vector<vector<double>>类型 
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<double>> Multi_Matrix(vector<vector<double>> matrix_left, vector<vector<double>> matrix_right)
{
	if (matrix_left.empty() || matrix_right.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	else if (matrix_left.at(0).empty() || matrix_right.at(0).empty())
	{
		throw runtime_error("Matrix Error!");
	}
	int32_t Row_matrix_left = matrix_left.size(), Col_matrix_left = matrix_left.at(0).size();
	int32_t Row_matrix_right = matrix_left.size(), Col_matrix_right = matrix_left.at(0).size();
	if (Col_matrix_left != Row_matrix_right)
	{
		throw runtime_error("Matrices cannot multiply!");
	}
	vector<double> init_vector(Col_matrix_right, 0);
	init_vector.shrink_to_fit();
	vector<vector<double>> Answer_matrix(Row_matrix_left, init_vector);
	Answer_matrix.shrink_to_fit();
	// 上面保证了结果矩阵的大小不会错
	for (int32_t row = 0; row < Row_matrix_left; ++row)
	{
		for (int32_t col = 0; col < Col_matrix_right; ++col)
		{
			for (int32_t cnt = 0; cnt < Col_matrix_left; ++cnt)
			{
				Answer_matrix[row][col] += matrix_left[row][cnt] * matrix_right[cnt][col];
			}
		}
	}
	return Answer_matrix;
}

/* 功能：方阵幂
 * 参数：matrix为方阵，类型为vector<vector<double>>类型,n为幂次数，类型为int32_t
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<double>> Power_Matrix(vector<vector<double>> matrix, int32_t n)
{
	if (matrix.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	int32_t Row_matrix = matrix.size(), Col_matrix = matrix.at(0).size();
	if (Row_matrix != Col_matrix)
	{
		throw runtime_error("Matrix is not square!");
	}
	vector<vector<double>> copy_matrix = matrix;
	for (int32_t cnt = 2; cnt < n; ++cnt)
	{
		matrix = Multi_Matrix(matrix, copy_matrix);
	}
	return matrix;
}

/* 功能：判断是否对称
 * 参数：matrix为方阵，类型为vector<vector<double>>类型,
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
bool isSymmetrical(vector<vector<double>> matrix)
{
	if (matrix.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	int32_t Row_matrix = matrix.size(), Col_matrix = matrix.at(0).size();
	if (Row_matrix != Col_matrix)
	{
		throw runtime_error("Matrix is not square!");
	}
	for (int32_t row = 0; row < Row_matrix; ++row)
	{
		for (int32_t col = 0; col < Col_matrix; ++col)
		{
			if (matrix[row][col] != matrix[col][row])
			{
				return false;
			}
		}
	}
	return true;
}

int main()
{
	vector<double> col(9, 0);
	vector<vector<double>> matrix1(9, col), matrix2(9, col);
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			matrix1[i][j] = j + 9 * i;
		}
	}
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			if (i == j)
			{
				matrix2[i][j] = 1;
			}
		}
	}
	// matrix2 = Multi_Matrix(matrix1, matrix2);
	matrix2 = Power_Matrix(matrix2, 20);
	cout << isSymmetrical(matrix1) << endl;
	cout << isSymmetrical(matrix2) << endl;
	for (int32_t i = 0; i < 9; ++i)
	{
		for (int32_t j = 0; j < 9; ++j)
		{
			cout << matrix2[i][j] << " ";
		}
		cout << endl;
	}
	return 0;
}

10、11和12题的合并实现:

#include <iostream>
#include <vector>
#include <cstdint>
#include <stdexcept>

using std::cout;
using std::endl;
using std::vector;
using std::runtime_error;


/* 功能：布尔矩阵交
 * 参数：matrix_1为矩阵1，matrix_2为矩阵2，类型均为vector<vector<bool>>类型
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<bool>> Or_Bool_Matrix(vector<vector<bool>> matrix_1, vector<vector<bool>> matrix_2)
{
	if (matrix_1.empty() || matrix_2.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	else if (matrix_1.at(0).empty() || matrix_2.at(0).empty())
	{
		throw runtime_error("Matrix Error!");
	}
	int32_t Row_matrix_1 = matrix_1.size(), Col_matrix_1 = matrix_1.at(0).size();
	int32_t Row_matrix_2 = matrix_2.size(), Col_matrix_2 = matrix_2.at(0).size();
	if (Row_matrix_1 != Row_matrix_2 || Col_matrix_1 != Col_matrix_2)
	{
		throw runtime_error("Matrices do not have same size!");
	}
	for (int32_t row = 0; row < Row_matrix_1; ++row)
	{
		for (int32_t col = 0; col < Col_matrix_1; ++col)
		{
			matrix_1[row][col] = matrix_1[row][col] || matrix_2[row][col];
		}
	}
	return matrix_1;
}

/* 功能：布尔矩阵并
* 参数：matrix_1为矩阵1，matrix_2为矩阵2，类型均为vector<vector<bool>>类型
* 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
*/
vector<vector<bool>> And_Bool_Matrix(vector<vector<bool>> matrix_1, vector<vector<bool>> matrix_2)
{
	if (matrix_1.empty() || matrix_2.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	else if (matrix_1.at(0).empty() || matrix_2.at(0).empty())
	{
		throw runtime_error("Matrix Error!");
	}
	int32_t Row_matrix_1 = matrix_1.size(), Col_matrix_1 = matrix_1.at(0).size();
	int32_t Row_matrix_2 = matrix_2.size(), Col_matrix_2 = matrix_2.at(0).size();
	if (Row_matrix_1 != Row_matrix_2 || Col_matrix_1 != Col_matrix_2)
	{
		throw runtime_error("Matrices do not have same size!");
	}
	for (int32_t row = 0; row < Row_matrix_1; ++row)
	{
		for (int32_t col = 0; col < Col_matrix_1; ++col)
		{
			matrix_1[row][col] = matrix_1[row][col] && matrix_2[row][col];
		}
	}
	return matrix_1;
}

/* 功能：布尔矩阵乘法
 * 参数：matrix_left为矩阵乘法左侧的矩阵，matrix_right为矩阵乘法右侧的矩阵 类型均为vector<vector<bool>>类型 
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<bool>> Multi_Bool_Matrix(vector<vector<bool>> matrix_left, vector<vector<bool>> matrix_right)
{
	if (matrix_left.empty() || matrix_right.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	else if (matrix_left.at(0).empty() || matrix_right.at(0).empty())
	{
		throw runtime_error("Matrix Error!");
	}
	int32_t Row_matrix_left = matrix_left.size(), Col_matrix_left = matrix_left.at(0).size();
	int32_t Row_matrix_right = matrix_left.size(), Col_matrix_right = matrix_left.at(0).size();
	if (Col_matrix_left != Row_matrix_right)
	{
		throw runtime_error("Matrices cannot multiply!");
	}
	vector<bool> init_vector(Col_matrix_right, 0);
	init_vector.shrink_to_fit();
	vector<vector<bool>> Answer_matrix(Row_matrix_left, init_vector);
	Answer_matrix.shrink_to_fit();
	// 上面保证了结果矩阵的大小不会错
	for (int32_t row = 0; row < Row_matrix_left; ++row)
	{
		for (int32_t col = 0; col < Col_matrix_right; ++col)
		{
			for (int32_t cnt = 0; cnt < Col_matrix_left; ++cnt)
			{
				Answer_matrix[row][col] = Answer_matrix[row][col] || (matrix_left[row][cnt] && matrix_right[cnt][col]);
			}
		}
	}
	return Answer_matrix;
}

/* 功能：方阵幂
 * 参数：matrix为方阵，类型为vector<vector<bool>>类型,n为幂次数，类型为int32_t
 * 备注：matrix[0][1]代表0行1列，若出现错误，则会抛出错误，请注意。
 */
vector<vector<bool>> Power_Bool_Matrix(vector<vector<bool>> matrix, int32_t n)
{
	if (matrix.empty())
	{
		throw runtime_error("Matrix cannot be empty!");
	}
	int32_t Row_matrix = matrix.size(), Col_matrix = matrix.at(0).size();
	if (Row_matrix != Col_matrix)
	{
		throw runtime_error("Matrix is not square!");
	}
	vector<vector<bool>> copy_matrix = matrix;
	for (int32_t cnt = 2; cnt < n; ++cnt)
	{
		matrix = Multi_Bool_Matrix(matrix, copy_matrix);
	}
	return matrix;
}

文章来源：

《离散数学及其应用》第二章 计算机课题 - Ace C Lee 个人网站​aceclee.com

对计算机科学或者日语感兴趣的同学可以访问我的网站，里面有很多计算机和日语相关的干货哦！

Ace C Lee 个人网站 - 我的个人网站​aceclee.com
里油哪多
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
离散数学及应用
04-28
很经典的一部离散数学著作 ，本书系统阐述了离散数学的经典内容，包括命题逻辑、谓词逻辑、集合、关系、代数系统、图论等方面的基本知识。本书根据计算机科学各专业的需要选择内容、把握尺度，尽可能将离散数学知识和计算机科学中的实际问题相结合。本书编排新颖，每章通过定义、定理、实例、例等形式将内容有机结合、融会贯通，达到学练兼顾的目的。本书加入了机上实现内容，满足了普通高校理工类本科生的实际需求。 本书书末还提供了离散数学常用符号、中英文名词术语对照表、英中文名词术语对照表以及习题答案与提示，能很好地帮助读者理解和学习。 本书既可作为应用型本科和高职高专院校计算机科学各专业的教材，也可作为工程技术人员的参考书。
离散数学及其应用 第三章：命题逻辑
Chtholly_Nota_L的博客
07-08 3576
命题逻辑命题原子命题复合命题命题联结词联结词的难点需要注意以下几点：命题公式命题公式的分类基本等价关系联结词的完备集公式的标准型---范式析取范式和合取范式极大项和极小项极大项与极小项的编码写主析取范式 命题 具有确切真值的陈述句称为命题 原子命题 不能再分解为更简单命题的命题 复合命题 可以分解为更简单命题的命题 命题联结词 联结词 记号 否定 ¬\neg¬ 合取 ∧\land∧ 析取 ∨\lor∨ 蕴含 →\to→ 等价 ↔\leftrightarrow↔ 注意这里的
离散数学及其应用（一）
qq_39210428的博客
08-10 2937
逻辑规则给出数学语句的准确含义，这些规则用来区分有效和无效的数学论证。逻辑规则用于计算机电路设计、计算机程序构造、程序正确性证明等等。
离散数学及其应用傅彦pdf_离散数学及其应用 傅彦 等 高等教育出版社
weixin_39980917的博客
02-12 4237
前辅文篇 预 备 知 识引言第1章 集合论1.0 内容提要1.1 学习要求1.2 集合1.3 无限集1.4 集合的应用1.5 本章总结1.6 习题第2章 计数问题2.0 内容提要2.1 学习要求2.3 排列与组合2.4 容斥原理与鸽笼原理2.5 本章总结2.6 习题第二篇 数 理 逻 辑引言第3章 命题逻辑3.0 内容提要3.1 学习要求3.2 命题与命题联结词3.3 命题公式、解释与真值表*3....
离散数学及其应用傅彦pdf_《离散数学及其应用》第二章 计算与探索
weixin_34358799的博客
01-06 722
C++实现:1.由于只用实现两个有限集的笛卡尔积，应该就是回顾概念吧。#include <iostream> #include <map> #include <set> #include <string> using std::cout; using std::endl; using std::set; using std::string; //...
离散数学及其应用傅彦pdf_《离散数学及其应用》第一章 计算与探索
weixin_34247778的博客
12-27 1314
不得不说，计算与探索和计算机课题的难度还是有一定差别的。接下来会给出第一章计算与探索中的第1到3题的实现：Q1：找出这样的正整数：它不是9个不同的正整数的立方和。当然，我们不用蛮力法来解题，手写9层循环也是很累的呀！（我当然不会告诉你我其实一开始用的就是蛮力法）好了，进入正题：我们需要找到9个不同的正整数，而且能够尽量节约时间，那么我们可以在《离散数学及其应用》的114页找到“集合的计算机表示”这...
离散数学及其应用傅彦pdf_2021高考数学热门考点最全笔记（领PDF打印版）
weixin_36368413的博客
12-17 901
《小确历》里收录了一句话“闲暇使人看清自己”，平日里忙于应付各种各样的学习任务，很难静下心来思考自己的学习方法、学习计划有没有问题。如果还没有，也可以借今天这篇高考数学热门考点笔记做自我评测、反思。本期福利：添加文末海报中老师微信，私信：年级+1127，获取本文PDF完整版高考数学热点笔记目录1．高考数学重难点：重点：函数，数列，三角函数，平面向量，圆锥曲线，立体几何。难点：函数、数列、...
傅 彦：离散数学及其应用习题解析
04-07
傅 彦：离散数学及其应用习题解析.pdf第一版答案
离散数学及其应用_傅彦_课后答案
11-08
离散数学及其应用_傅彦_课后答案_khdaw
离散数学及其应用-21689.zip
06-17
离散数学及其应用-21689.zip
离散数学第二版
07-30
离散数学答案，屈婉玲等清华大学出版社，希望对下载者有帮助
离散数学(第二版)答案
06-10
这是清华大学出版社<> (第2版)答案,作者屈婉玲
离散数学及其应用答案
11-04
离散数学及其应用 傅彦 顾小丰 王庆先 刘启和 答案 高等教育出版社
傅彦 离散数学 答案
11-30
离散数学及其应用习题解析.pdf ，这是标准答案哦
离散数学及其应用技术编号习题答案
07-12
离散数学及其应用（罗森，第七版）是许多高校计算机系使用的离散数学教材。书中附有大量的练习题，该资源为对应的偶数习题的答案（答案为中文）
离散数学及其应用怎么样_科研进阶 | 达特茅斯学院 | 计算机科学、数学：离散数学及其应用（7月开课）...
weixin_39743695的博客
12-08 116
项目价格：￥29800 课题名称离散数学及其应用 开课日期7月，具体时间待定(名额有限，先到先得～ 导师介绍1. 主导师：●达特茅斯学院数学正教授、数学系副主任●麻省理工学院博士●累计发表高水平论文50余篇，并于各大国际会议和研讨会演讲100余次●曾主持组织了代数组合学领域最大的国际会议FPSAC’18●研究领域：计数组合学及其在动力系统和计算生...
离散数学及其应用傅彦pdf_离散数学及其应用(第2版国家精品课程主讲教材)：傅彦//顾小丰//王庆先//刘启和 : 数理化学科 :数理化学科 :数学 ...
weixin_39820185的博客
12-22 3560
导语《离散数学及其应用(第2版国家精品课程主讲教材)》由傅彦、顾小丰、王庆先、刘启和编著，本书是国家精品课程“离散数学”的主讲教材，也是普通高等教育“十一五”国家级规划教材，系统介绍了数理逻辑、二元关系、图论、代数系统与布尔代数中有关的概念、定理及其证明方法。可作为高等学校计算机专业计算机科学方向、计算机工程方向“离散数学”必修课教材，也可作为其他相关专业“离散数学”课程教材。内容提要《离散数学及...
离散数学及其应用傅彦pdf
最新发布
03-01
离散数学是数学的一个分支，研究离散对象和离散结构的性质和关系。它主要涉及集合论、逻辑、图论、代数结构等内容，并且在计算机科学、信息科学、电子工程等领域有广泛的应用。 离散数学的应用非常广泛，以下是一些常见的应用领域： 1. 计算机科学：离散数学为计算机科学提供了基础理论，例如在算法设计与分析、数据结构、编译原理、计算机网络等方面都有应用。图论在网络拓扑、路由算法等方面有重要应用。 2. 信息科学：离散数学在信息论、密码学、编码理论等方面有应用。例如，布尔代数和逻辑门电路在计算机硬件设计中起着重要作用。 3. 电子工程：离散数学在电路设计、数字信号处理等方面有应用。例如，布尔代数和逻辑门电路在数字电路设计中起着重要作用。 4. 运筹学与优化：离散数学在运筹学和优化问题中有广泛应用。例如，图论在路径规划、最短路径等问题中有应用。 5. 组合数学：离散数学的一个重要分支是组合数学，它研究离散对象的排列组合和结构。组合数学在密码学、图论、编码理论等方面有应用。 关于傅彦pdf的介绍，很抱歉我无法提供相关信息。如果您需要获取相关资料，建议您在互联网上搜索相关资源或者向图书馆等机构咨询。希望能对您有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值