2.维克多

维克多博士创造了一个裂变反应堆，可取用处于液体状态的放射性物质，反应堆的容量是V加仑。他有N瓶的放射性液体，每个都有一定的质量和一定的体积。当液体倒入反应堆时，也产生一些单位的能量。现在，维克多想要将能量输出最大化。但是，有一个限制条件。他研究了原子元素的物理知识和历史，认识到反应堆内放射性液体的总量不能超过特定的临界质量M，否则反应就会失控，并引发剧烈的爆炸。
写一个算法，帮助他从反应堆获得最大的能量，而不会让他丢掉性命。

输入
该函数/方法的输入包括六个参数——
reactorCap，一个整数，表示反应堆的容量（V）；
numberOfRadLiquid，一个整数，表示现有小瓶的数量（N）；
criticalMass，一个整数，表示反应堆的最大临界值（M）；
volumes，一个整数列表，按顺序表示N份放射性液体的体积；
masses，一个整数列表，按顺序表示N份放射性液体的质量；
energies，一个整数列表，按顺序表示N份放射性液体产生的能量。

输出
返回一个整数，表示可在给定的约束条件下从反应堆中产生的最大能量。

约束条件
1≤numberOfRadLiquid≤10^4

示例
输入：
reactorCap=100
numberOfRadLiquid=5
criticalMass=15
volumes=[50,40,30,20,10]
masses=[1,2,3,9,5]
energies=[300,480,270,200,180]

输出：
960

解释：
通过选择1、2、5号瓶中的液体，产生的能量=300+480+180=960。
这种液体组合产生的总体积=50+40+10=100，不大于reactorCap，造成反应堆中的总质量=1+2+5=8，不大于criticalMass。

//INCLUDE HEADER FILES NEEDED BY YOUR PROGRAM
//SOME LIBRARY FUNCIONALITY MAY BE RESTRICTED
//DEFINE ANY FUNCTION NEEDED
//FUNCTION SIGNATURE BEGINS,THIS FUNCTION IS REQUIRED
int maxEnergyGenerate(int reactorCap,int numberOfRadLiquid,int criticalMass,int* volumes,int* masses,int* energies)
{
//WRITE YOUR CODE HERE
}
//FUNCTION SIGNATURE ENDS

回答：
李yc版本（用以下代码覆盖掉已给代码）
#include
#include
#include
using namespace std;
// 求排列组合算法: C(n, m): 从n个数中任选m个数组成一个新的数, 求有多少种组合, 分别是什么
// 从v[]里任选m个元素组成一个组合, 与顺序无关
template
vector<vector> fun(vector v, int m)
{
if (v.size() < m)
return{}; // 找不到这样的组合
vector<vector> ret;
if (v.size() == m) // v[]中任选m个数
{
ret.push_back(v); // 唯一的一个组合
return ret;
}
else if (m == 1) // v[]中任选1个数
{
for (auto& it : v)
{
ret.push_back(vector {it});
}
return ret;
}
while (v.size() >= m)
{
auto first = v.front();
v.erase(v.begin());
// 在剩下的v[1~]中任选m-1个数
auto res = fun(v, m - 1);
for (auto& it : res)
{
it.insert(it.begin(), first);
ret.push_back(it);
}
}
return ret;
}
int maxEnergyGenerate(int reactorCap, int numberOfRadLiquid, int criticalMass,
int *volumes, int *masses, int *energies)
{
int sum_energies = 0;
std::vector v = {};//每个瓶子编号
for (int i = 0; i < numberOfRadLiquid; i++)
v.push_back(i + 1);
for (int i = numberOfRadLiquid; i >= 1; i–)
{
auto res = fun(v, i);
int sum_energies_i = 0;
int sum_masses = 0;
int sum_volumes = 0;
for (auto& it : res)
{
sum_volumes = 0;
sum_masses = 0;
sum_energies_i = 0;
for (auto& it2 : it)
{
sum_volumes = volumes[it2 - 1] + sum_volumes;
sum_masses = masses[it2 - 1] + sum_masses;
sum_energies_i = energies[it2 - 1] + sum_energies_i;
}
if (sum_volumes <= reactorCap && sum_masses <= criticalMass && sum_energies_i > sum_energies)
{
sum_energies = sum_energies_i;
}
}
}
return sum_energies;
}

李yc版本：（改掉变量名的）
#include “pch.h”
#include
#include
#include
using namespace std;
// 求排列组合算法: C(n, m): 从n个数中任选m个数组成一个新的数, 求有多少种组合, 分别是什么
// 从v[]里任选m个元素组成一个组合, 与顺序无关
template
vector<vector> fun(vector v, int m)
{
if (v.size() < m)
return{}; // 找不到这样的组合
vector<vector> ret;
if (v.size() == m) // v[]中任选m个数
{
ret.push_back(v); // 唯一的一个组合
return ret;
}
else if (m == 1) // v[]中任选1个数
{
for (auto& it : v)
{
ret.push_back(vector {it});
}
return ret;
}
while (v.size() >= m)
{
auto first = v.front();
v.erase(v.begin());
// 在剩下的v[1~]中任选m-1个数
auto res = fun(v, m - 1);
for (auto& it : res)
{
it.insert(it.begin(), first);
ret.push_back(it);
}
}
return ret;
}
int maxEnergyGenerate(int reactorCap, int numberOfRadLiquid, int criticalMass,
int *volumes, int *masses, int *energies)
{
int sum_energies = 0;
std::vector v = {};//每个瓶子编号
for (int i = 0; i < numberOfRadLiquid; i++)
v.push_back(i + 1);
for (int i = numberOfRadLiquid; i >= 1; i–)
{
auto res = fun(v, i);
int sum_energies_i = 0;
int sum_masses = 0;
int sum_volumes = 0;
for (auto& it : res)
{
sum_volumes = 0;
sum_masses = 0;
sum_energies_i = 0;
for (auto& it2 : it)
{
sum_volumes = volumes[it2 - 1] + sum_volumes;
sum_masses = masses[it2 - 1] + sum_masses;
sum_energies_i = energies[it2 - 1] + sum_energies_i;
}
if (sum_volumes <= reactorCap && sum_masses <= criticalMass && sum_energies_i > sum_energies)
{
sum_energies = sum_energies_i;
}
}
}
return sum_energies;
}
int main()
{
int reactorCap = 250;//容量50
int numberOfRadLiquid = 5;//个数
int criticalMass = 25;//临界质量
int volumes[5] = { 30, 40, 50, 60, 70 };//体积
int masses[5] = { 7, 8, 9, 10, 11 };//质量
int energies[5] = { 300, 400, 500, 600, 700 };//能量
int sum_energies = maxEnergyGenerate(reactorCap, numberOfRadLiquid,criticalMass,
volumes, masses, energies);
cout << sum_energies << endl;
return 0;
}

汪px版本：
#include “pch.h”
#include
#include
#include
using namespace std;
// 求排列组合算法: C(n, m): 从n个数中任选m个数组成一个新的数, 求有多少种组合, 分别是什么
// 从v[]里任选m个元素组成一个组合, 与顺序无关
template
vector<vector> fun(vector v, int m)
{
if (v.size() < m)
return{}; // 找不到这样的组合
vector<vector> ret;
if (v.size() == m) // v[]中任选m个数
{
ret.push_back(v); // 唯一的一个组合
return ret;
}
else if (m == 1) // v[]中任选1个数
{
for (auto& it : v)
{
ret.push_back(vector {it});
}
return ret;
}
while (v.size() >= m)
{
auto first = v.front();
v.erase(v.begin());
// 在剩下的v[1~]中任选m-1个数
auto res = fun(v, m - 1);
for (auto& it : res)
{
it.insert(it.begin(), first);
ret.push_back(it);
}
}
return ret;
}
int maxEnergyGenerate(int reactorCap, int numberOfRadLiquid, int criticalMass,
int *volumes, int *masses, int *energies)
{
int sum_energies = 0;
std::vector v = {};//每个瓶子编号
for (int i = 0; i < numberOfRadLiquid; i++)
v.push_back(i + 1);
for (int i = numberOfRadLiquid; i >= 1; i–)
{
auto res = fun(v, i);
int sum_energies_i = 0;
int sum_masses = 0;
int sum_volumes = 0;
for (auto& it : res)
{
sum_volumes = 0;
sum_masses = 0;
sum_energies_i = 0;
for (auto& it2 : it)
{
sum_volumes = volumes[it2 - 1] + sum_volumes;
sum_masses = masses[it2 - 1] + sum_masses;
sum_energies_i = energies[it2 - 1] + sum_energies_i;
}
if (sum_volumes <= reactorCap && sum_masses <= criticalMass && sum_energies_i > sum_energies)
{
sum_energies = sum_energies_i;
}
}
}
return sum_energies;
}
int main()
{
int reactorCap = 250;//容量50
int numberOfRadLiquid = 5;//个数
int criticalMass = 25;//临界质量
int volumes[5] = { 30, 40, 50, 60, 70 };//体积
int masses[5] = { 7, 8, 9, 10, 11 };//质量
int energies[5] = { 300, 400, 500, 600, 700 };//能量
int sum_energies = maxEnergyGenerate(reactorCap, numberOfRadLiquid,criticalMass,
volumes, masses, energies);
cout << sum_energies << endl;
return 0;
}

黄yx版本：
int maxEnergyGenerate(int reactorCap, int numberOfRadLiquid, int criticalMass, int *volumes, int *masses, int *energies)
{
 float k = reactorCap / criticalMass;
 vector massRate;
 vector volumesRate;
 vector finalRate;
 vector list;
 for (int i = 0; i < numberOfRadLiquid; i++)
 {
  massRate.push_back(energies[i] / masses[i]);
  volumesRate.push_back(energies[i] / volumes[i]);
  finalRate.push_back(massRate[i] * k + volumesRate[i]);
  list.push_back(-1);
 }
 vector finalRateSort(finalRate);
 for (int i = 0; i < numberOfRadLiquid; i++)
 {
  double max = 0;
  for (int j = 0; j < numberOfRadLiquid; j++)
  {
   if (max < finalRate[j])
   {
    max = finalRate[j];
    finalRateSort[i] = max;
    list[i] = j;
   }
  }
  finalRate[list[i]] = 0;
 }
 int massNow = 0;
 int volNow = 0;
 int maxEn = 0;
 int n = 0;
 while(true)
 {
  if (n == numberOfRadLiquid)
   break;
  volNow += volumes[list[n]];
  if (volNow > reactorCap)
  {
   volNow -= volumes[list[n]];
   n++;
   continue;
  }
  massNow += masses[list[n]];
  if (massNow > criticalMass)
  {
   massNow -= masses[list[n]];
   n++;
   continue;
  }
  maxEn +=energies[list[n]];
  n++;
  if (n == numberOfRadLiquid)
   break;
 }
 return maxEn;
}