leetcode14双周赛

十六进制魔术数字
你有一个十进制数字，请按照此规则将它变成「十六进制魔术数字」：首先将它变成字母大写的十六进制字符串，然后将所有的数字 0 变成字母 O ，将数字 1  变成字母 I 。
如果一个数字在转换后只包含 {“A”, “B”, “C”, “D”, “E”, “F”, “I”, “O”} ，那么我们就认为这个转换是有效的。
给你一个字符串 num ，它表示一个十进制数 N，如果它的十六进制魔术数字转换是有效的，请返回转换后的结果，否则返回 “ERROR” 。

示例 1：
输入：num = “257”
输出：“IOI”
解释：257 的十六进制表示是 101 。

示例 2：
输入：num = “3”
输出：“ERROR”

提示：
1 <= N <= 10^12
给定字符串不会有前导 0 。
结果中的所有字母都应该是大写字母。

代码

public String toHexspeak(String num) {
	long l = Long.parseLong(num);
	String s = "";
	while (l > 0) {
		long y = l % 16;
		if (y > 1 && y < 10) {
			return "ERROR";
		}
		if (y == 0) {
			s = "O" + s;
		}
		if (y == 1) {
			s = "I" + s;
		}
		if (y >= 10) {
			s = ((char) (y - 10 + 'A')) + s;
		}
		l = l / 16;
	}
	if ("".equals(s)) {
		return "O";
	}
	return s;
}

删除区间
给你一个 有序的 不相交区间列表 intervals 和一个要删除的区间 toBeRemoved， intervals 中的每一个区间 intervals[i] = [a, b] 都表示满足 a <= x < b 的所有实数  x 的集合。
我们将 intervals 中任意区间与 toBeRemoved 有交集的部分都删除。
返回删除所有交集区间后， intervals 剩余部分的 有序 列表。

示例 1：
输入：intervals = [[0,2],[3,4],[5,7]], toBeRemoved = [1,6]
输出：[[0,1],[6,7]]
示例 2：
输入：intervals = [[0,5]], toBeRemoved = [2,3]
输出：[[0,2],[3,5]]
 
提示：
1 <= intervals.length <= 10^4
-10^9 <= intervals[i][0] < intervals[i][1] <= 10^9

代码

public List<List<Integer>> removeInterval(int[][] intervals,
		int[] toBeRemoved) {
	List<List<Integer>> left = new ArrayList<>();
	List<List<Integer>> right = new ArrayList<>();
	for (int i = 0; i < intervals.length; i++) {
		if (intervals[i][1] <= toBeRemoved[0]) {
			List<Integer> l = new ArrayList<Integer>();
			l.add(intervals[i][0]);
			l.add(intervals[i][1]);
			left.add(l);
			continue;
		}
		if (intervals[i][0] < toBeRemoved[0]) {
			List<Integer> l = new ArrayList<Integer>();
			l.add(intervals[i][0]);
			l.add(toBeRemoved[0]);
			left.add(l);
			if (intervals[i][1] > toBeRemoved[1]) {
				List<Integer> r = new ArrayList<Integer>();
				r.add(toBeRemoved[1]);
				r.add(intervals[i][1]);
				right.add(r);
			}
			continue;
		}
		if (intervals[i][1] < toBeRemoved[1]) {
			continue;
		}
		List<Integer> r = new ArrayList<Integer>();
		r.add(Math.max(toBeRemoved[1], intervals[i][0]));
		r.add(intervals[i][1]);
		right.add(r);
	}
	left.addAll(right);
	return left;
}

删除树节点
给你一棵以节点 0 为根节点的树，定义如下：
节点的总数为 nodes 个；
第 i 个节点的值为 value[i] ；
第 i 个节点的父节点是 parent[i] 。
请你删除节点值之和为 0 的每一棵子树。
在完成所有删除之后，返回树中剩余节点的数目。

示例：

输入：nodes = 7, parent = [-1,0,0,1,2,2,2], value = [1,-2,4,0,-2,-1,-1]
输出：2

提示：
1 <= nodes <= 10^4
-10^5 <= value[i] <= 10^5
parent.length == nodes
parent[0] == -1 表示节点 0 是树的根。

代码

public int deleteTreeNodes(int nodes, int[] parent, int[] value) {
Node[] nodess = new Node[nodes];
for (int i = 0; i < nodes; i++) {
nodess[i] = new Node();
nodess[i].value = value[i];
}
Node root = null;
for (int i = 0; i < nodes; i++) {
if (parent[i] == -1) {
root = nodess[i];
continue;
}
nodess[parent[i]].children.add(nodess[i]);
}
getValue(root);
return getNum(root);
}

private int getNum(Node root) {
	if (root.value == 0) {
		return 0;
	}
	int ans = 1;
	for (Node n : root.children) {
		ans += getNum(n);
	}
	return ans;
}

private int getValue(Node root) {
	int v = root.value;
	for (Node n : root.children) {
		v += getValue(n);
	}
	root.value = v;
	return v;
}

class Node {
	int value;
	List<Node> children = new ArrayList<Node>();;
}

矩形内船只的数目
在用笛卡尔坐标系表示的二维海平面上，有一些船。每一艘船都在一个整数点上，且每一个整数点最多只有 1 艘船。
有一个函数 Sea.hasShips(topRight, bottomLeft) ，输入参数为右上角和左下角两个点的坐标，当且仅当这两个点所表示的矩形区域（包含边界）内至少有一艘船时，这个函数才返回 true ，否则返回 false 。
给你矩形的右上角 topRight 和左下角 bottomLeft 的坐标，请你返回此矩形内船只的数目。题目保证矩形内 至多只有 10 艘船。
调用函数 hasShips 超过400次 的提交将被判为 错误答案（Wrong Answer） 。同时，任何尝试绕过评测系统的行为都将被取消比赛资格。

示例：

输入：
ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]
输出：3
解释：在 [0,0] 到 [4,4] 的范围内总共有 3 艘船。
 
提示：
ships 数组只用于评测系统内部初始化。你无法得知 ships 的信息，所以只能通过调用 hasShips 接口来求解。
0 <= bottomLeft[0] <= topRight[0] <= 1000
0 <= bottomLeft[1] <= topRight[1] <= 1000

可执行方法
class Sea {
public boolean hasShips(int[] topRight, int[] bottomLeft);
}

代码

public int countShips(Sea sea, int[] topRight, int[] bottomLeft) {
	if (!sea.hasShips(topRight, bottomLeft)) {
		return 0;
	}
	return getAns(sea, topRight, bottomLeft);
}

private int getAns(Sea sea, int[] topRight, int[] bottomLeft) {
	if (topRight[0] == bottomLeft[0]) {
		if (topRight[1] == bottomLeft[1]) {
			return 1;
		}
		int[] tr1 = topRight;
		int[] bL1 = new int[] { topRight[0],
				(topRight[1] + bottomLeft[1]) / 2 + 1 };
		int[] tr2 = new int[] { topRight[0],
				(topRight[1] + bottomLeft[1]) / 2 };
		int[] bL2 = bottomLeft;
		int ans = 0;
		if (sea.hasShips(tr1, bL1)) {
			ans += getAns(sea, tr1, bL1);
		} else {
			return getAns(sea, tr2, bL2);
		}
		if (sea.hasShips(tr2, bL2)) {
			return ans + getAns(sea, tr2, bL2);
		}
		return ans;
	}
	if (topRight[1] == bottomLeft[1]) {
		int[] tr1 = topRight;
		int[] bL1 = new int[] { (topRight[0] + bottomLeft[0]) / 2 + 1,
				topRight[1] };
		int[] tr2 = new int[] { (topRight[0] + bottomLeft[0]) / 2,
				topRight[1] };
		int[] bL2 = bottomLeft;
		int ans = 0;
		if (sea.hasShips(tr1, bL1)) {
			ans += getAns(sea, tr1, bL1);
		} else {
			return getAns(sea, tr2, bL2);
		}
		if (sea.hasShips(tr2, bL2)) {
			return ans + getAns(sea, tr2, bL2);
		}
		return ans;
	}
	int[] tr1 = topRight;
	int[] bL1 = new int[] { (topRight[0] + bottomLeft[0]) / 2 + 1,
			(topRight[1] + bottomLeft[1]) / 2 + 1 };
	int[] tr2 = new int[] { topRight[0],
			(topRight[1] + bottomLeft[1]) / 2  };
	int[] bL2 = new int[] { (topRight[0] + bottomLeft[0]) / 2 + 1,
			bottomLeft[1] };
	int[] tr3 = new int[] { (topRight[0] + bottomLeft[0]) / 2, topRight[1] };
	int[] bL3 = new int[] { bottomLeft[0],
			(topRight[1] + bottomLeft[1]) / 2+1 };
	int[] tr4 = new int[] { (topRight[0] + bottomLeft[0]) / 2,
			(topRight[1] + bottomLeft[1]) / 2 };
	int[] bL4 = bottomLeft;
	int ans = 0;
	if (sea.hasShips(tr1, bL1)) {
		ans += getAns(sea, tr1, bL1);
	}
	if (sea.hasShips(tr2, bL2)) {
		ans += getAns(sea, tr2, bL2);
	}
	if (sea.hasShips(tr3, bL3)) {
		ans += getAns(sea, tr3, bL3);
	}
	if (ans == 0) {
		return getAns(sea, tr4, bL4);
	}
	if (sea.hasShips(tr4, bL4)) {
		ans += getAns(sea, tr4, bL4);
	}
	return ans;
}