RMQ的FischerHeun算法实现(代码可能有错)

已于 2024-06-16 00:54:15 修改
阅读量292 收藏 3
点赞数 8
文章标签： 算法 c++
于 2024-06-15 20:43:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/naturerun/article/details/139707726
版权

RMQ的FischerHeun算法是构思非常巧妙的RMQ算法的变种，该算法的核心思想是在利用ballot number的模拟笛卡尔树的构建过程中计算每一棵笛卡尔数对应的类型,然后在对查询序列预处理的过程中计算具有实际数据的特定segment对应的笛卡尔树的类型，最后在RMQ查询过程中利用segment对应的类型找到对应笛卡尔树，利用其最近公共祖先完成RMQ查询。这个算法的精华之处在于笛卡尔树类型的计算，原论文中代码不算复杂但是原理比较难以理解，我在实现这个算法的过程中半懂不懂，多次尝试后总算完成了代码编写.但代码可能存在未知的错误和bug，目前只对长为256的查询序列(segment长度为3)通过了测试用例,更长的segment由于数据量过大没有测试，发现错误请告知，我会尽可能修改正确
具体参见论文Theoretical and Practical Improvements on the RMQ-Problem,with Applications to LCA and LCE
作者 Johannes Fischer and Volker Heun
C++代码:

#include <iostream>
#include <vector>
#include <stack>
#include <random>
using namespace std;

size_t log2(size_t N)
{
	size_t k = 0;
	while (1ull << k <= N)
	{
		++k;
	}
	--k;
	return k;
}

template <typename T>
struct m_info
{
	T m_value;
	size_t index;
	m_info(const T& m, size_t i) :m_value(m), index(i) {}
	m_info() = default;
	bool operator == (const m_info& be_compared)const { return m_value == be_compared.m_value && index == be_compared.index; }
};

template <typename T>
const m_info<T>& min_m_info(const m_info<T>& left, const m_info<T>& right)
{
	if (left.m_value <= right.m_value)
	{
		return left;
	}
	return right;
}

template <typename T>
void SparseTable(vector<vector<m_info<T>>>& d, vector<T>& seq, size_t left, size_t right)  //[left, right]从0开始
{
	for (size_t i = 0; i <= right - left; ++i)
	{
		d[i][0] = m_info<T>(seq[i + left], i);
	}

	for (size_t i = 1; (1 << i) <= right - left + 1; ++i)
	{
		for (size_t j = 0; j <= right - left + 1 - (1 << i); ++j)
		{
			if (d[j][i - 1].m_value <= d[j + (1 << i - 1)][i - 1].m_value)
			{
				d[j][i] = d[j][i - 1];
			}
			else
			{
				d[j][i] = d[j + (1 << i - 1)][i - 1];
			}
		}
	}
}

template <typename T>
m_info<T> query(size_t i, size_t j, vector<vector<m_info<T>>>& d)  i,j从0开始算
{
	size_t l = j - i + 1;
	size_t k = log2(l);
	if (d[i][k].m_value <= d[j - (1 << k) + 1][k].m_value)
		return d[i][k];
	return d[j - (1 << k) + 1][k];
}

template <typename T>
m_info<T> query(size_t i, size_t j, vector<vector<size_t>>& d, size_t offset, vector<T> &value_seq)    /i, j从0开始
{
	return m_info<T>(value_seq[offset + d[i][j] - 1], d[i][j] - 1);
}

void computeBallotNumber(vector<vector<size_t>>& ballot_num)
{
	
	for (size_t i = 0; i < ballot_num.size(); ++i)
	{
		ballot_num[0][i] = 1;
	}
	for (size_t i = 1; i < ballot_num.size(); ++i)
	{
		for (size_t j = 1; j <= i; ++j)
		{
			ballot_num[j][i] = ballot_num[j][i - 1] + ballot_num[j - 1][i];
		}
	}
}

enum class StackOperateType { PUSH, POP };
struct StackOperationSeqNode
{
	StackOperateType op_type;
	size_t be_operated_index;
	StackOperationSeqNode(StackOperateType o, size_t b) :op_type(o), be_operated_index(b) {}
	StackOperationSeqNode() = default;
};

template <typename T>
class FischerHeunRMQ
{
public:
	m_info<T> queryRMQ(size_t i, size_t j);
	FischerHeunRMQ(vector<T>& v, const T& m);
private:
	T max_value_for_type;
	size_t N;
	size_t segment_length;
	size_t block_num;
	vector<T> value_seq;
	vector<size_t> block_type;
	vector<vector<vector<size_t>>> group_in_query_map_table;
	vector<vector<m_info<T>>> group_between_query_table;
	vector<size_t> min_in_block_index;
	void preProcess(vector<vector<size_t>>& ballot_num);
	size_t computeTypeForEveryBlock(size_t left_start, vector<vector<size_t>>& ballot_num);
	void enumerateBlockTypePreprocessRMQ(size_t i, size_t q, stack<size_t>& work_stack, vector<StackOperationSeqNode>& op_seq, size_t op_seq_index, size_t N, vector<vector<size_t>>& ballot_num, vector<vector<vector<size_t>>>& group_in_query_map_table);
	void computeRMQForType(const vector<StackOperationSeqNode>& op_seq, size_t op_seq_index, vector<vector<size_t>>& LCA);
};

template <typename T>
void FischerHeunRMQ<T>::preProcess(vector<vector<size_t>>& ballot_num)   //
{
	vector<T> m_value_for_every_block(block_num);
	size_t start_index_for_left_bound = 0;
	for (size_t i = 0; i < block_num; ++i)
	{
		block_type[i] = computeTypeForEveryBlock(start_index_for_left_bound, ballot_num);
		m_info<T> t = query(0, segment_length - 1, group_in_query_map_table[block_type[i]], start_index_for_left_bound, value_seq);
		start_index_for_left_bound = start_index_for_left_bound + segment_length;
		m_value_for_every_block[i] = t.m_value;
		min_in_block_index[i] = t.index;
	}
	SparseTable(group_between_query_table, m_value_for_every_block, 0, m_value_for_every_block.size() - 1);
}

template <typename T>
FischerHeunRMQ<T>::FischerHeunRMQ(vector<T>& v, const T& m) :value_seq(v), N(v.size()), segment_length(log2(N)/4 + 1), block_num(N% segment_length != 0 ? N / segment_length + 1 : N / segment_length),
group_between_query_table(block_num, vector<m_info<T>>(log2(block_num) + 1)), max_value_for_type(m), block_type(block_num), min_in_block_index(block_num)   
{
	if (value_seq.empty())
	{
		cout << "ERROR输入序列为空!" << endl;
		exit(-1);
	}

	size_t r;
	if ((r = N % segment_length) != 0)
	{
		r = segment_length - r;
		for (size_t i = 1; i <= r; ++i)
		{
			value_seq.push_back(m);
		}
	}

	vector<vector<size_t>> ballot_num(segment_length + 1, vector<size_t>(segment_length + 1, 0));
	computeBallotNumber(ballot_num);

	new (&group_in_query_map_table) vector<vector<vector<size_t>>>(ballot_num[segment_length][segment_length] + 1, vector<vector<size_t>>(segment_length, vector<size_t>(segment_length)));
	for (size_t i = 0; i < group_in_query_map_table.size(); ++i)
	{
		for (size_t j = 0; j < segment_length; ++j)
		{
			group_in_query_map_table[i][j][j] = j + 1;
		}
	}
	if (segment_length > 1)
	{
		stack<size_t> work_stack;
		work_stack.push(1);
		vector<StackOperationSeqNode> op_seq(2 * segment_length - 1);  //改
		enumerateBlockTypePreprocessRMQ(2, segment_length, work_stack, op_seq, 0, 0, ballot_num, group_in_query_map_table);
	}
	   
	preProcess(ballot_num);
}

template <typename T>
size_t FischerHeunRMQ<T>::computeTypeForEveryBlock(size_t left_start, vector<vector<size_t>>& ballot_num)
{
	vector<T> rp(segment_length + 2);
	size_t q = segment_length;
	size_t type_value = 0;

	for (size_t i = 1; i <= segment_length; ++i)
	{
		while (q + i - segment_length != 1 && rp[q + i - segment_length] > value_seq[left_start + i - 1])
		{
			type_value += ballot_num[segment_length - i][q];
			--q;
		}
		rp[q + i - segment_length + 1] = value_seq[left_start + i - 1];
	}
	return type_value;
}

template <typename T>
void FischerHeunRMQ<T>::computeRMQForType(const vector<StackOperationSeqNode>& op_seq, size_t op_seq_index, vector<vector<size_t>> &LCA)  //对角线初始化
{
	vector<bool> in_stack(segment_length, false);
	stack<size_t> work_stack;
	in_stack[0] = true;  //是否必为1
	work_stack.push(0);
	work_stack.push(1);
	for (size_t i = 0; i <= op_seq_index; ++i)     //i应从1开始,0需预处理 
	{
		if (op_seq[i].op_type == StackOperateType::PUSH)
		{
			in_stack[op_seq[i].be_operated_index - 1] = true;

			for (size_t j = work_stack.top() + 1; j < op_seq[i].be_operated_index; ++j)
			{
				LCA[j - 1][op_seq[i].be_operated_index - 1] = op_seq[i].be_operated_index;
			}

			size_t k;
			for (size_t j = work_stack.top(); j >= 1; --j)
			{
				if (in_stack[j - 1])
				{
					k = j;
					LCA[j - 1][op_seq[i].be_operated_index - 1] = j;
				}
				else
				{
					LCA[j - 1][op_seq[i].be_operated_index - 1] = k;
				}
			}
			work_stack.push(op_seq[i].be_operated_index);
		}
		else
		{
			in_stack[op_seq[i].be_operated_index - 1] = false;
			work_stack.pop();
		}
	}
}

template<typename T>
void FischerHeunRMQ<T>::enumerateBlockTypePreprocessRMQ(size_t i, size_t q, stack<size_t> &work_stack, vector<StackOperationSeqNode> &op_seq, size_t op_seq_index, size_t N, vector<vector<size_t>> &ballot_num, vector<vector<vector<size_t>>> &group_in_query_map_table)
{  //注意第一层递归调用
	work_stack.push(i);
	op_seq[op_seq_index] = StackOperationSeqNode(StackOperateType::PUSH, i);
	if (i == segment_length)
	{
		computeRMQForType(op_seq, op_seq_index, group_in_query_map_table[N]);
	}
	else
	{
		enumerateBlockTypePreprocessRMQ(i + 1, q, work_stack, op_seq, op_seq_index + 1, N, ballot_num, group_in_query_map_table);
	}
	work_stack.pop();

	if (work_stack.empty() == false)
	{
		op_seq[op_seq_index] = StackOperationSeqNode(StackOperateType::POP, work_stack.top());
		work_stack.pop();
		enumerateBlockTypePreprocessRMQ(i, q - 1, work_stack, op_seq, op_seq_index + 1, N + ballot_num[segment_length - i][q], ballot_num, group_in_query_map_table);
		work_stack.push(op_seq[op_seq_index].be_operated_index);
	}
}

template <typename T>
m_info<T> FischerHeunRMQ<T>::queryRMQ(size_t i, size_t j)
{
	if (i > j || j > N)
	{
		cout << "非法的查询索引!" << endl;
		exit(-1);
	}

	size_t i_block_index = i / segment_length;
	size_t i_in_block_index = i % segment_length;
	size_t j_block_index = j / segment_length;
	size_t j_in_block_index = j % segment_length;
	m_info<T> result;
	size_t first_value_in_block_offset;
	if (i_block_index == j_block_index)
	{
		first_value_in_block_offset = i_block_index * segment_length;
		result = query(i_in_block_index, j_in_block_index, group_in_query_map_table[block_type[i_block_index]], first_value_in_block_offset, value_seq);
	}
	else
	{
		if (i_in_block_index == 0 && j_in_block_index == segment_length - 1)
		{
			result = query(i_block_index, j_block_index, group_between_query_table);
			size_t block_index = result.index;
			result = m_info<T>(result.m_value, min_in_block_index[block_index]);
			first_value_in_block_offset = block_index * segment_length;
		}
		else
		{
			m_info<T> r_ref;
			m_info<T> result2;
			m_info<T> result3;
			size_t block_index;
			if (i_block_index + 1 == j_block_index)
			{
				result2 = query(i_in_block_index, segment_length - 1, group_in_query_map_table[block_type[i_block_index]], i_block_index * segment_length, value_seq);
				result3 = query(0, j_in_block_index, group_in_query_map_table[block_type[j_block_index]], j_block_index * segment_length, value_seq);
				r_ref = min_m_info(result2, result3);
			}
			else
			{
				if (i_in_block_index == 0)
				{
					result = query(i_block_index, j_block_index - 1, group_between_query_table);
				}
				else if (j_in_block_index == segment_length - 1)
				{
					result = query(i_block_index + 1, j_block_index, group_between_query_table);
				}
				else
				{
					result = query(i_block_index + 1, j_block_index - 1, group_between_query_table);
				}

				block_index = result.index; 
				result = m_info<T>(result.m_value, min_in_block_index[block_index]);

				if (i_in_block_index == 0 || j_in_block_index == segment_length - 1)
				{
					if (i_in_block_index == 0)
					{
						result2 = query(0, j_in_block_index, group_in_query_map_table[block_type[j_block_index]], j_block_index * segment_length, value_seq);
					}
					else
					{
						result2 = query(i_in_block_index, segment_length - 1, group_in_query_map_table[block_type[i_block_index]], i_block_index * segment_length, value_seq);
					}
					r_ref = min_m_info(result, result2);
				}
				else
				{
					result2 = query(i_in_block_index, segment_length - 1, group_in_query_map_table[block_type[i_block_index]], i_block_index * segment_length, value_seq);
					result3 = query(0, j_in_block_index, group_in_query_map_table[block_type[j_block_index]], j_block_index * segment_length, value_seq);
					r_ref = min_m_info(result, min_m_info(result2, result3));
				}
			}

			if (i_block_index + 1 != j_block_index && r_ref == result)
			{
				first_value_in_block_offset = block_index * segment_length;
			}
			else
			{
				if (i_block_index + 1 == j_block_index && r_ref == result3 || i_block_index + 1 != j_block_index && (i_in_block_index != 0 && j_in_block_index != segment_length - 1 && r_ref == result3))
				{
					first_value_in_block_offset = j_block_index * segment_length;
					result3.index += first_value_in_block_offset;
					return result3;
				}
				else
				{
					if (i_block_index + 1 != j_block_index && i_in_block_index == 0)
					{
						first_value_in_block_offset = j_block_index * segment_length;
					}
					else
					{
						first_value_in_block_offset = i_block_index * segment_length;
					}

					result2.index += first_value_in_block_offset;
					return result2;
				}
			}
		}
	}
	result.index += first_value_in_block_offset;
	return result;
}


int main()
{
	const int N = 256;
	vector<long long> rmq_seq(N);
	for (size_t i = 0; i < N; ++i)
	{
		rmq_seq[i] = i + 1;
	}
	shuffle(rmq_seq.begin(), rmq_seq.end(), default_random_engine());
	FischerHeunRMQ<long long> obj(rmq_seq, 0xffffffffffffffffull >> 1);
	for (size_t i = 0; i < rmq_seq.size() - 1; ++i)
	{
		for (size_t j = i + 1; j < rmq_seq.size(); ++j)
		{
			m_info<long long> r = obj.queryRMQ(i, j);
			long long m = rmq_seq[i];
			for (size_t k = i + 1; k <= j; ++k)
			{
				if (rmq_seq[k] < m)
				{
					m = rmq_seq[k];
				}
			}
			if (r.m_value == m)
			{
				cout << "[" << i << "," << j << "]查询结果正确!" << endl;
			}
			else
			{
				cout << "[" << i << "," << j << "]查询结果错误!" << endl;
				exit(-1);
			}
		}
	}
	return 0;
}
naturerun
关注
  • 8
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++：实现RMQ算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-26 166
C++：实现RMQ算法(附完整源码)
C++:实现RMQ算法​(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-16 278
C++:实现RMQ算法​(附完整源码)
RMQ算法讲解
热门推荐
不期而遇
04-11 3万+
现在给你一个问题：给你一个数组 ，其中有N个数字，现在给你一次询问，给你区间[l ，r]，问你在这个区间内的最大值为多少? 哇！这题简单啊，一个for循环，遍历数组记录最大值输出即可啊。 那好，现在我告诉你假设N为50000，给你Q次询问（(1 ≤ Q ≤ 200,000)）,如果这种情况，我们还每次都进行暴力遍历求解的话，那么无论你提交几万次都会得到如下结果: 是的，这种暴...
RMQ算法
qq_37957064的博客
12-21 3640
RMQ介绍   要介绍RMQ算法首先要介绍其解决的问题，RMQ是一个解决多个区间最值查询的算法，RMQ（Range Minimum/Maximum Query）,即区间最值查询，如果我们要查询某一个区间内的最值，显然我们可以用暴力搜索的方式在O(n)的时间复杂度内获得结果，但是当我们要查询10000个不同区间内的最值时，我们如果依然采用暴力搜索的方式，那么时间复杂度就会变成O(mn)，其中m指的是查询次数，n指的是数据个数。   RMQ算法的目标就是降低多区间最值查询问题的时间复杂度，RMQ算法是通过动态规
RMQ 算法（图示）
小新的博客
07-07 1422
RMQ算法(图示）
RMQ标准算法
qq_73775097的博客
06-01 523
最终,当我们需要查询区间[i, j]内的最小值时,只需要从预处理好的结果中取出对应的块内最小值即可,时间复杂度为O(1)。现在我们的问题是将 LCA 问题转化为简化的 RMQ 问题。因为 LCA 是这两个节点的共同祖先,而在二叉搜索树的性质下,LCA 节点的值一定是区间 [i, j] 内的最小值。最后这一步的核心思想是利用动态规划的方法来预处理这个简化的RMQ问题,从而实现O(1)的查询时间复杂度。对于任意一个节点 u,它的左子树中所有节点的值都小于 u 的值,右子树中所有节点的值都大于 u 的值。
RMQ 算法
苏苏爱自由
04-13 2123
1. 概述 RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干询问RMQ（A,i,j）(i,j当然，该问题也可以用线段树（也叫区间树）解决，算法复杂度为：O(N)~O(logN)，这里我们暂不介绍。 2.RMQ算法 对于该问题，最容易想到的解决方案是遍历，复杂度是O(n)。但当数据量非常大
C#：实现RMQ区间最小值算法​(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-31 104
C#：实现RMQ区间最小值算法​(附完整源码)
RMQ算法模板
Nemaleswang的博客
09-04 202
RMQ算法，主要用于求区间最大值或者区间最小值。本质就是通过倍增的方法进行计算。
四毛子算法与+-1RMQ
Code92007的博客
07-06 2606
前言 cf群里，有人提了一个线段树区间连续1，不带修改的问题 Claris口胡一个O(n)-O(1)的做法，于是来学习一下 思路来源 https://www.cnblogs.com/whx1003/p/13996517.html 知识总结 四毛子算法是一种暴力分块的思想，+-1RMQ是其应用之一 ①+-1RMQ问题（O(n)-O(1)） +-1RMQ问题是这么一个问题，仍然询问区间的RMQ， 但是这个序列有着特殊的性质，即相邻项之差要么是-1，要么是+1， 于是，有如下的暴力思想，先分块
算法文档无代码RMQ&LCA问题
04-14
算法文档无代码RMQ&LCA问题提取方式是百度网盘分享地址
lca-rmq:RMQ查找LCA的算法的实现
05-15
最小公祖问题的算法。 如“重新审阅LCA问题”中所述，这将使用“范围最小查询”实现LCA。 已完成：天真RMQ，更快RMQ（使用nlogn稀疏表） 待办事项：执行±1 RMQ 天真的RMQ输出： (1(2(4..)(5..))(3(6..)(7..)))...
常用算法代码
09-11
| 二分图匹配（匈牙利算法 DFS 实现） 11 | 二分图匹配（匈牙利算法 BFS 实现） 11 | 二分图匹配（HOPCROFT－CARP 的算法） 11 | 二分图最佳匹配（KUHN MUNKRAS 算法 O(M*M*N)） 11 | 无向图最小割 O(N^3) 12 |...
算法之LCA与RMQ问题1
08-08
而对于RMQ，ST算法和线段树则能实现快速的区间最值查询。理解并掌握这些算法，对于处理大量数据的实时查询以及优化树形结构的分析至关重要。在实际应用中，这些技术常用于数据索引、图形算法、数据库查询优化等领域...
马拉车 tarjan算法 RMQ算法.zip_算法_算法 马拉车
09-21
可以实现马拉车算法 RMQ算法 tarjan算法
算法篇-二叉树
分享Java知识，记录思考和感悟
06-21 326
分享二叉树相关概念和算法题
【康复学习--LeetCode每日一题】2748. 美丽下标对的数目
Puppet__的博客
06-20 402
如果下标对 i、j 满足 0 ≤ i < j < nums.length ，如果 nums[i] 的 第一个数字 和 nums[j] 的 最后一个数字 互质 ，则认为 nums[i] 和 nums[j] 是一组 美丽下标对。2 和 5 互质，因此 gcd(2,1) == 1。i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1。i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1。
代码随想录算法训练营第38天|● 理论基础 ● 509. 斐波那契数● 70. 爬楼梯 ● 746. 使用最小花费爬楼梯
weixin_74408291的博客
06-17 667
2.确定递推公式dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。那么dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);3.dp数组初始化由题目可以知道你可以选择从下标为。
C语言入门系列：从内存原理看函数的值传递和引用传递
最新发布
epitomizelu的专栏
06-23 258
函数参数用于向函数传递数据，C语言支持两种传递方式：值传递和引用传递。
写一段C++语言的实现RMQ算法的代码
03-03
抱歉，我不确定您指的是哪种RMQ算法。一般来说，RMQ是“区间最小值查询”（Range Minimum Query）的缩写，其实现算法有多种。以下是两种常见的RMQ算法的实现代码，供参考： 1. 线段树RMQ算法 ```python class SegmentTree: def __init__(self, arr): self.tree = [0] * (4 * len(arr)) self.build(arr, 0, 0, len(arr) - 1) def build(self, arr, index, left, right): if left == right: self.tree[index] = arr[left] else: mid = (left + right) // 2 self.build(arr, index * 2 + 1, left, mid) self.build(arr, index * 2 + 2, mid + 1, right) self.tree[index] = min(self.tree[index * 2 + 1], self.tree[index * 2 + 2]) def query(self, index, left, right, qleft, qright): if left > qright or right < qleft: return float('inf') elif qleft <= left and qright >= right: return self.tree[index] else: mid = (left + right) // 2 return min(self.query(index * 2 + 1, left, mid, qleft, qright), self.query(index * 2 + 2, mid + 1, right, qleft, qright)) # 示例 arr = [1, 3, 2, 7, 9, 11] tree = SegmentTree(arr) print(tree.query(0, 0, len(arr) - 1, 1, 4)) # 输出2，即arr[2:5]的最小值 ``` 2. ST算法 ```python import math class ST: def __init__(self, arr): n = len(arr) k = int(math.log2(n)) self.table = [[0] * (k + 1) for _ in range(n)] for i in range(n): self.table[i][0] = arr[i] for j in range(1, k + 1): for i in range(n - 2 ** j + 1): self.table[i][j] = min(self.table[i][j - 1], self.table[i + 2 ** (j - 1)][j - 1]) def query(self, left, right): k = int(math.log2(right - left + 1)) return min(self.table[left][k], self.table[right - 2 ** k + 1][k]) # 示例 arr = [1, 3, 2, 7, 9, 11] st = ST(arr) print(st.query(1, 4)) # 输出2，即arr[2:5]的最小值 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值