1.KMP算法
给你两个字符串
haystack
和needle
,请你在haystack
字符串中找出needle
字符串的第一个匹配项的下标(下标从 0 开始)。如果needle
不是haystack
的一部分,则返回-1
。示例 1:
输入:haystack = "sadbutsad", needle = "sad" 输出:0 解释:"sad" 在下标 0 和 6 处匹配。 第一个匹配项的下标是 0 ,所以返回 0 。示例 2:
输入:haystack = "leetcode", needle = "leeto" 输出:-1 解释:"leeto" 没有在 "leetcode" 中出现,所以返回 -1 。提示:
1 <= haystack.length, needle.length <= 104
haystack
和needle
仅由小写英文字符组成
经典KMP算法,进行字符串匹配,YYDS
class Solution {
public:
vector<int> getNext(string tstr)
{
int i=1, pre_len=0;
vector<int> next;
next.push_back(0);
while(i<tstr.length())
{
if(tstr[i]==tstr[pre_len])
{
i++;
pre_len++;
next.push_back(pre_len);
}
else
{
if(!pre_len)
{
i++;
next.push_back(pre_len);
}
else
{
pre_len = next[pre_len-1];
}
}
}
return next;
}
int strStr(string haystack, string needle) {
vector<int> next = getNext(needle);
int judge = -1;
int i=0, j=0;
while(i<haystack.length())
{
if(haystack[i]==needle[j])
{
i++;
j++;
}
else
{
if(j>0)
{
j = next[j-1];
}
else
{
i++;
}
}
if(j == needle.length())
{
judge = i-j;
break;
}
}
return judge;
}
};
2.一大群背包问题来袭
1. 问能否能装满背包(或者最多装多少):
dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
2. 问装满背包有几种方法:
dp[j] += dp[j - nums[i]]
3. 问背包装满最大价值
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
4. 问装满背包所有物品的最小个数:
dp[j] = min(dp[j], dp[j - coins[i]] + 1)
2.1 01背包
实现一个算法求解 01 背包问题。背包问题的介绍如下:
已知一个容量为 total.eight 的背包,有不同重量不同价值的物品,问怎样在背包容量限制下达到利益最大化。.·01背包问题要求每个物品只有一个,可以选择放入或者不放入包。背包问题求解方法的介绍如下:
·用符号 : 表示第讠个物品的价值,W;表示第讠个物品的体积,V,表示当前背包容量为j时,前i个物品最佳组合对应的价值。
对于当前第之个商品,如果包的容量比该物品体积小,即讠< W;。那么此时的价值与前i-1个的价值是一样的,即 Vi=-1,j。
对于当前第之个商品,如果包的容量能够装下该物品,即 W;<”。此时需要判断装或者不装这个物品的价值对比,选择使价值更大的情况,即 ;= max(V +И-1.i-㎡,V-1.j)。
通过最优解回溯法找到解的组成:
·当 .= V-1.;时,说明没有选择第讠个物品。
·当 .i= K-1.i-㎡ 时,说明装了第讠个商品。
·从i,j的最大值一直遍历到 i=0,则找到了所有解。
输入描述
第一行为两个数字 total..eight、N,均不超过 1000。total..eight 含义见题干,N 为物品数量接下来 N 行,每行两个数字 W、亿,均不超过 1000。含义见题干。
头有点大,下列递推公式是关键
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
看到一个博主总结的就很不错:
这里需要对参数进行一些解释,是我在看的过程中所遇到的困惑,i表示的就是从0-i中选取物品,而不是选取物品的数量,可能包含第i件物品,也有可能不包含,具体要看是否是最大值的,即我们max函数的作用了。
j表示的就是背包的大小,而不是此时背包的剩余容量。
对于max第一个参数,比较好理解,就是不放第i个物品的情况
max第二个参数,先看j-weight[i],可以理解为“为了存放第i件物品,而腾出weight[i]的空间”,为何用dp[i-1][j-weight],而不是dp[i][j-weight]呢,原因是后者对于第i件物品是否存在于背包中的情况是不知道的(注意这块,和后面的完全背包问题有关系),而前者是确定第i件物品肯定不在包内,现在要放入第i件物品,就加上value[i]。
上面也只是我个人的理解,这只是二维的情况
二维完整代码如下:
#include <iostream>
#include <vector>
using namespace std;
int tmax(int a, int b)
{
return a>b?a:b;
}
int main()
{
vector<vector<int>> dp;
vector<int> weight, val;
int wbag, num, tmp;
cin >> wbag >> num;
for(int i=0;i<num;i++)
{
cin >> tmp;
weight.push_back(tmp);
cin >> tmp;
val.push_back(tmp);
}
//初始化数组
for(int i=0;i<num;i++)
{
vector<int> vtmp(wbag+1, 0);
dp.push_back(vtmp);
}
for(int j=0;j<dp[0].size();j++)
{
if(weight[0] <= j)
{
dp[0][j] = val[0];
}
}
//更新dp
for(int i=1;i<num;i++)
{
for(int j=1;j<dp[0].size();j++)
{
if(weight[i] > j) //放不下了
{
dp[i][j] = dp[i-1][j];
}
else
{
dp[i][j] = tmax(dp[i-1][j], dp[i-1][j-weight[i]]+val[i]);
}
}
}
cout << dp[dp.size()-1][dp[0].size()-1]; //输出最后一个元素
return 0;
}
二维是如何转化到一维的?
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
观察迭代式,可以发现,在更新dp数组的时候,只需要知道第i-1层,就可以计算出i层,理论上只要两层就够了 ,能否在精简一点呢?
倘若要变为一层,则需要在对[i][j]进行计算的时候,[j]之前的元素,即序号<j的元素不变即可,那么我们原本从上到下、从左到右(先物品后背包,背包从小到大),就要转变为从右到左(先物品后背包,背包从大到小),改变循环顺序即可。
一维代码如下:
#include <iostream>
#include <vector>
using namespace std;
int tmax(int a, int b)
{
return a>b?a:b;
}
int main()
{
vector<int> weight, val;
int wbag, num, tmp;
cin >> wbag >> num;
vector<int> dp(wbag+1, 0);
for(int i=0;i<num;i++)
{
cin >> tmp;
weight.push_back(tmp);
cin >> tmp;
val.push_back(tmp);
}
//初始化数组
for(int j=0;j<dp.size();j++)
{
if(weight[0] <= j)
{
dp[j] = val[0];
}
}
//更新dp
for(int i=1;i<num;i++)
{
for(int j=dp.size()-1;j>=weight[i];j--)
{
dp[j] = tmax(dp[j], dp[j-weight[i]]+val[i]);
}
}
cout << dp[dp.size()-1];
// 请在此输入您的代码
return 0;
}
2.2 完全背包
题目如下:
当物品的数量为无限的时候,又该如何解决呢?
01背包内嵌的循环是从大到小遍历,为了保证每个物品仅被添加一次。
而完全背包的物品是可以添加多次的,所以要从小到大去遍历
这是什么原理呢?
这就不得不提到2.1中的红字了,其实从小到大遍历,就相当于max当中的行数是[i]而不是[i-1],那么此时是无法确定第i件物品是否存在于背包中的情况是不知道的(具体加没有加,其实不重要,因为我们是可以重复加的),也就是说加了也无所谓,之后max函数选择最优情况。
#include <iostream>
#include <vector>
using namespace std;
int tmax(int a, int b)
{
return a>b?a:b;
}
int main()
{
vector<int> weight, val;
int wbag, num, tmp;
cin >> wbag >> num;
vector<int> dp(wbag+1, 0);
for(int i=0;i<num;i++)
{
cin >> tmp;
weight.push_back(tmp);
cin >> tmp;
val.push_back(tmp);
}
//初始化数组
for(int j=0;j<dp.size();j++)
{
if(weight[0] <= j)
{
dp[j] = val[0];
}
}
//更新dp
for(int i=1;i<num;i++)
{
for(int j=weight[i];j<dp.size();j++)
{
dp[j] = tmax(dp[j], dp[j-weight[i]]+val[i]);
}
}
cout << dp[dp.size()-1];
// 请在此输入您的代码
return 0;
}
2.3 分割等子串
给你一个 只包含正整数 的 非空 数组
nums
。请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。示例 1:
输入:nums = [1,5,11,5] 输出:true 解释:数组可以分割成 [1, 5, 5] 和 [11] 。示例 2:
输入:nums = [1,2,3,5] 输出:false 解释:数组不能分割成两个元素和相等的子集。提示:
1 <= nums.length <= 200
1 <= nums[i] <= 100
这里把元素大小看作重量,此时dp中存放的就是重量了,之后根据迭代式即可
class Solution {
public:
int tmax(int a, int b)
{
return a>b?a:b;
}
bool canPartition(vector<int>& nums) {
int sum = 0;
for(int i=0;i<nums.size();i++)
{
sum += nums[i];
}
if(sum%2)
{
return false;
}
sum /= 2;
vector<int> dp(sum+1, 0);
for(int i=0;i<nums.size();i++)
{
for(int j=dp.size()-1;j>=nums[i];j--)
{
dp[j] = tmax(dp[j], dp[j-nums[i]]+nums[i]);
if(dp[j] == sum)
{
return true;
}
}
}
return false;
}
};