银行家算法

算法介绍：1, 2
题目描述
请编写一个实现银行家算法的程序，输入进程需要的最大资源需求，进程已经拥有的系统资源和还预留的系统资源，再输入T0时刻Pi申请的系统资源数，请用银行家算法进行安全性检查，如果系统安全，则输出进程运行的安全序列，如果系统不安全，输出unsafe。要求：按资源需求量最小优先的原则选取进程的运行顺序。

输入描述
请编写一个实现银行家算法的程序，输入进程需要的最大资源需求，进程已经拥有的系统资源和还预留的系统资源，再输入T0时刻Pi申请的系统资源数。

2 5 // 资源数 进程数
2 4 // 进程需要最大资源数
10 2
5 4
3 1
4 2
2 0 // 进程已拥有的资源数
3 2
1 4
2 1
0 0
2 7 // 系统预留的资源数
0 0 4 // 进程编号 申请数 0进程申请(0,4)

输出描述

如果存在安全序列输出：
safe order:P00 P03 P02 P04 P01
如果不存在安全序列输出：
unsafe

输入样例

2 5
2 4
10 2
5 4
3 1
4 2
2 0
3 2
1 4
2 1
0 0
2 7
0 0 4

输出样例

safe order:P00 P03 P02 P04 P01

输入样例

2 5
2 4
10 2
5 4
3 1
4 2
2 0
3 2
1 4
2 1
0 0
2 7
1 2 0

输出样例

safe order:P00 P03 P02 P01 P04

其实这个算法还是挺简单的，就是判断资源够不够分配给某个进程，如果够，那就分配给他使用，并等他使用完回收回来，在重复判断其它的进程是否满足，依次迭代，直到所有进程都满足或者剩余的进程都不能满足时退出。坑点是根据第二个样例，猜测题意：题目要求对于t0时刻给出的资源请求，如果满足的话，就需要分配给他，但是这个需求不一定是该进程剩余需求的全部资源。

参考代码：

#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;
#define N 100
int Available[N]; // 系统预留资源 
int Allocation[N][N]; // 进程拥有资源 
int Need[N][N]; // 需求资源 
int Finish[N];  // 标记是否完成 
int Order[N];  // 标记是否完成 

int main(){
	int s_n, p_n;
	cin >> s_n >> p_n;
	// 需求 
	for(int i = 0; i < p_n; i++){
		for(int j = 0; j < s_n; j++)
			cin >> Allocation[i][j];
	} 
	// 已拥有 
	for(int i = 0; i < p_n; i++){
		for(int j = 0; j < s_n; j++)
			cin >> Need[i][j];
	} 
	// 预留
	for(int i = 0; i < s_n; i++){
		cin >> Available[i];
	} 
	int t0, pi, vi;
	// 再输入T0时刻Pi申请的系统资源数。
	cin >>  pi;
	int tt = 1;
	int vv[N]; 
	for(int i = 0; i < s_n; i++){
		cin >> vv[i];
		if(vv[i] > Available[i]){ // 必须全部分 
			tt = 0;
			break;
		}
	}
	int f = 0;
	if(tt == 1){
		// 分配资源给vi,并回收 
//		for(int i = 0; i < s_n; i++){
//			Available[i] +=  Allocation[pi][i];
//			Order[f] = pi;
//	//		cout << pass << endl; 
//			Finish[pi] = 1;
//		}
//		f++;
        // 分配出去，不会回收
		for(int i = 0; i < s_n; i++){
			Available[i] -= vv[i];
			Need[pi][i] += vv[i];
		} 
	}
	
//	for(int j = 0; j < p_n; j++){
//		cout << j << "-";
//		for(int i = 0; i < s_n; i++){
//			cout << Allocation[j][i] << " " << Need[j][i] << ", ";
//		}
//		cout << endl; 
//	}
	
	
	while(f < p_n){
		int pass = -1;
		int min_need = 0x3f3f3f3f;
		for(int i = 0; i < p_n; i++){
			if(Finish[i] == 1){
				continue;
			}
			int temp = 0;
			int is = 1;
			for(int j = 0; j < s_n; j++){
				if(Allocation[i][j] - Need[i][j] <= Available[j]){ // 满足分配 
					temp += Allocation[i][j] - Need[i][j]; // + ; // 记录该进程需要的资源数总和 
				}
				else{
					is = 0;
					break;
				} 
			}
			if(is && temp < min_need){ // 优先分配给需求小的 
//				cout << "i = " << i << ", pass= " << pass << ", min_need=" << min_need << endl;
				pass = i;
				min_need = temp;
//				cout << "i = " << i << ", pass= " << pass << ", min_need=" << min_need << endl;
			}
		}
		if(pass != -1){
			Order[f] = pass;
//			cout << pass << endl; 
			Finish[pass] = 1;
			f++;
			for(int j = 0; j < s_n; j++){
				Available[j] += Allocation[pass][j]; // 分配资源，并回收资源 
			}
		} 
		else{
			break;
		}
	} 
	if(f == p_n){
		cout << "safe order:";
		for(int i = 0; i < p_n; i++){
			printf("P%02d ", Order[i]);
		}
	}
	else{
		cout << "unsafe" << endl;
	}
	
	return 0;
}