zoukankan      html  css  js  c++  java
  • [Swift]LeetCode395. 至少有K个重复字符的最长子串 | Longest Substring with At Least K Repeating Characters

    原文地址:https://www.cnblogs.com/strengthen/p/10303512.html 

    Find the length of the longest substring T of a given string (consists of lowercase letters only) such that every character in T appears no less than k times.

    Example 1:

    Input:
    s = "aaabb", k = 3
    
    Output:
    3
    
    The longest substring is "aaa", as 'a' is repeated 3 times. 

    Example 2:

    Input:
    s = "ababbc", k = 2
    
    Output:
    5
    
    The longest substring is "ababb", as 'a' is repeated 2 times and 'b' is repeated 3 times.

    找到给定字符串(由小写字符组成)中的最长子串 T , 要求 T 中的每一字符出现次数都不少于 k 。输出 的长度。

    示例 1:

    输入:
    s = "aaabb", k = 3
    
    输出:
    3
    
    最长子串为 "aaa" ,其中 'a' 重复了 3 次。
    

    示例 2:

    输入:
    s = "ababbc", k = 2
    
    输出:
    5
    
    最长子串为 "ababb" ,其中 'a' 重复了 2 次, 'b' 重复了 3 次。

    16ms
     1 class Solution {
     2     func longestSubstring(_ s: String, _ k: Int) -> Int {
     3         guard s.count > 0 else {
     4             return 0
     5         } 
     6         
     7         guard k > 0 else {
     8             return s.count
     9         }
    10         
    11         var result = Int.min
    12         var sArray = s.map{ String($0) }
    13         
    14         func splitString(string: [String]) {
    15             guard string.count > 0 else {
    16                 return
    17             }
    18             var memo = [String: Int]()
    19             var invalidChar = [String]()
    20             for i in 0..<string.count {
    21                 memo[string[i]] = memo[string[i], default:0] + 1
    22             }
    23 
    24             var candidates = [[String]]()
    25             var last = -1
    26             var i = 0
    27             while i < string.count  {
    28                 if memo[string[i]]! < k {
    29                     if i <= last + 1 {
    30                         last = i
    31                         i += 1
    32                         continue
    33                     } else {
    34                         candidates.append(Array(string[last + 1..<i]))
    35                         last = i
    36                     }
    37                 }
    38                 i += 1
    39             }
    40             
    41             if last < string.count - 1{
    42                 candidates.append(Array(string[last + 1..<string.count]))
    43             }
    44             
    45             if last == -1 {
    46                 result = max(string.count, result)
    47                 return
    48             }
    49             
    50             for c in candidates {
    51                 splitString(string:c)
    52             }
    53         }
    54         
    55         splitString(string:sArray)
    56         return result == Int.min ? 0 : result
    57     }
    58 }

    20ms

     1 class Solution {
     2     func longestSubstring(_ s: String, _ k: Int) -> Int {
     3         return helper(Array(s), 0, s.count, k)
     4     }
     5     
     6     func helper(_ s: [Character], _ left: Int, _ right: Int, _ k: Int) -> Int {
     7         guard right - left >= k else { return 0 }
     8         var counts = [Character: Int]()
     9         for char in s[left..<right] {
    10             counts[char] = (counts[char] ?? 0) + 1
    11         }
    12         
    13         for i in left..<right where counts[s[i]]! < k {
    14             var j = i + 1
    15             while j < right && counts[s[j]]! < k { j += 1 }
    16             return max(helper(s, left, i, k), helper(s, j, right, k))
    17         }
    18         return right - left
    19     }
    20 }

    52ms

     1 class Solution {
     2     func longestSubstring(_ s: String, _ k: Int) -> Int {
     3         var arr = Array(s)
     4         var cmap:[Character:Int] = [:]
     5         
     6         if s.length == 0 {
     7             return 0
     8         }
     9         
    10         for c in arr {
    11             if cmap[c] == nil {
    12                 cmap[c] = 0
    13             }
    14             cmap[c] = cmap[c]! + 1
    15         }
    16         
    17         var leastfreq = arr.count+1
    18         var leastfreqchar:Character? = nil
    19         for (letter, count) in cmap {
    20             if count < leastfreq {
    21                 leastfreq = count
    22                 leastfreqchar = letter
    23             }
    24         }
    25         
    26         if leastfreq >= k {
    27             return s.count
    28         }        
    29         
    30         var begin = 0
    31         var maxsofar = 0
    32         for i in 0...arr.count {
    33             if i == arr.count || arr[i] == leastfreqchar {
    34                 let tmp = Array(arr[begin..<i])
    35                 let tmps:String = String(tmp)
    36                 maxsofar = max(maxsofar, longestSubstring(tmps, k))
    37                 begin = i+1
    38             }
    39         }
    40         
    41         return maxsofar
    42     }
    43 }

    56ms

     1 class Solution {
     2     func longestSubstring(_ s: String, _ k: Int) -> Int {
     3         if k <= 1 { return s.count }
     4         
     5         let array = [Character](s)
     6         var dict = [Character: Int]()
     7         for c in array {
     8             if let count = dict[c] {
     9                 dict[c] = count + 1
    10             } else {
    11                 dict[c] = 1
    12             }
    13         }
    14         
    15         var result = 0
    16         var separator: Character? = nil
    17         for key in dict.keys {
    18             if let count = dict[key], count < k {
    19                 separator = key
    20                 break
    21             }
    22         }
    23         if let separator = separator {
    24             let subStringArray = s.components(separatedBy: String(separator))
    25             for subString in subStringArray {
    26                 let temp = longestSubstring(subString, k)
    27                 if temp > result {
    28                     result = temp
    29                 }
    30             }
    31         } else {
    32             return s.count
    33         }
    34         return result
    35     }
    36 }

    764ms

     1 class Solution {
     2     func longestSubstring(_ s: String, _ k: Int) -> Int {
     3       if s.count < k {
     4         return 0
     5     }
     6     var dict = [Character: Int]()
     7     var i = 0
     8     var j = 0
     9     let ss = Array(s)
    10     var maxLength = 0
    11     for k in s {
    12         dict[k] = (dict[k] ?? 0) + 1
    13     }
    14     let dict2 = dict.filter{$0.value < k}
    15     if dict2.count == 0 {
    16         return s.count
    17     }
    18     while j < s.count {
    19         if let d = dict2[ss[j]] {
    20             if d < k {
    21                 let start = s.index(s.startIndex, offsetBy: i)
    22                 let end = s.index(s.startIndex, offsetBy: j)
    23                 let range = start..<end
    24                 let subS = s[range]
    25                 maxLength = max(maxLength, longestSubstring(String(subS), k))
    26                 i = j + 1
    27             }
    28         }
    29         j += 1
    30     }
    31     let start = s.index(s.startIndex, offsetBy: i)
    32     let end = s.index(s.startIndex, offsetBy: j)
    33     let range = start..<end
    34     let subS = s[range]
    35     maxLength = max(maxLength, longestSubstring(String(subS), k))
    36     return maxLength
    37     }
    38 }

    948ms

     1 class Solution {
     2     func longestSubstring(_ s: String, _ k: Int) -> Int {
     3         var n:Int = s.count
     4         var max_idx:Int = 0
     5         var res:Int = 0     
     6         var m:[Int] = [Int](repeating:0,count: 128)
     7         var ok:Bool = true
     8         for c in s.characters
     9         {
    10             m[c.ascii] += 1
    11         }
    12         for i in 0..<n
    13         {
    14             if m[s[i].ascii] < k
    15             {
    16                 res = max(res, longestSubstring(s.subString(max_idx, i - max_idx), k))
    17                 ok = false
    18                 max_idx = i + 1
    19             }
    20         }
    21         return ok ? n : max(res, longestSubstring(s.subString(max_idx, n - max_idx), k)) 
    22     }
    23 }
    24 
    25 extension String {        
    26     //subscript函数可以检索数组中的值
    27     //直接按照索引方式截取指定索引的字符
    28     subscript (_ i: Int) -> Character {
    29         //读取字符
    30         get {return self[index(startIndex, offsetBy: i)]}
    31     }
    32     
    33     // 截取字符串:指定索引和字符数
    34     // - begin: 开始截取处索引
    35     // - count: 截取的字符数量
    36     func subString(_ begin:Int,_ count:Int) -> String {
    37         let start = self.index(self.startIndex, offsetBy: max(0, begin))
    38         let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
    39         return String(self[start..<end]) 
    40     }
    41 }
    42 
    43 //Character扩展方法  
    44 extension Character  
    45 {  
    46   //属性:ASCII整数值(定义小写为整数值)
    47    var ascii: Int {
    48         get {
    49             let s = String(self).unicodeScalars
    50             return Int(s[s.startIndex].value)
    51         }
    52     }
    53 }
  • 相关阅读:
    POJ 3630 Phone List | Trie 树
    POJ 3974 Palindrome | 马拉车模板
    POJ 3422 Kaka's Matrix Travels | 最小费用最大流
    POJ 2195 Going Home | 带权二分图匹配
    POJ 3068 "Shortest" pair of paths | 最小费用最大流
    POJ 3686 The Windy's | 最小费用最大流
    洛谷 最小费用最大流 模板 P3381
    POJ 2987 Firing | 最大权闭合团
    POJ 3469 Dual Core CPU | 最小割
    POJ 3281 Dining | 最大流
  • 原文地址:https://www.cnblogs.com/strengthen/p/10303512.html
Copyright © 2011-2022 走看看