A string is a **valid parentheses string** (denoted **VPS**) if it meets one of the following:

- It is an empty string "", or a single character not equal to "(" or ")",
- It can be written as AB (A concatenated with B), where A and B are
**VPS**'s, or - It can be written as (A), where A is a
**VPS**.

We can similarly define the **nesting depth** depth(S) of any VPS S as follows:

- depth("") = 0
- depth(A + B) = max(depth(A), depth(B)), where A and B are
**VPS**'s - depth("(" + A + ")") = 1 + depth(A), where A is a
**VPS**.

For example, "", "()()", and "()(()())" are **VPS**'s (with nesting depths 0, 1, and 2), and ")(" and "(()" are not **VPS**'s.

Given a **VPS** represented as string s, return *the **nesting depth** of *s.

Input:s = "(1+(2*3)+((8)/4))+1"Output:3Explanation:Digit 8 is inside of 3 nested parentheses in the string.

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

Input:s = "1+(2*3)/(2-1)"Output:1

Input:s = "1"Output:0

- 1 <= s.length <= 100
- s consists of digits 0-9 and characters '+', '-', '*', '/', '(', and ')'.
- It is guaranteed that parentheses expression s is a
**VPS**.

Solution:

class Solution { /* depth("") = 0 depth(A + B) = max(depth(A), depth(B)), where A and B are VPS's depth("(" + A + ")") = 1 + depth(A), where A is a VPS. */ public int maxDepth(String s) { int left = 0, max = 0; for (int i = 0; i < s.length(); i ++) { char c = s.charAt(i); if (c == '(') { left ++; max = Math.max(max, left); } if (c == ')') { left --; } } return max; } }