[Swift]LeetCode1111. 有效括号的嵌套深度 | Maximum Nesting Depth of Two Valid Parentheses Strings

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：http://www.javashuo.com/article/p-ughouwtm-ky.html 
➤若是连接不是山青咏芝的博客园地址，则多是爬取做者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持做者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

A string is a valid parentheses string (denoted VPS) if and only if it consists of "(" and ")" characters only, and:

• It is the empty string, 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 seq, split it into two disjoint subsequences A and B, such that A and B are VPS's (and A.length + B.length = seq.length).

Now choose any such A and B such that max(depth(A), depth(B)) is the minimum possible value.

Return an answer array (of length seq.length) that encodes such a choice of A and B:  answer[i] = 0 if seq[i] is part of A, else answer[i] = 1.  Note that even though multiple answers may exist, you may return any of them. 

Example 1:

Input: seq = "(()())"
Output: [0,1,1,1,1,0]

Example 2:

Input: seq = "()(())()"
Output: [0,0,0,1,1,0,1,1] 

Constraints:

• 1 <= text.size <= 10000

---

有效括号字符串 仅由 "(" 和 ")" 构成，并符合下述几个条件之一：

• 空字符串
• 链接，能够记做 AB（A 与 B 链接），其中 A 和 B 都是有效括号字符串
• 嵌套，能够记做 (A)，其中 A 是有效括号字符串

相似地，咱们能够定义任意有效括号字符串 s 的 嵌套深度 depth(S)：

• s 为空时，depth("") = 0
• s 为 A 与 B 链接时，depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是有效括号字符串
• s 为嵌套状况，depth("(" + A + ")") = 1 + depth(A)，其中 A 是有效括号字符串

例如：""，"()()"，和 "()(()())" 都是有效括号字符串，嵌套深度分别为 0，1，2，而 ")(" 和 "(()" 都不是有效括号字符串。 

给你一个有效括号字符串 seq，将其分红两个不相交的子序列 A 和 B，且 A 和 B 知足有效括号字符串的定义（注意：A.length + B.length = seq.length）。

如今，你须要从中选出 任意 一组有效括号字符串 A 和 B，使 max(depth(A), depth(B)) 的可能取值最小。

返回长度为 seq.length 答案数组 answer ，选择 A 仍是 B 的编码规则是：若是 seq[i] 是 A 的一部分，那么 answer[i] = 0。不然，answer[i] = 1。即使有多个知足要求的答案存在，你也只需返回 一个。 

示例 1：

输入：seq = "(()())"
输出：[0,1,1,1,1,0]

示例 2：

输入：seq = "()(())()"
输出：[0,0,0,1,1,0,1,1] 

提示：

• 1 <= text.size <= 10000

---

24ms

 1 class Solution {
 2     func maxDepthAfterSplit(_ seq: String) -> [Int] {
 3         let N = seq.count 
 4         var chars = Array(seq)
 5         var result = [Int](repeating:0, count: N)
 6         for i in 0..<N {
 7             result[i] = (chars[i] == "(") ? (i & 1) : (1 - i & 1)
 8         }
 9         return result
10     }
11 }

---

Runtime: 32 ms

Memory Usage: 21.4 MB

 1 class Solution {
 2     func maxDepthAfterSplit(_ seq: String) -> [Int] {
 3         let n:Int = seq.count
 4         var levels:[Int] = [Int](repeating:0,count:n + 1)
 5         let arrSeq:[Character] = Array(seq)
 6         for i in 0..<n
 7         {
 8             let num:Int = arrSeq[i] == "(" ? +1 : -1
 9             levels[i + 1] = levels[i] + num
10         }
11         let max_level:Int = levels.max()!
12         let half:Int = max_level / 2
13         var answer:[Int] = [Int](repeating:0,count:n)
14         for i in 0..<n
15         {
16             answer[i] = min(levels[i], levels[i + 1]) < half ? 1 : 0
17         }
18         return answer
19     }
20 }

---

32ms 

1 class Solution {
2     func maxDepthAfterSplit(_ seq: String) -> [Int] {
3         var arr = [Int]()
4         for i in 0..<seq.length {
5             arr.append(1)
6         }
7         return arr
8     }
9 }