蓝桥杯刷题_day8_动态规划_简单多状态

按摩师

【题目描述】
一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。给定一个预约请求序列，替按摩师找到最优的预约集合（总预约时间最长），返回总的分钟数。

【输入样例】

[1,2,3,1]

【输出样例】

4

【数据规模与约定】
无

【解题思路】

• 定义两个状态数组f和g, f[i]表示前i个预约中,选择第i个预约的最大收益,g[i]表示前i个预约中,不选择第i个预约的最大收益。
• 状态转移方程为:f[i] = g[i-1] + nums[i], g[i] = max(f[i-1], g[i-1]).
• 最终答案为max(f[n-1], g[n-1]).

【C++程序代码】

class Solution {
public:
    int massage(vector<int>& nums) {
        int n = nums.size();
        if (n == 0)
        {
            return 0;
        }
        vector<int> f(n);
        vector<int> g(n);

        f[0] = nums[0];
        g[0] = 0;

        for (int i = 1; i < n; i++)
        {
            f[i] = g[i - 1] + nums[i];
            g[i] = max(f[i - 1],g[i - 1]);
        }

        return max(f[n - 1], g[n - 1]);
    }
};

打家劫舍

【题目描述】
一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响小偷偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组 nums ，请计算 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

【输入样例】

nums = [1,2,3,1]

【输出样例】

4

【数据规模与约定】

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 400

【解题思路】

• 定义两个状态数组f和g, f[i]表示前i个房间中,选择偷窃第i个房间的最大收益,g[i]表示前i个房间中,不选择偷窃第i个房间的最大收益。
• 状态转移方程为:f[i] = g[i-1] + nums[i], g[i] = max(f[i-1], g[i-1]).
• 最终答案为max(f[n-1], g[n-1]).

【C++程序代码】

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if (n == 0)
        {
            return 0;
        }
        vector<int> f(n);
        vector<int> g(n);

        f[0] = nums[0];
        g[0] = 0;

        for (int i = 1; i < n; i++)
        {
            f[i] = g[i - 1] + nums[i];
            g[i] = max(f[i - 1],g[i - 1]);
        }

        return max(f[n - 1], g[n - 1]);
    }
};

打家劫舍II

【题目描述】
一个专业的小偷，计划偷窃一个环形街道上沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组 nums ，请计算 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

【输入样例】

nums = [2,3,2]

【输出样例】

3

【数据规模与约定】

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 1000

【解题思路】

• 由于这个问题是一个环形的房屋,所以需要分两种情况讨论:
  1. 偷窃第一个房子,不偷窃最后一个房子
  2. 不偷窃第一个房子,偷窃最后一个房子
• 定义一个helper函数,用来解决第一种情况(仅仅偷窃中间的房子)。
• 最终答案为这两种情况的最大值。

【C++程序代码】

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        return max(nums[0] + rob1(nums, 2, n - 2), rob1(nums, 1, n - 1));
    }

    int rob1(vector<int>& nums, int left, int right)
    {
        if (left > right)
        {
            return 0;
        }
        int n = nums.size();

        vector<int> f(n);
        vector<int> g(n);

        f[left] = nums[left];
        g[0] = 0;

        for (int i = left + 1; i <= right; i++)
        {
            f[i] = g[i - 1] + nums[i];
            g[i] = max(f[i - 1], g[i - 1]);
        }

        return max(f[right], g[right]);
    }
};

删除并获得点数

【题目描述】
给你一个整数数组 nums ，你可以对它进行一些操作。
每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。

【输入样例】

nums = [3,4,2]

【输出样例】

6

【数据规模与约定】

• 1 <= nums.length <= 2 * 104
• 1 <= nums[i] <= 104

【解题思路】

• 由于每次删除一个数字,都需要删除该数字前后的数字,因此可以直接创建一个新数组arr,其中arr[i]表示数字i出现的次数乘以i。
• 然后对arr数组做一次"打家劫舍"问题的求解,得到最终结果。

【C++程序代码】

class Solution {
public:
    int deleteAndEarn(vector<int>& nums) {
    	//根据题目要求直接创建一个可以包含所有可能的数组
        int n = nums.size();
        int max_nums = 0;
        for (int i = 0; i < n; i++)
        {
            if (nums[i] > max_nums)
            {
                max_nums = nums[i];
            }
        }
        vector<int> arr(max_nums+1);

		//将nums数组中的所有的数都映射到新开辟的数组中
        for (int i = 0; i < n; i++)
        {
            arr[nums[i]] = arr[nums[i]] + nums[i];
        }
        
		//在arr数组中做一次“打家劫舍”问题
        vector<int> f(max_nums + 1);
        vector<int> g(max_nums + 1);

        f[0] = arr[0];
        g[0] = 0;

        for (int i = 1; i < max_nums + 1; i++)
        {
            f[i] = g[i - 1] + arr[i];
            g[i] = max(f[i - 1], g[i - 1]);
        }

        return max(f[max_nums], g[max_nums]);
    }
};

粉刷房子

【题目描述】
假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。

当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3 的正整数矩阵 costs 来表示的。

例如，costs[0][0] 表示第 0 号房子粉刷成红色的成本花费；costs[1][2] 表示第 1 号房子粉刷成绿色的花费，以此类推。

请计算出粉刷完所有房子最少的花费成本。

【输入样例】

costs = [[17,2,17],[16,16,5],[14,3,19]]

【输出样例】

10

【数据规模与约定】

• costs.length == n
• costs[i].length == 3
• 1 <= n <= 100
• 1 <= costs[i][j] <= 20

【解题思路】

• 定义三个状态数组r、g和b,分别表示当前房子刷成红色、绿色和蓝色的最小花费。
• 状态转移方程为:
  • r[i] = min(g[i-1], b[i-1]) + costs[i-1][0];
  • g[i] = min(r[i-1], b[i-1]) + costs[i-1][1];
  • b[i] = min(r[i-1], g[i-1]) + costs[i-1][2];
• 最终答案为min(r[n], g[n], b[n])。

【C++程序代码】

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int n = costs.size();

        vector<int> r(n + 1); //红色
        vector<int> g(n + 1); //绿色
        vector<int> b(n + 1); //蓝色

        for (int i = 1; i <= n; i++)
        {
            r[i] = min(g[i - 1], b[i - 1]) + costs[i - 1][0];
            g[i] = min(r[i - 1], b[i - 1]) + costs[i - 1][1];
            b[i] = min(r[i - 1], g[i - 1]) + costs[i - 1][2];
        }

        return min({ r[n], g[n], b[n] });
    }
};

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int n = costs.size();

        vector<vector<int> > dp(n + 1, vector<int>(3));

        for (int i = 1; i <= n; i++)
        {
            dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]) + costs[i - 1][0];
            dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + costs[i - 1][1];
            dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + costs[i - 1][2];
        }

        return min({ dp[n][0], dp[n][1], dp[n][2] });
    }
};