【动态规划】LeetCode2552:优化了6版的1324模式

简介: 【动态规划】LeetCode2552:优化了6版的1324模式

类似题解法

题目

给你一个长度为 n 下标从 0 开始的整数数组 nums ,它包含 1 到 n 的所有数字,请你返回上升四元组的数目。

如果一个四元组 (i, j, k, l) 满足以下条件,我们称它是上升的:

0 <= i < j < k < l < n 且

nums[i] < nums[k] < nums[j] < nums[l] 。

示例 1:

输入:nums = [1,3,2,4,5]

输出:2

解释:

  • 当 i = 0 ,j = 1 ,k = 2 且 l = 3 时,有 nums[i] < nums[k] < nums[j] < nums[l] 。
  • 当 i = 0 ,j = 1 ,k = 2 且 l = 4 时,有 nums[i] < nums[k] < nums[j] < nums[l] 。
    没有其他的四元组,所以我们返回 2 。
    示例 2:
    输入:nums = [1,2,3,4]
    输出:0
    解释:只存在一个四元组 i = 0 ,j = 1 ,k = 2 ,l = 3 ,但是 nums[j] < nums[k] ,所以我们返回 0 。
    参数范围
    4 <= nums.length <= 4000
    1 <= nums[i] <= nums.length
    nums 中所有数字 互不相同 ,nums 是一个排列。

第一版

分析

1324模式,第1的小在最前面,其次是第3小,再次是第2小的,最后是第4小的。

变量解释

v21 v21[i2][i1] = k,表示 nums[i2]和nums[x]组成12模式的数量是k,x取值范围[0,i1)
v32 v32[i3][i2]=k,表示以num[i3]为3以nums[x]为2 组成的132模式的数量是k,x取[0,i2)

代码

class Solution {
public:
long long countQuadruplets(vector& nums) {
m_c = nums.size();
//v21[i2][i1] = k,表示 nums[i2]和nums[x]组成12模式的数量是k,x取值范围[0,i1)
vector v21(m_c,vector(m_c+1));
for (int i2 = 0; i2 < m_c; i2++)
{
for (int i1 = 0; i1 < i2; i1++)
{
v21[i2][i1 + 1] = v21[i2][i1] + (nums[i1] < nums[i2]);
}
}
vector v32(m_c, vector(m_c + 1));
for (int i3 = 0; i3 < m_c; i3++)
{
for (int i2 = i3 + 1; i2 < m_c; i2++)
{
v32[i3][i2 + 1] = v32[i3][i2];
if (nums[i3] > nums[i2])
{
v32[i3][i2 + 1] += v21[i2][i3];
}
}
}
long long llRet = 0;
for (int i3 = 0; i3 < m_c; i3++)
{
for (int i4 = i3 + 1; i4 < m_c; i4++)
{
if (nums[i3] < nums[i4])
{
llRet += v32[i3][i4];
}
}
}
return llRet;
}
int m_c;
};

测试用例

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
  if (v1.size() != v2.size())
  {
    assert(false);
    return;
  }
  for (int i = 0; i < v1.size(); i++)
  {
    assert(v1[i] == v2[i]);
  }
}
template<class T>
void Assert(const T& t1, const T& t2)
{
  assert(t1 == t2);
}
int main()
{
  Solution slu;
  vector<int> nums ;
  long long res;
  nums = { 1, 3, 2, 4, 5 };
  res = slu.countQuadruplets(nums);
  Assert(2LL, res);
  nums = { 1, 2,3,4 };
  res = slu.countQuadruplets(nums);
  Assert(0LL, res);
  nums = { 4,3,2,1 };
  res = slu.countQuadruplets(nums);
  Assert(0LL, res);
  nums = { 4,3,2,6,5,1 };
  res = slu.countQuadruplets(nums);
  Assert(0LL, res);
  nums = { 1,3,2,4 };
  res = slu.countQuadruplets(nums);
  Assert(1LL, res);
  nums = { 2,1,4,3,5 };
  res = slu.countQuadruplets(nums);
  Assert(2LL, res);
  nums.clear();
  for (int i = 0; i < 4000; i++)
  {
    nums.emplace_back(i + 1);
  }
  res = slu.countQuadruplets(nums);
  Assert(0LL, res);
  //CConsole::Out(res);
}

第二版

三步是如此相似,也许可以合并。第一步的循环似乎不同。我们把第一步的第一层循环换到第二层就更相似了。修改后的第一步:

for (int i1 = 0; i1 < m_c ; i1++)   
    {
      for (int i2 = i1+1; i2 < m_c; i2++)
      {
        v21[i2][i1 + 1] = v21[i2][i1] + (nums[i1] < nums[i2]);
      }
    }

第三版

第一层 的循环变量改成i,第一层的循环变量改成j。

class Solution {
public:
  long long countQuadruplets(vector<int>& nums) {
    m_c = nums.size();
    //v21[i2][i1] = k,表示 nums[i2]和nums[x]组成12模式的数量是k,x取值范围[0,i1)
    vector<vector<int>> v21(m_c,vector<int>(m_c+1));
    for (int i = 0; i < m_c ; i++)    
    {
      for (int j = i+1; j < m_c; j++)
      {
        v21[j][i + 1] = v21[j][i] + (nums[i] < nums[j]);
      }
    }
    vector<vector<int>> v32(m_c, vector<int>(m_c + 1));
    for (int i = 0; i < m_c; i++)
    {
      for (int j = i + 1; j < m_c; j++)
      {
        v32[i][j + 1] = v32[i][j];
        if (nums[i] > nums[j])
        {
          v32[i][j + 1] += v21[j][i];
        }
      }
    }
    long long llRet = 0;
    for (int i = 0; i < m_c; i++)
    {
      for (int j = i + 1; j < m_c; j++)
      {
        if (nums[i] < nums[j])
        {
          llRet += v32[i][j];
        }
      }
    }
    return llRet;
  }
  int m_c;
};

第四版

三轮循环合并。

class Solution {
public:
  long long countQuadruplets(vector<int>& nums) {
    m_c = nums.size();
    //v21[i2][i1] = k,表示 nums[i2]和nums[x]组成12模式的数量是k,x取值范围[0,i1)
    vector<vector<int>> v21(m_c,vector<int>(m_c+1));
    vector<vector<int>> v32(m_c, vector<int>(m_c + 1));
    long long llRet = 0;
    for (int i = 0; i < m_c ; i++)    
    {
      for (int j = i+1; j < m_c; j++)
      {
        v21[j][i + 1] = v21[j][i] + (nums[i] < nums[j]);
        v32[i][j + 1] = v32[i][j];
        if (nums[i] > nums[j])
        {
          v32[i][j + 1] += v21[j][i];
        }
        if (nums[i] < nums[j])
        {
          llRet += v32[i][j];
        }
      }
    }
    return llRet;
  }
  int m_c;
};

第五版

v2 只用到三处, v21[j][i + 1] 和 v21[j][i],可以简化成一维变量。

优化后,代码如下:

class Solution {
public:
  long long countQuadruplets(vector<int>& nums) {
    m_c = nums.size();
    //v21[i2][i1] = k,表示 nums[i2]和nums[x]组成12模式的数量是k,x取值范围[0,i1)
    vector<vector<int>> v32(m_c, vector<int>(m_c + 1));
    long long llRet = 0;
    vector<int> v21(m_c);
    for (int i = 0; i < m_c ; i++)    
    {     
      for (int j = i+1; j < m_c; j++)
      {   
        v32[i][j + 1] = v32[i][j];
        if (nums[i] > nums[j])
        {
          v32[i][j + 1] += v21[j];
        }
        if (nums[i] < nums[j])
        {
          llRet += v32[i][j];
        }
        v21[j] +=  (nums[i] < nums[j]);
      }
    }
    return llRet;
  }
  int m_c;
};

第六版

v32只用到v32[i][j + 1] v32[i][j],我们可以简化成一个变量i32,i发生变化的时候赋初值0。

class Solution {
public:
  long long countQuadruplets(vector<int>& nums) {
    m_c = nums.size();
    //v21[i2][i1] = k,表示 nums[i2]和nums[x]组成12模式的数量是k,x取值范围[0,i1)
    long long llRet = 0;
    vector<int> v21(m_c);
    for (int i = 0; i < m_c ; i++)    
    { 
      int i32 = 0;
      for (int j = i+1; j < m_c; j++)
      {         
        if (nums[i] < nums[j])
        {
          llRet += i32;
        }
        if (nums[i] > nums[j])
        {
          i32 += v21[j];
        }
        v21[j] +=  (nums[i] < nums[j]);
      }
    }
    return llRet;
  }
  int m_c;
};

扩展阅读

视频课程

有效学习:明确的目标 及时的反馈 拉伸区(难度合适),可以先学简单的课程,请移步CSDN学院,听白银讲师(也就是鄙人)的讲解。

https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了,为老板分忧,请学习C#入职培训、C++入职培训等课程

https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法,请下载《喜缺全书算法册》doc版

https://download.csdn.net/download/he_zhidan/88348653

测试环境

操作系统:win7 开发环境: VS2019 C++17

或者 操作系统:win10 开发环境:

VS2022 C++17



相关文章
|
3天前
leetcode代码记录(动态规划基础题(斐波那契数列)
leetcode代码记录(动态规划基础题(斐波那契数列)
7 0
|
18天前
[leetcode~数位动态规划] 2719. 统计整数数目 hard
[leetcode~数位动态规划] 2719. 统计整数数目 hard
|
23天前
|
算法
代码随想录算法训练营第五十六天 | LeetCode 647. 回文子串、516. 最长回文子序列、动态规划总结
代码随想录算法训练营第五十六天 | LeetCode 647. 回文子串、516. 最长回文子序列、动态规划总结
34 1
|
25天前
|
JavaScript
【leetcode】221--最大正方形-动态规划法
【leetcode】221--最大正方形-动态规划法
10 0
|
25天前
|
JavaScript
【leetcode】221. 最大正方形 动态规划法
【leetcode】221. 最大正方形 动态规划法
12 0
|
2月前
|
Go C++
【力扣】2645. 构造有效字符串的最小插入数(动态规划 贪心 滚动数组优化 C++ Go)
【2月更文挑战第17天】2645. 构造有效字符串的最小插入数(动态规划 贪心 滚动数组优化 C++ Go)
31 8
|
2月前
动态规划之解码方法【LeetCode】
动态规划之解码方法【LeetCode】
|
2月前
动态规划之使用最小花费爬楼梯【LeetCode】
动态规划之使用最小花费爬楼梯【LeetCode】
|
2月前
|
算法
动态规划之第 N 个泰波那契数/三步问题【leetCode】【算法】
动态规划之第 N 个泰波那契数/三步问题【leetCode】【算法】
|
3月前
|
机器学习/深度学习 人工智能 测试技术
【动态规划】【矩阵快速幂】LeetCode2851. 字符串转换
【动态规划】【矩阵快速幂】LeetCode2851. 字符串转换

热门文章

最新文章