leetcode-378-有序矩阵中第K小的元素-java

题目及测试

package pid378;
/* Kth Smallest Element in a Sorted Matrix

给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。
请注意，它是排序后的第k小元素，而不是第k个元素。

示例:

matrix = [
   [ 1,  5,  9],
   [10, 11, 13],
   [12, 13, 15]
],
k = 8,

返回 13。

说明:
你可以假设 k 的值永远是有效的, 1 ≤ k ≤ n2 。

*/
public class main {
	
	public static void main(String[] args) {
		int[][] testTable = {{1,  5,  9},{10, 11, 13},
				{12, 13, 15}};
		int[] testTable2=new int[]{8,1};
		for(int i=0;i<testTable2.length;i++){
			test(testTable,testTable2[i]);
		}
		
	}
		 
	private static void test(int[][] ito,int ito2) {
		Solution solution = new Solution();
		long begin = System.currentTimeMillis();
		System.out.println("ito= ");
		for(int i=0;i<ito.length;i++){
			for(int j=0;j<ito[i].length;j++){
			System.out.print(ito[i][j]+" ");
			}
			System.out.println();
		}
		System.out.println();
		System.out.println("ito2= "+ito2);
		int rtn;
		rtn=solution.kthSmallest(ito,ito2);//执行程序
		long end = System.currentTimeMillis();		
		System.out.println("rtn="+rtn);
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，70ms，超慢）

由于每行都是有序的，相当于多路归并排序，从每行的第一个开始，每次确定第index小的元素，遍历，每行的指标对应的元素，速度为O(n*k)

package pid378;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import com.sun.xml.internal.ws.util.NoCloseOutputStream;



public class Solution  {
	public int kthSmallest(int[][] matrix, int k) {
		int n=matrix.length;
		if(n==0){
			return 0;
		}
		// 每行中当前最小的元素的col编号，row编号就是它们的index
		// 初始化时为(0,0) (1,0) ...
		int[] rowMin=new int[n];
		// 本次查询，要找到第index小的元素
		int index=1;
		// 第index小的元素的值
		int nowMin=0;
		// 第index小的元素的col值
		int nowMinCol=0;		

		while(true){
			nowMin=Integer.MAX_VALUE;
			nowMinCol=-1;
			for(int i=0;i<n;i++){
				int nowJ=rowMin[i];
				if(nowJ>=n){
					// 如果这行结束了，不查询这行
					continue;
				}
				int now=matrix[i][nowJ];
				if(now<nowMin){
					nowMin=now;
					nowMinCol=i;
				}
			}
			// 找到第index小的元素
			if(index==k){
				return nowMin;
			}else{
				index++;
				rowMin[nowMinCol]++;
			}
		}
		
        
    }
}

解法2（成功，36ms，较慢）

使用容量为k的最大堆。

	public int kthSmallest(int[][] matrix, int k) {
		int row=matrix.length;
		if(row==0){
			return 0;
		}
		int col = matrix[0].length;
		if(col==0){
			return 0;
		}
		PriorityQueue<Pair<Integer, Pair<Integer, Integer>>> queue = new PriorityQueue<Pair<Integer,Pair<Integer,Integer>>>(new Comparator<Pair<Integer,Pair<Integer,Integer>>>() {
			public int compare(Pair<Integer,Pair<Integer,Integer>> o1, Pair<Integer,Pair<Integer,Integer>> o2) {
				return o1.getKey() - o2.getKey();
			}
		});
		for(int i=0;i<row;i++) {
			queue.add(createPair(matrix[i][0],i, 0));
		}
		int index = 0;
		int result = 0;
		while(index < k) {
			Pair<Integer, Pair<Integer,Integer>> pair = queue.poll();
			result = pair.getKey();
			Pair<Integer,Integer> pairIndex = pair.getValue();
			if(pairIndex.getValue() < col - 1) {
				int rowNow = pairIndex.getKey();
				int colNow = pairIndex.getValue();
				queue.add(createPair(matrix[rowNow][colNow + 1],rowNow, colNow + 1));
			}
			index++;
		}
		return result;
	}
	
	private Pair<Integer, Pair<Integer,Integer>> createPair(int value,int row,int col){
		return new Pair<Integer, Pair<Integer,Integer>>(value, new Pair<Integer,Integer>(row, col));
	}

解法3（别人的）

思路非常简单：
1.找出二维矩阵中最小的数left，最大的数right，那么第k小的数必定在left~right之间
2.mid=(left+right) / 2；在二维矩阵中寻找小于等于mid的元素个数count
3.若这个count小于k，表明第k小的数在右半部分且不包含mid，即left=mid+1, right=right，又保证了第k小的数在left~right之间
4.若这个count大于k，表明第k小的数在左半部分且可能包含mid，即left=left, right=mid，又保证了第k小的数在left~right之间
5.因为每次循环中都保证了第k小的数在left~right之间，当left==right时，第k小的数即被找出，等于right

注意：这里的left mid right是数值，不是索引位置。

   public int kthSmallest(int[][] matrix, int k) {
        int row = matrix.length;
        int col = matrix[0].length;
        int left = matrix[0][0];
        int right = matrix[row - 1][col - 1];
        while (left < right) {
            // 每次循环都保证第K小的数在start~end之间，当start==end，第k小的数就是start
            int mid = (left + right) / 2;
            // 找二维矩阵中<=mid的元素总个数
            int count = findNotBiggerThanMid(matrix, mid, row, col);
            if (count < k) {
                // 第k小的数在右半部分，且不包含mid
                left = mid + 1;
            } else {
                // 第k小的数在左半部分，可能包含mid
                right = mid;
            }
        }
        return right;
    }

    private int findNotBiggerThanMid(int[][] matrix, int mid, int row, int col) {
        // 以列为单位找，找到每一列最后一个<=mid的数即知道每一列有多少个数<=mid
        int i = row - 1;
        int j = 0;
        int count = 0;
        while (i >= 0 && j < col) {
            if (matrix[i][j] <= mid) {
                // 第j列有i+1个元素<=mid
                count += i + 1;
                j++;
            } else {
                // 第j列目前的数大于mid，需要继续在当前列往上找
                i--;
            }
        }
        return count;
    }