noip模拟题 小奇2 by hzwer[DP][路径压缩][分类讨论][位运算]

最新推荐文章于 2017-10-17 18:57:51 发布
最新推荐文章于 2017-10-17 18:57:51 发布
阅读量585 收藏 1
点赞数 1
分类专栏： 模拟题 DP 路径压缩 分类讨论 位运算 文章标签： noip noip模拟题 位运算 DP 路径压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SindarDawn/article/details/52948818
版权
模拟题 同时被 3 个专栏收录
25 篇文章 0 订阅
订阅专栏
DP
19 篇文章 0 订阅
订阅专栏
分类讨论
2 篇文章 0 订阅
订阅专栏

这么颓下去，迟早要完。

这套题只考了2h,感觉还不错，T2做过类似的所以A了，T1和T3基本上也没什么大问题，关键就是要深入挖掘问题特质，学会分类讨论（很多题都可以剪掉大量的枝，比如T1,小奇1的T3,noip2015 day1 T3,都是需要有这种分类意识的。
T1：
题意：在坐标轴上有一些点有收益，问从0开始，每次只能向前跳4（0+4=4）步或7（0+7=7）步，最大收益是。
数据范围：
对于20%的数据n=1，m<=10^5
对于40%的数据n<=15，m<=10^5
对于60%的数据m<=10^5
对于100%的数据n<=10^5，m<=10^9，1<=ai<=10^4，1<=bi<=m
分析：
感觉这道题是数据分斥（还是什么，不知道叫什么）的典型例子，黄学长这两套题出的还是不错的。
20%n=1，只用看能不能去就行了。
60%的数据，m比较小，可以f[i]表示i这个位置的最大值，那么然后去找-4，-7的最大值就可以了。
100%，经过分析发现，>=18的情况是一定可以走到的！那么就可以18以内用数组存能不能走，18以外都可以走，在走的时候更新18以内的最大值就可以了！
下面是碎碎念可以不看：
关键就是发现>=18的那个性质，这个要求我们多手算找规律啊。
按理说发现>=18以后一百分算法应该顺理成章不过我居然没发现，还是没养成这种意识。
而且考这套题的时候太zz了，因为我的算法应该是40分，我想了很久后面那20分怎么拿，结果拿到解题报告才想起来，枚举m的话时间复杂度线性……

60分程序：

#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 long long ll
#define inf 2e8
#define modd 1e9+7
#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 each(i,n) for(int i=1;i<=n;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 "mining"
//for(int i=1;i<=n;i++)
//(double) (ll) LL (int)
//(double)clock()/CLOCKS_PER_SEC
using namespace std;
const int Maxn=1e5+5;
int n,m,ans,f[Maxn];
struct node
{
    int a,b;
}a[Maxn];
bool cmp(node x,node y)
{
    return x.a<y.a;
}
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()
{
    n=read();m=read();
    each(i,n){
        a[i].b=read();
        a[i].a=read();
    }
    sort(a+1,a+n+1,cmp);
}
int boo[20]={1,0,0,0,1,0,0,1,1,0,0,1,1,0,1,1,1,0,1,1};
int check(int cur,int pre)
{
    if(cur-pre>=18)return 1;
    return boo[cur-pre];
}
void work()
{
    for(int i=1;i<=n;i++){
        int j=i-1;int flg=1;
        for(;j>=0;j--)if(check(a[i].a,a[j].a))
        f[i]=max(f[j]+a[i].b,f[i]);
        ans=max(ans,f[i]);
    }
    printf("%d",ans);
}
void debug()
{
    //
}
int main()
{
    freopen("hop.in","r",stdin);
    freopen("hop.out","w",stdout);
    init();
    work();
    //debug();
    return 0;
}

100分：

#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 long long ll
#define inf 2e8
#define modd 1e9+7
#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 each(i,n) for(int i=1;i<=n;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 "mining"
//for(int i=1;i<=n;i++)
//(double) (ll) LL (int)
//(double)clock()/CLOCKS_PER_SEC
using namespace std;
const int Maxn=1e5+5;
int n,m,ans,maxn,f[Maxn];
struct node
{
    int a,b;
}a[Maxn];
bool cmp(node x,node y)
{
    return x.a<y.a;
}
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()
{
    n=read();m=read();
    each(i,n){
        a[i].b=read();
        a[i].a=read();
    }
    sort(a+1,a+n+1,cmp);
}
int boo[20]={1,0,0,0,1,0,0,1,1,0,0,1,1,0,1,1,1,0,1,1};
int check(int cur,int pre)
{
    if(cur-pre>=18)return 1;
    return boo[cur-pre];
}
void work()
{
    for(int i=1;i<=n;i++){
        int j=i-1;
        for(;j>=max(0,i-17);j--)if(check(a[i].a,a[j].a))f[i]=max(f[j]+a[i].b,f[i]);
        if(i>18)maxn=max(maxn,f[i-18]);
        if(check(a[i].a,0))f[i]=max(f[i],maxn+a[i].b);
        ans=max(ans,f[i]);
    }
    printf("%d",ans);
}
void debug()
{
    //
}
int main()
{
    freopen("hop.in","r",stdin);
    freopen("hop.out","w",stdout);
    init();
    work();
    //debug();
    return 0;
}

T2:
题意：从带权矩阵左上角走到右下角（只能向下或向右走），求 (n+m−1)∗Σn+m−1i=1(Ai−Aavg)2 的最小值.
分析：首先呢我们可以证明对于一个序列，若平均值错误，V值一定更小（具体怎么证？考虑一个长度为2的序列，把它拆开，看一下，这不是均值不等式吗）。
然后，你看这权值范围<=30，一看就可以做奇怪的事。根据最小精度枚举平均值情况就可以了。

#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 long long ll
#define inf 2e8
#define modd 1e9+7
#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 each(i,n) for(int i=1,i<=n;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 ""
//for(int i=1;i<=n;i++)
//(double) (ll) LL (int)
//(double)clock()/CLOCKS_PER_SEC
using namespace std;
const int Maxn=305;
int t,n,m,lim,limi,ans,a[Maxn][Maxn],f[Maxn][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()
{
   n=read();m=read();lim=n+m-1;
   for(int i=2;i<=n;i++)f[i][0]=inf;
   for(int j=2;j<=m;j++)f[0][j]=inf;
   for(int i=1;i<=n;i++)
       for(int j=1;j<=m;j++)
           a[i][j]=read()*lim;
   limi=lim*30;ans=2e9;
}
void work()
{
    for(int i=lim;i<=limi;i++){
        for(int j=1;j<=n;j++)
        for(int k=1;k<=m;k++)
            f[j][k]=min(f[j][k-1],f[j-1][k])+(a[j][k]-i)*(a[j][k]-i);
        ans=min(ans,f[n][m]);
    }
    printf("%d\n",ans/lim);
}
void debug()
{
    //
}
int main()
{
    freopen("matrix.in","r",stdin);
    freopen("matrix.out","w",stdout);
    t=read();
    for(int i=1;i<=t;i++){
    init();
    work();
    }
    //debug();
    return 0;
}

T3:
题意：对于一棵树，对于每个点，求其他点到这个点的距离分别异或一值的和。
分析：
其实吧，多法图你就会发现，这个东西，其实可以通过统计最后几位的01来解决。具体的实现就是，用处理0那种情况（也就是两次dfs记两个数组）的方法，再同时处理个01就可以了，然而我当初太天真，写了个暴力。
碎碎念：多fa图。
暴力：（好像m!=0处理有错WA了一组，求大神指点。）

#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 inf 2e8
#define modd 1e9+7
#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 each(i,n) for(int i=1;i<=n;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 ""
//for(int i=1;i<=n;i++)
//(double) (ll) LL (int)
//(double)clock()/CLOCKS_PER_SEC
using namespace std;
const int Maxn=1e5+5;
int n,m,a,b,ans,roa[Maxn],g[Maxn],son[Maxn];
int f[Maxn],fr[Maxn],tov[2*Maxn],des[2*Maxn],wor[2*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 addedge(int cur)
{
    a=read();b=read();wor[2*cur]=wor[2*cur-1]=read();
    tov[2*cur-1]=fr[a];fr[a]=2*cur-1;des[2*cur-1]=b;
    tov[2*cur]=fr[b];fr[b]=2*cur;des[2*cur]=a;
}
void dfs(int u,int fath,long long dis)
{
    if(dis)ans+=dis^m;
    for(int i=fr[u];i;i=tov[i])
        if(des[i]!=fath)
        dfs(des[i],u,dis+(long long)wor[i]);
}
void dfs2(int u,int fath)
{
    for(int i=fr[u];i;i=tov[i])
    if(des[i]!=fath){
        dfs2(des[i],u);
        roa[des[i]]=wor[i];son[u]+=1+son[des[i]];
        f[u]+=f[des[i]]+wor[i]*(son[des[i]]+1);
    }
}
void dfs3(int u,int fath)
{
    g[u]=f[fath]-f[u]+g[fath]+roa[u]*(n-son[u]*2-2);
    for(int i=fr[u];i;i=tov[i])
    if(des[i]!=fath)
        dfs3(des[i],u);
}
void init()
{
   n=read();m=read();
   for(int i=1;i<n;i++)addedge(i);
}
void work()
{
    if(m)
    {
        for(int i=1;i<=n;i++){
            ans=0;dfs(i,0,0LL);
            printf("%d\n",ans);
        }
    }
    else{
        dfs2(1,0);
        f[0]=f[1];dfs3(1,0);
        for(int i=1;i<=n;i++)
            printf("%d\n",f[i]+g[i]);
    }
}
void debug()
{
    //
}
int main()
{
    freopen("tree1.in","r",stdin);
    freopen("tree1.out","w",stdout);
    init();
    work();
    //debug();
    return 0;
}
NOIP 模拟赛 nan （暴力？）
Hawo11的博客
07-07 471
分块打表
#NOIP模拟赛bzoj3449#大佬(期望好题)
ElaineZXY的博客
10-24 295
其实我根本就不懂得期望是什么，准确地说应该是不太熟悉，但是现在大致也知道是怎么算的了。 说说这道题，出题人的正解很成功被我们某些大佬给卡掉了，原因是还有更好的解法，可以把时间复杂度降得更低，现在来看真正的正解。 假设现在我们有一种完整的N道题难度的排列，设现在这种排列为i，然后有w[i][j]来表示这种排列下，第j - k + 1天到第j天的劳累值。 对于方案i，完成总书的劳
10-1NOIP模拟赛总结
BroDrinkWater的博客
10-01 352
T1看到题目吓到了,什么最大团,这不是NP难题吗,本蒟蒻怎么会做?于是第一波心理防线崩塌了,打了一波2n∗n22^n*n^2的暴力发现就不会了,于是继续往下做.打完其他题(实际上只有第二题)回来看,猜到是不是可以dp?于是我想到一个状态,i之后所有点构成的最大团的点数.那这个怎么转移呢?于是我把题目中带有绝对值的式子拆开,把x升序,于是发现如果把x+w在x-w的序列里二分查找的位置p<=枚举决策的位
NOIP模拟考栽阴沟了，惨痛爆零
蒟蒻的博客
10-17 900
先把今天的模拟考试题放出来：T1： 反思：我在考场秒想到这道题是单调队列，但因为我分类讨论了绝对值，并没有把距离绝对值当做滑动区间来看，分别讨论4种情况的单调性，md我真是阿库娅，然后还有一点写挂了，最坑的是卡空间，惨痛送分。T2： 反思：树形dp水题，秒想特殊的树形背包（物品重量都是1）的时间复杂度是n^2，但TMD又卡long long空间，想死的心都有了，惨痛丢分。T3： 反思：简单的区
jzoj 2016.5.14noip模拟赛C 总结
一位蒟蒻的小博客
05-14 1003
久违的noip模拟赛8:10先看第一题，dp想了一下复杂度太高，贪心的话八成会有反例8:20算了不纠结第一题了，先瞄一眼其他题 然后看第二题，咦矩形是什么？(懵了三秒，论智商的重要性) 矩形怎么判来着？(又懵三秒)8:21哦哦原来是送分题啊，那看第三题 嗯..觉得是先求每一行拿k个的最大价值，然后再去背包这nm个货物，使得其总数为m8:25那先设两维分别表示取到了左右的第几个吧，公式显然 f[
NOIP普及组模拟试题，有测试数据，有题解。T2
10-30
【NOIP普及组模拟试题详解】 全国青少年信息学奥林匹克联赛（National Olympiad in Informatics in Provinces，简称NOIP）是中国计算机学会举办的一项面向中学生的编程竞赛，旨在培养青少年的计算思维、逻辑推理和...
noip模拟题
07-21
【NOIP模拟题】是针对全国青少年信息学奥林匹克竞赛（National Olympiad in Informatics,简称NOI）的一类训练题目，通常包含完整的数据集、参考代码以及题解报告，为参赛者提供了实战演练的机会，帮助他们提升编程...
NOIP模拟题一套
05-16
【NOIP模拟题一套】 NOIP（全国青少年信息学奥林匹克联赛）是一项面向中学生的编程竞赛，旨在提升学生的计算机科学素养和编程能力。本压缩包包含了2017年NOIP的模拟试题，提供了完整的题面、测试数据、标准程序以及...
noip模拟题1
07-21
【标题】"NOIP模拟题1"涉及到的是全国青少年信息学奥林匹克联赛（NOIP）的模拟练习题目。NOIP是中国计算机学会举办的一项针对中学生的信息技术竞赛，旨在提高学生的计算机编程能力和逻辑思维能力。模拟题通常包含...
NOIP模拟试题
10-17
### NOIP模拟试题知识点解析 #### 最多因数 (T1) **题目描述：** 给定两个整数\(a\)和\(b\)(\(1 \leq a \leq b \leq 10^9\))，求区间\([a, b]\)内最大的“反素数”。反素数的定义是：对于任意正整数\(x\)，设其...
【集训】jzoj 2017.7.8 noip模拟赛A 总结
一位蒟蒻的小博客
07-08 353
今天估分180，实际得分145，不fst实际能得的分230. 7.8的比赛要注意： 0. 摆好蒟蒻心态 (好像达成了吧？) 1. 至少打完三题暴力再死磕一题！ （今天只有一题暴力要打..） 2. 首次思考时间控制在1h， 每一题都要保证至少思考20分钟，不要把容易拿的分丢掉了。这时候暴力应该已经想好了，打完所有有分的题之后再来继续想。（这个做到了，没有想法的第三题也想了
jzoj 2016.5.21noip模拟赛C 总结
一位蒟蒻的小博客
05-21 875
8:00开始读题 第一题.. 判一下距离，应该直接暴力枚举0.01的精度就可以了 第二题.. 一个图论，没什么想法.. 第三题.. 咦好熟悉，不是gdkoi的魔卡少女！？ 然后开始推xor的部分.. 20min后，呀9:00了，还没推出来.先看下一题吧 第四题.. 仙人掌？ 。。 好像AB部分很好做的样子，90分应该没问题的，但是还是一道码农题..呀九点了，开始码吧第一题15
【集训】jzoj 2017.7.14 noip模拟赛A 总结
一位蒟蒻的小博客
07-14 306
7.14的比赛要注意： 0. 摆好蒟蒻心态，不要自以为是。 1. 先打暴力再打正解，有助于思考与查错。 2. 首次思考时间控制在1h， 每一题都要保证至少思考20分钟。 不能在最后没事干了才想没想过的题目 2.1. 先把所有题都看一遍再思考，把握一下时间。 3. 记得多根据数据范围与问题想一下学过的算法。 第一题十分简单，有两种做法。 如果一个区间[l,r]他已经存满
noip模拟题10
05-01
【标题】"noip模拟题10"是一个与全国青少年信息学奥林匹克竞赛（NOIP）相关的练习题目集，其中包含了第10套模拟试题。这个标题暗示了这组题目是为准备参加NOIP的学生或者爱好者设计的，目的是帮助他们熟悉比赛的题型...
noip模拟题2
03-26
noip模拟题（有数据，有代码，有题解报告）
NOIP模拟题 [模拟][DP][线段树]
NULL
11-10 1530
抽象题目所求性质。 熟练模板。T1: 题意： 把一序列重复，求一区间内某字符出现次数。 分析： 显然把超出该区间长度的直接乘法算就行了，注意一下并区间，区间从1开始导致len取不到的问题处理。思路很简单，但可能会被包装在比较难的题里面。解锁新错误：读入优化没开longlong 不知道什么时候才能把这些傻逼错集齐。#include<iostream> #include<cstdio> #i
NOIP模拟题 [模拟][递推][平衡规划]
NULL
11-16 1057
在写暴力的时候也不要放过发现的每一个题目特点，这可能就是正解的关键。T1: 题意： 求给定一个序列最大公约数为1的最长长度； 分析： 傻逼题，害我读了几次题。#include<cstdio> #include<iostream> #include<cmath> #include<cstdlib> #include<cstring> #include<string> #include<algo
NOIP模拟题[二分][树规][倍增][双向链表]
NULL
10-19 1053
感觉自己的弱点在代码实现上面，就是知道怎么写但写要很久而且易错难调，解决措施： 1.敲键盘之前要画好流程图，想好一共需要几个函数，函数的功能以及要怎么实现，需要用到哪些库函数哪些数据结构等等，思路要清晰，思路清不清晰看程序就知道。 2.如果是改程序，就先理清楚标程是怎么实现的，基本上按照标程写，把握标程好的代码特色。 3.如果是调试，就在每一步理清楚程序的数学本质，如果还调不好就: 1
NOIP模拟题[贪心][离散化][LIS]
NULL
11-06 1023
思考深入再深入！ 小心MLE（躺 T1: 题意： 有n个怪物,生命值分别是hi,你有M魔法值，魔法值可用来使某一怪物失去2点生命值或所有怪物失去1生命值。每一轮你可以选择是否用魔法值（若不用则使一怪物失1血），在你做出选择后，所有生命值严格大于一的怪物会分别使你失去1生命值，求怎样决策能使得你失去的生命值最少。 分析： 首先，肯定优先攻击生命值低的怪物，因为这样绝不会使你被攻击的次数增多
NOIP模拟题 [构造][贪心][暴力]
NULL
11-08 956
从以往犯的错上汲取经验。 注意循环,if的嵌套以及break等地方。 训练暴力能力。 如果要修改一个地方一定注意看一下有没有忘了的东西！还有复制黏贴也是一样。T1: 题意： 给定一些字符串，可对字符串的长度为偶数的前缀进行反转操作，相同则消除，求最后剩下多少。 分析： 先考虑把后面的匹配，则只要把某两个看作一块，只要还有一个相同且没有被配对的块，就一定可以被翻到最前面且调换方向，然后翻
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值