118th LeetCode Weekly Contest Pancake Sorting-CSDN博客

本文介绍了一种基于煎饼翻转的排序算法，通过选择正整数k并反转数组A的前k个元素，实现数组A的排序。文章详细解释了如何通过一系列煎饼翻转操作将数组从任意初始状态变为有序状态，并提供了具体的实例说明。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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.lengthflips 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 <= A.length <= 100
A[i] is a permutation of [1, 2, ..., A.length]

对于这种题倒着处理。

主要是看两种情况，

3 1 2

要把2放后面，这1 2 3变成2 1 3，再全部倒着来一次3 1 2就OK

2 3 1这种，就直接全部倒着来就行。

class Solution {
public:
    int arr[400];
    void reverse1(int from,int to) {
            while(from<to){
                int tmp=arr[from];
                arr[from++]=arr[to];
                arr[to--]=tmp;
            }
    }
    int Find(int num,int last){
        for(int i=0;i<last;i++){
            if(arr[i]==num){
                return i+1;
            }
        }
        return 0;
    }
    void x(int len){
        for(int i=0;i<len;i++){
            cout<<arr[i]<<" ";
        }
        cout<<endl;
    }
    
    
    vector<int> pancakeSort(vector<int>& A) {
        vector<int>Ve = A;
        vector<int>Vee;
        sort(Ve.begin(),Ve.end());
        
        int Size = A.size();
        
        for(int i=0;i<Size;i++){
            arr[i] = Ve[i];
        }
        
        for(int i=0;i<Size;i++){
           int address = Find(A[Size - i - 1],Size-i);
           if(address == 1){
                //cout<<address<<" A"<<endl;
                reverse1(0,Size - i - 1);
                //x(Size);
                if(Size - i == 1){
                    continue;
                }
                Vee.push_back(Size - i);

           }else if(address == Size - i){
                //cout<<address<<" B "<<Size - i<<endl;
                continue;
           }else{
               //cout<<address<<" C"<<endl;
                reverse1(0,address - 1);
                //x(Size);
               if(address == 1){
                    continue;
                }
                Vee.push_back(address);
                reverse1(0,Size - i - 1);
                //x(Size);
               if(Size - i == 1){
                    continue;
                }
                Vee.push_back(Size - i);
           }
        }
        reverse(Vee.begin(),Vee.end());
        return Vee;
    }
};