其實就是找到兩個陣列中第k大的數
每次一k/2的複雜度縮小
排除k/2個不可能的數
複雜度log(m+n)

class Solution {
public:
    double findMedianSortedArrays(vector<int>& a, vector<int>& b) {
        int m = a.size();
        int n = b.size();
        int cnt = m+n;
        if( cnt%2==1  ){
            return findk(a,b,(cnt+
 
1)/2 );
        }else{
            return (findk(a,b,cnt/2) +findk(a,b,cnt/2+1))/2.0 ;
        }
        return 0; 
    }
    
    int findk(vector<int>& a, vector<int>& b,int k){
        
        int m = a.size();
        int n = b.size();
        
        int ai = 0;
        int bi = 0
 
;
        
        while(true){
            
            if(ai==m){
                return b[bi+k-1];  
            }
            if(bi==n){
                return a[ai+k-1];
            }
            
            if(k==1){
                return min( a[ai],b[bi] );
            }
            
            int
 
 ani = min(ai+k/2-1,m-1);
            int bni = min(bi+k/2-1,n-1);
            
            if(a[ani] <= b[bni]){
                k -= ani - ai + 1;
                ai = ani + 1;
            }else{
                k -= bni - bi + 1;
                bi = bni + 1;
            }
        }
    }
};

長度分別為m和n的兩個序列
從兩個序列中各自畫一條線一分為二
將兩個序列左邊的個數相加，中位數就是找到(m+n+1)/2,
奇數是左邊多一個，偶數的時候一樣多
因為知道了總數，所有隻在較短的陣列進行二分查詢即可
較長的陣列的切割位置就是確定的（因為兩個序列總的長度固定）
找到滿足第一個序列切割位置左邊的最大值小於第二個序列切割位置的最小值的位置
將第一個序列的切割位置儘量向右推，最右時候就是答案
複雜度log(min(m,n))

class Solution {
public:
    double findMedianSortedArrays(vector<int>& a, vector<int>& b) {
        if(a.size() > b.size()){
            swap(a,b);
        }
        int m = a.size();
        int n = b.size();
        int lcnt = (m+n+1)/2;
        int l = 0;
        int r = m;
        //a[i-1]<b[j] && b[j-1]<a[i]
        
        int lmax = INT_MIN;
        int rmin = INT_MAX;
        
        while(l<=r){
            int i = (l+r+1)/2;
            int j = lcnt -i;
            
            int ai_1 = (i==0?INT_MIN:a[i-1]);
            int ai = (i==m?INT_MAX:a[i]);
            
            int bj_1 = (j==0?INT_MIN:b[j-1]);
            int bj = (j==n?INT_MAX:b[j]);
            
            if(ai_1 <= bj){
                lmax = max(ai_1,bj_1);
                rmin = min(ai,bj);
                l = i+1;    
            }else{
                r = i-1;
            }
        }
    
        if( (m+n)%2==0){
            return (lmax+ rmin)/2.0;
        }else{
            return lmax;
        }
        return 0;
    }
};