数据结构_just_sort

问题描述

给定两个序列 a b，序列 a 原先是一个单调递增的正数序列，但是由于某些
原因，使得序列乱序了，并且一些数丢失了（用 0 表示）。经过数据恢复后，找
到了正数序列 b ，且序列 a 中 0 的个数等于序列 b 的个数，打算使用序列 b 恢
复序列 a 。
对于序列 a 来说，我们可以交换两个位置上的非零的数，并且可以交换任意
次。序列 b 同样也可以进行任意次交换。
现在要将序列 b 填充到序列 a 中的值丢失的位置上，序列 b 中的每个数只能
填充一次，问最后构成的序列是否是单调递增的，如果是，则输出填充后的序列，
否则输出-1。

★数据输入
输入给定 N M， 表示序列 a 和序列 b 的长度。 第一行为序列 a ，第二行为
序列 b。 题目保证除了 0 以外的数，在序列 a 和 b 中只出现一次。
数据保证:
80%的数据， N, M <= 100
100%的数据， N, M <= 100000, 0 <= a[i] <= 100000, 0 < b[i] <= 100000

★数据输出
如果最后序列 a 是单调递增的，输出该序列，否则输出-1。

输入示例	输出示例
4 2 0 11 0 15 1 12	1 11 12 15

输入示例	输出示例
4 2 0 0 11 15 1 12	-1

思路：

　　用三个数组:

　　　　用 a0[ ] 存输入的序列a

　　　　用 a[ ] 存序列a中不带0的元素

　　　　用b[ ] 存序列b

　　用归并对 a[ ] 与b[ ]排序　（由于数据<=100000的原因，用计数排序会更快O(n) ；不用快排是最坏会O(n^2)，怕OJ故意出比较坑的数据）

　　将a[ ] 与b[ ]插入a0[ ] ，检测是否可行

code

#include <stdio.h>
#include <stdlib.h>

int buf[100001]={0};

inline int max(int a,int b)
{
    return a>b?a:b;
}

void mergesort(int *p,int l,int r)
{
    if(l>=r) return;
    if(l+1==r)
    {
        if(p[l]>p[r])
        {
            p[l]^=p[r];
            p[r]^=p[l];
            p[l]^=p[r];
        }
        return;
    }
    int i,j,k;
    int m = (l+r)/2;
    mergesort(p,l,m);
    mergesort(p,m+1,r);
    for(i=l; i<=r; i++) buf[i]=p[i];
    for(k=l,i=l,j=m+1; k<=r; k++)
    {
        if(i>m)                 p[k]=buf[j++];
        else if(j>r)            p[k]=buf[i++];
        else if(buf[i]<buf[j])    p[k]=buf[i++];
        else                    p[k]=buf[j++];
    }
}

int main()
{ 
    int i,j,k;
    int a_len=0;
    int a0_len,b_len,tmp;
    scanf("%d %d",&a0_len,&b_len);
    int *a0 = (int *)malloc(sizeof(int)*a0_len);
    int *a = (int *)malloc(sizeof(int)*a0_len);
    int *b = (int *)malloc(sizeof(int)*b_len);
    //--------------------------------------------------------
    for(i=0; i<a0_len; i++)
    {
        scanf("%d",a0+i);
        if(a0[i]!=0)
        {
            a[a_len++]=a0[i];
        }
    }
    for(i=0; i<b_len; i++)
    {
        scanf("%d",b+i);
    }
    mergesort(a,0,a_len-1);
    mergesort(b,0,b_len-1);
    
    bool flag = true;
    for(i=0,j=0,k=0; k<a0_len; k++)
    {
        if(a0[k]==0)
        {
            a0[k]=b[j++];
        }
        else
        {
            a0[k]=a[i++];
        }
        if(k!=0 && a0[k]<a0[k-1])
        {
            flag = false;
            break;
        }
    }
        

    if(flag)
    {
        for(i=0;i<a0_len;i++)
        {
            printf("%d ",a0[i]);
        }
    }
    else
    {
        printf("-1");
    }
    printf("
");
    //--------------------------------------------------------
    free(a);
    free(b);
    free(a0);
    return 0;
}