LeetCode第180場周賽

5356. 矩陣中的幸運數

暴力解法：

時間複雜度：O（mn）

class Solution {
    public List<Integer> luckyNumbers (int[][] matrix) {
    	int m = matrix.length;
    	int n = matrix[0].length;
    	List<Integer> res = new ArrayList<Integer>();
    	for (int i = 0; i < m; i++) {
			int minn = matrix[i][0];
			int minindex = 0;	//最小的列標
    		for (int j = 0; j < n; j++) {	//找到每一行最小的數,保存好下標
				if(matrix[i][j] < minn) {
					minn = matrix[i][j];
					minindex = j;
				}
			}
    		int maxx = minn;
    		int j = 0;
            boolean flag = true;
    		for (; j < m; j++) {	//以找到的下標對每列開始尋找最大值
				if(matrix[j][minindex] > maxx) {	//如果這一列有更大的數，不用找了
					flag = false;
                    break;
				}
			}
    		if(flag == true)	//找到就添加到集合中
    			res.add(maxx);
		}
    	return res;
    }
}

---

5357. 設計一個支持增量操作的棧

用數組模擬一個棧

class CustomStack {
	int length;
	int[] stack;
	int top = -1;	//top指針指向棧頂元素
	int currentlength;	//當前棧中元素數量
    public CustomStack(int maxSize) {
    	this.length = maxSize;
    	stack = new int[maxSize+5];
    }
    
    public void push(int x) {
        if(currentlength == length)
            return ;
    	stack[++top] = x;
    	currentlength ++;
    }
    
    public int pop() {
    	if(currentlength == 0)
    		return -1;
    	int temp = stack[top--];
        currentlength -- ;
    	return temp;
    }
    
    public void increment(int k, int val) {
    	if(currentlength < k) {
    		for (int i = 0; i <= top; i++) {
				stack[i] += val;
			}
    		return;
    	}
    	for (int i = 0; i < k; i++) {
			stack[i] += val;
		}
    	return;
    }
}

---

5179. 將二叉搜索樹變平衡

AVL樹左右旋來不及寫，中序遍歷，再重新建樹又想不到，只能看看人家代碼…

class Solution {
    ArrayList<TreeNode> orderList = null;
    TreeNode[] orderNode = null;
    public TreeNode balanceBST(TreeNode root) {
        orderList = new ArrayList<>();

        // 思路：先找出所有節點，然後中分取數
        // 先找所有節點，中序遍歷，查出有序的集合
        doSelect(root);

        if (orderList.size() < 3) return root; // 個數小於3就沒必要了

        orderNode = orderList.toArray(new TreeNode[orderList.size()]); // 構建成數組，以便於取區間的中位數

        return doBuild(0, orderNode.length - 1); // 構建新的樹
    }

    private TreeNode doBuild(int left, int right){
        if (left > right) return null;

        int curRootIndex = (left + right) / 2;
        TreeNode curRoot = orderNode[curRootIndex];
        curRoot.left = doBuild(left, curRootIndex - 1);
        curRoot.right = doBuild(curRootIndex + 1, right);
        return curRoot;
    }

    // 中序遍歷獲取數組鏈表
    private void doSelect(TreeNode curRoot){
        if (curRoot == null) return;

        doSelect(curRoot.left);
        orderList.add(curRoot);
        doSelect(curRoot.right);
    }
}

5359. 最大的團隊表現值

貪心：因爲效率按照最低的算，先按照效率從高到低排序，對於每一種效率，選出最大的k個speed

class Solution {
    public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
    	int[][] engineer = new int[n][2];
    	for (int i = 0; i < n; i++) {
			engineer[i][0] = speed[i];
			engineer[i][1] = efficiency[i];
		}
    	Arrays.sort(engineer, new Comparator<int[]>() {
			@Override
			public int compare(int[] o1, int[] o2) {
				return o2[1] - o1[1];
			}
		});
    	PriorityQueue<Integer> pq = new PriorityQueue<>();
    	long res = 0, sum = 0;
    	for (int i = 0; i < n; i++) {
    		pq.add(engineer[i][0]);
    		sum += engineer[i][0];
    		if(pq.size() > k) {
    			sum -= pq.poll();
    		}
    		res = Math.max(res, sum * engineer[i][1]);
    	}
    	return (int) (res%((int)1e9+7));
    }
}