2023华为OD机试 （B卷）|200分 代表团坐车（Java JavaScript C++ Python）

题目描述

某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车，可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满的接待方案，输出方案数量。
约束：
1.一个团只能上一辆车，并且代表团(代表团数量小于30，每个代表团人数小于30)小于汽车容量(汽车容量小于100)
2.需要将车辆坐满

输入描述

第一行 代表团人数，英文逗号隔开，代表团数量小于30，每个代表团人数小于30
第二行 汽车载客量，汽车容量小于100

输出描述

坐满汽车的方案数量
如果无解输出0

用例1

输入：
5， 4， 2， 3， 2， 4， 9
10
输出
4
说明
解释以下几种方式都可以坐满扯，所以优先街道输出为4
[2, 3, 5]
[2, 4, 4]
[2, 3, 5]
[2, 4, 4]

Java

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
 
    // 读取代表团人数
    int[] groups = Arrays.stream(sc.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
 
    // 读取汽车载客量
    int capacity = Integer.parseInt(sc.nextLine());
 
    // 初始化动态规划数组，dp[i]表示载客量为i时的方案数
    int[] dp = new int[capacity + 1];
    dp[0] = 1; // 载客量为0时，方案数为1（不接待任何代表团）
 
    // 动态规划转移
    for (int group : groups) {
      for (int j = capacity; j >= group; j--) { // 从后往前遍历，避免重复计算
        dp[j] += dp[j - group]; // 转移方程：dp[j] += dp[j - group]，表示加上接待当前代表团后的方案数
      }
    }
 
    // 输出结果
    if (dp[capacity] == 0) { // 无解
      System.out.println(0);
    } else { // 有解
      System.out.println(dp[capacity]);
    }
  }
}

JavaScript

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.on('line', (line) => {
  // 读取代表团人数
  const groups = line.split(',').map(Number);

  rl.on('line', (line) => {
    // 读取汽车载客量
    const capacity = Number(line);

    // 初始化动态规划数组，dp[i]表示载客量为i时的方案数
    const dp = new Array(capacity + 1).fill(0);
    dp[0] = 1; // 载客量为0时，方案数为1（不接待任何代表团）

    // 动态规划转移
    for (const group of groups) {
      for (let j = capacity; j >= group; j--) { // 从后往前遍历，避免重复计算
        dp[j] += dp[j - group]; // 转移方程：dp[j] += dp[j - group]，表示加上接待当前代表团后的方案数
      }
    }

    // 输出结果
    if (dp[capacity] === 0) { // 无解
      console.log(0);
    } else { // 有解
      console.log(dp[capacity]);
    }

    rl.close();
  });
});

C++

#include 
#include 
#include 
#include 
using namespace std;

int main() {
    string input;
    getline(cin, input);

    // 读取代表团人数
    stringstream ss(input);
    vector<int> groups;
    int num;
    char comma;
    while (ss >> num) {
        groups.push_back(num);
        ss >> comma;
    }

    // 读取汽车载客量
    int capacity;
    cin >> capacity;

    // 初始化动态规划数组，dp[i]表示载客量为i时的方案数
    vector<int> dp(capacity + 1);
    dp[0] = 1; // 载客量为0时，方案数为1（不接待任何代表团）

    // 动态规划转移
    for (int group : groups) {
        for (int j = capacity; j >= group; j--) { // 从后往前遍历，避免重复计算
            dp[j] += dp[j - group]; // 转移方程：dp[j] += dp[j - group]，表示加上接待当前代表团后的方案数
        }
    }

    // 输出结果
    if (dp[capacity] == 0) { // 无解
        cout << 0 << endl;
    } else { // 有解
        cout << dp[capacity] << endl;
    }

    return 0;
}

Python

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.on('line', (line) => {
  // 读取代表团人数
  const groups = line.split(',').map(Number);

  rl.on('line', (line) => {
    // 读取汽车载客量
    const capacity = Number(line);

    // 初始化动态规划数组，dp[i]表示载客量为i时的方案数
    const dp = new Array(capacity + 1).fill(0);
    dp[0] = 1; // 载客量为0时，方案数为1（不接待任何代表团）

    // 动态规划转移
    for (const group of groups) {
      for (let j = capacity; j >= group; j--) { // 从后往前遍历，避免重复计算
        dp[j] += dp[j - group]; // 转移方程：dp[j] += dp[j - group]，表示加上接待当前代表团后的方案数
      }
    }

    // 输出结果
    if (dp[capacity] === 0) { // 无解
      console.log(0);
    } else { // 有解
      console.log(dp[capacity]);
    }

    rl.close();
  });
});