LeetCode-Python-969. 煎饼排序

给定数组 A，我们可以对其进行煎饼翻转：我们选择一些正整数 k <= A.length，然后反转 A 的前 k 个元素的顺序。我们要执行零次或多次煎饼翻转（按顺序一次接一次地进行）以完成对数组 A 的排序。

返回能使 A 排序的煎饼翻转操作所对应的 k 值序列。任何将数组排序且翻转次数在 10 * A.length 范围内的有效答案都将被判断为正确。

 

示例 1：

输入：[3,2,4,1]
输出：[4,2,4,3]
解释：
我们执行 4 次煎饼翻转，k 值分别为 4，2，4，和 3。
初始状态 A = [3, 2, 4, 1]
第一次翻转后 (k=4): A = [1, 4, 2, 3]
第二次翻转后 (k=2): A = [4, 1, 2, 3]
第三次翻转后 (k=4): A = [3, 2, 1, 4]
第四次翻转后 (k=3): A = [1, 2, 3, 4]，此时已完成排序。 

示例 2：

输入：[1,2,3]
输出：[]
解释：
输入已经排序，因此不需要翻转任何内容。
请注意，其他可能的答案，如[3，3]，也将被接受。

 

提示：

1. 1 <= A.length <= 100
2. A[i] 是 [1, 2, ..., A.length] 的排列

 

思路：

按照题意，每次操作只能翻转前K个元素，所以得出结论排序应该先从最末尾排起，不然排好的顺序就会被接下来的翻转操作所打乱，因此我们每次都应该先把未排序数组里的最大元素放到未排序数组的最末尾，

比如 [1,4,2,3]这个数组，首先就应该想办法把4放到最后，

直接一步翻转放到最后显然不可行，那就倒着想，怎么假设已经放好了[X,X,X,4]，它的上一步应该是什么，

根据翻转的规则不难得出，上一步应该就是[4,X,X,X]

因此可以总结出翻转的规则：

        1. 每次都要处理未排序数组里的最大元素

        2. 先把这个最大元素翻转到未排序数组的头部 (K = 最大元素的下标 + 1 ）

        3. 再翻转整个未排序数组（定义一个变量num代表已经排好的元素个数， K = 元素总数-num），就可以使得这个最大元素排好位置

        4. 把两次翻转的K依次加入到res中去（这种翻转规则的翻转总数最多为数组长度的两倍，满足题目要求 <10 * A.length ）

举例[1, 4 , 2, 3]的操作步骤：

 [1,4,2,3] -----------------> [4,1,2,3] ----------------> [3,2,1,4]

 [3,2,1,4] -----------------> [1,2,3,4](排序已完成)

class Solution(object):
    def pancakeSort(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        l = len(A)
        num = 0
        res = []
        while(num < l - 1):
            maxe = max(A)
            index = A.index(maxe)
            if index != l - num -1:
                res.append(index + 1)
                res.append(l-num)     
                B = A[:index + 1][::-1] + A[index + 1:]
                A = B[::-1][:-1]
            else:
                A = A[:-1]
            num += 1
            
        return res
    

class Solution(object):
    def pancakeSort(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        l = len(A)
        num = 0
        res = []
        while(num < l - 1):
            maxe = max(A)
            index = A.index(maxe)
            if index != l - num -1:
                res.append(index + 1)
                res.append(l-num)     
                A[:index + 1] = A[:index + 1][::-1]
                A[:l - num] = A[:l - num][::-1]
            A = A[:-1]
            num += 1
            
        return res

#这是看了评论区之后学会了=左边也可以切片的写法