+-RMQ问题的C++实现

±RMQ问题指被查询序列每一对相邻数的值的差要么为1要么为-1,这种特殊的RMQ问题的解决代码如下
C++代码

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

struct m_info
{
	long long m_value;
	size_t index;
	m_info(long long 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; }
	bool operator!=(const m_info& be_compared) const { return !(operator ==(be_compared)); }
};

const m_info& min_m_info(const m_info& left, const m_info& right)
{
	if (left.m_value <= right.m_value)
	{
		return left;
	}
	return right;
}
void SparseTable(vector<vector<m_info>>& d, vector<long long>& seq)
{
	for (size_t i = 0; i < seq.size(); ++i)
	{
		d[i][0] = m_info(seq[i], i);
	}

	for (size_t i = 1; (1 << i) <= seq.size(); ++i)
	{
		for (size_t j = 0; j <= seq.size() - (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];
			}
		}
	}
}

m_info query(size_t i, size_t j, vector<vector<m_info>>& d)
{
	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];
}

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

class ConstraintRMQ
{
public:
	m_info queryRMQ(size_t i, size_t j);
	ConstraintRMQ(vector<long long>& v);
private:
	size_t N;
	size_t segment_length;
	size_t block_num;
	vector<long long> value_seq;
	vector<vector<vector<m_info>>> group_in_query_map_table;
	vector<size_t> index_for_every_block;
	vector<vector<m_info>> group_between_query_table;
	vector<size_t> min_in_block_index;
	void preprocessForConstraintRMQ();
	void preprocessAllPlusMinusSeq(size_t level, size_t bit_mode_index, vector<long long>& minus_add_value);
	void getFirstValueForBlock(size_t block_index, m_info& result);
};

void ConstraintRMQ::getFirstValueForBlock(size_t first_value_in_block_offset, m_info &result)
{
	result.m_value += value_seq[first_value_in_block_offset];
	result.index += first_value_in_block_offset;
}
m_info ConstraintRMQ::queryRMQ(size_t i, size_t j)   //i,j从0开始
{
	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 result;
	if (i_block_index == j_block_index)
	{
		result = query(i_in_block_index, j_in_block_index, group_in_query_map_table[index_for_every_block[i_block_index]]);
		getFirstValueForBlock(i_block_index * segment_length, result);
	}
	else
	{
		size_t block_index;
		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);
			block_index = result.index;
			result = m_info(result.m_value, min_in_block_index[block_index]);
		}
		else
		{
			m_info r_ref;
			m_info result2;
			m_info result3;
			if (i_block_index + 1 == j_block_index)
			{
				result2 = query(i_in_block_index, segment_length - 1, group_in_query_map_table[index_for_every_block[i_block_index]]);
				getFirstValueForBlock(i_block_index * segment_length, result2);
				result3 = query(0, j_in_block_index, group_in_query_map_table[index_for_every_block[j_block_index]]);
				getFirstValueForBlock(j_block_index * segment_length, result3);
				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(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[index_for_every_block[j_block_index]]);
						getFirstValueForBlock(j_block_index * segment_length, result2);
					}
					else
					{
						result2 = query(i_in_block_index, segment_length - 1, group_in_query_map_table[index_for_every_block[i_block_index]]);
						getFirstValueForBlock(i_block_index * segment_length, result2);
					}
					r_ref = min_m_info(result, result2);  
				}
				else
				{
					result2 = query(i_in_block_index, segment_length - 1, group_in_query_map_table[index_for_every_block[i_block_index]]);
					getFirstValueForBlock(i_block_index * segment_length, result2);
					result3 = query(0, j_in_block_index, group_in_query_map_table[index_for_every_block[j_block_index]]);
					getFirstValueForBlock(j_block_index * segment_length, result3);
					r_ref = min_m_info(result, min_m_info(result2, result3));
				}
			}

			if (i_block_index + 1 == j_block_index || r_ref != result)
			{
				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))
				{
					return result3;
				}
				else
				{
					return result2;
				}
			}
		}
	}
	return result;
}

ConstraintRMQ::ConstraintRMQ(vector<long long>& v) :value_seq(v), N(v.size()), segment_length((log2(N) >> 1) + 1),
group_in_query_map_table(1ull << segment_length - 1, vector<vector<m_info>>(segment_length, vector<m_info>(log2(segment_length) + 1)))
{  
	if (value_seq.empty())
	{
		cout << "ERROR输入序列为空!" << endl;
		exit(-1);
	}

	for (size_t i = 1; i < value_seq.size(); ++i)
	{
		if (value_seq[i] - value_seq[i - 1] != 1 && value_seq[i] - value_seq[i - 1] != -1)
		{
			cout << "ERROR输入序列不是+-1序列!" << endl;
			exit(-1);
		}
	}
	size_t r;
	if ((r = N % segment_length) != 0)
	{
		block_num = N / segment_length + 1;
		if (value_seq.back() == (1ll << 63))
		{
			cout << "错误末端值等于最小值!" << endl;
			exit(-1);
		}
		r = segment_length - r;
		bool original = false;
		for (size_t i = 1; i <= r; ++i)
		{
			if (!original)
			{
				value_seq.push_back(value_seq[N - 1] - 1);
			}
			else
			{
				value_seq.push_back(value_seq[N - 1]);
			}
			original = !original;
		}
	}
	else
	{
		block_num = N / segment_length;
	}

	new (&index_for_every_block) vector<size_t>(block_num);
	new (&group_between_query_table) vector<vector<m_info>>(block_num, vector<m_info>(log2(block_num) + 1));
	new (&min_in_block_index) vector<size_t>(block_num);
	preprocessForConstraintRMQ();
}

void ConstraintRMQ::preprocessForConstraintRMQ()
{
	vector<long long> minus_add_value(segment_length, 0);
	preprocessAllPlusMinusSeq(0, 0, minus_add_value);

	vector<long long> m_value_for_every_block(block_num);
	size_t start_index_for_left_bound = 0;
	for (size_t i = 0; i < block_num; ++i)
	{
		size_t bit_mode_index = 0;
		size_t j = start_index_for_left_bound + 1;
		for (; ; )
		{
			if (value_seq[j] - value_seq[j - 1] == 1)
			{
				bit_mode_index |= 1;
			}
			++j;
			if (j == start_index_for_left_bound + segment_length)
				break;
			bit_mode_index <<= 1;
		}
		index_for_every_block[i] = bit_mode_index;
		m_info t = query(0, segment_length - 1, group_in_query_map_table[bit_mode_index]);		
		m_value_for_every_block[i] = t.m_value + value_seq[start_index_for_left_bound];
		min_in_block_index[i] = t.index + start_index_for_left_bound;
		start_index_for_left_bound = j;
	}
	SparseTable(group_between_query_table, m_value_for_every_block);
}

void ConstraintRMQ::preprocessAllPlusMinusSeq(size_t level, size_t bit_mode_index, vector<long long>& minus_add_value)  //true为正,bit == 1false为负 bit == 0
{
	if (level + 1 == segment_length)
	{
		SparseTable(group_in_query_map_table[bit_mode_index], minus_add_value);
		return;
	}

	minus_add_value[level + 1] = minus_add_value[level] + 1;
	if (level + 2 == segment_length)
	{
		preprocessAllPlusMinusSeq(level + 1, bit_mode_index | 1, minus_add_value);
	}
	else
	{
		preprocessAllPlusMinusSeq(level + 1, (bit_mode_index | 1) << 1, minus_add_value);
	}

	minus_add_value[level + 1] = minus_add_value[level] - 1;
	if (level + 2 == segment_length)
	{
		preprocessAllPlusMinusSeq(level + 1, bit_mode_index, minus_add_value);
	}
	else
	{
		preprocessAllPlusMinusSeq(level + 1, bit_mode_index << 1, minus_add_value);
	}



}

int main()
{
	const int N = 256;
	vector<long long> rmq_seq(N);
	rmq_seq[0] = N;
	for (size_t i = 1; i < N; ++i)
	{
		if (rand() % 2)
		{
			rmq_seq[i] = rmq_seq[i - 1] + 1;
		}
		else
		{
			rmq_seq[i] = rmq_seq[i - 1] - 1;
		}
	}
	ConstraintRMQ obj(rmq_seq);
	for (size_t i = 0; i < rmq_seq.size() - 1; ++i)
	{
		for (size_t j = i + 1; j < rmq_seq.size(); ++j)
		{
			m_info 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;
}