PAT 1089. Insert or Merge (25)(插入排序还是归并排序)

官网

1089. Insert or Merge (25)

时间限制
200 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
According to Wikipedia:

Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.

Merge sort works as follows: Divide the unsorted list into N sublists, each containing 1 element (a list of 1 element is considered sorted). Then repeatedly merge two adjacent sublists to produce new sorted sublists until there is only 1 sublist remaining.

Now given the initial sequence of integers, together with a sequence which is a result of several iterations of some sorting method, can you tell which sorting method we are using?

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (<=100). Then in the next line, N integers are given as the initial sequence. The last line contains the partially sorted sequence of the N numbers. It is assumed that the target sequence is always ascending. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in the first line either “Insertion Sort” or “Merge Sort” to indicate the method used to obtain the partial result. Then run this method for one more iteration and output in the second line the resulting sequence. It is guaranteed that the answer is unique for each test case. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input 1:
10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0
Sample Output 1:
Insertion Sort
1 2 3 5 7 8 9 4 6 0
Sample Input 2:
10
3 1 2 8 7 5 9 4 0 6
1 3 2 8 5 7 4 9 0 6
Sample Output 2:
Merge Sort
1 2 3 8 4 5 7 9 0 6

解题思路

• 1.之前的那个方法方法一不对，有未发现的错误。
• 2.就是先假设它为插入排序，然后从插入排序的第二个数开始到最后一个数进行模拟，如果其中的中间状态与样本的中间状态相同的话，那么它就是插入排序了，然后再执行下一步的插入排序再输出即可，如果不是插入排序，那么也模拟归并排序，知道中间状态与题目给出的相同了，再执行一下归并排序输出即可，有一种简单的数前面有几个数字是排好序的不能保证一定是准确的，所以一步一步模拟比较保险。

代码

#include<iostream>
#include<vector>
#include<algorithm>
#include<fstream>
using namespace std;
int n;
//fstream in("1.txt");
//#define cin in
int init[100 + 5], then[100 + 5],origin[100+5];
void print(int a[]){
    cout << a[0];
    for (int i = 1; i < n; i++)
    {
        cout << " " << a[i];
    }
    cout << endl;
}
bool insert_sort(int k)
{
    if (k<1||k>n)
    {
        cout << "out of range!" << endl;
        return -1;
    }
    sort(init, init + k+1);
    for (int i = 0; i < n; i++)
    {
        ;
        if (init[i]!=then[i])
        {
            return false;
        }
    }
    return true;
}
void merge_sort(int k)
{
    for (int i = 0; i < n; i +=k)
    {
        int end = i + k;
        end = (end>n) ? n : end;
        sort(origin + i, origin + end);
    }
}
int main(){
    cin >> n;
    //vector<int> init(n), then(n);
    for (int i = 0; i < n; ++i) {
        cin >> init[i];
        origin[i] = init[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> then[i];
    }
    bool isInsertion = false;
    int k = -1;
    //一步一步模拟插入排序
    for (int i = 1; i <= n; i++)
    {
        isInsertion = insert_sort(i);
        //如果和题目给出的中间状态相同了，在执行一次插入排序再输出
        if (isInsertion)
        {
            k = i;
            break;
        }
    }
    if (isInsertion)
    {
        //cout << k << endl;
        cout << "Insertion Sort" << endl;
        if (k==n)
        {
            print(init);
        }
        else
        {
            insert_sort(k + 1);
            print(init);
        }
    }
    else
    {
        //如果是归并排序
        cout << "Merge Sort" << endl;
        bool flag = true;
        //一步一步模拟
        for (int step = 1; step <= n; step += step)
        {
            merge_sort(step);
            for (int i = 0; i < n; i++)
            {
                if (origin[i]!=then[i])
                {
                    flag = false;
                    break;
                }
            }
            if (flag)
            {
            //再执行一次输出
                merge_sort(step + step);
                break;
            }
            flag = true;
        }
        print(origin);
    }
    return 0;
}