k-th smallest 问题总结

k-th smallest/biggest 问题大约有这几道：

373. Find K Pairs with Smallest Sums	从两个list里各取一个数求和，求所有可能的sum里第k小的
378. Kth Smallest Element in a Sorted Matrix	给一个每一横排/每一纵列都有序的matrix，求其中第k小的元素
668. Kth Smallest Number in Multiplication Table	给一个乘法表（类似378的matrix），求其中第k小的元素
719. Find K-th Smallest Pair Distance	从一个list里取两个元素求和，求所有可能的sum里第k小的
786. K-th Smallest Prime Fraction	从一个list里取两个元素相除，求所有可能的sum里第k小的

可以看出，其实373 719 786是同一题，378 668是同一题

这种题大致有两种思路：

1. 用heap

关于堆的介绍网上有一大把......这里只划重点

堆是一种是一种特殊的完全二叉树，其中每个根节点一定比它的左、右儿子节点都大/小（大根堆or小根堆）。每次增/删元素时，需要移动二叉树节点来保持这一性质。

时间复杂度：

从一个长度为N的乱序数组建堆  O(NlogN)

向长度为N的堆插入/删除一个元素  O(logN)

实现：

C++里可以用priority_queue<int> pq。常用操作有push(), pop(), top(), empty(), size()

Python 里可以用import heapq，然后heapq.heapify(list_a)就在原list上建好堆啦，a[0]就是堆顶。不过它只能建大根堆  

import heapq

#heapq implemented min heap only. Thus we save -nums[i] into the heap
class Solution:
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        a=[]
        res=[]
        for i in range(len(nums)):
            a.append(-nums[i])
            if(i>=k):
                a.remove(-nums[i-k])
            heapq.heapify(a)
            if(i>=k-1):
                res.append(-a[0])
        return res

sl=Solution()
nn=[1,3,-1,-3,5,3,6,7]
rr=sl.maxSlidingWindow(nn,3)
print(rr)

解题思路：

把所有要比较的东西都塞到heap里，最后做k次取堆顶--弹出堆顶的操作

时间复杂度是 O(N^2 * log(N^2)) 有些medium题能过，但hard题肯定不行

根据题目具体情况，一开始不一定所有的东西都要塞进heap

例题：

373. Find K Pairs with Smallest Sums

反正过是能过...它的加强版就是719 786啦

priority_queue默认是大根堆，要是想要小根堆需要自定义比较函数。这里我直接重载了运算符（因为是pair嘛），推荐一下这种写法（骄傲

class Solution {
public:
    struct Node
    {
        pair<int, int> val;
        Node(int x,int y) {val=pair<int, int>(x,y);}
        bool operator <(Node a) const {return(val.first+val.second < a.val.first+a.val.second);}
        bool operator >(Node a) const {return(val.first+val.second > a.val.first+a.val.second);}
    };

    vector<pair<int, int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) 
    {
        vector< pair<int, int> > ans;
        int lx=nums1.size(),ly=nums2.size();
        if(lx==0 || ly==0) return ans;
        k=min(k,lx*ly);
        priority_queue<Node, vector<Node>, greater<Node> > pq;
        for(int i=0;i<min(lx,k);i++)
            for(int j=0;j<min(ly,k);j++)
            {
                pq.push(Node(nums1[i], nums2[j]));
            }

        while(k)
        {
            ans.push_back(pq.top().val);
            pq.pop();
            k--;
        }
        return ans;

    }
};

378. Kth Smallest Element in a Sorted Matrix

赤果果的heap。又不是不能用......

//O(N*N*log(N*N))
class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k)
    {
        int dx=matrix.size(),dy=matrix[0].size();
        priority_queue<int> pq;
        for(int i=0;i<dx;i++)
            for(int j=0;j<dy;j++)
                pq.push(matrix[i][j]);

        int ans;
        k=dx*dy-k+1;
        while(k)
        {
            ans=pq.top();
            pq.pop();
            k--;
        }
        return ans;
    }
};

另外三题heap都是妥妥超时的噢......hard就是hard

2. Binary Search

二分查找模板了解一下：

under_construction

时间复杂度：

O(log(N))

解题思路：

用二分查找(有left, right, mid)来枚举第k小的值，然后看原数组里当前有多少是小于mid的，多了就减小right，少了就增大left。直到查找结束，此时left就是第k小值啦

实现时先对原数组按行/列排个序，或者题目本身就是保证有序的

时间复杂度是 O(log(X)*N) ，其中log(X)是二分查找的开销(X=right-left)，N是在原数组里找小于mid的数的开销（二维数组的话最坏情况可能会N^2，不过一般也能过）

例题：

378. Kth Smallest Element in a Sorted Matrix

就按上面的方法实现哒

在原数组里count时用了一个函数upper_bound(matrix[i].begin(), matrix[i].end(), mid)，返回matrix[i]这个从小到大有序的vector里小于等于mid的第一个数的指针

这玩意底层是二分查找，时间复杂度是logN呢。

//O(N*log(N)*log(max-min))
//Binary Search
class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k)
    {
        int dx=matrix.size(),dy=matrix[0].size();
        int ml=matrix[0][0], mr=matrix[dx-1][dy-1];
        int mid,cnt;
        while(ml<mr)
        {
            mid=(ml+mr)/2;
            cnt=0;
            for(int i=0;i<dx;i++)
            {
                cnt+=upper_bound(matrix[i].begin(), matrix[i].end(), mid)-matrix[i].begin();
            }
            if(cnt>=k)
                mr=mid;
            else if(cnt<k)
                ml=mid+1;
        }
        return ml;
    }
};

668. Kth Smallest Number in Multiplication Table

上面的改巴改巴就行了......

//Binary Search
class Solution {
public:
    //int kthSmallest(vector<vector<int>>& matrix, int k)
    int findKthNumber(int m, int n, int k) 
    {
        int ml=1, mr=m*n;
        int mid,cnt;
        while(ml<mr)
        {
            mid=(ml+mr)/2;
            cnt=0;
            for(int i=1;i<=m;i++)
            {
                cnt+=min(mid/i,n);
            }
            if(cnt>=k)
                mr=mid;
            else if(cnt<k)
                ml=mid+1;
        }
        return ml;
    }
};

719. Find K-th Smallest Pair Distance

一样的套路噢...就是从一个matrix变成了两个list

// Binary Search
class Solution {
public:
    int smallestDistancePair(vector<int>& nums, int k)
    {
        int n=nums.size();
        sort(nums.begin(), nums.end());
        int ml=nums[1]-nums[0],mr=nums[n-1]-nums[0],mid=0,cnt=0;
        for(int i=0;i<n-1;i++) ml=min(ml,nums[i+1]-nums[i]);
        while(ml<mr)
        {
            mid=(ml+mr)/2;
            cnt=0;
            for(int i=0;i<n;i++)
            {
                int j=i+1;
                while(j<n && nums[j]-nums[i]<=mid) j++;
                cnt+=(j-i-1);
            }
            if(cnt<k)
                ml=mid+1;
            else
                mr=mid;
        }
        return ml;
    }
};

这题其实还有个骚操作：因为list值的范围比较小，所以可以用counting sort：先用O(N^2)的时间把所有可能的pair和记下来，然后在counting sort的数组里从小到大数数即可

不过感觉这方法通用性应该不强...

//counting sort: O(N^2)
class Solution {
public:
    int smallestDistancePair(vector<int>& nums, int k) 
    {
        int val[1000010];
        memset(val,0,sizeof(val));
        int nl=nums.size();
        for(int i=0;i<nl;i++)
            for(int j=i+1;j<nl;j++)
            {
                //cout<<abs(nums[j]-nums[i])<<endl;
                val[abs(nums[j]-nums[i])]++;
            }

        int ans=0;
        while(k)
        {
            if(val[ans]>0) 
            {
                //cout<<k<<" "<<ans<<endl;
                val[ans]--;
                k--;
            }
            else ans++;
        }
        return ans;
    }
};

786. K-th Smallest Prime Fraction

这题坑多一点，因为是分数，涉及到浮点数嘛

涉及到浮点数就不能直接用=比较辣，要用r-l<eps。

以及注意两个int做除法，要先强制转换成double

//Binary Search, AC
class Solution {
public:
    vector<int> kthSmallestPrimeFraction(vector<int>& A, int k) 
    {
        vector<int> ans;
        int al=A.size();
        sort(A.begin(), A.end());
        double ml=0.0, mr=1.0, md=0.5;
        int dx,dy,cnt;
        double eps=1e-10;
        while(mr-ml>eps)
        {
            md=(ml+mr)/2;
            cnt=0;
            for(int i=0;i<al;i++)
            {
                int j=al-1;
                while(j>i && (double)A[i]/(double)A[j]<md) j--;
                cnt+=(al-1-j);
            }
            cout<<ml<<","<<mr<<"=="<<md<<" "<<cnt<<endl;
            if(cnt<k)
                ml=md;
            else
                mr=md;
            
        }
        for(int i=0;i<al;i++)
            for(int j=i+1;j<al;j++)
                if(abs((double)A[i]/(double)A[j] - ml)<eps)
                {
                    dx=A[i]; dy=A[j];
                    ans.push_back(dx); ans.push_back(dy);
                    return(ans);
                }
        return ans;
    }
};