EZ 2018 05 13 NOIP2018 模拟赛（十三）

最新推荐文章于 2024-07-12 16:35:20 发布
最新推荐文章于 2024-07-12 16:35:20 发布
阅读量53 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/cjjsb/p/9038047.html
版权

这次的比赛真心水，考时估分240，然后各种悠闲乱逛

然后测完T1数组开小了炸成40，T2，T3都没开long long，T2炸成20，T3爆0

掉回1600+的深渊，但是还有CJJ dalao比我更惨，链接

T1

这道题就比较simple了，很显然用数据结构乱优化

貌似有很多种解法：单调队列，堆，线段树等等

我主要就讲一下我考试的时候YY出来的线段树

首先我们发现一个性质：对于n次操作之后，序列就进入循环

然后我们只需要处理处前n次询问就可以O(n)处理了

我们开一个前缀和记录原串中1的个数，然后设一个数组f[i]表示i左边k的长度范围内（包括它自己）一共有几个1（不足k也允许）

然后我们发现将一个数从尾部移到最前面，有两种情况：

  • 如果这个数是0，那么只需要把它自己的f[i]修改成0即可

  • 如果这个数是1，那么只需要把它自己的f[i]就改成1，并且把队头的前k-1项的f[]值加1

然后我们之间把初始数组右移n个长度（前面的为循环做准备)，然后上线段树即可

然而我f数组忘记<<1了，而且那个字符串数组也看错了范围dog！！！

CODE

#include<cstdio>
#include<cstring>
using namespace std;
const int N=100005;
struct segtree
{
    int add,s;
}tree[N<<3];
int a[N],f[N<<1],sum[N],ans[N],n,k,q,tot;
char s[N<<1];
inline void read(int &x)
{
    x=0; char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
}
inline void write(int x)
{
    if (x/10) write(x/10);
    putchar(x%10+'0');
}
inline int max(int a,int b)
{
    return a>b?a:b;
}
inline void up(int root)
{
    tree[root].s=max(tree[root<<1].s,tree[root<<1|1].s);
}
inline void down(int root)
{
    if (tree[root].add)
    {
        tree[root<<1].add+=tree[root].add;
        tree[root<<1|1].add+=tree[root].add;
        tree[root<<1].s+=tree[root].add;
        tree[root<<1|1].s+=tree[root].add;
        tree[root].add=0;
    }
}
inline void build(int root,int l,int r)
{
    if (l==r)
    {
        tree[root].s=f[l];
        return;
    }
    int mid=l+r>>1;
    build(root<<1,l,mid); build(root<<1|1,mid+1,r);
    up(root);
}
inline void updata(int root,int l,int r,int id)
{
    if (l==r)
    {
        tree[root].s=0;
        return;
    }
    int mid=l+r>>1;
    down(root);
    if (id<=mid) updata(root<<1,l,mid,id); else updata(root<<1|1,mid+1,r,id);
    up(root);
}
inline void modify(int root,int l,int r,int beg,int end)
{
    if (l>=beg&&r<=end)
    {
        tree[root].s+=1; tree[root].add+=1;
        return;
    }
    int mid=l+r>>1;
    down(root);
    if (beg<=mid) modify(root<<1,l,mid,beg,end); 
    if (end>mid) modify(root<<1|1,mid+1,r,beg,end);
    up(root);
}
int main()
{
    //freopen("A.in","r",stdin); freopen("A.out","w",stdout);
    register int i; 
    read(n); read(k); read(q);
    for (i=1;i<=n;++i)
    {
        read(a[i]); sum[i]=sum[i-1]+a[i];
        if (i>=k) f[i+n]=sum[i]-sum[i-k]; else f[i+n]=sum[i];
    }
    build(1,1,n<<1);
    ans[0]=tree[1].s;
    for (i=1;i<=n;++i)
    {
        updata(1,1,n<<1,(n<<1)-i+1); 
        if (a[n-i+1]) modify(1,1,n<<1,n-i+1,n-i+k);
        ans[i]=tree[1].s;
    }
    for (scanf("%s",s+1),i=1;i<=q;++i)
    if (s[i]=='?') write(ans[tot]),putchar('\n'); else { if (++tot==n) tot=0; }
    return 0;
}

T2

这题意一看就是暴力数据结构，然而我没开long long

我们通过观察发现2操作满足一个很凶猛的性质：前面的操作不会影响后面的操作

因此我们可以从前往后推一下，对于所有的操作2，将它操作的区间中的所有操作的次数+=目前这个操作的次数（默认为1）

然后最后我们得到了所有操作的次数，然后对于操作1上线段树 or 树状数组+差分即可

线段树CODE

#include<cstdio>
using namespace std;
typedef long long LL;
const LL N=100005,mod=1e9+7;
struct time_segtree
{
    LL add[N<<2],sum[N<<2];
    inline void up(LL root)
    {
        sum[root]=(sum[root<<1]+sum[root<<1|1])%mod;
    }
    inline void down(LL root,LL l,LL r)
    {
        if (add[root])
        {
            add[root<<1]=(add[root<<1]+add[root])%mod;
            add[root<<1|1]=(add[root<<1|1]+add[root])%mod;
            sum[root<<1]=(sum[root<<1]+add[root]*l)%mod;
            sum[root<<1|1]=(sum[root<<1|1]+add[root]*r)%mod;
            add[root]=0;
        }
    }
    inline void modify(LL root,LL l,LL r,LL beg,LL end,LL k)
    {
        if (l>=beg&&r<=end)
        {
            sum[root]=(sum[root]+k*(r-l+1))%mod;
            add[root]=(add[root]+k)%mod;
            return;
        }
        LL mid=l+r>>1;
        down(root,mid-l+1,r-mid);
        if (beg<=mid) modify(root<<1,l,mid,beg,end,k); 
        if (end>mid) modify(root<<1|1,mid+1,r,beg,end,k);
        up(root);
    }
    inline LL query(LL root,LL l,LL r,LL id)
    {
        if (l==r) return sum[root];
        LL mid=l+r>>1;
        down(root,mid-l+1,r-mid);
        if (id<=mid) return query(root<<1,l,mid,id); else return query(root<<1|1,mid+1,r,id);
    }
}T;
struct ans_segtree
{
    LL add[N<<2],sum[N<<2];
    inline void up(LL root)
    {
        sum[root]=(sum[root<<1]+sum[root<<1|1])%mod;
    }
    inline void down(LL root,LL l,LL r)
    {
        if (add[root])
        {
            add[root<<1]=(add[root<<1]+add[root])%mod;
            add[root<<1|1]=(add[root<<1|1]+add[root])%mod;
            sum[root<<1]=(sum[root<<1]+add[root]*l)%mod;
            sum[root<<1|1]=(sum[root<<1|1]+add[root]*r)%mod;
            add[root]=0;
        }
    }
    inline void modify(LL root,LL l,LL r,LL beg,LL end,LL k)
    {
        if (l>=beg&&r<=end)
        {
            sum[root]=(sum[root]+k*(r-l+1))%mod;
            add[root]=(add[root]+k)%mod;
            return;
        }
        LL mid=l+r>>1;
        down(root,mid-l+1,r-mid);
        if (beg<=mid) modify(root<<1,l,mid,beg,end,k); 
        if (end>mid) modify(root<<1|1,mid+1,r,beg,end,k);
        up(root);
    }
    inline LL query(LL root,LL l,LL r,LL id)
    {
        if (l==r) return sum[root];
        LL mid=l+r>>1;
        down(root,mid-l+1,r-mid);
        if (id<=mid) return query(root<<1,l,mid,id); else return query(root<<1|1,mid+1,r,id);
    }
}A;
struct data
{
    LL opt,x,y;
}q[N];
LL n,m;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(LL &x)
{
    x=0; char ch=tc();
    while (ch<'0'||ch>'9') ch=tc();
    while (ch>='0'&&ch<='9') x=x*10+ch-'0',ch=tc();
}
inline void write(LL x)
{
    if (x/10) write(x/10);
    putchar(x%10+'0');
}
int main()
{
    //freopen("B.in","r",stdin); freopen("B.out","w",stdout);
    register LL i;
    read(n); read(m);
    for (i=1;i<=m;++i)
    read(q[i].opt),read(q[i].x),read(q[i].y);
    for (i=m;i>=1;--i)
    {
        T.modify(1,1,m,i,i,1); 
        if (q[i].opt==2) { LL x=T.query(1,1,m,i); T.modify(1,1,m,q[i].x,q[i].y,x); }
    }
    for (i=1;i<=m;++i)
    if (q[i].opt==1) { LL x=T.query(1,1,m,i); A.modify(1,1,n,q[i].x,q[i].y,x); }
    for (i=1;i<=n;++i)
    write(A.query(1,1,n,i)),putchar(' ');
    return 0;
}

T3

比较玄学的卢卡斯定理乱推

反正我对这种数学的东西没什么兴趣，还是打打暴力好了

这里的暴力也比较有技巧，我们搞一下每一个点第x天的权值，记录下来，因为既可以用来推后面的，也可以用来O(1)求答案

40ptsCODE

#include<cstdio>
#include<cstring>
using namespace std;
typedef long long LL;
const LL N=1005;
struct edge
{
    LL to,next;
}e[N<<1];
LL head[N],w[N][N],a[N],n,q,x,y,root,cnt,m;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(LL &x)
{
    x=0; char ch=tc();
    while (ch<'0'||ch>'9') ch=tc();
    while (ch>='0'&&ch<='9') x=x*10+ch-'0',ch=tc();
}
inline void write(LL x)
{
    if (x/10) write(x/10);
    putchar(x%10+'0');
}
inline void add(LL x,LL y)
{
    e[++cnt].to=y; e[cnt].next=head[x]; head[x]=cnt;
}
inline LL max(LL a,LL b)
{
    return a>b?a:b;
}
inline void DFS(LL now,LL fa)
{
    bool flag=1; register LL i,j;
    for (i=head[now];i!=-1;i=e[i].next)
    if (e[i].to!=fa)
    {
        flag=0;
        DFS(e[i].to,now);
    }
    if (flag) for (i=1;i<=m;++i) w[now][i]=w[now][0]; else
    {
        for (i=1;i<=m;++i)
        for (w[now][i]=w[now][i-1],j=head[now];j!=-1;j=e[j].next)
        if (e[j].to!=fa) w[now][i]^=w[e[j].to][i];
    }
}
int main()
{
    //freopen("C.in","r",stdin); freopen("C.out","w",stdout);
    register LL i;
    memset(head,-1,sizeof(head));
    memset(e,-1,sizeof(e));
    read(n); read(q);
    for (i=1;i<n;++i)
    read(x),read(y),add(x,y),add(y,x);
    for (i=0;i<n;++i)
    read(w[i][0]);
    for (i=1;i<=q;++i)
    read(a[i]),m=max(m,a[i]);
    DFS(root,-1);
    for (i=1;i<=q;++i)
    write(w[root][a[i]]),putchar('\n');
    return 0;
}

转载于:https://www.cnblogs.com/cjjsb/p/9038047.html

weixin_30526593
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
NOIP2018模拟卷(2.0).pdf
09-30
这份NOIP2018模拟卷（2.0）针对普及组，主要考察C++编程语言的基础知识以及信息学相关概念。试卷包含了多项选择题、问题求解和程序阅读理解等部分，旨在测试参赛者的逻辑思维、编程基础和问题解决能力。 1. C++中的...
Noip普及组模拟赛
10-20
【Noip普及组模拟赛】是一场针对编程竞赛的训练活动，主要面向准备参加Noip2016的参赛者。模拟赛旨在帮助参赛者熟悉比赛环境和题型，提高编程解决问题的能力。以下是对其中四道题目的详细解析： 1. **和睦时间** ...
EZ 2018 05 20 NOIP2018 模拟赛（十五）
weixin_30814223的博客
05-20 53
这次的比赛充满着玄学的气息，玄学链接 首先讲一下为什么没有第十四场 其实今天早上9点时看到题目就叫了：原题！ 没错，整套试卷都做过，我还写了题解 然后老叶就说换一套，但如果仅仅是这样就没什么 但等13min后结束这场考试后，一评测发现有人A了T1 但老叶并没有开启Unrated，然后大家集体垫底被踩 然后我就莫名掉了74Rating 但是之后第二场很快就开始了，但是等第二场测完之后还是没...
EZ 2018 05 04 NOIP2018 模拟赛（十二）
weixin_30664615的博客
05-07 87
这次的试卷应该是激励我们一下的，链接 然后大家的分数就都很高，然后我就210被一群秒A T2的240大佬爆踩 掉了5rating但Rank竟然发杀了 X_o_r dalao && YZC dalao 论写暴力的重要性 T1 真心水，直接DFS爆搜即可 O(2^n)不会超，n大了之后可以DP，签到题不解释 CODE #include<cstdio> using ...
EZ 2018 05 26 NOIP2018 模拟赛（十六）
weixin_30437847的博客
06-06 73
这次难道就是传说中的标准分大赛？而且这次比赛的链接不翼而飞了 一堆人153pts然后就有Rank4?看来这个Rank4不值钱了，才涨了50+的Rating。 不过还好最后5min的时候想出了T1正解，否则就会因为少10pts被爆踩了吧 好了开始讲题。 T1 这其实是水题，我们很容易想到DP： 令\(f_{i,j}\)表示前\(i\)个数中有i个数选择正数时的最小价值和，则有转移： \(f...
EZ 2018 04 13 NOIP2018 模拟赛（八）
weixin_30362233的博客
04-14 66
这次的题目都是什么鬼？ 玄学乱搞+肉眼看CODE+倒着搜索？ 好吧是我ZZ了 链接在此 T1 玄学乱搞 由于考场上写的部分分做法忘记讨论n<=2000时的情况，少得了30pts 很容易得到一个基于排序的算法： 记录每个数的值以及编号 按编号将原数组从大到小排序 对于每一个数，用在它之前的编号最大和最小的分别更新ans 对于这个算法的正确性显然。因为之前所有点的值都比它大，所以可...
2015重庆市NOIP模拟赛题目+数据
01-24
2015年10月4日重庆市NOIP模拟赛题目+数据 2015年10月4日重庆市NOIP模拟赛题目+数据 2015年10月4日重庆市NOIP模拟赛题目+数据 2015年10月4日重庆市NOIP模拟赛题目+数据
NOIP模拟赛 试题
07-15
此为NOIP模拟赛的试题。 共三题，时间2小时； 难度符合NOIP标准 （还是自己出的呢） 勘误： 1.A题 输入样例中两字符串无空格 2.C题 n是位置的个数，不是猫的个数
NOIP2018普及组&提高组官方测试数据
11-20
《NOIP2018普及组&提高组官方测试数据详解》 全国青少年信息学奥林匹克联赛（National Olympiad in Informatics in Provinces,简称NOIP）是中国计算机学会举办的一项面向中学生的计算机编程竞赛，旨在激发青少年对...
LCR 155. 将二叉搜索树转化为排序的双向链表
weixin_61067952的博客
07-09 264
中序遍历可以得到排序的序列，遍历时维护当前节点和前一个节点，改变左右指针。头节点设为null，遍历开始判断一下然后初始化。尾节点中序遍历时一直更新。
[高频 SQL 50 题(基础版)]第一千七百五十七题，可回收且低脂产品
weixin_45201305的博客
07-10 257
low_fats 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品是低脂产品，'N' 表示不是低脂产品。recyclable 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品可回收，而 'N' 表示不可回收。没什么难度，作为基础题五十题的第一题练手，现在也开始陆续写一些SQL，作为记录，和leetcode一起，大家都加油。编写解决方案找出既是低脂又是可回收的产品编号。是该表的主键（具有唯一值的列）。
Redis数据结构-String篇
最新发布
时间如瑾 代码如诗
07-12 512
对⼀个内部表示成long型的string执行append, setbit, getrange这些命令，针对的仍然是string的值（即⼗进制表示的字符串），而不是针对内部表⽰的long型进⾏操作。因此，在这些命令的实现中，会把long型先转成字符串再进行相应的操作。String 的内部存储结构⼀般是 sds（Simple Dynamic String，可以动态扩展内存），但是如果⼀个String 类型的 value 的值是数字，那么 Redis 内部会把它转成 long 类型来存储，从⽽减少内存的使用。
文章检查敏感词速度提升10倍+
陈海龙的格物之路
07-09 696
如何对文章进行高效的敏感词检查？
7.深度学习概述
MechMaster
07-10 930
1. 线性回归 1.1 线性回归一般表达式 1.2 线性回归内积表达方式： 1.3 多个样本时，线性回归的进一步表达： 1.4 线性回归方程的解析 1.5 线性回归就是求loss函数的最小值 2. 如何求函数最小值 2.1 一个例子 2.2 求导法——求最小值 2.3 求导法存在的问题 2.4 迭代法——求最小值 3. 代码实现 3.1 手动求函数最小值 3.2 使用pytorch求函数最小值
代码随想录算法训练营第33天
m0_62262158的博客
07-10 139
【代码】代码随想录算法训练营第33天。
如何在淘客返利系统中实现高效的搜索与推荐算法
微赚淘客开发者博客
07-08 1780
本文介绍了如何在淘客返利系统中实现高效的搜索与推荐算法，涵盖了倒排索引技术、搜索结果排序优化以及协同过滤、基于内容的推荐算法的实现方法和示例。通过合理选择和优化算法，可以显著提升系统的搜索效率和推荐精度，从而增强用户体验和平台的竞争力。微赚淘客系统3.0小编出品，必属精品，转载请注明出处！
Leetcode刷题——7 滑动窗口 双指针
as_your_heart的博客
07-09 182
注：以下代码均为c++
机器学习笔记：初始化0的问题
qq_40206371的博客
07-09 720
他们的损失函数都是交叉熵sigmoid函数的导数：他们能不能用0初始化呢？
2018年noip普及组模拟试题一
08-25
2018年的NOIP普及组模拟试题一是一道计算题，题目要求计算给定正整数N的所有约数的和。具体的解题思路如下： 首先，我们需要遍历从1到N的所有正整数，判断每个正整数是否是N的约数，如果是的话，我们将它们加入到一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值