Iterative program to generate distinct Permutations of a String

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class GFG {

    // C# implementation of the approach
    static String ans = "";

    // No more permutations can be generated
    static final int END = -1;

    // Permutation is valid
    static final int VALID = 1;

    // Utility function to print the generated permutation
    static void printString(List<Integer> word, List<Pair<Character, Integer>> refList) {
        StringBuilder str = new StringBuilder();
        for (int index : word) {
            str.append(refList.get(index).first);
        }
        if (str.length() != 0)
            ans = "\n" + str + ans;
    }

    // Function that checks for any conflict present
    // in the word/string for the index
    static boolean hasConflict(List<Integer> word, List<Pair<Character, Integer>> refList, int index) {
        if (index >= word.size() || word.get(index) >= refList.size())
            return false;

        // Check number of instances where value of
        // the character is equal to the
        // value at checking index
        int conflictCount = 0;

        for (int i = 0; i < index; i++) {
            if (word.get(i).equals(word.get(index)))
                conflictCount++;
        }

        // If the number of instances are greater
        // than the number of occurrences of the
        // character then conflict is present
        if (conflictCount < refList.get(word.get(index)).second)
            return false;

        return true;
    }

    // Function that returns the validity of the
    // next permutation generated and makes
    // changes to the word array
    static int getNext(List<Integer> word, List<Pair<Character, Integer>> refList, int mod) {
        int left, right, carry;

        right = word.size() - 1;
        carry = 1;

        // Simply add 1 to the array word following
        // the number system with base mod
        // generates a new permutation
        for (left = right; left >= 0; left--) {
            if (left == 0 && word.get(left) + carry >= mod) {
                return END; // overflown
            }

            if (word.get(left) + carry >= mod) {
                word.set(left, (word.get(left) + carry) % mod);
            } else {
                word.set(left, word.get(left) + carry);
                break;
            }
        }

        // All the values between left and right (inclusive)
        // were changed and therefore need to be
        // adjusted to get a valid permutation
        while (left <= right) {
            while (hasConflict(word, refList, left) && word.get(left) < mod) {
                // Increment till conflict between substring [0, i)
                // is resolved or word.get(left) goes above mod
                word.set(left, word.get(left) + 1);
            }

            if (word.get(left) >= mod) {
                // The value for left has crossed mod therefore
                // all the values for word with [0, left)
                // constant have been converted therefore add 1
                // to the substring [0, left) to get a new value
                // of left which represents all affected parts.
                // Repeat the process of conflict resolution
                // and validity checking from this new left
                word.set(left, word.get(left) % mod);
                carry = 1;
                left--;

                while (left >= 0) {
                    if (left == 0 && word.get(left) + carry >= mod) {
                        // Overflow
                        return END;
                    }

                    if (word.get(left) + carry >= mod) {
                        word.set(left, (word.get(left) + carry) % mod);
                        left--;
                    } else {
                        word.set(left, word.get(left) + carry);
                        break;
                    }
                }
            } else {
                // Increment left if conflict is resolved
                // for the current index and do conflict
                // resolution for the next index
                left++;
            }
        }

        return VALID;
    }

    // Iterative function to generate all the
    // distinct permutations of str
    static void generatePermutations(String str) {
        if (str.length() == 0)
            return;

        // First sort the string to assign mapped values
        // and occurrences to each letter
        // Sorting needs to handle letters
        // with multiple occurrences
        char[] charArray = str.toCharArray();
        List<Character> charList = new ArrayList<>();
        for (char c : charArray) {
            charList.add(c);
        }
        Collections.sort(charList, Collections.reverseOrder());
        StringBuilder sortedStr = new StringBuilder();
        for (char c : charList) {
            sortedStr.append(c);
        }

        // Reference list to store the mapping of
        // its index to its corresponding char
        // and the number of occurrences of the character
        // as the second element of the pair
        List<Pair<Character, Integer>> refList = new ArrayList<>();

        // Assign each character its index and the
        // number of occurrences
        int count = 0;
        refList.add(new Pair<>(sortedStr.charAt(0), 1));

        for (int i = 1; i < sortedStr.length(); i++) {
            // Increment occurrences if the character is repeated
            // Else create a new mapping for the next character
            if (sortedStr.charAt(i) == sortedStr.charAt(i - 1)) {
                refList.set(count, new Pair<>(refList.get(count).first, refList.get(count).second + 1));
            } else {
                count++;
                refList.add(new Pair<>(sortedStr.charAt(i), 1));
            }
        }

        // Size may differ in case of multiple
        // occurrences of characters
        while (refList.size() > count + 1) {
            refList.remove(refList.size() - 1);
        }
        while (refList.size() < count + 1) {
            refList.add(new Pair<>('\0', 0));
        }

        // Construct the word
        // Word stores the mapped values for every letter
        // in a permuted sequence i.e. say for "abc"
        // word would be initially [0, 1, 2] or "aba", [0, 1, 0]
        List<Integer> word = new ArrayList<>();
        for (int i = 0; i < refList.size(); i++) {
            for (int j = 0; j < refList.get(i).second; j++)
                word.add(i);
        }

        // mod is the number of distinct letters in the string
        int mod = refList.size();
        int flag = VALID;

        while (flag != END) {
            // If the permutation sent by GetNext
            // is valid then print it
            printString(word, refList);

            // Get the next permutation, validity
            // stored in flag
            flag = getNext(word, refList, mod);
        }
        System.out.println(ans);
    }

    // Driver code
    public static void main(String[] args) {
        String str = "abc";
        generatePermutations(str);
    }

    // Pair class to store two elements together
    static class Pair<A, B> {
        A first;
        B second;

        public Pair(A first, B second) {
            this.first = first;
            this.second = second;
        }
    }
}

// This code is contributed by phasing17