Given a balanced parentheses string S
, compute the score of the string based on the following rule:
()
has score 1AB
has scoreA + B
, where A and B are balanced parentheses strings.(A)
has score2 * A
, where A is a balanced parentheses string.
Example 1:
Input: "()" Output: 1
Example 2:
Input: "(())" Output: 2
Example 3:
Input: "()()" Output: 2
Example 4:
Input: "(()(()))" Output: 6
Note:
S
is a balanced parentheses string, containing only(
and)
.2 <= S.length <= 50
// OJ: https://leetcode.com/problems/score-of-parentheses/
// Author: github.com/lzl124631x
// Time: O(N^2)
// Space: O(N^2)
class Solution {
public:
int scoreOfParentheses(string S) {
if (S == "()") return 1;
int i = 0, left = 0;
do {
left += S[i++] == '(' ? 1 : -1;
} while (left);
if (i == S.size()) return 2 * scoreOfParentheses(S.substr(1, S.size() - 2));
return scoreOfParentheses(S.substr(0, i)) + scoreOfParentheses(S.substr(i));
}
};
Same idea as Solution 1, but more space efficient.
// OJ: https://leetcode.com/problems/score-of-parentheses/
// Author: github.com/lzl124631x
// Time: O(N^2)
// Space: O(N)
class Solution {
private:
int score(string &S, int begin, int end) {
if (begin + 2 == end) return 1;
int i = begin, left = 0;
do {
left += S[i++] == '(' ? 1 : -1;
} while (left);
if (i == end) return 2 * score(S, begin + 1, end - 1);
return score(S, begin, i) + score(S, i, end);
}
public:
int scoreOfParentheses(string S) {
return score(S, 0, S.size());
}
};
// OJ: https://leetcode.com/problems/score-of-parentheses/solution/
// Author: github.com/lzl124631x
// Time: O(N)
// Space: O(N)
class Solution {
int dfs(string &s, int &i) {
int ans = 0;
while (i < s.size() && s[i] == '(') {
if (i + 1 < s.size() && s[i + 1] == ')') {
i += 2;
++ans;
} else {
++i;
ans += 2 * dfs(s, i);
++i;
}
}
return ans;
}
public:
int scoreOfParentheses(string s) {
int i = 0;
return dfs(s, i);
}
};
// OJ: https://leetcode.com/problems/score-of-parentheses/
// Author: github.com/lzl124631x
// Time: O(N)
// Space: O(N)
class Solution {
public:
int scoreOfParentheses(string s) {
stack<int> st;
st.push(0);
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '(') {
if (i + 1 < s.size() && s[i + 1] == ')') {
++i;
st.top()++;
} else st.push(0);
} else {
int val = 2 * st.top();
st.pop();
st.top() += val;
}
}
return st.top();
}
};
Or
// OJ: https://leetcode.com/problems/score-of-parentheses/
// Author: github.com/lzl124631x
// Time: O(N)
// Space: O(N)
class Solution {
public:
int scoreOfParentheses(string s) {
stack<int> st;
st.push(0);
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '(') st.push(0);
else {
int val = max(2 * st.top(), 1);
st.pop();
st.top() += val;
}
}
return st.top();
}
};
// OJ: https://leetcode.com/problems/score-of-parentheses/
// Author: github.com/lzl124631x
// Time: O(N)
// Space: O(1)
// Ref: https://leetcode.com/problems/score-of-parentheses/solution/
class Solution {
public:
int scoreOfParentheses(string S) {
int ans = 0, depth = 0;
for (int i = 0; i < S.size(); ++i) {
if (S[i] == '(') ++depth;
else {
--depth;
if (i - 1 >= 0 && S[i - 1] == '(') ans += 1 << depth;
}
}
return ans;
}
};