+ Vendedor de Pensamiento árbol segmento (Valle de Los P2672)

vendedor

título Descripción

Amin era un vendedor, se le ordenó a atornillar la calle para vender productos de su empresa. calle tornillo es un callejón sin salida, la salida y la entrada son los mismos, el lado de la pared de la calle, siendo el otro lado del hogar. Tornillo N total de hogares en una calle, la i-ésima inquilinos de la entrada a la metro es Si. Desde la misma casa puede tener un número de los inquilinos, lo que puede haber un número igual de los hogares de la entrada. Amin entraría desde la entrada, con el fin de promover sus productos a los tornillos de los hogares de la calle X de la familia, y luego salir de la misma manera.
Amin Todo el medidor se acumulan 01:00 valor de la fatiga, para promover sus productos se acumulan valor Ai-punto de la fatiga a la i-ésimo hogar. Amin es un adicto al trabajo, lo que quería saber, para diferentes X, sin forma innecesaria a ir, y la cantidad de puntos que acumuló valor de la fatiga más.

Formato de entrada

La primera línea tiene un número entero positivo n, el número de tornillos de los hogares de la calle.

La siguiente línea de N enteros positivos, en el que Si representa el i-ésimo número entero de los hogares a la i-ésima entrada. aseguramiento de datos S_1≤S_2≤ ... ≤S_n <10 ^ 8 siguiente línea con N un entero positivo, en el que el número entero A_i representa el i-ésimo valor del producto para promover la fatiga se acumulará en el i-ésimo hogares. aseguramiento de datos A_i <1000

Formato de salida

líneas de salida N, cada uno un número entero positivo, el valor de número entero i-ésima fila fatiga cuando X = i, Amin más acumulado.

---

mantenimiento de los árboles segmento valor máximo del intervalo ;,

I-1 antes de la grabación mxl usuario la máxima hogar distancia, cuando la primera distancia de usuario es menor que el valor máximo i, entonces ninguna operación;
si es mayor que el valor máximo, el valor del usuario i MXL-se convierte en valor de la fatiga de la casa, i + 1 de la n-ésima de usuario para el usuario menos el i-ésimo usuario mxl distancia del usuario;

código:

#include<bits/stdc++.h>
#define LL long long
#define pa pair<int,int>
#define ls k<<1
#define rs k<<1|1
#define inf 0x3f3f3f3f
using namespace std;
const int N=100010;
const int M=2000100;
const LL mod=2e9;
int n,s[N],a[N];
struct Node{
	int l,r,num;
	LL mx,lt;
}tr[N*4];
void pp(int k){
	if(tr[ls].mx>=tr[rs].mx) tr[k].mx=tr[ls].mx,tr[k].num=tr[ls].num;
	else tr[k].mx=tr[rs].mx,tr[k].num=tr[rs].num;
}
void pd(int k){
	if(tr[k].lt){
		tr[ls].mx-=tr[k].lt;
		tr[rs].mx-=tr[k].lt;
		tr[ls].lt+=tr[k].lt;
		tr[rs].lt+=tr[k].lt;
	}
	tr[k].lt=0;
}
void build(int l,int r,int k){
	tr[k].l=l,tr[k].r=r;
	if(l==r){
		tr[k].mx=(LL)(2*s[l]+a[l]);
		tr[k].num=l;
		return;
	}
	int d=(l+r)>>1;
	build(l,d,ls);
	build(d+1,r,rs);
	pp(k);
}
void update1(int l,int r,int k){
	if(tr[k].mx<=0||l>r) return;
	if(tr[k].l==tr[k].r){
		tr[k].mx=a[tr[k].num];
		return;
	}
	pd(k);
	int d=(tr[k].l+tr[k].r)>>1;
	if(l<=d) update1(l,r,ls);
	if(r>d) update1(l,r,rs);
	pp(k);
}
void update2(int l,int r,LL w,int k){
	if(tr[k].mx<=0||l>r) return;
	if(tr[k].l>=l&&tr[k].r<=r){
		tr[k].mx-=w;
		tr[k].lt+=w;
		return;
	}
	pd(k);
	int d=(tr[k].l+tr[k].r)>>1;
	if(l<=d) update2(l,r,w,ls);
	if(r>d) update2(l,r,w,rs);
	pp(k);
}
void dele(int pos,int k){
	if(tr[k].l==tr[k].r){
		tr[k].mx=0;
		return;
	}
	pd(k);
	int d=(tr[k].l+tr[k].r)>>1;
	if(pos<=d) dele(pos,ls);
	else dele(pos,rs);
	pp(k);
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) scanf("%d",&s[i]);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	build(1,n,1);
	LL ans=0;
	int mxl=0;
	for(int i=1;i<=n;i++){
		ans+=tr[1].mx;
		int k=tr[1].num;
		if(k>mxl){
			update1(mxl+1,k-1,1);
			update2(k+1,n,2ll*(s[k]-s[mxl]),1);
			mxl=k;
		}
		printf("%d\n",ans);
		dele(k,1);
	}
	return 0;
}