找到相同奇偶性的数字交换形成的最大数

给定一个数字N，任务是通过遵循给定的条件来最大化这个数字：

• 数字的奇数只能与给定数字中存在的任何奇数交换。
• 数字的偶数只能与给定数字中存在的任何偶数交换。

例子：

Input: N = 234
Output: 432
Explanation: The 0th index is swapped with 2nd index.

Input: N = 6587
Output: 8765
Explanation: The 0th index is swapped with 2nd index.
The 1st index is swapped with 3rd index.

天真的方法：如果给定数字N中的一个数字是偶数，那么找到它右边的最大元素也是偶数，最后交换两者。如果数字是奇数，同样做同样的事情。

按照下面提到的步骤来实现这个想法：

• 将给定的数字N转换为字符串s （这将使遍历数字的每个数字变得容易）
• 将字符串从0迭代到s.length()-1 ：
  • 使用变量将最大值存储在当前索引（例如maxi ）及其位置（例如idx ）的右侧。
  • 将字符串从j = i+1迭代到s.length()-1
    • 如果第 i位和第 j位具有相同的奇偶性并且第 j位大于ith ，则更新maxi和idx 。
    • 否则，继续迭代。
  • 最后用s[idx]交换s[i ]
• 返回字符串s的整数值。

下面是上述方法的实现。

C++

// C++ code to implement the approach
  
#include 
using namespace std;
  
// Function to maximize the number
int maximizedNumber(int num)
{
  
    // String will be used to represent the
    // number in string
    string s = to_string(num);
  
    // Traversing the string
    for (int i = 0; i < s.length(); i++) {
        int maxi = s[i] - '0';
        int idx = i;
  
        // Check ith digit with all
        // the remaining unoperated
        // string to maximize the string
        for (int j = i + 1; j < s.length();
             j++) {
  
            // If both the ith and
            // jth digit is odd
            if (maxi % 2 == 0
                && (s[j] - '0') % 2 == 0) {
  
                // If the jth digit is
                // greater than the ith digit
                if (s[j] - '0' > maxi) {
                    maxi = s[j] - '0';
                    idx = j;
                }
            }
  
            // If both ith and
            // jth digit is even
            else if (maxi % 2 == 1
                     && (s[j] - '0') % 2 == 1) {
  
                // If the jth digit is
                // greater than ith digit.
                if (s[j] - '0' > maxi) {
                    maxi = s[j] - '0';
                    idx = j;
                }
            }
        }
  
        // Swap the largest digit to the right
        // of ith digit with ith digit
        swap(s[i], s[idx]);
    }
  
    // Convert string into integer
    return stoi(s);
}
  
// Driver code
int main()
{
    int N = 6587;
  
    // Function call
    cout << maximizedNumber(N);
    return 0;
}

输出

8765

时间复杂度： O(N ² )，其中N是给定字符串的长度。
辅助空间： 在）

高效的方法：这个问题可以基于以下思路高效解决：

Store all even digits in non-increasing order and do the same for odd digits. 
Now replace all stored even digits of given number in non-increasing order with even digits in it and do the same for odd digits.

按照下面提到的步骤来实现这个想法。

• 将给定的数字N转换为字符串s 。
• 迭代s并执行以下操作：
  • 将所有偶数数字存储在一个字符串中（例如evenDigit ），将所有奇数数字存储在另一个字符串中（例如oddDigit ）。
  • 以非递增顺序对两个字符串进行排序。
• 迭代s并执行以下操作：
  • 使用两个迭代器（比如itr1和itr2 ）指向下一个要选择的偶数或奇数位。
  • 如果s中的数字是偶数，则将其替换为eventDigit[itr1]中的数字并递增 itr1。
  • 如果 s 中的数字是奇数，则将其替换为oddDigit[itr2]中的数字并递增 itr2。
• 最后，将字符串s转换为整数并返回。

下面是上述方法的实现。

C++

// C++ code to implement the approach
  
#include 
using namespace std;
  
// Function to maximize the number
int maximizedNumber(int num)
{
    // Store all even digits
    string oddDigit = "";
  
    // Store all odd digits
    string evenDigit = "";
  
    // Convert given number into string
    string s = to_string(num);
  
    for (int i = 0; i < s.size(); i++) {
        // Check if digit is even or odd
        if ((s[i] - '0') % 2 == 0) {
            evenDigit += s[i];
        }
        else {
            oddDigit += s[i];
        }
    }
  
    // Sort oddDigit and evenDigit string
    // in non-increasing order.
    sort(oddDigit.begin(), oddDigit.end(),
         greater());
    sort(evenDigit.begin(), evenDigit.end(),
         greater());
  
    int i1 = 0, j1 = 0;
  
    for (int i = 0; i < s.size(); i++) {
  
        // If the current digit is even
        // then replace it with evenDigit[i1]
        if ((s[i] - '0') % 2 == 0) {
            s[i] = evenDigit[i1];
            i1++;
        }
  
        // If the current digit is odd then
        // replace it with the oddDigit[j1]
        else {
            s[i] = oddDigit[j1];
            j1++;
        }
    }
  
    return stoi(s);
}
  
// Driver code
int main()
{
    int N = 6587;
  
    // Function call
    cout << maximizedNumber(N);
    return 0;
}

输出

8765

时间复杂度： O(M * log M)，其中M是 N 中存在的位数。
辅助空间： （男）