【设计】 【数学】1622 奇妙序列

简介: 【设计】 【数学】1622 奇妙序列

本文涉及知识点

设计 数学

LeetCode1622. 奇妙序列

请你实现三个 API append,addAll 和 multAll 来实现奇妙序列。

请实现 Fancy 类 :

Fancy() 初始化一个空序列对象。

void append(val) 将整数 val 添加在序列末尾。

void addAll(inc) 将所有序列中的现有数值都增加 inc 。

void multAll(m) 将序列中的所有现有数值都乘以整数 m 。

int getIndex(idx) 得到下标为 idx 处的数值(下标从 0 开始),并将结果对 109 + 7 取余。如果下标大于等于序列的长度,请返回 -1 。

示例:

输入:

[“Fancy”, “append”, “addAll”, “append”, “multAll”, “getIndex”, “addAll”, “append”, “multAll”, “getIndex”, “getIndex”, “getIndex”]

[[], [2], [3], [7], [2], [0], [3], [10], [2], [0], [1], [2]]

输出:

[null, null, null, null, null, 10, null, null, null, 26, 34, 20]

解释:

Fancy fancy = new Fancy();

fancy.append(2); // 奇妙序列:[2]

fancy.addAll(3); // 奇妙序列:[2+3] -> [5]

fancy.append(7); // 奇妙序列:[5, 7]

fancy.multAll(2); // 奇妙序列:[52, 72] -> [10, 14]

fancy.getIndex(0); // 返回 10

fancy.addAll(3); // 奇妙序列:[10+3, 14+3] -> [13, 17]

fancy.append(10); // 奇妙序列:[13, 17, 10]

fancy.multAll(2); // 奇妙序列:[132, 172, 10*2] -> [26, 34, 20]

fancy.getIndex(0); // 返回 26

fancy.getIndex(1); // 返回 34

fancy.getIndex(2); // 返回 20

提示:

1 <= val, inc, m <= 100

0 <= idx <= 105

总共最多会有 105 次对 append,addAll,multAll 和 getIndex 的调用。

数学

已经增加了n个数,令第i个数是x[i],x∈ \in[0,n)。

乘法m次。令第i个乘法的m为mml[i],它们的积为mmm[i]=mm[i]*mm[i+1] ⋯ \cdotsmm[m-1]。

mm[0]之前的所有加法参数inc之和为sumInc[0]。mm[i]和mm[i+1]之间的inc和为suninc[i],mm[m-1]之h后的和为suminc[m]。

此时,第i个数可以表示为:

a× \times×val[i]+b。如果此时乘以m,就变成了amval[i]+mb。如果此时增加inc。就变成了a× \times×val[i]+b+inc。

我们只需要记录系数(a,b)。

如果我们不能统一各数的系数(a,b),那每mul或all一次的时间复杂度是O(n),总时间复杂度是O(nn),超时。

image.png


除以 mmm[t] 就 是第i个数刚加入b(0)。mmm[t] = mmm[n-1]/ 加入第i个数的a(0)。

m_va[i] 记录第i个数加入时的a(0),m_vb[i]记录第i个数加入时b(0)。

b(i)等于 = b(0)-m_vb[i]*(mmm[m-1]/m_va[i])

代码

核心代码

template<int MOD = 1000000007>
class C1097Int
{
public:
  C1097Int(long long llData = 0) :m_iData(llData% MOD)
  {
  }
  C1097Int  operator+(const C1097Int& o)const
  {
    return C1097Int(((long long)m_iData + o.m_iData) % MOD);
  }
  C1097Int& operator+=(const C1097Int& o)
  {
    m_iData = ((long long)m_iData + o.m_iData) % MOD;
    return *this;
  }
  C1097Int& operator-=(const C1097Int& o)
  {
    m_iData = (m_iData + MOD - o.m_iData) % MOD;
    return *this;
  }
  C1097Int  operator-(const C1097Int& o)
  {
    return C1097Int((m_iData + MOD - o.m_iData) % MOD);
  }
  C1097Int  operator*(const C1097Int& o)const
  {
    return((long long)m_iData * o.m_iData) % MOD;
  }
  C1097Int& operator*=(const C1097Int& o)
  {
    m_iData = ((long long)m_iData * o.m_iData) % MOD;
    return *this;
  }
  bool operator<(const C1097Int& o)const
  {
    return m_iData < o.m_iData;
  }
  C1097Int pow(long long n)const
  {
    C1097Int iRet = 1, iCur = *this;
    while (n)
    {
      if (n & 1)
      {
        iRet *= iCur;
      }
      iCur *= iCur;
      n >>= 1;
    }
    return iRet;
  }
  C1097Int PowNegative1()const
  {
    return pow(MOD - 2);
  }
  int ToInt()const
  {
    return m_iData;
  }
private:
  int m_iData = 0;;
};
class Fancy {
public:
  Fancy() {
  }
  void append(int val) {
    m_va.emplace_back(m_a);
    m_vb.emplace_back(m_b);
    m_val.emplace_back(val);
  }
  void addAll(int inc) {
    m_b += inc;
  }
  void multAll(int m) {
    m_a *= m;
    m_b *= m;
  }
  int getIndex(int idx) {
    if (idx >= m_val.size())
    {
      return -1;
    }
    C1097Int<> biB = m_b - m_vb[idx] * (m_a * m_va[idx].PowNegative1());
    C1097Int<> biRet = m_val[idx] * m_a * m_va[idx].PowNegative1() + biB;
    return biRet.ToInt();
  }
  C1097Int<> m_a = 1, m_b = 0;
  vector<C1097Int<>> m_va, m_vb,m_val;
};

2023年8月

class Fancy {
public:
Fancy() {
}
void append(int val) {
C1097Int<> tmp(val);
tmp -= m_iAdd * m_iMul;
tmp *= m_iMul.PowNegative1();
m_vValue.emplace_back(tmp);
}
void addAll(int inc) {
m_iAdd *= m_iMul;
m_iAdd += inc;
m_iAdd *= m_iMul.PowNegative1();
}
void multAll(int m) {
m_iMul *= m;
}
int getIndex(int idx) {
if (idx >= m_vValue.size())
{
return -1;
}
return ((m_vValue[idx] + m_iAdd) * m_iMul).ToInt();
}
vector<C1097Int<>> m_vValue;
C1097Int<> m_iMul = 1;
C1097Int<> m_iAdd = 0;
};


扩展阅读

视频课程

有效学习:明确的目标 及时的反馈 拉伸区(难度合适),可以先学简单的课程,请移步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

如无特殊说明,本算法用**C++**实现。

相关文章
|
6月前
|
算法 测试技术 C++
【动态规划】【 数学】C++算法:514自由之路
【动态规划】【 数学】C++算法:514自由之路
|
6月前
|
机器学习/深度学习 算法 Java
数论中的十个基本概念
数论中的十个基本概念
|
6月前
数学基础从高一开始4、集合的基本运算2
数学基础从高一开始4、集合的基本运算2
46 0
|
6月前
数学基础从高一开始3、集合的基本运算
数学基础从高一开始3、集合的基本运算
61 0
|
6月前
|
自然语言处理
数学基础从高一开始1、集合的概念
数学基础从高一开始1、集合的概念
69 0
|
3月前
|
机器学习/深度学习 存储 人工智能
矩阵乘法运算:在这看似枯燥的数字组合中,究竟蕴含着怎样令人称奇的奥秘?
【8月更文挑战第19天】矩阵乘法不仅是数学概念,还在工程、图像处理及AI等领域发挥核心作用。例如,通过矩阵乘法可精确实现图像变换;在神经网络中,它帮助模型学习和优化以识别图像和理解语言。两个矩阵A(m×n)与B(n×p)相乘得C(m×p),其中C[i,j]为A的第i行与B的第j列元素乘积之和。尽管面临维度匹配等挑战,矩阵乘法仍在持续推动技术创新。下次享受智能服务时,不妨想想背后的矩阵乘法吧。
68 3
|
4月前
|
存储 算法 Python
震撼!Python算法设计与分析,分治法、贪心、动态规划...这些经典算法如何改变你的编程世界!
【7月更文挑战第9天】在Python的算法天地,分治、贪心、动态规划三巨头揭示了解题的智慧。分治如归并排序,将大问题拆解为小部分解决;贪心算法以局部最优求全局,如Prim的最小生成树;动态规划通过存储子问题解避免重复计算,如斐波那契数列。掌握这些,将重塑你的编程思维,点亮技术之路。
72 1
|
5月前
|
算法 Java Go
斐波那契数列是一个非常经典的数学问题,在计算机科学中也经常被用作算法设计和分析的例子。
斐波那契数列是一个非常经典的数学问题,在计算机科学中也经常被用作算法设计和分析的例子。
|
6月前
|
算法 C++
【软件设计师备考 专题 】数学基础知识:命题逻辑、谓词逻辑、形式逻辑与数值计算
【软件设计师备考 专题 】数学基础知识:命题逻辑、谓词逻辑、形式逻辑与数值计算
80 0
|
算法
梯度下降算法详解(从下山比喻、数学推导到代码实现)
梯度下降算法详解(从下山比喻、数学推导到代码实现)
993 0