[Swift]LeetCode943. 最短超级串 | Find the Shortest Superstring

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

Given an array A of strings, find any smallest string that contains each string in A as a substring.

We may assume that no string in A is substring of another string in A.

Example 1:

Input: ["alex","loves","leetcode"]
Output: "alexlovesleetcode"
Explanation: All permutations of "alex","loves","leetcode" would also be accepted.

Example 2:

Input: ["catg","ctaagt","gcta","ttca","atgcatc"]
Output: "gctaagttcatgcatc"

Note:

1. 1 <= A.length <= 12
2. 1 <= A[i].length <= 20

---

给定一个字符串数组 A，找到以 A 中每个字符串作为子字符串的最短字符串。

我们可以假设 A 中没有字符串是 A 中另一个字符串的子字符串。

示例 1：

输入：["alex","loves","leetcode"]
输出："alexlovesleetcode"
解释："alex"，"loves"，"leetcode" 的所有排列都会被接受。

示例 2：

输入：["catg","ctaagt","gcta","ttca","atgcatc"]
输出："gctaagttcatgcatc"

提示：

1. 1 <= A.length <= 12
2. 1 <= A[i].length <= 20

---

 100ms

class Solution {
    func countSubstr(_ A: [String], _ n: String) -> Int {
      var sum = 0
      for var s in A {
        if n.contains(s) {
          sum += s.count
        }
      }
      return sum
    }
    func shortestSuperstring(_ Ain: [String]) -> String {
        var A = Ain
        while A.count > 1 {
          var maxC = 0
          var newStr = ""
          for var i in 0..<A.count {
            for var j in 0..<A.count {
              guard i != j else {
                continue
              } 
              if A[i].count == 1 { continue }
              for var l in 1...A[i].count-1 {
                if A[j].hasPrefix(A[i].suffix(l)) {
                  let n = A[i] + A[j].suffix(A[j].count - l)
                  let C = countSubstr(A, n) - n.count
                  if C > maxC {
                    maxC = C
                    newStr = n
                  }
                }
              }
            }
          }
          if maxC == 0 {
            newStr = A[0] + A[1]
          }
          A.removeAll(where: { newStr.contains($0) })
          A.append(newStr)
        }
        return A[0]
    }
}

extension String { 
   func contains(_ find: String) -> Bool{
     return self.range(of: find) != nil
   }
}

---

364ms

class Solution {
    func shortestSuperstring(_ A: [String]) -> String {
        var N:Int = A.count
        
        // Populate overlaps
        var overlaps:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:N),count:N)
        for i in 0..<N
        {
            for j in 0..<N
            {
                if i != j
                {
                    var m:Int = min(A[i].count, A[j].count)
                    for k in (0...m).reversed()
                    {
                        if A[i].hasSuffix(A[j].substring(0, k))
                        {
                            overlaps[i][j] = k
                            break
                        }
                    }
                }
            }
        }
        // dp[mask][i] = most overlap with mask, ending with ith element
        var dp:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:N),count:1<<N)
        var parent:[[Int]] = [[Int]](repeating:[Int](repeating:-1,count:N),count:1<<N)
        for mask in 0..<(1<<N)
        {
            for bit in 0..<N
            {
                if ((mask >> bit) & 1) > 0
                {
                    // Let's try to find dp[mask][bit].  Previously, we had
                    // a collection of items represented by pmask.
                    var pmask:Int = mask ^ (1 << bit)
                    if pmask == 0 {continue}
                    for i in 0..<N
                    {
                        if ((pmask >> i) & 1) > 0
                        {
                            // For each bit i in pmask, calculate the value
                            // if we ended with word i, then added word 'bit'.
                            var val:Int = dp[pmask][i] + overlaps[i][bit]
                            if val > dp[mask][bit]
                            {
                                dp[mask][bit] = val
                                parent[mask][bit] = i
                            }
                        }
                    }  
                }
            }
        }
        // # Answer will have length sum(len(A[i]) for i) - max(dp[-1])
        // Reconstruct answer, first as a sequence 'perm' representing
        // the indices of each word from left to right.
        var perm:[Int] = [Int](repeating:0,count:N)
        var seen:[Bool] = [Bool](repeating:false,count:N)
        var t:Int = 0
        var mask:Int = (1 << N) - 1
        
        // p: the last element of perm (last word written left to right)
        var p:Int = 0
        for j in 0..<N
        {
            if dp[(1<<N) - 1][j] > dp[(1<<N) - 1][p]
            {
                p = j
            }
        }
        
        // Follow parents down backwards path that retains maximum overlap
        while (p != -1)
        {
            perm[t] = p
            t += 1
            seen[p] = true
            var p2:Int = parent[mask][p]
            mask ^= 1 << p
            p = p2
        }        
        
        // Reverse perm
        for i in 0..<(t/2)
        {
            var v:Int = perm[i]
            perm[i] = perm[t-1-i]
            perm[t-1-i] = v
        }
        
        // Fill in remaining words not yet added
        for i in 0..<N
        {
            if !seen[i]
            {
                perm[t] = i
                t += 1
            }
        }
        
        // Reconstruct final answer given perm
        var ans:String = String(A[perm[0]])
        for i in 1..<N
        {
            var overlap:Int = overlaps[perm[i-1]][perm[i]]
            ans.append(A[perm[i]].substring(overlap))
        }
        return ans
    }
}

extension String {    
// 截取字符串：从index到结束处
    // - Parameter index: 开始索引
    // - Returns: 子字符串
    func substring(_ index: Int) -> String {
        let theIndex = self.index(self.endIndex, offsetBy: index - self.count)
        return String(self[theIndex..<endIndex])
    }
    
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func substring(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
}