查税

题意：

A 镇刚刚成立，你被任命为税务局长，你的职责是保证镇上所有公司有足够多的会计。A 镇主街上有N 个商业办公室，从左到右依次编号为1 到N，一开始所有办公室都是空的，没有任何公司进驻，后面陆陆续续有公司进进出出。在某一个时间段，你会巡视一段连续编号的办公室，要求计算巡视的公司中账户余额最多的是多少。一个公司的进驻用以下四个整数来描述：
T：表示进驻是哪一天，从A 镇成立那天算起，A 镇成立那天算第一天；
K：进驻的办公室的编号；
Z：该公司每天的赢利，如果亏损的话则为负值；
S：搬进来那天公司账户的余额。
如果在新公司搬进来之前第K 个办公室已经有公司进驻，那么这个公司会先搬出去，然后再把新公司搬进来，新搬进来的公司会在搬进来的第二天开始营业(赢利或亏损)。
你作为税务局长，会经常来巡视，用以下三个整数来描述：
T：巡视那天的编号；
A 和B：巡视第A 到第B 个编号范围的办公室。
由于巡视的时间是一天中很晚的时刻，所以所有公司已经完成当天的营业并且财务已经把当天的盈利更新到公司账户中。你的任务就是对于每次巡视，找到账户余额最多的公司。

$N\le 100,000$
操作数$M\le 500,000$

分析

原题就是要维护一些形如Y = Z * $T_{now}$ + S - Z * T=$k * T_{now} + b$的直线。
分块。分成$\sqrt{n}$块。
若在$T_{now}$时，直线$l_2$：$Y_2$ = $k_2$ * $T_{now}$ + $b_2$ ,直线$l_1$：$Y_1$ = $k_1$ * $T_{now}$ + $b_1$ (设$k_1 < k_2$)，$l_2比l_1$更优的话，有$Y_1$ < $Y_2$,整理得$\frac{b_2 - b_1}{k_2 - k_1} > -T_{now}$，$-T_{now}$单调递减。这样就变成斜率优化了。每块维护按$k$从小到大排序后的直线和一个单调队列。
对于插入操作，在块内删除、插入排序，并重新构建单调队列。
对于查询操作，包含于区间的块直接扫它们的单调队列，剩下的一些位置暴力扫就行了。
时间复杂度$O$(M$\sqrt{N}$)

#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;

typedef long long LL;
const int N = 1e5 + 10,M = 320;
const LL Inf = -5000000000001LL;
struct sl {
    LL k,b;
} s[M][M],in[N];
int cnt[M],n,m,nn,nt;
int head[M],tail[M],l[M][M];

bool check(sl a,sl b,sl c,sl d) {
    return (b.b - a.b) * (d.k - c.k) < (d.b - c.b) * (b.k - a.k);
}

bool Check(sl a,sl b,LL x) {
    return (b.b - a.b) > (b.k - a.k) * x;
}

void insert(int pos,LL k,LL b,LL t) {
    int be = (pos - 1) / nt + 1,i;
    for (i = cnt[be];i;i --) if (s[be][i].k < k) break;
    else s[be][i + 1] = s[be][i];
    s[be][i + 1].k = k,s[be][i + 1].b = b,cnt[be] ++;
    head[be] = 1,tail[be] = 1;
    l[be][1] = 1;
    for (int i = 2;i <= cnt[be];i ++) {
        while (head[be] <= tail[be] && Check(s[be][l[be][tail[be]]],s[be][i],-t)) tail[be] --;
        tail[be] ++;
        l[be][tail[be]] = i;
        sl x = s[be][l[be][tail[be]]];
        sl y = s[be][l[be][tail[be] - 1]];
        sl z = s[be][l[be][tail[be] - 2]];
        while (head[be] + 1 < tail[be] && check(z,y,y,x)) { 
            l[be][tail[be] - 1] = l[be][tail[be]];
            tail[be] --;
            x = s[be][l[be][tail[be]]];
            y = s[be][l[be][tail[be] - 1]];
            z = s[be][l[be][tail[be] - 2]];
        }
    }
}

LL qry(int L,int R,LL t) {
    if (L > R) return Inf;
    LL re = Inf;
    for (int i = L;i <= R;i ++) {
        while (head[i] < tail[i] && Check(s[i][l[i][head[i]]],s[i][l[i][head[i] + 1]],-t)) head[i] ++;
        if (head[i] <= tail[i]) {
            int cur = l[i][head[i]];
            re = max(re,s[i][cur].b + t * s[i][cur].k);
        }
    }
    return re;
}

LL find(int l,int r,LL t) {
    LL re = Inf;
    for (int i = l;i <= r;i ++) if (in[i].k != Inf) re = max(re,in[i].b + in[i].k * t);
    return re;
}

void del(int pos,LL k,LL b) {
    int be = (pos - 1) / nt + 1,i;
    for (i = 1;i <= cnt[be];i ++) if (s[be][i].k == k && s[be][i].b == b) break;
    for (int j = i;j <= cnt[be] - 1;j ++) s[be][j] = s[be][j + 1];
    cnt[be] --;
}

int main() {
    scanf("%d%d",&n,&m);
    nn = sqrt(n);
    nt = n / nn + (n % nn != 0);
    for (int i = 1;i <= n;i ++) in[i].k = Inf;
    for (int i = 1;i <= nn;i ++) head[i] = 1,tail[i] = 0;
    for (int i = 1;i <= m;i ++) {
        int type;
        scanf("%d",&type);
        if (type == 1) {
            LL T,K,Z,S;
            scanf("%lld%lld%lld%lld",&T,&K,&Z,&S);
            if (in[K].k != Inf) del(K,in[K].k,in[K].b);
            in[K].k = Z,in[K].b = S - Z * T;
            insert(K,Z,S - Z * T,T);
        }
        else {
            int l,r;
            LL t;
            scanf("%lld%d%d",&t,&l,&r);
            if (l > r) swap(l,r);
            int ln = (l - 1) / nt + 1,rn = (r - 1) / nt + 1;
            LL ans = qry(ln + 1,rn - 1,t);
            ans = max(find(l,min(r,ln * nt),t),ans);
            ans = max(ans,find(max(l,(rn - 1) * nt + 1),r,t));
            if (ans == Inf) printf("nema\n");
            else printf("%lld\n",ans);
        }
    }
}