Leetcode每日随机2021/5/8

题

今天状态很不好。

思

这一个礼拜过得真快，仿佛才刚回来又要回去了
我的心越来越软了
我很害怕
第一题
傻逼题，空间O(1)那个是人能想出来的？
第二题
这题真不该花那么多时间，代码里有错误没检查出来，说白了就是从0开始，把跟0相关的都转成由0作为起始点的，然后依次遍历就行了。
可是我在写dfs的时候出现了一个很傻逼的错误，最后才发现，搞得我写最后一题的时候只剩十几分钟了。
第三题
我看答案居然还看了半天，就是记录一下当前节点和走到他的边，左用false表示，右用true表示。
dfs遍历一下，记录一下以当前节点为交错终点的路径长度。

代码

第一题

class Solution {
    public int majorityElement(int[] nums) {
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		for (int i : nums) {
			map.put(i, map.getOrDefault(i, 0) + 1);
			if (map.get(i) > nums.length / 2) {
				return i;
			}
		}
		return 0;
	}
}

第二题

class Solution {
    private int count = 0;
	private Set<Integer> visited = new HashSet<Integer>();
	private Map<Integer, Set<int[]>> map = new HashMap<Integer, Set<int[]>>();

	public int minReorder(int n, int[][] connections) {
		for (int[] is : connections) {
			if (map.containsKey(is[0])) {
				map.get(is[0]).add(is);
			} else {
				Set<int[]> set = new HashSet<int[]>();
				set.add(is);
				map.put(is[0], set);
			}
			if (map.containsKey(is[1])) {
				map.get(is[1]).add(is);
			} else {
				Set<int[]> set = new HashSet<int[]>();
				set.add(is);
				map.put(is[1], set);
			}
		}
		dfs(0);
		return count;
	}

	private void dfs(int target) {
		if (visited.size() == map.size() + 1) {
			return;
		}
		for (int[] is : map.get(target)) {
			if (is[0] == target && !visited.contains(is[1])) {
				count++;
			}
		}
		visited.add(target);
		for (int[] is : map.get(target)) {
			int temp = is[0] == target ? is[1] : is[0];
			if (!visited.contains(temp)) {
				dfs(temp);
			}
		}
	}
}

代码参考自官方题解
第三题

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    private int max = 0;

	public int longestZigZag(TreeNode root) {
		dfs(true, root, 0);
		dfs(false, root, 0);
		return max;
	}

	private void dfs(boolean direction, TreeNode node, int len) {
		max = len > max ? len : max;
		if (node == null) {
			return;
		}
		if (direction) {
			if (node.left != null) {
				dfs(false, node.left, len + 1);
			}
			if (node.right != null) {
				dfs(true, node.right, 1);
			}
		} else {
			if (node.left != null) {
				dfs(false, node.left, 1);
			}
			if (node.right != null) {
				dfs(true, node.right, len + 1);
			}
		}
	}
}