NOIP模拟题 [递推][优化][dp][线段树][离散]

最新推荐文章于 2021-11-23 01:47:20 发布
最新推荐文章于 2021-11-23 01:47:20 发布
阅读量877 收藏 1
点赞数
分类专栏： 模拟题 DP 递推 离散化 线段树 文章标签： NOIP模拟 递推 DP 线段树 离散
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SindarDawn/article/details/53160904
版权
模拟题 同时被 3 个专栏收录
25 篇文章 0 订阅
订阅专栏
DP
19 篇文章 0 订阅
订阅专栏
递推
5 篇文章 0 订阅
订阅专栏

稳啊稳啊。对拍大法好。
不过最开始看题的时候要记住评估一下正解难度和暴力难度，T3明明可以搞60分的，可惜了。
还有就是，写程序之前一定要想清楚！处理好特殊情况，确保算法在实现过程中的正确性！对拍出错再来改代价太大！

T1:
题意：
对一个给定字符串进行多次复制黏贴操作，求最后得到字符串的前n位，若字符串过长，只保留前m位。
分析：
看了下m的大小，觉得非常酸爽。
因为如果正向处理的话，要么就要记下正处理的字符串，要么就，不对，必须存，因为存开头结尾的话可能会变。
所以考虑逆推，我们只需要用f[i]来存在当前情况的i这个位置在哪个位置。显然初始值为f[i]=i，然后只需要注意以下情况：
1.一串字母插入到前面：减去插入长度；
2.正好在这串字母插入后的区间内：变为该串字母中对应位置上字母的位置。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<ctime>
#define ll long long 
#define inf 2e8
#define clr(x) memset(x,0,sizeof(x))
#define maxen(x) memset(x,127,sizeof(x))
#define maxer(x) memset(x,31,sizeof(x))
#define minus(x) memset(x,-1,sizeof(x))
#define each(i,n,m) for(int i=n;i<m;i++)
#define eachrev(i,n,m) for(int i=n;i>m;i--)
#define minn(a,b,c) min(a,min(b,c))
#define maxx(a,b,c) max(a,max(b,c))
#ifdef WIN32
#define lld "%I64d"
#else
#define lld "%lld"
#endif
#define PROC "A"
//for(int i=1;i<=n;i++)
//(double) (ll) LL (int)
//(double)clock()/CLOCKS_PER_SEC
using namespace std;
const int Maxn=3e5+5;
const int modd=1e9+7;
int res[Maxn];
int n,kkk,m,a[Maxn],b[Maxn],c[Maxn];
char ini[Maxn];
int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void init()
{
    kkk=read();m=read();
    cin.getline(ini+1,Maxn);
    n=read();
    for(int i=1;i<=n;i++){
        a[i]=read()+1;b[i]=read();c[i]=read()+1;
    }
    for(int i=1;i<=kkk;i++)
    res[i]=i;
}
void work()
{
    for(int i=n;i>=1;i--){
        for(int j=1;j<=kkk;j++)
            if(res[j]>=c[i]&&res[j]<=c[i]+b[i]-a[i])
                res[j]=a[i]+res[j]-c[i];
            else if(res[j]>c[i]+b[i]-a[i])res[j]-=b[i]-a[i]+1;
        /*if(c[i]<=kkk){
            b[i]=min(b[i],kkk-c[i]+1+a[i]);
            for(int j=1;j<=b[i]-a[i];j++){
                int tmp=res[c[i]+j-1];
                for(int k=c[i]+j;k<=kkk;k++)
                swap(res[k],tmp);
            }
            for(int j=c[i];j<=c[i]+b[i]-a[i];j++)
                res[j]=j-c[i]+a[i];
        }*/
    }
    for(int i=1;i<=kkk;i++)
        printf("%c",ini[res[i]]);
        //减到负数，未填完 
}
void debug()
{
    //
}
void work1()
{
    char ovo[Maxn];
    for(int i=1;i<=n;i++){
    for(int j=1;j<=m;j++)
    ini[j]=res[j];
        a[i]=read()+1;b[i]=read();c[i]=read()+1;
        for(int j=b[i];j>=a[i];j--){
        char tmp=ini[j];
        for(int k=c[i];k<=m;k++)
        swap(tmp,res[k]);
    }
    }
     for(int i=1;i<=kkk;i++)
    printf("%c",res[i]);
}
int main()
{
    freopen(PROC".in","r",stdin);
    freopen(PROC".out","w",stdout);
    init();
    if(n<=2000&&m<=2000)
    work1();
    else 
    work();
    //debug();
    return 0;
}

T2:
题意：
给定一个序列和一个标准序列（为一个递归序列，每次在前面加上同样长度的某字母），求最少改变几个，可以使这个序列从某个地方开始遍历一次恰好为标准序列。
分析：
根据该序列的定义可以知道，会有很长的一个区间字母相同，此时若用暴力一个枚举开始一个统计不同会重复做很多操作，所以只需要枚举某区间结尾的那个数:
若该字母之前匹配，后来不匹配，答案为之前答案加一。
若该字母之前不匹配，之后匹配，答案为之前答案减一。
然后这里就体现了准确的变量定义的重要性：
保存之前是否匹配用一个数组，这个数组只能对应读入序列，因为标准序列的对应一直在变，内部不更新。
然后因为最后一个无论怎样都满足，所以要考虑对used数组的传递。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<ctime>
#define ll long long 
#define inf 2e8
#define clr(x) memset(x,0,sizeof(x))
#define maxen(x) memset(x,127,sizeof(x))
#define maxer(x) memset(x,31,sizeof(x))
#define minus(x) memset(x,-1,sizeof(x))
#define each(i,n,m) for(int i=n;i<m;i++)
#define eachrev(i,n,m) for(int i=n;i>m;i--)
#define minn(a,b,c) min(a,min(b,c))
#define maxx(a,b,c) max(a,max(b,c))
#ifdef WIN32
#define lld "%I64d"
#else
#define lld "%lld"
#endif
#define PROC "B"
//for(int i=1;i<=n;i++)
//(double) (ll) LL (int)
//(double)clock()/CLOCKS_PER_SEC
using namespace std;
const int Maxn=(1<<21)+5;
const int modd=1e9+7;
int k,lim,cur,mini,cur2,ans[Maxn],used[Maxn];
char a[Maxn],stdd[Maxn];
int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void init()
{
    k=read();lim=(1<<(2*k));
    cin.getline(a+1,Maxn);
    for(int i=k-1;i>=0;i--)
        for(int j=1;j<=3;j++)
            for(int z=1;z<=(1<<(2*i));z++){
                cur++;
                stdd[cur]=(j==1?'J':(j==2?'O':'I'));
             }
}
void calc(int nowy)
{
    cur=nowy-1;cur2=0;
    for(int i=k-1;i>=0;i--)
        for(int j=1;j<=3;j++){
            cur+=(1<<(2*i));
            cur2+=(1<<(2*i));
            if(cur>lim)cur%=lim;
            if(a[cur]!=stdd[cur2]&&(!used[cur])){
                ans[nowy]++;used[cur]=1;
            }
            else if(a[cur]==stdd[cur2]&&used[cur]){
                used[cur]=0;ans[nowy]--;}
        }
    cur++;
    if(cur>lim)cur%=lim;
    used[cur]=used[nowy];
    ans[nowy]+=ans[nowy-1];
    mini=min(mini,ans[nowy]);
}
void work()
{
    for(int i=1;i<lim;i++)
    if(a[i]!=stdd[i]){
        ans[1]++;used[i]=1;}
    mini=ans[1];used[lim]=used[1];
    for(int i=2;i<=lim;i++)
        calc(i);
    printf("%d",mini);
}
void debug()
{
    //
}
int main()
{
    freopen(PROC".in","r",stdin);
    freopen(PROC".out","w",stdout);
    init();
    work();
    //debug();
    return 0;
}

T3:
题意：
给你一个序列
你可以删除序列中的数，当然，有代价
删除之后统计，你此次删除的得分为序列得分减去删除数的代价
序列得分定义为：
被删除后，所有“左边或右边没有比它大的数”的数的得分和
然后让你删除，求最大得分

分析：
首先，n^2的算法很好想吧。
然后我们要考虑优化，因为这道题一看最后就要带log，优先考虑线段树。然后我们要把之前的DP式变得可以优化，也就是说，避开和正在枚举的数相关的量。
所以就可以把DP变成：
f[i]=max(f[j]+sigma cost[k])也就是从j推过来，拔掉j,k之间比它们大的。
此处f在i为从左向右最高时的收益。再从右向左来一次就可以了。
具体实现：
线段树维护最大值，f很简单，关键是sigma c。我们可以把所有比它小的数都直接加上代价c，因为如果有比它小又可能被取到的数被误减了，则这个数一定会比那个被误减的数更优！
这种思路比较有用，要记住，随时注意最优解的取得条件和排除条件。

需要注意：离散的时候，因为高度相等也可以选，离散后值要相等，且找最大也要包括自己。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<ctime>
#define ll long long 
#define inf 2e8
#define clr(x) memset(x,0,sizeof(x))
#define maxen(x) memset(x,127,sizeof(x))
#define maxer(x) memset(x,31,sizeof(x))
#define minus(x) memset(x,-1,sizeof(x))
#define each(i,n,m) for(int i=n;i<m;i++)
#define eachrev(i,n,m) for(int i=n;i>m;i--)
#define minn(a,b,c) min(a,min(b,c))
#define maxx(a,b,c) max(a,max(b,c))
#ifdef WIN32
#define lld "%I64d"
#else
#define lld "%lld"
#endif
#define PROC "C"
//for(int i=1;i<=n;i++)
//(double) (ll) LL (int)
//(double)clock()/CLOCKS_PER_SEC
using namespace std;
const int Maxn=1e5+5;
const int modd=1e9+7;
ll ans;
struct node
{
    ll h,b,c,lf,rf;
    int num,pos; 
}a[Maxn];
struct node2
{
    int lef,rig;
    ll maxn[2];
    ll bj[2];
}tre[Maxn<<2];
int n;
int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
bool cmp(node x,node y)
{
    return x.h<y.h;
}
bool cmp2(node x,node y)
{
    return x.num<y.num;
}
void build(int u,int lef,int rig)
{
    tre[u].lef=lef;
    tre[u].rig=rig;
    if(lef==rig)return;
    int mid=(lef+rig)>>1;
    build(2*u,lef,mid);
    build(2*u+1,mid+1,rig);
}
void init()
{
    n=read();
    for(int i=1;i<=n;i++){
        a[i].h=(ll)read();a[i].b=(ll)read();
        a[i].c=(ll)read();a[i].num=i;
    }
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=n;i++)
        a[i].pos=i;
    sort(a+1,a+n+1,cmp2);
    build(1,0,n+1);
}
void pushdown(int u,int pd)
{
    if(tre[u].lef==tre[u].rig)return;
    tre[2*u].maxn[pd]+=tre[u].bj[pd];
    tre[2*u+1].maxn[pd]+=tre[u].bj[pd];
    tre[2*u].bj[pd]+=tre[u].bj[pd];
    tre[2*u+1].bj[pd]+=tre[u].bj[pd];
    tre[u].bj[pd]=0;
}
ll query(int u,int lef,int rig,int pd)
{
    if(tre[u].lef==lef&&tre[u].rig==rig)
        return tre[u].maxn[pd];
    if(tre[u].bj[pd])pushdown(u,pd);
    tre[u].maxn[pd]=max(tre[2*u].maxn[pd],tre[2*u+1].maxn[pd]);
    int mid=(tre[u].lef+tre[u].rig)>>1;
    if(rig<=mid)return query(2*u,lef,rig,pd);
    else if(lef>mid)return query(2*u+1,lef,rig,pd);
    return max(query(2*u,lef,mid,pd),query(2*u+1,mid+1,rig,pd));
}
void update(int u,int lef,int rig,int val,int pd)
{
    if(tre[u].lef==lef&&tre[u].rig==rig){
        tre[u].maxn[pd]+=val;
        tre[u].bj[pd]+=val;
        return;}
    if(tre[u].bj[pd])pushdown(u,pd);
    int mid=(tre[u].lef+tre[u].rig)>>1;
    if(rig<=mid)update(2*u,lef,rig,val,pd);
    else if(lef>mid)update(2*u+1,lef,rig,val,pd);
    else{
    update(2*u,lef,mid,val,pd);
    update(2*u+1,mid+1,rig,val,pd);
    }
    tre[u].maxn[pd]=max(tre[2*u].maxn[pd],tre[2*u+1].maxn[pd]);
}
void update1(int u,int lef,int rig,int val,int pd)
{
    if(tre[u].bj[pd])pushdown(u,pd);
    if(tre[u].lef==lef&&tre[u].rig==rig){
        tre[u].maxn[pd]=val;
        return;}
    int mid=(tre[u].lef+tre[u].rig)>>1;
    if(rig<=mid)update1(2*u,lef,rig,val,pd);
    else if(lef>mid)update1(2*u+1,lef,rig,val,pd);
    else{
    update1(2*u,lef,mid,val,pd);
    update1(2*u+1,mid+1,rig,val,pd);
    }
    tre[u].maxn[pd]=max(tre[2*u].maxn[pd],tre[2*u+1].maxn[pd]);
}
void work()
{
    for(int i=1;i<=n;i++){
        a[i].lf=a[i].b+query(1,0,a[i].pos-1,0);
        update(1,0,a[i].pos-1,-a[i].c,0);
        update1(1,a[i].pos,a[i].pos,a[i].lf,0);
    }
    for(int i=n;i>=1;i--){
        a[i].rf=query(1,0,a[i].pos-1,1);
        update(1,0,a[i].pos-1,-a[i].c,1);
        update1(1,a[i].pos,a[i].pos,a[i].rf+a[i].b,1);
        query(1,3,3,1);
    }
    for(int i=1;i<=n;i++)
        ans=max(ans,a[i].lf+a[i].rf);
    printf(lld,ans);
}
void debug()
{
    //
}
int main()
{
    freopen(PROC".in","r",stdin);
    freopen(PROC".out","w",stdout);
    init();
    work();
    //debug();
    return 0;
}
SindarDawn
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOIP模拟试题
10-17
NOIP模拟试题
【noip2016模拟day1】【线段树】【dp】
Sue2333的博客
11-14 626
复制&粘贴2(A.c/cpp/pas/in/out) (Time Limit:1s Memory Limit:256MB) 【Description】 文本编辑器的一个最重要的机能就是复制&粘贴。JOI社现在正在开发一款能够非常高速地进行复制&粘贴的文本编辑器，作为JOI社一名优秀的程序猿，你担负起了复制&粘贴功能的测试这一核心工作。整个JOI社的命运都系在你的身上，因此你无
【题解】NOIP2021模拟赛
cqbzlydd的博客
07-19 1043
A. 状压 dp 。考虑到合并和分裂是互逆操作，所以只需要考虑合并操作。 trick: 将 b[i] 设置为 -b[i] ，题目转化为对一个序列，找到尽量多的和为 0 的集合。暴力转移是 O(3^(n+m)) ，我们考虑优化转移。 注意到 sum=0 时贡献加一，可以设计出如下转移方程 ： dp[i]=max(dp[j]+dp[i-j])+(sum==0),j \in i 时间复杂度 O((n+m)2^(n+m))。 实际优化并不大。 #include<bits/stdc++.h> #defin
NOIP2021 题解
liuzhangfeiabc的博客
11-23 1474
T1：两人轮流报数，规定所有含有 777 的数字及其倍数都不能报出，每次询问给出上一个报的数，求下一个报的数是多少（或判断上一个报的数不合法）。 询问次数 T≤2×105T \leq 2 \times10^5T≤2×105 ，数字范围 n≤107n \leq 10^7n≤107 。 题解：直接模拟题意即可。 从小到大处理出所有含有 777 的数，这可以通过一个递推关系来实现：设 f(n)f(n)f(n) 表示数字 nnn 中是否含有 777 ，则有 f(n)=f(n/10) ∣ (n%1
NOIP知识点大提纲
LORD_ZEUS的博客
10-10 553
基础算法  搜索与优化 一般的深搜不能满足题目要求。当题目一时没有头绪或者无从下手时不妨考虑搜索。剪 枝的原则:正确、高效。一般分为可行性剪枝和最优性剪枝。还可以使用记忆化搜索。 快速幂 复杂度 O(log n)。需要取模时基数和返回值都需要被取模。 二分查找 根据中值合法性缩小可行范围。O(log n)。  归并排序求逆序对 利用辅助数组排序。合并过程中可以求出逆序对的个数。复杂度 O...
NOIP模拟题一套
05-16
NOIP2017模拟题，带题面，数据，标程，题解。 难度与联赛相近，考点均在联赛范围内 NOIP2017模拟题，带题面，数据，标程，题解。 难度与联赛相近，考点均在联赛范围内
noip模拟题
07-21
noip模拟题（有数据，有代码，有题解报告）
noip模拟题1
07-21
noip模拟题（有数据，有代码，有题解报告）
noip模拟题10
05-01
noip模拟题（有数据，有代码，有题解报告）
NOIP模拟题 [模拟][DP][线段树]
NULL
11-10 1449
抽象题目所求性质。 熟练模板。T1: 题意： 把一序列重复，求一区间内某字符出现次数。 分析： 显然把超出该区间长度的直接乘法算就行了，注意一下并区间，区间从1开始导致len取不到的问题处理。思路很简单，但可能会被包装在比较难的题里面。解锁新错误：读入优化没开longlong 不知道什么时候才能把这些傻逼错集齐。#include<iostream> #include<cstdio> #i
NOIP模拟题 [模拟][递推][平衡规划]
NULL
11-16 1027
在写暴力的时候也不要放过发现的每一个题目特点，这可能就是正解的关键。T1: 题意： 求给定一个序列最大公约数为1的最长长度； 分析： 傻逼题，害我读了几次题。#include<cstdio> #include<iostream> #include<cmath> #include<cstdlib> #include<cstring> #include<string> #include<algo
NOIP模拟题[二分][树规][倍增][双向链表]
NULL
10-19 1021
感觉自己的弱点在代码实现上面，就是知道怎么写但写要很久而且易错难调，解决措施： 1.敲键盘之前要画好流程图，想好一共需要几个函数，函数的功能以及要怎么实现，需要用到哪些库函数哪些数据结构等等，思路要清晰，思路清不清晰看程序就知道。 2.如果是改程序，就先理清楚标程是怎么实现的，基本上按照标程写，把握标程好的代码特色。 3.如果是调试，就在每一步理清楚程序的数学本质，如果还调不好就: 1
NOIP模拟题[贪心][离散化][LIS]
NULL
11-06 944
思考深入再深入！ 小心MLE（躺 T1: 题意： 有n个怪物,生命值分别是hi,你有M魔法值，魔法值可用来使某一怪物失去2点生命值或所有怪物失去1生命值。每一轮你可以选择是否用魔法值（若不用则使一怪物失1血），在你做出选择后，所有生命值严格大于一的怪物会分别使你失去1生命值，求怎样决策能使得你失去的生命值最少。 分析： 首先，肯定优先攻击生命值低的怪物，因为这样绝不会使你被攻击的次数增多
NOIP模拟题 [构造][贪心][暴力]
NULL
11-08 924
从以往犯的错上汲取经验。 注意循环,if的嵌套以及break等地方。 训练暴力能力。 如果要修改一个地方一定注意看一下有没有忘了的东西！还有复制黏贴也是一样。T1: 题意： 给定一些字符串，可对字符串的长度为偶数的前缀进行反转操作，相同则消除，求最后剩下多少。 分析： 先考虑把后面的匹配，则只要把某两个看作一块，只要还有一个相同且没有被配对的块，就一定可以被翻到最前面且调换方向，然后翻
NOIP模拟题[数论}[暴力][拆点]
NULL
11-09 814
沉迷T3，不能自拔。 T1： 题意：求2的n次方modp，p为质数; 分析： 如果n小，就是快速幂。 如果n大，又是质数，就是费马小定理先把nmod了再直接暴力算。 有人写高精度快速幂，过了70，辛苦了。#include<cstdio> #include<iostream> #include<cmath> #include<cstdlib> #include<cstring> #incl
NOIP模拟题 [LIS][建图][递推][容斥]
NULL
11-15 790
正确评估题目难度。T1： 题意： 给定一棵树，求使得每一个节点的左子树任意值都比当前节点值小，右子树任意值都比当前节点大所需要的最小改动点数。 分析： 首先对于这种神奇的递归定义，我们通过传递大小关系可以发现，通过上推我们可以确定任意两点之间的大小关系，然后很容易想到把树上的点排序。 所以如果先忽略掉“严格递增”和“可能中间不能加数”，这道题显然可以直接贪心减去LIS。 那么这种算法会遇
NOIP模拟题 [DP][RMQ][分块]
NULL
10-29 789
要稳一点啊。 一定要对拍！ 然后就是加快写对拍的速度，给最后一道题多争取一点时间。 T1： 题意：给定n,k，对于1-n的所有排列，求出逆序对数为k的所有排列数。 分析：fa一fa图我们会发现，其实这里存在着一个状态转移，即对于当前位选出的数让后面增加几个逆序对（其实就是模拟自己生成满足一定条件的序列）。因为很容易证明前面的数列到底是什么并不重要，所以这道题只需要f[i][j]，i为还需要
XJOI NOIP模拟题2[数论][组合数][树规]
NULL
10-30 776
今天玩得有点嗨，嗯冷静冷静。 考试策略很重要，时间分配啊难度的选择啊对拍啊都很重要。建议还是看一遍题，像今天觉得T1好写结果不知不觉卡很久，T3其实是写过的水题就这么没了。该开始复习数论了不然药丸，组合数，逆元，拓展欧几里得，费马小定理，欧拉函数……T1: 题意： 给定n,k和两个字符串A,B，求与A相差字母个数为K的所有字符串按字典顺序排好后，B所在的位置。 分析： 若我们外层循环枚举光
noip 模拟题,数据下载
最新发布
08-13
在进行NOIP模拟题数据下载时，我们可以按照以下步骤进行操作： 1. 确认下载链接：NOIP官方会提供下载数据集的链接或者FTP地址，参赛者需要确认链接是否可用和正确。 2. 选择下载工具：根据自己的需求，参赛者可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值