Codeforces #263 Div 1 简要题解

最新推荐文章于 2024-09-30 05:54:51 发布

qpswwww

最新推荐文章于 2024-09-30 05:54:51 发布

阅读量697

点赞数

分类专栏：比赛题解比赛赛题 CodeForces

本文链接：https://blog.youkuaiyun.com/qpswwww/article/details/46638333

版权

比赛赛题同时被 3 个专栏收录

49 篇文章

订阅专栏

比赛题解

42 篇文章

订阅专栏

CodeForces

37 篇文章

订阅专栏

本文提供 CodeForces 461 赛事 A、B、C 三题的详细解析及代码实现。A题介绍了一种贪心策略，通过不断分裂集合来获得最大得分的方法；B题利用树形DP解决如何删除树边以确保每棵树仅含一个黑点的问题；C题则展示了使用树状数组维护操作和查询的技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A. Appleman and Toastman

题目链接

http://codeforces.com/contest/461/problem/A

题目大意

给你 $n$ 个数构成的集合 $S$ ，每次操作你可以选择当前的一个集合，将它分裂成两个非空集合，每次操作后，你将每个集合里的数字之和加起来，若出现了大小为1的集合，就将这个集合删去。问你操作的最大得分是多少。

思路

这样的贪心感觉比较多吧，比如NOIP的合并果子等等

显然在这个题目里，我们要让数字大的数字的加的次数尽量多点，我们可以考虑每次将一个集合分裂成两个集合，其中一个新集合的大小为1，这样就相当于每次操作会将所有的数字求和后加入得分里，然后删去其中一个数字。显然每次删最小的数字是最优的，自行yy脑补下这个贪心的正确性吧，我也很难给出详细的证明。

代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

#define MAXN 310000

using namespace std;

typedef long long int LL;

int n;
LL a[MAXN],sum[MAXN],ans=0;

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%I64d",&a[i]);
    sort(a+1,a+n+1);
    for(int i=1;i<=n;i++)
        sum[i]=sum[i-1]+a[i];
    ans+=sum[n];
    for(int i=2;i<=n;i++)
        ans+=a[i-1]+sum[n]-sum[i-1];
    printf("%I64d\n",ans);
    return 0;
}

B. Appleman and Tree

题目链接

http://codeforces.com/contest/461/problem/B

题目大意

给你一个树，树上的点要么是白点要么是黑点，删去 $k$ 条树边后，树就变成了一个包含 $k+1$ 个树的森林。问有多少种删边方案，使得最终森林里每个树上都只有一个黑点

思路

树上DP

设 $f[i][0]=$ 在删边后的森林里，点 $i$ 所在的树里，子树 $i$
里不包含黑点的方案数。设 $f[i][1]=$ 在删边后的森林里，点 $i$ 所在的树里，子树 $i$ 里只包含一个黑点的方案数。

假设对于点 $u$ ，我们已经确定了它的所有的儿子 $v$ 的 $f[v][0],f[v][1]$ 的值，我们按照顺序枚举儿子 $v$ ，分情况进行讨论：
1、点 $u$ 为黑点
显然 $f[u][0]$ 永远为0， $f[u][1]=\prod_v f[v][0]*f[v][1]$ (子树 $v$ 里全是白点的话，必须与 $u$ 连，不连就不合法了，子树 $v$ 包含一个黑点的话，必须与 $u$ 不连)
2、点 $u$ 为白点
$f[u][0]=\prod_v f[v][0]*f[v][1]$ (子树 $v$ 里全是白点的话，必须与 $u$ 连，不连的话就有一个树没有黑点，不合法了；子树 $v$ 包含一个黑点的话，必须与 $u$ 不连，连的话就会有一个树包含两个黑点，同样不合法)

这个情况下， $f[u][1]$ 比较特殊些，因为 $f[u][1]$ 的方案里，必须是与 $u$ 相连的儿子 $v$ 中，只有一个是黑点。考虑按顺序枚举 $v$ ，对于每个 $v$ ：

$f [u] [1] * = f [u] [1] (f [v] [0] + f [v] [1]) + f [u] [0] f [v] [1]$ $f[u][1]*=f[u][1](f[v][0]+f[v][1])+f[u][0]f[v][1]$
当前已经枚举了前面的儿子是否和点 $u$ 相连，因此有三种决策：1、子树 $u$ 尚不包含黑点，点 $u$ 在这时和包含黑点的子树 $v$ 相连；2、子树 $u$ 已经包含黑点，点 $u$ 在这时只能和不包含黑点的子树 $v$ 相连；3、子树 $u$ 尚不包含黑点，点 $u$ 在这时仍然和不包含黑点的子树 $v$ 相连。

要想在枚举了之前的儿子和当前的儿子 $v$ 之后，子树 $u$ 包含一个黑点，有两种选择：
1、如果在之前枚举的 $v$ 里，已经让子树 $u$ 包含有黑点1的话，那么只有让点 $u$ 和全为白点的子树 $v$ 相连，或者和保护黑点的子树 $v$ 不连接。
2、如果在之前枚举的 $v$ 里，子树 $u$ 没有包含黑点1的话，那么只有让点 $u$ 和包含一个黑点的子树 $v$ 相连。
对这两种情况，我们用加法计数和乘法计数来统计方案数即可。

虽然这个DP思路有点绕，不过大家仔细研究下DP方程还是能搞明白的

代码

#include <iostream> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <algorithm> #define MAXN 110000 #define MOD 1000000007 using namespace std; typedef long long int LL; struct edge { int u,v,next; }edges[MAXN*2]; int head[MAXN],nCount=0; void AddEdge(int U,int V) { edges[++nCount].u=U; edges[nCount].v=V; edges[nCount].next=head[U]; head[U]=nCount; } int color[MAXN],n; LL f[MAXN][2]; void DFS(int u,int fa) { for(int p=head[u];p!=-1;p=edges[p].next) { int v=edges[p].v; if(v==fa) continue; DFS(v,u); } if(color[u]) //u为黑点 { f[u][0]=0; //!!!!! f[u][1]=1; for(int p=head[u];p!=-1;p=edges[p].next) { int v=edges[p].v; if(v==fa) continue; f[u][1]=(f[u][1]*(f[v][0]+f[v][1]))%MOD; } } else { f[u][0]=1; f[u][1]=0; for(int p=head[u];p!=-1;p=edges[p].next) { int v=edges[p].v; if(v==fa) continue; f[u][1]=(f[u][1]*(f[v][0]+f[v][1])%MOD+f[u][0]*f[v][1]%MOD)%MOD; //!!!! f[u][0]=(f[u][0]*((f[v][0]+f[v][1])%MOD))%MOD; //v子树都是是白点可以选择连或者不连 } } } int main() { memset(head,-1,sizeof(head)); scanf("%d",&n); for(int i=2;i<=n;i++) { int x; scanf("%d",&x); x++; AddEdge(x,i); AddEdge(i,x); } for(int i=1;i<=n;i++) scanf("%d",&color[i]); DFS(1,-1); printf("%I64d\n",(f[1][1])%MOD); return 0; }

C. Appleman and a Sheet of Paper

题目链接

http://codeforces.com/contest/461/problem/C

题目大意

这是简化后的题目大意，部分细节和输入数据不同，需要注意
给你 $n$ 个数，这些数字初始为1，分别放在 $[1,n]$ ，每次有两种操作：1、让区间 $[L,L+l-1]$ 部分的数字依次加入到 $[L+l,L+2l-1]$ ，这个数字序列的有效部分变成 $[L+l,\max\{L+2l-1,R\}]([L,R]是原来的序列的有效部分)$ ；2、询问某个区间里的数字和

思路

我们可以用树状数组维护，每次执行操作1时，就 $l$ 次在树状数组里做单点增加数值的操作，操作1复杂度为 $O(ql\log n)$ ，对于操作2，就是树状数组区间求和了，操作2复杂度为 $O(q\log n)$

但是有个问题，假设当前数字序列的有效区间为 $[L,R]$ ，若 $l>\lfloor \frac{R-L+1}2\rfloor$ ，直观的讲就是左边叠过去的长度比右边被覆盖的部分更长。这样的情况可能会炸掉内存。为了保证每次有效区间永远在 $[1,n]$ 之中，我们可以打一个翻转标记 $rev$ ，若出现上述的情况时，就相当于是右边往左边叠过去，此时整个序列翻转了一遍，rev^=1

这个题特判和细节真的非常多，虽然口头讲下还是很简单的，不过想一遍写对还是非常难的

代码

#include <iostream> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <algorithm> #define MAXN 110000 #define MOD 1000000007 using namespace std; typedef long long int LL; struct edge { int u,v,next; }edges[MAXN*2]; int head[MAXN],nCount=0; void AddEdge(int U,int V) { edges[++nCount].u=U; edges[nCount].v=V; edges[nCount].next=head[U]; head[U]=nCount; } int color[MAXN],n; LL f[MAXN][2]; void DFS(int u,int fa) { for(int p=head[u];p!=-1;p=edges[p].next) { int v=edges[p].v; if(v==fa) continue; DFS(v,u); } if(color[u]) //u为黑点 { f[u][0]=0; //!!!!! f[u][1]=1; for(int p=head[u];p!=-1;p=edges[p].next) { int v=edges[p].v; if(v==fa) continue; f[u][1]=(f[u][1]*(f[v][0]+f[v][1]))%MOD; } } else { f[u][0]=1; f[u][1]=0; for(int p=head[u];p!=-1;p=edges[p].next) { int v=edges[p].v; if(v==fa) continue; f[u][1]=(f[u][1]*(f[v][0]+f[v][1])%MOD+f[u][0]*f[v][1]%MOD)%MOD; //!!!! f[u][0]=(f[u][0]*((f[v][0]+f[v][1])%MOD))%MOD; //v子树都是是白点可以选择连或者不连 } } } int main() { memset(head,-1,sizeof(head)); scanf("%d",&n); for(int i=2;i<=n;i++) { int x; scanf("%d",&x); x++; AddEdge(x,i); AddEdge(i,x); } for(int i=1;i<=n;i++) scanf("%d",&color[i]); DFS(1,-1); printf("%I64d\n",(f[1][1])%MOD); return 0; }