Shoi2017试题泛做

一口气做完六个省的省选（误）

Day1

[Shoi2017]期末考试

枚举最大的天数，然后代价贪心地O(1)计算。

 #include <cstdio>
 #include <algorithm>

 #define R register
 typedef long long ll;
 #define maxn 100010
 #define cmax(_a, _b) (_a < (_b) ? _a = (_b) : 0)
 #define cmin(_a, _b) (_a > (_b) ? _a = (_b) : 0)
 #define dmin(_a, _b) ((_a) < (_b) ? (_a) : (_b))
 int a[maxn], b[maxn];
 int main()
 {
     R ll A, B, C, sum = , suma = ; scanf("%lld%lld%lld", &A, &B, &C);
     R int n, m, maxx = ; scanf("%d%d", &n, &m);
     for (R int i = ; i <= n; ++i) scanf("%d", &a[i]), suma += a[i];
     for (R int i = ; i <= m; ++i) scanf("%d", &b[i]), sum += b[i];
     std::sort(a + , a + n + );
     std::sort(b + , b + m + );
     maxx = b[m];
     R int p = m + , pp = n + ;
     R ll pre = sum, suf = , ans = 1e18;
     for (R int i = maxx; i; --i)
     {
         while (p && b[p - ] >= i) --p, suf += b[p], pre -= b[p];
         while (pp && a[pp - ] >= i) suma -= a[--pp];
         R ll need = suf - 1ll * i * (m - p + );
         if (A >= B)
         {
             R ll cost = (1ll * i * (pp - ) - suma) * C + need * B;
             cost >  ? cmin(ans, cost) : ;
         }
         else
         {
             R ll v = 1ll * i * (p - ) - pre;
 //            printf("v = %lld %lld %d\n", v, need, i);
 //            printf("pp %d suma %lld\n", pp, suma);
             cmin(v, need);
             R ll cost = (1ll * i * (pp - ) - suma) * C + v * A;
             need -= v;
             cost += need * B;
             cost >  ? cmin(ans, cost) : ;
 //            printf("%lld\n", ans);
         }
     }
     printf("%lld\n", ans);
     return ;
 }

D1T1

[Shoi2017]相逢是问候

恶心题。广义欧拉定理+线段树。

不懂什么是广义欧拉定理的同学（比如我）自行Baidu吧。大意和普通的欧拉定理是差不多的。

我们想象一下，指数第一次是模phi(p)，第二次就是模phi(phi(p))，如此迭代下去直到模数变成1，那么就和原先的数无关了，并且因为后面都是模1，到最后的时候每次操作相当于最上面的那个c拿去模1，结果还是c^c^c...的多少次方，所以它的值没有变。

一直迭代phi的这个操作我们联想到了 2749: [HAOI2012]外星人 ，可以证明这个操作次数是log级别的（详见那题题解）。

根据以上预备知识我们可以得到以下算法：

用线段树维护区间没有变成自环的点的位置，然后每次找到这个点暴力重新计算数值。

复杂度是每个点最多算log次*每次要算log次*快速幂的log，所以是3个log的。（很爆炸的复杂度）

 #include <cstdio>

 #define R register
 #define maxn 50010
 #define maxh 25
 #define maxx 500000
 typedef long long ll;
 bool flag, fl[maxh][maxx + ], vis[maxh][maxx + ];
 int dp[maxh][maxx + ];
 int ph[], phcnt, fc, p, c;
 int counter;
 inline int qpow(R int base, R int power, R int mh)
 {
     flag = ;
     R bool memo = power <= maxx && phcnt - mh < maxh;
     if (memo && vis[phcnt - mh][power]) {flag = fl[phcnt - mh][power]; ++counter; return dp[phcnt - mh][power];}
     R int mod = ph[mh], tp = power;
 //    fprintf(stderr, "base %d %d\n", mh, power);
     R int ret = ; ret >= mod ? flag = , ret %= mod : ;
     for (R ll t; power; power >>= , base = 1ll * base * base % mod)
         power &  ? (t = 1ll * ret * base) >= mod ? flag = , ret = t % mod : ret = t : ;
 //    printf("flag %d\n", flag);
     memo ? vis[phcnt - mh][tp] = , fl[phcnt - mh][tp] = flag, dp[phcnt - mh][tp] = ret : ;
     return ret;
 }
 inline int phi(R int x)
 {
     R int t = x, ret = ;
 //    printf("%d\n", x);
     for (R int i = ; 1ll * i * i <= x; ++i)
         if (t % i == )
         {
             t /= i; ret *= i - ;
             while (t >  && t % i == )
                 t /= i, ret *= i;
         }
     t !=  ? ret *= t -  : ;
     return ret;
 }
 ll sum[maxn << ];
 bool tr[maxn << ];
 int cov[maxn], a[maxn], ql, qr, qv;
 inline void update(R int o)
 {
     sum[o] = (sum[o << ] + sum[o <<  | ]) % p;
     tr[o] = tr[o << ] && tr[o <<  | ];
 }
 void build(R int o, R int l, R int r)
 {
     if (l == r)
     {
         sum[o] = a[l];
         tr[o] = phcnt == ;
         return ;
     }
     R int mid = l + r >> ;
     build(o << , l, mid); build(o <<  | , mid + , r);
     update(o);
 }
 int query(R int o, R int l, R int r)
 {
     if (ql <= l && r <= qr) return sum[o];
     R int mid = l + r >> , ret = ;
     if (ql <= mid) (ret += query(o << , l, mid)) %= p;
     if (mid < qr) (ret += query(o <<  | , mid + , r)) %= p;
     return ret;
 }
 void modify(R int o, R int l, R int r)
 {
     if (l == r)
     {
         if (tr[o]) return ;
         ++cov[l];
         a[l] >= ph[cov[l]] ? flag =  : flag = ;
         R int ff = a[l] % ph[cov[l]];
 //        printf("apos %d flag %d\n", a[l], flag);
         for (R int i = cov[l]; i; --i) ff = qpow(c, ff + (flag ? ph[i] : ), i - );

 //        printf("l %d ff %d\n", l, ff);
         tr[o] = cov[l] == phcnt;
         sum[o] = ff;
         return ;
     }
     R int mid = l + r >> ;
     if (ql <= l && r <= qr)
     {
         if (!tr[o << ]) modify(o << , l, mid);
         if (!tr[o <<  | ]) modify(o <<  | , mid + , r);
     }
     else
     {
         if (ql <= mid) modify(o << , l, mid);
         if (mid < qr) modify(o <<  | , mid + , r);
     }
     update(o);
 }
 int main()
 {
     R int n, m; scanf("%d%d%d%d", &n, &m, &p, &c);
     ph[] = p; for (; ph[phcnt] != ;) ph[++phcnt] = phi(ph[phcnt - ]);
     ph[++phcnt] = ;
 //    fprintf(stderr, "phcnt %d\n", phcnt);
 //    for (R int i = phcnt - 1; i; --i) fc = qpow(c, fc + ph[i], ph[i - 1]);
 //    printf("%d\n", fc);
     for (R int i = ; i <= n; ++i) scanf("%d", &a[i]);
     build(, , n);
     for (; m; --m)
     {
         R int opt, l, r; scanf("%d%d%d", &opt, &l, &r);
         if (opt == )
         {
             ql = l; qr = r;
             modify(, , n);
         }
         else
         {
             ql = l; qr = r;
             printf("%d\n", query(, , n));
         }
     }
 //    fprintf(stderr, "%d\n", counter);
     return ;
 }

D1T2

[Shoi2017]组合数问题

循环矩阵快速幂，做法和 4818: [Sdoi2017]序列计数 有点像。

 #include <cstdio>
 #include <algorithm>
 #include <cstring>

 #define R register
 typedef long long ll;
 int k, p;
 typedef int Vector[];
 Vector base, ans;
 void mul(R Vector A, R Vector B)
 {
     R Vector C; memset(C, , k << );
     for (R int i = ; i < k; ++i)
         for (R int j = ; j < k; ++j)
             C[(i + j) % k] = (C[(i + j) % k] + 1ll * A[i] * B[j]) % p;
     memcpy(A, C, k << );
 }
 int main()
 {
     R int n, r; scanf("%d%d%d%d", &n, &p, &k, &r);
     base[] = ; ++base[k - ];
     ans[] = ;
     for (R ll power = 1ll * n * k; power; power >>= , mul(base, base))
         power &  ? mul(ans, base),  : ;
 //    for (R int i = 0; i < k; ++i) printf("%d ", ans[i]);
     printf("%d\n", ans[r]);
     return ;
 }

D1T3

Day2

[Shoi2017]摧毁“树状图”

恶心题*2。树形DP

这题本来写了一个换根的做法结果因为太乱太复杂就推掉重新写了。（论想清楚再写的重要性）

最后参考了 SD_le 做法的题解。这位神犇的状态设计有理有据令人信服，所以我就参考了他的DP状态设计，然后自己推了一遍转移。然而推完以后还是不能1A，对拍以后才发现自己漏掉了好几种情况。。。（我好菜啊.jpg）

 #include <cstdio>
 #include <cstring>

 #define R register
 #define maxn 500010
 struct Edge {
     Edge *next;
     int to;
 } *last[maxn], e[maxn << ], *ecnt = e;
 inline void link(R int a, R int b)
 {
     *++ecnt = (Edge) {last[a], b}; last[a] = ecnt;
     *++ecnt = (Edge) {last[b], a}; last[b] = ecnt;
 }
 int f1[maxn], f2[maxn], f3[maxn], f4[maxn], g1[maxn], g2[maxn], ans;
 #define cmax(_a, _b) (_a < (_b) ? _a = (_b) : 0)
 void dfs(R int x, R int fa)
 {
     R int tf1, tf2, tf3, tf4, tg1, tg2, deg = , mx = ;
     R bool debug = x == ;
     for (R Edge *iter = last[x]; iter; iter = iter -> next)
         if (iter -> to != fa)
         {
             dfs(iter -> to, x); ++deg;
             tf1 = f1[x]; tf2 = f2[x]; tf3 = f3[x]; tf4 = f4[x]; tg1 = g1[x]; tg2 = g2[x];

             cmax(tg1, f2[iter -> to]);
             cmax(tg1, g1[iter -> to] - );

             cmax(tg2, g1[x] + g1[iter -> to] - );
             cmax(tg2, g1[x] + f2[iter -> to]);
             cmax(tg2, f4[iter -> to]);
             cmax(tg2, g2[iter -> to] - );

             cmax(tf1, f1[iter -> to] - );

             cmax(tf2, f1[x] + f1[iter -> to] - );

             cmax(tf3, f1[x] + f2[iter -> to] - );// && debug ? printf("t1 %d %d\n", iter -> to, tf3) : 0;
             cmax(tf3, f1[x] + g1[iter -> to] - );// && debug ? printf("t2 %d %d\n", iter -> to, tf3) : 0;
             cmax(tf3, f2[x] + f1[iter -> to] - );// && debug ? printf("t3 %d %d\n", iter -> to, tf3) : 0;
             cmax(tf3, mx + f1[iter -> to] - );// && debug ? printf("t4 %d %d %d\n", iter -> to, tf3) : 0;
             cmax(tf3, f3[iter -> to] - );// && debug ? printf("t5 %d %d\n", iter -> to, tf3) : 0;

             cmax(tf4, f1[x] + f3[iter -> to] - );
             cmax(tf4, f3[x] + f1[iter -> to] - );
             cmax(tf4, f2[x] + g1[iter -> to] - );
             cmax(tf4, f2[x] + f2[iter -> to] - );

             cmax(mx, f2[iter -> to]);
             cmax(mx, g1[iter -> to]);
             f1[x] = tf1; f2[x] = tf2; f3[x] = tf3; f4[x] = tf4; g1[x] = tg1; g2[x] = tg2;
 //            printf("f %d %d %d %d iter -> to %d %d\n", tf1, tf2, tf3, tf4, iter -> to, x);
         }
     ++g1[x]; ++g2[x];
     f1[x] += deg; f2[x] += deg; f3[x] += deg; f4[x] += deg;
     /*cmax(g1[x], 1);*/ cmax(g2[x], g1[x]);
     cmax(f2[x], f1[x]); cmax(f3[x], f2[x]); cmax(f4[x], f3[x]);
     cmax(ans, g2[x]); cmax(ans, f4[x]);
 //    printf("ans %d x %d\n", ans, x);
 //    x == 2 ? printf("f %d %d %d %d\ng %d %d\n", f1[x], f2[x], f3[x], f4[x], g1[x], g2[x]) : 0;
 }
 int main()
 {
     R int T, type; scanf("%d%d", &T, &type);
     for (; T; --T)
     {
         R int n; scanf("%d", &n); ans = ;
         for (R int i = ; i <= type; ++i) scanf("%*d%*d");
         for (R int i = ; i < n; ++i)
         {
             R int a, b; scanf("%d%d", &a, &b); link(a, b);
         }
         if (n == ) {puts(""); continue;}
         dfs(, );
         printf("%d\n", ans);

         memset(last, , (n + ) << ); ecnt = e;
         memset(f1, , (n + ) << );
         memset(f2, , (n + ) << );
         memset(f3, , (n + ) << );
         memset(f4, , (n + ) << );
         memset(g1, , (n + ) << );
         memset(g2, , (n + ) << );
     }
     return ;
 }
 /*
 1 0
 15
 1 2
 2 3
 1 4
 2 5
 1 6
 3 7
 4 8
 3 9
 4 10
 6 11
 5 12
 4 13
 6 14
 5 15
 9

 1 0
 10
 1 2
 2 3
 1 4
 3 5
 3 6
 2 7
 1 8
 7 9
 9 10
 6

 1 0
 10
 1 2
 1 3
 2 4
 1 5
 3 6
 3 7
 5 8
 5 9
 4 10
 */

D2T1

[Shoi2017]分手是祝愿

高斯消元有95分。

先把倍数关系通过一次高斯消元转化为单个灯是否要改变。

计c[i]表示还剩下i个1时的期望步数。根据题意，对于i<=k,有c[i] = i。然后这个转移有环，所以得高斯消元。

推出来每一行只有3个变量，所以消元是线性的。因为n和模数很接近，而消元的时候又有+1，然后系数很容易就+到0了，然后就boom（爆炸熊.jpg）。

既然出题人卡了高斯消元那么我们就来考虑推推式子。（因为没有用markdown所以式子略丑请原谅。。。）

考虑我们之前推出来的递推式：c[i] = (i/n) * c[i-1] + ((n - i) / n) * c[i + 1] + 1

然后对于i=n的时候，有c[n] = c[n - 1] + 1 (1)

对于i=n-1时，有c[n-1] = 1 + ((n - 1) / n) * c[n - 2] + (1 / n) * c[n] (2)

把(1)式代入(2)式：c[n - 1] = 1 + ((n - 1) / n) * c[n - 2] + 1 / n + 1 / n * c[n - 1]

移项：((n - 1) / n) * c[n - 1] = ((n - 1) / n) * c[n - 2] + (n + 1) / n

除过去：c[n - 1] = c[n - 2] + (n + 1) / (n - 1)

只剩两项啦~于是我们猜想c[i]这个序列是一个一阶递推式，并且上一项的系数是1（这个可以用数学归纳法证）。

于是我们就只要知道递推的常数项即可。我们来强行分析一波：

设第i项的系数为x[i]，而且我们已知了x[n] = 1。递推式可以写成c[i] = c[i - 1] + x[i]

我们从一开始的式子入手：c[i] = (i / n) * c[i - 1] + ((n - i) / n) * c[i + 1] + 1

代入：c[i] = (i / n) * c[i - 1] + ((n - i) / n) * (c[i] + x[i + 1]) + 1

两边乘个n然后再移项：i * c[i] = i * c[i - 1] + (n - i) * x[i + 1] + n

除个i：c[i] = c[i - 1] + ((n - i) * x[i + 1] + n) / i

这样的话连上面系数等于1的顺便也给证了。。。

所以求得x[i] = ((n - i) * x[i + 1] + n) / i。

然后递推一下就能求出c每一项的值来啦。

附代码：（95分的高斯消元在注释里面）

 #include <cstdio>
 #define R register
 #define maxn 100010
 const int mod = 1e5 + ;
 int a[maxn], b[maxn], c[maxn][], f[maxn], x[maxn], inv[maxn];
 inline int qpow(R int base, R int power)
 {
     R int ret = ;
     for (; power; power >>= , base = 1ll * base * base % mod)
         power &  ? ret = 1ll * ret * base % mod : ;
     return ret;
 }
 int main()
 {
     R int n, k, fact = ; scanf("%d%d", &n, &k);
     for (R int i = ; i <= n; ++i) scanf("%d", &a[i]);
     inv[] = ;
     for (R int i = ; i <= n; ++i)
     {
         fact = 1ll * fact * i % mod, inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
 //        printf("%d %d\n", inv[i], qpow(i, mod - 2));
     }
     R int tmp = k, kk = ;
     for (R int i = n; i; --i)
     {
         b[i] = a[i];
         for (R int j = i << ; j <= n; j += i) b[i] ^= b[j];
         kk += b[i];
     }
     if (kk <= k) return !printf("%d\n", 1ll * kk * fact % mod);
 /*    c[k][0] = 1; c[k][1] = 0; c[k][2] = k;
     for (R int i = k + 1; i <= n; ++i)
     {
         R int tmp = 1ll * qpow(c[i - 1][0], mod - 2) * i % mod * qpow(n, mod - 2) % mod;
         c[i][0] = (1 + 1ll * c[i - 1][1] * tmp) % mod;
         c[i][1] = 1ll * (mod + i - n) * qpow(n, mod - 2) % mod;
         c[i][2] = (1 + 1ll * c[i - 1][2] * tmp) % mod;
     }
     for (R int i = n; i > k; --i)
     {
         f[i] = 1ll * (c[i][2] - 1ll * f[i + 1] * c[i][1] % mod + mod) * qpow(c[i][0], mod - 2) % mod;
     }
     printf("%d\n", 1ll * f[kk] * fact % mod);*/
     x[n] = ;
     R int ans = k;
     for (R int i = n - ; i > k; --i)
     {
         x[i] = (1ll * x[i + ] * (n - i) % mod * inv[n] % mod + ) * n % mod * inv[i] % mod;
     }
     for (R int i = k + ; i <= kk; ++i) (ans += x[i]) %= mod;
     printf("%d\n", 1ll * ans * fact % mod);
     return ;
 }

D2T2

[Shoi2017]寿司餐厅

最大权闭合子图。最小割。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 #define R register
 #define maxn 100010
 #define inf 0x7fffffff
 #define dmin(_a, _b) ((_a) < (_b) ? (_a) : (_b))
 struct Edge {
     Edge *next, *rev;
     int to, cap;
 } *last[maxn], *cur[maxn], e[maxn << ], *ecnt = e;
 inline void link(R int a, R int b, R int w)
 {
 //    printf("%d %d %d\n", a, b, w);
     *++ecnt = (Edge) {last[a], ecnt + , b, w}; last[a] = ecnt;
     *++ecnt = (Edge) {last[b], ecnt - , a, }; last[b] = ecnt;
 }
 int a[], d[][], id1[], id2[], id[][];
 int ans, s, t, q[maxn], dep[maxn];
 inline bool bfs()
 {
     memset(dep, -, (t + ) << );
     dep[q[] = t] = ; R int head = , tail = ;
     while (head < tail)
     {
         R int now = q[++head];
         for (R Edge *iter = last[now]; iter; iter = iter -> next)
             if (dep[iter -> to] == - && iter -> rev -> cap)
                 dep[q[++tail] = iter -> to] = dep[now] + ;
     }
     return dep[s] != -;
 }
 int dfs(R int x, R int f)
 {
     if (x == t) return f;
     R int used = ;
     for (R Edge* &iter = cur[x]; iter; iter = iter -> next)
         if (iter -> cap && dep[iter -> to] +  == dep[x])
         {
             R int v = dfs(iter -> to, dmin(f - used, iter -> cap));
             iter -> cap -= v;
             iter -> rev -> cap += v;
             used += v;
             if (used == f) return f;
         }
     return used;
 }
 inline void dinic()
 {
     while (bfs())
     {
         memcpy(cur, last, sizeof cur);
         ans += dfs(s, inf);
     }
 }
 int main()
 {
     R int n, m, sum = ; scanf("%d%d", &n, &m);
     for (R int i = ; i <= n; ++i) scanf("%d", &a[i]);
     for (R int i = ; i <= n; ++i) for (R int j = i; j <= n; ++j) scanf("%d", &d[i][j]);
     R int tot = ;
     for (R int i = ; i <= n; ++i)
     {
         for (R int j = i; j <= n; ++j)
             id[i][j] = ++tot;
         link(id[i][i], id1[a[i]] ? id1[a[i]] : id1[a[i]] = ++tot, a[i]);
         m ? link(id[i][i], id2[a[i]] ? id2[a[i]] : id2[a[i]] = ++tot, inf),  : ;
     }
     t = ++tot;
     for (R int i = ; i <= n; ++i)
     {
         for (R int j = i; j <= n; ++j)
         {
             d[i][j] >  ? link(s, id[i][j], d[i][j]), sum += d[i][j] : (link(id[i][j], t, -d[i][j]), );
             i != j ? link(id[i][j], id[i + ][j], inf), link(id[i][j], id[i][j - ], inf),  : ;
         }
     }
     for (R int i = ; i <= ; ++i)
     {
         id1[i] ? link(id1[i], t, inf),  : ;
         id2[i] ? link(id2[i], t, i * i),  : ;
     }
     dinic();
 //    printf("ans = %d %d\n", ans, t);
     printf("%d\n", sum - ans);
     return ;
 }

D2T3