HDU 5875 N^2能过的大水题，可用单调栈，离线处理优化

就是求A[L] MOD A[L+1] MOD A[L + 2] ….MOD A[R]
很容易想到mod的时候碰到大的数就可以不算，所以只要找到每个数右边第一个小于等于该数的数的位置就行了
这题太水了，N^2枚举就能过
当然这里可以用单调栈优化（复习一下） 维护一个单调递增的栈
碰到一个小于等于栈顶的数，就把大于这个数的数都出栈，同时记录到next数组里，o(n)时间就能算出来了
然后对于每次询问算一波，就ok了
然而查了网上大神的题解，还有对离线处理的优化
离线处理的作用是考虑到每次询问之间的计算关系，从而优化时间复杂度
把一个L开头的排序，从小到大计算，可以快很多
下面是没有加这个优化的AC代码

#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<stack>
using namespace std;
const int maxn = 100010;
struct node{
    int value;
    int id;
};
int main()
{
    int T;
    int n;
    int m;
    scanf("%d",&T);
    int next[maxn],a[maxn];
    stack<node> s;
    for(int cas = 1; cas <= T; cas++){
        scanf("%d",&n);
        memset(next,-1,sizeof(next));
        for(int i = 1; i <= n; i++){
            scanf("%d",&a[i]);
        }
        while(!s.empty()) s.pop();
        for(int i = 1;  i <= n; i++){
            while (!s.empty()){
                if (s.top().value >= a[i]){
                    next[s.top().id] = i;
                    s.pop();
                }
                else break;
            }
            s.push(node{a[i],i});
        }
        scanf("%d",&m);
        for(int i = 1; i <= m; i++){
            int l,r;
            scanf("%d %d",&l,&r);
            int ans,x;
            for( x = next[l],ans = a[l]; x != -1 && x <= r;x = next[x]){

                ans = ans % a[x];
            }
            printf("%d\n",ans);

        }
    }
    return 0;
}