剑指offer刷题笔记01

JZ.19 正则表达式匹配

动态规划 O(nm)
题目描述：
请实现一个函数用来匹配包括’.‘和’*‘的正则表达式。
1.模式中的字符’.‘表示任意一个字符
2.模式中的字符’*'表示它前面的字符可以出现任意次（包含0次）。
在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配

输入：
s=“aa”
p=“a*”
输出:true

1. 递归法

思路：

• 状态表示：f[x][y] 表示 s[i,…] 和 p[j,…]相匹配, s[…,i]和p[…,j]已匹配。
• 状态转移：
  1. p[j]是正常字符，f[i][j] = s[i] == p[j] && f[i + 1] [j + 1]
  2. p[j]是’.', f[i][j] = f[i + 1][j + 1]
  3. p[j + 1]是‘*’， s[i] == p[j] && f[i][j] = f[i + 1][j] || f[i][j + 2]
     提示：前两种情况是p[j + 1] 不是'*'

第三种情况：最直观的转移方式是这样的：枚举通配符’*'可以匹配多少个p[j]，只要有一种情况可以匹配，则f[i][j]就是真；
这样做的话，我们发现，f[i][j]除了枚举0个p[j]之外，其余的枚举操作都包含在f[i+1][j]中了，所以我们只需判断f[i+1][j]是否为真，以及s[i]是否可以和p[j]匹配即可。

时间复杂度分析：n 表示s的长度，m 表示p的长度,总共 nm 个状态,状态复杂度O(1),所以总时间复杂度是O(nm)

代码:

#include <vector>
class Solution {
public:
    int n, m;
    vector<vector<int>> f;
    bool match(string str, string pattern) {
        n = str.size();
        m = pattern.size();
        f = vector<vector<int>>(n + 1, vector<int>(m + 1, -1)); // f的范围[0,0]到[n,m]；且考虑到二维数组都为空的情况
        return dp(0, 0, str, pattern);
    }
    bool dp(int x, int y, string &str, string &pattern) {
        if (f[x][y] != -1) return f[x][y]; // 利用到的f[x][y]，有值说明已经计算过，直接返回不需要递归。利用到已经计算的值，截枝不让重复递归。
        if (y == m) return f[x][y] = x == n; // 递归跳出条件
        bool first_match = x < n && (str[x] == pattern[y] || pattern[y] == '.'); // 判断字符是否对应相等，或者pattern的对应的值为'.'，即能万能匹配。 x<n防止了计算f[x][y]时会越界；因为下面进入dp(x+1, , ,)都用first做先做了限制。
        if (y + 1 < m && pattern[y + 1] == '*') {
        f[x][y] = dp(x, y + 2, str, pattern) || first_match && dp(x + 1, y, str, pattern); // y + 2在进入下一次dp不会越界，因为进入下一次dp前提y+1是‘*’,而f开的列大小比patter多1。故当*位于最后一位时，f可以到最后一位加一；
        } else {
            f[x][y] = first_match && dp(x + 1, y + 1, str, pattern); // y递增加1，总会遇到y == m 后返回。且这两个条件不能互换，如果换了，没有x<n做限制，当x == n时，递归到下一层时，x = n + 1 会发生越界。
        }
        return f[x][y];
    }

};

2. 非递归版本

class Solution {
public:
    bool isMatch(string s, string p) {
        int n = s.size(), m = p.size();
        vector<vector<bool>> f(n + 1, vector<bool>(m + 1));
        s = " " + s, p = " " + p;
        for (int i = 0; i <= n; i ++ )
            for (int j = 0; j <= m; j ++ )
                if (!i && !j) f[i][j] = true;
                else
                {
                    if (j + 1 <= m && p[j + 1] == '*') continue;
                    if (p[j] != '*')
                    {
                        if (p[j] == '.' || s[i] == p[j])
                            if (i && j) f[i][j] = f[i - 1][j - 1];
                    }
                    else if (j)
                    {
                        if (j >= 2) f[i][j] = f[i][j - 2];
                        if (p[j - 1] == '.' || s[i] == p[j - 1])
                            if (i && j >= 2 && f[i - 1][j]) f[i][j] = f[i - 1][j];
                    }
                }

        return f[n][m];
    }
};

JZ81. 调整数组顺序使奇数位于偶数前面(二）

双指针法

描述：
输入一个长度为 n 整数数组，数组里面可能含有相同的元素，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前面部分，所有的偶数位于数组的后面部分，对奇数和奇数，偶数和偶数之间的相对位置不做要求，但是时间复杂度和空间复杂度必须如下要求。
要求：时间复杂度O(n),空间复杂度O(1)

代码：

class Solution {
public:
    vector<int> reOrderArrayTwo(vector<int>& array) {
        // write code here
        int l = 0, r = array.size() - 1;
        while (l < r) {
             while (l < r && array[l] % 2 == 1) l ++ ;
             while (l < r && array[r] % 2 == 0) r -- ;
             if (l < r) swap(array[l], array[r]); 
         }
         return array;
    }
};

JZ22. 链表中倒数最后k个结点

单链表遍历（从前往后）

思路：一共遍历两次

1. 第一次遍历得到链表的总长度 n
2. 链表的倒数第k个结点，相当于整数第 n - k + 1。即第二次需要遍历到 n - k - 1 个结点，就是我们要找的答案。

时间复杂度: 链表总共遍历两次，所以时间复杂度是O(n)

代码：

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        // write code here
        int n = 0;
        for (auto p = pHead; p; p = p->next) n ++ ;
        if (n < k) return NULL; 
        auto cur = pHead;
        for (int i = 0; i < n - k; i ++ ) cur = cur->next;
        return cur;
    }
};

JZ. 反转链表

JZ. 求1 + 2 + … + n