可以由A的数字组成的小于等于B的最大数字

给定两个整数A和B ，任务是找到可以使用A的所有数字形成的最大数≤B 。

例子：

Input: A = 123, B = 222
Output: 213
123, 132 and 213 are the only valid numbers which are ≤ 222.
213 is the maximum among them.

Input: A = 3921, B = 10000
Output: 9321

方法：让我们从最左边开始逐位构造答案。我们需要建立一个词典上最大的答案，因此我们应该在每个步骤中选择最大的数字。

从最大值开始对所有可能的数字进行迭代。对于每个数字，请检查是否可以将其放置在此位置。为此，请构造最小的后缀(贪心地放入最低位)，然后将所得的数字与B进行比较。如果该数字小于或等于B，则转到下一个数字。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
// Function to return the greatest number
// not gtreater than B that can be formed
// with the digits of A
string Permute_Digits(string a, long long b)
{
    // To store size of A
    int n = a.size();
  
    // To store the required answer
    string ans = "";
  
    // Traverse from leftmost digit and 
    // place a smaller digit for every
    // position.
    for (int i = 0; i < n; i++) {
  
        // Keep all digits in A
        set temp(a.begin(), a.end());
  
        // To avoid leading zeros
        if (i == 0)
            temp.erase(0);
  
        // For all possible values at ith position from
        // largest value to smallest
        for (auto j = temp.rbegin(); j != temp.rend(); ++j) {
  
            // Take largest possible digit
            string s1 = ans + *j;
  
            // Keep duplicate of string a
            string s2 = a;
  
            // Remove the taken digit from s2
            s2.erase(s2.find(*j), 1);
  
            // Sort all the remaining digits of s2
            sort(s2.begin(), s2.end());
  
            // Add s2 to current s1
            s1 += s2;
  
            // If s1 is less than B then it can be
            // included in the answer. Note that 
            // stoll() converts a string to lomg
            // long int.
            if (stoll(s1) <= b) {
                ans += *j;
  
                // change A to s2
                a = s2;
                break;
            }
        }
    }
  
    // Return the required answer
    return ans;
}
  
// Driver code
int main()
{
    string a = "123";
    int b = 222;
    cout << Permute_Digits(a, b);
  
    return 0;
}

Python3

# Python implementation of the approach
  
# Function to return the greatest number
# not gtreater than B that can be formed
# with the digits of A
def permuteDigits(a: str, b: int) -> str:
  
    # To store size of A
    n = len(a)
  
    # To store the required answer
    ans = ""
  
    # Traverse from leftmost digit and
    # place a smaller digit for every
    # position.
    for i in range(n):
  
        # Keep all digits in A
        temp = set(list(a))
  
        # To avoid leading zeros
        if i == 0:
            temp.discard(0)
  
        # For all possible values at ith position from
        # largest value to smallest
        for j in reversed(list(temp)):
  
            # Take largest possible digit
            s1 = ans + j
  
            # Keep duplicate of string a
            s2 = list(a).copy()
  
            # Remove the taken digit from s2
            s2.remove(j)
  
            # Sort all the remaining digits of s2
            s2 = ''.join(sorted(list(s2)))
  
            # Add s2 to current s1
            s1 += s2
  
            # If s1 is less than B then it can be
            # included in the answer. Note that
            # int() converts a string to integer
            if int(s1) <= b:
                ans += j
  
                # change A to s2
                a = ''.join(list(s2))
                break
  
    # Return the required answer
    return ans
  
# Driver Code
if __name__ == "__main__":
  
    a = "123"
    b = 222
    print(permuteDigits(a, b))
  
# This code is contributed by
# sanjeev2552

输出：

213

优化：我们可以使用多重集将所有出现的数字保留在集合中。我们还可以使用C++中的lower_bound()进行二进制搜索，以快速找到要放置的数字。