【2023/1/3】每日leetcode && 每日effective c++-CSDN博客

本文链接：https://blog.csdn.net/yuwei021/article/details/128534910

文章介绍了使用动态规划解决爬楼梯、零钱兑换、完全平方数和单词拆分问题的C++代码实现，强调了动态规划的五步走策略。同时，文章讨论了面向对象编程中的封装原则，推荐将成员变量声明为private，并使用non-member函数增强封装性和灵活性。

摘要由CSDN通过智能技术生成

stay hard！实习+sci+准备面试+雅思！

1、每日leetcode

70. 爬楼梯（完全背包解法）

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：输入： 2 输出： 2 解释：有两种方法可以爬到楼顶。

1 阶 + 1 阶
2 阶
示例 2：输入： 3 输出： 3 解释：有三种方法可以爬到楼顶。

1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶

把爬的方法视为物品，总阶梯数视为容器。
还是五步走：
1、dp[j]就是爬到j层有dp个方法
2、dp[j] += dp[j-nums[i]];
3、dp[0] = 1，因为需要累加
4、由于是排序，所以背包在外，物品在内。
5、模拟：

class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n+1);
        dp[0] = 1;
        for(int j = 0; j <= n; j++)
            for(int i = 1; i <= 2; i++)
                if(j >= i) dp[j] += dp[j-i];
        return dp[n];
    }
};

322. 零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

你可以认为每种硬币的数量是无限的。

示例 1：输入：coins = [1, 2, 5], amount = 11 输出：3 解释：11 = 5 + 5 + 1

示例 2：输入：coins = [2], amount = 3 输出：-1

示例 3：输入：coins = [1], amount = 0 输出：0

示例 4：输入：coins = [1], amount = 1 输出：1

示例 5：输入：coins = [1], amount = 2 输出：2

提示：

1 <= coins.length <= 12
1 <= coins[i] <= 2^31 - 1
0 <= amount <= 10^4

五步走：
1、dp[j]就是j金额需要的最少硬币数
2、dp[j] = min(dp[j], dp[j-coins[i]]+1);
3、dp[0] = 0 dp[other] = INT_MAX;
4、由于是算组合数，所以先遍历物品，再遍历背包
5、模拟：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1, INT_MAX);
        dp[0] = 0;
        for(int i = 0; i < coins.size(); i++)
            for(int j = coins[i]; j <= amount; j++)
                if(dp[j-coins[i]]!=INT_MAX)
                    dp[j] = min(dp[j], dp[j-coins[i]]+1);
        if(dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};

279.完全平方数

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

给你一个整数 n ，返回和为 n 的完全平方数的最少数量。

完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

示例 1：输入：n = 12 输出：3 解释：12 = 4 + 4 + 4

示例 2：输入：n = 13 输出：2 解释：13 = 4 + 9

提示：

1 <= n <= 10^4

五步走：
1、dp[j]：数字j所需要的完全平方数最小个数
2、dp[j] = min(dp[j], dp[j - i*i] + 1);
3、dp[0] = 0 dp[other] = INT_MAX;
4、由于是算组合数，所以先遍历物品，再遍历背包
5、模拟：

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n+1, INT_MAX);
        dp[0] = 0;
        for(int i = 1; i * i <= n; i++)
            for(int j = i*i; j <= n; j++)
                dp[j] = min(dp[j], dp[j-i*i]+1);
        return dp[n];
    }
};

139.单词拆分

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

拆分时可以重复使用字典中的单词。

你可以假设字典中没有重复的单词。

示例 1：

输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。
示例 2：

输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
输出: true
解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。
注意你可以重复使用字典中的单词。
示例 3：

输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
输出: false

五步走：
1、dp[j]：长度为j的子串是否可以由字典中的单词组成
2、if([j, i]区间内子串可在字典中找到，而且dp[j] == true)，那么dp[i] = true;
3、dp[0] = true; dp[other] = false;
4、由于是排序数，所以先遍历背包，再遍历物品。
5、模拟：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        vector<bool> dp(s.size()+1);
        dp[0] = true;
        for(int i = 0; i <= s.size(); i++){
            for(int j = 0; j < i; j++){
                string subs = s.substr(j, i-j);
                if(wordSet.count(subs) && dp[j]) 
                    dp[i] = true; 
            }
        }
        return dp[s.size()];     
    }
};

这里物品的遍历比较特殊，要注意一下。

2、每日effective c++

条款22：将成员变量声明为private

private：只有当前类中成员可访问
protected：当前类和继承该类的类可访问
public：都可访问

如果将成员变量声明为public，将可以直接访问，但是封装性就会出现问题，而且这种方法会不具备弹性。
使用一个public的成员函数来访问private的对象是一个比较好的方法，这种方法更具弹性（可以自行决定如何使用），而且让用户无法随意改变变量。
使用protected，并不能提升封装性，因为一旦改动，其子类就会收到影响。
总而言之，要么使用private（封装），要么使用public（用户使用）。

条款23：宁以non-member、non-friend替换member函数

友元可以访问类内私有成员
比如类内声明friend void xxx，类外定义void xxx

总之，就是使用成员函数访问对象，就会降低封装性，所以可以使用非成员函数，传入该类对象，然后使用该类对象的成员函数就可以了。
我发现这个条款暗含玄只因。
namespace其实就遵守了这个条款，命名空间当中包含类以及其非成员函数，提供给外界使用的方法。

namespace WebBrowserStuff{
	class WebBrowser {...};
	void clearBrowser(WebBrowser& wb);
	...
}

然后这种方法，可以每个头文件用相同的类，提供不同的非成员函数，这样子就类似于C++标准程序库的使用方式，想用什么方法，就直接引用对应的头文件就可以了。