leetcode 1007 Minimum Domino Rotations For Equal Row & leetcode 1008 Construct Binary Search Tree from Preorder Traversal
leetcode 1007 Minimum Domino Rotations For Equal Row
Use three int array of size 6
The first one invalid array records valid(or invalid) numbers which can be the same in A or B
the rest two records the count of valid numbers in A and B
class Solution {
public int minDominoRotations(int[] A, int[] B) {
int N = A.length;
if (N != B.length) return -1;
int[] invalid = new int[6];
int[] ac = new int[6];
int[] bc = new int[6];
for (int i = 0; i < N; ++i) {
for (int j = 1; j <= 6; ++j) {
//find invalid numbers
if (A[i] != j && B[i] != j) invalid[j - 1] = 1;
}
//for valid number, record A's count and B's count
if (invalid[A[i] - 1] == 0) ac[A[i] - 1] += 1;
if (invalid[B[i] - 1] == 0) bc[B[i] - 1] += 1;
}
int ret = 20001;
for (int i = 0; i < 6; ++i) {
if (invalid[i] == 1) continue;
ret = Math.min(ret, Math.min(N - ac[i], N - bc[i]));
}
return ret == 20001? -1: ret;
}
}
leetcode 1008 Construct Binary Search Tree from Preorder Traversal
Non-recursive solution, I first came up with the below solution
class Solution {
public TreeNode bstFromPreorder(int[] preorder) {
TreeNode root = new TreeNode(preorder[0]);
Stack<TreeNode> s = new Stack<TreeNode>();
s.push(root);
for (int i = 1; i < preorder.length; ++i) {
TreeNode node = s.peek();
if (preorder[i] < node.val) {
node.left = new TreeNode(preorder[i]);
s.push(node.left);
}
else {
s.pop();
while (s.size() != 0 && s.peek().val < preorder[i]) {
node = s.pop();
}
node.right = new TreeNode(preorder[i]);
s.push(node.right);
}
}
return root;
}
}
But the code seemed a little weird, especially in the else code block. So with some modification it seemed much better.
class Solution {
public TreeNode bstFromPreorder(int[] preorder) {
TreeNode root = new TreeNode(preorder[0]);
Stack<TreeNode> s = new Stack<TreeNode>();
TreeNode node = root;
for (int i = 1; i < preorder.length; ++i) {
if (preorder[i] < node.val) {
node.left = new TreeNode(preorder[i]);
s.push(node);
node = node.left;
}
else {
while (s.size() != 0 && s.peek().val < preorder[i]) {
node = s.pop();
}
node.right = new TreeNode(preorder[i]);
node = node.right;
}
}
return root;
}
}
I figured out the non-recursive version really quick, but after that I spent quite some time trying the recursive version and failed….
I'll come back to post the recursive version when finishing it.