[树链剖分 线段树 标记永久化] BZOJ 4515 [Sdoi2016]游戏

想到了维护 ax+b 但不知道怎么修改 然后就听说了标记永久化 对于两个直线方程 把决定范围小的下放到子树中

树链剖分两个log，标记一次最多下推log层

三个log复杂度好虚

UPD:day2讲课的时候惊闻原来这叫超哥线段树，Orz

然后回自己blog一看，代码贴错了，我的锅

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#define V G[p].v
#define oo (1LL<<60)
using namespace std;
typedef long long ll;

inline char nc()
{
	static char buf[100000],*p1=buf,*p2=buf;
	if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
	return *p1++;
}

inline void read(int &x)
{
	char c=nc(),b=1;
	for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
	for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=200005;

struct edge{
	int u,v,w,next;
};

edge G[2*N];
int head[N],inum;

inline void add(int u,int v,int w,int p){
	G[p].u=u; G[p].v=v; G[p].w=w; G[p].next=head[u]; head[u]=p;
}

int size[N],depth[N],fat[N];
ll dis[N];
int clk,tid[N],top[N],inv[N];

void dfs(int u,int fa){
	fat[u]=fa; depth[u]=depth[fa]+1; size[u]=1;
	for (int p=head[u];p;p=G[p].next)
		if (V!=fa)
		{
			dis[V]=dis[u]+G[p].w;
			dfs(V,u),size[u]+=size[V];
		}
}

void find(int u,int fa,int z){
	tid[u]=++clk; top[u]=z; inv[clk]=u;
	int maximum=0,son=0;
	for (int p=head[u];p;p=G[p].next)
		if (V!=fa && size[V]>maximum)
			maximum=size[son=V];
	if (son) find(son,u,z);
	for (int p=head[u];p;p=G[p].next)
		if (V!=fa && V!=son)
			find(V,u,V);
}

inline int LCA(int u,int v){
	for (;top[u]!=top[v];u=fat[top[u]])
		if (depth[top[u]]<depth[top[v]]) 
			swap(u,v);
	if (depth[u]>depth[v]) swap(u,v);
	return u;
}

int n,m;
ll Min[N*4],A[N*4],B[N*4],F[N*4];
int lp[N*4],rp[N*4];

inline void Build(int rt,int l,int r){
	lp[rt]=l; rp[rt]=r;
	if (l==r) return;
	int mid=(l+r)>>1;
	Build(rt<<1,l,mid); Build(rt<<1|1,mid+1,r);
}

inline void update(int rt){
	int l=lp[rt],r=rp[rt];
    if (F[rt]) Min[rt]=min(B[rt],A[rt]*(dis[inv[r]]-dis[inv[l]])+B[rt]);
    if (l!=r)  Min[rt]=min(Min[rt],min(Min[rt<<1],Min[rt<<1|1]));
}

inline void Flag(int rt,ll a,ll b) 
{
	int l=lp[rt],r=rp[rt];
	if (!F[rt]) { A[rt]=a; B[rt]=b; F[rt]=1; update(rt); return; }
	int mid=(l+r)>>1; 
	ll len=dis[inv[mid+1]]-dis[inv[l]],d;
    if (A[rt]==a || l==r)
	{
		B[rt]=min(B[rt],b);
	}
    else if (a>A[rt] && B[rt]<b)
	{
		
	}
    else if (a>A[rt] && B[rt]>=b) 
	{
        d=(B[rt]-b)/(a-A[rt]);
        if (d<len)
			Flag(rt<<1,a,b);
        else 
		{
            swap(A[rt],a),swap(B[rt],b);
        	Flag(rt<<1|1,a,b+a*len);
        }
    }
    else if (a<A[rt] && B[rt]>b) 
		A[rt]=a,B[rt]=b;
    else if (a<A[rt] && B[rt]<=b) 
	{
        d=(B[rt]-b)/(a-A[rt])+1;
        if (d>=len)
			Flag(rt<<1|1,a,b+a*len);
        else
		{
            swap(A[rt],a),swap(B[rt],b);
            Flag(rt<<1,a,b);
        }
    }
    update(rt);
}

void modify(int rt,int ql,int qr,ll a,ll b) {
	int l=lp[rt],r=rp[rt];
    if (ql<=l && r<=qr) 
	{
        Flag(rt,a,b+a*(dis[inv[l]]-dis[inv[ql]]));
        return;
    }
    int mid=(l+r)>>1;
    if (ql<=mid) modify(rt<<1,ql,qr,a,b);
    if (qr>mid) modify(rt<<1|1,ql,qr,a,b);
    update(rt);
}

ll Query(int rt,int ql, int qr) {
    ll ret=oo;
  	int l=lp[rt],r=rp[rt];
    if (F[rt]) 
	{
        int L=max(l,ql),R=min(r,qr);
        ret=min(A[rt]*(dis[inv[L]]-dis[inv[l]])+B[rt],A[rt]*(dis[inv[R]]-dis[inv[l]])+B[rt]);
    }
    if (ql<=l && r<=qr) 
		return min(ret,Min[rt]);
    else 
	{
        int mid=(l+r)>>1;
        if (ql<=mid) ret=min(ret,Query(rt<<1,ql,qr));
        if (qr>mid)  ret=min(ret,Query(rt<<1|1,ql,qr));
	}
    return ret;
}

inline ll Solve(int u,int v)
{
	ll ret=oo;
	for (;!(top[u]==top[v]);u=fat[top[u]])
	{
		if (depth[top[u]]<depth[top[v]]) swap(u,v);
		ret=min(ret,Query(1,tid[top[u]],tid[u]));
	}
	if (depth[u]>depth[v]) swap(u,v);
	ret=min(ret,Query(1,tid[u],tid[v]));
	return ret;
}

inline void modify2(int lca,int x,ll a,ll b) {
    for (;top[lca]!=top[x];x=fat[top[x]])
        modify(1,tid[top[x]],tid[x],a,b+a*(dis[top[x]]-dis[lca]));
    modify(1,tid[lca],tid[x],a,b);
}

inline void Modify(int u,int v,ll a,ll b) {
    int lca=LCA(u,v);
    modify2(lca,u,-a,b+a*(dis[u]-dis[lca]));
    modify2(lca,v,a,b+a*(dis[u]-dis[lca]));
}

int main()
{
	int iu,iv,iw,Q,order;
	int a,b,s,t;
	freopen("t.in","r",stdin);
	freopen("t.out","w",stdout);
	read(n); read(Q);
	for (int i=1;i<n;i++)
		read(iu),read(iv),read(iw),add(iu,iv,iw,++inum),add(iv,iu,iw,++inum);
	dfs(1,0); find(1,0,1);
	Build(1,1,n);
	for (int i=0;i<=N*2;i++) Min[i]=123456789123456789LL;
	while (Q--)
	{
		read(order);
		if (order==1)
		{
			read(s); read(t); read(a); read(b);
			Modify(s,t,a,b);
		}
		else
		{
			read(s); read(t);
			printf("%lld\n",Solve(s,t));
		}
	}
	return 0;
}