LeetCode: 856 Score of Parentheses

Question

Given a balanced parentheses string S, compute the score of the string based on the following rule:
() has score 1
AB has score A + B, where A and B are balanced parentheses strings.
(A) has score 2 * A, where A is a balanced parentheses string.

Solution 1: Stack

class Solution {
    public int scoreOfParentheses(String S) {
    	Stack<Integer> stack = new Stack<>();
    	stack.push(0);
    	for (char c : S.toCharArray()) {
    		if (c == '(') { // depth + 1
    			stack.push(0);
    		} else {
    			int v = stack.pop();
    			int w = stack.pop();
    			// v is largest current depth, 
    			// w is previous depth
    			stack.push(w + Math.max(2*v, 1));
    		}
    	}
		return stack.pop();
    }
}

Note 1 :

The depth of a position in the string means the number of matching parentheses surrounding it.
Our goal is to maintain the score at the current depth we are on. When we see an opening bracket, we increase our depth, and our score at the new depth is 0. When we see a closing bracket, we add twice the score of the previous deeper part - except when counting (), which has a score of 1.

Time-Complexity

O(N)

Solution 2: without stack

class Solution {
    public int scoreOfParentheses(String S) {
    	int res = 0, depth = 0;
    	for (int i = 0; i < S.length(); i++) {
    		if(S.charAt(i) == '(') {
    			depth++;
    		} else { // when  char == ')'
    			depth--;
    			if (S.charAt(i-1) == '(') {
    				int multiplier = 1 << depth;
    				res = res + multiplier;
    			}
    		}
    	}
    	return res;
    }
}

Note:

The second solution is similar to the first one, but the difference is that it doesn’t use stack but an integer.