最大子数组和
方法一：常规动态规划。
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int n = nums.size();
vector<int> dp(n + 1);
int res = -0x3f3f3f3f;
for (int i = 1; i <= n; i++)
{
dp[i] = max(dp[i - 1], 0) + nums[i - 1];
res = max(res, dp[i]);
}
return res;
}
};
状态：定义 dp[i] 为以i位置为结尾的所有连续子数组的最大和；
转移：dp[i] = max(0, dp[i - 1]) + nums[i]；
方法二：空间优化，仅用一个变量记录dp值。
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int ret = INT_MIN, prev = 0;
for (int e : nums)
{
prev = max(0, prev) + e;
ret = max(ret, prev);
}
return ret;
}
};
环形子数组的最大和
数组是成环的，要我们求所有非空子数组的最大可能和，此时就有两种情况，一是目标子数组是连续的，二是首尾相连的。既然数组成环，那我们可以求它的对立情况，也就是求所有非空子数组的最小可能和，然后由数组总和减去最小可能和，就得到了首位相连的目标情况。
注意：有可能数组中的元素全为负数，此时子数组的最大和只有一个负数元素，但是数组总和减去子数组的最小和就为0了，所以这种情况要特判一下。
class Solution {
public:
int maxSubarraySumCircular(vector<int>& nums) {
int prev_max = 0, ret_max = INT_MIN;
int prev_min = 0, ret_min = INT_MAX, sum = 0;
for (int e : nums)
{
prev_max = max(0, prev_max) + e;
ret_max = max(ret_max, prev_max);
prev_min = min(0, prev_min) + e;
ret_min = min(ret_min, prev_min);
sum += e;
}
return sum == ret_min ? ret_max : max(ret_max, sum - ret_min);
}
};
乘积最大子数组
用 f[i] 表示以i位置为结尾的所有子数组的最大乘积，用 g[i] 表示以i位置为结尾的所有子数组的最小乘积。
当 nums[i] < 0 时，需要乘以最小的乘积和，当 nums[i] > 0 时，需要乘以最大的乘积和。
class Solution {
public:
int maxProduct(vector<int>& nums) {
int n = nums.size();
vector<int> f(n + 1, 1);
auto g = f;
int ret = INT_MIN;
for (int i = 1; i <= n; i++)
{
int x = nums[i - 1], y = f[i - 1]*nums[i - 1], z = g[i - 1]*nums[i - 1];
f[i] = max(x, max(y, z));
g[i] = min(x, min(y, z));
ret = max(ret, f[i]);
}
return ret;
}
};
乘积为正数的最长子数组长度
定义状态 f[i] 为以i位置为结尾的所有子数组中乘积为正数的最长长度；
定义状态 g[i] 为以i位置为结尾的所有子数组中乘积为负数的最长长度。
class Solution {
public:
int getMaxLen(vector<int>& nums) {
int n = nums.size();
int ret = INT_MIN;
vector<int> f(n + 1), g(n + 1);
for (int i = 1; i <= n; i++)
{
if (nums[i - 1] > 0)
{
f[i] = f[i - 1] + 1;
g[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
}
else if (nums[i - 1] < 0)
{
f[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
g[i] = f[i - 1] + 1;
}
ret = max(ret, f[i]);
}
return ret;
}
};
等差数列划分
class Solution {
public:
int numberOfArithmeticSlices(vector<int>& nums) {
int n = nums.size(), ret = 0;
vector<int> dp(n);
for (int i = 2; i < n; i++)
{
if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2])
dp[i] = dp[i - 1] + 1;
ret += dp[i];
}
return ret;
}
};
最长湍流子数组
定义 f[i] 为以i位置为结尾的所有子数组中，最后是“上升”状态的最长湍急子数组的长度；定义 g[i] 为以i位置为结尾的所有子数组中，最后是“下降”状态的最长湍急子数组的长度。
例如：如果 arr[i] > arr[i - 1]，也就是呈现“上升”状态，则以i位置为结尾的最长湍急子数组的长度为：f[i] = g[i - 1] + 1。
本题中不管什么情况，最小长度都有1，则可以在初始化的时候全部初始化为1，以减少操作。
class Solution {
public:
int maxTurbulenceSize(vector<int>& arr) {
int n = arr.size();
vector<int> f(n, 1), g(n, 1);
int ret = 1;
for (int i = 1; i < n; i++)
{
if (arr[i] > arr[i - 1])
f[i] = g[i - 1] + 1;
if (arr[i - 1] > arr[i])
g[i] = f[i - 1] + 1;
ret = max(ret, max(f[i], g[i]));
}
return ret;
}
};
单词拆分 *
定义状态：dp[i] 表示 [0, i] 区间内能否由字典中的字符串拼接而成。
则如果 dp[j - 1] == true && s.substr(j, i - j + 1)在字典中，则 dp[i] = true。
class Solution {
public:
bool wordBreak(string s, vector<string>& wordDict) {
unordered_set<string> hash(wordDict.begin(), wordDict.end());
int n = s.size();
vector<bool> dp(n + 1);
dp[0] = true;
s = ' ' + s; // 使原始字符串的下标统一
for (int i = 1; i <= n; i++)
{
for (int j = i; j >= 1; j--)
{
if (dp[j - 1] && hash.count(s.substr(j, i - j + 1)))
{
dp[i] = true;
break;
}
}
}
return dp[n];
}
};
环绕字符串中唯一的子字符串
定义 dp[i] 为以i位置的元素为结尾的所有子串中，有多少在base中出现过。
任意元素都会在base中出现，因此最小为1，可以在初始化的时候顺便初始化一下。
最后返回值，以某个元素为结尾的子串可能连续出现，因此需要去重，只保留其中dp值最大的即可。
class Solution {
public:
int findSubstringInWraproundString(string s) {
int n = s.size();
vector<int> dp(n, 1);
for (int i = 1; i < n; i++)
if (s[i - 1] + 1 == s[i] || (s[i - 1] == 'z' && s[i] == 'a'))
dp[i] += dp[i - 1];
int hash[26] = {};
for (int i = 0; i < n; i++)
hash[s[i] - 'a'] = max(hash[s[i] - 'a'], dp[i]);
int ret = 0;
for (int e : hash) ret += e;
return ret;
}
};
本篇文章的分享就到这里了，如果您觉得在本文有所收获，还请留下您的三连支持哦~
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
