将字符串转换为其给定字谜的最小相邻交换次数

给定两个字符串s1和s2 ，任务是找到将s1转换为s2所需的最小步骤数。唯一允许的操作是交换第一个字符串中的相邻元素。每一次交换都算作一个步骤。
例子：

Input: s1 = “abcd”, s2 = “cdab”
Output: 4
Swap 2^nd and 3^rd element, abcd => acbd
Swap 1^st and 2^nd element, acbd => cabd
Swap 3^rd and 4^th element, cabd => cadb
Swap 2^nd and 3^rd element, cadb => cdab
Minimum 4 swaps are required.
Input: s1 = “abcfdegji”, s2 = “fjiacbdge”
Output:17

编程需要懂一点英语

方法：分别对第一个和第二个字符串使用两个指针i和j 。将i和j初始化为0 。
遍历第一个字符串并通过将值增加到j来找到位置j使得s1[j] = s2[i] 。继续交换相邻元素j和j – 1并递减j直到它大于i 。
现在第一个字符串的第i^个元素等于第二个字符串，因此增加i的值。
由于不必要的交换为零，因此该技术将提供最少的步骤数。
下面是上述方法的实现：

C++

// C++ implementation of the above approach
#include 
using namespace std;
 
// Function that returns true if s1
// and s2 are anagrams of each other
bool isAnagram(string s1, string s2)
{
    sort(s1.begin(), s1.end());
    sort(s2.begin(), s2.end());
    if (s1 == s2)
        return 1;
    return 0;
}
 
// Function to return the minimum swaps required
int CountSteps(string s1, string s2, int size)
{
    int i = 0, j = 0;
    int result = 0;
 
    // Iterate over the first string and convert
    // every element equal to the second string
    while (i < size) {
        j = i;
 
        // Find index element of first string which
        // is equal to the ith element of second string
        while (s1[j] != s2[i]) {
            j += 1;
        }
 
        // Swap adjacent elements in first string so
        // that element at ith position becomes equal
        while (i < j) {
 
            // Swap elements using temporary variable
            char temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
        }
        i += 1;
    }
    return result;
}
 
// Driver code
int main()
{
    string s1 = "abcd";
    string s2 = "cdab";
 
    int size = s2.size();
 
    // If both the strings are anagrams
    // of each other then only they
    // can be made equal
    if (isAnagram(s1, s2))
        cout << CountSteps(s1, s2, size);
    else
        cout << -1;
 
    return 0;
}

Java

// Java implementation of the above approach
import java.util.*;
 
class GFG
{
 
// Function that returns true if s1
// and s2 are anagrams of each other
static boolean isAnagram(String s1, String s2)
{
    s1 = sortString(s1);
    s2 = sortString(s2);
    return (s1.equals(s2));
}
 
// Method to sort a string alphabetically
public static String sortString(String inputString)
{
    // convert input string to char array
    char tempArray[] = inputString.toCharArray();
     
    // sort tempArray
    Arrays.sort(tempArray);
     
    // return new sorted string
    return new String(tempArray);
}
 
// Function to return the minimum swaps required
static int CountSteps(char []s1, char[] s2, int size)
{
    int i = 0, j = 0;
    int result = 0;
 
    // Iterate over the first string and convert
    // every element equal to the second string
    while (i < size)
    {
        j = i;
 
        // Find index element of first string which
        // is equal to the ith element of second string
        while (s1[j] != s2[i])
        {
            j += 1;
        }
 
        // Swap adjacent elements in first string so
        // that element at ith position becomes equal
        while (i < j)
        {
 
            // Swap elements using temporary variable
            char temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
        }
        i += 1;
    }
    return result;
}
 
// Driver code
public static void main(String[] args)
{
    String s1 = "abcd";
    String s2 = "cdab";
 
    int size = s2.length();
 
    // If both the strings are anagrams
    // of each other then only they
    // can be made equal
    if (isAnagram(s1, s2))
        System.out.println(CountSteps(s1.toCharArray(), s2.toCharArray(), size));
    else
        System.out.println(-1);
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python3 implementation of the above approach
 
# Function that returns true if s1
# and s2 are anagrams of each other
def isAnagram(s1, s2) :
    s1 = list(s1);
    s2 = list(s2);
    s1 = s1.sort();
    s2 = s2.sort();
     
    if (s1 == s2) :
        return 1;
         
    return 0;
 
# Function to return the minimum swaps required
def CountSteps(s1, s2, size) :
    s1 = list(s1);
    s2 = list(s2);
     
    i = 0;
    j = 0;
    result = 0;
     
    # Iterate over the first string and convert
    # every element equal to the second string
    while (i < size) :
        j = i;
         
        # Find index element of first string which
        # is equal to the ith element of second string
        while (s1[j] != s2[i]) :
            j += 1;
             
        # Swap adjacent elements in first string so
        # that element at ith position becomes equal
        while (i < j) :
             
            # Swap elements using temporary variable
            temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
             
        i += 1;
         
    return result;
 
# Driver code
if __name__ == "__main__":
 
    s1 = "abcd";
    s2 = "cdab";
 
    size = len(s2);
 
    # If both the strings are anagrams
    # of each other then only they
    # can be made equal
    if (isAnagram(s1, s2)) :
        print(CountSteps(s1, s2, size));
    else :
        print(-1);
 
# This code is contributed by AnkitRai01

C#

// C# implementation of the above approach
using System;
using System.Linq;
 
class GFG
{
 
// Function that returns true if s1
// and s2 are anagrams of each other
static Boolean isAnagram(String s1, String s2)
{
    s1 = sortString(s1);
    s2 = sortString(s2);
    return (s1.Equals(s2));
}
 
// Method to sort a string alphabetically
public static String sortString(String inputString)
{
    // convert input string to char array
    char []tempArray = inputString.ToCharArray();
     
    // sort tempArray
    Array.Sort(tempArray);
     
    // return new sorted string
    return new String(tempArray);
}
 
// Function to return the minimum swaps required
static int CountSteps(char []s1, char[] s2, int size)
{
    int i = 0, j = 0;
    int result = 0;
 
    // Iterate over the first string and convert
    // every element equal to the second string
    while (i < size)
    {
        j = i;
 
        // Find index element of first string which
        // is equal to the ith element of second string
        while (s1[j] != s2[i])
        {
            j += 1;
        }
 
        // Swap adjacent elements in first string so
        // that element at ith position becomes equal
        while (i < j)
        {
 
            // Swap elements using temporary variable
            char temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
        }
        i += 1;
    }
    return result;
}
 
// Driver code
public static void Main(String[] args)
{
    String s1 = "abcd";
    String s2 = "cdab";
 
    int size = s2.Length;
 
    // If both the strings are anagrams
    // of each other then only they
    // can be made equal
    if (isAnagram(s1, s2))
        Console.WriteLine(CountSteps(s1.ToCharArray(), s2.ToCharArray(), size));
    else
        Console.WriteLine(-1);
}
}
 
/* This code is contributed by PrinciRaj1992 */

Javascript

输出：