Pancake Sorting

Given an array A, we can perform a pancake flip: We choose some positive integer k <= A.length, then reverse the order of the first kelements of A.  We want to perform zero or more pancake flips (doing them one after another in succession) to sort the array A.

Return the k-values corresponding to a sequence of pancake flips that sort A.  Any valid answer that sorts the array within 10 * A.length flips will be judged as correct.

 

Example 1:

Input: [3,2,4,1]
Output: [4,2,4,3]
Explanation: 
We perform 4 pancake flips, with k values 4, 2, 4, and 3.
Starting state: A = [3, 2, 4, 1]
After 1st flip (k=4): A = [1, 4, 2, 3]
After 2nd flip (k=2): A = [4, 1, 2, 3]
After 3rd flip (k=4): A = [3, 2, 1, 4]
After 4th flip (k=3): A = [1, 2, 3, 4], which is sorted. 

Example 2:

Input: [1,2,3]
Output: []
Explanation: The input is already sorted, so there is no need to flip anything.
Note that other answers, such as [3, 3], would also be accepted.

 

Note:

1. 1 <= A.length <= 100
2. A[i] is a permutation of [1, 2, ..., A.length]

题目理解：

给定一个数组nums，定义flip（k）操作：将nums的前k个元素倒置。求一个filp（k）操作序列，使得操作完成之后，数组是增序的

解题思路：

由于题目的约束，数组的长度是length，数组的元素就是1~length，而且length<100，操作序列的长度只要小于10 * length都可以。因此可以采用选择排序的思想，每一次找到未排序的数里面最大的那个数，使用filp将它挪动数组的最前面，然后使用filp把未排序的所有元素倒置，这个数就到了它应该到的位置。操作序列长度是2 * length，复杂度是N*N，是一个比较好的解法。

class Solution {
    
    public void reverse(int[] A, int k){
        int left = 0, right = k - 1;
        while(left < right){
            int temp = A[left];
            A[left] = A[right];
            A[right] = temp;
            left++;
            right--;
        }
    }
    
    public List<Integer> pancakeSort(int[] A) {
        int len = A.length;
        int target = len;
        List<Integer> list = new ArrayList<>();
        for(int i = len; i > 0; i--){
            int pos = -1;
            for(int j = 0; j < len; j++){
                if(A[j] == target){
                    pos = j;
                    break;
                }
            }
            reverse(A, pos + 1);
            reverse(A, i);
            list.add(pos + 1);
            list.add(i);
            target--;
        }
        return list;
    }
}