COCI 2012 Inspektor
coci 2012 inspektor
街道由左到右分布着\(N\)个办公室，编号为\(1\)到\(N\)，最开始，每个办公室都是空的，一些公司将入住，并赶走办公室里面现有的公司。一人每天会路过一些连续的办公室。他会查帐，找到最富的公司。
公司入住的描述如下：
\(1\ T\ K\ Z\ S\)，\(T\)表示搬来的时间，\(K\)表示入住的办公室编号，\(Z\)表示公司每天的收益，\(S\)表示原来的余额。如果办公室原来有单位，原来的将离开，公司入住当天没有收益。
对于查帐的描述：
\(2\ T\ A\ B\) , \(T\)表示查帐的时间。\(A\)和\(B\)表示要查的办公室在\(A\)和\(B\)之间（包涵端点）。查帐时要算当天的收益。
输入
第一行两个正整数 \(N (1 ≤ N ≤ 100 000) and M (1 ≤ M ≤ 300 000)\),表示办公室的间数，\(M\)表示有\(M\)个事件。
接下来\(M\)行，每行描述一个事件\(1\ T\ K\ Z\ S\) 或\(2\ T\ A\ B\)所有事件按时间顺序给出。 每天最多发生一个事件，所以\(T\)严格递增 \(T\)小于\(10^6\),\(Z\)和\(S\)的绝对值小于\(10^6\).
输出
对于每一次查帐输出一行，表示最富的公司的钱数，如果没有公司输出\(nema\).
input
2 4
1 1 1 2 4
1 2 2 3 2
2 5 1 2
2 7 1 2
output
12
17
input
3 6
1 1 1 4 -2
1 2 2 2 6
2 3 3 1
2 4 3 1
1 5 3 -6 20
2 6 2 3
output
8
10
14
input
5 9
1 1 5 4 -5
2 2 3 5
1 3 4 6 9
2 4 1 2
1 6 2 2 3
2 8 2 1
1 9 4 0 17
2 10 5 5
2 11 1 4
output
-1
nema
7
31
17
当前是第\(T\)天时，对于每一个公司，盈利是
其中，\(T_0,z_i,s_i\)分别表示，搬来的时间，每天盈利，初始盈利；
等价于
发现这是一个一次函数，意味着每个公司都可以用一条直线来表示；
我们可以维护每个时间点的坐标系，找到当\(x\)取\(T\)时的最大值，这就是答案；
我们先不考虑修改操作；看怎样找到\(T\)取值下的最大值；
在一个坐标系里，有可能被取成最大值只可能是最上面的直线；
比如：
只有红色部分可能是答案直线，我们也只用维护这一部分；
这其实就是一个下凸壳，我们可以用单调栈来构造，用一个指针扫描来寻找答案；
关于下凸壳的构造
我们需要按顺序维护出在下凸壳上的直线的编号，
可以发现下凸壳上的直线的斜率是单调递增的，两两直线的交点与直线对应，横坐标也是单调递增的；
我们先把直线按斜率大小排序（小的在前
我们可以按横坐标维护一个存交点的单调栈；
因为交点也是两条直线得来的，我们可以直接把直线放到栈内，相邻两条直线的交点的横坐标保证单调递增；
当我们新加入一条直线时，如果这条直线与栈顶直线的交点，在栈顶交点（就是栈顶直线与栈内的第二条直线的交点，它的横坐标是当前最大的） 右边，那么这条直线可以直接加入栈中；
如果在栈顶交点的左边，应当把栈顶交点弹出（其实就是把栈顶直线弹出，这个交点就没有了），直到当前直线与栈顶直线的交点成为最大值，再把当前直线加入栈中。（单调栈的基本操作）
最后栈内的直线，就是下凸壳中的直线；
举个例子
我先加入第一条直线，这是斜率最小的一条直线
再加入第二条直线，因为当前栈内直线只有一条，还没有交点，就直接加入
红色部分就是当前栈维护出的下凸壳；
\(A\)就是现在横坐标最大的交点
再加入第三条直线，它与第二条直线的交点在\(A\)右边，我们可以直接加入；
\(B\)就是现在横坐标最大的交点
第三条直线是栈顶直线，红色部分是下凸壳
再加入第四条直线，它与第三条直线的交点在\(B\)左边，我们发现第三条直线已不能在下凸壳里了，应先把第三条直线弹出，
再发现第四条直线与第二条直线的交点在\(A\)右边，可以加入第四条直线；
现在的\(B\)是横坐标的最大的交点
栈内元素应该是\(1,2,4\),也就是下凸壳中的直线（红色部分）；
构造的时间复杂度是\(O(nlogn)\)
关于在已有下凸壳上求解
我们想知道横坐标是\(T\)时，下凸壳上的纵坐标；
主要目的就是找\(x=T\)这条直线与哪条直线相交
根据之前的操作，我们知道下凸壳中直线的分界是依据交点的；
我们先要保证交点与直线对应，
假设这个交点所对应的直线是相交的两条直线的前一条；
我们找到第一个横坐标大于等于\(T\)的交点，那么它对应的直线应该与\(x=T\)相交，也就是答案直线；
当前第一个大于等于\(T\)的交点是\(B\)，可知\(x=T\)与直线\(2\)相交
又由于我们询问的\(T\)是严格单增的，那答案交点也是单增的，我们只需要记录这个凸壳已经被扫到哪里了，下次从这里开始就可以了；
查询的总时间复杂度是\(O(T)\)
考虑有修改操作的情况
修改具有不可继承性，修改后的凸壳和之前的凸壳是可能没有相同点的；
修改一条直线可能改变凸壳的全貌；
意味着每次修改一条直线，都需要重构凸壳，这样成本太高了；
我们可以考虑分块；
对\(n\)分块，假设每个块大小是\(B\)，我们在每个块中维护一个这个区间的凸壳；
对于查询，不是整块的暴力扫描，是整块的用指针在对应块找答案，前者复杂度是\(O(B)\),后者总时间复杂度是\(O(\frac{n}{B}*T)\),\(T\)是最大时间；
对于修改，把待修改的块打上标记，当调用它是进行一次重构，对于一次重构时间复杂度是\(O(BlogB)\)
\(Code\)
#include<bits/stdc++.h>
#define ll long long
#define re register
using namespace std;
const int N=100005;
int n,m,len,opt;
int pos[N],L[N],R[N];
struct line
{
ll k,b;//斜率和截距
bool operator<(line l)const
{
return k==l.k?b>l.b:k<l.k; //按斜率排序，斜率相同按截距
}
}a[N],b[N];
bool vis[N],use[N],need[N];
int head[N],tail[N]; //第i块在栈中的首尾
int sta[N]; //栈，存直线的下标
double point[N]; //记录交点
inline ll max(ll x,ll y){return x>y?x:y;}
inline int read()
{
int x=0,f=1;char st=getchar();
while(st<'0'||st>'9'){if(st=='-') f=-1;st=getchar();}
while(st>='0'&&st<='9') x=x*10+st-'0',st=getchar();
return x*f;
}
inline void write(ll x)
{
if(x<0) x=~x+1,putchar('-');
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline double getx(line x,line y)
{
return (double)(x.b-y.b)/(y.k-x.k); //算两条直线交点的横坐标
}
inline void rebuild(int x)
{
int st=L[x]-1,top=L[x];
for(re int i=L[x];i<=R[x];++i)
if(vis[i]) b[++st]=a[i]; //把需要重构的直线加入
sort(b+L[x],b+st+1);
sta[top]=L[x];
for(re int i=L[x]+1;i<=st;++i)
if(b[i].k!=b[i-1].k) //如果两条直线斜率相同，只可能取到截距大的一条
{
while(top>L[x]&&getx(b[i],b[sta[top]])<getx(b[sta[top]],b[sta[top-1]])) top--;
point[top]=getx(b[i],b[sta[top]]); //算交点
sta[++top]=i;
}
head[x]=L[x];
tail[x]=top;
}
inline void doit(int t,int l,int r)
{
if(l>r) swap(l,r);
ll tmp=-1e18;
int p=pos[l],q=pos[r];
if(p==q)
{
for(re int i=l;i<=r;++i)
if(vis[i]) tmp=max(tmp,t*a[i].k+a[i].b); //暴力
}
else
{
for(re int i=l;i<=R[p];++i)
if(vis[i]) tmp=max(tmp,t*a[i].k+a[i].b);
for(re int i=L[q];i<=r;++i)
if(vis[i]) tmp=max(tmp,t*a[i].k+a[i].b);
for(re int i=p+1;i<q;++i)
{
if(need[i]) //如果需要重构
{
rebuild(i);
need[i]=0;
}
if(use[i])
{
while(head[i]<tail[i]&&point[head[i]]<t) head[i]++; //找第一个大于等于t的交点
tmp=max(tmp,t*b[sta[head[i]]].k+b[sta[head[i]]].b);
}
}
}
if(tmp==-1e18) puts("nema");
else write(tmp),puts("");
}
int main()
{
freopen("inspektor.in","r",stdin);
freopen("inspektor.out","w",stdout);
n=read();m=read();
len=sqrt(n/log2(n))+1;
// len=144;
for(re int i=1;i<=n;++i)
pos[i]=(i-1)/len+1;
for(re int i=1;i<=pos[n];++i)
L[i]=R[i-1]+1,R[i]=R[i-1]+len;
R[pos[n]]=n;
while(m--)
{
opt=read();
if(opt==1)
{
int T=read(),x=read(),z=read(),s=read();
vis[x]=1;use[pos[x]]=1;//这个点有，这个块有
need[pos[x]]=1;//需要重构
a[x].k=z;a[x].b=s-(ll)T*z;
}
else
{
int T=read(),l=read(),r=read();
doit(T,l,r);
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
