浙江省队选拔 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(intint &);
 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() - 10);
 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(11), 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] = {01};//是否是包含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 }
多串后缀自动机

 

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

posted @ 2015-05-01 16:30 Asm.Definer 阅读(...) 评论(...) 编辑 收藏