int Findmin()
{int x = root;     //x记录当前结点，当然从根节点开始找 while (ls[x]) x=ls[x];    //如果Is[x]不为0，说明有左儿子，让x等于它的左儿子 return key[x];            //返回最小权值
}

int Find(int x)               //在搜索二叉堆里定位一个数
{int now=root;             //从根节点开始找 while(key[now]!=x)        //如果不相等就一直往下找 if (key[now]<x) now=rs[now]; //如果大于当前结点就直接从右边找,二分思想减少复杂度 else now=ls[now];            //否则从左边找 return now;               //如果没找到会返回空值
}

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<ctime>
#include<set>
#include<vector>
#include<map>
#include<queue>#define N 300005
#define M 8000005#define mid ((l+r)>>1)#define mk make_pair
#define pb push_back
#define fi first
#define se secondusing namespace std;int i,j,m,n,p,k,ls[N],rs[N],sum[N],size[N],a[N],root,tot,fa[N]; void ins(int x)//插入一个权值为x的数字
{sum[++tot]=x;   //用tot来表示二叉树里的节点个数,sum数组存第tot个结点的权值 size[tot]=1;    //它能遍历到的点只有它自己 if (!root) root=tot;//如果一开始一个节点都没有,就要找一个节点当根else{int now=root; //从根开始for (;;){++size[now]; if (sum[now]>sum[tot]) //判断和当前节点的大小,如果tot小于当前结点now,说明应该插在now左边
                        {if (!ls[now])  //如果now没左儿子,直接插入
                                {ls[now]=tot;fa[tot]=now;   //标记now的左儿子为tot,tot的父亲为now break;     //跳出循环,进入下次插入
                                }else now=ls[now];//如果now有左儿子,那么继续从now的左儿子Is[now]继续往下找
                        } else{if (!rs[now])  //与上面同理
                                {rs[now]=tot; fa[tot]=now;break;}else now=rs[now];}}}
}int FindMin()             //找最小值,肯定在左子树里
{int now=root;     //从根节点开始找 while (ls[now]) now=ls[now]; //一直往下找,直到没有左孩子 return sum[now];             //返回最小值
}void build1()//暴力build的方法,每次插入一个值
{for (i=1;i<=n;++i) ins(a[i]);
}int Divide(int l,int r)
{if (l>r) return 0;ls[mid]=Divide(l,mid-1);rs[mid]=Divide(mid+1,r);fa[ls[mid]]=fa[rs[mid]]=mid; fa[0]=0;sum[mid]=a[mid];size[mid]=size[ls[mid]]+size[rs[mid]]+1;return mid;
}void build2()//精巧的构造,使得树高是log N的
{sort(a+1,a+n+1);root=Divide(1,n);tot=n;
}int Find(int x)//查询值为x的数的节点编号
{int now=root;while (sum[now]!=x&&now)if (sum[now]<x) now=rs[now]; else now=ls[now];return now;
}int Findkth(int now,int k)
{if (size[rs[now]]>=k) return Findkth(rs[now],k); //因为右子树的数都大于左子树中的数,所以如果当前点右子树的size值大于k,那么第k大的值一定在右子树里,递归右子树继续往下找 else if (size[rs[now]]+1==k) return sum[now]; //因为右子树一共有size[rs[now]]个,若size[rs[now]]+1==k，说明第k大的值就是当前结点，直接返回，因为左边的数都比当前结点的数小 else Findkth(ls[now],k-size[rs[now]]-1);//注意到递归下去之后右侧的部分都比它要大，第k大的数只能在左子树里了，此时我们已经找了前size[rs[now]]+1位大数了，所以要用k减去它
}void del(int x)       //删除一个值为x的点
{int id=Find(x),t=fa[id];//找到这个点的编号id，t位id的父亲 if (!ls[id]&&!rs[id])   //如果这个结点没有儿子
        {if (ls[t]==id) ls[t]=0;   //是左儿子就将ls[t]置空 else rs[t]=0; //否则就将rs[t]置空 for (i=id;i;i=fa[i]) size[i]--;  //将结点id删去后，他及他的祖先能遍历到的点都减少了一，所以要减去一
        }elseif (!ls[id]||!rs[id])   //只有一个儿子
        {int child=ls[id]+rs[id];//找存在的儿子的编号，因为其中肯定有一个儿子的编号为0表示没有该儿子，加起来就是存在的那个儿子的编号 if (ls[t]==id) ls[t]=child; //是左儿子就将ls[t]接上id的孩子childelse rs[t]=child;        //否则就将rs[t]接上id的孩子child       fa[child]=t;             //标记child的新父亲 for (i=id;i;i=fa[i]) size[i]--;      //将结点id删去后，他及他的祖先能遍历到的点都减少了一，所以要减去一
        }else{int y=rs[id]; while (ls[y]) y=ls[y]; //找后继 if (rs[id]==y) {if (ls[t]==id) ls[t]=y; else rs[t]=y;fa[y]=t;ls[y]=ls[id];fa[ls[id]]=y;for (i=id;i;i=fa[i]) size[i]--;size[y]=size[ls[y]]+size[rs[y]];//y的子树大小需要更新
                }else //最复杂的情况
                {for (i=fa[y];i;i=fa[i]) size[i]--;//注意到变换完之后y到root路径上每个点的size都减少了1int tt=fa[y]; //先把y提出来 if (ls[tt]==y){ls[tt]=rs[y];fa[rs[y]]=tt;}                    else{rs[tt]=rs[y];fa[rs[y]]=tt;}    //再来提出x          if (ls[t]==x){ls[t]=y;fa[y]=t;ls[y]=ls[id];rs[y]=rs[id];}else{rs[t]=y;fa[y]=t;ls[y]=ls[id];rs[y]=rs[id];}size[y]=size[ls[y]]+size[rs[y]]+1;//更新一下size
                }}
}int main()
{scanf("%d",&n);for (i=1;i<=n;++i) scanf("%d",&a[i]);build1();printf("%d\n",Findkth(root,2));//查询第k大的权值是什么,这里k==2 del(4);printf("%d\n",Findkth(root,2));         return 0；
}

int dfs(int now)
{if (ls[now]) dfs(ls[now]);   //如果有左儿子,访问左儿子 printf("%d",key[now])        //输出now结点的权值 if (rs[now]) dfs(rs[now]);   //如果有右儿子,访问右儿子
}

for(int i=1;i<=n;i++)f[i][0]=i;                              //f[i][0]就是i自己，因为这个区间是左闭右开的 for(int j=1;1<<j<=n;j++)                //注意j层在外面，不然f[i][0]更新不到其他的状态，这一层是保证右边的中括号里的值在范围内  for(int i=1;i+(1<<j)-1<=n;i++)       //注意减一，左闭右开！这一层是保证左边的中括号里的值在范围内 f[i][j]=min(f[i][j-1],f[i+1<<(j-1)][j-1]);    //状态转移方程 

for(int i=1;i<=m;i++){cin>>l>>r;int len=r-l+1;                        //求区间长度 int t=(int)(double)log(len)/log(2.0); //要以2为底就要加上后面的log(2.0) f[l][r]=min(f[l][t],f[r-(1<<t)+1][t]);//这是上面推出来的公式 }

const int N=100001;
int tree[N*4];                                //tree数组记录区间和
void modify(int q,int c,int l,int r,int t)    //这个点的权值为q，也可以看作是区间[q,q]，我们要将它修改成c，当前正分解的区间是[l,r]，这个点的编号为t
{if(q==l&&q==r)                            //如果当前分解的区间正好在这个点以内（说白了就是这个点），就将这个点的权值进行修改
    {tree[t]=c;                            //将这个点的权值修改为c return ;}int mid=(l+r)/2;                          //找区间中点 if(q<=mid) modify(q,c,l,mid,t*2);         //如果这个点小于中点，说明在这个区间的左区间里 else modify(q,c,mid+1,r,t*2+1);           //否则就在这个区间的右区间里 tree[t]=tree[t*2]+tree[t*2+1];            //将最底层的q修改后别忘了修改它的祖宗的值
} 

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<ctime>
#include<set>
#include<vector>
#include<map>
#include<queue>#define N 1000005
#define M 1000005#define ls (t*2)
#define rs (t*2+1)
#define mid ((l+r)/2) using namespace std;long long i,j,m,n,p,k,lazy[N*4],a[N],x,c,l,r;       //lazy数组存每个结点的懒标记，sum数组存每个结点的区间和，注意四倍空间 long long ans,sum[N*4];void build(int l,int r,int t)           //初始化sum的值，为原先的区间和
{if (l==r) sum[t]=a[l];          //只有一个结点 else{build(l,mid,ls);           //找它的左儿子 build(mid+1,r,rs);         //找它的右儿子 sum[t]=sum[ls]+sum[rs];    //该结点的区间和等于它的左儿子加上它的右儿子的区间和
        }
}
void down(int t,int len)                //对lazy标记进行下传
{if (!lazy[t]) return;           //如果没有lazy标记，那么直接返回 sum[ls]+=lazy[t]*(len-len/2);   //求左儿子的新区间和，len-len/2是左儿子的长度 sum[rs]+=lazy[t]*(len/2);       //求右儿子的新区间和，len/2是右儿子的长度 lazy[ls]+=lazy[t];              //传给左右儿子，累积lazy标记 lazy[rs]+=lazy[t];lazy[t]=0;                      //父亲结点的lazy标记已经传下去了，所以要清空
}void modify(int ll,int rr,long long c,int l,int r,int t) //[ll,rr]整体加上c，当前节点代表的区间位[l,r]
{if (ll<=l&&r<=rr)              //如果当前分解的区间在所给的区间内
         {sum[t]+=(r-l+1)*c;      //对[l,r]区间的影响就是加上了(r-l+1)*c lazy[t]+=c;             //加上lazy标记
         }else                           //如果当前分解的区间未完全被包含在内的话
         {down(t,r-l+1);          //要往下细分就要下传lazy标记 if (ll<=mid) modify(ll,rr,c,l,mid,ls);   //如果与左区间有交集，那么我们就去细分左区间 if (rr>mid)  modify(ll,rr,c,mid+1,r,rs); //如果与右区间有交集，那么我们就去细分右区间 sum[t]=sum[ls]+sum[rs];//更新一下区间和
         }
} void ask(long long ll,long long rr,long long l,long long r,long long t) //[ll，rr]是要查询的区间，[l，r]是当前分解的区间
{if (ll<=l&&r<=rr) ans+=sum[t];  //代表着找到了完全被包含在内的一个区间，所以直接返回这个区间的区间和 else                            //如果有未完全被包含在内的
        {down(t,r-l+1);          //将lazy标记下传并继续细分它的儿子 if (ll<=mid) ask(ll,rr,l,mid,ls);  //如果与左区间有交集就细分左区间 if (rr>mid)  ask(ll,rr,mid+1,r,rs);//如果与右区间有交集就细分右区间
        }
}int main()
{scanf("%d%d",&n,&m); for (i=1;i<=n;++i) scanf("%d",&a[i]); build(1,n,1);                   //初始化 for(long long i=1;i<=m;i++){long long p;      scanf("%lld",&p);if(p==1)                    //如果是1则在区间[l，r]上加上k
            {long long l,r,k;scanf("%lld%lld%lld",&l,&r,&k);modify(l,r,k,1,n,1);}    if(p==2)                    //如果是2则输出区间[l，r]的和
            {long long l,r;scanf("%lld%lld",&l,&r);ans=0; ask(l,r,1,n,1); printf("%lld\n",ans);}} return 0;
}

1 int change(int x,int y,int n)       //x是要改的那个数的位置，a[x]+=y，n是最大范围
2 {
3     for(int i=x;i<=n;i+=lowbit(i))  //根据上面的推理，每次i要加上lowbit(i)
4     c[i]+=y;
5 }

1 int change(int x,int n)
2 {
3     for(int i=x;i;i-=lowbit(i))   //根据上面的公式，要一直用i减去它的lowbit直至为0
4     sum+=c[i];
5     return sum;
6 }

int getroot(int x)
{if(fa[x]==x) return x;      //如果fa[x]==x说明x就是树根，直接返回树根 else return getroot(fa[x]); //否则就往上找，直至找到树根
} 

int getroot(int x)
{if(fa[x]!=x)  fa[x]=getroot(fa[x]);      //如果x有父亲就一直往上找直至找到祖宗 return fa[x];                            //返回祖宗结点
} 

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=500001;
int head[2*maxn],to[2*maxn],next[2*maxn],grand[2*maxn][21],dep[maxn];       //注意开两倍大小的数组,因为这个图是无向图
//head[i]是存以i结点为起点的最后一条出边的编号
//to[i]数组是存第i条边的终点
//next[i]是存以i结点为起点的所有出边中的倒数第二条出边的编号，其实也就是head[i]的上一条边
int n,m,s,edge_sum=0;                  //edge_sum记录边数
void add(int x,int y)                  //用链式前向星(链表)建图
{next[++edge_sum]=head[x];          //根据我们定义的head与next的含义得出 head[x]=edge_sum;                  //有新的边加入，则将head[x]内的值更新 to[edge_sum]=y;                    //当前边的终点是y
}
void dfs(int v,int deep)
{dep[v]=deep;                       //记录v结点的深度 for(int i=head[v];i>0;i=next[i])   //后序访问v的所有出边
    {int u=to[i];                   //u记录当前边的终点，也就是说u是v的儿子 if(!dep[u]) dfs(u,deep+1),grand[u][0]=v;  //如果该儿子u的深度没被更新，则更新它，并记录u的父亲是v
    }
}
int lca(int x,int y)
{if(dep[x]<dep[y]) swap(x,y);       //我们让x是深度最大的那个 for(int i=20;i>=0;i--)if(dep[y]<=dep[x]-(1<<i)) x=grand[x][i];     //让x和y跳到同一层上 if(x==y) return y;                 //如果跳到同一点上了，说明这个点就是最近公共祖先 for(int i=20;i>=0;i--)             //倍增找最近公共祖先
    {if(grand[x][i]!=grand[y][i])   //如果跳不到公共祖先，那就往上跳
        {x=grand[x][i];             //将x和y往上跳 y=grand[y][i];              }}return grand[x][0];                //因为我们只要求跳不到同一点就往上跳，所以这样操作之后它们再往上跳一层也就是它们的最近公共祖先了
}
int read()                             //快读
{char ch=getchar();int a=0;while(ch<'0'||ch>'9') ch=getchar();while(ch>='0'&&ch<='9'){a=a*10+(ch-'0');ch=getchar();}return a;
}
int main()
{memset(head,0,sizeof(head));       //head数组初始化,好像可以去掉 n=read(),m=read(),s=read();        //这个题数据那么大,快读优化下 for(int i=1;i<n;i++)               //n-1条边
    {int x=read(),y=read();          add(x,y);                      //题目中给的是无向图,所以也要反过来建一次
        add(y,x);                       }grand[s][0]=s;                     //设起点s的父亲就是自己 dfs(s,1);                          //从深度为1的起点开始深搜 for(int i=1;(1<<i)<=n;i++)         //利用状态转移方程计算出每个点的grand值 for(int j=1;j<=n;j++)grand[j][i]=grand[grand[j][i-1]][i-1];for(int i=1;i<=m;i++)              //m次询问
    {int x=read(),y=read();printf("%d\n",lca(x,y));}return 0;
}