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.