7-3 银行家算法--综合 (50 分)（思路+详解+分析输入）宝宝们 加油

最新推荐文章于 2024-07-25 21:13:04 发布
最新推荐文章于 2024-07-25 21:13:04 发布
阅读量3.3k 收藏 17
点赞数 18
分类专栏： 操作系统 银行家算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48508278/article/details/121070947
版权

算法 银行家算法

一：前言

这道题涉及到 银行家算法的申请资源 算法 还有 安全性检查的耍算法 那么强烈建议 把前面的学完再看本题
7-1 银行家算法–安全性检查 (20 分)
7-2 银行家算法–申请资源 (30 分)

二：题目

输入N个进程(N<=100)，以及M类资源（M<=100），初始化各种资源的总数，T0时刻资源的分配情况。例如： 假定系统中有5个进程{P0，P1，P2，P3，P4}和三类资源{A,B,C}，各种资源的数量分别为10、5、7，在T0时刻的资源分配
在这里插入图片描述
根据菜单选择相应操作：

1.初始化：第一行输入进程数量N，第二行输入资源类数M，第三行输入M类资源个类资源的总数，以下N行分别输入每个进程的名字，该进程对M类资源的最大需求以及已分配资源。

2.安全性检查：判断当前系统是否处于安全状态，若安全，输出“找到安全序列，处于安全状态。”否则，输出“找不到安全序列，处于不安全状态。”

3.申请资源：输入申请进程的名字和申请各类资源的数目。 若分配，输出”可以找到安全序列，可以分配。“若不分配，给出不分配的原因：

(1).若输入的进程的名字不正确，输出“查无此进程。”

(2).若申请的资源数目大于最大需求，输出“需求不合理，不予分配。”

(3).若申请的资源数目大于剩余资源，输出“剩余资源不足，不予分配。”

(4).若找不到安全序列，输出“找不到安全序列，不予分配。”
4.当前资源分配情况：按照格式输出当前资源分配情况，包括进程名称、最大需求、已获得资源、可利用资源向量。例如T0时刻，当前的资源分配情况如下：
在这里插入图片描述
输入格式:
先显示菜单（只显示一次），然后按照需求进行选择：
在这里插入图片描述
输出格式:
按照选择，输出相应数据。

输入样例1:
在这里给出一组输入。例如：

1
5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 2 0 0
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
2
0
结尾无空行

输出样例1:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
找到安全序列，处于安全状态。

结尾无空行
输入样例2:
在这里给出一组输入。例如：

1
5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 2 0 0
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
2
4
0
结尾无空行

输出样例2:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
找到安全序列，处于安全状态。
name max allocation need available
P0 7 5 3 | 0 1 0 | 7 4 3 | 3 3 2
P1 3 2 2 | 2 0 0 | 1 2 2 |
P2 9 0 2 | 3 0 2 | 6 0 0 |
P3 2 2 2 | 2 1 1 | 0 1 1 |
P4 4 3 2 | 0 0 2 | 4 3 0 |
结尾无空行

输入样例3:
在这里给出一组输入。例如：

1
5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 2 0 0
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
3
P1 1 0 2
0
结尾无空行

输出样例3:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
可以找到安全序列，可以分配。

结尾无空行
输入样例4:
在这里给出一组输入。例如：

1
5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 2 0 0
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
3
P6 1 0 2
0
结尾无空行

输出样例4:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
查无此进程。
结尾无空行
输入样例5:

在这里给出一组输入。例如：

1
5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 3 0 2
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
3
P4 3 3 0
0
结尾无空行

输出样例5:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
剩余资源不足，不予分配。
结尾无空行

输入样例6:
在这里给出一组输入。例如：

1

5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 3 0 2
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
3
P0 0 2 0
0
结尾无空行

输出样例6:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
找不到安全序列，不予分配。
结尾无空行

输入样例7:
在这里给出一组输入。例如：

1
5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 3 0 2
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
3
P1 2 2 0
0

结尾无空行
输出样例7:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
需求不合理，不予分配。
结尾无空行

输入样例8:
在这里给出一组输入。例如：

1
5
3
10 5 7
P0 7 5 3 0 1 0
P1 3 2 2 3 0 2
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 2 0 0 2
9
0
结尾无空行

输出样例8:
在这里给出相应的输出。例如：

******************
1.初始化
2.安全性检查
3.请求资源
4.当前资源分配情况
0.退出
******************
请选择：
输入错误，请重新输入！
结尾无空行

二：输入格式

1.

可能乖宝宝们想不出 这个题是如何输入的 又是如何实现各个功能的，其实就是发送一个请求 实现一个功能

2.接下来直接看贴心杰的演示用例

(1):这就是刚开始的状态（只出现一次）

在这里插入图片描述

(2):这是输入的选项1 实现的输入数据的功能

在这里插入图片描述

(3):这是输入了选项2 实现了检查当前系统是否是在安全状态下

在这里插入图片描述

(4):这是是实现了功能4 展现了各个阶段的的进程状态

在这里插入图片描述

三：思路

思路：1.我觉得你如果把前两道题做出来这道题就没那么难了
2.分析我们的写码思路
1>:根据示例我们能很轻松的知道这是标准的 菜单栏的功能选择
即你输入 1 就是让你输入 输入数据，输入其他选项就是实现其他功能
根据我们的示例 我们会发现每次都是先输入1因为那是要实现输入数据 功能
然后输完数据后 就可以 来进行其他功能

四：写码思路

就是先将整个框架建好，然后再挨个实现各个功能

五：DeBug方法

本题中我在解决好几个bug,不光光是拿上方的测试直接来用，而是输入一个用例后 我并没有 按示例当中的输入0直接退出 而是继续输入数据 这样解决的我好几个漏洞！所以贴心杰 在这里 仿佛把啥都想分享受给乖宝宝们，恨不得面对面解决你的疑问，平时也没人问，做出来也就分享给屏幕前的你了，这样我也很开心呀！！

六：来干了这杯代码

/**
	思路：1.我觉得你如果把前两道题做出来这道题就没那么难了
		  2.分析我们的写码思路
		    1>:根据示例我们能很轻松的知道这是标准的 菜单栏的功能选择
			  即你输入 1 就是让你输入 输入数据，输入其他选项就是实现其他功能
			  根据我们的示例  我们会发现每次都是先输入1因为那是要实现输入数据 功能
			  然后输完数据后 就可以 来进行其他功能 
*/

#include<bits/stdc++.h>
using namespace std;

int N,M;
string str;
vector<int>v1;//用于存放各种的资源总量 
vector<int>v2;//用于代表申请资源的进程申请的  资源量 
vector<int>v3;//用于记录最初的avaliable 

struct Node{
	string processName; 
	int a[10000];//Max
	int b[10000];//allocation 
	int c[10000];//need
	bool finish;
} node[10000];

//1.初始化输入功能 
void cinFunction(){
	cin >> N >> M;
	
	for(int i = 0; i < M; i++){
		int nums;
		cin >> nums;
		v1.push_back(nums);	
	} 
	
	for(int i = 0; i < N; i++){
		
		cin >> node[i].processName;
		
		//输入Max 
		for(int j = 0; j < M; j++){
			cin >> node[i].a[j]; 
		}
		//输入allovation  
		for(int j = 0; j < M; j++){

			cin >> node[i].b[j];
			
			v1[j] -= node[i].b[j];//这里是每次减去分配的资源 那么剩下的最后就是  available 
		}
		//计算need
		for(int j = 0; j < M; j++){
			node[i].c[j] = node[i].a[j] - node[i].b[j];
		} 
	
	}	
	
	//将最初的avaliable记录下来 
	for(int i = 0; i < M; i++){
		v3.push_back(v1[i]);
	} 
	
}

//用于判断是否有该进程
bool judgeExit(string str){
	
	for(int i = 0; i < N; i++){
		 if(str == node[i].processName){
		 	return true;
		 }
	}
	
	return false;
}

//用于计算此时的request 和 need
bool requestNeed(){
	
	int count  = 0;
	
	for(int i = 0;  i < N; i++){
        
		if(str == node[i].processName){
		
			for(int j = 0;  j < M; j++){
				if(v2[j] <= node[i].c[j]){//请求量 小于 need 
					count++;
				}
			}			
		}
		
		if(count == M){
			return true;
		}
	}
	
	return false;
	
}  
//用判断申请的资源数目是否大于剩余资源 
bool requestAvaliable(){
	int count  = 0;
	
	for(int j = 0; j < M; j++){
		if(v2[j] <= v1[j]){ //请求量 小于 avaliabale 
			count++;
		}
	}			
				
	if(count == M){
		return true;
	}
	
	return false;
	
}

//2.安全性检查
bool isSafe(){
	
	//注意每次进行安全的检查 都需要更新finish = false 否则 下一次再检查 finish 都等于 true了 
	for(int i = 0; i < N; i++){
		node[i].finish = false;
	}

	int cnt = 0;	
	for(int i = 0; i < N; i++){
	
		int count = 0;
		for(int j = 0; j < M; j++){
			
			if(node[i].c[j] <= v1[j]){
				count++;
			
			}else{
				break;//只要有一个不合适就 break 出去 
			}				
		}
				
		if(node[i].finish == false && count == M) {//count == M说明剩余的各个资源总量大于该进程的所需要的 
					
			for(int j = 0; j < M; j++){
				
				v1[j] += node[i].b[j];//那么此时剩余的资源总量为原来的加上 该进程释放其占有的资源
		 
			}	
			
			node[i].finish = true; 
			
			cnt++;//记录完成进程的个数 
			
		//	cout << node[i].processName << ' ';
				
			//此处牛逼之处在于 只要我们找到满足条件的就从-1开始继续寻找满足条件的 
			i = -1; 
			
			
		}					
	}
	
	if(cnt == N){
		return true;
	}
	
	return false;
} 

//进行一次 安全性检查 就需要 将 检查前的数据还原回去 否则当你进行了两次安全性检查
// 那么第一次结果正确  那么第二次的时候  此时的avaliable已经是全满状态

void toFormer(){
	
	for(int i = 0; i < M; i++){
		v1[i] = v3[i];
	}
} 

//3.申请资源 
void apply_Resources(){
	
	cin >> str;
	
	for(int i = 0; i < M; i++){
		int temp;
		cin >> temp;
		v2.push_back(temp);
	}
		
	if(judgeExit(str) == false){
		cout << "查无此进程。" << endl;
		//state();
	}else if(requestNeed() == false){
		cout << "需求不合理，不予分配。" << endl;
	//	state();
	}else if(requestAvaliable() == false) {
		cout << "剩余资源不足，不予分配。" << endl;
	//	state();
	}
	//此时开始将申请的资源赋值给该进程同时进行安全检测 
	else if(judgeExit(str) == true && requestNeed() == true && requestAvaliable() == true){
	 	
	 	for(int i = 0; i < N; i++){
	 		
	 		if(str == node[i].processName){
	 			
	 			for(int j = 0; j < M; j++){
	 				
					 node[i].b[j] += v2[j];//这里是更新 该进程的allocation 
					 node[i].c[j] -= v2[j];//这里是更新 该进程的need
					 v1[j] -= v2[j]; //这里是更新 该进程的avaliable 
					 v3[j] -= v2[j];//存放 最初 avaliable的	
				 }
			 }	 		
		} 
		 
		 if(isSafe() == true){
		 	cout << "可以找到安全序列，可以分配。" << endl;
		 	toFormer();//只要一进行安全性检查 就需要将avaliable 还原回去 
		 //	state();
		 }else{
		 	cout << "找不到安全序列，不予分配。" << endl;
		 	toFormer();//只要一进行安全性检查 就需要将avaliable 还原回去 
		 	
		 	//如果不满足条件的话 需要将原来 进程的的资源分配形式输出来 
		 	for(int i = 0; i < N; i++){
	 		
		 		if(str == node[i].processName){
		 			
		 			for(int j = 0; j < M; j++){
		 				
						 node[i].b[j] -= v2[j];//这里是更新 该进程的allocation 
						 node[i].c[j] += v2[j];//这里是更新 该进程的need
						 v1[j] += v2[j]; //这里是更新 该进程的avaliable 
						 v3[j] += v2[j];//存放 最初 avaliable的	
					 }
				 }	 		
			} 
		 		
		 //	state();
		 } 
		 	
	} 
	
	//注意每次都要清理这个vector容器 因为 当你下一次再往里装数据时 他不是从下标为0的
	//地方装的,而是从你上次填装的截至为止开始的 
	v2.clear(); 
		
}




//4.当前的资源情况 
void state(){
	int flag = 0;
    
	cout << "name max allocation need available" << endl;
	
	for(int i = 0; i < N; i++){
		
		cout << node[i].processName << ' ';
		for(int j = 0; j < M; j++){
		 
		 cout << node[i].a[j] << ' ';			
		}			
		
		cout << "| ";
		
		for(int j = 0; j < M; j++){
		 
		 cout << node[i].b[j] << ' ';			
		}
		
		cout << "| ";
		
		for(int j = 0; j < M; j++){
		 
		 cout << node[i].c[j] << ' ';			
		}
		
		cout << "|";
		
		if(flag == 0){
		
           
			for(int j = 0; j < M; j++){
			 
                if(j == 0)
                    cout << ' ' <<v3[j];
                else
			        cout << ' ' <<v3[j] ;				 			
			}	
			
			flag = 1;		
		}	
		
			cout << endl;	
		}
}


void init(){
	
		cout << "******************" << endl;
		cout << "1.初始化" << endl;
		cout << "2.安全性检查" << endl;
		cout << "3.请求资源" << endl;
		cout << "4.当前资源分配情况" << endl;
		cout << "0.退出" << endl;
		cout << "******************" << endl;
		cout << "请选择：" << endl ;
}

int main(){
	
	int option;
	bool flag = false;
	
	init(); 
	
	while(flag == false){
		
		cin >> option;
	
		switch(option){
			
			case 1: 
			 	cinFunction();
			 	break;
			
			case 2:
				if(isSafe() == true){
					cout << "找到安全序列，处于安全状态。" << endl;
					toFormer();//只要一进行安全性检查 就需要将avaliable 还原回去 
				} else{
					cout << "找不到安全序列，处于不安全状态。" << endl;
					toFormer();//只要一进行安全性检查 就需要将avaliable 还原回去 
				}
				break;
			case 3:
				apply_Resources();
				break;	
			case 4:
			    state(); 
				break;
			case 0:
			 flag = true;
			 break;	
			default:
			cout << "输入错误，请重新输入！" << endl;	
			
		}
			
	}
	
}



//1
//5
//3
//10 5 7
//P0 7 5 3 0 1 0
//P1 3 2 2 2 0 0
//P2 9 0 2 3 0 2
//P3 2 2 2 2 1 1
//P4 4 3 2 0 0 2   
//3
//P1 1 0 2
//0 



//1
//5
//3
//10 5 7
//P0 7 5 3 0 1 0
//P1 3 2 2 3 0 2
//P2 9 0 2 3 0 2
//P3 2 2 2 2 1 1
//P4 4 3 2 0 0 2
//3
//P0 0 2 0
//0
//
//
//
//1
//5
//3
//10 5 7
//P0 7 5 3 0 1 0
//P1 3 2 2 3 0 2
//P2 9 0 2 3 0 2
//P3 2 2 2 2 1 1
//P4 4 3 2 0 0 2
//3
//P1 2 2 0
//0

在这里插入图片描述
再唠叨一句 加油 宝宝们 有疑问记得留言呀 留言呀 我码不停地的赶到 加油 我们共同进步

天天向上的菜鸡杰！！
关注
  • 18
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
算法设计与分析期末复习（知识点+习题详解）
02-28
算法设计与分析期末复习的主要章节如下： 第1章算法引论 第2章递归与分治法 第3章动态规划 第4章贪心方法 第5章回溯法 第6章分支限界法 文档中包括各个重要章节的重难点知识还有部分常考习题解析，其中分求解0-1背包...
Python搜索算法-二分查找算法详解
04-10
Python搜索算法——二分查找算法详解
银行家算法的几道题目，快来看看吧
Yajyaj123的博客
06-18 8926
银行家算法的几个题目，快来看看吧
2024年操作系统重点知识——银行家算法
2401_84557986的博客
05-01 733
让该进程运行完成，最后将资源释放，也就是将已分配的资源加到可利用的资源，如果最后每一个进程都能运行完成就得到了我们的安全序列，所以系统就是安全的，如果存在一个进程，可利用资源不能满足需求就不再分配。，P0的Need>Available,不满足，往后找，
7-2 银行家算法--申请资源 (30 分)
qq_48508278的博客
10-31 2496
一：前言 这道题需要用到前面的一道题 安全性检查 算法知识，所以强烈建议先看前面那道题 7-1 银行家算法–安全性检查 (20 分) 二：题目 输入N个进程(N<=100)，以及M类资源（M<=100），初始化各种资源的总数，T0时刻资源的分配情况。例如： 假定系统中有5个进程{P0，P1，P2，P3，P4}和三类资源{A,B,C}，各种资源的数量分别为10、5、7，在T0时刻的资源分配 输入申请资源的进程以及申请各类资源的数目，判断是否分配。若分配，输出”可以找到安全序列，可以分配。“并输出
数据挖掘-关联分析与Apriori算法详解
04-03
数据挖掘|关联分析与Apriori算法详解
TCP-IP详解 卷1+卷2+卷3-stevens-3
08-26
TCP-IP详解 卷1+卷2+卷3-stevens 史蒂文斯的呕心之作 linux学习的圣经
Gauss-Seidel迭代算法的Python实现详解
09-19
主要介绍了Gauss-Seidel迭代算法的Python实现详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 882
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 186
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 267
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 509
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 260
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 1606
环形链表
贪心加暴力枚举
wniuniu_的博客
07-24 215
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 383
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1028
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1058
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天天向上的菜鸡杰！！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值