Four Russian RMQ算法的C++实现

Four Russian RMQ算法的基本思想是对原序列分块，对每块及块间均建立ST表，从而处理块内和块间查询，具体见以下代码
C++代码:

#include <iostream>
#include <vector>
#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>
class FourRussianRMQ
{
public:
	m_info<T> queryRMQ(size_t i, size_t j);
	FourRussianRMQ(vector<T>& v, size_t s, 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<vector<vector<m_info<T>>>> group_in_query_map_table;
	vector<vector<m_info<T>>> group_between_query_table;
	vector<vector<m_info<T>>> prefix_RMQ;
	vector<vector<m_info<T>>> suffix_RMQ;
	void preProcess();
};

template <typename T>
m_info<T> FourRussianRMQ<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)
	{
		if (i_in_block_index == 0)
		{
			result = prefix_RMQ[i_block_index][j_in_block_index];
		}
		else if (j_in_block_index == segment_length - 1)
		{
			result = suffix_RMQ[i_block_index][i_in_block_index];
		}
		else
		{
			result = query(i_in_block_index, j_in_block_index, group_in_query_map_table[i_block_index]);
		}
		
		first_value_in_block_offset = i_block_index * segment_length;
	}
	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 = prefix_RMQ[block_index][segment_length - 1];
			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 = suffix_RMQ[i_block_index][i_in_block_index];
				result3 = prefix_RMQ[j_block_index][j_in_block_index];
				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 = prefix_RMQ[block_index][segment_length - 1];

				if (i_in_block_index == 0 || j_in_block_index == segment_length - 1)
				{
					if (i_in_block_index == 0)
					{
						result2 = prefix_RMQ[j_block_index][j_in_block_index];
					}
					else
					{
						result2 = suffix_RMQ[i_block_index][i_in_block_index];
					}
					r_ref = min_m_info(result, result2);
				}
				else
				{
					result2 = suffix_RMQ[i_block_index][i_in_block_index];
					result3 = prefix_RMQ[j_block_index][j_in_block_index];
					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;
}

template <typename T>
void FourRussianRMQ<T>::preProcess()
{
	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)
	{   
		prefix_RMQ[i][0] = m_info<T>(value_seq[start_index_for_left_bound], 0);
		for (size_t j = start_index_for_left_bound + 1; j < start_index_for_left_bound + segment_length; ++j)
		{
			if (value_seq[j] < prefix_RMQ[i][j - start_index_for_left_bound - 1].m_value)
			{
				prefix_RMQ[i][j - start_index_for_left_bound] = m_info<T>(value_seq[j], j - start_index_for_left_bound);
			}
			else
			{
				prefix_RMQ[i][j - start_index_for_left_bound] = prefix_RMQ[i][j - start_index_for_left_bound - 1];
			}
		}

		suffix_RMQ[i][segment_length - 1] = m_info<T>(value_seq[start_index_for_left_bound + segment_length - 1], segment_length - 1);
		if (segment_length > 1)
		{
			for (size_t j = start_index_for_left_bound + segment_length - 2; ; --j)
			{
				if (value_seq[j] < suffix_RMQ[i][j - start_index_for_left_bound + 1].m_value)
				{
					suffix_RMQ[i][j - start_index_for_left_bound] = m_info<T>(value_seq[j], j - start_index_for_left_bound);
				}
				else
				{
					suffix_RMQ[i][j - start_index_for_left_bound] = suffix_RMQ[i][j - start_index_for_left_bound + 1];
				}
				if (j == start_index_for_left_bound)
				{
					break;
				}
			}
		}

		SparseTable(group_in_query_map_table[i], value_seq, start_index_for_left_bound, start_index_for_left_bound + segment_length - 1);
		start_index_for_left_bound = start_index_for_left_bound + segment_length;
		m_value_for_every_block[i] = query(0, segment_length - 1, group_in_query_map_table[i]).m_value;
	}
	SparseTable(group_between_query_table, m_value_for_every_block, 0, m_value_for_every_block.size() - 1);
}

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

	if (segment_length > N)
	{
		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);
		}
	}
	preProcess();
}

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());
	FourRussianRMQ<long long> obj(rmq_seq, 2, 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 && rmq_seq[r.index] == m)
			{
				cout << "[" << i << "," << j << "]查询结果正确!" << endl;
			}
			else
			{
				cout << "[" << i << "," << j << "]查询结果错误!" << endl;
				exit(-1);
			}
		}
	}
    return 0;
}