[Swift]LeetCode1044. 最长重复子串 | Longest Duplicate Substring

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

Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times.  (The occurrences may overlap.)

Return any duplicated substring that has the longest possible length.  (If S does not have a duplicated substring, the answer is "".)

Example 1:

Input: "banana"
Output: "ana"

Example 2:

Input: "abcd"
Output: ""

Note:

1. 2 <= S.length <= 10^5
2. S consists of lowercase English letters.

---

给出一个字符串 S，考虑其所有重复子串（S 的连续子串，出现两次或多次，可能会有重叠）。

返回任何具有最长可能长度的重复子串。（如果 S 不含重复子串，那么答案为 ""。）

示例 1：

输入："banana"
输出："ana"

示例 2：

输入："abcd"
输出：""

提示：

1. 2 <= S.length <= 10^5
2. S 由小写英文字母组成。

---

Runtime: 356 ms

Memory Usage: 27.3 MB

class Solution {
    func longestDupSubstring(_ S: String) -> String {
        var sa:[Int] = suffixArray(Array(S), 26)
        let n:Int = S.count
        var lcp:[Int] = buildLCP(Array(S), sa)
        var isa:[Int] = [Int](repeating:0,count:n)
        for i in 0..<n {isa[sa[i]] = i}
        var max:Int = 0
        var arg:Int = -1
        for i in 1..<n
        {
            if lcp[i] > max
            {
                max = lcp[i]
                arg = i
            }
        }
        if arg == -1 {return String()}
        return S.subString(sa[arg], max + 1)
    }
    
    func buildLCP(_ str:[Character],_ sa:[Int]) -> [Int]
    {
        let n:Int = str.count
        var h:Int = 0
        var lcp:[Int] =  [Int](repeating:0,count:n)
        var isa:[Int] = [Int](repeating:0,count:n)
        for i in 0..<n {isa[sa[i]] = i}
        for i in 0..<n
        {
            if isa[i] > 0
            {
                let j:Int = sa[isa[i] - 1]
                while(j+h < n && i+h < n && str[j+h] == str[i+h])
                {
                    lcp[isa[i]] = h
                    h += 1
                }
            }
            else
            {
                lcp[isa[i]] = 0
            }
            if h > 0 {h -= 1}
        }
        return lcp
    }
    
    func suffixArray(_ str:[Character],_ W:Int) -> [Int]
    {
        let n:Int = str.count
        if n <= 1 {return [Int](repeating:0,count:n)}
        var sa:[Int] = [Int](repeating:0,count:n)
        var s:[Int] = [Int](repeating:0,count:n + 3)
        for i in 0..<n
        {
            s[i] = str[i].ascii - 96
        }
        suffixArray(s, &sa, n, W+1)
        return sa
    }
    
    func suffixArray(_ s:[Int],_ sa:inout [Int],_ n:Int,_ K:Int)
    {
        let n0:Int = (n+2)/3
        let n1:Int = (n+1)/3
        let n2:Int = n/3
        let n02:Int = n0 + n2
        
        var s12:[Int] = [Int](repeating:0,count:n02 + 3)
        var sa12:[Int] = [Int](repeating:0,count:n02 + 3)
        var s0:[Int] = [Int](repeating:0,count:n0)
        var sa0:[Int] = [Int](repeating:0,count:n0)
        
        // generate positions of mod 1 and mod 2 suffixes
        // the "+(n0-n1)" adds a dummy mod 1 suffix if n%3 == 1
        let sup:Int = n + (n0 - n1)
        var i1:Int = 0
        var j1:Int = 0
        while(i1 < sup)
        {
            if i1 + 1 < sup {
                s12[j1] = i1 + 1
                 j1 += 1
            }
            if i1 + 2 < sup {
                s12[j1] = i1 + 2
                 j1 += 1
            }
            i1 += 3
        }
        
        // lsb radix sort the mod 1 and mod 2 triples
        radixPass(s12, &sa12, s, 2, n02, K)
        radixPass(sa12, &s12, s, 1, n02, K)
        radixPass(s12, &sa12, s, 0, n02, K)
        
        // find lexicographic names of triples
        var name:Int = 0
        var c0:Int = -1
        var c1:Int = -1
        var c2:Int = -1
        
        for i in 0..<n02
        {
            if s[sa12[i]] != c0 || s[sa12[i]+1] != c1 || s[sa12[i]+2] != c2
            {
                name += 1
                c0 = s[sa12[i]]
                c1 = s[sa12[i]+1]
                c2 = s[sa12[i]+2]
            }
            if sa12[i] % 3 == 1
            {
                // left half
                s12[sa12[i]/3] = name
            }
            else
            {
                // right half
                s12[sa12[i]/3 + n0] = name
            }
        }
        
        // recurse if names are not yet unique
        if name < n02
        {
            suffixArray(s12, &sa12, n02, name)
            // store unique names in s12 using the suffix array
            for i in 0..<n02
            {
                s12[sa12[i]] = i + 1
            }
        }
        else
        {
            // generate the suffix array of s12 directly
            for i in 0..<n02
            {
                sa12[s12[i]-1] = i
            }
        }
        
        // stably sort the mod 0 suffixes from sa12 by their first character
        var i2:Int = 0
        var j2:Int = 0
        while(i2 < n02)
        {
            if sa12[i2] < n0
            {
                s0[j2] = 3 * sa12[i2]
                j2 += 1
            }
            i2 += 1
        }
        radixPass(s0, &sa0, s, 0, n0, K)
        
        // merge sorted sa0 suffixes and sorted sa12 suffixes
        var p:Int = 0
        var t:Int = n0 - n1
        var k:Int = 0
        while(k < n)
        {
            // pos of current offset 12 suffix
            let i:Int = sa12[t] < n0 ? sa12[t] * 3 + 1 : (sa12[t] - n0) * 3 + 2
            // pos of current offset 0 suffix
            let j:Int = sa0[p]
            if sa12[t] < n0 ?
                (s[i] < s[j] || s[i] == s[j] && s12[sa12[t]+n0] <= s12[j/3]) :
                (s[i] < s[j] || s[i] == s[j] && (s[i+1] < s[j+1] || s[i+1] == s[j+1] && s12[sa12[t]-n0+1] <= s12[j/3+n0]))
            {
                // suffix from a12 is smaller
                sa[k] = i
                t += 1
                if t == n02
                {
                    // done --- only sa0 suffixes left
                    k += 1
                    while(p < n0)
                    {
                        sa[k] = sa0[p]
                        p += 1
                        k += 1
                    }
                }
            }
            else
            {
                // suffix from sa0 is smaller
                sa[k] = j
                p += 1
                if p == n0
                {
                    // done --- only sa12 suffixes left
                    k += 1
                    while(t < n02)
                    {
                        sa[k] = sa12[t] < n0 ? sa12[t] * 3 + 1 : (sa12[t] - n0) * 3 + 2
                        t += 1
                        k += 1
                    }
                }
            }
            k += 1
        }
    }
    
    func radixPass(_ a:[Int],_ b:inout [Int],_ r:[Int],_ l:Int,_ n:Int,_ K:Int)
    {
        // counter array
        var c:[Int] = [Int](repeating:0,count:K + 1)
        for i in 0..<n
        {
            // count occurrences
            c[r[l + a[i]]] += 1
        }
        var i:Int = 0
        var sum:Int = 0
        while(i <= K)
        {
            // exclusive prefix sums
            let t:Int = c[i]
            c[i] = sum
            sum += t
            i += 1
        }
        for i in 0..<n
        {
            b[c[r[l + a[i]]]] = a[i]
            c[r[l + a[i]]] += 1
        }
    }
}

//Character扩展
extension Character
{
    //Character转ASCII整数值(定义小写为整数值)
    var ascii: Int {
        get {
            return Int(self.unicodeScalars.first?.value ?? 0)
        }
    }
}

extension String {
    // 截取字符串：指定索引和字符数
    // - 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])
    }
}