Leetcode周赛180总结

1380. Lucky numbers in a matrx
      Given a m * n matrix of distinct numbers, return all lucky numbers in the matrix in any order. A lucky number is an element of the matrix such that it is the minimum element in its row and maximum in its column

public List<Integer> luckyNumbers(int[][] matrix) {
		int rows = matrix.length;
		int cols = matrix[0].length;

		List<Integer> res = new ArrayList<>();

		for (int i = 0; i < rows; i++) {
			int minrow = Integer.MAX_VALUE;
			int minrowcol = 0;

			for (int j = 0; j < cols; j++) {
				int cur = matrix[i][j];

				// find min in row i
				if (cur < minrow) {
					minrow = cur;
					minrowcol = j; // gives the col of min element in row i
				}
			}

			// check minrowcol, see if i is the max in col
			int maxcol = 0;
			int maxcolrow = 0;
			for (int k = 0; k < rows; k++) {
				int cur = matrix[k][minrowcol];
				if (cur > maxcol) {
					maxcol = cur;
					maxcolrow = k; // gives the row of max element in row minrowcol
				}
			}

			if (maxcolrow == i)
				res.add(matrix[maxcolrow][minrowcol]);
		}
		return res;
	}

自己用的很笨的方法，先找一行的最小，找到之后确定是不是那一列的最大。如果是的话，加入res。
很失败，做题时候竟然把minrow和minrowcol放在了forloop外面，结果简单题都没过。看来最最基础的编码能力还是很弱。下周赛希望简单题能够保证，而且尽量短时间做完，给中等题留些时间。

还有一种方法是看题解学到的：

 public List<Integer> luckyNumbers (int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[] mi = new int[m], mx = new int[n];
        Arrays.fill(mi, Integer.MAX_VALUE);
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                mi[i] = Math.min(matrix[i][j], mi[i]);
                mx[j] = Math.max(matrix[i][j], mx[j]);
            }
        }
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < m; ++i)
            for (int j = 0; j < n; ++j)
                if (mi[i] == mx[j]) 
                    res.add(mi[i]);
        return res;        
    }

这里运用了矩阵中都是独特元素的性质，因此找出行和列中的最小元素，然后对比看他们的相同元素，加入返回结果。

1382. Balance a BST
      Given a binary search tree, return a balanced binary search tree with the same node values.
      A BST is balanced if and only if the depth of the two subtrees of every node never differ by more than 1.
      If there is more than one answer, return any of them.

public class _1382_BalanceBST {

	List<Integer> sorted = new ArrayList<>();

	public TreeNode balanceBST(TreeNode root) {
		inorder(root);
		return helper(0, sorted.size() - 1);
	}

	private void inorder(TreeNode root) {
		if (root == null)
			return;

		inorder(root.left);
		sorted.add(root.val);
		inorder(root.right);
	}

	private TreeNode helper(int l, int r) {
		if (l > r)
			return null;

		int mid = (l + r) / 2;
		TreeNode root = new TreeNode(sorted.get(mid));

		root.left = helper(l, mid - 1);
		root.right = helper(mid + 1, r);

		return root;
	}

}

学到的答案，当时没有思路。
思路是这样的：首先遍历树，得到排序的数组，中序遍历BST可以得到！然后根据数组递归的重建BST。 那么为什么根据数组重建的方法一定是平衡的呢？首先看root，他去了mid之后，左右子树的数量是一样的，同理所有的子节点。