# Count minimum swap to make string palindrome

• Difficulty Level : Medium
• Last Updated : 18 Oct, 2022

Given a string S, the task is to find out the minimum no of adjacent swaps required to make string s palindrome. If it is not possible, then return -1.

Examples:

Input: aabcb
Output:
Explanation:
After 1st swap: abacb
After 2nd swap: abcab
After 3rd swap: abcba

Output: -1

Approach
The following are detailed steps to solve this problem.

• Check whether it is possible to make a palindrome or not from the given string. As we know that if more than one character in a string occurs an odd number of times that string can’t be a palindrome.
• If palindrome is not possible then return -1.
• Take two pointers left pointing to the 0th index and a right pointer pointing to the last index to the given string
• Do the following until left pointer is less than right pointer:
• Fix the left pointer and move a copy of right pointer say r, to rightside to search element which is similar to character pointing by left pointer.
• If the left pointer is equal to r pointer, it means this is an odd occurring character that we have to move at the middle of the string.
•  So swap character at r index to its next index (move character toward right side)
• Increment result by 1 for this swap operation.
• Otherwise,
• Swap the found character at r to rightside, until it reaches at right index and keeps incrementing the result for the swap operation.
• Increment left by 1 and decrement right by 1.
• Return the result.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `int` `minSwap(string s)``{``    ``unordered_map<``char``, ``int``> unmp;``    ``int` `odd = 0, left = 0, right = s.size() - 1, result = 0;` `    ``for` `(``char` `ch : s)``        ``unmp[ch]++;` `    ``for` `(``auto` `i : unmp)``        ``if` `(i.second % 2 == 1)``            ``odd++;` `    ``if` `(odd > 1)``        ``return` `-1;` `    ``while` `(left < right) {``        ``int` `l = left, r = right;``        ``while` `(s[l] != s[r])``            ``r--;``        ``if` `(l == r) {` `            ``// when we found odd element``            ``swap(s[r], s[r + 1]);``            ``result++;``            ``continue``;``        ``}``        ``else` `{``            ``// Normal element``            ``while` `(r < right) {``                ``swap(s[r], s[r + 1]);``                ``result++;``                ``r++;``            ``}``        ``}``        ``left++, right--;``    ``}``    ``return` `result;``}` `// Driver's code``int` `main()``{``    ``string s = ``"aabcc"``;``    ``cout << minSwap(s);``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Globals``{``  ` `    ``public` `static` `int` `minSwap(String s)``    ``{``        ``HashMap unmp = ``new` `HashMap();``        ``int` `odd = ``0``;``        ``int` `left = ``0``;``        ``int` `right = s.length() - ``1``;``        ``int` `result = ``0``;` `        ``char``[] strArray = s.toCharArray();``        ``for` `(``char` `c : strArray) {``            ``if` `(unmp.containsKey(c))``                ``unmp.put(c, unmp.get(c) + ``1``);``            ``else``                  ``unmp.put(c, ``1``);``        ``}``      ` `          ``for` `(Map.Entry i : unmp.entrySet())``        ``{``            ``int` `val = unmp.get(i.getKey());``            ``if``(val % ``2` `== ``1``)``            ``{``              ``odd++;``            ``}``        ``}` `        ``if` `(odd > ``1``)``        ``{``            ``return` `-``1``;``        ``}` `        ``while` `(left < right)``        ``{``            ``int` `l = left;``            ``int` `r = right;``            ``while` `(s.charAt(l) != s.charAt(r))``            ``{``                ``r--;``            ``}``            ``if` `(l == r)``            ``{` `                ``// when we found odd element``                  ``char` `ch1 = s.charAt(r), ch2 = s.charAt(r+``1``);``                ``s = s.substring(``0``, r) + ch2``                   ``+ ch1 + s.substring(r + ``2``);``                ``result++;``                ``continue``;``            ``}``            ``else``            ``{``                ``// Normal element``                ``while` `(r < right)``                ``{``                    ``char` `ch1 = s.charAt(r), ch2 = s.charAt(r+``1``);``                    ``s = s.substring(``0``, r) + ch2``                           ``+ ch1 + s.substring(r + ``2``);``                    ``result++;``                    ``r++;``                ``}``            ``}``            ``left++; right--;``        ``}``        ``return` `result;``    ``}` `    ``// Driver's code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String s = ``"aabcc"``;``        ``System.out.print(minSwap(s));``    ``}``}` `// This code is contributed by manav23lohani.`

## Python3

 `# Python implementation of program``def` `minSwap(s):``    ``strng ``=` `list``(s)``    ``unmp ``=` `{}``    ``for` `i ``in` `strng:``        ``unmp[i] ``=` `unmp.get(i,``0``)``+``1``    ``odd ``=` `0``    ``result ``=` `0``    ``left ``=` `0``    ``right ``=` `len``(strng)``-``1``    ``for` `i ``in` `unmp:``        ``if` `unmp[i]``%``2` `!``=` `0``:``            ``odd ``+``=` `1``    ``# If we found more then one odd number``    ``if` `odd > ``1``:``        ``return` `-``1``    ``while` `left < right:``        ``l ``=` `left``        ``r ``=` `right``        ``while` `strng[l] !``=` `strng[r]:``            ``r ``-``=` `1``        ``if` `l ``=``=` `r:``            ``# When we found odd element move towards middle``            ``strng[r],strng[r``+``1``] ``=` `strng[r``+``1``],strng[r]``            ``result ``+``=` `1``            ``continue``        ``else``:``            ``# Normal element  move towards right of string``            ``while` `r < right:``                ``strng[r],strng[r``+``1``] ``=` `strng[r``+``1``],strng[r]``                ``r ``+``=` `1``                ``result ``+``=` `1``        ``left ``+``=` `1``        ``right ``-``=` `1``    ``return` `result``s``=``"aabcc"``print``(minSwap(s))` `# This code is contributed by rupasriachanta421`

## C#

 `// C# implementation of program``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{``  ``public` `static` `int` `minSwap(String s)``  ``{``    ``Dictionary < ``char``, ``int` `> unmp = ``new` `Dictionary < ``char``, ``int` `> ();` `    ``int` `odd = 0;``    ``int` `left = 0;``    ``int` `right = s.Length - 1;``    ``int` `result = 0;` `    ``for` `(``int` `i = 0; i < s.Length; i++) {``      ``if` `(unmp.ContainsKey(s[i])) {``        ``unmp[s[i]]++;``      ``}``      ``else` `{``        ``unmp.Add(s[i], 1);``      ``}``    ``}` `    ``foreach` `(KeyValuePair<``char``, ``int``> i ``in` `unmp) {``      ``int` `val = i.Value;``      ``if` `(val % 2 == 1) {``        ``odd++;``      ``}``    ``}`  `    ``if` `(odd > 1) {``      ``return` `-1;``    ``}` `    ``while` `(left < right) {``      ``int` `l = left;``      ``int` `r = right;``      ``while` `(s[l] != s[r]) {``        ``r--;``      ``}` `      ``if` `(l == r) {``        ``// when we found odd element``        ``char` `ch1 = s[r], ch2 = s[r + 1];``        ``s = s.Substring(0, r) + ch2 + ch1 + s.Substring(r + 2);``        ``result++;``        ``continue``;``      ``}``      ``else` `{``        ``// Normal element``        ``while` `(r < right) {``          ``char` `ch1 = s[r], ch2 = s[r + 1];``          ``s = s.Substring(0, r) + ch2 + ch1 + s.Substring(r + 2);``          ``result++;``          ``r++;``        ``}``      ``}``      ``left++; right--;``    ``}` `    ``return` `result;``  ``}` `  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``String s = ``"aabcc"``;``    ``Console.WriteLine(minSwap(s));``  ``}``}` `// This code is contributed by ajaymakvana.`

Output

`4`

Time Complexity: O(n2
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up