dfs|前后缀分解

lc1671

前后缀分解+最长递增子序列(子序列dp)

左右开弓 典中典

class Solution {

public:

int minimumMountainRemovals(vector<int>& nums) {

int n=nums.size();

vector<int> pre(n,INT_MAX),suf(n,INT_MAX);

for(int i=0;i<n;i++){

prei=i;

for(int j=0;j<i;j++){

if(numsi>numsj){

prei=min(prei,prej+i-j-1);

}

}

}

for(int i=n-1;i>=0;i--){

sufi=n-i-1;

for(int j=n-1;j>i;j--){

if(numsi>numsj){

sufi=min(sufi,sufj+j-i-1);

}

}

}

int ans=INT_MAX;

for(int i=1;i<n-1;i++){

if(prei!=i&&sufi!=n-i-1) {

ans = min(ans, prei + sufi);

}

}

return ans;

}

};

lis复用

class Solution {

public:

//误区:原数组的最大值不一定是答案的峰值

//定义dpi为以i结尾最长递增子序列长度

//维护数组prei,表示前i个元素的最长递增子序列长度,每次更新完dpi插入pre

//将数组反转后求递增子序列长度,即原数组的后缀递减子序列长度

//所以可以包装一个函数,调用两次求出pre和suf数组

//原数组的最长山型序列长度即为prei + sufn-1-i - 1(因为第i个元素算了两次)

//枚举i统计最大值maxv,答案即为n - maxv

void LIS(vector<int>& nums,vector<int>& lis){

int n = nums.size();

vector<int> dp(n,1);

for(int i = 0;i < n;i++){

for(int j = i-1;j >= 0;j--){

if(numsj < numsi) dpi = max(dpi,dpj + 1);

}

lis.push_back(dpi);

}

}

int minimumMountainRemovals(vector<int>& nums) {

int n = nums.size();

vector<int> pre,suf;

LIS(nums,pre);

reverse(nums.begin(),nums.end());

LIS(nums,suf);

int maxv = 0;

for(int i = 0;i < n;i++){ //注意这里pre、suf都要>1,否则峰值会出现在一端,不符合题意

if(prei > 1 && sufn - 1 - i > 1){

maxv = max(maxv,prei + sufn - 1 - i - 1);

}

}

return n - maxv;

}

};

优化

两次贪心+二分 分别计算每个位置的最长严格递增子序列(前缀)和最长严格递减子序列(后缀),找到最长山脉子序列的长度后,用数组总长度减去该长度,得到最少需要移除的元素数量

class Solution {

public:

int minimumMountainRemovals(vector<int> &nums) {

int n = nums.size();

vector<int> suf(n), g;

for (int i = n - 1; i; i--)

{

int x = numsi;

auto it = lower_bound(g.begin(), g.end(), x);

sufi = it - g.begin() + 1; // 从 numsi 开始的最长严格递减子序列的长度

if (it == g.end())

g.push_back(x);

else

*it = x;

}

int mx = 0;

g.clear();

for (int i = 0; i < n - 1; i++) {

int x = numsi;

auto it = lower_bound(g.begin(), g.end(), x);

int pre = it - g.begin() + 1; // 在 numsi 结束的最长严格递增子序列的长度

if (it == g.end()) {

g.push_back(x);

} else {

*it = x;

}

if (pre >= 2 && sufi >= 2) {

mx = max(mx, pre + sufi - 1); // 减去重复的 numsi

}

}

return n - mx;

}

};

lc1589

差分+前缀和+贪心

++cntstart++;++

cntend + 1--;

for (int i = 1; i < n; i++)

cnti += cnti - 1;

#include <vector>

#include <algorithm>

using namespace std;

const int MOD = 1e9 + 7;

class Solution {

public:

int maxSumRangeQuery(vector<int>& nums, vector<vector<int>>& requests)

{

int n = nums.size();

// 1. 差分 统计每个索引的查询次数

vector<int> cnt(n, 0);

for (auto& req : requests)

{

int start = req0, end = req1;

++cntstart++;++

if (end + 1 < n)

++cntend + 1--;++

}

// 2. 前缀和,每个索引的实际查询次数

for (int i = 1; i < n; i++)

++cnti += cnti - 1;++

// 3. 对nums和查询次数都降序排序

sort(nums.rbegin(), nums.rend());

sort(cnt.rbegin(), cnt.rend());

// 4. 计算总结果并取余

long long ret = 0;

for (int i = 0; i < n; i++)

ret = (ret + (long long)numsi * cnti) % MOD;

return ret % MOD;

}

};

lc1339

两次递归遍历二叉树

先计算整棵树的节点值总和,再++遍历每个子树计算其节点值和++

找出子树和与剩余部分和的最大乘积

class Solution {

long long sum = 0, ret = 0;

const int MOD = 1e9 + 7;

public:

int maxProduct(TreeNode* root)

{

cal_sum(root);

dfs(root);

return ret % MOD;

}

void cal_sum(TreeNode* node)

{

if (!node) return;

sum += node->val;

cal_sum(node->left);

cal_sum(node->right);

}

long long dfs(TreeNode* node)

{

if (!node) return 0;

long long sub_sum = dfs(node->left) + dfs(node->right) + node->val;

long long p = sub_sum * (sum - sub_sum);

ret=max(ret,p);

return sub_sum;

}

};

相关推荐
漂流瓶jz2 小时前
UVA-1615 高速公路 题解答案代码 算法竞赛入门经典第二版
数据结构·算法·贪心算法·贪心·aoapc·算法竞赛入门经典·uva
凌冰_12 小时前
数据结构 - 时间空间复杂度(一)
数据结构·算法·软件工程
Pniubi12 小时前
力扣2 . 两数相加
算法·leetcode·职场和发展
戴·菲瑜12 小时前
为什么PPO难以做出顶级棋类引擎
算法·博弈论·rl·ppo
在所不辞兄15 小时前
为什么数字孪生驱动的产线标定需要在线更新机制,而不能一次标定后长期沿用?
人工智能·神经网络·其他·算法·机器学习
AvocadoZeroOneOI19 小时前
B4500 [GESP202603 三级] 凯撒密码 详细解题报告
c++·算法
cjz389921 小时前
双指针技巧:覆盖式双指针(原地覆盖)
算法
橘子131 天前
【高级数据库】关系代数基本概念
算法
电科_银尘1 天前
【大模型算法与工程 15】手写Self-Attention:Q、K、V与缩放点积
算法
郝学胜-神的一滴2 天前
Effective STL 条款03:容器中的对象复制要廉价且正确
开发语言·数据结构·c++·算法·rpc·stl