AcWing 1273. 天才的记忆（线段树/ST表）

整理的算法模板：ACM算法模板总结（分类详细版）

 

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

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

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

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

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

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

输入格式

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

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

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

接下来 MM 行，每行都有两个整数 A,BA,B。

输出格式

输出共 MM 行，每行输出一个数，表示对一个问题的回答。

数据范围

1≤N≤2×1051≤N≤2×105,
1≤M≤1041≤M≤104

输入样例：

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

输出样例：

34
123
123
8

 区间查询最大值，并且是离线静态的，很明显用ST表，存储时间复杂度 O(nlogn)，查询速度O(1)；

如果用线段树，存储和查询的时间复杂度都是 O(nlogn)；但是这道题数据比较水，都能过；

ST表：

#include <bits/stdc++.h>
using namespace std;
const int N=2e5+7,M=20;
int dp[N][M],a[N];
int main()
{
    int n;
    cin >>n;
    for(int i=1;i<=n;i++) cin >>a[i];
    for(int j=0;j<M;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]);
        }
    }
    int q;
    cin >>q;
    while(q--)
    {
        int a,b;
        cin >>a>>b;
        int res=log(b-a+1)/log(2);
        cout <<max(dp[a][res],dp[b-(1<<res)+1][res])<<endl;
    }
    
}

线段树：

#include <bits/stdc++.h>
using namespace std;
const int N=2*100005;

int w[N];//区间里的数 
int n,m;
 
struct node
{
	int l,r;   //当前结点所处区间 
	int maxx;
}tr[N*4];//注意对题中所给操作数量或者数据要开4倍大 
 
 
void pushup(int u)// 由子节点更新父节点 
{
	tr[u].maxx=max(tr[u<<1].maxx,tr[u<<1|1].maxx);
}
 
void build(int u,int l,int r)
{
	if(l==r) tr[u]={l,r,w[r]};//如果处理到叶结点了，就保存叶结点的信息 
	else
	{	tr[u]={l,r};	//保存当前节点的区间信息 
		int mid=l+r>>1;	
		build(u<<1,l,mid);	//递归左节点 
		build(u<<1|1,mid+1,r);	//	递归右节点 
		pushup(u);	//每次根据子节点更新父节点 
	}
}
 
node query(int u,int l,int r)   //在区间l，r里面查询 
{
	if(tr[u].l>=l&&tr[u].r<=r) return tr[u]; // 如果当前区间在l~r里面，则直接返回想要的信息 
	else
	{	
		int mid=tr[u].l+tr[u].r>>1;  //取当前节点的区间中点 
		if(r<=mid) return query(u<<1,l,r);	//	如果当前查询区间在当前区间的中点左端，则递归左儿子 
		else if(l>mid) return query(u<<1|1,l,r);	//如果当前查询区间在当前节点区间的右端，则递归右儿子； 
		else //如果一部分在mid左边，一部分在mid右边 
		{
			auto left=query(u<<1,l,r);   //递归左儿子 
			auto right=query(u<<1|1,l,r);	//递归右儿子 
			node res;
			res.maxx=max(left.maxx,right.maxx) ; //由左儿子和右儿子的信息来更新当前父节点的信息 
			return res;
		}	
	}
}
int main()
{
    int n;
    cin >>n;
    for(int i=1;i<=n;i++) cin >>w[i];
    build(1,1,n);
    int m;
    cin >>m;
    for(int i=0;i<m;i++)
    {
        int l,r;
        cin >>l>>r;
        cout <<query(1,l,r).maxx<<endl;
    }
}