浙江省队选拔 ZJOI2015 (Round 1) 解题报告

     最近莫名其妙地喜欢上了用这种格式写各省省选的全套题解= =

     今年浙江省选的出题人是算法竞赛界传说级人物陈立杰，看样子他的出题风格颇有特色……ABC三题难度是严格递减的，感受若是在作第一题的时候被卡住的话恐怕连想死的心都有了……

     那么咱们先从最难的一题开始……= =

BZOJ 3924 A.幻想乡战略游戏

      给定一棵N个结点的有正的边权、初始点权为0的无根树，进行M次操做，每次将一个点u的权值增长e($0 \leq |e| \leq 1000$)，保证任意时刻点权非负。你的任务是在每次操做后找到一个带权重心u，使得全部点到重心的距离与点权的乘积之和最小（即最小化$\sum_{v} dist(u, v) × val_v，并输出这个最小的值。

      N, M均不超过${10}^5$.保证每一个点的度数均不超过20.

分析.

      首先咱们假设每次操做事后咱们能够快速地在线查询以任意一个点为关键点获得的权值和，那么在这种状况下如何求出最小权值？

      为了表达方便，咱们不妨设当前以点u为关键点求得的权值和为$S_u$，那么咱们不难发现这样一个性质：在树上任意两点a, b之间的路径上，$S_u$构成了一个存在极小值的单峰函数。证实也很简单：考虑路径上任意一条边e，设e两端点分别为s, t，两端链接的点集分别为S, T，边权为e.v。则关键点从s走到t的过程当中权值和的变化量：$$\Delta = S_t - S_s = (\sum_{u \in S} val_u - \sum_{v \in T} val_v) * e.v.$$      而在转移的过程当中，点t和它的不在链上的后代结点都将从T集合转移到S集合，即 $(\sum_{u \in S} val_u - \sum_{v \in T} val_v)$ 是单调递增的，又由题意得知边权都是正整数，所以函数 $\Delta = S_t - S_s = (\sum_{t \in S} val_u- \sum_{v \in T} val_v) * e.v.$ 的零点区间必定惟一（因为$\Delta$是离散函数，这里“零点区间”指的是左右两侧函数值正负性相反的区间），且左负右正。因为$\Delta$表示的是S函数的增量，那么$\Delta$的零点区间惟一且左负右正就证实了S是存在极小值的单峰函数。

      那么咱们设点c为咱们要求的一个带权重心。考虑树上任意一点u和它到c之间的路径，因为u的S函数取最小值，又由路径上S函数值的单峰性，咱们能够证实在从u到c的路径上S值是单调递增的，而相邻两点S值相同当且仅当这两点的S值均为$S_u$，即最小值。最后这点结论能够由“零点区间连续”天然地得出。

      有了这条性质，查询最小权值就好办了。咱们能够在树上任取一点u将树有根化，判断它的各邻接点的S值是否小于$S_u$。若存在一点v使得$S_v < S_u$，那么根据上面的结论，咱们知道答案必定在v所在的子树中，递归查询便可。若不存在这样的点v，那么答案必定是$S_u$。

      听起来很爽对不对？然而，若是咱们每次在树上“任取一点”，最坏状况下递归的深度能够达到$O(N)$级别，时间复杂度退化得很严重。怎么办呢？咱们能够在树上找到一点u，使得以u为根最大的子树的规模最小化（通常称u为这棵树的重心）。那么这样每棵子树的规模都不会超过原树规模的1/2，那么不难证实此时递归查询的深度就成了$O(\log N)$。

      再来考虑开头咱们假设的咱们已经会了的操做——在线查询任意一个$S_u$。

      考虑咱们刚才创建的重心分治结构。对点v进行修改时，咱们能够花费$O(\log N)$的时间更新v所在的每一层分治结构的重心维护的答案（即在分治u维护的答案中增长$dist(u, v) * \Delta val_v$)，并记录每层分治结构中的结点对上一层分治维护的答案的贡献。在对点v查询时，先将答案设为v分治中维护的答案，而后向上移动累加答案：在从分治current向它的上一层分治parent移动时，在parent维护的答案中减去current对它的贡献获得$\delta S$，将获得的结果临时当作点v的后代累加进答案。即$Ans = lastAns + \delta S + (Sum_{parent} - Sum_{current}) * dist(parent, v) $，其中$Sum_t$表示t维护的分治结构中全部点权的平凡加和。这样，咱们就会作这道题了。

      若是咱们用倍增LCA法求dist，时间复杂度为$O((N+M) \log^3 N) $，可能有些卡常数。考虑到操做不会改变原树的结构，咱们能够在$O(N \log N)$的时间内预处理后经过ST表维护DFS序列来求LCA，总时间复杂度$O((N+M) \log^2 N)$.

代码.

  1  /* ********************************************************************* */
  2  /* *********************By Asm.Def-Wu Jiaxin**************************** */
  3  /* ********************************************************************* */
  4 #include <cstdio>
  5 #include <cstring>
  6 #include <cstdlib>
  7 #include <ctime>
  8 #include <cctype>
  9 #include <algorithm>
 10  using  namespace std;
 11  #define SetFile(x) ( freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout) );
 12  #define UseFREAD
 13 #ifdef UseFREAD
 14  #define getc() *(file_ptr++)
 15  #define FreadLenth 5000000
 16  char CHARPOOL[FreadLenth], *file_ptr = CHARPOOL;
 17  #else
 18  #define getc() getchar() 
 19  #endif
 20 #ifdef DEBUG
 21 #include <sys/timeb.h>
 22 timeb SysTp;
 23  #endif
 24 template< class T>inline  void getd(T &x){
 25      char ch = getc(); bool neg =  false;
 26      while(!isdigit(ch) && ch !=  ' - ')ch = getc();
 27      if(ch ==  ' - ')ch = getc(), neg =  true;
 28     x = ch -  ' 0 ';
 29      while(isdigit(ch = getc()))x = x *  10 -  ' 0 ' + ch;
 30      if(neg)x = -x;
 31 }
 32  /* ********************************************************************* */
 33  const  int maxn =  100005;
 34 typedef  long  long LL;
 35 
 36  int N, Q, lg2[maxn <<  1], dfs_iter;
 37 
 38  struct Node{
 39     Node *adj[ 22], *p, *Brid;
 40      int w[ 22], adj_d, dep, dis, id; // 用于距离查询
 41       int size; // 临时变量
 42      LL Val, Sum, Cont, Ans; // 树分治
 43       int AnsTag;
 44      bool tag;
 45     inline  void Link(Node *t,  int v){
 46         w[adj_d] = v;
 47         adj[adj_d++] = t;
 48     }
 49      void dfs(); void dfs2();
 50     Node *dp( int,  int &);
 51     LL Query();
 52     inline  void GetAns();
 53 }T[maxn], *ST[ 18][maxn<< 1], *Root;
 54 
 55  void Node::dfs(){
 56     (*ST)[id = dfs_iter++] =  this;
 57      int i;Node *to;
 58      for(i =  0;i < adj_d;++i) if((to = adj[i]) != p){
 59         to->p =  this, to->dep = dep +  1, to->dis = dis + w[i];
 60         to->dfs();
 61         (*ST)[dfs_iter++] =  this;
 62     }
 63 }
 64 
 65 inline Node * Cmp(Node *a, Node *b){ return a->dep > b->dep ? b : a;}
 66 
 67 inline  void Build_ST(){
 68      int i =  2, j =  1, t =  4;
 69      while(i <= dfs_iter){
 70          if(i == t)++j, t <<=  1;
 71         lg2[i++] = j;
 72     }
 73      for(i =  1, t =  2;t <= dfs_iter;++i, t <<=  1) for(j =  0;j + t <= dfs_iter;++j)
 74         ST[i][j] = Cmp(ST[i- 1][j], ST[i- 1][j+(t >>  1)]);
 75 }
 76 
 77 inline  int dist(Node *a, Node *b){
 78      int u = a->id, v = b->id; if(v < u)swap(u, v);
 79      int len = v - u +  1, lg = lg2[len];
 80      return a->dis + b->dis - (Cmp(ST[lg][u], ST[lg][v+ 1-( 1 << lg)])->dis <<  1);
 81 }
 82 
 83  void Node::dfs2(){
 84     size =  1;
 85      int i;Node *to;
 86      for(i =  0;i < adj_d;++i) if(!(to = adj[i])->tag && to != p){
 87         to->p =  this;
 88         to->dfs2();
 89         size += to->size;
 90     }
 91 }
 92 
 93 Node * Node::dp( int psize,  int &Maxsize){
 94     Node *ans =  this, *to, *t;Maxsize = psize;
 95      int mx, i;
 96      for(i =  0;i < adj_d;++i) if((!(to = adj[i])->tag) && to != p)
 97         Maxsize = max(Maxsize, to->size);
 98     psize += size;
 99      for(i =  0;i < adj_d;++i) if((!(to = adj[i])->tag) && to != p){
100         t = to->dp(psize - to->size, mx);
101          if(mx < Maxsize)ans = t, Maxsize = mx;
102     }
103      return ans;
104 }
105 
106 Node *Build_DC(Node *t){
107      int s;t->p = NULL;
108     t->dfs2();
109     Node *root = t->dp( 0, s), *to;
110     root->tag =  true;root->Brid = t;
111      for( int i =  0;i < root->adj_d;++i){
112          if((to = root->adj[i])->tag)swap(root->adj[i--], root->adj[--root->adj_d]);
113          else{
114             root->adj[i] = Build_DC(to);
115             root->adj[i]->p = root;
116         }
117     }
118      return root;
119 }
120 
121 inline  void Modify(Node *v,  int d){
122     v->Sum += d;
123     Node *t = v;
124     LL cont;
125      while(t != Root){
126         LL &s_cont = t->Cont;
127         t = t->p;
128         t->Sum += d;
129         cont = (LL)dist(v, t) * d;
130         t->Val += cont;s_cont += cont;
131     }
132 }
133 
134 inline  void Node::GetAns(){
135      if(AnsTag == Q) return; // 避免一次操做后重复查询
136      Ans = Val;
137     Node *t = p;
138     LL sum_d = Sum, cont = Cont, diff, dsum;
139      while(t){
140         diff = t->Val - cont;dsum = t->Sum - sum_d;
141          if(dsum)Ans += diff + dsum * dist(t,  this);
142         sum_d = t->Sum, cont = t->Cont;
143         t = t->p;
144     }
145     AnsTag = Q;
146 }
147 
148 LL Node::Query(){
149     GetAns();
150      int i;Node *to;
151      for(i =  0;i < adj_d;++i){
152         (to = adj[i])->Brid->GetAns();
153          if(to->Brid->Ans < Ans) return to->Query();
154     }
155      return Ans;
156 }
157 
158 inline  void init(){
159      int i, a, b, c;
160      for(i =  1;i < N;++i){
161         getd(a), getd(b), getd(c);
162         T[a].Link(T + b, c);
163         T[b].Link(T + a, c);
164     }
165     T[ 1].dfs();
166     Build_ST();
167     (Root = Build_DC(T +  1))->p =  0x0;
168 }
169 
170  int main(){
171 
172 #ifdef DEBUG
173     freopen( " test.txt ",  " r ", stdin);ftime(&SysTp);
174     size_t Begin_sec = SysTp.time, Begin_mill = SysTp.millitm;
175  #elif !defined ONLINE_JUDGE
176     SetFile(zjoi15_tree);
177  #endif
178 #ifdef UseFREAD
179     fread(file_ptr,  1, FreadLenth, stdin);
180  #endif
181 
182      int u, e;
183     getd(N), getd(Q);
184 
185     init();
186 
187      while(Q){
188         getd(u), getd(e);
189         Modify(T + u, e);
190         printf( " %lld\n ", Root->Query());
191         --Q;
192     }
193 
194 #ifdef DEBUG
195     ftime(&SysTp);
196     printf( " \n%.3lf sec \n ", (SysTp.time - Begin_sec) + (SysTp.millitm - Begin_mill) /  1000.0);
197  #endif
198      return  0;
199 }

重心分治+ST算法求LCA

 

BZOJ 3925 B.地震后的幻想乡

给定一个n个点m条边的无向图，每条边的权值在0~1之间随机选取，求这张图的最小瓶颈生成树的瓶颈的指望值。

点数不超过10， 保证无重边且无自环。

分析.

     须要一点点高等数学知识= =

     因为题目中的最小瓶颈生成树的瓶颈大小是连续变量，咱们没法经过简单地枚举答案和几率来求解。不妨这样考虑：设$F_S(x)$表示图中全部小于x的边能使点集S连通的几率。那么点集S的最小瓶颈为x的几率就是$$P_{(ans=x)} = \lim_{\Delta x \to 0} F_S(x+\Delta x) - F_S(x)$$也就是$$P_{(ans=x)} = F_S '(x) \mathrm{d} x$$

      由指望的定义，咱们有：$$E = \int_0^1 x * F_S ' (x) \mathrm{d} x$$是个乘积复合函数，咱们对它作分部积分：$$E = \left. \left( x \int F_S '(x) \mathrm{d} x - \int (x' \int F_S '(x) \mathrm{d} x)  \right) \right|_0^1 $$获得：$$E = \left. \left( x F_S(x)  -  \int F_S(x) \mathrm{d} x \right) \right|_0^1$$那么$$E = 1 - \left.  \int F_S(x) \mathrm{d} x \right|_0^1$$

      那么咱们只须要用dp求出整个图的F_V函数，再积分一下就能够获得答案了。

      点集连通的几率彷佛无法直接求？那么咱们来考虑相反的状况，点集S不连通的几率。咱们能够任选一点$v_0$，枚举它所在的连通块S'，并计算出S'与$S - S'$的割边数量cnt，那么$$F_S = 1 - \sum_{S' \ni v_0 \land S' \subsetneqq S} (1 - x) ^ {cnt} $$这样就能够求出答案了。

代码.

  1 #include <cstdio>
  2 #include <cstring>
  3 #include <cstdlib>
  4 #include <ctime>
  5 #include <cctype>
  6 #include <algorithm>
  7 #include <cmath>
  8  using  namespace std;
  9  // #define USEFREAD
 10  #ifdef USEFREAD
 11  #define InputLen 5000000
 12  char *ptr=( char *) malloc(InputLen);
 13  #define getc() (*(ptr++))
 14  #else
 15  #define getc() (getchar())
 16  #endif
 17  #define SetFile(x) (freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout))
 18 template< class T>inline  void getd(T &x){
 19      int ch = getc(); bool neg =  false;
 20      while(!isdigit(ch) && ch !=  ' - ')ch = getc();
 21      if(ch ==  ' - ')ch = getc(), neg =  true;
 22     x = ch -  ' 0 ';
 23      while(isdigit(ch = getc()))
 24         x = x *  10 -  ' 0 ' + ch;
 25      if(neg)x = -x;
 26 }
 27  /* ********************************************************************* */
 28 #ifdef DEBUG
 29  #define __float128 double // 由于蒟蒻的编译器太老了不支持__float128...
 30  #endif
 31 typedef  long  long LL;
 32 #include <vector>
 33 typedef vector<LL> Poly;
 34 
 35 inline  void  operator += (Poly &a,  const Poly &b){ // 要求a != b
 36      Poly ans(max(a.size(), b.size()),  0);
 37      for(unsigned i =  0;i < ans.size();++i){
 38          if(i < a.size())ans[i] += a[i];
 39          if(i < b.size())ans[i] += b[i];
 40     }
 41     a = ans;
 42 }
 43 
 44 inline Poly  operator * ( const Poly &a,  const Poly &b){
 45     Poly ans(a.size() + b.size() -  1,  0);
 46     unsigned i, j;LL k;
 47      for(i =  0;i < a.size();++i){
 48         k = a[i];
 49          for(j =  0;j < b.size();++j)ans[i + j] += k * b[j];
 50     }
 51      return ans;
 52 }
 53 
 54 inline Poly  operator - ( const Poly &a,  const Poly &b){
 55     Poly Ans(max(a.size(), b.size()),  0);
 56     unsigned i, end = min(Ans.size(), b.size());
 57      for(i =  0;i < a.size();++i)Ans[i] = a[i];
 58      for(i =  0;i < end;++i)Ans[i] -= b[i];
 59      return Ans;
 60 }
 61 
 62 Poly op( 2), True( 1,  1), F[ 1025], Pow[ 26];
 63 
 64  int N, M, adj[ 11], USet;
 65 inline  void init(){
 66      int i, u, v;
 67     getd(N), getd(M);
 68     USet = ( 1 << N) -  1;
 69      while(M--){
 70         getd(u), getd(v);
 71         --u, --v;
 72         adj[u] |= ( 1 << v);
 73         adj[v] |= ( 1 << u);
 74     }
 75     op[ 0] =  1, op[ 1] = - 1;
 76     Pow[ 0] = True;
 77      for(i =  1;i <=  25;++i)Pow[i] = Pow[i- 1] * op;
 78 }
 79 
 80 inline  void Calc(){
 81     __float128 Ans =  0;
 82     unsigned i, end = F[USet].size();
 83      for(i =  0;i < end;++i)Ans += (__float128)F[USet][i] / (i +  1);
 84     printf( " %.6lf\n ",  1.0 - ( double)Ans);
 85 }
 86 
 87 #include <queue>
 88  bool inc[ 1025] = { 0,  1}; // 是不是包含1的连通块
 89 
 90 #ifdef DEBUG
 91  void Print(Poly x){
 92      for( int i = x.size()- 1;i >=  0;--i)printf( " %d  ", x[i]);
 93     putchar( ' \n ');
 94 }
 95  #endif
 96 
 97 inline  void work(){
 98      int t, i, j, b, e, cnt, it;
 99     queue< int> Q;Q.push( 1);
100      while(!Q.empty()){
101         t = Q.front();Q.pop();
102          for(j =  0, b =  1;j < N;++j, b <<=  1) if(t & b){
103             e = adj[j];
104              while(e){
105                 e ^= (i = e & -e);
106                  if(t & i || inc[t ^ i]) continue;
107                 inc[t ^ i] =  true;
108                 Q.push(t ^ i);
109             }
110         }
111     }
112     F[ 1] = True;
113      for(i =  2;i <= USet;++i) if(inc[i]){
114          for(j = (i -  1) & i;j;(--j) &= i) if(inc[j]){
115             cnt =  0;
116              for(t =  0, b =  1;t < N;++t, b <<=  1) if(j & b){
117                 e = adj[t];
118                  while(e){
119                     e ^= (it = e & -e);
120                      if((i ^ j) & it)++cnt;
121                 }
122             }
123             F[i] += F[j] * Pow[cnt];
124         }
125         F[i] = True - F[i];
126     }
127      /* #ifdef DEBUG
128      for(i = 1;i <= USet;++i)if(inc[i]){
129          printf("%d: ", i);
130          Print(F[i]);
131      }
132      #endif */
133     Calc();
134 }
135 
136  int main(){
137     #ifdef DEBUG
138     freopen( " test.txt ",  " r ", stdin);
139      #else       
140     SetFile(zjoi15_mst);
141      #endif
142     #ifdef USEFREAD
143     fread(ptr, 1,InputLen,stdin);
144      #endif
145     
146     init();
147     
148     work();
149     
150 #ifdef DEBUG
151     printf( " \n%.3lf sec \n ", ( double)clock() / CLOCKS_PER_SEC);
152  #endif
153      return  0;
154 }

几率多项式+状压dp

 

C.诸神眷顾的幻想乡

 给定一棵N个结点的树，每一个结点有一个颜色，求树上的全部路径通过的不一样颜色序列的数量。

  N不超过100000，保证树上的叶子结点数量不超过20，颜色值不超过10.

分析.

     一道比较良心的题……保证了叶子结点不超过20个，咱们就能够枚举全部的叶子，分别遍历一遍整棵树，对获得的全部序列创建多串后缀数据结构，查询不一样的子串数便可。用广义SAM实现起来比较容易。

代码. 

  1  /* ********************************************************************* */
  2  /* *********************By Asm.Def-Wu Jiaxin**************************** */
  3  /* ********************************************************************* */
  4 #include <cstdio>
  5 #include <cstring>
  6 #include <cstdlib>
  7 #include <cctype>
  8 #include <algorithm>
  9  using  namespace std;
 10  #define SetFile(x) ( freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout) );
 11  #define UseFREAD
 12 #ifdef UseFREAD
 13  #define getc() *(file_ptr++)
 14  #define FreadLenth 5000000
 15  char CHARPOOL[FreadLenth], *file_ptr = CHARPOOL;
 16  #else
 17  #define getc() getchar() 
 18  #endif
 19 #ifdef DEBUG
 20 #include <ctime>
 21  #endif
 22 template< class T>inline  void getd(T &x){
 23      char ch = getc(); bool neg =  false;
 24      while(!isdigit(ch) && ch !=  ' - ')ch = getc();
 25      if(ch ==  ' - ')ch = getc(), neg =  true;
 26     x = ch -  ' 0 ';
 27      while(isdigit(ch = getc()))x = x *  10 -  ' 0 ' + ch;
 28      if(neg)x = -x;
 29 }
 30  /* ********************************************************************* */
 31  const  int maxn =  100003, maxs =  1000000;
 32 typedef  long  long LL;
 33  int N, c, *adj[maxn], d[maxn], col[maxn], leaf[ 22], lcnt;
 34 
 35  struct SAM{
 36     SAM *son[ 10], *link;
 37      int len;
 38     LL cnt;
 39 }Node[maxs<< 1], *iter = Node +  1;
 40 
 41 inline SAM * insert(SAM *last,  int ch){
 42     SAM *cur = iter++, *it, *s, *clone;
 43     cur->len = last->len +  1;
 44     it = last;
 45      while(it && !it->son[ch])it->son[ch] = cur, it = it->link;
 46      if(!it)cur->link = Node;
 47      else{
 48          if(it->len +  1 == (s = it->son[ch])->len)cur->link = s;
 49          else{
 50             clone = iter++;*clone = *s;clone->len = it->len +  1;
 51             cur->link = s->link = clone;
 52              do{
 53                 it->son[ch] = clone;
 54                 it = it->link;
 55             } while(it && it->son[ch] == s);
 56         }
 57     }
 58      return cur;
 59 }
 60 
 61  void Build(SAM *last,  int cur,  int p){
 62     SAM *tmp = insert(last, col[cur]);
 63      int son;
 64      for( int i =  0;i < d[cur];++i) if((son = adj[cur][i]) != p)
 65         Build(tmp, adj[cur][i], cur);
 66 }
 67 
 68 inline  void init(){
 69     getd(N), getd(c);
 70     size_t intsize =  sizeof( int);
 71      int i, a, b, u[maxn], v[maxn], it[maxn] = { 0};
 72      for(i =  1;i <= N;++i)getd(col[i]);
 73      for(i =  1;i < N;++i){
 74         getd(u[i]), getd(v[i]);
 75         ++d[u[i]], ++d[v[i]];
 76     }
 77      for(i =  1;i <= N;++i){
 78         adj[i] = ( int*) malloc(intsize * (d[i] +  1));
 79          if(d[i] ==  1)leaf[lcnt++] = i;
 80     }
 81      for(i =  1;i < N;++i){
 82         a = u[i], b = v[i];
 83         adj[a][it[a]++] = b;
 84         adj[b][it[b]++] = a;
 85     }
 86      for(i =  0;i < lcnt;++i)Build(Node, leaf[i],  0);
 87 }
 88 
 89  int main(){
 90 
 91 #ifdef DEBUG
 92     freopen( " test.txt ",  " r ", stdin);
 93  #elif !defined ONLINE_JUDGE
 94     SetFile(zjoi15_substring);
 95  #endif
 96 
 97 #ifdef UseFREAD
 98     fread(file_ptr,  1, FreadLenth, stdin);
 99  #endif
100 
101     init();
102     LL Ans =  0;
103      for(SAM *it = Node +  1;it != iter;++it)Ans += it->len - it->link->len;
104     printf( " %lld\n ", Ans);
105 
106 #ifdef DEBUG
107     printf( " \n%.3lf sec \n ", ( double)clock() / CLOCKS_PER_SEC);
108  #endif
109      return  0;
110 }

多串后缀自动机

 

另附相关资料： 出题人的题解