【剑指Offer】动态规划(3)

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

请实现一个函数用来匹配包含'. '和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但与"aa.a"和"ab*a"均不匹配。

示例 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 = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。

示例 5:

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false

• s 可能为空，且只包含从 a-z 的小写字母。
• p 可能为空，且只包含从 a-z 的小写字母以及字符 . 和 *，无连续的 '*'。

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

算法思路

这题主要用到的算法是动态规划,dp[i][j]表示p[0_i]和s[0j]，是否匹配，当p[i] == s[j]时，dp[i][j]的匹配情况和dp[i- 1][j - 1]一样，重点是对符号’*‘的处理，'*'表示它前面的字符可以出现任意次（含0次），因此遇到’*‘时，’*'可以去除前面一个字符，此时dp[i][j] = dp[i][j] ||

dp[i-2][j]，或者表示前面一个字符，此时dp[i][j] = dp[i][j] || dp[i][j - 1]，其它情况则是不匹配。

剑指 Offer 49. 丑数

我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。

示例:

输入: n = 10
输出: 12
解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。

说明:

1. 1 是丑数。
2. n 不超过1690。

思路一

#define ll long long
class Solution {
public:
    int nthUglyNumber(int n) {
        vector<ll> dp(n);
        dp[0] = 1;
        int a = 0, b = 0, c = 0;
        for(int i = 1; i < n; ++ i){
            dp[i] = min(dp[a] * 2, min(dp[b] * 3, dp[c] * 5));
            if(dp[i] == dp[a] * 2){
                a ++;
            }else if(dp[i] == dp[b] * 3){
                b ++;
            }else c++;
            if(dp[i] == dp[i - 1])i--;
        }
        return dp[n - 1];
    }
};

算法思路

思路一用的是3指针，我们知道丑数是2、3、5的倍数(1除外)，因此我们用三个指针指向2、3、5的倍数，然后逐个插入队列，值越小越优先插入，插入时判断上一个是否重复来去重。

思路二

#define ll long long
class Solution {
public:
    int nthUglyNumber(int n) {
        priority_queue<ll, vector<ll>, greater<ll>> q;
        set<ll> st;
        q.push(1);
        st.insert(1);
        ll cur;
        for(int i = 0; i < n ; ++ i){
            cur = q.top();
            q.pop();
            if(st.find(cur * 2) == st.end()){
                st.insert(cur * 2);
                q.push(cur * 2);
            }
            if(st.find(cur * 3) == st.end()){
                st.insert(cur * 3);
                q.push(cur * 3);
            }
            if(st.find(cur * 5) == st.end()){
                st.insert(cur * 5);
                q.push(cur * 5);
            }
        }
        return cur;
    }
};

算法思路

思路二是用最小堆，每次取堆顶元素乘2、3、5然后插入堆，当排除第n个元素时就是答案。

剑指 Offer 60. n个骰子的点数

把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。

你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。

示例 1:

输入: 1
输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]

示例 2:

输入: 2
输出: [0.02778,0.05556,0.08333,0.11111,0.13889,0.16667,0.13889,0.11111,0.08333,0.05556,0.02778]

限制：

1 <= n <= 11

class Solution {
public:
    vector<double> dicesProbability(int n) {
        vector<double> ans(6, 1.0/6), tmp(6, 1.0 / 6);
        for(int i = 1; i < n; ++ i){
            ans.clear();
            ans.resize(5 * (i + 1) + 1, 0);
            for(int j = 0; j < 5 * i + 1; j ++){
                for(int k = 0; k < 6; ++ k){
                    ans[j + k] += tmp[j] * (1.0 / 6);
                }
            }
            tmp = ans;
        }
        return ans;
    }
};

算法思路

这一题用的是动态规划算法，n个骰子摇的点数概率和n-1个骰子摇的点数概率是有规律的dp[i][j]表示i个骰子摇到点数j的概率，
$$d{p}_{ij}=\sum d{p}_{i-1j^{,}}(1/6.0)$$
由上一级所有能组成的点数概率的和组成。

【剑指Offer】系列：
【剑指Offer】栈
【剑指Offer】链表
【剑指Offer】字符串
【剑指Offer】查找算法
【剑指Offer】查找算法(1)
【剑指Offer】搜索与回溯算法
【剑指Offer】搜索与回溯算法(1)
【剑指Offer】动态规划
【剑指Offer】动态规划(1)
【剑指Offer】动态规划(2)
【剑指Offer】双指针
【剑指Offer】双指针(1)
【剑指Offer】双指针(2)
【剑指Offer】搜索与回溯算法(2)
【剑指Offer】搜素与回溯算法(3)
【剑指Offer】排序
【剑指Offer】排序(1)
【剑指Offer】搜索与回溯算法(4)
【剑指Offer】搜索与回溯算法(5)
【剑指Offer】分治算法
【剑指Offer】位运算
【剑指Offer】位运算(1)
【剑指Offer】数学
【剑指Offer】数学(1)
【剑指Offer】模拟
【剑指Offer】字符串(1)
【剑指Offer】栈和队列
【剑指Offer】搜索与回溯算法(6)