class Solution {
    
    private TreeNode root;
    
    private HashMap<Integer, TreeNode> map;
    
    public TreeNode buildTree(int[] inorder, int[] postorder) 
    {
        if(inorder.length == 0 || postorder.length == 0)
        {
            return null;
        }
        map = new HashMap<Integer, TreeNode>();
        ArrayList<Integer> in = new ArrayList<Integer>();
        for(int i = 0; i < inorder.length; i++)
        {
            map.put(inorder[i], new TreeNode(inorder[i]));
            in.add(inorder[i]);
        }
        ArrayList<Integer> p = new ArrayList<Integer>();
        for(int i = 0; i < postorder.length; i++)
        {
            p.add(postorder[i]);
        }
        p.remove(p.size() - 1);
        root = map.get(postorder[postorder.length - 1]);
        helper(root, in, p);
        return root;
        
    }
    
    public void helper(TreeNode node, ArrayList<Integer> inorder, ArrayList<Integer> postorder)
    {
        if(inorder.size() == 0)
        {
            return;
        }
        ArrayList<Integer> potentialLeft = new ArrayList<Integer>();
        ArrayList<Integer> potentialRight = new ArrayList<Integer>();
        int temp = -1;
        for(int i = 0; i < inorder.size(); i++)
        {
            if(inorder.get(i) == node.val)
            {
                temp = i;
                break;
            }
        }
        potentialLeft = new ArrayList<Integer>(inorder.subList(0, temp));
        potentialRight =  new ArrayList<Integer>(inorder.subList(temp + 1, inorder.size()));
        int leftNode = Integer.MAX_VALUE;
        int rightNode = Integer.MAX_VALUE;
        boolean left = false;
        boolean right = false;
        for(int j = postorder.size() - 1; j >= 0; j--)
        {
            if(potentialLeft.contains(postorder.get(j)) && !left)
            {
                leftNode = postorder.get(j);
                left = true;
            }
            if(potentialRight.contains(postorder.get(j)) && !right)
            {
                rightNode = postorder.get(j);
                right = true;
            }
            if(left && right)
            {
                break;
            }
        }

        if(leftNode != Integer.MAX_VALUE)
        {
            node.left = map.get(leftNode);
            helper(node.left, potentialLeft, postorder);
        }
        if(rightNode != Integer.MAX_VALUE)
        {
            node.right = map.get(rightNode); 
            helper(node.right, potentialRight, postorder);
        }
    }
}