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