2020.7.12

剑指 Offer 29. 顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

 func spiralOrder(_ matrix: [[Int]]) -> [Int] {
   		if matrix.count == 0 {
            return [Int]()
        }
        var left = 0, right = matrix[0].count - 1
        var top = 0, bottom = matrix.count - 1
        var result = [Int]()
        
          while left <= right && top <= bottom {
            for i in left...right {
                result.append(matrix[top][i])
            }
            top += 1
            if top > bottom {
                break
            }
            for i in top...bottom {
                result.append(matrix[i][right])
            }
            right -= 1
            if right < left {
                break
            }
            for i in (left...right).reversed() {
                result.append(matrix[bottom][i])
            }
            bottom -= 1
            if bottom < top {
                break
            }
            for i in (top...bottom).reversed() {
                result.append(matrix[i][left])
            }
            left += 1
            if left > right {
                break
            }
        }
        
        return result
    }

剑指 Offer 19. 正则表达式匹配

请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’‘表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"aba"均不匹配。
示例 1:
输入:
s = “aa”
p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。
示例 2:
输入:
s = “aa”
p = "a"
输出: true
解释: 因为 ‘’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。
示例 3:
输入:
s = “ab”
p = "."
输出: true
解释: "." 表示可匹配零个或多个（’’）任意字符（’.’）。
示例 4:
输入:
s = “aab”
p = “cab”
输出: true
解释: 因为 ‘’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。
示例 5:
输入:
s = “mississippi”
p = "misisp."
输出: false
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母以及字符 . 和 ，无连续的 '’

public:
    bool isMatch(string s, string p) {
         if (p.empty()) return s.empty();
        bool isFirstMatch = !s.empty() && (s[0] == p[0] || '.' == p[0]);
        if (p.size() >= 2 && p[1] == '*') {
            return (isFirstMatch && isMatch(s.substr(1), p)) || isMatch(s, p.substr(2));
        }
        return isFirstMatch && isMatch(s.substr(1), p.substr(1));

    }

递归终止条件
if p.empty() return s.empty()
一: 假设没有.也没有*的情况,s和p要匹配
!s.isEmpty() && p[0] == s[0]

这里是引用
那么第一个字符进行match
bool isFirstMatch = !s.isEmpty() && p[0] == s[0]
如何第一个字符已经match,则找子问题, 第一个字符后面的部分也必须是相等的
这么个递归思想一定要训练自己掌握
return isFirstMatch && isMatch(s.substr(1), p.substr(1))
假设没有.和的话一般人都会把两个字符串给循环下,看对应的位置只要有不相等的就返回,另外就是找相似性变为重复子问题分治求解, 分治的思想,就是只要比较第一个字符,第一个字符相等那么就转换为子问题比较s和p的第二个,第三个字符
二: 接下来支持有.
记s[0]和p[0]第一个字符就算不相等,但是p[0] == ‘.’,也可以,因为.匹配任意字符,.就是通配符
三: 然后是的情况 代表0个,1个或多个元素前面的元素
要有的话,至少p.size() >= 2, p[1] == ‘’ 有两种情况考虑
isFirstMatch && isMatch(s.substr(1), p)
一种情况 是firstMatch为真时,只需要单词去掉上一个(已经满足),将下面的单词继续和p比较
另一种情况
isMatch(s, p.subStr(2)) 表示前面没有任何字符匹配到,
所以s不变, p去掉前面的那个字符和 比如 s = aab, p = cab

class RegularExpressionMatching {

   func isMatch(_ s: String, _ p: String) -> Bool {
       if p.isEmpty {return s.isEmpty}
       let firstMatch = !s.isEmpty && (s[0] == p[0] || "." == p[0])
       if p.count >= 2 && p[1] == "*" {
          return firstMatch && isMatch(s.obtainStr(1), p) || isMatch(s, p.obtainStr(2))
       }
       return firstMatch && isMatch(s.obtainStr(1), p.obtainStr(1))
    }
       
}

 
// 注意小标越界 的情况
extension String {
     subscript(i: Int) -> Character {
         return self[index(startIndex, offsetBy: i)]
     }
     func obtainStr(_ offsetBy: Int) -> String {
         let index = self.index(self.startIndex, offsetBy: offsetBy)
         let subStr = self.suffix(from: index)
         return String(subStr)
     }
 }