题目描述

口袋妖怪(又名神奇宝贝或宠物小精灵)红/蓝/绿宝石中的水系道馆需要经过三个冰地才能到达馆主的面前，冰地中
的每一个冰块都只能经过一次。当一个冰地上的所有冰块都被经过之后，到下一个冰地的楼梯才会被打开。三个冰
地分别如下：
当走出第三个冰地之后，就可以与馆主进行道馆战了。馆主发现这个难度太小，导致经常有挑战者能通过，为了加
大难度，将道馆分成了n个房间，每个房间中是两个冰块或障碍，表示一列冰地。任意两个房间之间均有且仅有一
条路径相连，即这n个房间构成一个树状结构。每个房间分成了A和B两个区域，每一区域都是一个薄冰块或者障碍
物。每次只能移动到相邻房间的同一类区域(即若你现在在这个房间的A区域，那么你只能移动到相邻房间的A区域)
或这个房间的另一区域。现在挑战者从房间u出发，馆主在房间v，那么挑战者只能朝接近馆主所在房间的方向过去
。一开始挑战者可以在房间u的任意一个冰块区域内。如果挑战者踩过的冰块数达到了最大值(即没有一种方案踩过
的冰块数更多了)，那么当挑战者走到最后一个冰块上时，他会被瞬间传送到馆主面前与馆主进行道馆战。自从馆
主修改规则后已经经过了m天，每天要么是有一个挑战者来进行挑战，要么就是馆主将某个房间进行了修改。对于
每个来的挑战者，你需要计算出他若要和馆主进行战斗需要经过的冰块数。

输入

第一行包含两个正整数n和m。第2行到第n行，每行包含两个正整数x和y，表示一条连接房间x和房间y的边。房间编
号为1…n。接下来n行，每行包含两个字符。第n + k行表示房间k的两个区域，第一个字符为A区域，第二个字符为
B区域。其中“.”(ASCII码为46)表示是薄冰块，“#”(ASCII码为35)表示是障碍物。最后的m行，每行一个操作：
l C u s：将房间u里的两个区域修改为s。
l Q u v：询问挑战者在房间u，馆主在房间v时，挑战者能与馆主进行挑战需要踩的冰块数。如果房间u的两个区域
都是障碍物，那么输出0。
N≤ 30 000
M ≤ 80 000

输出

包含若干行，每行一个整数。即对于输入中的每个询问，依次输出一个答案。

样例输入

5 3
1 2
2 3
2 4
1 5
.#
..
#.
.#
..
Q 5 3
C 1 ##
Q 4 5

样例输出

6
3
 

题目大意：给一棵树，树上每个点分为AB两个区域，每个区域可能是空地或障碍物，每次可以从一个点的一个区域走到相邻点的相同区域或走到这个点的另一个区域，每次能走的前提是走到的区域是空地，一个点的一个区域只能走一次(也就是说从一个区域走出去就不能走回来了)。有两种操作：1、修改一个点的两个区域。2、查询从u的任意空地区域走到v最多能走多少步，可以不到达v，如果u无空地输出0。

显然是用树链剖分+线段树，线段树维护连通性(最长路)。

维护连通性的方法和BZOJ1018类似(建议先做一下bzoj1018再做这道题)。

线段树的每个点维护8个信息，分别是从左上到右上(luru)、从左上到右下(lurd)、从左下到右上(ldru)、从左下到右下(ldrd)的最长路，如果不连通就是0。
以及区间从左上(lumx)、左下(ldmx)、右上(rumx)、右下(rdmx)开始向另一边走的最长路。
线段树回溯时O(1)合并子节点区间信息。
修改时直接修改对应点在线段树中沿途更新信息。
查询时树链剖分往上跳，每次跳时将当次查询区间合并。
因为是从u走到v，所以u和v有一边到lca的区间是反的，需要把这一边跳完合并后的区间翻转一下再与另一边的区间合并。
翻转时直接将区间的左端右端信息交换。
代码有点长，见谅。

  1. #include<set>
  2. #include<map>
  3. #include<stack>
  4. #include<queue>
  5. #include<cmath>
  6. #include<cstdio>
  7. #include<vector>
  8. #include<bitset>
  9. #include<cstring>
  10. #include<iostream>
  11. #include<algorithm>
  12. #define ll long long
  13. using namespace std;
  14. struct miku
  15. {
  16.     int luru;
  17.     int ldrd;
  18.     int lurd;
  19.     int ldru;
  20.     int lumx;
  21.     int ldmx;
  22.     int rumx;
  23.     int rdmx;
  24.     int l,r;
  25. }t[400010];
  26. int n,m;
  27. int x,y;
  28. int num;
  29. int tot;
  30. char c[4];
  31. char ch[4];
  32. int f[50010];
  33. int d[50010];
  34. int s[50010];
  35. int q[50010];
  36. int to[100010];
  37. int son[50010];
  38. int top[50010];
  39. int size[50010];
  40. int head[50010];
  41. int a[50010][4];
  42. int next[100010];
  43. void add(int x,int y)
  44. {
  45.     tot++;
  46.     next[tot]=head[x];
  47.     head[x]=tot;
  48.     to[tot]=y;
  49. }
  50. void dfs(int x)
  51. {
  52.     size[x]=1;
  53.     d[x]=d[f[x]]+1;
  54.     for(int i=head[x];i;i=next[i])
  55.     {
  56.         if(to[i]!=f[x])
  57.         {
  58.             f[to[i]]=x;
  59.             dfs(to[i]);
  60.             size[x]+=size[to[i]];
  61.             if(size[to[i]]>size[son[x]])
  62.             {
  63.                 son[x]=to[i];
  64.             }
  65.         }
  66.     }
  67. }
  68. void dfs2(int x,int tp)
  69. {
  70.     top[x]=tp;
  71.     s[x]=++num;
  72.     q[num]=x;
  73.     if(son[x])
  74.     {
  75.         dfs2(son[x],tp);
  76.     }
  77.     for(int i=head[x];i;i=next[i])
  78.     {
  79.         if(to[i]!=f[x]&&to[i]!=son[x])
  80.         {
  81.             dfs2(to[i],to[i]);
  82.         }
  83.     }
  84. }
  85. void merge(miku &z,miku x,miku y)
  86. {
  87.     z.l=x.l;
  88.     z.r=y.r;
  89.     z.luru=0;
  90.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&x.luru&&y.luru)
  91.     {
  92.         z.luru=max(x.luru+y.luru,z.luru);
  93.     }
  94.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&x.lurd&&y.ldru)
  95.     {
  96.         z.luru=max(x.lurd+y.ldru,z.luru);
  97.     }
  98.     z.lurd=0;
  99.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&x.luru&&y.lurd)
  100.     {
  101.         z.lurd=max(x.luru+y.lurd,z.lurd);
  102.     }
  103.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&x.lurd&&y.ldrd)
  104.     {
  105.         z.lurd=max(x.lurd+y.ldrd,z.lurd);
  106.     }
  107.     z.ldru=0;
  108.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&x.ldru&&y.luru)
  109.     {
  110.         z.ldru=max(x.ldru+y.luru,z.ldru);
  111.     }
  112.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&x.ldrd&&y.ldru)
  113.     {
  114.         z.ldru=max(x.ldrd+y.ldru,z.ldru);
  115.     }
  116.     z.ldrd=0;
  117.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&x.ldru&&y.lurd)
  118.     {
  119.         z.ldrd=max(x.ldru+y.lurd,z.ldrd);
  120.     }
  121.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&x.ldrd&&y.ldrd)
  122.     {
  123.         z.ldrd=max(x.ldrd+y.ldrd,z.ldrd);
  124.     }
  125.     z.lumx=x.lumx;
  126.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&x.luru)
  127.     {
  128.         z.lumx=max(x.luru+y.lumx,z.lumx);
  129.     }
  130.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&x.lurd)
  131.     {
  132.         z.lumx=max(x.lurd+y.ldmx,z.lumx);
  133.     }
  134.     z.ldmx=x.ldmx;
  135.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&x.ldru)
  136.     {
  137.         z.ldmx=max(x.ldru+y.lumx,z.ldmx);
  138.     }
  139.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&x.ldrd)
  140.     {
  141.         z.ldmx=max(x.ldrd+y.ldmx,z.ldmx);
  142.     }
  143.     z.rumx=y.rumx;
  144.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&y.luru)
  145.     {
  146.         z.rumx=max(y.luru+x.rumx,z.rumx);
  147.     }
  148.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&y.ldru)
  149.     {
  150.         z.rumx=max(y.ldru+x.rdmx,z.rumx);
  151.     }
  152.     z.rdmx=y.rdmx;
  153.     if(a[q[x.r]][1]&&a[q[y.l]][1]&&y.lurd)
  154.     {
  155.         z.rdmx=max(y.lurd+x.rumx,z.rdmx);
  156.     }
  157.     if(a[q[x.r]][2]&&a[q[y.l]][2]&&y.ldrd)
  158.     {
  159.         z.rdmx=max(y.ldrd+x.rdmx,z.rdmx);
  160.     }
  161. }
  162. void build(int rt,int l,int r)
  163. {
  164.     if(l==r)
  165.     {
  166.         t[rt].l=l;
  167.         t[rt].r=r;
  168.         if(a[q[l]][1]==1&&a[q[l]][2]==1)
  169.         {
  170.             t[rt].luru=t[rt].ldrd=1;
  171.             t[rt].lurd=t[rt].ldru=2;
  172.             t[rt].lumx=t[rt].ldmx=t[rt].rumx=t[rt].rdmx=2;
  173.         }
  174.         else if(a[q[l]][1]==1&&a[q[l]][2]==0)
  175.         {
  176.             t[rt].luru=t[rt].lumx=t[rt].rumx=1;
  177.         }
  178.         else if(a[q[l]][1]==0&&a[q[l]][2]==1)
  179.         {
  180.             t[rt].ldrd=t[rt].ldmx=t[rt].rdmx=1;
  181.         }
  182.         return ;
  183.     }
  184.     int mid=(l+r)>>1;
  185.     build(rt<<1,l,mid);
  186.     build(rt<<1|1,mid+1,r);
  187.     merge(t[rt],t[rt<<1],t[rt<<1|1]);
  188. }
  189. void clear(miku &x)
  190. {
  191.     x.luru=x.lurd=x.ldru=x.ldrd=0;
  192.     x.lumx=x.ldmx=x.rumx=x.rdmx=0;
  193. }
  194. void change(int rt,int l,int r,int k)
  195. {
  196.     if(l==r)
  197.     {
  198.         clear(t[rt]);
  199.         if(a[q[l]][1]==1&&a[q[l]][2]==1)
  200.         {
  201.             t[rt].luru=t[rt].ldrd=1;
  202.             t[rt].lurd=t[rt].ldru=2;
  203.             t[rt].lumx=t[rt].ldmx=t[rt].rumx=t[rt].rdmx=2;
  204.         }
  205.         else if(a[q[l]][1]==1&&a[q[l]][2]==0)
  206.         {
  207.             t[rt].luru=t[rt].lumx=t[rt].rumx=1;
  208.         }
  209.         else if(a[q[l]][1]==0&&a[q[l]][2]==1)
  210.         {
  211.             t[rt].ldrd=t[rt].ldmx=t[rt].rdmx=1;
  212.         }
  213.         return ;
  214.     }
  215.     int mid=(l+r)>>1;
  216.     if(k<=mid)
  217.     {
  218.         change(rt<<1,l,mid,k);
  219.     }
  220.     else
  221.     {
  222.         change(rt<<1|1,mid+1,r,k);
  223.     }
  224.     merge(t[rt],t[rt<<1],t[rt<<1|1]);
  225. }
  226. miku query(int rt,int l,int r,int L,int R)
  227. {
  228.     if(L<=l&&r<=R)
  229.     {
  230.         return t[rt];
  231.     }
  232.     int mid=(l+r)>>1;
  233.     if(R<=mid)
  234.     {
  235.         return query(rt<<1,l,mid,L,R);
  236.     }
  237.     if(L>mid)
  238.     {
  239.         return query(rt<<1|1,mid+1,r,L,R);
  240.     }
  241.     miku res;
  242.     merge(res,query(rt<<1,l,mid,L,R),query(rt<<1|1,mid+1,r,L,R));
  243.     return res;
  244. }
  245. void rotate(miku &x)
  246. {
  247.     swap(x.lurd,x.ldru);
  248.     swap(x.lumx,x.rumx);
  249.     swap(x.ldmx,x.rdmx);
  250.     swap(x.l,x.r);
  251. }
  252. int lca(int x,int y)
  253. {
  254.     miku res;
  255.     miku ans;
  256.     clear(ans);
  257.     clear(res);
  258.     int tx=0;
  259.     int ty=0;
  260.     while(top[x]!=top[y])
  261.     {
  262.         if(d[top[x]]>d[top[y]])
  263.         {
  264.             if(tx==0)
  265.             {
  266.                 res=query(1,1,n,s[top[x]],s[x]);
  267.                 tx=1;
  268.             }
  269.             else
  270.             {
  271.                 merge(res,query(1,1,n,s[top[x]],s[x]),res);
  272.             }
  273.             x=f[top[x]];
  274.         }
  275.         else
  276.         {
  277.             if(ty==0)
  278.             {
  279.                 ans=query(1,1,n,s[top[y]],s[y]);
  280.                 ty=1;
  281.             }
  282.             else
  283.             {
  284.                 merge(ans,query(1,1,n,s[top[y]],s[y]),ans);
  285.             }
  286.             y=f[top[y]];
  287.         }
  288.     }
  289.     if(d[x]<d[y])
  290.     {
  291.         rotate(res);
  292.         if(tx==0)
  293.         {
  294.             res=query(1,1,n,s[x],s[y]);
  295.         }
  296.         else
  297.         {
  298.             merge(res,res,query(1,1,n,s[x],s[y]));
  299.         }
  300.         if(ty!=0)
  301.         {
  302.             merge(res,res,ans);
  303.         }
  304.         return max(res.lumx,res.ldmx);
  305.     }
  306.     else
  307.     {
  308.         if(ty!=0)
  309.         {
  310.             rotate(ans);
  311.         }
  312.         if(tx==0)
  313.         {
  314.             res=query(1,1,n,s[y],s[x]);
  315.         }
  316.         else
  317.         {
  318.             merge(res,query(1,1,n,s[y],s[x]),res);
  319.         }
  320.         if(ty!=0)
  321.         {
  322.             merge(res,ans,res);
  323.         }
  324.         return max(res.rumx,res.rdmx);
  325.     }
  326. }
  327. int main()
  328. {
  329.     scanf("%d%d",&n,&m);
  330.     for(int i=1;i<n;i++)
  331.     {
  332.         scanf("%d%d",&x,&y);
  333.         add(x,y);
  334.         add(y,x);
  335.     }
  336.     for(int i=1;i<=n;i++)
  337.     {
  338.         scanf("%s",ch);
  339.         if(ch[0]=='.')
  340.         {
  341.             a[i][1]=1;
  342.         }
  343.         else
  344.         {
  345.             a[i][1]=0;
  346.         }
  347.         if(ch[1]=='.')
  348.         {
  349.             a[i][2]=1;
  350.         }
  351.         else
  352.         {
  353.             a[i][2]=0;
  354.         }
  355.     }
  356.     dfs(1);
  357.     dfs2(1,1);
  358.     build(1,1,n);
  359.     for(int i=1;i<=m;i++)
  360.     {
  361.         scanf("%s",c);
  362.         if(c[0]=='Q')
  363.         {
  364.             scanf("%d%d",&x,&y);
  365.             printf("%d\n",lca(x,y));
  366.         }
  367.         else
  368.         {
  369.             scanf("%d",&x);
  370.             scanf("%s",ch);
  371.             if(ch[0]=='.')
  372.             {
  373.                 a[x][1]=1;
  374.             }
  375.             else
  376.             {
  377.                 a[x][1]=0;
  378.             }
  379.             if(ch[1]=='.')
  380.             {
  381.                 a[x][2]=1;
  382.             }
  383.             else
  384.             {
  385.                 a[x][2]=0;
  386.             }
  387.             change(1,1,n,s[x]);
  388.         }
  389.     }
  390. }

BZOJ2325[ZJOI2011]道馆之战——树链剖分+线段树的更多相关文章

  1. 【bzoj2325】[ZJOI2011]道馆之战 树链剖分+线段树区间合并

    题目描述 给定一棵树,每个节点有上下两个格子,每个格子的状态为能走或不能走.m次操作,每次修改一个节点的状态,或询问:把一条路径上的所有格子拼起来形成一个宽度为2的长方形,从起点端两个格子的任意一个开 ...

  2. 【BZOJ-2325】道馆之战 树链剖分 + 线段树

    2325: [ZJOI2011]道馆之战 Time Limit: 40 Sec  Memory Limit: 256 MBSubmit: 1153  Solved: 421[Submit][Statu ...

  3. 【BZOJ2243】[SDOI2011]染色 树链剖分+线段树

    [BZOJ2243][SDOI2011]染色 Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的 ...

  4. BZOJ2243 (树链剖分+线段树）

    Problem 染色(BZOJ2243) 题目大意 给定一颗树,每个节点上有一种颜色. 要求支持两种操作: 操作1:将a->b上所有点染成一种颜色. 操作2:询问a->b上的颜色段数量. ...

  5. POJ3237 (树链剖分+线段树）

    Problem Tree (POJ3237) 题目大意 给定一颗树,有边权. 要求支持三种操作: 操作一:更改某条边的权值. 操作二:将某条路径上的边权取反. 操作三:询问某条路径上的最大权值. 解题 ...

  6. bzoj4034 （树链剖分+线段树）

    Problem T2 (bzoj4034 HAOI2015) 题目大意 给定一颗树,1为根节点,要求支持三种操作. 操作 1 :把某个节点 x 的点权增加 a . 操作 2 :把某个节点 x 为根的子 ...

  7. HDU4897 （树链剖分+线段树）

    Problem Little Devil I (HDU4897) 题目大意 给定一棵树,每条边的颜色为黑或白,起始时均为白. 支持3种操作: 操作1:将a->b的路径中的所有边的颜色翻转. 操作 ...

  8. Aizu 2450 Do use segment tree 树链剖分+线段树

    Do use segment tree Time Limit: 1 Sec Memory Limit: 256 MB 题目连接 http://www.bnuoj.com/v3/problem_show ...

  9. 【POJ3237】Tree（树链剖分+线段树）

    Description You are given a tree with N nodes. The tree’s nodes are numbered 1 through N and its edg ...

随机推荐

  1. helm 部署 使用 记录

    0.概念:Helm作为一个包管理工具, 它把Kubernetes资源(比如deployments.services或 ingress等) 打包到一个chart中,方便我们将其chart保存到chart ...

  2. Zephyr的Logging

    1 前言 刚接触Zephyr,两眼一抹黑,光是阅读代码对系统没什么概念.还需要通过一些日志了解系统的运行机制,以及各种内核行为. 这就需要借助系统的Logging,大体分为两部分System Logg ...

  3. 没有内涵段子可以刷了，利用Python爬取段友之家贴吧图片和小视频(含源码)

    由于最新的视频整顿风波,内涵段子APP被迫关闭,广大段友无家可归,但是最近发现了一个"段友"的app,版本更新也挺快,正在号召广大段友回家,如下图,有兴趣的可以下载看看(ps:我不 ...

  4. token令牌

    本文摘自 WebApi安全性 使用TOKEN+签名验证 首先问大家一个问题,你在写开放的API接口时是如何保证数据的安全性的?先来看看有哪些安全性问题在开放的api接口中,我们通过http Post或 ...

  5. Spring Extensible XML

    Spring框架从2.0版本开始,提供了基于Schema风格的Spring XML格式用来定义bean的扩展机制.引入Schema-based XML是为了对Traditional的XML配置形式进行 ...

  6. windows平台快速搭建Linux（CentOS）

    VMware简介 VMware Workstation(简称 “虚拟机”)是一款功能强大的桌面虚拟计算机软件,用户可在Windows平台通过VMware软件同时运行不同的操作系统.这对IT开发人员而言 ...

  7. PCB之PASTE助焊层和SOLDER阻焊层

    1.PASTE为焊接层,用于SMT贴片元件的焊接,对应的图形为钢网(钢网上的小孔): 2.SOLDER为阻焊层,它代表的是绿油的涂抹区域,且为负片输出(负片输出指的是图形以外的区域为有效区域): PA ...

  8. Linux系统安装IDS(snort工具)

    第一步:预装daq所需程序 snort使用数据采集器(daq)监听防火墙数据包队列,所以按照daq.需预装的程序有:flex.bison.libcap. sudo apt-get install fl ...

  9. InnoDB 文件系统

    1. 操作系统文件系统inode 2. InnoDB的存储结构 2.1Innodb inode page 参考 http://mysql.taobao.org/monthly/2016/02/01/ ...

  10. 配置Nginx反向代理WebSocket，以代理noVNC为例

    什么是Nginx Nginx (engine x) 是一个高性能的HTTP和反向代理服务器,也是一个IMAP/POP3/SMTP服务器. Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮 ...