【2024华为OD-E卷-100分- 求最多可以派出多少支团队】（题目+思路+Java&C++&Python解析)

题目

你是一家科技公司的HR，现在公司计划派出一些团队去参加国际科技竞赛。每个团队的人数要求在3到5人之间（包含3人和5人）。给定一个整数数组people，其中people[i]表示第i个员工的编号。你需要计算最多可以派出多少个满足人数要求的团队。

输入描述

• 输入为一个整数数组people，其中people[i]表示第i个员工的编号。

输出描述

• 输出一个整数，表示最多可以派出多少个满足人数要求的团队。

示例

示例1

输入: [1, 2, 3, 4, 5, 6]
输出: 3
解释: 可以组成3个团队：[1, 2, 3], [4, 5], [6] 或者 [1, 2, 3], [4, 6], [5] 等其他组合。

示例2

输入: [1, 2, 3, 4]
输出: 2
解释: 可以组成2个团队：[1, 2, 3], [4] 或者 [1, 2], [3, 4] 等其他组合。

思路

这个问题可以通过回溯法（Backtracking）来解决。回溯法是一种通过探索所有可能的候选解来找出所有解的算法。具体思路如下：

1. 排序：首先对员工数组进行排序，这有助于在回溯过程中更容易地找到符合条件的团队组合。
2. 回溯：定义一个递归函数，该函数尝试在当前位置开始选择3到5个员工组成团队，然后递归地处理剩余的员工。
3. 剪枝：在回溯过程中，如果当前已经选择了足够多的团队，可以提前返回。
4. 更新结果：在每次回溯完成后，更新当前的最大团队数量。

Java 编码解析

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] people = {1, 2, 3, 4, 5, 6};
        System.out.println(maxTeams(people));
    }

    public static int maxTeams(int[] people) {
        Arrays.sort(people);
        int maxTeams = 0;
        backtrack(people, 0, 0, maxTeams, new boolean[people.length], new int[people.length], 0);
        return maxTeams;
    }

    private static void backtrack(int[] people, int index, int currentTeamSize, int maxTeams, boolean[] used, int[] currentTeam, int currentCount) {
        if (currentCount >= maxTeams) {
            maxTeams = currentCount;
        }

        if (index == people.length) {
            return;
        }

        for (int teamSize = 3; teamSize <= 5 && index + teamSize - 1 < people.length; teamSize++) {
            boolean isValidTeam = true;
            for (int i = 0; i < teamSize; i++) {
                if (used[index + i] || (i > 0 && people[index + i] == people[index + i - 1])) {
                    isValidTeam = false;
                    break;
                }
            }
            if (isValidTeam) {
                for (int i = 0; i < teamSize; i++) {
                    used[index + i] = true;
                    currentTeam[i] = people[index + i];
                }
                backtrack(people, index + teamSize, 0, maxTeams, used, currentTeam, currentCount + 1);
                for (int i = 0; i < teamSize; i++) {
                    used[index + i] = false;
                }
            }
        }

        backtrack(people, index + 1, currentTeamSize, maxTeams, used, currentTeam, currentCount);
    }
}

C++ 编码解析

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int maxTeamsHelper(vector<int>& people, int index, int currentTeamSize, int& maxTeams, vector<bool>& used, vector<int>& currentTeam, int currentCount) {
    if (currentCount >= maxTeams) {
        maxTeams = currentCount;
    }

    if (index == people.size()) {
        return 0;
    }

    int result = currentCount;
    for (int teamSize = 3; teamSize <= 5 && index + teamSize - 1 < people.size(); teamSize++) {
        bool isValidTeam = true;
        for (int i = 0; i < teamSize; i++) {
            if (used[index + i] || (i > 0 && people[index + i] == people[index + i - 1])) {
                isValidTeam = false;
                break;
            }
        }
        if (isValidTeam) {
            for (int i = 0; i < teamSize; i++) {
                used[index + i] = true;
            }
            result = max(result, maxTeamsHelper(people, index + teamSize, 0, maxTeams, used, currentTeam, currentCount + 1));
            for (int i = 0; i < teamSize; i++) {
                used[index + i] = false;
            }
        }
    }

    result = max(result, maxTeamsHelper(people, index + 1, currentTeamSize, maxTeams, used, currentTeam, currentCount));
    return result;
}

int maxTeams(vector<int>& people) {
    sort(people.begin(), people.end());
    int maxTeams = 0;
    vector<bool> used(people.size(), false);
    vector<int> currentTeam(5); // Maximum team size is 5
    return maxTeamsHelper(people, 0, 0, maxTeams, used, currentTeam, 0);
}

int main() {
    vector<int> people = {1, 2, 3, 4, 5, 6};
    cout << maxTeams(people) << endl;
    return 0;
}

Python 编码解析

def max_teams_helper(people, index, current_team_size, max_teams, used, current_team, current_count):
    if current_count >= max_teams:
        nonlocal max_teams
        max_teams = current_count

    if index == len(people):
        return

    for team_size in range(3, 6):
        if index + team_size - 1 >= len(people):
            break

        is_valid_team = True
        for i in range(team_size):
            if used[index + i] or (i > 0 and people[index + i] == people[index + i - 1]):
                is_valid_team = False
                break

        if is_valid_team:
            for i in range(team_size):
                used[index + i] = True
            max_teams_helper(people, index + team_size, 0, max_teams, used, current_team, current_count + 1)
            for i in range(team_size):
                used[index + i] = False

    max_teams_helper(people, index + 1, current_team_size, max_teams, used, current_team, current_count)

def max_teams(people):
    people.sort()
    max_teams = 0
    used = [False] * len(people)
    max_teams_helper(people, 0, 0, max_teams, used, [], 0)
    return max_teams

# Test
people = [1, 2, 3, 4, 5, 6]
print(max_teams(people))