Codeforces Round #263 (Div. 2) A,B,C,D,E

最新推荐文章于 2023-04-30 15:30:17 发布

i-o07

最新推荐文章于 2023-04-30 15:30:17 发布

阅读量527

点赞数

分类专栏： Codeforces Solutions

本文链接：https://blog.csdn.net/u013649253/article/details/38920235

版权

Codeforces Solutions 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

题目链接：http://codeforces.com/contest/462/problem/A

签到题了，扫一遍矩阵的每个位置统计统计每个位置四个方向的o的个数看是不是偶数就可以了。

code：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include<cstdio>
#include <queue>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
#define INF 2000000000
using namespace std;
typedef long long ll;
const int MAX_E=10000;
const int MAX_V=9000;
const int MAX_Q=100000;
const int MAX_N=220;

int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
char cc[MAX_N][MAX_N];
int N;
int cal(int x,int y)
{
    int num=0;
    for(int i=0;i<4;i++){
        int midx=x+dir[i][0],midy=y+dir[i][1];
        if(midx<0||midy<0||midx>=N||midy>=N) continue;
        if(cc[midx][midy]=='o') num++;
    }
    return num;
}
void solve()
{
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            if(cal(i,j)%2!=0){
                printf("NO\n");
                return ;
            }
        }
    }
    printf("YES\n");
    return ;
}
int main()
{
    scanf("%d",&N);
    for(int i=0;i<N;i++) scanf("%s",cc[i]);
    solve();
    return 0;
}

题目链接：http://codeforces.com/contest/462/problem/B

大致题意：给你一个由大写字母组成的字符串，让你从中挑出一些字母，对于挑出的每个字母你都有一个得分，其得分为挑出的字母中此字母的个数，问挑选得到的最大得分。

思路：对于每一种字母其总得分等于其个数的平方，因为字母的总数有限（设为k），所以我们可以假设挑选了两种字母其个数分别为a，b，所以有a+b=k，求a*a+b*b的最大值。

易证，a和b越接近，a*b就越大，所求式子的值就越小，所以我们就应该让a尽可能的大，由此我们就能得到此题的贪心思路：

对输入的字符串统计每个字符出现的次数，然后对这个次数记录的数组进行降序排序，然后贪心的选取最大的字母就行，注意中间开long long。

code：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include<cstdio>
#include <queue>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
#define INF 2000000000
using namespace std;
typedef long long ll;
const int MAX_E=10000;
const int MAX_V=9000;
const int MAX_Q=100000;
const int MAX_N=100500;

bool cmp(int a,int b)
{
    return a>b;
}
int main()
{
    int n,k,num[30];
    ll ans=0;
    char cc[MAX_N];
    scanf("%d%d",&n,&k);
    scanf("%s",cc);
    memset(num,0,sizeof(num));
    for(int i=0;i<n;i++) num[cc[i]-'A']++;
    sort(num,num+26,cmp);
    for(int i=0;i<26;i++){
        if(num[i]<=k){ans+=(ll)num[i]*num[i]; k-=num[i];}
        else         {ans+=(ll)k*k;break;}
    }
    printf("%lld\n",ans);
}

题目链接：http://codeforces.com/contest/462/problem/C

大致题意：去看题吧~~

思路：我当时脑子里立刻想到的是有两思路，一个是每次分的时候将分成的两部分的个数尽可能的平均，一个是每次都将最小的那个数分出来，我手算了几组，发现后面的那个都会更大一点，就按了这个思路写了，然后就过了。

code：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include<cstdio>
#include <queue>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
#define INF 2000000000
using namespace std;
typedef long long ll;
const int MAX_E=10000;
const int MAX_V=9000;
const int MAX_Q=100000;
const int MAX_N=500500;

int a[MAX_N];

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

题目链接：http://codeforces.com/problemset/problem/462/D

大致题意：给你一棵树，这个树上n个节点，节点的颜色有黑和白，删掉树上的一条边就可以将一个树分成两个子树，问有多少种删边的方法，使得最后的每个子树有且仅有一个黑色节点。

思路：树形dp.

dp定义：dp[i][0] 表示将结点i作为根节点的子树划分成不含黑色节点的方案数，dp[i][1]表示将结点i作为根节点的子树划分成只含一个黑色节点的方案数

dp转移方程：x表示节点v的一个子节点，则有

dp[v][1]=dp[x][1]*dp[v][1](可以将链接含黑色节点子树的边删掉)+dp[x][0]*dp[v][1]+dp[x][1]*dp[v][0]

dp[v][0]=dp[x][0]*dp[v][0]+dp[x][1]*dp[v][0]

dp边界条件： dp[v][cor[v]]=1 dp[v][cor[v]^1]=0

闲谈：这道题也是后来参考题解做的，树形dp掌握的还是很不熟练的，现在理解的感觉也不是很透彻，需要再练。

code：

//#define LOCAL
#include <iostream>
#include <cstring>
#include <cstdlib>
#include<cstdio>
#include <algorithm>
#include <vector>
#define INF 1000000000
#define eps 1e-9
using namespace std;
typedef long long LL;
const int MAX_N=100000;
const int p=1000000007;

int a[MAX_N],n;
vector<int> G[MAX_N];
LL dp[MAX_N][2];
void dfs(int v,int f)
{
    dp[v][a[v]]=1;
    for(int i=0;i<(int)G[v].size();i++){
        int x=G[v][i];
        if(x==f) continue;
        dfs(x,v);
        dp[v][1]=(dp[v][1]*dp[x][1]+dp[v][1]*dp[x][0]+dp[v][0]*dp[x][1])%p;
        dp[v][0]=(dp[v][0]*dp[x][1]+dp[v][0]*dp[x][0])%p;
    }
}
int main()
{
    //#ifdef LOCAL
       // freopen("input.txt","r",stdin);
       // freopen("output.txt","w",stdout);
    //#endif
    int t;
    scanf("%d",&n);
    for(int i=0;i<n-1;i++){
        scanf("%d",&t);
        G[i+1].push_back(t);
        G[t].push_back(i+1);
    }
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    memset(dp,0,sizeof(dp));
    dfs(0,-1);
    printf("%lld\n",dp[0][1]);
    return 0;
}

题目链接：http://codeforces.com/problemset/problem/462/E

大致题意：折纸片，给你一张纸片，纸片上标记了0~N个顶点，再给你两个操作一个是，将某个节点左边的纸片向右翻折，一个是求一段区间的纸片的厚度和。

思路：这题我做的实在是坎坷。我看题之后马上反映过来就是线段树维护区间和，因为纸片越折越短所以再更新的时候我们可以直接暴力的一个一个的更新，感觉是水但是我当时做了快一个下午。。。。。

姿势一：这是我最原初的想法，就是记录一个纸片的头head，每次更新的时候先更新头的位置，然后将头左边的数一次对应的加到头的右边，但是这个时候遇到了一个问题，就是当翻折长度大于一般的时候怎么办，我的想法是将这个纸片初始的很长，在一开始的时候将有纸片的位置初始成1，将没纸片的位置初始成0，这样做过了但是却a不掉，原因是对于大数据初始的纸片要打到10^9左右，内存开不下，线段树求和也会超时，姿势一挂掉。

姿势二：纸片的head不变，更新都将更新后的提到最前面，但是仔细一想，这样后面的也要进行更新，多余的操作做了好多，铁定会超时呀。

姿势三：我发现了一个重要的性质，就是当更新的时候超过一半的时候相当于将右侧的纸片想左折，但是这样也有一个问题就是纸片的头和尾是反着的，怎么办？

线段树翻转？从新初始化纸条建立线段树？？感觉都好不靠谱呀~ 所以我去查了题解，发现只要直接记录一个标记如果是相反的就反着更新和求和就行，照着这个思路最后还真做出来了~~~~

也学到了一个小技巧就是，可以用异或快捷的对标记进行翻转~

code：

//#define LOCAL
#include <iostream>
#include <cstring>
#include <cstdlib>
#include<cstdio>
#include <algorithm>
#include <vector>
#define INF 1000000000
#define eps 1e-9
using namespace std;
typedef long long LL;
const int MAX_N=105000;
const int p=1000000007;

int dat[4*MAX_N-1],n,q;

void init(int n_)
{
    n=1;
    while(n<n_) n*=2;
    for(int i=0;i<2*n-1;i++) dat[i]=0;
}
void update(int k,int x)
{
    k+=n-1;
    dat[k]+=x;
    while(k>0){
        k=(k-1)/2;
        dat[k]=dat[2*k+1]+dat[2*k+2];
    }
}
int sum(int a,int b,int k,int l,int r)
{
    if(b<l||r<a) return 0;
    if(a<=l&&r<=b) return dat[k];
    else{
        int v1=sum(a,b,2*k+1,l,(l+r)/2);
        int v2=sum(a,b,2*k+2,(l+r)/2+1,r);
        return v1+v2;
    }
}
int main()
{
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    int kind,l,r,head,tail,m,cur;
    scanf("%d%d",&m,&q);
    n=m;
    init(n);
    for(int i=0;i<m;i++) update(i,1);
    head=0;
    tail=m-1;
    cur=0;
    while(q--){
        scanf("%d",&kind);
        if(kind==1){
            scanf("%d",&l);
            if(2*l<=tail-head+1){
                if(cur==0){
                    head+=l;
                    for(int i=0;i<l;i++) update(head+i,dat[head-i-1+n-1]);
                }
                else{
                    tail-=l;
                    for(int i=0;i<l;i++) update(tail-i,dat[tail+i+n]);
                }
            }
            else{
               cur^=1;
               l=(tail-head+1)-l;
                if(cur==0){
                    head+=l;
                    for(int i=0;i<l;i++) update(head+i,dat[head-i-1+n-1]);
                }
                else{
                    tail-=l;
                    for(int i=0;i<l;i++) update(tail-i,dat[tail+i+n]);
                }
            }

        }
        else{
            scanf("%d%d",&l,&r);
            if(cur==0)  printf("%d\n",sum(head+l,head+r-1,0,0,n-1));
            else        printf("%d\n",sum(tail-r+1,tail-l,0,0,n-1));
        }
    }
    return 0;
}