【动态规划】ST算法解决区间最值询问问题（RMQ问题）

一、前言

RMQ问题、即区间最值问题，在遇到这类题目的时候，我们可以用暴力枚举两重for循环的方式来解决，但是这样的话会在时间上超时。如果想要不超时的话，我们也可以用线段树来解决该问题。但是我们在日常的训练中意识到：线段树的代码比较多并且比较复杂，稍有不慎的话就有可能出错。因此，在这里作者简单介绍一种写起来比较简单的算法-----ST算法。

例题引入：Acwing 天才的记忆

从前有个人名叫 WNB，他有着天才般的记忆力，他珍藏了许多许多的宝藏。

在他离世之后留给后人一个难题（专门考验记忆力的啊！），如果谁能轻松回答出这个问题，便可以继承他的宝藏。

题目是这样的：给你一大串数字（编号为 1到 N，大小可不一定哦！），在你看过一遍之后，它便消失在你面前，随后问题就出现了，给你 M 个询问，每次询问就给你两个数字 A,B，要求你瞬间就说出属于 A 到 B

这段区间内的最大数。

一天，一位美丽的姐姐从天上飞过，看到这个问题，感到很有意思（主要是据说那个宝藏里面藏着一种美容水，喝了可以让这美丽的姐姐更加迷人），于是她就竭尽全力想解决这个问题。

但是，她每次都以失败告终，因为这数字的个数是在太多了！

于是她请天才的你帮他解决。如果你帮她解决了这个问题，可是会得到很多甜头的哦！
输入格式

第一行一个整数 N表示数字的个数。

接下来一行为 N个数，表示数字序列。

第三行读入一个 M，表示你看完那串数后需要被提问的次数。

接下来 M行，每行都有两个整数 A,B

。
输出格式

输出共 M

行，每行输出一个数，表示对一个问题的回答。
数据范围

1≤N≤2×105
,
1≤M≤104,
1≤A≤B≤N

。
输入样例：

6
34 1 8 123 3 2
4
1 2
1 5
3 4
2 3

输出样例：

34
123
123
8

二、算法介绍

首先定义dp[i,j]为以第i个数为起点，长度为2^j的一段区间中的最大值，显然状态转移为

dp[i,j] = max(dp[i,j-1],dp[i+2^(j-1),j-1])

这样的话可以在nlogn的时间下完成f数组的建立，下边是区间最大值的查询，对于区间[l,r]，存在一个k使得r-l+1>=2^k且r-l+1<2^(k+1),这样的话区间[l,r]的最大值就是max(dp[l,k],dp[r-2^k+1,k]),查询可以在常数级完成。
在这里可以用这张图解释一下状态转移方程的推导逻辑。

三、代码实现

1.ST算法

// Problem: 天才的记忆
// Contest: AcWing
// URL: https://www.acwing.com/problem/content/1275/
// Memory Limit: 64 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)

//#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define endl '\n'
#define int long long
#define INF 0x3f3f3f3f
#define ull unsigned long long
#define mem(a, b) memset(a, b, sizeof(a))
#define ck(x) cerr << #x << "=" << x << '\n';
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 7, mod = 1e9 + 7;
int dp[N][20];
int a[N];


void solve()
{
  int n;
  cin >> n;
  for (int i = 1; i <= n; i++)
    cin >> a[i];
  int q;
  for (int j = 0; j < 18; j++)
  {
    for (int i = 1; i + (1 << j) - 1 <= n; i++)
      if (!j)
        dp[i][j] = a[i];
      else
        dp[i][j] = max(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
  }
  cin >> q;
  while (q--)
  {
    int l, r;
    cin >> l >> r;
    int k = r - l + 1;
    k = log(k) / log(2);
    int ans = max(dp[l][k], dp[r - (1 << k) + 1][k]);
    cout << ans << endl;
  }
}

signed main()
{
  std::ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  solve();
  return 0;
}

2.线段树

//#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define endl '\n'
#define int long long
#define INF 0x3f3f3f3f
#define ull unsigned long long
#define mem(a, b) memset(a, b, sizeof(a))
#define ck(x) cerr << #x << "=" << x << '\n';
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 7, mod = 1e9 + 7;
int a[N];
struct Node
{
  int l, r, v;
} tr[N * 4];
void pushup(int u)
{
  tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
}
void build(int u, int le, int ri)
{
  if (le == ri)
    tr[u] = { le, ri, a[le] };
  else
  {
    tr[u] = { le, ri };
    int mid = (le + ri) >> 1;
    build(u << 1, le, mid);
    build(u << 1 | 1, mid + 1, ri);
    pushup(u);
  }
}
int query(int u, int le, int ri)
{
  if (tr[u].l >= le && tr[u].r <= ri)
    return tr[u].v;
  else
  {
    int mid = (tr[u].l + tr[u].r) >> 1;
    int ans = -INF;
    if (le <= mid)
      ans = max(ans, query(u << 1, le, ri));
    if (mid < ri)
      ans = max(ans, query(u << 1 | 1, le, ri));
    return ans;
  }
}
void solve()
{
  int n;
  cin >> n;
  for (int i = 1; i <= n; i++)
    cin >> a[i];
  int q;
  build(1, 1, n);
  cin >> q;
  while (q--)
  {
    int l, r;
    cin >> l >> r;
    cout << query(1, l, r) << endl;
    ;
  }
}

signed main()
{
  std::ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  solve();
  return 0;
}

作者：Avalon Demerzel