LeetCode 902：最大为 N 的数字组合——Java & C++ 题解与拓展

2023-09-03 03:42:26

引言

在 LeetCode 902：最大为 N 的数字组合这道题中，我们被要求找到一个长度为 k 的数字组合，使得这个数字组合的最大值为 N。同时，这个数字组合必须满足一定的条件：

数字组合中的每个数字必须是 0 到 9 之间的整数。
数字组合中的每个数字只能使用一次。
数字组合中的数字必须按照从左到右的顺序排列。

解题思路

为了解决这个问题，我们可以使用数位 DP 动态规划方法。数位 DP 动态规划是一种解决具有重叠子问题的动态规划问题的方法。在数位 DP 动态规划中，我们将问题分解成若干个子问题，然后解决这些子问题，并将子问题的解存储起来，以便在解决后续问题时重用。

在这个问题中，我们可以将问题分解成若干个子问题。每个子问题都是：给定一个长度为 k 的数字组合，且这个数字组合的最大值为 N，找到这个数字组合的所有可能排列。

我们可以使用动态规划方法来解决这些子问题。首先，我们将创建一个二维数组 dp，其中 dp[i][j] 表示长度为 i 的数字组合，且最大值为 j 的所有可能排列。然后，我们可以使用以下递推公式来计算 dp[i][j]：

dp[i][j] = dp[i-1][j] + dp[i][j-1]

其中，dp[i-1][j] 表示长度为 i-1 的数字组合，且最大值为 j 的所有可能排列，dp[i][j-1] 表示长度为 i 的数字组合，且最大值为 j-1 的所有可能排列。

一旦我们计算出 dp[i][j]，我们就可以找到长度为 k 的数字组合，且最大值为 N 的所有可能排列。我们可以从 dp[k][N] 开始，然后使用以下步骤回溯到这个数字组合：

如果 dp[k][N] > 0，那么长度为 k 的数字组合，且最大值为 N 的所有可能排列都存储在 dp[k][N] 中。
否则，长度为 k 的数字组合，且最大值为 N 的所有可能排列都存储在 dp[k-1][N] 和 dp[k][N-1] 中。我们可以分别从 dp[k-1][N] 和 dp[k][N-1] 回溯到长度为 k-1 的数字组合，且最大值为 N 和长度为 k 的数字组合，且最大值为 N-1 的所有可能排列。

Java 代码

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

public class Solution {

    public List<Integer> maxNumber(int[] nums, int k) {
        int n = nums.length;
        int[][] dp = new int[n + 1][k + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= k; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }

        List<Integer> result = new ArrayList<>();
        int i = n;
        int j = k;
        while (i >= 1 && j >= 1) {
            if (dp[i - 1][j] > 0) {
                i--;
            } else {
                result.add(nums[i - 1]);
                j--;
            }
        }

        return result;
    }
}

C++ 代码

#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    vector<int> maxNumber(vector<int>& nums, int k) {
        int n = nums.size();
        vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= k; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }

        vector<int> result;
        int i = n;
        int j = k;
        while (i >= 1 && j >= 1) {
            if (dp[i - 1][j] > 0) {
                i--;
            } else {
                result.push_back(nums[i - 1]);
                j--;
            }
        }

        return result;
    }
};