题解:
题目真**长
我们用LCT来解决这道题。
首先我们需要观察到一个性质.每一次加入的病毒一定是新变种。
也就是说其实每个点究竟是那种颜色并不重要,因为每一次都加入新颜色
所以无论是什么颜色都会被直接xx掉。
所以我们的可以得出这样的一条结论
- 一个点到根的不同的颜色数即为这个点到根时经过的虚边的个数
也就是说我们直接把第一个操作当作access操作
我们发现这样前两个操作都解决了
但是我们查询一个点的时候并不能暴力跳fa找经过的虚边数.
所以我们需要外部维护一下.
由于我们要查询的是一个子树内的权和,那我们应该自然地想到用dfs序
所以我们在进行LCT的过程中在外部动态维护一个dfs序.
Wait !!这是有换跟操作的啊,dfs序不是固定的.
我们可以根据当前的根节点rt与查询节点u的关系来分类讨论.
具体是:
if rt == u: query all
if lca(rt,u) == rt : query tree of u
if lca(u,rt) == u :
find point p has min depth and (lca(p,rt) = p,lca(p,u) = u)
上述lca是指在初始树中.
我们发现lca 只是用来祖孙判定的,我们可以用dfs序来代替这个简单的问题.
还不明白的话,,可以看我这从晚自习开始一直调到第二天早自习的代码.
如果有人想问我是怎么做到拍了一晚上没找出错交到bzoj上4msRE却只因为自己写数据生成器的时候只生成了查询操作的话我是会非常乐意地告诉你以后写数据生成器写到一半的时候不要因为有事就编译好生成器然后关掉生成器的cpp去干一些其他的愉悦的会让你忘了你的生成器还没有写完的事情比如说在大下雨天去学校满是水的塑胶跑道上去跑操并且跑完后躺在全是水的假草坪上然后会机房的时候再感个冒.
。。。 。。。
呵呵
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
inline void read(int &x){
x=0;char ch;bool flag = false;
while(ch=getchar(),ch<'!');if(ch == '-') ch=getchar(),flag = true;
while(x=10*x+ch-'0',ch=getchar(),ch>'!');if(flag) x=-x;
}
const int maxn = 410000;
const double eps = 1e-8;
inline int dcmp(const double &x){
return (x > -eps) - (x < eps);
}
int a[maxn],n,dep[maxn],rt;
namespace Graph{
struct Edge{
int to,next;
}G[maxn<<1];
int head[maxn],cnt;
void add(int u,int v){
G[++cnt].to = v;
G[cnt].next = head[u];
head[u] = cnt;
}
int ind[maxn],oud[maxn];
int dfs_clock,fa[maxn][23];
#define v G[i].to
void dfs(int u){
ind[u] = ++ dfs_clock;a[dfs_clock] = u;
for(int i = head[u];i;i=G[i].next){
if(v == fa[u][0]) continue;
dep[v] = dep[u] + 1;
fa[v][0] = u;dfs(v);
}
oud[u] = dfs_clock;
}
#undef v
}
namespace seg{
double T[maxn<<2],lazy[maxn<<2];
void build(int rt,int l,int r){
if(l == r){
T[rt] = dep[a[l]];
return ;
}
int mid = (l+r) >> 1;
build(rt<<1,l,mid);
build(rt<<1|1,mid+1,r);
T[rt] = T[rt<<1] + T[rt<<1|1];
}
inline void pushdown(int rt,int l,int r){
if(rt == 0 || dcmp(lazy[rt] == 0) ) return;
int mid = (l+r) >> 1;
lazy[rt<<1] += lazy[rt];
lazy[rt<<1|1] += lazy[rt];
T[rt<<1] += lazy[rt]*(mid - l + 1);
T[rt<<1|1] += lazy[rt]*(r - mid);
lazy[rt] = 0;
}
void modify(int rt,int l,int r,int L,int R,int val){
if(L <= l && r <= R){
lazy[rt] += val;
T[rt] += (r-l+1)*val;
return ;
}
int mid = (l+r) >> 1;pushdown(rt,l,r);
if(L <= mid) modify(rt<<1,l,mid,L,R,val);
if(R > mid) modify(rt<<1|1,mid+1,r,L,R,val);
T[rt] = T[rt<<1] + T[rt<<1|1];
}
void modify(int x,int val){
using namespace Graph;
if(x == rt) modify(1,1,n,1,n,val);
else if(ind[rt] < ind[x]||oud[x] < ind[rt])modify(1,1,n,ind[x],oud[x],val);
else{
int p = rt;
for(int j=20;~j;--j){
if(dep[fa[p][j]] <= dep[x]) continue;
p = fa[p][j];
}
if(1 <= ind[p] - 1) modify(1,1,n,1,ind[p]-1,val);
if(oud[p] + 1 <= n) modify(1,1,n,oud[p]+1,n,val);
}
}
double query(int rt,int l,int r,int L,int R){
if(L <= l && r <= R) return T[rt];
int mid = (l+r) >> 1;pushdown(rt,l,r);
if(R <= mid) return query(rt<<1,l,mid,L,R);
if(L > mid) return query(rt<<1|1,mid+1,r,L,R);
return query(rt<<1,l,mid,L,R) + query(rt<<1|1,mid+1,r,L,R);
}
}
namespace lct{
struct Node{
Node *ch[2],*fa;
int id,tag;
}mem[maxn],*it,*null;
inline Node* newNode(){
Node *p = it++;p->ch[0] = p->ch[1] = p->fa = null;
p->id = -1;p->tag = 0;return p;
}
inline void init(){
it = mem;null = it++;null->id = -1;
null->ch[0] = null->ch[1] = null->fa = null;
null->tag = 0;
for(int i=1;i<=n;++i) newNode()->id = i;
for(int i=2;i<=n;++i){
(mem+i)->fa = (mem+Graph::fa[i][0]);
}
}
inline void rever(Node *p){
p->tag ^= 1;swap(p->ch[0],p->ch[1]);
}
inline void pushdown(Node *p){
if(p == null || p->tag == 0) return ;
if(p->ch[0] != null) rever(p->ch[0]);
if(p->ch[1] != null) rever(p->ch[1]);
p->tag = 0;
}
inline void rotate(Node *p,Node *x){
int k = p == x->ch[1];
Node *y = p->ch[k^1],*z = x->fa;
if(z->ch[0] == x) z->ch[0] = p;
if(z->ch[1] == x) z->ch[1] = p;
if(y != null) y->fa = x;
p->fa = z;p->ch[k^1] = x;
x->fa = p;x->ch[k] = y;
}
inline bool isroot(Node *p){
return (p == null) || (p->fa->ch[0] != p && p->fa->ch[1] != p);
}
inline void splay(Node *p){
pushdown(p);
while(!isroot(p)){
Node *x = p->fa,*y = x->fa;
pushdown(y);pushdown(x);pushdown(p);
if(isroot(x)) rotate(p,x);
else if((x->ch[0] == p)^(y->ch[0] == x)) rotate(p,x),rotate(p,y);
else rotate(x,y),rotate(p,x);
}
}
inline Node* find(Node *p){
pushdown(p);
while(p->ch[0] != null){
p = p->ch[0];
pushdown(p);
}
return p;
}
inline void access(Node *x){
for(Node *y = null;x != null;y=x,x=x->fa){
splay(x);
if(x->ch[1] != null){
Node *p = find(x->ch[1]);
seg::modify(p->id,1);
}
x->ch[1] = y;
if(y != null){
Node *p = find(y);
seg::modify(p->id,-1);
}
}
}
inline void makeroot(Node *p){
access(p);splay(p);rever(p);
rt = p->id;
}
}
inline double query(int x){
using namespace Graph;
if(rt == x) return 1.0*seg::query(1,1,n,1,n)/n;
if(ind[rt] < ind[x] || oud[x] < ind[rt])
return 1.0*seg::query(1,1,n,ind[x],oud[x])/(oud[x]-ind[x]+1);
int p = rt;
for(int j=20;~j;--j){
if(dep[fa[p][j]] <= dep[x]) continue;
p = fa[p][j];
}
double upside = .0;
if(1 <= ind[p] - 1) upside += seg::query(1,1,n,1,ind[p]-1);
if(oud[p] + 1 <= n) upside += seg::query(1,1,n,oud[p]+1,n);
double dnside = (ind[p]-1) + (n-(oud[p]+1)+1);
return upside/dnside;
}
char cmd[12];
int main(){
int m;read(n);read(m);
for(int i=1,u,v;i<n;++i){
read(u);read(v);
Graph::add(u,v);
Graph::add(v,u);
}
dep[1] = 1;rt = 1;Graph::fa[1][0] = 1;
Graph::dfs(1);seg::build(1,1,n);lct::init();
for(int j=1;j<=20;++j){
for(int i=1;i<=n;++i){
Graph::fa[i][j] = Graph::fa[Graph::fa[i][j-1]][j-1];
}
}
int x;
while(m--){
scanf("%s",cmd);read(x);
if(cmd[2] == 'L'){
lct::access(lct::mem+x);
}else if(cmd[2] == 'C'){
lct::makeroot(lct::mem+x);
}else{
double ans = query(x);
printf("%.10lfn",ans);
}
}
return 0;
}
德国一名电脑考古学家开发出电脑创作情诗程序，但他并非这一程序的原创者。 早在６０多年前，情诗生成程序已经问世。 电脑作诗 １９４８年６月，世界上第一台能完全执行存储程序的电子计算机原型机在英国曼彻斯特大学诞生。人们给它取名“婴儿”。 当时研究人员为它编写了几十种新型程序，不过现今大部分已经丢失。 英国研究人员克里斯托弗·斯特雷奇也参与了“婴儿”的研制。他为测验这台原型机随机选择信息的能力，编写出自动创作情诗程序。 “婴儿”本身储存了大量诗歌数据。每次运行作诗程序，人们只需输入几百个含义浪漫的动词和名词，它就能自动生成一首短情诗。 斯特雷奇把“婴儿”的“大作”打印出来贴在公告栏上。虽然这些情诗不一定能打动女性的芳心，但作诗程序开创了电脑文本生成程序的先河。 后来随着计算机技术迅速发展，“婴儿”和作诗程序被人们渐渐遗忘。 历史重演 德国电脑考古学家戴维·瓦尔德近期在英国牛津大学博德利图书馆研究斯特雷奇论文时发现这一程序。 他花３个月时间编写出同样的在线“情诗生成器”程序供网民自由使用。 用户在线运行这一程序，输入一些词语，每次点击“重载”键，网页上就会出现一首新的情诗。 英国《曼彻斯特新闻晚报》１０日援引瓦尔德的话报道：“这牵涉到一部分有国际影响力的英国计算机文化遗产。编写程序的这３个月十分折磨人，因为根据现今标准，这一程序非常原始。” 瓦尔德将于３月下旬在英国伦敦就作诗程序发表演讲。他制造的“婴儿”复制机不久后将在德国展出，届时他会用这台机器演示“情书程序”。 电脑“艺术” 斯特雷奇１９１６年出生于英格兰汉普斯特德，父亲爱好音乐和美术，母亲是一名数学家和电气工程师。这让斯特雷奇从小受到艺术和理工知识的双重熏陶。 他１９３５年进入剑桥大学国王学院学习，毕业后做过物理学家和校长，并从２０世纪４０年代开始对计算机技术产生兴趣。 １９５１年１月，斯特雷奇第一次接触有储存程序的计算机并开始编写程序。１９５２年，他结束校长工作，成为英国国家研究发展公司的全职计算机技术研究员。 同年夏天，斯特雷奇从姐姐那里得到灵感，利用同事、著名计算机科学家艾伦·图灵的随机数字生成器，开发出作诗程序，这是人类第一次利用计算机生成文学作品。 斯特雷奇还编写过最早的计算机音乐软件。他于１９７５年在牛津大学去世。
个人观点看
- 编程是学习成本最低、效益最大的学习科目，它只需要一台电脑和软件，学习范围也仅需要一张桌子和椅子
- 其他学科需要购置更多的器材和提供更大的场地或者需要建设一个空间来学习
- 编程是各种兴趣活动中唯一可以同时锻炼多种能力提升的技能
题目:
黑客们通过对已有的病毒反编译，将许多不同的病毒重组，并重新编译出了新型的重组病毒。这种病毒的繁殖和变异能力极强。为了阻止这种病毒传播，某安全机构策划了一次实验，来研究这种病毒。
实验在一个封闭的局域网内进行。局域网内有n台计算机，编号为1~n。一些计算机之间通过网线直接相连，形成树形的结构。局域网中有一台特殊的计算机，称之为核心计算机。根据一些初步的研究，研究员们拟定了一个一共m步的实验。实验开始之前，核心计算机的编号为1，每台计算机中都有病毒的一个变种，而且每台计算机中的变种都不相同。实验中的每一步会是下面中的一种操作：
- RELEASE x
在编号为x的计算机中植入病毒的一个新变种。这个变种在植入之前不存在于局域网中。- RECENTER x
将核心计算机改为编号为x的计算机。但是这个操作会导致原来核心计算机中的病毒产生新变种，并感染过来。换言之，假设操作前的核心计算机编号为y，相当于在操作后附加了一次RELEASE y的操作。
根据研究的结论，在植入一个新变种时，病毒会在局域网中搜索核心计算机的位置，并沿着网络中最短的路径感染过去。
而第一轮实验揭露了一个惊人的真相：病毒的不同变种是互斥的。新变种在感染一台已经被旧变种感染的电脑时，会把旧变种完全销毁之后再感染。但研究员发现了实现过程中的漏洞。如果新变种在感染过程中尚未销毁过这类旧变种，需要先花费1单位时间分析旧变种，才能销毁。如果之前销毁过这类旧变种，就可以认为销毁不花费时间。病毒在两台计算机之间的传播亦可认为不花费时间。
研究员对整个感染过程的耗时特别感兴趣，因为这是消灭病毒的最好时机。于是在m步实验之中，研究员有时还会做出如下的询问：
3,REQUEST x
询问如果在编号为x的计算机的关键集合中的计算机中植入一个新变种，平均感染时间为多长。编号为y的计算机在编号为x的计算机的关键集合中，当且仅当从y沿网络中的最短路径感染到核心计算机必须经过x。由于有RECENTER操作的存在，这个集合并不一定是始终不变的。
至此，安全机构认为已经不需要实际的实验了，于是他们拜托你编写一个程序，模拟实验的结果，并回答所有的询问。
从大环境看
编程现今已经渗透各行各业,未来的十年，相信会全面覆盖任何行业,没有哪一个行业不会和编程搭上关系
6949359_3_thumb.jpg
###### *到市场买菜也可以用手机付费
既然任何行业都和编程有联系，那不久的将来就会缺乏大量人才，而人才需要培养，且培养速度需要够快！
- 工业4.0甚至将来的发展，机器人会取代部分行业的人手操控，懂编程的人会优胜于不懂编程的人
- 为国家持续性发展提供足够的科研力量，提升未来国家竞争力
本文由美高梅路线检测发布于4688am,转载请注明出处：所以我们的可以得出这样的一条结论，德国一名
关键词：
