17082 两个有序数序列中找第k小（递归）

17082 两个有序数序列中找第k小

Description

已知两个已经排好序（非减序）的序列X和Y，其中X的长度为m，Y长度为n，
现在请你用分治算法，找出X和Y的第k小的数，算法时间复杂度为O(max{logm, logn})。

此题请勿采用将序列X和Y合并找第k小的O(m+n)的一般方法，要充分利用X和Y已经排好序的这一特性。

输入格式

第一行有三个数，分别是长度m、长度n和k，中间空格相连（1<=m,n<=100000; 1<=k<=m+n）。
第二行m个数分别是非减序的序列X。第三行n个数分别是非减序的序列Y。

输出格式

序列X和Y的第k小的数。

输入样例

5 6 7
1 8 12 12 21 
4 12 20 22 26 31

输出样例

20

提示

提示陆续写上来，不着急，先自行思考和讨论……

作者

提示

假设：X序列为X[xBeg...xEnd]，而Y序列为Y[yBeg...yEnd]。

将序列X和Y都均分2段，即取X序列中间位置为xMid (xMid = xBeg+(xEnd-xBeg)/2)，也同理取序列Y中间位置为yMid。
比较X[xMid]和Y[yMid]的大小，此时记录X左段和Y左段元素个数合计为halfLen，即halfLen = xMid-xBeg+yMid-yBeg+2。

1. 当X[xMid] < Y[yMid]时，在合并的数组中，原X[xBeg...xMid]所有元素一定在Y[yMid]的左侧，
   （1） 若k < halfLen，则此时第k大的元素一定不会大于Y[yMid]这个元素，故以后没有必要搜索 Y[yMid...yEnd]这些元素，可弃Y后半段数据。
       此时只需递归的对X序列+Y序列的前半段，去搜索第k小的数。

   （2） 若k >= halfLen，则此时第k大的元素一定不会小于X[xMid]这个元素，故以后没有必要搜索 X[xBeg...xMid]这些元素，可弃X前半段数据。
       此时只需递归的对X序列的后半段+Y序列，去搜索第 k-(xMid-xBeg+1）小的数。

2. 当X[xMid] >= Y[yMid]时，在合并的数组中，原Y[yBeg...yMid]的所有元素一定在X[xMid]的左侧，
   （1） 若k < halfLen，则此时第k大的元素一定不会大于X[xMid]这个元素，故以后没有必要搜索 X[xMid...xEnd]这些元素，可弃X后半段数据。
       此时只需递归的对X序列的前半段+Y序列，去搜索第k小的数。

   （2） 若k >= halfLen，则此时第k大的元素一定不会小于Y[yMid]这个元素，故以后没有必要搜索 Y[yBeg...yMid]这些元素，可弃Y前半段数据。
       此时只需递归的对X序列+Y序列的后半段，去搜索第 k-(yMid-yBeg+1）小的数。

我的实现代码：

#include <iostream>

using namespace std;

//int test_count = 0;
int a[100010], b[100010];

void search_i(int need_i, int a_left, int a_right, int b_left, int b_right)
{
    
    /*
     cout << "* " << need_i << " *\n";
     test_count++;
     if(test_count == 7)
     {
     return;
     }
     
     
     int i;
     for(i = a_left; i <= a_right; i++)
     {
     cout << a[i] << " ";
     }
     cout << "\n";
     for(i = b_left; i <= b_right; i++)
     {
     cout << b[i] << " ";
     }
     cout << "\n";
     */
    
    int a_mid = (a_left + a_right + 1)/2;// +1 是关键，因为数组下标从1开始放数据
    int b_mid = (b_left + b_right + 1)/2;// +1 是关键，因为数组下标从1开始放数据
    int half = a_mid - a_left +1   +    b_mid - b_left + 1;// half为每次处理时数据个数的一半，根据mid和left计算得出
    
    if(a[a_mid] < b[b_mid])// a中间数 < b中间数
    {
        if(need_i < half)// 此处不能为 <=，因为此处b_mid - 1，会提前导致right < left
        {
            // 舍弃[b_mid]~b[b_right]，即大数组中间数的右侧
            b_right = b_mid - 1;
        }
        else
        {
            // 舍弃a[a_left]~a[a_mid]，即小数组中间数的左侧
            need_i -= (a_mid - a_left + 1);// 参与比较的数少了，更新need_i
            a_left = a_mid + 1;
        }
    }
    else
    {
        if(need_i < half)// 此处不能为 <=，因为此处a_mid - 1，会提前导致right < left
        {
            // 舍弃a[a_mid]~a[a_right]，即大数组中间数的右侧
            a_right = a_mid - 1;
            
        }
        else
        {
            // 舍弃b[b_left]~b[b_mid]，即小数组中间数的左侧
            need_i -= (b_mid - b_left + 1);// 参与比较的数少了，更新need_i
            b_left = b_mid + 1;
        }
    }
    
    if(a_right < a_left)
    {// a数组已不在范围内，从b数组取结果即可
        cout << b[b_left - 1 + need_i];
        return;
    }
    if(b_right < b_left)
    {// b数组已不在范围内，从a数组取结果即可
        cout << a[a_left -1 + need_i];
        return;
    }
    
    search_i(need_i, a_left, a_right, b_left, b_right);//递归
}

/*
 
5 6 8
1 8 12 12 21
4 12 20 22 26 31
 
 */

int main()
{
    int first_nums,second_nums,need_i;
    cin >> first_nums;
    cin >> second_nums;
    cin >> need_i;
    
    //int a[100010],b[100010];
    int a_left = 1, a_right = first_nums;
    int b_left = 1, b_right = second_nums;
    
    
    int i;
    for(i = 1; i <= first_nums; i++)
    {
        cin >> a[i];
    }
    for(i = 1; i <= second_nums; i++)
    {
        cin >> b[i];
    }
    // 以上为初始化输入数据
    
    
    //预处理
    if(need_i == 1){// 第1小
        
        cout << min(a[1],b[1]);
    }
    else if(need_i == (first_nums + second_nums)){// 第(first_nums + second_nums)小
        
        cout << max(a[first_nums], b[second_nums]);
    }
    else{// 第need_i小出现在中间
        
        search_i(need_i, a_left, a_right, b_left, b_right);
    }
    
    cout << endl;
    
    return 0;
}