[LCT 线性模方程] BZOJ 2759 一个动态树好题

%%%PoPoQQQ：http://blog.csdn.net/popoqqq/article/details/40436165

“题目大意：给定n个形如xi=ki*x_pi+bi mod p的同余方程组 支持修改操作和求解操作

确实好题 感谢此题作者 顺便吐槽一下作者的Splay不加空节点太蛋疼了0.0

将每个点i的父亲设为pi 我们将会得到一座基环树林 将环上的一条边拆掉，在边的起始节点新开个域special_father记录这条边(P.S:好浪费 但是没办法)

于是我们得到了一座森林 显然可以用LCT来维护 每个节点的权值是个二元组(k,b)，记录每个点关于答案的线性关系，合并时左侧代入右侧中

查询时将root的special_father进行Access+Splay操作 然后借助这个环通过EXGCD求出root->special_father的值 然后Access+Splay(x)代入出解

若环上k=1 讨论b 若b=0则无穷多解 否则无解 注意k=0时要加一些处理 正常求EXGCD求不出来

单点修改 有向图 没有标记 爽爆了！

修改x的父节点时需要讨论：

首先切掉原先的父节点

如果x是所在树的根 直接切掉special_father

如果x不是根，切掉x与父节点的联系，然后讨论x是否在环上

设x所在树的根节点为root

若root->special_father所在树的根不为root 则x在环上 将root的special_father变为root的fa节点

否则切断父节点完毕

然后讨论新的父节点f是否在x的子树中

若在，将x的special_father设为f

若不在，将x的fa设为f”

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#define P 10007 
using namespace std;
typedef long long ll;
typedef pair<ll,ll> abcd;

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;
}

inline void read(ll &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;
}

inline void read(char &x){
	for (x=nc();x!='A' && x!='C';x=nc());
}

namespace Math{
	#define N 10007
	inline abcd EXGCD(ll a,ll b){
		if (a<b) { abcd ret=EXGCD(b,a); return abcd(ret.second,ret.first); }
		if (!b) return abcd(1,0);
		abcd ret=EXGCD(b,a%b);
		return abcd(ret.second,ret.first-a/b*ret.second);
	}
	inline int Solve(ll A,ll B){
		A%=N; B%=N;
		if (!A && !B) return -2;
		if (!A && B) return -1;
		if (!B && A) return 0;
		abcd E=EXGCD(A,N);
		ll D=A*E.first+N*E.second,X;
		if (B%D==0)
		{
			if (D!=1) return -2;
			X=E.first*(B/D);
			X=((X%(N/D))+N/D)%(N/D);
			return X;
		}
		else
			return -1;
	}
}

struct data{
	ll k,b;
	data(int k=1,int b=0):k(k),b(b) { }
	friend data operator + (const data &A,const data &B){
		data ret;
		(ret.k=A.k*B.k)%=P;
		(ret.b=B.k*A.b+B.b)%=P;
		return ret;
	}
};

struct Splay{
	struct node{
		int size,idx;
		node *p,*ch[2],*fat,*sf;
		data dat,sum;
		inline void setc(node *c,int d) { ch[d]=c; c->p=this; }
		inline bool dir() { return p->ch[1]==this; }
		inline void update() { size=ch[1]->size+ch[0]->size+1; sum=ch[0]->sum+dat+ch[1]->sum; }
	}*null,Mem[30005];
	Splay() { null=Mem; null->p=null->ch[0]=null->ch[1]=null->fat=null->sf=null; null->size=0; null->sum=data(1,0); }
	inline void rot(node *x){
		if (x==null || x->p==null) return;
		bool d=x->dir(); node *p=x->p;
		if (p->p!=null) p->p->setc(x,p->dir()); else x->p=null;
		p->setc(x->ch[d^1],d); x->setc(p,d^1); p->update(); x->update(); swap(x->fat,p->fat);
	}
	inline void splay(node *x){
		if (x==null) return;
		while (x->p!=null)
			if (x->p->p==null)
				rot(x);
			else
				x->dir()==x->p->dir()?(rot(x->p),rot(x)):(rot(x),rot(x));
	}
	inline node *Access(node *x){
		node *y=null;
		while (x!=null)
		{
			splay(x);
			x->ch[1]->p=null; x->ch[1]->fat=x;
			x->setc(y,1); y->fat=null;
			x->update();
			y=x; x=x->fat;
		}
		return y;
	}
	inline void Link(node *x,node *y){
		Access(x);
		splay(x);
		x->fat=y;
		Access(x);
	}
	inline void Cut(node *x){
		Access(x);
		splay(x);
		x->ch[0]->p=null; x->ch[0]=null;
		x->fat=null; x->update();
	}
	inline node *Root(node *x){
		Access(x);
		splay(x);
		node *y=x;
		while (y->ch[0]!=null) y=y->ch[0];
		return y;
	}
	inline bool Jud(node *x,node *y){
		return Root(x)==Root(y);
	}
	inline data Query(node *x){
		return Access(x)->sum;
	}
}LCT;

int n;
Splay::node *pos[30005];

inline void Init(int n)
{
	for (int i=1;i<=n;i++)
		pos[i]=LCT.Mem+i,pos[i]->p=pos[i]->ch[0]=pos[i]->ch[1]=pos[i]->fat=pos[i]->sf=LCT.null,pos[i]->size=1,pos[i]->idx=i;
}

inline void PCut(Splay::node *x){
	if (x==LCT.Root(x)){
		x->sf=LCT.null; return;
	}
	Splay::node *rt=LCT.Root(x),*sf=rt->sf;
	LCT.Cut(x);
	if (!LCT.Jud(sf,rt))
	{
		rt->sf=LCT.null;
		LCT.Link(rt,sf);	
	}
}

inline void PLink(Splay::node *x,Splay::node *y){
	if (LCT.Root(y)==x){
		x->sf=y; return;
	}
	LCT.Link(x,y);
}

int par[30005];

int main()
{
	char order;
	int ip,Q,u,ik,ib;
	ll x0;
	freopen("t.in","r",stdin);
	freopen("t.out","w",stdout);
	read(n); Init(n);
	for (int i=1;i<=n;i++)
	{
		read(pos[i]->dat.k); read(par[i]); read(pos[i]->dat.b); pos[i]->update();
	}
	for (int i=1;i<=n;i++)
		PLink(pos[i],pos[par[i]]);
	read(Q);
	while (Q--)
	{
		read(order);
		if (order=='A')
		{
			read(u);
			Splay::node *sf=LCT.Root(pos[u])->sf;
			data ret=LCT.Query(sf); 
			ret.b=(-ret.b+P)%P;
			ret.k=(ret.k-1+P)%P;
			x0=Math::Solve(ret.k,ret.b);
			if (x0!=-1 && x0!=-2)
			{
				ret=LCT.Query(pos[u]);
				(x0=x0*ret.k+ret.b)%=P;
			}
			printf("%lld\n",x0);
		}
		else
		{
			read(u); read(ik); read(ip); read(ib);
			PCut(pos[u]);
			LCT.splay(pos[u]);
			pos[u]->dat=data(ik,ib); pos[u]->update();
			PLink(pos[u],pos[ip]);
		}
	}
	return 0;
}