华为OD机试 - 符合要求的元组的个数 - 回溯（Python/JS/C/C++ 2025 A卷 100分）

华为OD机试 2025A卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

一、题目描述

给定一个整数数组nums、一个数字k，一个整数目标值target，请问nums中是否存在k个元素，使其相加结果为target，请输出所有符合条件且不重复的k元组的个数。

取值范围：

2 <= nums.length <= 200
-10⁹ < numslil < 10⁹
-10⁹ < target< 10⁹
2 <= k <= 100

二、输入描述

第一行输入整数数组nums；
第二行输入数字k；
第三行输入整数目标值target；

三、输出描述

输出第一行是符合要求的元组个数。

四、测试用例

测试用例1：

1、输入

-1 -2 -3 4 5
2
2

2、输出

2

3、说明

符合条件的2元组为：( -1, 3) 和 (-2, 4)。注意数组中没有3，因此只有一种有效的组合，可能需要修正代码。

测试用例2：

1、输入

0 0 0 0
2
0

2、输出

1

3、说明

符合条件的2元组为：(0,0)。尽管有多个0，去重后只有一个唯一的元组。

五、解题思路

1. 输入整数数组nums；
2. 输入数字k；
3. 输入整数目标值target；
4. 递归计算数组nums中是否有k个数字之和等于target，并且组合不能重复；
5. 输出符合条件的数量okSum；

六、Python算法源码

import sys
from itertools import combinations

def main():
    # 读取输入
    nums = list(map(int, sys.stdin.readline().strip().split()))
    k = int(sys.stdin.readline())
    target = int(sys.stdin.readline())

    nums.sort()  # 预排序

    unique_tuples = set()
    okSum = 0

    def backtrack(start, n, current_sum, path):
        nonlocal okSum
        if n == 0:
            if current_sum == target:
                tuple_key = tuple(path)
                if tuple_key not in unique_tuples:
                    unique_tuples.add(tuple_key)
                    okSum += 1
            return
        for i in range(start, len(nums) - n + 1):
            # 剪枝
            if current_sum + nums[i] + nums[i + 1]*(n - 1) > target:
                break
            if current_sum + nums[i] + nums[-1]*(n - 1) < target:
                continue
            # 跳过重复元素
            if i > start and nums[i] == nums[i - 1]:
                continue
            backtrack(i + 1, n - 1, current_sum + nums[i], path + [nums[i]])

    backtrack(0, k, 0, [])
    print(okSum)

if __name__ == "__main__":
    main()

七、JavaScript算法源码

const readline = require('readline');

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

    let input = [];
    rl.on('line', (line) => {
        input.push(line.trim());
        if (input.length === 3) {
            rl.close();
        }
    });

    rl.on('close', () => {
        const nums = input[0].split(' ').map(Number);
        const k = parseInt(input[1]);
        const target = parseInt(input[2]);

        nums.sort((a, b) => a - b); // 预排序

        let okSum = 0;
        const uniqueTuples = new Set();

        function backtrack(start, n, currentSum, path) {
            if (n === 0) {
                if (currentSum === target) {
                    const tupleKey = path.join(',');
                    if (!uniqueTuples.has(tupleKey)) {
                        uniqueTuples.add(tupleKey);
                        okSum++;
                    }
                }
                return;
            }
            for (let i = start; i <= nums.length - n; i++) {
                // 剪枝
                if (currentSum + nums[i] + nums[i + 1]*(n -1) > target) break;
                if (currentSum + nums[i] + nums[nums.length -1]*(n -1) < target) continue;
                // 跳过重复元素
                if (i > start && nums[i] === nums[i -1]) continue;
                backtrack(i + 1, n -1, currentSum + nums[i], path.concat(nums[i]));
            }
        }

        backtrack(0, k, 0, []);
        console.log(okSum);
    });
}

main();

八、C算法源码

#include <stdio.h>
#include <stdlib.h>

int okSum = 0;
int target;
int numsList[200][100];
int listCount = 0;

// 比较函数，用于排序
int cmp(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

// 检查是否已包含
int isContains(int *list, int size) {
    // 遍历已存储的元组
    for(int i = 0; i < listCount; i++) {
        int flag = 1;
        for(int j = 0; j < size; j++) {
            if(numsList[i][j] != list[j]) {
                flag = 0;
                break;
            }
        }
        if(flag) return 1;
    }
    return 0;
}

// 递归函数
void calculate(int *nums, int n, int *list, int listSize, int index, int currentSum, int size) {
    if(n == 0) {
        if(currentSum == target) {
            if(!isContains(list, size)) {
                for(int i = 0; i < size; i++) {
                    numsList[listCount][i] = list[i];
                }
                listCount++;
                okSum++;
            }
        }
        return;
    }
    for(int i = index; i <= size - n; i++) {
        // 剪枝
        if(currentSum + nums[i] + nums[i +1]*(n -1) > target) break;
        if(currentSum + nums[i] + nums[size -1]*(n -1) < target) continue;
        // 跳过重复元素
        if(i > index && nums[i] == nums[i -1]) continue;
        list[listSize] = nums[i];
        calculate(nums, n -1, list, listSize +1, i +1, currentSum + nums[i], size);
    }
}

int main(){
    // 读取输入
    int nums[200];
    int k;
    // 读取第一行
    int i = 0;
    while(scanf("%d", &nums[i]) == 1) {
        i++;
        if(getchar() == '\n') break;
    }
    int size = i;
    // 读取k和target
    scanf("%d", &k);
    scanf("%d", &target);

    // 排序
    qsort(nums, size, sizeof(int), cmp);

    int list[100];
    calculate(nums, k, list, 0, 0, 0, size);

    printf("%d\n", okSum);
    return 0;
}

九、C++算法源码

#include <bits/stdc++.h>
using namespace std;

int okSum = 0;
int target;
set<vector<int>> uniqueTuples;

// 递归函数
void calculate(vector<int> &nums, int n, vector<int> &path, int index, int currentSum) {
    if(n == 0) {
        if(currentSum == target) {
            if(uniqueTuples.find(path) == uniqueTuples.end()) {
                uniqueTuples.insert(path);
                okSum++;
            }
        }
        return;
    }
    for(int i = index; i <= nums.size() - n; i++) {
        // 剪枝
        if(currentSum + nums[i] + nums[i +1]*(n -1) > target) break;
        if(currentSum + nums[i] + nums[nums.size() -1]*(n -1) < target) continue;
        // 跳过重复元素
        if(i > index && nums[i] == nums[i -1]) continue;
        path.push_back(nums[i]);
        calculate(nums, n -1, path, i +1, currentSum + nums[i]);
        path.pop_back();
    }
}

int main(){
    // 读取输入
    string line;
    getline(cin, line);
    vector<int> nums;
    int num;
    stringstream ss(line);
    while(ss >> num) {
        nums.push_back(num);
    }
    int k, t;
    cin >> k >> t;
    target = t;

    sort(nums.begin(), nums.end()); // 预排序

    vector<int> path;
    calculate(nums, k, path, 0, 0);

    cout << okSum << endl;
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 A卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。