临时程序

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 50100
#define maxm 1001000
struct node{
    int ch[2],val,s,sum;
}t[maxm];
#define lc(x) t[x].ch[0]
#define rc(x) t[x].ch[1]
inline void update(int x) {
    t[x].s=1+t[lc(x)].s+t[rc(x)].s;
    t[x].sum=t[x].val+t[lc(x)].sum+t[rc(x)].sum;
}
inline int _d(int x,int k) {
    if (t[lc(x)].s+1==k) return -1;
    return t[lc(x)].s<k;
}
inline void rotate(int &u,int d) {
    int v=t[u].ch[d];
    t[u].ch[d]=t[v].ch[d^1];
    t[v].ch[d^1]=u;
    update(u);
    update(v);
    u=v;
}
inline void splay(int &u,int k){ 
    int d=_d(u,k);
    if (d==-1) return ;
    if (d==1) k-=t[lc(u)].s+1;
    int &v=t[u].ch[d];
    int d1=_d(v,k);
    if (d1==-1) {rotate(u,d);return ;}
    if (d1==1) k-=t[lc(v)].s+1;
    splay(t[v].ch[d1],k);
    if (d1!=d) rotate(v,d1),rotate(u,d);
    else rotate(u,d),rotate(u,d1);
}
inline void cut(int &u,int &v,int k) {
    splay(u,k);
    v=t[u].ch[1];
    t[u].ch[1]=0;
    update(u);
}
inline void link(int &u,int v) {
    splay(u,t[u].s);
    t[u].ch[1]=v;
    update(u);
}
inline int que(int &u,int k) {
    splay(u,k);
    return t[u].sum-t[rc(u)].sum;
}
#define maxk 18
int clo,in[maxn],out[maxn],dep[maxn],f[maxn][maxk];
vector<int> e[maxn];
#define pb push_back
typedef pair<int,int> ii;
#define fi first
#define se second
ii a[maxn*2];
void dfs(int u,int fa) {
    in[u]=++clo;
    a[clo]=ii(u,1);
    dep[u]=dep[fa]+1;
    f[u][0]=fa;
    for (int i=1;i<maxk;i++) {
    if (f[f[u][i-1]][i-1]==0) break;
    f[u][i]=f[f[u][i-1]][i-1];
    }
    for (int i=0;i<e[u].size();i++) 
    if (e[u][i]!=fa) dfs(e[u][i],u);
    out[u]=++clo;
    a[clo]=ii(u,-1);
}
int up(int x,int y) {
   for (int i=0;i<maxk;i++) 
      if (y&(1<<i)) x=f[x][i];
   return x;
}
int lca(int x,int y) {
    if (dep[x]<dep[y]) swap(y,x);
    x=up(x,dep[x]-dep[y]);
    if (x==y) return x;
    for (int i=maxk-1;i>=0;i--) {
    if (f[x][i]==f[y][i]) continue;
    x=f[x][i],y=f[y][i];
    }
    return f[x][0];
}
#define mid ((l+r)>>1)
int cnt,c[maxn],v[maxn];
int build(int l,int r,int col) {
    if (r<l) return 0;
    int x=++cnt;
    t[x].val=(c[a[mid].fi]==col?v[a[mid].fi]:0)*a[mid].se;
    t[x].ch[0]=build(l,mid-1,col);
    t[x].ch[1]=build(mid+1,r,col);
    update(x);
    return x;
}
#define maxc 10
int root[maxc+2];
char opt[10];
int main(){
    int n;
       freopen("tree.in","r",stdin);
       freopen("tree.out","w",stdout);
       t[0]=(node){{0,0},0,0,0};
    scanf("%d",&n);
    for (int i=1;i<=n;i++) {scanf("%d",c+i);c[i]++;}
    for (int i=1;i<=n;i++) scanf("%d",v+i);
    for (int i=1;i<n;i++) {
    int x,y;
    scanf("%d%d",&x,&y);
    x++,y++;
    e[x].pb(y);e[y].pb(x);
    }
    dfs(1,0);
    for (int i=1;i<=maxc;i++) root[i]=build(0,clo,i);
    int T;
    scanf("%d",&T);
    while (T--) {
    scanf("%s",opt);
    int u,v,x,y;
    switch (opt[0]) {    
        case 'C':
        scanf("%d%d%d",&u,&x,&y);
        u++,x++,y++;
        int xmid,xr,ymid,yr;
        cut(root[x],xmid,in[u]);
        cut(xmid,xr,out[u]-in[u]+1);
        cut(root[y],ymid,in[u]);
        cut(ymid,yr,out[u]-in[u]+1);
        swap(ymid,xmid);
        link(root[x],xmid);link(root[x],xr);
        link(root[y],ymid);link(root[y],yr);
        break;
        case 'S':
        scanf("%d%d%d",&u,&x,&y);
        u++,x++;
        for (int i=1;i<=maxc;i++) {
            splay(root[i],in[u]+1);
            t[root[i]].val=x==i?y:0;
            update(root[i]);
            splay(root[i],out[u]+1);
            t[root[i]].val=x==i?-y:0;
            update(root[i]);
        }
        break;
        case 'A':
        scanf("%d%d%d",&u,&v,&x);
        u++,v++,x++;
        y=lca(u,v);
        printf("%d\n",que(root[x],in[u]+1)+que(root[x],in[v]+1)-que(root[x],in[y])-que(root[x],in[y]+1));
        break;
    }
    }
    return 0;
}

 

type
  arr=record
    toward,next:longint;
  end;
const
  maxn=5000000;
var
  edge:array[0..maxn]of arr;
  sum,size,cost,col,value,fa,left,right,first,num1,num2,deep:array[0..maxn]of longint;
  f:array[0..maxn,0..18]of longint;
  sroot:array[0..10]of longint;
  chose:array[0..maxn]of boolean;
  tot,esum,time,n,trsum:longint;

procedure swap(var x,y:longint);
var
  i:longint;
begin
  i:=x;
  x:=y;
  y:=i;
end;

procedure addedge(j,k:longint);
begin
  inc(esum);
  edge[esum].toward:=k;
  edge[esum].next:=first[j];
  first[j]:=esum;
end;

procedure dfs(x:longint);
var
  too,i:longint;
begin
  inc(time);
  num1[x]:=time;
  chose[x]:=false;
  i:=first[x];
  while i>0 do begin
    too:=edge[i].toward;
    if chose[too] then begin
      f[too,0]:=x;
      deep[too]:=deep[x]+1;
      dfs(too);
    end;
    i:=edge[i].next;
  end;
  inc(time);
  num2[x]:=time;
end;

procedure before;
var
  i,j:longint;
begin
  trsum:=trunc(ln(n)/ln(2));
  for i:=1 to trsum  do
   for j:=1 to n do
     f[j,i]:=f[f[j,i-1],i-1];
end;

function lca(x,y:longint):longint;
var
  i:longint;
begin
  if deep[x]<deep[y] then swap(x,y);
  for i:=trsum downto 0 do
    if deep[f[x,i]]>=deep[y] then
      x:=f[x,i];
  if x=y then exit(x);
  for i:=trsum downto 0 do
    if f[x,i]<>f[y,i] then begin
      x:=f[x,i];
      y:=f[y,i];
    end;
  exit(f[x,0]);
end;

procedure update(x:longint);
begin
  if x=0 then exit;
  sum[x]:=cost[x]+sum[left[x]]+sum[right[x]];
  size[x]:=size[left[x]]+1+size[right[x]];
end;

procedure lt(x:longint);
var
  k,u:longint;
  flag:boolean;
begin
  k:=right[x];
  u:=fa[x];
  if left[u]=x then flag:=true else flag:=false;
  right[x]:=left[k];
  fa[right[x]]:=x;
  left[k]:=x;
  fa[x]:=k;
  update(x);
  update(k);
  fa[k]:=u;
  if flag then left[u]:=k else right[u]:=k;
end;

procedure rt(x:longint);
var
  k,u:longint;
  flag:boolean;
begin
  k:=left[x];
  u:=fa[x];
  if left[u]=x then flag:=true else flag:=false;
  left[x]:=right[k];
  fa[left[x]]:=x;
  right[k]:=x;
  fa[x]:=k;
  update(x);
  update(k);
  if flag then left[u]:=k else right[u]:=k;
  fa[k]:=u;
end;

procedure splay(x,y:longint);
begin
  while fa[x]<>y do begin
    if fa[fa[x]]=y then
      if left[fa[x]]=x then rt(fa[x])
        else lt(fa[x])
    else
      if left[fa[x]]=x then begin
        if left[fa[fa[x]]]=fa[x] then rt(fa[fa[x]]);
        rt(fa[x]);
      end
      else begin
        if right[fa[fa[x]]]=fa[x] then lt(fa[fa[x]]);
        lt(fa[x]);
      end;
  end;
end;

function find(x,y:longint):longint;
begin
  //writeln(x,' ',size[x],' ',y);
  if size[left[x]]+1=y then exit(x);
  if y<=size[left[x]] then exit(find(left[x],y))
    else exit(find(right[x],y-1-size[left[x]]));
end;

function build(l,r:longint):longint;
var
  now,mid:longint;
begin
  //writeln(l,' ',r);
  inc(tot);
  now:=tot;
  cost[now]:=0;
  sum[now]:=0;
  size[now]:=r-l+1;
  left[now]:=0;
  right[now]:=0;
  if l=r then exit(now);
  mid:=(l+r)>>1;
  if l<mid then begin
    left[now]:=build(l,mid-1);
    fa[left[now]]:=now;
  end;
  if mid<r then begin
    right[now]:=build(mid+1,r);
    fa[right[now]]:=now;
  end;
  //update(now);
  exit(now);
end;

function ask(x,y,color:longint):longint;
var
  point1,point2:longint;
begin
  point1:=find(sroot[color],x);
  splay(point1,0);
  sroot[color]:=point1;
  point2:=find(sroot[color],y);
  splay(point2,point1);
  exit(sum[left[point2]]);
end;

procedure change(x,col1,col2:longint);
var
  point1,point2,point3,point4,point5,point6:longint;
begin
  point1:=find(sroot[col1],num1[x]-1);
  splay(point1,0);
  sroot[col1]:=point1;
  point2:=find(sroot[col1],num2[x]+1);
  splay(point2,point1);
  point3:=left[point2];

  point4:=find(sroot[col2],num1[x]-1);
  splay(point4,0);
  sroot[col2]:=point4;
  point5:=find(sroot[col2],num2[x]+1);
  splay(point5,point4);
  point6:=left[point5];

  fa[point3]:=point5;
  left[point5]:=point3;
  update(point5);
  update(point4);

  fa[point6]:=point2;
  left[point2]:=point6;
  update(point2);
  update(point1);
end;

procedure setnew(x,color,y:longint);
var
  point1,point2:longint;
begin
  //writeln(color);
  point1:=find(sroot[color],num1[x]);
  splay(point1,0);
  sroot[color]:=point1;
  point2:=find(sroot[color],num2[x]);
  splay(point2,point1);
  cost[point2]:=-y;
  cost[point1]:=y;
  update(point2);
  update(point1);
end;

procedure into;
var
  i,j,k:longint;
begin
  read(n);
  for i:=1 to n do read(col[i]);
  for i:=1 to n do read(value[i]);
  for i:=1 to n-1 do begin
    readln(j,k);
    addedge(j+1,k+1);
    addedge(k+1,j+1);
  end;
  time:=1;
  deep[0]:=0;
  deep[1]:=1;
  fillchar(chose,sizeof(chose),true);
  dfs(1);
  before;
  inc(time);
  tot:=0;
  sum[0]:=0;
  size[0]:=0;
  cost[0]:=0;
  for i:=0 to 9 do sroot[i]:=build(1,time);
  for i:=1 to n do setnew(i,col[i],value[i]);
end;

procedure work;
var
  m,i,j,k,l,ans1,ans2,ans3,color,col1,col2:longint;
  ch:char;
begin
  readln(m);
  while m>0 do begin
    //writeln('!');
    dec(m);
   // writeln(m);
    read(ch);
    if ch='A' then begin
      while ch<>' ' do read(ch);
      readln(j,k,color);
      j:=j+1;
      k:=k+1;
      if deep[j]<deep[k] then swap(j,k);
      l:=lca(j,k);
      if l=k then writeln(ask(l,j,color))
      else begin
        ans1:=ask(num1[l]-1,num1[j]+1,color);
        ans2:=ask(num1[l],num1[k]+1,color);
        ans3:=ans1+ans2;
        writeln(ans3);
      end;
    end
    else
    if ch='C' then begin
      while ch<>' ' do read(ch);
      readln(j,col1,col2);
      j:=j+1;
      change(j,col1,col2);
    end
    else begin
      while ch<>' ' do read(ch);
      readln(j,k,l);
      j:=j+1;
      for i:=0 to 9 do setnew(j,i,0);
      setnew(j,k,l);
    end;
  end;
end;

begin
  assign(input,'1.in');
  assign(output,'tree1.out');
  reset(input);
  rewrite(output);
  into;
  work;
  close(input);
  close(output);
end.

 

cf 2017.8.1

#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
#define rep(i,l,r) for(int i=l;i<=r;i++)
#define dow(i,l,r) for(int i=r;i>=l;i--)
#define rep0(i,r) for(int i=0;i<r;i++)
#define repedge(i,x) for(int i=fi[x];i;i=e[i].next)
#define maxn 200200
#define LL long long
using namespace std;

LL f[maxn],cost[maxn],sum[maxn];
int vis[maxn],n,total,l,r,fa[maxn],fi[maxn],flag=0,col[maxn],p[maxn];
vector<int> vec;
typedef struct{
    int next,t;
    LL v;
}E;
E e[maxn*2];

void addedge(int j,int k,LL l)
{
    ++total;
    e[total].next=fi[j];
    fi[j]=total;
    e[total].t=k;
    e[total].v=l;
}

void dfs(int x)
{
    vis[x]=1;
    repedge(i,x) {
        int too=e[i].t;
        if (!vis[too]) dfs(too);
        else {
            if (vis[too] && fa[x]!=too) {
                l=x,r=too,cost[l]=e[i].v;
                flag=1;
                return;
            }
        }
        if (flag) return;
    }
}

void dfs2(int x)
{
    repedge(i,x) {
        int too=e[i].t;
        if (fa[x]!=too && too!=l) {
            fa[too]=x;
            dfs2(too);
        }
    }
}

void dfs4(int x)
{
    f[x]=0;
    repedge(i,x) {
        int too=e[i].t;
        if (too==fa[x]) continue;
        dfs4(too);
        f[x]=max(f[x],f[too]+e[i].v);
    }
}

void dfs3(int x)
{
    repedge(i,x) {
        int too=e[i].t;
        if (too!=fa[x] && too!=l) {
            if (col[too])  {
                cost[too]=e[i].v;
                dfs3(too);
            }
            else {
                dfs4(too);
                f[x]=max(f[x],f[too]+e[i].v); 
            } 
        }
    }
}

int main()
{
    scanf("%d",&n);
    memset(vis,0,sizeof(vis));
    memset(fa,0,sizeof(fa));
    rep(i,1,n) {
        int j,k;
        LL l;
        scanf("%d %d %lld",&j,&k,&l);
        addedge(j,k,l);
        addedge(k,j,l);
    }
    dfs(1);
    memset(vis,0,sizeof(vis));
    memset(fa,0,sizeof(fa));
    dfs2(l);
//    printf("!!\n");
    int now=r;
    while (now) {
        vec.push_back(now);
        col[now]=1;
        now=fa[now];
    }
    int tot=0;
    rep0(i,vec.size()) 
    dfs3(l);
    printf("%d %d\n",l,r);
    rep0(i,vec.size()) printf("%d %lld %lld\n",vec[i],f[vec[i]],cost[vec[i]]);
    int len=vec.size();
    sum[0]=0;
    rep(i,1,len-1) sum[i]=sum[i-1]+cost[vec[len-i-1]];
    rep(i,0,len-1) sum[i+len]=sum[i+len-1]+cost[vec[len-i-1]];
    rep(i,0,len*2-1) printf("%d %lld\n",i,sum[i]);
    LL ans=(LL)1<<50;
    int l=1,r=0;
    rep(i,l,r) {
        while (l<=r && sum[p[r]]-f[vec[p[r]]]>sum[i]-f[vec[i]]) r--;
        p[++r]=i;
    }
    rep(i,len-1,2*len-1) {
        printf("%d %lld\n",i,sum[i]);
        while (l<=r && i-p[l]>=len) l++;
        printf("\t%d\n",l);
        if (l<=r) ans=min(ans,sum[i]-sum[p[l]]+f[vec[p[l]]]+f[vec[i]]);
        else ans=min(ans,sum[i]+f[vec[i]]);
        while (l<=r && sum[p[r]]-f[vec[p[r]]]>sum[i]-f[vec[i]]) r--;
        p[++r]=i;
        printf("%lld\n",ans);
    }
    printf("!!\n");
    printf("%lld\n",ans);
    return 0;
}

 

#include<stdio.h>
#include<stdlib.h>
#include<queue>


//结构
struct Passenger{   //乘客类型
        int tsum,id,plantime;  //tsum表示乘客处理的时间,id表示乘客的编号
        Passenger *next;
};
typedef Passenger* PassEnger;

//函数声明部分
double get_people_rand();            //得到人数的随机函数

//常量说明
int MaxHallPeople;            //大厅能接纳的最大人数=MaxLines*MaxCustSingleLine


//变量
int peoplesum;                  //表示当前已经产生的人数

void from_hall_to_window()                                      //从接纳大厅到排队窗口
{
        while (hallqueue.empty()==0) {
                if      (add_window(winqueue)!=-1) hallqueue.pop();
                else break;
        }
        // !!!!还没添加动画事件，动画事件同样需要把人数前移
}


void getpeople_from_ButterOrRand()      //新增乘客进入接纳大厅
{
        int hallqueuesize=hallqueue.size();
        if (get_mouse_manage) {


        }
        else {
                int morepeople=get_people_rand();
                if (hallqueuesize+morepeopeo>MaxHallPeople) return ;
                while (morepeople--) {
                        PassEnger nowpeo=(Passenger*)malloc(sizeof(Passenger));
                        nowpeo.id=++peoplesum;
                        hallqueue.push(nowpeo);
                }
        }

}