【赛后总结+部分题解】2019中国大学生程序设计竞赛（CCPC）

赛后总结：

　　T：今天状态一般，甚至有点疲惫。然后12点比赛开始，和队友开始看题，从最后往前面看，发现数学题公式看不懂。然后发现队友已经双开做1001和1006了，我看着1007有人A，开始做1007。看了一会发现这是一个简单签到题，构造一下就完事了。然后一遍A，结束。在他们看1008的时候，我回去看1002和1003，1002的题意没看清楚，队友说的也有点模糊，然后不知道怎么下手。开始看1003，因为A的人真的好多呜呜呜。从AC自动机一直re转为后缀自动机，然后不会。结束了。今天对队伍的贡献太少了，复杂度也没算好，一直在re。做题策略还是有点问题，不该纠结自己不会的领域。然后也有很多不会的知识需要去弥补。

P：lucky，从中间看到的第一题就是一道签到题。但由于读题不完整，在输出格式上WA了2-3次。所幸，过了。然后，就去看了钓鱼那题，将题意告诉了队友，队友有思路直接开做，我负责着错误样例。期间，我考虑到的一个点跟队友说，队友无法理解，我就想着自己打打看。AC后，才发现，队友这次想复杂了。接着的1002，1003，只能说自己的知识储备不够，大概从题目能够知道用了什么算法，但无法解决。

　　J：今天状态贼差，1008WA了七八次还是没A出来，结果是我想复杂了，队友一下就A了，还是太弱了，1002是线段树，但是不知道该怎么做，看来应该做一下线段树专题了。

部分题解：

1001 ^&^

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<queue>

#include<set>

#include<cmath>

#include<string>

#include<map>

#include<vector>

#include<ctime>

#include<stack>

using namespace std;

#define mm(a,b) memset(a,b,sizeof(a))

typedef long long ll;

const long long mod = 1e9 + ;

const int maxn = 1e6 + ;

int main()

{

    ll a, b, c, k, cnt;

    int t;

    cin >> t;

    k = ;

    while (t--)

    {

        c = , k = , cnt = ;

        scanf("%lld%lld", &a, &b);

        int flag = ;

        while (a || b)

        {

            if (a &  && b & )

            {

                c += k;

            }

            else if ((a & ) + (b & ) ==  && flag)

            {

                flag = , cnt = k;

            }

            a >>= , b >>= ;

            k <<= ;

        }

        if (!c) c = cnt ==  ?  : cnt;

        printf("%lld\n", c);

    }

}

1002 array

题解来源：https://mmfunnytree.github.io/2019/08/23/begin14/#more?tdsourcetag=s_pcqq_aiomsg 原博主的代码有点点小问题，不能直接提交哦

分析

首先可以想到，由于一开始给的A数组是个排列，且第一种操作加的数字固定为1e7，所以，操作1可以认为在原序列中删除了A[i]A这个数字；
那么我们可以把A[i]这个数字标记为已经被删除，那么下次查询的时候，一方面我们可以从原序列中去查询第一个大于等于k，且未在A[1..r]出现过的数字，另一方面，我们可以在标记删除的容器里二分找到第一个不小于k的数字，两者取小便可，根据排列的性质，这两个数字一定不会冲突；
所以问题就变成了，维护一个set，存放被删除的数字，构造一个主席树，然后查询的时候直接找到第一个合适的数字便可。

#pragma comment(linker, "/STACK:1024000000,1024000000")

#pragma GCC optimize(2)

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<queue>

#include<set>

#include<cmath>

#include<string>

#include<map>

#include<vector>

#include<ctime>

#include<stack>

using namespace std;

#define mm(a,b) memset(a,b,sizeof(a))

typedef long long ll;

const long long mod = 1e9+;

const int maxn = 2e5;

set<int>st;

int n,m,lst;

int T[maxn],lson[maxn*],rson[maxn*],c[maxn*],tot;

int a[maxn];

void update(int &u,int p,int l,int r)

{

    ++tot;

    lson[tot]=lson[u];

    rson[tot]=rson[u];

    c[tot]=c[u]+;

    u=tot;

    if(l==r) return;

    int mid=(l+r)>>;

    if(p<=mid) update(lson[u],p,l,mid);

    else update(rson[u],p,mid+,r);

}

int tmp1;

void query(int rt,int L,int R,int l,int r)

{

    if(tmp1<n+) return;

    if(L<=l&&R>=r)

    {

        if(c[rt]==)

        {

            tmp1=l;return;

        }

        if(c[rt]==r-l+) return;

        int mid=(l+r)>>;

        if(c[lson[rt]]==mid-l+) query(rson[rt],L,R,mid+,r);

        else query(lson[rt],L,R,l,mid);

    }

    int mid=(l+r)>>;

    if(L<=mid) query(lson[rt],L,R,l,mid);

    if(R>mid) query(rson[rt],L,R,mid+,r);

}

int main()

{

    int t;

    scanf("%d",&t);

    while(t--)

    {

        st.clear();

        tot=;lst=;

        scanf("%d %d",&n,&m);

        st.insert(n+);

        for(int i=;i<=n;i++)

        {

            scanf("%d",&a[i]);

            T[i]=T[i-];

            update(T[i],a[i],,n);

        }

        int op,pos,r,k;

        while(m--)

        {

            scanf("%d",&op);

            if(op==)

            {

                scanf("%d",&pos);

                pos^=lst;

                st.insert(a[pos]);

            }

            else

            {

                scanf("%d %d",&r,&k);

                r^=lst,k^=lst;

                int ans=*(st.lower_bound(k));

                tmp1=n+;

                query(T[r],k,n,,n);

                ans=min(ans,tmp1);

                printf("%d\n",ans);

                lst=ans;

            }

        }

    }

    return ;

}

1003 K-th occurrence

#pragma comment(linker, "/STACK:1024000000,1024000000")

#pragma GCC optimize(2)

#include <bits/stdc++.h>

using namespace std;

#define mm(a,b) memset(a,b,sizeof(a))

typedef long long ll;

const long long mod = ;

const int maxn = 1e5+;

const int inf = 0x3f3f3f3f;

char s[maxn];

struct Tree{

    int tot, rt[maxn], lson[maxn*], rson[maxn*], cnt[maxn*];

    int build (int l, int r) {

        int o = ++tot;

        int mid = (l + r) >> ;

        cnt[o] = ;

        if (l != r) {

            lson[o] = build(l, mid);

            rson[o] = build(mid+, r);

        }

        return o;

    }

    int update(int prev, int l, int r, int v) {

        int o = ++tot;

        int mid = (l + r) >> ;

        lson[o] = lson[prev];

        rson[o] = rson[prev];

        cnt[o] = cnt[prev] + ;

        if (l != r) {

            if (v <= mid) lson[o] = update(lson[o], l, mid, v);

            else rson[o] = update(rson[o], mid+, r, v);

        }

        return o;

    }

    int query(int u, int v, int l, int r, int k) {

        if (l == r) return l;

        int mid = (l + r) >> ;

        int num = cnt[lson[v]] - cnt[lson[u]];

        if (num >= k) return query(lson[u], lson[v], l, mid, k);

        else return query(rson[u], rson[v], mid+, r, k-num);

    }

};

struct SuffixArray{ // 下标1

    int cntA[maxn], cntB[maxn], A[maxn], B[maxn];

    int Sa[maxn], tsa[maxn], height[maxn], Rank[maxn]; // Sa[i] 排名第i的下标， Rank[i] 下标i的排名

    int n, dp[maxn][];

    Tree T;

    void build() {

        T.tot = ;

        T.rt[] = T.build(, n);

        for (int i = ; i <= n; ++i) T.rt[i] = T.update(T.rt[i-], , n, Sa[i]);

    }

    void init(char *buf, int len) { // 预处理，sa，rank，height

        n = len;

        for (int i = ; i < ; ++i) cntA[i] = ;

        for (int i = ; i <= n; ++i) cntA[(int)buf[i]]++;

        for (int i = ; i < ; ++i) cntA[i] += cntA[i-];

        for (int i = n; i >= ; --i) Sa[ cntA[(int)buf[i]]-- ] = i;

        Rank[ Sa[] ] = ;

        for (int i = ; i <= n; ++i) {

            Rank[Sa[i]] = Rank[Sa[i-]];

            if (buf[Sa[i]] != buf[Sa[i-]]) Rank[Sa[i]]++;

        }

        for (int l = ; Rank[Sa[n]] < n; l <<= ) {

            for (int i = ; i <= n; ++i) cntA[i] = ;

            for (int i = ; i <= n; ++i) cntB[i] = ;

            for (int i = ; i <= n; ++i) {

                cntA[ A[i] = Rank[i] ]++;

                cntB[ B[i] = (i + l <= n) ? Rank[i+l] : ]++;

            }

            for (int i = ; i <= n; ++i) cntB[i] += cntB[i-];

            for (int i = n; i >= ; --i) tsa[ cntB[B[i]]-- ] = i;

            for (int i = ; i <= n; ++i) cntA[i] += cntA[i-];

            for (int i = n; i >= ; --i) Sa[ cntA[A[tsa[i]]]-- ] = tsa[i];

            Rank[ Sa[] ] = ;

            for (int i = ; i <= n; ++i) {

                Rank[Sa[i]] = Rank[Sa[i-]];

                if (A[Sa[i]] != A[Sa[i-]] || B[Sa[i]] != B[Sa[i-]]) Rank[Sa[i]]++;

            }

        }

        for (int i = , j = ; i <= n; ++i) {

            if (j) --j;

            int tmp = Sa[Rank[i] - ];

            while (i + j <= n && tmp + j <= n && buf[i+j] == buf[tmp+j]) ++j;

            height[Rank[i]] = j;

        }

    }

    void st() {

        for (int i = ; i <= n; ++i) {

            dp[i][] = height[i];

        }

        for (int j = ; j <= log2(n); ++j) {

            for (int i = ; i + ( << j) -  <= n; ++i) {

                dp[i][j] = min(dp[i][j - ], dp[i + ( << (j - ))][j - ]);

            }

        }

    }

    int rmq(int l, int r) {

        if (l == r) return inf;

        l++;

        int len = r - l + ;

        int x = log2(len);

        return min(dp[l][x], dp[r - ( << x) + ][x]);

    }

    int findl(int pos, int len) {

        int l = , r = pos;

        while (l <= r) {

            int mid = (l + r) >> ;

            if (rmq(mid, pos) < len) l = mid + ;

            else r = mid - ;

        }

        return l;

    }

    int findr(int pos, int len) {

        int l = pos, r = n;

        while (l <= r) {

            int mid = (l + r) >> ;

            if (rmq(pos, mid) < len) r = mid - ;

            else l = mid + ;

        }

        return r;

    }

    int solve(int ql, int qr, int k) {

        int len = qr - ql + ;

        int pos = Rank[ql];

        int l = findl(pos, len);

        int r = findr(pos, len);

        if (r - l +  < k) return -;

        return T.query(T.rt[l-], T.rt[r], , n, k);

    }

}S;

int main()

{

    int T;

    scanf("%d",&T);

    while(T--)

    {

        int n,m;

        scanf("%d %d",&n,&m);

        scanf("%s",s+);

        S.init(s,strlen(s+));

        S.st();

        S.build();

        int l,r,k;

        for(int i=;i<m;i++)

        {

            scanf("%d %d %d",&l,&r,&k);

            printf("%d\n",S.solve(l,r,k));

        }

    }

    return ;

}

1006 Shuffle Card

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<queue>

#include<set>

#include<string>

#include<map>

#include<vector>

#include<ctime>

#include<stack>

#include<fstream>

#include<iomanip>

using namespace std;

#define mm(a,b) memset(a,b,sizeof(a))

typedef long long ll;

typedef unsigned long long ull;

const int maxn = 1e5+;

const int inf = 0x3f3f3f3f;

const int mod = ;

const double PI = acos(-1.0);

int a[maxn];

int b[maxn];

map<int,int> ma;

int main(){

    int n,m;

    scanf("%d %d",&n,&m);

    for(int i=;i<n;i++)

        scanf("%d",a+i);

    for(int i=;i<m;i++)

        scanf("%d",b+i);

    for(int i=m-;i>=;i--){

        if(ma[b[i]])

            b[i]=;

        else

            ma[b[i]]=;

    }

    int sum=;

    for(int i=m-;i>=;i--){

        if(b[i]!=){

            printf("%d ",b[i]);

            sum++;

        }

        if(sum==n)

            break;

    }

    if(sum!=n){

        for(int i=;i<n;i++){

            if(!ma[a[i]]){

                printf("%d ",a[i]);

                sum++;

            }

            if(sum==n)

                break;

        }

    }

    return ;

}

1007 Windows of CCPC

#pragma comment(linker, "/STACK:1024000000,1024000000")

#pragma GCC optimize(2)

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<queue>

#include<set>

#include<cmath>

#include<string>

#include<map>

#include<vector>

#include<ctime>

#include<stack>

using namespace std;

#define mm(a,b) memset(a,b,sizeof(a))

typedef long long ll;

const long long mod = 1e9+;

const int maxn = 2e5;

char mp[][];

int num[];

void init()

{

    num[]=;

    for(int i=;i<=;i++)

    {

        num[i]=num[i-]*;

    }

    mp[][]='C';

    mp[][]='C';

    mp[][]='P';

    mp[][]='C';

    for(int i=;i<=;i++)

    {

        for(int j=;j<=num[i];j++)

        {

            for(int k=;k<=num[i];k++)

            {

                if(j<=num[i-]&&k<=num[i-])

                    continue;

                if(k>num[i-]&&j<=num[i-])

                {

                    mp[j][k]=mp[j][k-num[i-]];

                }

                else if(j>num[i-]&&k>num[i-])

                {

                    mp[j][k]=mp[j-num[i-]][k-num[i-]];

                }

                else if(j>num[i-]&&k<=num[i-])

                {

                    if(mp[j-num[i-]][k]=='C')

                        mp[j][k]='P';

                    else mp[j][k]='C';

                }

            }

        }

    }

}

int main()

{

    init();

    int T;

    scanf("%d",&T);

    while(T--)

    {

        int k;

        scanf("%d",&k);

        for(int i=;i<=num[k];i++)

        {

            for(int j=;j<=num[k];j++)

            {

                printf("%c",mp[i][j]);

            }

            printf("\n");

        }

    }

//

    return ;

}

1008Fishing Master

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<queue>

#include<set>

#include<cmath>

#include<string>

#include<map>

#include<vector>

#include<ctime>

#include<stack>

using namespace std;

#define mm(a,b) memset(a,b,sizeof(a))

typedef long long ll;

const long long mod = 1e9 + ;

const int maxn = 1e6 + ;

int t, n, vis[maxn];

ll a[maxn], k;

struct node{

    int id;

    ll yu;

}extra[maxn];

bool cmp(node a,node b) {

    return a.yu>b.yu;

}

int main()

{

    ll ans = , cnt, sum;

    cin >> t;

    while (t--)

    {

        queue<ll>q;

        ans = ;

        cnt = ;

        sum = ;

        scanf("%d%lld", &n, &k);

        ans+=k;

        for (int i = ; i < n; ++i)

        {

            scanf("%lld", &a[i]);

            cnt+=a[i]/k;

            extra[i].id=i;

            extra[i].yu=a[i]%k;

            ans+=a[i];

        }

        if(cnt<n){

            sort(extra,extra+n,cmp);

            for(ll i=;i<=n-cnt-;i++){

                    ans+=k-extra[i].yu;

            }

        }

        printf("%lld\n",ans);

    }

}

【赛后总结+部分题解】2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛的更多相关文章

[BFS,A*,k短路径] 2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛 path (Problem - 6705)
题目:http://acm.hdu.edu.cn/showproblem.php?pid=6705 path Time Limit: 2000/2000 MS (Java/Others) Mem ...
[贪心,dp] 2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛 Fishing Master (Problem - 6709)
题目:http://acm.hdu.edu.cn/showproblem.php?pid=6709 Fishing Master Time Limit: 2000/1000 MS (Java/Othe ...
2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛（8/11）
$$2019中国大学生程序设计竞赛(CCPC)\ -\ 网络选拔赛$$ $A.\hat{} \& \hat{}$ 签到,只把AB都有的位给异或掉 //#pragma comment(lin ...
2019中国大学生程序设计竞赛-女生专场（重现赛）部分题解C-Function(贪心+优先队列) H-clock(模拟)
Function 题目链接 Problem Description wls 有 n 个二次函数 Fi(x) = aix2 + bix + ci (1 ≤ i ≤ n). 现在他想在∑ni=1xi = ...
2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛
传送门 A.^&^ 题意: 找到最小的正数$C$,满足$(A\ xor\ C)\&(B\ xor \ C)$最小. 思路: 输出$A\&B$即可,特判答案为0的情况 ...
【2019中国大学生程序设计竞赛-女生专场】C - Function
原题韦神提供的思路orz 首先一个显然的性质,所有的c可以提出来,方程变成ax^2+bx的形式因为x的值是离散的,而m的值又不大所以一开始让x都为1(注意!x是正整数),然后每次挑一个x让他加一 ...
2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛 A题
A - ^&^ Bit operation is a common computing method in computer science ,Now we have two positive ...
2016中国大学生程序设计竞赛 - 网络选拔赛 C. Magic boy Bi Luo with his excited tree
Magic boy Bi Luo with his excited tree Problem Description Bi Luo is a magic boy, he also has a migi ...
2016年中国大学生程序设计竞赛（合肥）-重现赛1001 HDU 5961
传递 Time Limit: 12000/6000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)Total Submiss ...

随机推荐

ansible-yum
#yum 需要在vim /etc/ansible/hosts里面给执行的主机配置远程调用python的路径不知道为什么默认值认识python2.6.6 vim /etc/ansible/hosts ...
用python twilio模块实现发手机短信的功能
前排提示:这个模块不是用于对陌生人进行短信轰炸和电话骚扰的,这个模块也没有这个功能,如果是抱着这个心态来的,可以关闭网页了语言:python 步骤一:安装twilio模块 pip install t ...
2019前端面试系列——HTTP、浏览器面试题
浏览器存储的方式有哪些特性 cookie localStorage sessionStorage indexedDB 数据生命周期一般由服务器生成,可以设置过期时间除非被清理,否则一直存在页面 ...
深入理解JVM-类加载器深入解析(3)
深入理解JVM-类加载器深入解析(3) 获得ClassLoader的途径获得当前类的ClassLoader clazz.getClassLoader() 获得当前线程上下文的ClassLoader ...
C#连接SQL Anywhere 12 数据库
using System;using System.Data.Common; namespace ConsoleApplication27{ class Program { ...
19 个 JavaScript 编码小技巧
这篇文章适合任何一位基于JavaScript开发的开发者.我写这篇文章主要涉及JavaScript中一些简写的代码,帮助大家更好理解一些JavaScript的基础.希望这些代码能从不同的角度帮助你更好 ...
防止sql注入：替换危险字符
在用户名或者密码框中输入“11‘ or ’1‘ = '1”时,生成的sql语句将为“selec * from userInfo where name = '11' or '1' = '1' and p ...
C#之BackgroundWorker从简单入门到深入精通的用法总结
需求分析经常用到的耗时操作,例如: 1.文件下载和上载(包括点对点应用程序传输文件,从网络下载文件.图像等)2.数据库事务(从数据库读到大量的数据到WinForm界面中的DataGridview里呈 ...
Shiro权限注解原理
概述前不久刚学会使用权限注解(),开始思索了一番.最开始猜测实现方式是注解@Aspect,具体实现方式类似如下所示(切面记录审计日志).后来发现并非如此,所以特地分析一下源码. @Component ...
Groovy语法基础
Groovy 简介 Groovy 是一种基于 JVM 的动态语言,他的语法和 Java 相似,最终也是要编译 .class 在JVM上运行. Groovy 完全兼容 Java 并且在此基础上添加了很多 ...

【赛后总结+部分题解】2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛

分析

【赛后总结+部分题解】2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛的更多相关文章

随机推荐

热门专题