有一台机器，上面有m个储存空间。然后有n个请求，第i个请求计算时需要占 R[i]个空间，储存计算结果则需要占据O[i]个空间（据O[i]个空间（其中O[i]<R[i]）。问怎么安排这n个请求的顺序，使

有一台机器，上面有m个储存空间。然后有n个请求，第i个请求计算时需要占 R[i]个空间，储存计算结果则需要占据O[i]个空间（据O[i]个空间（其中O[i]<R[i]）。问怎么安排这n个请求的顺序，使得所有请求都能完成。你的算法也应该能够判断出无论如何都不能处理完的情况。

比方说，m=14，n=2，R[1]=10，O[1]=5，R[2]=8，O[2]=6。在这个例子中，我们可以先运行第一个任务，剩余9个单位的空间足够执行第二个任务；但如果先走第二个任务，第一个任务执行时空间就不够了，因为10>14-6。

//请求数
#define N 2
//存储空间
#define M 14

typedef struct request {
int no;
int r;
int o;
} REQ;

void printReqs(REQ* reqs, int len) {
for (int i = 0; i < len - 1; ++i) {
cout << reqs[i].no << "->";
}
cout << reqs[len - 1].no << endl;
}

int cmp(const void* req1, const void* req2) {
return (((const REQ*) req2)->r - ((const REQ*) req2)->o)
- (((const REQ*) req1)->r - ((const REQ*) req1)->o);
}

//获取处理完所有请求所需的存储空间
int getAllOccupy(REQ* reqs, int len) {
int sum = 0;
for (int i = 0; i < len; ++i) {
sum += reqs[i].o;
}
return sum;
}

bool arrangeDealRequest(REQ* reqs, int len) {
if (!reqs || !len) {
return false;
}
int occupy = getAllOccupy(reqs, len);

//必定不满足的情况: 处理完所有请求后所需空间小于指定空间
if (M < occupy) {
cout << "存储空间不足!!!";
return false;

} else {
int curSpace = M;
//按照R[i]-O[i]的值降序排序
qsort(reqs, len, sizeof(REQ), cmp);
for (int i = 0; i < len; ++i) {
if (curSpace >= reqs[i].r) {
curSpace -= reqs[i].o;
} else {
cout << "运行空间不足!!!";
return false;
}
}
return true;
}
}