Find the string from an array that can be converted to a string S with minimum number of swaps

// Java program for the above approach

import java.io.*;
import java.util.*;

class GFG {

    // Function to find anagram of S
    // requiring minimum number of swaps
    static String getBestString(String S,
                                List<String> group)
    {
        // Initialize variables
        boolean isAnagram = false;
        String bestString = null;
        int minMoves = Integer.MAX_VALUE;

        // Count frequency of characters in S
        int[] charCountS = getCharCount(S);

        // Traverse the array of strings
        for (String S1 : group) {

            // Count frequency of characters in S1
            int[] charCountS1 = getCharCount(S1);

            // Check if S1 is anagram of S
            boolean anagram
                = checkIsAnagram(charCountS, charCountS1);

            // If not an anagram of S
            if (!anagram)
                continue;

            isAnagram = true;

            // Count swaps required
            // to convert S to S1
            int moves = findMinMoves(S, S1);

            // Count minimum number of swaps
            if (moves < minMoves) {
                minMoves = moves;
                bestString = S1;
            }
        }

        // If no anagram is found, print -1
        return (isAnagram) ? bestString : "-1";
    }

    // Function to return the minimum number
    // of swaps required to convert S1 to S
    static int findMinMoves(String S, String S1)
    {

        // Stores number of swaps
        int minMoves = 0;

        // Initialize Fenwick Tree
        int[] fenwickTree = new int[S.length() + 1];

        // Get all positions of characters
        // present in the string S1
        List<List<Integer> > charPositions
            = getPositions(S1);

        // Traverse the given string in reverse
        for (int i = S.length() - 1; i >= 0; i--) {

            // Get the list corresponding
            // to character S[i]
            List<Integer> temp
                = charPositions.get(S.charAt(i) - 'a');

            // Size of the list
            int size = temp.size() - 1;

            // Get and remove last
            // indices from the list
            int index = temp.remove(size) + 1;

            // Count of indices to
            // the left of this index
            int leftShift = get(fenwickTree, index);

            // Update Fenwick T ree
            update(fenwickTree, index);

            // Shift the index to it's left
            index -= leftShift;

            // Update moves
            minMoves += Math.abs(i - index + 1);
        }

        // Return moves
        return minMoves;
    }

    // Function to get all positions of
    // characters present in the string S1
    static List<List<Integer> > getPositions(String S)
    {
        @SuppressWarnings("unchecked")
        List<List<Integer> > charPositions
            = new ArrayList();

        for (int i = 0; i < 26; i++)
            charPositions.add(new ArrayList<Integer>());

        for (int i = 0; i < S.length(); i++)
            charPositions.get(S.charAt(i) - 'a').add(i);

        return charPositions;
    }

    // Update function of Fenwick Tree
    static void update(int[] fenwickTree, int index)
    {
        while (index < fenwickTree.length) {
            fenwickTree[index]++;
            index += (-index) & index;
        }
    }

    // Function to return the count of
    // indices to the left of this index
    static int get(int[] fenwickTree, int index)
    {
        int leftShift = 0;
        leftShift += fenwickTree[index];

        while (index > 0) {
            index -= (-index) & index;
            leftShift += fenwickTree[index];
        }
        return leftShift;
    }

    // Function to return the frequency of
    // characters in the array of strings
    static int[] getCharCount(String S)
    {
        int[] charCount = new int[26];

        for (int i = 0; i < S.length(); i++)
            charCount[S.charAt(i) - 'a']++;

        return charCount;
    }

    // Function to check is two
    // strings are anagrams
    static boolean checkIsAnagram(int[] charCountS,
                                  int[] charCountS1)
    {

        for (int i = 0; i < 26; i++) {
            if (charCountS[i] != charCountS1[i])
                return false;
        }

        return true;
    }

    // Driver Code
    public static void main(String[] args)
    {

        // Given string
        String S = "abcdac";

        // Given array of strings
        String arr[] = { "cbdaca", "abcacd", "abcdef" };

        String bestString
            = getBestString(S, Arrays.asList(arr));

        // Print answer
        System.out.println(bestString);
    }
}