通过交换最多一个字符对，按字典顺序排列更小的字符串

鉴于两个字符串A和全部大写的B，任务是寻找是否有可能通过在一个最一对字符的交换使字符串中的严格词典顺序小于字符串B时。
例子：

Input: A = “AGAIN”, B = “ACTION” 
Output: Yes 
Explanation: 
We can make string A strictly lexicographically smaller than string B by swapping G and A (AAGIN) 
AAGIN is lexicographically smaller than ACTION 
Input: A = “APPLE” B = “AAAAAPPPLLE” 
Output: No 
 

方法：

1. 对字符串A 进行排序。
2. 我们可以找到 A 和 sorted(A) 不匹配的第一个位置。
3. 然后我们找到应该在那个位置的字母并将它与 sorted(A) 中的字母交换。
4. 如果有多个选择，最好采用最后出现的那个，因为它使结果字符串最小。
5. 现在，比较字符串A 和字符串B。

下面是上述方法的实现。

C++

// C++ program check whether is
// it possible to make string A
// lexicographically smaller than string B
 
#include 
using namespace std;
 
// Swap function
void swap(char& x, char& y)
{
    char temp = x;
    x = y;
    y = temp;
}
 
// Function that finds whether is
// it possible to make string A
// lexicographically smaller than string B
bool IsLexicographicallySmaller(
    string A, string B)
{
    // Condition if string A
    // is already smaller than B
    if (A < B) {
        return true;
    }
    string temp = A;
 
    // Sorting temp string
    sort(temp.begin(), temp.end());
 
    int index = -1;
 
    for (int i = 0; i < A.length(); i++) {
        // Condition for first changed
        // character of string A and temp
        if (A[i] != temp[i]) {
            index = i;
            break;
        }
    }
 
    // Condition if string A
    // is already  sorted
    if (index == -1) {
        return false;
    }
 
    int j;
 
    // Finding first changed character
    // from  last of string A
    for (int i = 0; i < A.length(); i++) {
        if (A[i] == temp[index])
            j = i;
    }
 
    // Swap the two characters
    swap(A[index], A[j]);
 
    // Condition if string A
    // is smaller   than B
    if (A < B) {
        return true;
    }
 
    else {
        return false;
    }
}
 
// Driver Code
int main()
{
    string A = "AGAIN";
    string B = "ACTION";
 
    if (IsLexicographicallySmaller(A, B)) {
        cout << "Yes"
             << "\n";
    }
    else {
        cout << "No"
             << "\n";
    }
 
    return 0;
}

Java

// Java program check whether is
// it possible to make String A
// lexicographically smaller than String B
import java.util.*;
 
class GFG{
     
     
    // Swap function
    static String swap(String str, int i, int j)
    {
        char[] tempArr = str.toCharArray();
        char temp = tempArr[i];
        tempArr[i] = tempArr[j];
        tempArr[j] = temp;
        return String.valueOf(tempArr);
    }
     
    // Function that finds whether is
    // it possible to make String A
    // lexicographically smaller than String B
    static boolean IsLexicographicallySmaller(String A, String B)
    {
        // Condition if String A
        // is already smaller than B
        if (A.compareTo(B) < 0) {
            return true;
        }
        String temp = A;
        char p[] = temp.toCharArray();
 
        // Sorting temp String
        Arrays.sort(p);
        temp=String.valueOf(p);
        int index = -1;
     
        for (int i = 0; i < A.length(); i++) {
 
            // Condition for first changed
            // character of String A and temp
            if (A.charAt(i) != temp.charAt(i)) {
                index = i;
                break;
            }
        }
     
        // Condition if String A
        // is already sorted
        if (index == -1) {
            return false;
        }
     
        int j = 0;
     
        // Finding first changed character
        // from last of String A
        for (int i = 0; i < A.length(); i++) {
            if (A.charAt(i) == temp.charAt(index))
                j = i;
        }
     
        // Swap the two characters
        A = swap(A, index, j);
     
        // Condition if String A
        // is smaller than B
        if (A.compareTo(B) < 0) {
            return true;
        }
     
        else {
            return false;
        }
    }
     
    // Driver Code
    public static void main(String args[])
    {
        String A = "AGAIN";
        String B = "ACTION";
     
        if (IsLexicographicallySmaller(A, B)) {
            System.out.println("Yes");
        }
        else {
            System.out.println("No");
        }
     
    }
}
 
// This code is contributed by AbhiThakur

Python3

# Python3 program check
# it possible to make string
# A lexicographically smaller
# than string B
 
# Function that finds whether is
# it possible to make string A
# lexicographically smaller than
# string B
def IsLexicographicallySmaller(A, B):
 
    # Condition if string A
    # is already smaller
    # than B
    if(A < B):
        return True
    temp = A
 
    # Sorting temp string
    temp = ''.join(sorted(temp))
    index =- 1
 
    for i in range(len(A)):
 
        # Condition for first
        # changed character of
        # string A and temp
        if(A[i] != temp[i]):
            index = i
            break
 
    # Condition if string A
    # is already  sorted
    if(index == -1):
        return False
       
    j = 0
 
    # Finding first changed
    # character from last
    # of string A
    for i in range(len(A)):
        if(A[i] == temp[index]):
            j = i
             
    A = list(A)
 
    # Swap the two characters
    A[index], A[j] = A[j], A[index]
    A = ''.join(A)
 
    # Condition if string A
    # is smaller than B
    if(A < B):
        return True
    else:
        return False
 
# Driver Code
A = "AGAIN"
B = "ACTION"
 
if(IsLexicographicallySmaller(A, B)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by avanitrachhadiya2155

C#

// C# program check whether is
// it possible to make String A
// lexicographically smaller
// than String B
using System;
class GFG{
      
// Swap function
static string swap(string str,
                   int i, int j)
{
  char[] tempArr = str.ToCharArray();
  char temp = tempArr[i];
  tempArr[i] = tempArr[j];
  tempArr[j] = temp;
  return new string(tempArr);
}
      
// Function that finds whether is
// it possible to make String A
// lexicographically smaller than String B
static bool IsLexicographicallySmaller(string A,
                                       string B)
{
  // Condition if String A
  // is already smaller than B
  if (A.CompareTo(B) < 0)
  {
    return true;
  }
  string temp = A;
  char []p = temp.ToCharArray();
 
  // Sorting temp String
  Array.Sort(p);
  temp=new string(p);
  int index = -1;
 
  for (int i = 0; i < A.Length; i++)
  {
    // Condition for first changed
    // character of String A and temp
    if (A[i] != temp[i])
    {
      index = i;
      break;
    }
  }
 
  // Condition if String A
  // is already sorted
  if (index == -1)
  {
    return false;
  }
 
  int j = 0;
 
  // Finding first changed character
  // from last of String A
  for (int i = 0; i < A.Length; i++)
  {
    if (A[i] == temp[index])
      j = i;
  }
 
  // Swap the two characters
  A = swap(A, index, j);
 
  // Condition if String A
  // is smaller than B
  if (A.CompareTo(B) < 0)
  {
    return true;
  }
  else
  {
    return false;
  }
}
      
// Driver Code
public static void Main(string []args)
{
  string A = "AGAIN";
  string B = "ACTION";
  if (IsLexicographicallySmaller(A, B))
  {
    Console.Write("Yes");
  }
  else
  {
    Console.Write("No");
  }
}
}
 
// This code is contributed by Rutvik_56

输出：

Yes

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live