剑指 Offer 42. 连续子数组的最大和
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。
示例1:
输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
提示：
1 <= arr.length <= 10^5
-100 <= arr[i] <= 100
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int ans = -999, t = 0;
for (const auto& e : nums)
{
// if (t <= 0) {
// t = e;
// } else {
// t += e;
// }
t = max(t + e, e);
ans = max(ans, t);
}
return ans;
}
};
152. 乘积最大子数组
给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
测试用例的答案是一个 32-位 整数。子数组 是数组的连续子序列。
示例 1:
输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
示例 2:
输入: nums = [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。
提示:
1 <= nums.length <= 2 * 104
-10 <= nums[i] <= 10
nums 的任何前缀或后缀的乘积都 保证 是一个 32-位 整数
class Solution {
public:
int maxProduct(vector<int>& nums) {
int p_max = 1, p_min = 1;
int ans = -999;
for (const auto& e : nums)
{
int max_tmp = p_max, min_tmp = p_min;
p_max = max(max(max_tmp * e, e), min_tmp * e);
p_min = min(min(max_tmp * e, e), min_tmp * e);
ans = max(ans, p_max);
}
return ans;
}
};
300. 最长递增子序列
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
示例 1：
输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：
输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：
输入：nums = [7,7,7,7,7,7,7]
输出：1
提示：
1 <= nums.length <= 2500
-104 <= nums[i] <= 104
法一：动态规划 \(O(n^2)\)
class Solution {
public:
//
int lengthOfLIS(vector<int>& nums) {
int ans = 1;
int nlen = nums.size();
vector<int> dp(nlen, 1);
for(int i = 1; i < nlen; ++i)
{
for (int j = 0; j < i; ++j)
{
if (nums[j] < nums[i]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
if (ans < dp[i]) {
ans = dp[i];
}
}
return ans;
}
};
法二：动态规划+二分查找 \(O(nlogn)\)
class Solution {
public:
int lengthOfLIS(vector<int>& nums)
{
int nlen = nums.size();
int ans = 0;
vector<int> tails(nlen, 0);
for(const auto& num : nums)
{
int i = 0, j = ans;
while(i < j)
{
int mid = (i + j) / 2;
if (tails[mid] < num) {
i = mid + 1;
} else {
j = mid;
}
}
tails[i] = num;
if(j == ans) {
ans += 1;
}
}
return ans;
}
};
剑指 Offer 63. 股票的最大利润
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
限制：
0 <= 数组长度 <= 10^5
class Solution {
public:
int maxProfit(vector<int>& prices) {
int profit = 0, p_min = INT_MAX;
for (const auto& price : prices)
{
p_min = min(p_min, price);
profit = max(profit, price - p_min);
}
return profit;
}
};
128. 最长连续序列
给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
示例 1：
输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
示例 2：
输入：nums = [0,3,7,2,5,8,4,6,0,1]
输出：9
提示：
0 <= nums.length <= 10^5
-10^9 <= nums[i] <= 10^9
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
int nlen = nums.size();
if (nlen == 0) return 0;
unordered_set<int> st;
for (const auto& e : nums) {
st.insert(e);
}
int cnt = 0;
for (const auto & num : nums) {
int curNum = num;
int cur_cnt = 1;
//如果连续小1的数不存在，则判断；否则，从小的数开始遍历；
if (!st.count(curNum - 1))
{
while (st.count(curNum + 1))
{
cur_cnt++; curNum++;
}
}
cnt = max(cnt, cur_cnt);
}
return cnt;
}
};
剑指 Offer II 101. 分割等和子集
给定一个非空的正整数数组 nums ，请判断能否将这些数字分成元素和相等的两部分。
示例 1：
输入：nums = [1,5,11,5]
输出：true
解释：nums 可以分割成 [1, 5, 5] 和 [11] 。
示例 2：
输入：nums = [1,2,3,5]
输出：false
解释：nums 不可以分为和相等的两部分
提示：
1 <= nums.length <= 200
1 <= nums[i] <= 100
法一：动态规划
class Solution {
public:
bool canPartition(vector<int>& nums) {
int nlen = nums.size();
if (nlen < 2) {
return false;
}
int total_sum = accumulate(nums.begin(), nums.end(), 0);
// 和为奇数，肯定不可以拆分
if (total_sum % 2) {
return false;
}
int max_sum = *max_element(nums.begin(), nums.end());
int part_sum = total_sum / 2;
if (max_sum > part_sum) {
return false;
}
//dp代表部分和为i
vector<vector<int> > dp(nlen, vector<int>(part_sum + 1, 0));
for (int i = 0; i < nlen; ++i) {
dp[i][0] = true;
}
dp[0][nums[0]] = true;
for(int i = 1; i < nlen; ++i)
{
int num = nums[i];
for (int j = 1; j <= part_sum; ++j)
{
if (nums[i] <= j) {
dp[i][j] = dp[i-1][j] | dp[i-1][j -num];
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[nlen - 1][part_sum];
}
};
class Solution {
public:
bool canPartition(vector<int>& nums) {
int nlen = nums.size();
if (nlen < 2) {
return false;
}
int total_sum = accumulate(nums.begin(), nums.end(), 0);
// 和为奇数，肯定不可以拆分
if (total_sum % 2) {
return false;
}
int max_sum = *max_element(nums.begin(), nums.end());
int target_sum = total_sum / 2;
if (max_sum > target_sum) {
return false;
}
vector<int> dp(target_sum + 1);
dp[0] = true;
for (int i = 0; i < nlen; ++i)
{
int num = nums[i];
for (int j = target_sum; j >= num; --j)
{
dp[j] = dp[j] | dp[j - num];
}
}
return dp[target_sum] ;
}
};
