[Swift]LeetCode942. 增减字符串匹配 | DI String Match

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9977759.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a string S that only contains "I" (increase) or "D" (decrease), let N = S.length.

Return any permutation A of [0, 1, ..., N] such that for all i = 0, ..., N-1:

• If S[i] == "I", then A[i] < A[i+1]
• If S[i] == "D", then A[i] > A[i+1]

 Example 1:

Input: "IDID"
Output: [0,4,1,3,2]

Example 2:

Input: "III"
Output: [0,1,2,3]

Example 3:

Input: "DDI"
Output: [3,2,0,1]

 Note:

1. 1 <= S.length <= 10000
2. S only contains characters "I" or "D".

---

给定只含 "I"（增大）或 "D"（减小）的字符串 S ，令 N = S.length。

返回 [0, 1, ..., N] 的任意排列 A 使得对于所有 i = 0, ..., N-1，都有：

• 如果 S[i] == "I"，那么 A[i] < A[i+1]
• 如果 S[i] == "D"，那么 A[i] > A[i+1]

示例 1：

输出："IDID"
输出：[0,4,1,3,2]

示例 2：

输出："III"
输出：[0,1,2,3]

示例 3：

输出："DDI"
输出：[3,2,0,1]

提示：

1. 1 <= S.length <= 1000
2. S 只包含字符 "I" 或 "D"。

---

68ms

class Solution {
    func diStringMatch(_ S: String) -> [Int] {
      let N = S.count
      var min = 0
      var max = N
      
      var res : [Int] = []
      
      for c in S {
        if c == "I" {
          res.append(min)
          min += 1
        } else if c == "D" {
          res.append(max)
          max -= 1
        }
      }
      assert(min == max);
      res.append(min)
      
      return res
    }
}

---

84ms

class Solution {
    func diStringMatch(_ S: String) -> [Int] {
        let array = Array(0...S.count)
        
        var left = 0
        var right = S.count
        
        var result = [Int]()
        for char in S {
            if char == "I" {
                result.append(array[left])
                left += 1
            } else if char == "D" {
                result.append(array[right])
                right -= 1
            }
        }
        result.append(array[left])
        
        return result
    }
}

---

88ms

class Solution {
    func diStringMatch(_ S: String) -> [Int] {
        
        var out:[Int] = []
        
        var i = 0
        var d = S.count
        
        for c in S {
            
            if c == "I" {
                
                out.append(i)
                i += 1
                
            } else {
                out.append(d)
                d -= 1
            }
            
        }
        
        if S.last! == "I" {
             out.append(i)
                i += 1
        } else {
            out.append(d)
                d -= 1
        }
        
        return out
    }
}

---

120ms

class Solution {
    func diStringMatch(_ S: String) -> [Int] {
        var arr:[Int] = []
        var min = -1, max = S.count + 1
        for c in S {
            if c == "I" {
                min+=1
                arr.append(min)
            } else {
                max-=1
                arr.append(max)
            }
        }
        arr.append(min+1)
        return arr
    }
}

---

312ms

class Solution {
    
    struct HeapElement {
        let idx: Int
        let value: Int
        init(_ idx: Int, _ value: Int) {
            self.idx = idx
            self.value = value
        }
    }
    
    func diStringMatch(_ S: String) -> [Int] {
        let N = S.count
        var heap: [HeapElement] = [HeapElement(0,0)]
        var prevValue = 0
        var idx = 1
        for ch in S {
            if ch == "I" {
                prevValue += 1
            } else {
                prevValue -= 1
            }
            heap.append(HeapElement(idx, prevValue))
            var curInd = heap.count - 1
            while heap[curInd].value < heap[(curInd - 1) / 2].value && curInd > 0 {
                let parentInd = (curInd - 1) / 2
                heap.swapAt(curInd, parentInd)
                curInd = parentInd
            }
            idx += 1
        }
        
        var result: [Int] = Array(repeating: 0, count: N + 1)
        prevValue = 0
        while !heap.isEmpty {
            heap.swapAt(0, heap.count - 1)
            let element = heap.removeLast()
            result[element.idx] = prevValue
            prevValue += 1
            var curInd = 0
            while (2*curInd + 1 < heap.count && heap[curInd].value > heap[2*curInd + 1].value) || 
            (2*curInd + 2 < heap.count && heap[curInd].value > heap[2*curInd + 2].value) {
                var childInd = 2*curInd + 1
                if 2*curInd + 2 < heap.count {
                    if heap[childInd].value > heap[2*curInd + 2].value {
                        childInd = 2*curInd + 2
                    }
                }
                heap.swapAt(curInd, childInd)
                curInd = childInd
            }
        }
        return result
    }
}

---

2096ms

class Solution {
    func diStringMatch(_ S: String) -> [Int] {
        var n:Int = S.count + 1
        var ret:[Int] = [Int](repeating: 0,count: n)
        var v:Int = n - 1
        var pre:Int = 0
        for i in 0..<(n - 1)
        {
            if S[i] == "D"
            {
                for j in (pre...i).reversed()
                {
                    ret[j] = v
                    v -= 1
                }
                pre = i + 1
            }
        }
        for j in (pre...(n - 1)).reversed()
        {
            ret[j] = v
            v -= 1
        }
        return ret
    }
}

extension String {
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
    }
}