邻位交换的最小次数

/*
 * Similar to the traditional Java solution, we can use Java streams
 * to manipulate and find permutations, and then determine the required swaps.
 */

import java.util.*;
import java.util.stream.*;

public class SolutionStream {
    public int getMinSwaps(String num, int k) {
        char[] chars = num.toCharArray();
        String target = IntStream.range(0, k).mapToObj(i -> {
            nextPermutation(chars);
            return new String(chars);
        }).reduce((first, second) -> second).orElse(num);

        chars = num.toCharArray();
        int swaps = 0;

        for (int i = 0; i < num.length(); i++) {
            if (chars[i] != target.charAt(i)) {
                int j = i;
                while (chars[j] != target.charAt(i)) {
                    j++;
                }
                while (j > i) {
                    swap(chars, j, j - 1);
                    j--;
                    swaps++;
                }
            }
        }

        return swaps;
    }

    private void nextPermutation(char[] chars) {
        int i = chars.length - 2;
        while (i >= 0 && chars[i] >= chars[i + 1]) {
            i--;
        }
        if (i >= 0) {
            int j = chars.length - 1;
            while (chars[j] <= chars[i]) {
                j--;
            }
            swap(chars, i, j);
        }
        reverse(chars, i + 1);
    }

    private void swap(char[] chars, int i, int j) {
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
    }

    private void reverse(char[] chars, int start) {
        int end = chars.length - 1;
        while (start < end) {
            swap(chars, start, end);
            start++;
            end--;
        }
    }
}