【线段树】1622. 奇妙序列

最新推荐文章于 2024-04-27 19:42:34 发布
最新推荐文章于 2024-04-27 19:42:34 发布
阅读量632 收藏 32
点赞数 14
分类专栏： # 困难算法题 文章标签： 算法 c++ leetcode 线段树 奇妙序列 加 乘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/137097381
版权

本文涉及知识点

设计 数学 线段树

本文基础解法

【设计】 【数学】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 的调用。

线段树

由于最多105个元素，故线段树的元素个数105，初始全部为0。m_iSize记录已经插入的数据。
插入相当于对m_iSize单点更新（加法），乘和加相当于区域[0,m_iSize-1]更新。
std::pair记录更新的参数。first表示要乘的数，second 表示要加的数。两次操作合并的代码如下：

 virtual void OnUpdateRecord(TRecord& old, const TRecord& newRecord) override
	  {
		  old.first *= newRecord.first;
		  old.second = old.second * newRecord.first + newRecord.second;
	  }

推导过程x先乘以a,加b；在乘以c，加d。
x1 = ax +b
x2 = axc + bc + d
相当于：x直接乘以 ab 后加bc+d。

代码

核心代码

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;
	}
	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;;
};

template<class TSave, class TRecord>
class CLineTree
{
public:
	CLineTree(int iEleSize, TRecord recordNull=0)
		:m_iEleSize(iEleSize), m_vArr(m_iEleSize * 4), m_vRecord(m_iEleSize * 4, recordNull), m_recordNull(recordNull)
	{

	}
	void Update(int iLeftIndex, int iRightIndex, TRecord value)
	{
		Update(1, 1, m_iEleSize, iLeftIndex + 1, iRightIndex + 1, value);
	}
	template<class TGet>
	void Query(const TGet& oGet, int iLeftIndex, int iRightIndex)
	{
		Query(oGet, 1, 1, m_iEleSize, iLeftIndex + 1, iRightIndex + 1);
	}
private:
	virtual void OnUpdateRecord(TRecord& old, const TRecord& newRecord) = 0;
	virtual void OnUpdateParent(TSave& par, const TSave& left, const TSave& r) = 0;
	virtual void OnUpdate(TSave& save, const int& len, const TRecord& iUpdate) = 0;
	template<class TGet>
	void Query(const TGet& oGet, int iNode, int iSaveLeft, int iSaveRight, int iQueryLeft, int iQueryRight)
	{
		if ((iQueryLeft <= iSaveLeft) && (iQueryRight >= iSaveRight))
		{
			oGet(m_vArr[iNode]);
			return;
		}
		Fresh(iNode, iSaveLeft, iSaveRight);
		const int iMid = iSaveLeft + (iSaveRight - iSaveLeft) / 2;
		if (iMid >= iQueryLeft)
		{
			Query(oGet, iNode * 2, iSaveLeft, iMid, iQueryLeft, iQueryRight);
		}
		if (iMid + 1 <= iQueryRight)
		{
			Query(oGet, iNode * 2 + 1, iMid + 1, iSaveRight, iQueryLeft, iQueryRight);
		}
	}
	void Update(int iNode, int iSaveLeft, int iSaveRight, int iOpeLeft, int iOpeRight, TRecord value)
	{
		if (iNode >= m_vArr.size())
		{
			return;
		}
		if ((iOpeLeft <= iSaveLeft) && (iOpeRight >= iSaveRight))
		{
			OnUpdate(m_vArr[iNode], min(iSaveRight, iOpeRight) - max(iSaveLeft, iOpeLeft) + 1, value);
			OnUpdateRecord(m_vRecord[iNode], value);
			return;
		}
		Fresh(iNode, iSaveLeft, iSaveRight);
		const int iMid = iSaveLeft + (iSaveRight - iSaveLeft) / 2;
		if (iMid >= iOpeLeft)
		{
			Update(iNode * 2, iSaveLeft, iMid, iOpeLeft, iOpeRight, value);
		}
		if (iMid + 1 <= iOpeRight)
		{
			Update(iNode * 2 + 1, iMid + 1, iSaveRight, iOpeLeft, iOpeRight, value);
		}
		// 如果有后代，至少两个后代
		OnUpdateParent(m_vArr[iNode], m_vArr[iNode * 2], m_vArr[iNode * 2 + 1]);
	}
	void Fresh(int iNode, int iDataLeft, int iDataRight)
	{
		if (m_recordNull == m_vRecord[iNode])
		{
			return;
		}
		const int iMid = iDataLeft + (iDataRight - iDataLeft) / 2;
		Update(iNode * 2, iDataLeft, iMid, iDataLeft, iMid, m_vRecord[iNode]);
		Update(iNode * 2 + 1, iMid + 1, iDataRight, iMid + 1, iDataRight, m_vRecord[iNode]);
		m_vRecord[iNode] = m_recordNull;
	}
	const int m_iEleSize;
	vector<TSave> m_vArr;
	vector<TRecord> m_vRecord;
	const TRecord m_recordNull;
};


  template<class TSave = C1097Int<>, class TRecord = pair<C1097Int<>,C1097Int<>> >
  class CMyLineTree : public CLineTree<TSave, TRecord>
  {
  public:
	  using CLineTree<TSave, TRecord>::CLineTree;	  
  protected:
	  virtual void OnUpdateRecord(TRecord& old, const TRecord& newRecord) override
	  {
		  old.first *= newRecord.first;
		  old.second = old.second * newRecord.first + newRecord.second;
	  }
	  virtual void OnUpdateParent(TSave& par, const TSave& left, const TSave& r) override
	  {
	  }
	  virtual void OnUpdate(TSave& save, const int& len, const TRecord& iUpdate) override
	  {
		  save = save * iUpdate.first + iUpdate.second;
	  }
  };
  class Fancy {
  public:
	  Fancy() :m_lineTree(100'000, { 1,0 }) {
	  }
	  void append(int val) {
		  m_lineTree.Update(m_iSize, m_iSize, { 1,val });
		  m_iSize++;
	  }
	  void addAll(int inc) {
		  m_lineTree.Update(0, m_iSize - 1, { 1,inc });
	  }

	  void multAll(int m) {
		  m_lineTree.Update(0, m_iSize - 1, { m,0 });
	  }

	  int getIndex(int idx) {
		  if (idx >= m_iSize)
		  {
			  return -1;
		  }
		  C1097Int<> iiRet = 0;
		  auto Get = [&](const C1097Int<>& value ) {
			  iiRet += value;
		  };
		  m_lineTree.Query(Get,idx,idx);
		  return iiRet.ToInt();
	  }
	  CMyLineTree<> m_lineTree;
	  int m_iSize=0;
  };

旧代码

旧类库，将TRecord 的默认值 设计成参数，编辑器对次有限制。改成成员变量。
template
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;;
};
template<class TSave, class TRecord, TRecord RecordNull = 0>
class CLineTree
{
public:
CLineTree(int iEleSize)
:m_iEleSize(iEleSize), m_vArr(m_iEleSize * 4), m_vRecord(m_iEleSize * 4, RecordNull)
{

}
void Update(int iLeftIndex, int iRightIndex, TRecord value)
{
	Update(1, 1, m_iEleSize, iLeftIndex + 1, iRightIndex + 1, value);
}
template<class TGet>
void Query(const TGet& oGet, int iLeftIndex, int iRightIndex)
{
	Query(oGet, 1, 1, m_iEleSize, iLeftIndex + 1, iRightIndex + 1);
}

private:
virtual void OnUpdateRecord(TRecord& old, const TRecord& newRecord) = 0;
virtual void OnUpdateParent(TSave& par, const TSave& left, const TSave& r) = 0;
virtual void OnUpdate(TSave& save, const int& len, const TRecord& iUpdate) = 0;
template
void Query(const TGet& oGet, int iNode, int iSaveLeft, int iSaveRight, int iQueryLeft, int iQueryRight)
{
if ((iQueryLeft <= iSaveLeft) && (iQueryRight >= iSaveRight))
{
oGet(m_vArr[iNode]);
return;
}
Fresh(iNode, iSaveLeft, iSaveRight);
const int iMid = iSaveLeft + (iSaveRight - iSaveLeft) / 2;
if (iMid >= iQueryLeft)
{
Query(oGet, iNode * 2, iSaveLeft, iMid, iQueryLeft, iQueryRight);
}
if (iMid + 1 <= iQueryRight)
{
Query(oGet, iNode * 2 + 1, iMid + 1, iSaveRight, iQueryLeft, iQueryRight);
}
}
void Update(int iNode, int iSaveLeft, int iSaveRight, int iOpeLeft, int iOpeRight, TRecord value)
{
if (iNode >= m_vArr.size())
{
return;
}
if ((iOpeLeft <= iSaveLeft) && (iOpeRight >= iSaveRight))
{
OnUpdate(m_vArr[iNode], min(iSaveRight, iOpeRight) - max(iSaveLeft, iOpeLeft) + 1, value);
OnUpdateRecord(m_vRecord[iNode], value);
return;
}
Fresh(iNode, iSaveLeft, iSaveRight);
const int iMid = iSaveLeft + (iSaveRight - iSaveLeft) / 2;
if (iMid >= iOpeLeft)
{
Update(iNode * 2, iSaveLeft, iMid, iOpeLeft, iOpeRight, value);
}
if (iMid + 1 <= iOpeRight)
{
Update(iNode * 2 + 1, iMid + 1, iSaveRight, iOpeLeft, iOpeRight, value);
}
// 如果有后代，至少两个后代
OnUpdateParent(m_vArr[iNode], m_vArr[iNode * 2], m_vArr[iNode * 2 + 1]);
}
void Fresh(int iNode, int iDataLeft, int iDataRight)
{
if (RecordNull == m_vRecord[iNode])
{
return;
}
const int iMid = iDataLeft + (iDataRight - iDataLeft) / 2;
Update(iNode * 2, iDataLeft, iMid, iDataLeft, iMid, m_vRecord[iNode]);
Update(iNode * 2 + 1, iMid + 1, iDataRight, iMid + 1, iDataRight, m_vRecord[iNode]);
m_vRecord[iNode] = RecordNull;
}
const int m_iEleSize;
vector m_vArr;
vector m_vRecord;
};
const long long llUnit = 2000’000’000;
template<class TSave = C1097Int<>, class TRecord = long long, TRecord RecordNull = llUnit >
class CMyLineTree : public CLineTree<TSave, TRecord, RecordNull>
{
public:
using CLineTree<TSave, TRecord, RecordNull>::CLineTree;
protected:
virtual void OnUpdateRecord(TRecord& old, const TRecord& newRecord) override
{
long long mul = (old/ llUnit) * (newRecord/ llUnit);
long long add = (old% llUnit) * (newRecord/ llUnit) + (newRecord% llUnit);
old = C1097Int<>(mul).ToInt()*llUnit + C1097Int<>(add).ToInt();
}
virtual void OnUpdateParent(TSave& par, const TSave& left, const TSave& r) override
{
}
virtual void OnUpdate(TSave& save, const int& len, const TRecord& iUpdate) override
{
save = save * (iUpdate/ llUnit) + iUpdate% llUnit ;
}
};
class Fancy {
public:
Fancy():m_lineTree(100’000){
}
void append(int val) {
m_lineTree.Update(m_iSize, m_iSize, llUnit + val );
m_iSize++;
}
void addAll(int inc) {
m_lineTree.Update(0, m_iSize-1, llUnit + inc);
}
void multAll(int m) {
m_lineTree.Update(0, m_iSize - 1, llUnit *m);
}
int getIndex(int idx) {
if (idx >= m_iSize)
{
return -1;
}
C1097Int<> iiRet = 0;
auto Get = [&](const C1097Int<>& value ) {
iiRet += value;
};
m_lineTree.Query(Get,idx,idx);
return iiRet.ToInt();
}
CMyLineTree<> m_lineTree;
int m_iSize=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++**实现。

闻缺陷则喜何志丹
关注
  • 14
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
线段树 线段树acm.ppt
09-17
线段树 线段树acm.ppt
线段树汇总
闻缺陷则喜何志丹
04-18 1083
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 区间更新（查询）的时间复杂度是O(logn)，使用懒惰法只会影响以下四类节点，每类节点数量都不超过logn。一，左边界及其祖先。二，右边界及其祖先。三，第一类的兄弟节点。四，第二类的兄弟节点。
LeetCode题解(1622)：奇妙序列(Python)
长行
01-10 394
题目：原题链接（困难） 标签：数学、设计、线段树 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) append = O(1)O(1)O(1) ; addAll = O(1)O(1)O(1) ; multAll = O(1)O(1)O(1) ; getIndex = O(N)O(N)O(N) O(N)O(N)O(N) 超出时间限制 Ans 2 (Python) append = O(1)O(1)O(1) ; addAll = O(1)O(1)O(1) ; multAl
HDU1540——线段树维护连续区间
mumei的博客
12-12 220
题目链接：https://vjudge.net/problem/HDU-1540#author=cqbzguomao Description 在抗日战争期间，华北平原广大地区进行了大规模的隧道战。 一般来说，通过隧道连接的村庄排成一列。 除了两端，每个村庄都与两个相邻的村庄直接相连。 入侵者经常对一些村庄发动袭击并摧毁其中的部分隧道。 八路军指挥官要求最新的隧道和村庄连接状态。 如果某些...
一些奇妙的线段树操作
weixin_30291791的博客
02-13 99
学过数据结构和会做题完全是两个概念orz 各种各样的题目都应该见识一下 简单的目录： 最大连续长度 吉司机线段树 线段树合并/分裂 最大连续长度问题 典型题目：HDU 3911（$Black$ $And$ $White$） 题目大意：有一个长度为$n$（$1\le n\le 10^5$）的$01$序列$a_i$，现在有$m$个操作：将区间$[l_i,r_i]$反转（$0...
线段树(C++).pptx
04-09
线段树的结构 线段树是一棵二叉树，其结点是一条“线段”——[a,b]，它的左儿子和右儿子分别是这条线段的左半段和右半段，即[a, (a+b)/2 ]和[(a+b)/2 ,b]。线段树的叶子结点是长度为1的单位线段[a,a+1]。下图就是一...
加法线段树模板.cpp
10-19
加法线段树模板
线段树.pdf
12-05
线段树完全版，涉及到线段树的所有用法。 包括单点更新（增减，替换），区间求和，区间最值。 区间求最大值的位置。 成段更新（延迟标记，增减）。 离散化 扫描线
pku2104.rar_线段树
09-23
PKU2104的源代码，高级数据结构线段树的应用之一：找数据。
偏微分方程算法之五点菱形差分法
L_peanut的博客
04-26 523
主要对二维椭圆型方程的五点菱形差分算法进行推导及算例的C++实现。
算法训练营day21
wugong_true的博客
04-23 386
接下来，根据计数count与最大计数maxCount的比较，更新众数的结果数组resList和最大计数maxCount。如果count大于maxCount，则清空resList并将当前节点值添加进去，并更新maxCount为count；接着，根据resList中的众数，创建一个整型数组res，并将其返回作为结果。然后，通过与前一个节点的值进行比较，判断当前节点值出现的次数。如果当前节点与前一个节点的值不同，说明出现了一个新的值，将计数count重置为1；，计算相邻两个元素的差值，并将较小的差值更新到。
二分搜索法
m0_73950754的博客
04-26 222
二分搜索法
代码随想录算法训练营day40
weixin_43390031的博客
04-23 389
1为头，左子树节点个数为0，右子数节点个数为2，即dp[0]*dp[2]，2为头，dp[1]*dp[1]，3为头dp[2]*dp[0]。故对dp[i]，我们也考虑1到i为头节点的数量相加，dp[i]=dp[0]*dp[i-1]+dp[1]*dp[i-2]+…时间复杂度O(n^2)。(i-2)取最大值，综合讨论一下就是拆成i-j和j，然后比较dp[i-j]*j和(i-j)*j的最大值，这里因为dp[i-j]必须要进行至少拆成两个数，所以没有包含i-j，故我们还需要比较i-j，递推公式就是。
【算法学习】线段树基础版
weixin_55939638的博客
04-23 514
根结点维护的是区间1 到 4，结点权值是该区间的和，再将区间一份为二，其左儿子维护的是 1 - 2，右儿子维护的是 3 - 4 ，以此类推，直到结点维护的区间长度为1。线段树可以理解为一个二叉树，如果是利用线段树求区间的和，那么每个结点的权值维护的是结点所维护区间的和，再将该区间一分为二，分别交由左右儿子维护。从根节点开始，目标区间和左子树有交集，递归左子树，目标区间和右子树有交集 ，递归右子树；从根节点开始，目标区间和左子树有交集，递归左子树，目标区间和右子树有交集 ，递归右子树；
第六章 图
最新发布
qq_44419734的博客
04-27 326
带权有向图中，顶点表示事件，有向边表示活动，边上的权值表示完成该活动的开销（如完成活动所需要的时间），称之为用边表示活动的网络。
局部多项式近似与 AMPM 算法
weixin_43608857的博客
04-26 261
相位解缠的 CKF局部多项式系数递推估计法 谢 先 明 ,孙 玉 铮 ,梁 小 星 ,曾 庆 宁 ,郑 展 恒。效果不是很好，放弃了，
最大层内元素和
青釉Oo的博客
04-23 189
最大层内元素和
【力扣】16. 最接近的三数之和
嵌入式小菜鸟一枚~
04-25 375
【力扣】16. 最接近的三数之和
Python 线段树
10-06
Python中的线段树是一种用于解决区间查询问题的数据结构。线段树可以被看作是一棵二叉树，其中每个节点代表了一个区间。每个内部节点都有两个子节点，左子节点代表区间的左半部分，右子节点代表区间的右半部分。叶...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值