codeforces 602 D. Lipshitz Sequence (单调栈)

D. Lipshitz Sequence

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

A function  is called Lipschitz continuous if there is a real constant K such that the inequality |f(x) - f(y)| ≤ K·|x - y| holds for all . We'll deal with a more... discrete version of this term.

For an array , we define it's Lipschitz constant  as follows:

• if n < 2, 
• if n ≥ 2,  over all 1 ≤ i < j ≤ n

In other words,  is the smallest non-negative integer such that |h[i] - h[j]| ≤ L·|i - j| holds for all 1 ≤ i, j ≤ n.

You are given an array  of size n and q queries of the form [l, r]. For each query, consider the subarray ; determine the sum of Lipschitz constants of all subarrays of .

Input

The first line of the input contains two space-separated integers n and q (2 ≤ n ≤ 100 000 and 1 ≤ q ≤ 100) — the number of elements in array  and the number of queries respectively.

The second line contains n space-separated integers  ().

The following q lines describe queries. The i-th of those lines contains two space-separated integers li and ri (1 ≤ li < ri ≤ n).

Output

Print the answers to all queries in the order in which they are given in the input. For the i-th query, print one line containing a single integer — the sum of Lipschitz constants of all subarrays of .

Sample test(s)

input

10 4
1 5 2 9 1 3 4 2 1 7
2 4
3 8
7 10
1 9

output

17
82
23
210

input

7 6
5 7 7 4 6 6 2
1 2
2 3
2 6
1 7
4 7
3 5

output

2
0
22
59
16
8

Note

In the first query of the first sample, the Lipschitz constants of subarrays of  with length at least 2 are:

• 
• 
• 

The answer to the query is their sum.

发现L(h)其实是相邻两个数绝对值的最大值，考虑每个值的贡献，然后单调栈预处理就好了

/*======================================================
# Author: whai
# Last modified: 2015-11-25 12:48
# Filename: d1.cpp
======================================================*/
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <map>
#include <queue>
#include <stack>

using namespace std;

#define LL __int64
#define PB push_back
#define P pair<int, int>
#define X first
#define Y second

const int N = 1e5 + 5;
const int INF = 0x3f3f3f3f;

int a[N];
int b[N];
int L[N], R[N];

int _abs(int x) {
	if(x < 0) return -x;
	return x;
}

P st[N];
int top = -1;

void predo(int n) {
	for(int i = 1; i < n; ++i) {
		b[i] = _abs(a[i + 1] - a[i]);
	}
	//for(int i = 1; i < n; ++i) {
	//	cout<<b[i]<<' ';
	//}
	//cout<<endl;
	top = -1;
	st[++top] = P(INF, 0);
	for(int i = 1; i < n; ++i) {
		int j;
		for(j = top; j >= 0; --j) {
			if(b[i] <= st[j].X) break;
			else R[st[j].Y] = i - 1;
		}
		L[i] = st[j].Y + 1;
		top = j;
		st[++top] = P(b[i], i);
	}
	for(int i = 0; i <= top; ++i) {
		R[st[i].Y] = n - 1;
	}
	//for(int i = 1; i < n; ++i) {
	//	cout<<L[i]<<' '<<R[i]<<endl;
	//}
}

void gao(int l, int r) {
	LL ans = 0;
	for(int i = l; i < r; ++i) {
		LL left = (i - max(L[i], l) + 1);
		LL right = (min(R[i], r - 1) - i + 1);
		ans += left * right * b[i];
	}
	cout<<ans<<endl;

}

int main() {
	int n, m;
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i) {
		scanf("%d", &a[i]);
	}
	predo(n);
	for(int i = 0; i < m; ++i) {
		int u, v;
		scanf("%d%d", &u, &v);
		gao(u, v);
	}
	return 0;
}