CF1601E Phys Ed Online

考虑一个贪心。

我们一定采取的方案是

\(b_i = \min_{j = i - k}^i a_j\)
\(\sum a_l + b_{l + k} + \min_{i = 1}^2{b_{l + ik}} + \min_{i = 1}^3{b_{l + ik}}......\min_{i = 1}^t{b_{l + ik}}\)

那么我们看出来可以只考虑同余系的关键点即可。

但是我们发现我们不好计算答案。

一个想要的考虑是扫描线。

但是我们发现这样需要支持区间加，区间取 \(0\)，区间加等差数列，单点查。
然后我发现我不会区间加等差数列，所以只能考虑正解做法。

考虑我们差分答案，记\(f_i\)为一直到结尾的答案，考虑倒序枚举\(i\)，直接单调栈，其转移显然。

那么\([l,r]\)答案应为\(f_i - f_p + b_p * {(r - p + 1)} + a_l\)
\(p\)为\([l,r]\)中最小值位置。

考虑笛卡尔树上的\([l,r]\)的最小值位置即其两点\(LCA\)位置。

那么复杂度为\(O(nlog{\frac{n}{k}} + q)\)

较正解做法\(O(nlog + q)\) 效率应该差距不大。

所以这里采用正解做法即ST表。

#include
#define ll long long 
#define N 600005
#define int ll

int n,q,k;

std::pair g[N][30];//ST表

int lg[N],b[N];

std::pair get(int l,int r){
	if(l > r)
	return std::pair(0,0);
	int p = lg[r - l + 1];
	return std::min(g[l][p],g[r - (1ll << p) + 1][p]);
} 

int stk[N],top,nxt[N],f[N];

ll calc(int l,int r){
	int p = get(l - k,r).second;
	int tmp = g[p][0].first;
	if(p == l - k)
	p += k;
	p = p + (r - p) % k;
	return f[l] - f[p] + (r / k - p / k + 1) * b[p];
}

signed main(){
	scanf("%d%d%d",&n,&q,&k);
	lg[0] = -1;
	for(int i = 1;i <= n;++i)
	lg[i] = lg[i / 2] + 1;
	for(int i = 1;i <= n;++i){
		scanf("%d",&g[i][0].first);
		g[i][0].second = i;
	}
	for(int j = 1;j <= 20;++j)
	for(int i = 1;i + (1ll << j) - 1 <= n;++i)
	g[i][j] = std::min(g[i][j - 1],g[i + (1ll << (j - 1))][j - 1]);
	for(int i = k + 1;i <= n;++i)
	b[i] = get(i - k,i).first;
	for(int l = k + 1;l + k <= n && l <= 2 * k;++l){
		int r = l + (n - l) / k * k;
		top = 1;
		for(int i = r;i >= l;i -= k){
			while(top > 1 && b[i] <= b[stk[top]])
			top -- ;
			nxt[i] = stk[top];
			f[i] = f[nxt[i]] + b[i] * (nxt[i] / k - i / k);
			stk[++top] = i;
		}
	}
	while(q -- ){
		int l,r;
		scanf("%d%d",&l,&r);
		r = l + (r - l) / k * k;
		std::cout<<(1ll * g[l][0].first + 1ll * (l + k <= r? calc(l + k,r) : 0))<