LintCode-Previous Permuation

Given a list of integers, which denote a permutation.

Find the previous permutation in ascending order.

Note

The list may contains duplicate integers.

Example

For [1,3,2,3], the previous permutation is [1,2,3,3]

For [1,2,3,4], the previous permutation is [4,3,2,1]

Analysis:

Find out the fisrt local minimum and add it and its later elements into a list from back to front. Add the element just before this minimum into list also, set the element as bar ( we will decrease it to some smaller value). Sort the list, find out the next value smaller than the bar, put it on the position that one before the local minimum, then put all left elements in the list to the array in the decreasing order.

Solution:

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: A list of integers that's previous permuation
     */
    public ArrayList<Integer> previousPermuation(ArrayList<Integer> nums) {
        int len = nums.size();
        if (len==0 || len ==1) return nums;

        ArrayList<Integer> buff = new ArrayList<Integer>();
        buff.add(nums.get(len-1));
        int index = len-2;
        while (index>=0 && nums.get(index)<= nums.get(index+1)){
            buff.add(nums.get(index));
            index--;
        }
        
        if (index>=0){
            buff.add(nums.get(index));
            int bar = nums.get(index);
            Collections.sort(buff);
            int index2 = buff.size()-2;
            while (!(buff.get(index2)!=bar && buff.get(index2+1)==bar)) index2--;
            nums.set(index,buff.get(index2));
            buff.remove(index2);
            index++;
            for (int i=buff.size()-1;i>=0;i--){
                nums.set(index,buff.get(i));
                index++;
            }
            return nums;
        } else {
            Collections.sort(buff, Collections.reverseOrder());
            return buff;
        }    
    }
}