#include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<cstdlib>

 #include<algorithm>

 #include<cmath>

 #include<queue>

 #include<set>

 #include<map>

 #include<vector>

 #include<cctype>

 using namespace std;

 const int MAXN=;

 typedef long long LL;

 int N,M,root_now;

 struct edge{ int to,next; }E[MAXN<<];

 int first[MAXN],np,val[MAXN],dfs_clock,l[MAXN],r[MAXN];

 struct segment_tree{

     static const int maxn=;

     int rt,np,lc[maxn],rc[maxn]; LL sum[maxn],add[maxn];

     void pushup(int now) { sum[now]=sum[lc[now]]+sum[rc[now]]; }

     void pushdown(int now,int L,int R)

     {

         if(!add[now]) return;

         int m=L+R>>;

         add[lc[now]]+=add[now],sum[lc[now]]+=add[now]*(m-L+);

         add[rc[now]]+=add[now],sum[rc[now]]+=add[now]*(R-m);

         add[now]=;

     }

     void build(int &now,int L,int R,int *a)

     {

         now=++np;

         lc[now]=rc[now]=sum[now]=add[now]=;

         if(L==R){ sum[now]=a[L]; return;}

         int m=L+R>>;

         build(lc[now],L,m,a); build(rc[now],m+,R,a);

         pushup(now);

     }

     void update(int now,int L,int R,int A,int B,int v)

     {

         if(A<=L&&R<=B){

             add[now]+=v,sum[now]+=(R-L+)*v;

             return;

         }

         pushdown(now,L,R);

         int m=L+R>>;

         if(B<=m) update(lc[now],L,m,A,B,v);

         else if(A>m) update(rc[now],m+,R,A,B,v);

         else update(lc[now],L,m,A,B,v),update(rc[now],m+,R,A,B,v);

         pushup(now);

     }

     LL query(int now,int L,int R,int A,int B)

     {

         if(A<=L&&R<=B) return sum[now];

         pushdown(now,L,R);

         int m=L+R>>;

         if(B<=m) return query(lc[now],L,m,A,B);

         if(A>m) return query(rc[now],m+,R,A,B);

         return query(lc[now],L,m,A,B)+query(rc[now],m+,R,A,B);

     }

 }st;

 struct link_cut_tree{

     static const int maxn=;

     struct node{

         int fa,ch[]; bool rev;

         node(){ fa=ch[]=ch[]=,rev=; }

     }nd[maxn];

     void link(int x,int d,int y) { nd[x].ch[d]=y,nd[y].fa=x; }

     bool isrt(int x) { return nd[nd[x].fa].ch[]!=x&&nd[nd[x].fa].ch[]!=x; }

     void pushdown(int x)

     {

         if(!nd[x].rev) return;

         int lc=nd[x].ch[],rc=nd[x].ch[];

         if(lc) nd[lc].rev^=,swap(nd[lc].ch[],nd[lc].ch[]);

         if(rc) nd[rc].rev^=,swap(nd[rc].ch[],nd[rc].ch[]);

         nd[x].rev=;

     }

     void rot(int x)

     {

         int y=nd[x].fa,z=nd[y].fa;

         pushdown(y);pushdown(x);

         int d=nd[y].ch[]==x;

         if(!isrt(y)) link(z,y==nd[z].ch[],x); nd[x].fa=z;

         link(y,d^,nd[x].ch[d]);

         link(x,d,y);

     }

     void splay(int x)

     {

         pushdown(x);

         while(!isrt(x)){

             int y=nd[x].fa,z=nd[y].fa;

             if(!isrt(y)) rot((x==nd[y].ch[])==(y==nd[z].ch[])?y:x);

             rot(x);

         }

     }

     int find(int x,int d)

     {

         while(nd[x].ch[d]){ pushdown(x),x=nd[x].ch[d]; }

         return x;

     }

     void access(int x)

     {

         int y=,xx,yy;

         while(x){

             splay(x);

             if(y){

                 yy=find(y,);

                 if(l[x]<l[yy]&&l[yy]<=r[x]) st.update(st.rt,,N,l[yy],r[yy],-);

                 else{

                     if(l[x]>) st.update(st.rt,,N,,l[x]-,-);

                     if(r[x]<N) st.update(st.rt,,N,r[x]+,N,-);

                 }

             }

             pushdown(x);

             if((xx=find(nd[x].ch[],))&&l[x]<l[xx]&&l[xx]<=r[x]) st.update(st.rt,,N,l[xx],r[xx],);

             else if(xx){

                 if(l[x]>) st.update(st.rt,,N,,l[x]-,);

                 if(r[x]<N) st.update(st.rt,,N,r[x]+,N,);

             }

             nd[x].ch[]=y,y=x,x=nd[x].fa;

         }

     }

     void mroot(int x)

     {

         access(x); splay(x);

         nd[x].rev^=,swap(nd[x].ch[],nd[x].ch[]);

     }

 }lct;

 void add_edge(int u,int v)

 {

     E[++np]=(edge){v,first[u]};

     first[u]=np;

 }

 void data_in()

 {

     scanf("%d%d",&N,&M);

     int x,y;

     for(int i=;i<N;i++){

         scanf("%d%d",&x,&y);

         add_edge(x,y); add_edge(y,x);

     }

 }

 void DFS(int i,int f,int d)

 {

     l[i]=++dfs_clock,val[l[i]]=d;

     for(int p=first[i];p;p=E[p].next){

         int j=E[p].to;

         if(j==f) continue;

         lct.nd[j].fa=i;

         DFS(j,i,d+);

     }

     r[i]=dfs_clock;

 }

 void work()

 {

     DFS(root_now=,,);

     st.build(st.rt,,N,val);

     char op[]; int x,len; double ans;

     for(int i=;i<=M;i++){

         scanf("%s%d",op,&x);

         if(op[]=='L') lct.access(x);

         else if(op[]=='C') lct.mroot(root_now=x);

         else if(op[]=='Q'){

             ans=,len=;

             if(l[x]<=l[root_now]&&r[root_now]<=r[x]){

                 lct.splay(x);

                 x=lct.nd[x].ch[]?lct.find(lct.nd[x].ch[],):lct.nd[x].fa;

                 if(l[x]>) ans+=1.0*st.query(st.rt,,N,,l[x]-),len+=l[x]-;

                 if(r[x]<N) ans+=1.0*st.query(st.rt,,N,r[x]+,N),len+=N-r[x];

                 ans/=len;

             }

             else ans=1.0*st.query(st.rt,,N,l[x],r[x])/(r[x]-l[x]+);

             printf("%.10f\n",ans);

         }

     }

 }

 int main()

 {

     freopen("test.in","r",stdin);

     freopen("test.out","w",stdout);

     data_in();

     work();

     return ;

 }