交换一次的先前排列

/*
 * Problem: Given a positive integer array arr (which may contain duplicate elements), return the maximum permutation that is lexicographically smaller than arr after exactly one swap (swap the positions of two numbers arr[i] and arr[j]).
 * If it is not possible to do so, return the original array.
 *
 * Approach:
 * 1. Traverse the array from right to left to find the first pair where arr[i] > arr[i+1]. This pair indicates the point where the order starts decreasing.
 * 2. If such a pair is found, traverse again from right to left to find the first element that is smaller than arr[i]. This element will be arr[j].
 * 3. Swap arr[i] and arr[j].
 * 4. If no such pair is found, return the original array as it is already the smallest permutation.
 */
import java.util.*;
import java.util.stream.*;

public class Solution {
    public int[] prevPermOpt1(int[] arr) {
        List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());
        int n = list.size();
        for (int i = n - 2; i >= 0; i--) {
            if (list.get(i) > list.get(i + 1)) {
                for (int j = n - 1; j > i; j--) {
                    if (list.get(j) < list.get(i)) {
                        while (j > 0 && list.get(j).equals(list.get(j - 1))) {
                            j--;
                        }
                        Collections.swap(list, i, j);
                        return list.stream().mapToInt(k -> k).toArray();
                    }
                }
            }
        }
        return arr;
    }
}