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 resuling 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

思路

以后做这种题目还是老老实实模拟归并排序（或者堆排序）叭……一开始偷懒，想着只要对归并排序的每一组元素个数×2，然后对每个新的组再用sort排序，就是下一步的序列了，结果最后一个测试点一直过不了，也不知道该改哪儿了。然后干脆就删了代码，重新对原始序列模拟一遍归并排序，如果达到了和第二行序列相同的情况，再人为往后操作一步就好了。

这里贴一下这题的兄弟【1098 Insertion or Heap Sort (25分)】，这个兄弟题也是一样的，插排的话直接包含第一个未排序的元素进行sort即可，如果是堆排就需要从头到尾模拟一遍，然后碰到目标序列了，再往下走一步。

代码

#include<cstdio>
#include<stdlib.h>
#include<algorithm>
#include<string.h>
#include<iostream>
using namespace std;
const int maxn = 110;
int initialSeq[maxn] = {
    0};
int partialSorted[maxn] = {
    0};
bool isSame(int a[], int b[], int len){
    
    for(int i=1;i<=len;i++){
    
        if(a[i]!=b[i]) return false;
    }
    return true;
}
int main(){
    
    int N;
    scanf("%d", &N);
    for(int i=1;i<=N;i++) scanf("%d", &initialSeq[i]);
    for(int i=1;i<=N;i++) scanf("%d", &partialSorted[i]);
    int index = 0;
    for(int i=1;i<N;i++){
    
        if(partialSorted[i+1]<partialSorted[i]){
    
            index = i+1;
            break;
        }
    }
    bool flag = false;//默认是插入排序
    for(int i=index;i<=N;i++){
    
        if(initialSeq[i]!=partialSorted[i]){
    
            flag=true;//后面未排序部分和原序列不等,就是归并排序
            break;
        }
    }
    if(flag==true){
    
        printf("Merge Sort\n");
        for(int step=2;step/2<=N;step*=2){
    
            for(int i=1;i<=N;i+=step){
    
                sort(initialSeq+i, initialSeq+min(i+step, N+1));
            }
            if(isSame(initialSeq, partialSorted, N)==true){
    
                step *= 2;
                for(int i=1;i<=N;i+=step){
    
                    sort(initialSeq+i, initialSeq+min(i+step, N+1));
                }
                break;
            }
        }
        for(int i=1;i<=N;i++){
    
            if(i==1) printf("%d", initialSeq[i]);
            else printf(" %d", initialSeq[i]);
        }
    }
    else{
    
        printf("Insertion Sort\n");
        sort(partialSorted+1, partialSorted+index+1);
        for(int i=1;i<=N;i++){
    
            if(i==1) printf("%d", partialSorted[i]);
            else printf(" %d", partialSorted[i]);
        }
    }
    return 0;
}