AtCoder Grand Contest 008题解

最新推荐文章于 2024-08-19 16:01:20 发布
最新推荐文章于 2024-08-19 16:01:20 发布
阅读量90 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/yuanquming/p/11441968.html
版权

传送门

\(A\)

分类讨论就行了

然而我竟然有一种讨论不动的感觉

int x,y;
inline int min(R int x,R int y){return x<y?x:y;}
inline int min(R int a,R int b,R int c,R int d){
    return min(min(a,b),min(c,d));
}
inline int calc(R int x,R int y){return y>=x?y-x:x-y+2;}
int main(){
    scanf("%d%d",&x,&y);
    printf("%d\n",min(calc(x,y),1+calc(-x,y),1+calc(x,-y),2+calc(-x,-y)));
    return 0;
}

\(B\)

发现最优策略一定是选择一段长度为\(k\)的区间，这个区间之外的数可以任意选或不选，区间内的数必须全选或全不选，那么枚举区间即可

const int N=5e5+5;
int a[N],n,k;ll Pre[N],suf[N],sum[N],res;
int main(){
    scanf("%d%d",&n,&k);
    fp(i,1,n)scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];
    fp(i,1,n)Pre[i]=Pre[i-1]+(a[i]>=0?a[i]:0);
    fd(i,n,1)suf[i]=suf[i+1]+(a[i]>=0?a[i]:0);
    for(R int l=1,r=k;r<=n;++l,++r)
        cmax(res,Pre[l-1]+suf[r+1]+max(sum[r]-sum[l-1],0ll));
    printf("%lld\n",res);
    return 0;
}

\(C\)

首先\(T,S,Z\)型的完全不用考虑因为肯定不合法，\(O\)型的肯定是自己放自己的，\(I,J,L\)都是可以自己跟自己拼成一个合法的，以及有可能\(I,J,L\)共同拼成一个合法的，讨论一下就行了

ll I,O,T,J,L,S,Z,res;
int main(){
    cin>>I>>O>>T>>J>>L>>S>>Z;
    cmax(res,(I-(I&1))+O+(J-(J&1))+(L-(L&1)));
    if(I&&J&&L)--I,--J,--L,cmax(res,(I-(I&1))+O+(J-(J&1))+(L-(L&1))+3),++I,++J,++L;
    cout<<res<<endl;
    return 0;
}

\(D\)

首先把所有数按\(x\)排序，那么按照这个顺序把\(x_ii\)前面的\(i-1\)个\(i\)给填满，以及记得剩下的\(n-i\)个数必须得填在\(x_i\)的后面

//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int N=505;
int a[N*N],st[N*N],x[N],id[N],top,n;
inline bool cmp(const int &a,const int &b){return x[a]<x[b];}
inline void ins(R int x){fp(i,1,n-x)st[++top]=x;}
int main(){
//  freopen("testdata.in","r",stdin);
    scanf("%d",&n);
    fp(i,1,n)scanf("%d",&x[i]),a[x[i]]=i,id[i]=i;
    sort(id+1,id+1+n,cmp);
    R int i=1,j=1;
    for(;i<=n;++i){
        R int c=0;
        while(c<id[i]-1){
            while(j<x[id[i]]&&a[j])ins(a[j++]);
            if(j==x[id[i]])return puts("No"),0;
            a[j]=id[i],++c,++j;
        }
    }
    while(233){
        while(j<=n*n&&a[j])ins(a[j++]);
        if(j>n*n)break;if(!top)return puts("No"),0;
        a[j++]=st[top--];
    }
    puts("Yes");
    fp(i,1,n*n)printf("%d ",a[i]);
    return 0;
}

\(E\)

这题是真的神仙啊……完全想不到

以下可以看做是题解的翻译

首先我们从\(i\)向\(p_i\)连边，那么显然会形成若干个环

对于每个环我们单独考虑，在环里对于每个点向\(p_i\)或者\(p_{p_i}\)连边，那么总共有四种情况（借用题解里的图）

1729838-20190901181213133-1118344154.png

1729838-20190901181214553-1701025752.png

1729838-20190901181219066-275937484.png

1729838-20190901181222163-1304338757.png

  • 得到一个不变的图

  • 得到一个同构的图，此时环的大小为奇数（且大于\(1\)）

  • 得到两个完全相同的环，此时环的大小为偶数

  • 得到一个环，环上伸展出去若干触手，且每个点只伸展出一个触手，触手无分叉

那么对于输入，我们把\(i\)向\(a_i\)连边，首先此时得到的图要合法（即由环和长触手的环构成），然后考虑它能反过来构成多少原来的环

对于大小为\(k\)的环，假设有\(c_k\)个，那么每一个都可以通过方法一变回环，如果环的大小大于\(1\)且是奇数那么还可以通过方法二，也可以把两个环给拼在一起（注意拼在一起的方案数为\(k\)）。设\(f_{i}\)表示\(i\)个环变回去的方案数，最终\(f_{c_k}\)就是答案了，这个可以\(O(c_k)\)的\(dp\)出来

然后来考虑触手，把触手接回环里有两种方案

1729838-20190901182014039-1323092686.png

那么设\(l_1\)表示这个触手的长，\(l_2\)表示这个触手距离上一个触手的距离，则这个触手缩回去的方案，当\(l_1<l_2\)时为\(2\)，\(l_1=l_2\)时为\(1\)，\(l_1>l_2\)时为\(0\)

综上，时间复杂度为\(O(n)\)

//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int P=1e9+7;
inline void upd(R int &x,R int y){(x+=y)>=P?x-=P:0;}
inline int add(R int x,R int y){return x+y>=P?x+y-P:x+y;}
inline int dec(R int x,R int y){return x-y<0?x-y+P:x-y;}
inline int mul(R int x,R int y){return 1ll*x*y-1ll*x*y/P*P;}
int ksm(R int x,R int y){
    R int res=1;
    for(;y;y>>=1,x=mul(x,x))(y&1)?res=mul(res,x):0;
    return res;
}
const int N=1e5+5;
int to[N],deg[N],cir[N],cnt[N],dp[N],col[N],len[N];
int n,res,tim;
inline int calc(R int x,R int y){return (x<y)+(x<=y);}
int main(){
//    freopen("testdata.in","r",stdin);
    scanf("%d",&n),res=1;
    fp(i,1,n)scanf("%d",&to[i]),++deg[to[i]];
    fp(i,1,n)if(!col[i]){
        R int u=i;
        for(++tim;!col[u];u=to[u])col[u]=tim;
        if(col[u]==tim)for(;!cir[u];u=to[u])cir[u]=1;
    }
    fp(i,1,n)if(deg[i]>cir[i]+1)return puts("0"),0;
    fp(i,1,n)if(!deg[i])
        for(R int u=i,l=0;!cir[u];len[to[u]]=++l,u=to[u]);
    fp(i,1,n)if(cir[i]){
        R int u=i,fir=0,firlen=0,k=0,las=0;
        for(;cir[u];cir[u]=0,u=to[u])
            if(++k,len[u]){
                if(!fir){fir=las=k,firlen=len[u];continue;}
                res=mul(res,calc(len[u],k-las)),las=k;
            }
        fir?res=mul(res,calc(firlen,fir+k-las)):++cnt[k];
    }
    fp(i,1,n)if(cnt[i]){
        R int op=(i&1)+(i>1);
        dp[0]=1;
        fp(j,1,cnt[i]){
            dp[j]=mul(dp[j-1],op);
            if(j>1)upd(dp[j],1ll*i*(j-1)%P*dp[j-2]%P);
        }
        res=mul(res,dp[cnt[i]]);
    }
    printf("%d\n",res);
    return 0;
}

\(F\)

更神仙的一道题

这题似乎有两种理解方法，这里只讲其中一种（另外一种枚举中点的我实在是看不懂啊……）

首先，我们设\(f(u,d)\)表示所有离\(u\)的距离不超过\(d\)的点构成的点集，如果直接去数有多少合法的\(d\)，显然会使很多点集被重复计数

考虑如何才能不重不漏的数完。首先整棵树肯定是合法的，那么我们规定染色的时候不能染完整棵树，最后答案\(+1\)即可

先假设所有的点都是特殊点，那么\(f(i,d_1)\)和\(f(j,d_2)\)如果相等，设这条路径为\(i,p_1,p_2,...,p_v,j\)，那么必定存在点\(p_k\)满足\(f(i,d_1)=f(p_1,d_1-1)=f(p_2,d_1-2)=...=f(p_{k-1},d_3+1)=f(p_k,d_3)=f(p_{k+1},d_3+1)=...=f(p_v,d_2-1)=f(j,d_2)\)

那么我们对于这个点集只要数\(f(p_k,d_3)即可\)，最终可以把条件转化为\(f(i,d)\)合法当且仅当对于任意一个和\(i\)相邻的点\(v\)，\(f(v,d-1)\neq f(i,d)\)

综上，条件为

\(1.f(i,d)\)不为全集

\(2.\)对于任意一个和\(i\)相邻的点\(v\)，\(f(v,d-1)\neq f(i,d)\)

第一个条件，我们只要求出\(i\)到树上任意一点的最远距离\(dis_i\)，那么\(d\leq dis_i-1\)

第二个条件，易知\(f(v,d-1)=f(i,d)\)等价于以\(i\)为根时，除了\(v\)这棵子树内，其它所有点均被染色，那么记下从\(i\)出发不经过\(v\)的最长路径\(len(i,v)\)，则有\(d-1\leq len(i,v)+1-1\)，即\(d\leq len(i,v)+1\)

然后现在有的点可能不是特殊点……事情变得辣手了起来……

先给出结论，一个\(d\)满足上界的\(f(i,d)\)合法，要么\(i\)是特殊点，要么以\(i\)为根时，这种染色方案能把某棵内部存在特殊点的子树内所有点全部染完

前一种情况很容易，因为如果\(i\)是特殊点显然\(d\)的下界为\(0\)

对于后一种情况，假设对应的特殊点为\(u\)，显然\(f(i,d)\)应该是以\(i\)为中点的一个点集，而我们需要从\(u\)拓展过来，所以这个点集的中点必定是偏向\(u\)的，所以只有当这个点集染完了\(u\)所在的子树且向\(i\)的其它子树扩展了足够的距离之后，才能满足\(f(i,d)\)是一个合法的点集，即\(i\)能够作为这个点集的中点，此时\(d\)的下界为以\(i\)为根时，满足\(v\)的子树中存在特殊点，且\(v\)的子树内离\(v\)距离最大的点距离最小，的距离

于是我们可以通过两遍树形\(dp\)求出答案，时间复杂度为\(O(n)\)，具体细节可以参考代码

//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
typedef long long ll;
const int N=2e5+5,inf=0x3f3f3f3f;
struct eg{int v,nx;}e[N<<1];int head[N],tot;
inline void add(R int u,R int v){e[++tot]={v,head[u]},head[u]=tot;}
inline int max(R int x,R int y){return x>y?x:y;}
inline int min(R int x,R int y){return x<y?x:y;}
int d1[N],d2[N],d3[N],d4[N],sz[N],fa[N];
//d1子树内离u最远的距离
//d2来自父亲的离u最远的距离
//d3存在特殊点的子树的最小的距离
//d4父亲不经过u这棵子树时能到达的最远距离 
ll res;char s[N];int n;
void dfs1(int u){
    sz[u]=(s[u]=='1'),d3[u]=sz[u]?0:inf;
    go(u)if(v!=fa[u]){
        fa[v]=u,dfs1(v),sz[u]+=sz[v],cmax(d1[u],d1[v]+1);
        if(sz[v])cmin(d3[u],d1[v]+1);
    }
}
void dfs2(int u){
    if(fa[u])d4[u]=d2[u]-1;
    R int se=0,fi=0,to=0;
    go(u)if(v!=fa[u]){
        if(d1[v]+1>=fi)to=v,se=fi,fi=d1[v]+1;
        else cmax(se,d1[v]+1);
    }
    go(u)if(v!=fa[u]){
        d2[v]=max(v==to?se:fi,d2[u])+1;
        dfs2(v);
    }
}
int main(){
    scanf("%d",&n);
    for(R int i=1,u,v;i<n;++i)scanf("%d%d",&u,&v),add(u,v),add(v,u);
    scanf("%s",s+1);
    dfs1(1),dfs2(1);
    fp(u,1,n){
        R int mn=min(d3[u],sz[u]==sz[1]?1e9:d2[u]);
        R int mx=max(d1[u],d2[u])-1;
        go(u)cmin(mx,(v==fa[u]?d1[u]:d4[v])+1);
        res+=max(mx-mn+1,0);
    }
    printf("%lld\n",res+1);
    return 0;
}

转载于:https://www.cnblogs.com/yuanquming/p/11441968.html

weixin_30735391
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AtCoder Regular Contest 102 Task C 题解（含代码）
01-16
这篇题解是关于AtCoder Regular Contest 102 Task C的，主要讨论的是一个与数学和算法相关的编程问题。题目要求找到所有满足以下条件的三元组(a, b, c)：a, b, c 不大于给定的整数 n，并且 a+b, b+c, a+c 都是另一个...
题解：AtCoder Beginner Contest 265C - Belt Conveyor (atcoder.jp)
06-18
这篇题解是关于AtCoder Beginner Contest 265C题目——"Belt Conveyor"的解决方案。这是一道入门级别的算法问题，主要考察的是模拟和边界条件处理能力。在这个问题中，你需要模拟一个传送带系统，并根据给定的网格...
牛客练习赛54 F 染色（思维）
。
11-17 247
链接：https://ac.nowcoder.com/acm/contest/1842/F 来源：牛客网 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 小a在研究自然数的染色问题时，发现了一个有趣的问题。 一个由正整数构成的集合S，若满足：对全体正整数集作k色染色后，S中不存在...
AtCoder Grand Contest 008 题解
aedwi06822的专栏
09-12 108
A - Simple Calculator 模拟+分类讨论即可。 //waz #include <bits/stdc++.h> using namespace std; #define mp make_pair #define pb push_back #define fi first #define se second #define AL...
AtCoder Grand Contest 043 题解 [A~D,EF暂坑]
curry的博客
03-22 606
爆零祭
Atcoder Grand Contest 003 题解
weixin_30646315的博客
09-08 84
A - Wanna go back home 如果有S就必须要有N，反之亦然，如果有E必须要有W，反之亦然。判断一下就好了。 //waz #include <bits/stdc++.h> using namespace std; #define mp make_pair #define pb push_back #define fi first #defin...
AtCoder Grand Contest 004题解
weixin_30735391的博客
08-15 105
传送门 \(A\) 咕咕 int a,b,c; int main(){ scanf("%d%d%d",&a,&b,&c); if((a&1^1)|(b&1^1)|(c&1^1))return puts("0"),0; printf("%lld\n",min(1ll*a*b,min(1ll*a*c,1ll*b*c)))...
AtCoder Grand Contest 037 题解
ezoileaner的博客
08-21 474
T1：不想说… T2：给一个R,G,B构成的序列，长度3n，各有n个 分给n个人，位置为a,b,c的话 答案为求∑max(a,b,c)−min(a,b,c)\sum max(a,b,c)-min(a,b,c)∑max(a,b,c)−min(a,b,c)为最小值时的方案数 n⩽105n\leqslant 10^5n⩽105 这是一道贪心题 维护当前匹配的R,G,B,RG,BG,RB，空的个数 然后加...
AtCoder Grand Contest 026 题解
fyc的博客
10-30 214
B - rng_10s： 大部分情况都很好判断，最后剩一种情况：A在mod B意义下+D，问是否存在x使得A+xD&gt;C。 容易发现循环节长度为gcd(B,D)，判一下即可。 code： #include&lt;cstdio&gt; #include&lt;cstdlib&gt; #include&lt;iostream&gt; #include&lt;cstring&gt; #define ...
AtCoder Grand Contest 007 题解
aedwi06822的专栏
09-11 132
A - Shik and Stone 直接模拟判断就好了。 //waz #include <bits/stdc++.h> using namespace std; #define mp make_pair #define pb push_back #define fi first #define se second #define ALL(x...
AtCoder Grand Contest 010 题解
aedwi06822的专栏
09-13 96
A - Addition 如果奇数的个数是奇数就无解，否则就有解。 //waz #include <bits/stdc++.h> using namespace std; #define mp make_pair #define pb push_back #define fi first #define se second #define A...
题解：AtCoder Beginner Contest 260 D-Changing Jewels
06-06
代码
AtCoder Beginner Contest 042解析（日文原版）
01-20
AtCoder Beginner Contest 042 解析（日文原版） 本资源摘要信息将对 AtCoder Beginner Contest 042 解析（日文原版）进行详细的知识点解析。 Overall Editorial 官方编辑=adminA - 和風いろはちゃんイージー /...
Atcoder Beginner Contest 113A题
11-04
#include using namespace std; int main(){ int x,y; cin>>x>>y; cout(y/2); return 0; }
【链表在Java中DeBug】
最新发布
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 146
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 370
C语言 | Leetcode C语言题解之第337题打家劫舍III
Java | Leetcode Java题解之第337题打家劫舍III
m0_57195758的博客
08-15 342
Java | Leetcode Java题解之第337题打家劫舍III
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 872
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
AtCoder Beginner Contest 134 简要题解
05-23
AtCoder Beginner Contest 134 是一场 AtCoder 的入门级比赛，以下是每道题的简要题解： A - Dodecagon 题目描述：已知一个正十二边形的边长，求它的面积。 解题思路：正十二边形的内角为 $150^\circ$，因此可以将正十二边形拆分为 12 个等腰三角形，通过三角形面积公式计算面积即可。 B - Golden Apple 题目描述：有 $N$ 个苹果和 $D$ 个盘子，每个盘子最多可以装下 $2D+1$ 个苹果，求最少需要多少个盘子才能装下所有的苹果。 解题思路：每个盘子最多可以装下 $2D+1$ 个苹果，因此可以将苹果平均分配到每个盘子中，可以得到最少需要 $\lceil \frac{N}{2D+1} \rceil$ 个盘子。 C - Exception Handling 题目描述：给定一个长度为 $N$ 的整数序列 $a$，求除了第 $i$ 个数以外的最大值。 解题思路：可以使用两个变量 $m_1$ 和 $m_2$ 分别记录最大值和次大值。遍历整个序列，当当前数不是第 $i$ 个数时，更新最大值和次大值。因此，最后的结果应该是 $m_1$ 或 $m_2$ 中较小的一个。 D - Preparing Boxes 题目描述：有 $N$ 个盒子和 $M$ 个物品，第 $i$ 个盒子可以放入 $a_i$ 个物品，每个物品只能放在一个盒子中。现在需要将所有的物品放入盒子中，每次操作可以将一个盒子内的物品全部取出并分配到其他盒子中，求最少需要多少次操作才能完成任务。 解题思路：首先可以计算出所有盒子中物品的总数 $S$，然后判断是否存在一个盒子的物品数量大于 $\lceil \frac{S}{2} \rceil$，如果存在，则无法完成任务。否则，可以用贪心的思想，每次从物品数量最多的盒子中取出一个物品，放入物品数量最少的盒子中。因为每次操作都会使得物品数量最多的盒子的物品数量减少，而物品数量最少的盒子的物品数量不变或增加，因此这种贪心策略可以保证最少需要的操作次数最小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值