LeetCode训练题-1

LeetCoede 训练题-1

打家劫舍

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

思路

类似于0、1背包问题，取或者不取；
取$i$i则相邻的不可以取，不取$i$i则相邻的可以取：

dp[i] = max(dp[i-1], dp[i-2]+num[i])

代码如下：

#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    int rob(vector<int> &nums) {
        if (nums.size() < 2)
            if (nums.size() == 1)
                return nums[0];
            else return 0;
        int dp[nums.size()];

        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);

        for (int i = 2; i < nums.size(); i++) {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        }

        return dp[nums.size() - 1];
    }
};

int main() {
    Solution s;
    vector<int> nums({2});
    cout << s.rob(nums) << endl;
    return 0;
}

区域和检索-数组不可变

题目描述

给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。

思路

垃圾版思路：
利用一个数组保存每个i, j之间的和, 时间复杂度和空间复杂度都是$O(n^2)$O(n2)。

简化一下：
利用一个数组保存每个起点到j的和, 计算i, j 之和相减即可，时间复杂度和空间复杂度都是$O(n)$O(n)。

#include <iostream>
#include <vector>

using namespace std;

class NumArray {
public:
    int *dp;
    int len;

    NumArray(vector<int> nums) {
        len = nums.size();

        dp = new int[len];
        if (len > 0)
            dp[0] = nums[0];
        for (int i = 1; i < len; i++) {
            dp[i] = dp[i - 1] + nums[i];
        }
    }

    int sumRange(int i, int j) {
        if (i != 0)
            return dp[j] - dp[i - 1];
        else return dp[j];
    }

    ~NumArray() {
        delete[]dp;
    }
};

int main() {
    vector<int> nums({-2, 0, 3, -5, 2, -1});
    NumArray n(nums);
    cout << n.sumRange(0, 2) << endl;
    cout << n.sumRange(2, 5) << endl;
    cout << n.sumRange(0, 5) << endl;

    return 0;
}
/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(i,j);
 */

解码方法

题目描述

一条包含字母 A-Z 的消息通过以下方式进行了编码：

‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26
给定一个只包含数字的非空字符串，请计算解码方法的总数。

示例 1:

输入: “12”
输出: 2
解释: 它可以解码为 “AB”（1 2）或者 “L”（12）。
示例 2:

输入: “226”
输出: 3
解释: 它可以解码为 “BZ” (2 26), “VF” (22 6), 或者 “BBF” (2 2 6) 。

解题思路

一般情况下，这就是dp[i]=dp[i-1]+dp[i-2]，即两种情况：

1. 选择一个字符解码
2. 选择两个字符进行解码

举例：

123
dp[0] = 1
dp[1] = 2
dp[2] = {dp[0],‘23’}+{dp[1],‘3’}

但是，这个地方就有一些需要注意的地方，因为只有1~26才是合法的，0, 00~09, 27~99都是不合法的数字，并且，对于10, 20这样的数据合法但不可拆分，而00~09, x0这样的数据是非法数据且拆分后也是不合法, 27~99(除去含有零)是非法数据但是可以被拆分，其余数据合法且可拆分。
于是根据以上的分析可以发现，这是带有约束的动态规划，对于不同的情况进行不同的处理。

代码如下：

#include <iostream>
#include <string>

using namespace std;

class Solution {
public:
    int isMatch(char f, char s) {
        if (s != '0' && ((f == '2' && s < '7') || f == '1'))
            return 2;
        else if ((f == '0' || f > '2') && s == '0')
            return -1;
        else if ((f == '0' || f > '2' || (f == '2' && s > '6')) && s != 0) // 不合法的不含0
            return 0;
        return 1;
    }

    int numDecodings(string s) {
        auto len = s.size();
        if (len == 0)
            return 0;


        int dp[s.size()];
        int re = 0;

        dp[0] = s[0] == '0' ? 0 : 1;

        if (len == 1)
            return dp[0];
        re = isMatch(s[0], s[1]);
        if (re == 2)
            dp[1] = 2;
        else if (re == 1 || re == 0)
            dp[1] = dp[0];
        else dp[1] = 0;
        for (int i = 2; i < len; i++) {
            re = isMatch(s[i - 1], s[i]);
            if (re == 2) {
                dp[i] = dp[i - 1] + dp[i - 2];
            } else if (re == 1) {
                dp[i] = dp[i - 2];
            } else if (re == 0) {
                dp[i] = dp[i - 1];
            } else dp[i] = 0;
        }
        return dp[len - 1];
    }
};

int main() {
//    std::cout << "Hello, World!" << std::endl;
    Solution s;
    cout << s.numDecodings("227");
    return 0;
}