华为OD机考E卷100分题 - 第k个排列

原创 已于 2024-11-18 07:56:33 修改 · 1.8k 阅读 · 44 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#华为od #算法 #数据结构

于 2024-11-18 07:40:54 首次发布

最新华为OD机试

题目描述

给定参数n，从1到n会有n个整数：1,2,3,…,n,这n个数字共有n!种排列。

按大小顺序升序列出所有排列的情况，并一一标记，

当n=3时,所有排列如下:

“123” “132” “213” “231” “312” “321”

给定n和k，返回第k个排列。

输入描述

  • 输入两行，第一行为n，第二行为k，
  • 给定n的范围是[1,9],给定k的范围是[1,n!]。

输出描述

输出排在第k位置的数字。

示例1

输入

3
3
12

输出

213
1

说明

3的排列有123,132,213…,那么第三位置就是213

示例2

输入

2
2
12

输出

21
1

说明

2的排列有12,21，那么第二位置的为21。

解题思路

常见的递归解法

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        int n, k;
        Vector<String> lines = new Vector<String>();
        Scanner scanner = new Scanner(System.in);

        // 读取 n 和 k
        n = scanner.nextInt();
        k = scanner.nextInt();

        // 如果 n 等于 1，则直接输出 1 并结束程序
        if (n == 1) {
            System.out.println("1");
            return;
        }

        // 初始化 nums 数组，存储 1 到 n 的整数
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = i + 1;
        }

        // 初始化结果列表
        List<String> result = new ArrayList<>();

        // 递归函数，用于生成所有排列
        generatePermutations(nums, "", result, k);

        // 对结果列表进行排序
        Collections.sort(result);

        // 输出第k个排列
        System.out.println(result.get(k - 1));
    }

    public static void generatePermutations(int[] nums, String current, List<String> result, int k) {
        // 如果数字数组为空，将当前结果添加到结果列表中
        if (nums.length == 0) {
            result.add(current);
            return;
        }

        // 遍历当前数字数组
        for (int i = 0; i < nums.length; i++) {
            // 取出一个数字
            int num = nums[i];

            // 创建新的数字数组，删除当前数字
            int[] newNums = new int[nums.length - 1];
            for (int j = 0; j < i; j++) {
                newNums[j] = nums[j];
            }
            for (int j = i + 1; j < nums.length; j++) {
                newNums[j - 1] = nums[j];
            }

            // 递归调用函数，传递更新后的数字数组和结果字符串
            generatePermutations(newNums, current + num, result, k);

            // 如果结果列表长度等于k，直接返回
            if (result.size() == k) {
                return;
            }
        }
    }
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869

Python

n = int(input())
k = int(input())


if n == 1:
    print("1")
    exit()

nums = [i+1 for i in range(n)]
result = []

def generatePermutations(nums, current, result, k):
    if len(nums) == 0:
        result.append(current)
        return

    for i in range(len(nums)):
        num = nums[i]
        newNums = nums[:i] + nums[i+1:]
        generatePermutations(newNums, current + str(num), result, k)

        if len(result) == k:
            return

generatePermutations(nums, "", result, k)

result.sort()
print(result[k-1])

1234567891011121314151617181920212223242526272829

JavaScript

const readline = require('readline');

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

rl.on('line', (n) => {
  rl.on('line', (k) => {
    // 如果 n 等于 1，则直接输出 1 并结束程序
    if (n == 1) {
      console.log("1");
      rl.close();
      return;
    }

    // 初始化 nums 数组，存储 1 到 n 的整数
    let nums = [];
    for (let i = 0; i < n; i++) {
      nums.push(i + 1);
    }

    // 初始化结果列表
    let result = [];

    // 递归函数，用于生成所有排列
    generatePermutations(nums, "", result, k);

    // 对结果列表进行排序
    result.sort();

    // 输出第k个排列
    console.log(result[k - 1]);

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

function generatePermutations(nums, current, result, k) {
  // 如果数字数组为空，将当前结果添加到结果列表中
  if (nums.length === 0) {
    result.push(current);
    return;
  }

  // 遍历当前数字数组
  for (let i = 0; i < nums.length; i++) {
    // 取出一个数字
    let num = nums[i];

    // 创建新的数字数组，删除当前数字
    let newNums = nums.slice(0, i).concat(nums.slice(i + 1));

    // 递归调用函数，传递更新后的数字数组和结果字符串
    generatePermutations(newNums, current + num, result, k);

    // 如果结果列表长度等于k，直接返回
    if (result.length === k) {
      return;
    }
  }
}


12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364

C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void generatePermutations(vector<int>& nums, string current, vector<string>& result, int k);

int main() {
    int n, k;
    vector<string> lines;
    cin >> n >> k;

    if (n == 1) {
        cout << "1" << endl;
        return 0;
    }

    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        nums[i] = i + 1;
    }

    vector<string> result;
    generatePermutations(nums, "", result, k);

    sort(result.begin(), result.end());

    cout << result[k - 1] << endl;

    return 0;
}

void generatePermutations(vector<int>& nums, string current, vector<string>& result, int k) {
    if (nums.empty()) {
        result.push_back(current);
        return;
    }

    for (int i = 0; i < nums.size(); i++) {
        int num = nums[i];
        vector<int> newNums(nums.size() - 1);
        copy(nums.begin(), nums.begin() + i, newNums.begin());
        copy(nums.begin() + i + 1, nums.end(), newNums.begin() + i);

        generatePermutations(newNums, current + to_string(num), result, k);

        if (result.size() == k) {
            return;
        }
    }
}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152

C语言

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

// 生成排列的递归函数
void generatePermutations(int* nums, int numsSize, char* current, char** result, int* resultSize, int k) {
    // 如果数字数组为空，将当前结果添加到结果列表中
    if (numsSize == 0) {
        result[*resultSize] = (char*)malloc(strlen(current) + 1);
        strcpy(result[*resultSize], current);
        (*resultSize)++;
        return;
    }

    // 遍历当前数字数组
    for (int i = 0; i < numsSize; i++) {
        // 取出一个数字
        int num = nums[i];

        // 创建新的数字数组，删除当前数字
        int* newNums = (int*)malloc((numsSize - 1) * sizeof(int));
        for (int j = 0; j < i; j++) {
            newNums[j] = nums[j];
        }
        for (int j = i + 1; j < numsSize; j++) {
            newNums[j - 1] = nums[j];
        }

        // 更新结果字符串
        int newCurrentLen = strlen(current) + 10; // 分配足够大的空间
        char *newCurrent = (char*)malloc(newCurrentLen * sizeof(char));
        snprintf(newCurrent, newCurrentLen, "%s%d", current, num);

        // 递归调用函数，传递更新后的数字数组和结果字符串
        generatePermutations(newNums, numsSize - 1, newCurrent, result, resultSize, k);

        // 如果结果列表长度等于k，直接返回
        if (*resultSize == k) {
            free(newNums);
            free(newCurrent); // 避免内存泄漏
            return;
        }

        // 释放内存
        free(newNums);
        free(newCurrent); // 每次循环后释放newCurrent
    }
}

int compareStrings(const void* a, const void* b) {
    return strcmp(*(const char**)a, *(const char**)b);
}

int main() {
    int n, k;

    // 读取 n 和 k
    scanf("%d %d", &n, &k);

    // 如果 n 等于 1，则直接输出 1 并结束程序
    if (n == 1) {
        printf("1\n");
        return 0;
    }

    // 初始化 nums 数组，存储 1 到 n 的整数
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        nums[i] = i + 1;
    }

    // 初始化结果列表
    char** result = (char**)malloc(100000000 * sizeof(char*));   
    int resultSize = 0;

    // 调用递归函数生成所有排列
    char current[100] = "";  // 初始的结果字符串为空
    generatePermutations(nums, n, current, result, &resultSize, k);

    // 对结果列表进行排序
    qsort(result, resultSize, sizeof(char*), compareStrings);

    // 输出第 k 个排列
    printf("%s\n", result[k - 1]);

    // 释放内存
    for (int i = 0; i < resultSize; i++) {
        free(result[i]);
    }
    free(result);
    free(nums);

    return 0;
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394

不用递归，用全排列

核心解题思路是基于康托展开（Cantor Expansion）原理来解决排列组合问题。康托展开是一种将排列转换为字典序数（第几个排列）的方法，反之也可以用来根据字典序数反向推导出具体的排列。

解题思路

  1. 理解排列的字典序：对于给定的整数 n 和 k，题目要求找到由 [1, 2, ..., n] 组成的所有排列中按字典序排列的第 k 个排列。字典序排列是将排列按数值大小进行排序。

  2. 分解问题：将排列问题分解为一系列位置选择的问题：

    • 首先确定排列的第一个数字，然后确定剩下数字的排列。
    • 通过除以某个数字的阶乘，可以找到这一位上的数字索引，接着更新 k 值并继续进行下一位的选择。

  3. 计算阶乘：使用阶乘来计算某个位置上的数字有多少种可能性。

    • 对于长度为 n 的数组，第一个数字确定后，剩下的 n-1 个数字有 (n-1)! 种排列方式。
    • 例如，对于 [1, 2, 3]，如果第一个数字是 1，那么剩余 [2, 3] 可以有 2! = 2 种排列。

  4. 确定每一位数字：通过计算 (k-1) / (n-1)! 来确定第一个数字的位置索引 index，然后从数字列表中删除已经选择的数字，并调整 k 为 k % (n-1)!，继续下一位的选择。

  5. 重复过程：这个过程从左到右一位一位确定，每一步都使用上述计算方法，直到所有位都确定。

康托展开原理解析

以下通过一个例子详细讲解康托展开的原理：

例子：判断数字2143在集合{1, 2, 3, 4}的全排列中是第几大的排列？

求解过程：

集合{1, 2, 3, 4}共有4个元素，因此总共有 4 ! = 24 4! = 24 4!=24 种排列方式。要计算2143在这些排列中所处的具体位置，我们可以通过以下步骤进行：

  1. 计算首位小于2的排列数：

    • 比2小的数字只有1。
    • 剩余的三个数字有 3 ! = 6 3! = 6 3!=6 种排列方式。
    • 因此，这部分排列的数量为 1 × 3 ! = 6 1 \times 3! = 6 1×3!=6。

  2. 计算首位为2、第二位小于1的排列数：

    • 第二位比1小的数字不存在。
    • 因此，这部分排列的数量为 0 × 2 ! = 0 0 \times 2! = 0 0×2!=0。

  3. 计算前两位为21、第三位小于4的排列数：

    • 第三位比4小的数字只有3。
    • 剩余的一个数字有 1 ! = 1 1! = 1 1!=1 种排列方式。
    • 因此，这部分排列的数量为 1 × 1 ! = 1 1 \times 1! = 1 1×1!=1。

  4. 计算前三位为214、第四位小于3的排列数：

    • 第四位比3小的数字不存在。
    • 因此，这部分排列的数量为 0 × 0 ! = 0 0 \times 0! = 0 0×0!=0。
结果计算：

将以上各部分的结果相加，即可得到2143在全排列中的位置：

1 × 3 ! + 0 × 2 ! + 1 × 1 ! + 0 × 0 ! = 7 1 \times 3! + 0 \times 2! + 1 \times 1! + 0 \times 0! = 7 1×3!+0×2!+1×1!+0×0!=7

所以2143是第8大的排列。

康托展开公式

通过上述例子，我们可以推导出康托展开的通用公式：

X = a [ n ] × ( n − 1 ) ! + a [ n − 1 ] × ( n − 2 ) ! + ⋯ + a [ i ] × ( i − 1 ) ! + ⋯ + a [ 2 ] × 1 ! + a [ 1 ] × 0 ! X = a[n] \times (n-1)! + a[n-1] \times (n-2)! + \dots + a[i] \times (i-1)! + \dots + a[2] \times 1! + a[1] \times 0! X=a[n]×(n−1)!+a[n−1]×(n−2)!+⋯+a[i]×(i−1)!+⋯+a[2]×1!+a[1]×0!

其中， a [ i ] a[i] a[i]表示原数第 i i i 位在当前未出现的元素中排在第几位（从0开始计数），并且满足 0 ≤ a [ i ] < i 0 \leq a[i] < i 0≤a[i]<i（ 1 ≤ i ≤ n 1 \leq i \leq n 1≤i≤n）。

康托逆展开

康托展开的逆过程称为康托逆展开，即对于某个集合的全排列，输入一个数字 k k k，返回对应的第 k k k 大排列。

Java

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static String getPermutation(int n, int k) {
        // 初始化数字列表和阶乘表
        List<Integer> numbers = new ArrayList<>();
        int[] factorial = new int[n + 1];
        
        // 填充1到n的数字
        for (int i = 1; i <= n; i++) {
            numbers.add(i);
        }
        
        // 初始化阶乘表，factorial[0] = 1
        factorial[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = factorial[i - 1] * i;
        }
        
        // 调整k到0索引
        k--;
        StringBuilder result = new StringBuilder();
        
        // 从大到小确定每一位
        for (int i = n; i > 0; i--) {
            // 计算当前位数字索引
            int index = k / factorial[i - 1];
            result.append(numbers.get(index));
            
            // 移除已经选择的数字
            numbers.remove(index);
            
            // 更新k值
            k %= factorial[i - 1];
        }
        
        return result.toString();
    }

    public static void main(String[] args) {
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        System.out.println(getPermutation(n, k));
    }
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647

Python

import math

def get_permutation(n, k):
    # 初始化数字列表和阶乘表
    numbers = list(range(1, n+1))
    factorial = [1] * (n+1)
    
    # 预先计算所有阶乘值
    for i in range(2, n+1):
        factorial[i] = factorial[i-1] * i
    
    # 调整k到0索引
    k -= 1
    result = ""
    
    # 从大到小确定每一位
    for i in range(n, 0, -1):
        # 计算当前位数字索引
        index = k // factorial[i-1]
        result += str(numbers[index])
        
      
        
        # 更新k值
        k %= factorial[i-1]
    
    return result

 
n = int(input())
k = int(input())
print(get_permutation(n, k))
1234567891011121314151617181920212223242526272829303132

JavaScript

function getPermutation(n, k) {
    // 初始化数字列表和阶乘表
    let numbers = Array.from({ length: n }, (_, i) => i + 1);
    let factorial = new Array(n + 1).fill(1);

    // 预先计算所有阶乘值
    for (let i = 2; i <= n; i++) {
        factorial[i] = factorial[i - 1] * i;
    }

    // 调整k到0索引
    k--;
    let result = '';

    // 从大到小确定每一位
    for (let i = n; i > 0; i--) {
        // 计算当前位数字索引
        let index = Math.floor(k / factorial[i - 1]);
        result += numbers[index];

        // 移除已经选择的数字
        numbers.splice(index, 1);

        // 更新k值
        k %= factorial[i - 1];
    }

    return result;
}

// 示例用法
const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

readline.on('line', n => {
    readline.on('line', k => {
        console.log(getPermutation(parseInt(n), parseInt(k)));
        readline.close();
    });
});
123456789101112131415161718192021222324252627282930313233343536373839404142

C++

#include <iostream>
#include <vector>
using namespace std;

string getPermutation(int n, int k) {
    // 初始化数字列表和阶乘表
    vector<int> numbers;
    vector<int> factorial(n + 1, 1);

    // 填充1到n的数字
    for (int i = 1; i <= n; i++) {
        numbers.push_back(i);
    }

    // 预先计算所有阶乘值
    for (int i = 2; i <= n; i++) {
        factorial[i] = factorial[i - 1] * i;
    }

    // 调整k到0索引
    k--;
    string result;

    // 从大到小确定每一位
    for (int i = n; i > 0; i--) {
        // 计算当前位数字索引
        int index = k / factorial[i - 1];
        result += to_string(numbers[index]);

        // 移除已经选择的数字
        numbers.erase(numbers.begin() + index);

        // 更新k值
        k %= factorial[i - 1];
    }

    return result;
}

int main() {
    int n, k;
    cin >> n >> k;
    cout << getPermutation(n, k) << endl;
    return 0;
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445

C语言

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

void getPermutation(int n, int k, char* result) {
    // 初始化数字列表和阶乘表
    int* numbers = (int*)malloc(n * sizeof(int));
    int* factorial = (int*)malloc((n + 1) * sizeof(int));

    // 填充1到n的数字
    for (int i = 0; i < n; i++) {
        numbers[i] = i + 1;
    }

    // 初始化阶乘表
    factorial[0] = 1;
    for (int i = 1; i <= n; i++) {
        factorial[i] = factorial[i - 1] * i;
    }

    // 调整k到0索引
    k--;
    int index, pos = 0;

    // 从大到小确定每一位
    for (int i = n; i > 0; i--) {
        // 计算当前位数字索引
        index = k / factorial[i - 1];
        result[pos++] = numbers[index] + '0';  // 转换为字符保存

        // 移除已经选择的数字
        for (int j = index; j < n - 1; j++) {
            numbers[j] = numbers[j + 1];
        }

        // 更新k值
        k %= factorial[i - 1];
    }
    result[pos] = '\0';  // 添加字符串结束符

    // 释放动态分配的内存
    free(numbers);
    free(factorial);
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    char result[10];  // 假设n最大为9
    getPermutation(n, k, result);
    printf("%s\n", result);
    return 0;
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
【华为OD】C卷真题 100分：CPU算力分配 C语言代码实现[思路+代码]
十年以上编程经验的干货分享
03-10 1078
A和B，每组有多个算力不同的CPU，其中 A[i] 是 A 组第 i 个CPU的运算能力，B[i] 是 B组 第 i 个CPU的运算能力。第一行输入为L1和L2，以空格分隔，L1表示A组服务器中的CPU数量，L2表示B组服务器中的CPU数量。对于每组测试数据，输出两个整数，以空格分隔，依次表示A组选出的CPU算力，B组选出的CPU算力。求两组服务器中，用于交换的CPU的算力，并且要求从A组服务器中选出的CPU，算力尽可能小。第二行输入为A组服务器中各个CPU的算力值，以空格分隔。
2024年华为od机试真题题库
面试高手的博客
03-08 9万+
我是一名软件开发机构老师，我的学生已经有上百人通过了华为OD机试，2024年8月-2025年2月考的都是OD统一考试（E卷），题库已经整理好了，命中率95%以上。
华为OD机试真题.pdf
04-15
华为机试真题（非牛客网试练题）OD考试真题，不定期更新，文档含代码解答
OD机试题
qq_27704713的博客
07-22 462
输入一行，为打乱字符的字符串和正整数序列的长度，两者间用空格分隔，字符审长度不超过200，正整数不超过1000，保证输入可以还原成唯一序列。第2到M+1行是半角逗号分割的整数序列，表示评委为每个选手的打分，0号下标数字表示1号选手分数，1号下标数字表示2号选手分数，一次类推。2号选手得分36分排第1，1号选手36分排第2，5号选手30分(2号10分值有3个，1号10分值只有1个，所以2号排第一)一个有N个选手参加比赛，选手编号为1~N（3
OD机试题(五)
weixin_45054115的博客
04-22 642
如果单词中包含有重复的字母，只保留第1个，将所得结果作为新字母表开头，并将新建立的字母表中未出现的字母按照正常字母表顺序加入新字母表。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。描述：有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。输入描述：一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？
华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|2025C卷B卷
u014481728的博客
01-26 8万+
华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|B卷C卷
华为OD机考E卷200分题 - 字母组合过滤组合字符串
left_freckle的专栏
11-19 669
屏蔽字符串：屏蔽字符串中的所有字母不能同时在输出的字符串出现，如屏蔽字符串是abc，则要求字符串中不能同时出现a,b,c，但是允许同时出现a,b或a,c或b,c等；数字字符串78，可以得到如下字符串uw，ux，vw，vx；由于ux是屏蔽字符串，因此排除ux，最终的输出是uw，vw，vx;第一行输入为一串数字字符串，数字字符串中的数字不允许重复，数字字符串的长度大于0，小于等于5；第二行输入是屏蔽字符串，屏蔽字符串的长度一定小于数字字符串的长度，屏蔽字符串中字符不会重复；输出可能的字符串组合。
【华为OD机考真题】- 流浪地球(E卷-100分)（Java）
**My Coding Family**
03-20 1485
🔔本文收录于「2025华为OD机试真题(Java版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！本人所写题库均搜集于互联网。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可阅读使用！
【华为OD机考真题】- 第N个排列(E卷-100分)（Java）
**My Coding Family**
02-11 1342
🔔本文收录于「最新最全华为OD机试真题(Java版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！本人所写题库均精心搜集于互联网。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可阅读使用！
【华为OD机考真题】- 第N个排列(E卷-100分)（C++版）
**My Coding Family**
05-07 1459
🔔本文收录于「最新最全华为OD机试真题(C++版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！本人所写题库均精心搜集于互联网。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可阅读使用！
华为OD机考100题，真题
06-05
华为OD机考100题
OD机试题练习(一)
weixin_45054115的博客
04-15 958
OD试题在线联系一
华为OD机试题
weixin_56538996的博客
06-29 1万+
华为OD机试
华为OD机试题（ B+C+D卷）真题抽中记录文档（更新到 24 年 2 月 24 日）
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
05-18 1万+
如果你收到的 试卷名称为 《OD 统一考试（B 卷）》，这个要注意了，使用的题库扩大了，不过橡皮擦已经抓紧在整理 B 卷题库了，不用担心。【牛 x 网】你好，OD 项目邀你参加在线笔试，如未收到邮件，可关注某信服务号：牛 x 招聘助手随时查询。⭐️ 华为 OD 机考 Python ⭐️。⭐️ 华为 OD 机考 Golang ⭐️。⭐️ 华为 OD 机考真 C 语言 ⭐️。⭐️ 华为 OD 机考 C++ ⭐️。⭐️ 华为 OD 机考 JAVA⭐️。⭐️ 华为 OD 机考 JS⭐️。
华为OD机考题目（自动化测试）
qq_39177863的博客
10-19 3202
华为OD机考题目（自动化测试）
华为OD机试真题 2023 B + 2023 C&D 卷（JAVA&JS&Python&C++）
热门推荐
qq_34465338的博客
12-15 11万+
本栏包含了华为OD机试真题2022Q4 A + 2023 B卷的全部机试真题。
【华为OD机考】2024E+D卷真题【完全原创题解 详细考点分类 不断更新题目 六种主流语言Py+Java+Cpp+C+Js+Go】
m0_74825488的博客
03-01 1699
可上练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【优快云】否则不通过）
【华为OD机试】真题B卷-分班问题（python）
u014481728的博客
12-18 866
幼儿园两个班的小朋友在排队时混在了一起，每位小朋友都知道自己是否与前面一位小朋友同班，请你帮忙把同班的小朋友找出来。小朋友的编号是整数，与前一位小朋友同班用Y表示，不同班用N表示。学生序号范围(0,999]，如果输入不合法则打印ERROR。
华为OD机试（含B卷）真题2023 精简版，50道100分题目。如果距离机考时间不多了，就看这个吧
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
04-28 3万+
关于华为od题库的说明（2023-06-23 更新本文） 关于订阅华为OD机试题库的后续问题 华为OD机试 真题，新题库，50到100分题 华为OD机试 6 大宝典，包含题库完整真题 关于华为OD的更多疑问，可查看下述专栏
华为od机考真题 商品的前K个方案
最新发布
05-31
<think>好的，我现在需要解决用户关于华为OD机考中“商品前K个高频方案”的真题及解答的问题。首先，用户之前的问题是关于恰好花费K元的购买方案总数，现在转向了前K个高频方案，可能是需要找出出现次数最多的前K种方案。需要明确问题的具体要求。首先，我需要确定用户的问题具体是什么。根据用户提到的“商品前K个高频方案”，可能是指给定一组商品购买记录，统计每种购买方案出现的频率，然后找出出现次数最多的前K种方案。或者，可能是在所有可能的购买方案中，找出金额最大的前K种方案，或者某种特定条件下的前K个方案。需要结合华为OD机考的常见题型来推测。参考之前的对话，用户之前的问题是关于完全背包或0-1背包的恰好花费K元的方案数，现在转向高频方案，可能题目发生了变化。例如，可能需要找出所有可能的购买组合，然后按出现频率或某种条件排序，取前K个。或者，题目可能涉及到组合方案中的前K个最小或最大的方案，比如金额最小的前K种方案。接下来，我需要查找华为OD机考相关的真题，特别是涉及商品和K个方案的题目。根据用户提供的引用内容，引用[4]提到华为OD机考涉及动态规划、回溯、贪心等算法，可能相关题目属于这些类别。例如，动态规划生成所有可能的方案，然后取前K个，或者使用优先队列来维护前K个高频或最小/大的方案。假设题目类似于：给定商品价格数组，找出所有能组成总金额的购买方案，并按金额升序排列，输出前K个方案。或者，统计每个方案的出现次数，输出频率最高的前K个。但根据用户之前的例子，输出的是方案数，可能现在的题目需要具体输出方案本身，并按某种顺序取前K个。例如，可能的题目描述是：给定商品价格数组prices和目标金额K，找出所有恰好花费K元的购买方案，并按字典序输出前K个方案。或者，输出出现次数最多的前K种方案（但需要购买记录的数据，题目可能没有给出，所以更可能是前者）。需要进一步分析可能的题目结构。例如，用户之前的问题输出是4种方案，现在可能需要输出前K个，比如当K=2时，输出前两种方案，如字典序最小的两个。或者，题目可能要求输出所有可能的方案，并按某种规则排序后取前K个。 在解法方面，可能需要先生成所有可能的方案，然后进行排序，再取前K个。生成方案可以使用回溯法，记录所有满足总金额等于目标的情况。然后对这些方案进行排序，比如按商品数量升序，或者按字典序排列，然后输出前K个。例如，输入为prices=[1,2,5]，K=5，生成所有恰好5元的方案，如[1,1,1,1,1],[1,1,1,2],[1,2,2], [5]。然后按字典序排列，可能得到顺序为[1,1,1,1,1], [1,1,1,2],[1,2,2],[5]。此时，若要求前K=2个方案，输出这两个。 因此，解题步骤可能包括：1.使用回溯法生成所有可能的购买方案，确保总金额等于目标K。 2.对生成的方案进行排序（按字典序、长度或其他条件）。 3.取前K个方案作为结果。 需要注意去重和剪枝，例如，当商品可以重复购买时，不同的顺序可能被视为同一方案（如[1,2]和[2,1]视为相同），此时需要避免重复计数。或者在回溯时控制顺序，比如只允许非递减顺序添加商品，这样生成的方案自然不重复，且有序。 例如，在回溯时，每次只能选择当前商品及之后的商品，这样可以避免重复组合。例如，先选1，然后下一层只能选1或更大的商品，这样生成的方案是排序后的，避免重复。 代码实现方面，可以使用回溯，并在递归时传递起始索引，确保每次选择商品不回头，从而生成唯一的组合方式。同时，记录路径，当路径总和等于K时，保存该路径。 然后，将所有符合条件的路径进行排序，取前K个。需要注意效率问题，当目标K较大时，组合数可能很多，需要剪枝优化。 例如，在回溯过程中，如果当前路径的总和已经超过K，可以提前终止该分支的递归。此外，排序可能需要在生成所有方案后进行，但若K较小，可能可以边生成边维护一个优先队列，只保留前K个方案，以减少内存消耗。 综上，可能的解法是回溯剪枝生成所有有效方案，排序后取前K个。接下来需要验证这个思路是否符合华为OD的真题，并给出相应的代码示例。同时，需要参考用户提供的引用内容，尤其是引用[4]提到的动态规划、回溯等考点，确保解法符合华为OD的常见题型。例如，引用[4]中提到的动态规划可能用于生成方案数，但输出具体方案可能需要回溯。最后，需要确保回答的结构清晰，包含问题描述、输入输出样例、解题思路、代码实现，以及相关考点和问题，符合用户之前的提问格式。同时，按照要求使用LaTeX格式的数学表达式，引用相关段落，并生成相关问题。</think>### 华为OD机考“商品前K个高频方案”真题解析 --- #### 问题描述（根据引用[4]动态规划与回溯考点推测） 给定商品价格数组$prices$和目标金额$K$，要求输出**恰好花费$K$元**的所有购买方案中，按**字典序升序排列**后的**前$K$个方案**。每个商品可重复购买（完全背包问题变种）[^4]。 **输入样例** ``` 5 # 目标金额K=5元 [1,2,5] # 商品价格数组 3 # 要求输出前3个方案 ``` **输出样例** ``` [[1,1,1,1,1], [1,1,1,2], [1,2,2]] # 字典序最小的前3个方案 ``` --- ### 解题思路与代码实现 #### 方法一：回溯剪枝 + 字典序排序 1. **回溯生成所有有效方案**：通过限制选择顺序（非递减选择商品）避免重复方案。 2. **字典序排序**：对生成的方案按字典序排序后取前$K$个。 3. **剪枝优化**：当路径累计金额超过$K$时提前终止递归。 ```python def find_k_plans(prices, K, top_k): prices.sort() # 确保字典序生成 res = [] def backtrack(start, path, current_sum): if current_sum == K: res.append(path.copy()) return for i in range(start, len(prices)): price = prices[i] if current_sum + price > K: continue # 剪枝：金额超过则跳过 path.append(price) backtrack(i, path, current_sum + price) # 允许重复选商品 path.pop() backtrack(0, [], 0) res.sort() # 按字典序排序 return res[:top_k] if top_k <= len(res) else res # 测试样例 print(find_k_plans([1,2,5], 5, 3)) # 输出[[1,1,1,1,1], [1,1,1,2], [1,2,2]] ``` --- #### 关键考点解析 1. **字典序控制**：通过先对$prices$排序，并在回溯时按非递减顺序选择商品，保证生成的方案自然有序[^4]。 2. **剪枝优化**：时间复杂度由$O(2^N)$降低到$O(\text{valid\_combinations})$。 3. **去重处理**：限制每次选择的起始位置，避免生成重复方案（如`[1,2]`和`[2,1]`视为同一方案）。 --- ### 相关问题 1. 如何优化算法以处理较大的$K$值（如$K=1000$）？ 2. 如果要求输出金额最小的前$K$个方案（而非字典序），应如何调整排序逻辑？ 3. 当商品数量较多时（如$prices$长度为50），如何避免内存溢出？ 4. 如何用动态规划记录具体方案（而非仅方案数）？ 5. 如果商品只能购买一次（0-1背包），算法需要如何修改？ --- [^4]: 参考华为OD机考动态规划与回溯考点说明。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值