Maximum nesting depth of parentheses

1614. Maximum nesting depth of parentheses

The difficulty is simple 105

If the string meets one of the following conditions , It can be called Valid bracket string **（valid parentheses string**, I could just write it as VPS）：

• The string is an empty string "", Or a not for "(" or ")" The single character of .
• The string can be written as AB（A And B String connection ）, among A and B All are Valid bracket string .
• The string can be written as (A), among A It's a Valid bracket string .

Similarly , You can define any valid parenthesis string S Of Nesting depth depth(S)：

• depth("") = 0
• depth(C) = 0, among C Is a single character string , And the character is not "(" perhaps ")"
• depth(A + B) = max(depth(A), depth(B)), among A and B All are Valid bracket string
• depth("(" + A + ")") = 1 + depth(A), among A It's a Valid bracket string

for example ：""、"()()"、"()(()())" All are Valid bracket string （ The nesting depth is 0、1、2）, and ")(" 、"(()" Are not Valid bracket string .

To give you one Valid bracket string s, Returns the of the string s Nesting depth .

Example 1：

 Input ：s = "(1+(2*3)+((8)/4))+1"
 Output ：3
 explain ： Numbers  8  In the nested  3  Layer in parentheses .

Example 2：

 Input ：s = "(1)+((2))+(((3)))"
 Output ：3

Tips ：

• 1 <= s.length <= 100
• s By digital 0-9 And character '+'、'-'、'*'、'/'、'('、')' form
• Title Data guarantee bracket expression s yes Valid parenthesis expression

---

Ideas ：

For bracketed calculation questions , We can often think with stacks .

Traversal string ss, If you encounter an open parenthesis , Then put it on the stack ; If you encounter a right parenthesis , Then pop up the left bracket at the top of the stack , Match the closing bracket . The maximum stack size in this process , That is to say ss The nesting depth of .

When the code is implemented , Because we only need to consider the stack size , We can use a variable size Indicates the size of the stack , When you encounter an open parenthesis, add one , When you encounter a right parenthesis, subtract it by one , Thus, it indicates the change of elements in the stack . In the process size The maximum value of is ss The nesting depth of .

class Solution {
    
public:
    int maxDepth(string s) {
    
        int tmp = 0;
        int size = 0;
        int n = s.size();
        for(int i = 0; i < n; ++i)
        {
    
            if(s[i] == '(')
            {
    
                size++;
            }
            else if(s[i] == ')')
            {
    
                size--;
            }
            tmp = max(tmp, size);
        }
        return tmp;
    }
};