3299 有序数组合并求第K大问题

题目描述 Description

给出两个有序数组A和B（从小到大有序），合并两个有序数组后新数组c也有序，询问c数组中第k大的数

假设不计入输入输出复杂度，你能否给出一个O(logN)的方法？

输入描述 Input Description

第一行输入三个整数n、m和k

第二行输入n个用空格隔开的整数表示数组A

第三行输入m个用空格隔开的整数表示数组B

输入保证A和B数组非递减

输出描述 Output Description

合并两个数组之后的第k大的数

样例输入 Sample Input

2 3 4

1  2

1 1 5

样例输出 Sample Output

2

数据范围及提示 Data Size & Hint

1<=n,m<=1000000

1<=k <=n+m

算法一：O（m+n+k）

做类似于归并排序的合并，但是没有使用额外的空间。

 #include <stdio.h>
 long long n,m,k,a[],b[];
 long long findKthSMallest()
 {
     int ai=,bi=;
     while(k>)
     {
         if(ai<n&&bi<m)
         {
             if(a[ai]<=b[bi])
             {
                 if(k==) return a[ai];
                 ai++;
             }
             else if(b[bi]<=a[ai])
             {
                 if(k==) return b[bi];
                 bi++;
             }
         }
         else if(ai<n&&bi==m)
         {
             if(k==) return a[ai];
             ai++;
         }
         else if(ai==n&&bi<m)
         {
             if(k==) return b[bi];
             bi++;
         }
         else return -;

         k--;
     }
 }
 int main(int argc, char *argv[])
 {
     int i;
     scanf("%d%d%d",&n,&m,&k);
     for(i=;i<n;i++) scanf("%d",&a[i]);
     for(i=;i<m;i++) scanf("%d",&b[i]);
     printf("%d\n",findKthSMallest());
     return ;
 }

下面的代码是同样的思路，但是代码比较简洁易懂：

 #include <stdio.h>
 int n,m,k,a[],b[];
 int findKthSMallest(int a[],int n,int b[],int m,int k)
 {
     int a_offset = , b_offset = ;
     if(n+m<k) return -;

     while(true)
     {
         if(a_offset<n)
         {
             while (b_offset == m || a_offset<n&&a[a_offset] <= b[b_offset])
             {
                 if(a_offset+ + b_offset == k) return a[a_offset];
                 a_offset++;
             }
         }
         if(b_offset<m)
         {
             while (a_offset == n || b_offset<m&&a[a_offset] >= b[b_offset])
             {
                 if (a_offset + b_offset+ == k) return b[b_offset];
                 b_offset++;
             }
         }
     }
 }
 int main(int argc, char *argv[])
 {
     int i;
     scanf("%d%d%d",&n,&m,&k);
     for(i=;i<n;i++) scanf("%d",&a[i]);
     for(i=;i<m;i++) scanf("%d",&b[i]);
     printf("%d\n",findKthSMallest(a,n,b,m,k));
     return ;
 }

第二段代码参考自：在线疯狂的博客，原文代码有误，已经修正。

第三种写法：省一些空间，b[ ]并没有提前完整输入。

 #include <stdio.h>
 int n,m,k,a[];
 int main(int argc, char *argv[])
 {
     int i,j,bTemp,kIndex,kValue=,f;
     scanf("%d%d%d",&n,&m,&k);
     for(i=;i<n;i++) scanf("%d",&a[i]);

     i=,kIndex=,f=;
     for(j=;j<m||i<n;j++) // i是a[]的下标，j是b[]的下标
     {
         //for的语句条件和这里的if条件是防止b[]扫描完了却未曾寻找到第k个数.
         //这个时候需要继续循环，在a[]中寻找，但是不再输入
         if(j<m) scanf("%d",&bTemp);

         while(i<n||j<m)
         {
             if(j==m||i<n&&a[i]<=bTemp)
             {
                 kIndex++;
                 kValue=a[i++];
                 if(kIndex==k) { f=; break; }
             }
             else
             {
                 kIndex++;
                 kValue=bTemp;
                 if(kIndex==k) f=;
                 break;
             }
         }
         if(f==) break;
     }
     printf("%d\n",kValue);
     return ;
 }

算法二：时间复杂度O（log（n+m））。当然，假如考虑输入，那时间复杂度仍然是O（n+m）

代码来源：http://www.cnblogs.com/swanspouse/p/5285015.html

代码解析：

• 传统解法，最直观的解法是O(m+n)。直接merge两个数组，然后求第K大的数字。

• 如果想要时间复杂度将为O(log(m+n))。我们可以考虑从K入手。如果我们每次能够删除一个一定在第K个元素之前的元素，那么我们需要进行K次，但是如果每次我们都删除一半呢？由于两个数组都是有序的，我们应该充分利用这个信息。

  • 假设A B 两数组的元素都大于K/2，我们将A B两数组的第K/2个元素进行比较。比较的结果有三种情况。
    • A[K/2] == B[K/2]
    • A[K/2] > B[K/2]
    • A[K/2] <= B[K/2]
  • 如果 A[K/2] < B[K/2] 意味着 A[0] 到 A[K/2] 肯定在A∪B的前k个元素中。因此我们可以放心删除A数组的这个k/2个元素。同理A[K/2] > B[K/2]。
  • 如果 A[K/2] == B[K/2] 说明已经找到了第K个元素，直接返回A[K/2]或者B[K/2]。

 #include <stdio.h>
 #include <iostream>
 using namespace std;
 int a[],b[];
 int find_kth(int A[],int m, int B[], int n, int k)
 {
     if(m > n )  return find_kth(B, n, A, m, k);
     if( m == ) return B[k-];
     if( k == ) return min(A[], B[]);

     int ia = min(k /, m);
     int ib = k -ia;
     if( A[ia-] < B[ib -])
         return find_kth(A +ia, m -ia, B, n, k -ia);
     else if( A[ia-] > B[ib-])
         return find_kth(A, m, B +ib, n -ib, k -ib);
     else
         return A[ia-];
 }
 int main(int argc, char *argv[])
 {
     int i,n,m,k;
     int ans;
     scanf("%d%d%d",&n,&m,&k);
     for(i=;i<n;i++) scanf("%d",&a[i]);
     for(i=;i<m;i++) scanf("%d",&b[i]);
     ans=find_kth(a,n,b,m,k);
     printf("%d\n",ans);
     return ;
 }

说明

• 注意其中的递归终止条件。
• 将求第K大元素的问题划分成为子问题，不断的对问题进行缩小，采取递归的方式求解。
• 此问题可以进行拓展，比如求两有序数组的中位数。