银行家算法实现

已于 2024-04-18 16:46:06 修改
阅读量358 收藏 9
点赞数 5
文章标签： 算法 数据结构
于 2024-04-18 16:11:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74176921/article/details/137922506
版权

变量描述

输入初始化

首先会给我们这样一个表，分别是最大需要资源数量，当前有多少个资源，那么很明显，还需要多少个资源就是前者减去后者。

已知系统总的可用资源为10,5,7，那么我们用这个数减去所有已经分配的资源数，就是目前还有多少是可以利用的，代码实现如下

代码

void init() {
	cout << "请输入每个进程的运转所需要的最大资源数量:\n";
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			cin >> Max[i][j];
	cout << "请输入现在为每个进程所分配的资源数量：\n";
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			cin >> Allocation[i][j];
	//计算每个进程还需要多少资源才能工作  Need=MAX-allocation
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			Need[i][j] = Max[i][j] - Allocation[i][j];
	//该进程用于分配给每个进程以达到最大需要资源量进行工作
	cout << "请输入每个进程一共拥有的资源数量数量:\n";
	for (int j = 1; j < M; j++)
		cin >> sum[j];

	for (int j = 1; j < M; j++) {
		int tmp = 0;
		for (int i = 1; i < N; i++) {
			tmp += Allocation[i][j];
		}
		Avaliable[j] = sum[j] - tmp;
	}
}

测试数据

MAX
7 5 3
3 2 2
9 0 2
2 2 2
4 3 3

Allocation
0 1 0
2 0 0
3 0 2
2 1 1
0 0 2

10 5 7

输出初始化

代码

void output() {
	cout << "\n";
	cout << "\t" << "Allocation" << "\t" << "Need" << "\t\t" << "Avaliable" << "\n";
	for (int i = 1; i < N; i++) {
		cout << "p" << i << "\t";
		for (int j = 1; j < M; j++) {
			cout << Allocation[i][j] << " ";
		}
		cout << "\t\t";
		for (int j = 1; j < M; j++) {
			cout << Need[i][j] << " ";
		}
		cout << "\t\t";
		if (i == 1) {
			for (int j = 1; j < M; j++) {
				cout << Avaliable[j] << " ";
			}
		}
		cout << "\n";
	}
}

运行效果

判断是否合法

判断是否合法的一个条件就是   是否当前有的闲置资源都大于我所需要的资源，如果有一个不满足，那一定是不合法的。

代码

bool check_work(int need[], int work[]) {//检查每个时间的所有进程是否都资源都够
	int flag = 1;
	for (int i = 1; i < M; i++) {
		if (need[i] > work[i]) {//当前需要的资源量与目前还剩余的资源量
			flag = 0;//如果需要的大于当前有的，就不够
			break;
		}
	}
	return flag;
}

进程分配过程

该部分就是逐个检查当前资源数量是否全部大于所需要的资源数量，如果都大于了，说明是可以分配的，那就分配给他让他做这个进程，注意，当这个进程做完之后，那他还要释放他所持有的所有资源。然后作为下一阶段的闲置资源数量。

代码

其中加入了一些输出，方便观察运行过程。

int check_security() {
	memcpy(Work, Avaliable, sizeof Work);//开始的资源数量
	cout << "\n当前每种资源还有的数量\n";
	for (int i = 1; i < M; i++)
		cout << Work[i] << " ";
	cout << "\n";
	cout << "\n";
	cout << "\t" << "Work " << "\t\t" << "Allocation" << "\t" << "Need" << "\t\t" << "Work+Allocation" << "\t"<<"Isfinish" << "\n";

	//开始模拟分配过程
	for (int k = 1; k < N; k++) {
		for (int i = 1; i < N; i++) {//对于每一个时间
			if (Finish[i] == 1)//当前进程已经完成了，就不用继续往下看
				continue;
			if (check_work(Need[i], Work)) {//如果当前有的资源够分配
				for (int j = 1; j < M; j++)
					Work_allo[j] = Work[j] + Allocation[i][j];//回收资源
				Finish[i] = 1;
				List[++FinishNum] = i;//安全进程
				cout << "p" << i << "\t";
				output_work(Need[i],Allocation[i],Finish[i]);
				memcpy(Work,Work_allo,sizeof(Work));
				break;
			}
		}
	}
	int flag = 1;
	for (int i = 1; i < N; i++) {
		if (!Finish[i]) {
			flag = 0;
			cout << "p" << i << "\t";
			output_work(Need[i], Allocation[i],Finish[i]);
		}
	}
	if (flag) {//安全
		cout << "系统处于安全状态!\n安全序列为:\n";
		for (int i = 1; i <= FinishNum; i++)
			cout << List[i] << " ";
		cout << "\n";
	}
	else {
		cout << "系统处于不安全状态!\n";
	}
	return flag;
}

输出部分 

void output_work(int Need[],int Allocation[],int Isfinish) {
	for (int j = 1; j < M; j++) {
		cout << Work[j] << " ";
	}
	cout << "\t\t";
	for (int j = 1; j < M; j++) {
		cout << Allocation[j] << " ";
	}
	cout << "\t\t";
	for (int j = 1; j < M; j++) {
		cout << Need[j] << " ";
	}
	
	cout << "\t\t";
	for (int j = 1; j < M; j++) {
		cout << Work_allo[j] << " ";
	}
	cout << "\t\t";
	cout << Isfinish;
	cout << "\n";

}

运行效果

  新增资源分配

当前要给当前的某个进程再分配一些资源，即当前拥有的资源数量增多，需要的资源数减少，闲置的资源减少，问是否安全。

代码

注意需要先检查两种情况

原来值需要2个资源就够了，但你给他发了3个，他根本用不了这么多，属于资源浪费，这样分配是不合法的。

现在还有2个资源是闲置的，但是你却要3个，很明显我是完全给不起的，不合法。

int  banker() {
	if (!check_work(requst, Need[give_num])) {//请求资源已经大于了他所需要的资源
		cout << "出错！请求资源数量已经大于了所需要的数量\n";
		return 1;
	}
	if (!check_work(requst, Avaliable)) {
		cout << "当前可用资源不足，需要等待\n";
		return 1;
	}
	for (int j = 1; j < M; j++) {
		Avaliable[j] -= requst[j];//剩余总资源减少
		Allocation[give_num][j] += requst[j];
		Need[give_num][j] -= requst[j];//给他分配了他就不需要那么多了
	}
	output();
	if (check_security()) {
		cout << "安全！将进行资源分配\n";
	}
	else {//不够了，恢复
		for (int j = 1; j < M; j++) {
			Avaliable[j] += requst[j];
			Allocation[give_num][j] -= requst[j];
			Need[give_num][j] += requst[j];
		}
	}
	return 0;
}

效果

完整代码

#include<iostream>
using namespace std;
const int N = 6, M = 4;
int Max[N][M];//表示某个进程对某个资源的最大需求量
int Allocation[N][M];//当前拥有，已分配的资源
int Need[N][M];//还需要多少资源才能达到最大值
int Avaliable[M],sum[M];//把所有的资源分给每个进程之后还剩多少资源可以利用，总共有多少资源
int Finish[N];//判断每个进程是否能完成
int Work[M];//动态的工作过程的资源剩余量
int Work_allo[M];//当当前进程结束之后，回收资源
int List[M];//安全队列
int requst[M];//需求进程的资源数
int FinishNum = 0;//当前有多少个进程合法
int give_num;//需求进程的编号

void init() {
	cout << "请输入每个进程的运转所需要的最大资源数量:\n";
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			cin >> Max[i][j];
	cout << "请输入现在为每个进程所分配的资源数量：\n";
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			cin >> Allocation[i][j];
	//计算每个进程还需要多少资源才能工作  Need=MAX-allocation
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			Need[i][j] = Max[i][j] - Allocation[i][j];
	//该进程用于分配给每个进程以达到最大需要资源量进行工作
	cout << "请输入每个进程一共拥有的资源数量数量:\n";
	for (int j = 1; j < M; j++)
		cin >> sum[j];

	for (int j = 1; j < M; j++) {
		int tmp = 0;
		for (int i = 1; i < N; i++) {
			tmp += Allocation[i][j];
		}
		Avaliable[j] = sum[j] - tmp;
	}
}

void init_requst() {
	cout << "\n请输入要分配资源的编号：\n";
	cin >> give_num;
	cout << "请输入要分配的资源数量\n";
	for (int i = 1; i < M; i++)
		cin >> requst[i];
}

void output() {
	cout << "\n";
	cout << "\t" << "Allocation" << "\t" << "Need" << "\t\t" << "Avaliable" << "\n";
	for (int i = 1; i < N; i++) {
		cout << "p" << i << "\t";
		for (int j = 1; j < M; j++) {
			cout << Allocation[i][j] << " ";
		}
		cout << "\t\t";
		for (int j = 1; j < M; j++) {
			cout << Need[i][j] << " ";
		}
		cout << "\t\t";
		if (i == 1) {
			for (int j = 1; j < M; j++) {
				cout << Avaliable[j] << " ";
			}
		}
		cout << "\n";
	}
}

void output_work(int Need[],int Allocation[],int Isfinish) {
	for (int j = 1; j < M; j++) {
		cout << Work[j] << " ";
	}
	cout << "\t\t";
	for (int j = 1; j < M; j++) {
		cout << Allocation[j] << " ";
	}
	cout << "\t\t";
	for (int j = 1; j < M; j++) {
		cout << Need[j] << " ";
	}
	
	cout << "\t\t";
	for (int j = 1; j < M; j++) {
		cout << Work_allo[j] << " ";
	}
	cout << "\t\t";
	cout << Isfinish;
	cout << "\n";

}

bool check_work(int need[], int work[]) {//检查每个时间的所有进程是否都资源都够
	int flag = 1;
	for (int i = 1; i < M; i++) {
		if (need[i] > work[i]) {//当前需要的资源量与目前还剩余的资源量
			flag = 0;//如果需要的大于当前有的，就不够
			break;
		}
	}
	return flag;
}

int check_security() {
	memcpy(Work, Avaliable, sizeof Work);//开始的资源数量
	cout << "\n当前每种资源还有的数量\n";
	for (int i = 1; i < M; i++)
		cout << Work[i] << " ";
	cout << "\n";
	cout << "\n";
	cout << "\t" << "Work " << "\t\t" << "Allocation" << "\t" << "Need" << "\t\t" << "Work+Allocation" << "\t"<<"Isfinish" << "\n";

	//开始模拟分配过程
	for (int k = 1; k < N; k++) {
		for (int i = 1; i < N; i++) {//对于每一个时间
			if (Finish[i] == 1)//当前进程已经完成了，就不用继续往下看
				continue;
			if (check_work(Need[i], Work)) {//如果当前有的资源够分配
				for (int j = 1; j < M; j++)
					Work_allo[j] = Work[j] + Allocation[i][j];//回收资源
				Finish[i] = 1;
				List[++FinishNum] = i;//安全进程
				cout << "p" << i << "\t";
				output_work(Need[i],Allocation[i],Finish[i]);
				memcpy(Work,Work_allo,sizeof(Work));
				break;
			}
		}
	}
	int flag = 1;
	for (int i = 1; i < N; i++) {
		if (!Finish[i]) {
			flag = 0;
			cout << "p" << i << "\t";
			output_work(Need[i], Allocation[i],Finish[i]);
		}
	}
	if (flag) {//安全
		cout << "系统处于安全状态!\n安全序列为:\n";
		for (int i = 1; i <= FinishNum; i++)
			cout << List[i] << " ";
		cout << "\n";
	}
	else {
		cout << "系统处于不安全状态!\n";
	}
	return flag;
}

int  banker() {
	if (!check_work(requst, Need[give_num])) {//请求资源已经大于了他所需要的资源
		cout << "出错！请求资源数量已经大于了所需要的数量\n";
		return 1;
	}
	if (!check_work(requst, Avaliable)) {
		cout << "当前可用资源不足，需要等待\n";
		return 1;
	}
	for (int j = 1; j < M; j++) {
		Avaliable[j] -= requst[j];//剩余总资源减少
		Allocation[give_num][j] += requst[j];
		Need[give_num][j] -= requst[j];//给他分配了他就不需要那么多了
	}
	output();
	if (check_security()) {
		cout << "安全！将进行资源分配\n";
	}
	else {//不够了，恢复
		for (int j = 1; j < M; j++) {
			Avaliable[j] += requst[j];
			Allocation[give_num][j] -= requst[j];
			Need[give_num][j] += requst[j];
		}
	}
	return 0;
}

int main() {
	init();
	output();
	cout << "检查t0时刻是否合法\n";
	check_security();//检查初始状态是否合法
	int flag = 1;
	while (flag) {
		cout << "\n对请求资源的银行家算法的检查\n";
		memset(Finish, 0, sizeof Finish);
		FinishNum = 0;
		init_requst();
		if (banker()) {
			cout << "请重新输入\n";
			continue;
		}
		cout << "是否继续检查?(输入0退出)\n";
		cin >> flag;
	};

	return 0;
}

面向对象

#include<iostream>
#include<cstring>


const int N = 6, M = 4;

class BankerAlgorithm {
private:
	int Max[N][M]; // 最大需求量
	int Allocation[N][M]; // 当前已分配资源
	int Need[N][M]; // 还需要的资源
	int Avaliable[M], sum[M]; // 可用资源
	int Finish[N]; // 判断每个进程是否能完成
	int Work[M]; // 动态工作过程的资源剩余量
	int Work_allo[M]; // 当前进程结束后回收资源
	int List[M]; // 安全队列
	int requst[M]; // 请求资源数
	int FinishNum; // 合法进程数
	int give_num; // 请求资源的进程编号
	int Isfinish;
public:
	BankerAlgorithm() : FinishNum(0) {
		memset(Finish, 0, sizeof(Finish));
	}
	void init();
	void init_requst();
	void output();
	void output_work(int Need[], int Allocation[], int Isfinish);
	bool check_work(int need[], int work[]);
	int check_security();
	int banker();
};

// 类外方法定义
void BankerAlgorithm::init() {
	std::cout << "请输入每个进程的运转所需要的最大资源数量:\n";
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			std::cin >> Max[i][j];
	std::cout << "请输入现在为每个进程所分配的资源数量：\n";
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			std::cin >> Allocation[i][j];
	//计算每个进程还需要多少资源才能工作  Need=MAX-allocation
	for (int i = 1; i < N; i++)
		for (int j = 1; j < M; j++)
			Need[i][j] = Max[i][j] - Allocation[i][j];
	//该进程用于分配给每个进程以达到最大需要资源量进行工作
	std::cout << "请输入每个进程一共拥有的资源数量数量:\n";
	for (int j = 1; j < M; j++)
		std::cin >> sum[j];

	for (int j = 1; j < M; j++) {
		int tmp = 0;
		for (int i = 1; i < N; i++) {
			tmp += Allocation[i][j];
		}
		Avaliable[j] = sum[j] - tmp;
	}
}

void BankerAlgorithm::init_requst() {
	std::cout << "\n请输入要分配资源的编号：\n";
	std::cin >> give_num;
	std::cout << "请输入要分配的资源数量\n";
	for (int i = 1; i < M; i++)
		std::cin >> requst[i];
}

void BankerAlgorithm::output() {
	std::cout << "\n";
	std::cout << "\t" << "Allocation" << "\t" << "Need" << "\t\t" << "Avaliable" << "\n";
	for (int i = 1; i < N; i++) {
		std::cout << "p" << i << "\t";
		for (int j = 1; j < M; j++) {
			std::cout << Allocation[i][j] << " ";
		}
		std::cout << "\t\t";
		for (int j = 1; j < M; j++) {
			std::cout << Need[i][j] << " ";
		}
		std::cout << "\t\t";
		if (i == 1) {
			for (int j = 1; j < M; j++) {
				std::cout << Avaliable[j] << " ";
			}
		}
		std::cout << "\n";
	}
}

void BankerAlgorithm::output_work(int Need[], int Allocation[], int Isfinish) {
	for (int j = 1; j < M; j++) {
		std::cout << Work[j] << " ";
	}
	std::cout << "\t\t";
	for (int j = 1; j < M; j++) {
		std::cout << Allocation[j] << " ";
	}
	std::cout << "\t\t";
	for (int j = 1; j < M; j++) {
		std::cout << Need[j] << " ";
	}

	std::cout << "\t\t";
	for (int j = 1; j < M; j++) {
		std::cout << Work_allo[j] << " ";
	}
	std::cout << "\t\t";
	std::cout << Isfinish;
	std::cout << "\n";
}

bool BankerAlgorithm::check_work(int need[], int work[]) {
	int flag = 1;
	for (int i = 1; i < M; i++) {
		if (need[i] > work[i]) {//当前需要的资源量与目前还剩余的资源量
			flag = 0;//如果需要的大于当前有的，就不够
			break;
		}
	}
	return flag;
}

int BankerAlgorithm::check_security() {
	memcpy(Work, Avaliable, sizeof Work);//开始的资源数量
	std::cout << "\n当前每种资源还有的数量\n";
	for (int i = 1; i < M; i++)
		std::cout << Work[i] << " ";
	std::cout << "\n";
	std::cout << "\n";
	std::cout << "\t" << "Work " << "\t\t" << "Allocation" << "\t" << "Need" << "\t\t" << "Work+Allocation" << "\t" << "Isfinish" << "\n";

	//开始模拟分配过程
	for (int k = 1; k < N; k++) {
		for (int i = 1; i < N; i++) {//对于每一个时间
			if (Finish[i] == 1)//当前进程已经完成了，就不用继续往下看
				continue;
			if (check_work(Need[i], Work)) {//如果当前有的资源够分配
				for (int j = 1; j < M; j++)
					Work_allo[j] = Work[j] + Allocation[i][j];//回收资源
				Finish[i] = 1;
				List[++FinishNum] = i;//安全进程
				std::cout << "p" << i << "\t";
				output_work(Need[i], Allocation[i], Finish[i]);
				memcpy(Work, Work_allo, sizeof(Work));
				break;
			}
		}
	}
	int flag = 1;
	for (int i = 1; i < N; i++) {
		if (!Finish[i]) {
			flag = 0;
			/*	cout << "p" << i << "\t";
				output_work(Need[i], Allocation[i],Finish[i]);*/
		}
	}
	if (flag) {//安全
		std::cout << "系统处于安全状态!\n安全序列为:\n";
		for (int i = 1; i <= FinishNum; i++)
			std::cout << List[i] << " ";
		std::cout << "\n";
	}
	else {
		std::cout << "系统处于不安全状态!\n";
	}
	return flag;
}

int BankerAlgorithm::banker() {
	memset(Finish, 0, sizeof Finish);
	FinishNum = 0;
	if (!check_work(requst, Need[give_num])) {//请求资源已经大于了他所需要的资源
		std::cout << "出错！请求资源数量已经大于了所需要的数量\n";
		return 1;
	}
	if (!check_work(requst, Avaliable)) {
		std::cout << "当前可用资源不足，需要等待\n";
		return 1;
	}
	for (int j = 1; j < M; j++) {
		Avaliable[j] -= requst[j];//剩余总资源减少
		Allocation[give_num][j] += requst[j];
		Need[give_num][j] -= requst[j];//给他分配了他就不需要那么多了
	}
	output();
	if (check_security()) {
		std::cout << "安全！将进行资源分配\n";
	}
	else {//不够了，恢复
		for (int j = 1; j < M; j++) {
			Avaliable[j] += requst[j];
			Allocation[give_num][j] -= requst[j];
			Need[give_num][j] += requst[j];
		}
	}
	return 0;
}

// 主函数
int main() {
	BankerAlgorithm ba;
	ba.init();
	ba.output();
	std::cout << "检查t0时刻是否合法\\n";
	ba.check_security(); // 检查初始状态是否合法

	int flag = 1;
	while (flag) {
		std::cout << "\\n对请求资源的银行家算法的检查\\n";
		BankerAlgorithm* b = new BankerAlgorithm(); // 动态分配内存
		*b = ba;
		b->init_requst();
		if (b->banker()) {
			std::cout << "请重新输入\\n";
			delete b; // 释放内存
			continue;
		}
		std::cout << "是否继续检查?(输入0退出)\\n";
		std::cin >> flag;
		delete b; // 释放内存
	}

	return 0;
}

endlessdream01
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ese.rar_银行家算法实现
09-21
总的来说，"ese.rar_银行家算法实现"是一个用于教学或研究的实用程序，它演示了如何在实际环境中应用银行家算法，帮助理解如何避免死锁，并为有限资源的安全分配提供解决方案。通过运行和分析这个程序，我们可以更...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 828
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
cf场+线性dp
xxx_jsu的博客
07-23 297
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 235
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 226
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
2766. 重新放置石块 Medium
珞米的博客
07-24 477
第 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 有石块。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 572
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
算法题目整合5
qq_62571233的博客
07-23 885
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 282
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
贪心加暴力枚举
wniuniu_的博客
07-24 185
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1001
二叉搜索树向左或向右指明方向，不用遍历整个树。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 351
糖果公司的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,因为我们这里求的是最大值,
2024.7.22
white__ice的博客
07-22 578
Q次操作，每次操作有下列两种： •1,l,r,x：表示把l到r的所有ai变成x •2,l,r,x：查询l到r的所有砝码，每个砝码可以用无数次，是否能称出重量x ai和所有的x都不大于m。若tp=1，则第二行有两个正整数n,k，表示天数和小L赚的金币个数。对于30%的数据，n,m,Q≤10 对于50%的数据，n,m,Q≤1000 对于另外20%的数据，opt=2 对于100% 的数据，n,Q≤10。共2行，每行1个字符串，依次表示a,b。有两种方案，每天的价格分别是：[1,1,2,2]，[1,2,1,2]。
【算法】分割回文串
时清云的博客
07-24 283
难度：中等。
【常微分方程】
qq_74285286的博客
07-24 308
常微分方程笔记
AtCoder Beginner Contest 363(A~D题)
sin1810335764的博客
07-23 229
枚举长度，首先计算出答案回文数的长度。通过枚举和减法可以计算出是当前长度下第k𝑘大的回文数。而前一半就是顺序的，第k𝑘大就是当前长度的数的第k𝑘大，这个很好求。接下来只需要构成回文，直接输出即可。将L𝐿从小往大排序，那么只需要第n−P+1𝑛−𝑃+1大的数满足条件即可，假设这个数是a𝑎。因此，只需要计算T−a𝑇−𝑎即可。注意，如果这个数是负数，意味着初始时就满足条件，此时要输出00。我们只需要找到下一阶段的下限。a / 100 是本阶段+1 变成下一阶段，再 * 100变成下限，再与原来的相减即可。
CSP-J模拟赛day1——解析+答案
CylMK的博客
07-23 853
的时间复杂度，显然过不了，所以我们这里采用桶排，这样的时间复杂度就是。，也就是在二进制的情况下只有一个1，所以我们直接模拟就行了。因为有过牌这一方法，所以这道题就直接变成了01背包问题。很容易想到贪心的思路，但是无论是快排还是插排都需要。由题可得，每次只加一个。送分题，暴力枚举即可。
算法：BFS解决 FloodFill 算法
一名还在努力学习技术的程序员的博客
07-24 1077
本篇博客是关于BFS 解决 FloodFill 算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
银行家算法实现与详解
本资源包含了银行家算法的详细实现，包括数据结构、算法流程以及课程设计的相关内容。" 银行家算法是计算机操作系统中用于预防死锁的一种经典方法，由艾兹格·迪杰斯特拉提出。它的核心目标是在资源有限的情况下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值