T1 huajitree

纯模拟,把S拆成二进制查一下有多少个1,然后把这个数和N*M求一下gcd,除一下输出就好了。说求期望值可能对新高一不太友好….

 //huajitree
 //2016.8.22
 //by Cydiater
 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <queue>
 #include <map>
 #include <cstring>
 #include <string>
 #include <algorithm>
 #include <cmath>
 #include <ctime>
 #include <iomanip>
 using namespace std;
 #define FILE "huajitree"
 #define ll long long
 #define up(i,j,n)       for(int i=j;i<=n;i++)
 #define down(i,j,n)     for(int i=j;i>=n;i--)
 const int oo=0x3f3f3f3f;
 inline ll read(){
       ,f=;
       ;ch=getchar();}
       +ch-';ch=getchar();}
       return x*f;
 }
 ll S,ans=,N,M;
 namespace solution{
       inline ll gcd(ll a,ll b){?a:gcd(b,a%b);}
       void init(){
             N=read();M=read();S=read();
             ans=;
       }
       void slove(){
             ){ans+=S%;S/=;}
       }
       void output(){
             ll d=gcd(ans,N*M);
             )cout<<ans/d<<'/'<<N*M/d;
             ");
       }
 }
 int main(){
       freopen(FILE".in","r",stdin);
       freopen(FILE".out","w",stdout);
       using namespace solution;
       init();
       slove();
       output();
       ;
 }

T2 pack

起名叫pack是为了衔接剧情QAQ,60分裸的DP,会DP就应该会,如果学过DP这个的60分没写出来就应该考虑补一下DP了。

所有数据都是随机的..所以加上一些奇淫技巧也许能暴力A掉?

给出状态转移方程:

首先把h和v的前缀和都搞出来

 //NOIp by Cydiater right
 //by Cydiater
 //2016.8.24
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <algorithm>
 #include <queue>
 #include <map>
 #include <ctime>
 #include <cstdlib>
 #include <iomanip>
 #include <cmath>
 using namespace std;
 #define ll long long
 #define up(i,j,n)       for(int i=j;i<=n;i++)
 #define down(i,j,n)     for(int i=j;i>=n;i--)
 #define FILE "pack"
 ;
 const int oo=0x3f3f3f3f;
 inline ll read(){
       ,f=;
       ;ch=getchar();}
       +ch-';ch=getchar();}
       return x*f;
 }
 ll N,sum[MAXN],h[MAXN],q[MAXN],head,tail,f[MAXN];
 namespace solution{
       void init(){
             N=read();
             memset(sum,,sizeof(sum));
             memset(h,,sizeof(h));
             memset(f,,sizeof(f));
             up(i,,N){
                   sum[i]=sum[i-]+read();
                   h[i]=h[i-]+read();
             }
       }
       inline double col(int x,int y){
             double t1=f[y]-f[x];
             double t2=sum[y]-sum[x];
             return t1/t2;
       }
       void slove(){
             head=;tail=;q[++tail]=;
             up(i,,N){
                   ])<h[i])head++;
                   f[i]=f[q[head]]+(sum[i]-sum[q[head]])*h[i];
                   ],q[tail])>col(q[tail],i))tail--;
                   q[++tail]=i;
             }
       }
       void output(){
             cout<<f[N]<<endl;
       }
 }
 int main(){
       freopen(FILE".in","r",stdin);
       freopen(FILE".out","w",stdout);
       using namespace solution;
       init();
       slove();
       output();
       ;
 }

T3 block

我太弱啦出不了第三题,这是BZOJ上的一道题,所以说这个的题解你随便一搜成片的都是,我简单废话一下,本题所需要的数据结构就是线段树,简单的说就是用线段树维护连通性,高二的各位神犇你们说良心不良心呀。

怎么用线段树维护连通性呢?

反正我是用一个线段树里维护6个值,分别是

左上到左下的连通性

左上到右下的连通性

左上到右上的连通性

左下到右下的连通性

左下到右上的连通性

右上到右下的连通性

维护四个值好像也没什么问题,具体的自己思考

然后合并什么的就很好(ma)搞(fan)了

具体的实现可以参考我180行的代码,虽然写的很丑..

COGS上有一个神犇90行就解决了,你们也可以去看看他的代码

 //BZOJ 1018
 //by Cydiater
 //2016.8.24
 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
 #include <string>
 #include <ctime>
 #include <cmath>
 #include <queue>
 #include <map>
 #include <iomanip>
 #include <algorithm>
 using namespace std;
 #define FILE "block"
 #define ll long long
 #define up(i,j,n)       for(int i=j;i<=n;i++)
 #define down(i,j,n)     for(int i=j;i>=n;i--)
 ;
 const int oo=0x3f3f3f3f;
 inline int read(){
       ,f=;
       ;ch=getchar();}
       +ch-';ch=getchar();}
       return x*f;
 }
 struct Tree{
       bool luru;/*left up to right up*/
       bool ldrd;/*left down to right down*/
       bool lurd;/*left up to right down*/
       bool ldru;/*left down to right up*/
       bool luld;/*left up ro left down*/
       bool rurd;/*right up to right down*/
 }t[MAXN<<];
 ][MAXN],pipe[MAXN];
 ;
 ];
 namespace solution{
       Tree reload(Tree a,Tree b,bool upedge,bool downedge){
             Tree c;
             c.luld=a.luld;c.rurd=b.rurd;
             c.luru=(a.luru&upedge&b.luru)|(a.lurd&downedge&b.ldru);
             c.ldrd=(a.ldrd&downedge&b.ldrd)|(a.ldru&upedge&b.lurd);
             c.lurd=(c.luru&c.rurd)|(c.luld&c.ldrd)|(a.luru&upedge&b.lurd)|(a.lurd&downedge&b.ldrd);
             c.ldru=(c.ldrd&c.rurd)|(c.luld&c.luru)|(a.ldrd&downedge&b.ldru)|(a.ldru&upedge&b.luru);
             c.luld=c.luld|(c.lurd&c.ldrd)|(c.ldru&c.luru)|(a.luru&upedge&b.luld&downedge&a.ldrd);
             c.rurd=c.rurd|(c.lurd&c.luru)|(c.ldru&c.ldrd)|(b.luru&upedge&a.rurd&downedge&b.ldrd);
             return c;
       }
       void build(int leftt,int rightt,int root){
             if(leftt==rightt){
                   t[root].luru=t[root].ldrd=;
                   t[root].lurd=t[root].ldru=t[root].luld=t[root].rurd=;
                   return;
             }
             ;
             t[root].luru=t[root].ldrd=t[root].lurd=t[root].ldru=t[root].luld=t[root].rurd=;
             build(leftt,mid,root<<);
             build(mid+,rightt,root<<|);
       }
       void updata1(int leftt,int rightt,int root){
             if(leftt>k||rightt<k)       return;
             if(leftt==k&&rightt==k){
                   t[root].luld=t[root].rurd=t[root].lurd=t[root].ldru=v;
                   return;
             }
             ;
             updata1(leftt,mid,root<<);
             updata1(mid+,rightt,root<<|);
             t[root]=reload(t[root<<],t[root<<|],toright[][mid],toright[][mid]);
       }
       void updata2(int leftt,int rightt,int root){
             if(leftt>k||rightt<k)   return;
             if(leftt==k&&rightt==k) return;
             ;
             updata2(leftt,mid,root<<);
             updata2(mid+,rightt,root<<|);
             t[root]=reload(t[root<<],t[root<<|],toright[][mid],toright[][mid]);
       }
       Tree get(int leftt,int rightt,int root){
             Tree a,b,c;
             if(leftt>=limleft&&rightt<=limright)     return t[root];
             ;
             <=limleft)                  ,rightt,root<<|);
             );
             else{
                   a=);
                   b=,rightt,root<<|);
                   c=reload(a,b,toright[][mid],toright[][mid]);
             }
             return c;
       }
       void slove(){
             memset(toright,,sizeof(toright));
             while(scanf("%s",s)!=EOF){
                   ]=='E')break;
                   ]=='O'){
                         c1=read();r1=read();c2=read();r2=read();
                         if(r1==r2&&c1!=c2){
                               k=r1;v=;pipe[k]=;
                               updata1(,N,);
                         }
                         if(r1!=r2&&c1==c2){
                               r1=min(r1,r2);k=r1;
                               toright[c1-][r1]=;
                               updata2(,N,);
                         }
                   }
                   ]=='C'){
                         c1=read();r1=read();c2=read();r2=read();
                         if(r1>r2){
                               swap(r1,r2);
                               swap(c1,c2);
                         }/*make sure that r1<=r2*/
                         if(r1==r2&&c1!=c2){
                               k=r1;v=;pipe[k]=;
                               updata1(,N,);
                         }
                         if(r1!=r2&&c1==c2){
                               r1=min(r1,r2);
                               toright[c1-][r1]=;k=r1;
                               updata2(,N,);
                         }
                   }
                   ]=='A'){
                         c1=read();r1=read();c2=read();r2=read();
                         if(c1==c2&&r1==r2){puts("Y");continue;}
                         if(r1>r2){
                               swap(r1,r2);
                               swap(c1,c2);
                         }/*make sure that r1<=r2*/
                         limleft=;limright=r1;Tree go_left=,N,);
                         limleft=r1;limright=r2;Tree go_mid=,N,);
                         limleft=r2;limright=N;Tree go_right=,N,);
                         if(r1==r2&&c1!=c2){
                               if(go_left.rurd||go_right.luld||go_mid.luld)puts("Y");
                               else                                        puts("N");
                         }
                         if(r1!=r2&&c1==c2){
                               ){
                                     if((go_left.rurd&go_mid.ldrd&go_right.luld)||go_mid.luru||(go_left.rurd&go_mid.ldru)||(go_right.luld&go_mid.lurd))puts("Y");
                                     else                                                                                                              puts("N");
                               }else{
                                     if((go_left.rurd&go_mid.luru&go_right.luld)||go_mid.ldrd||(go_left.rurd&go_mid.lurd)||(go_right.luld&go_mid.ldru))puts("Y");
                                     else                                                                                                              puts("N");
                               }
                         }
                         if(r1!=r2&&c1!=c2){
                               ){/*left up to right down*/
                                     if((go_left.rurd&go_mid.ldrd)||go_mid.lurd||(go_left.rurd&go_mid.ldru&go_right.luld)||(go_mid.luru&go_right.luld))puts("Y");
                                     else                                                                                                              puts("N");
                               }else{/*left down to right up*/
                                     if((go_left.rurd&go_mid.luru)||go_mid.ldru||(go_left.rurd&go_mid.lurd&go_right.luld)||(go_mid.ldrd&go_right.luld))puts("Y");
                                     else                                                                                                              puts("N");
                               }
                         }
                   }
             }
       }
 }
 int main(){
     freopen(FILE".in","r",stdin);
     freopen(FILE".out","w",stdout);
       using namespace solution;
       N=read();
       build(,N,);
       slove();
       ;
 }

小结

这套题对新高一可能不太友好,但是这些知识点全都是在NOIp范围内的,可能一些比较偏?但是一些零碎的东西还是要学的。个人以为NOIp2016想进top5这套题应该要拿到230分以上吧..

没什么可说的了,感谢滑稽大师cdc友情出演。

NOIp 0904 出题报告的更多相关文章

  1. NOIP 2017 解题报告

    ---恢复内容开始--- NOIP 2017 的题真的很难啊,怪不得当年我这个萌新爆零了(当然现在也是萌新)越学越觉得自己什么都不会. 想要成为强者要把这些好题都弄懂弄透 至少现在6道题我都比较陌生 ...

  2. NOIP 2000解题报告

    题目简单,思路很快就有,关键是代码实现能力,大概3个多小时完成.第一题:题目大意:将一个10进制数N转换成-B进制数 (负进制转换):B<=20, N(-32768<=N<=3276 ...

  3. NOIP 2001解题报告

    第一题:  有形如:ax3+bx2+cx+d=0  这样的一个一元三次方程.给出该方程中各项的系数(a,b,c,d  均为实数),并约定该方程存在三个不同实根(根的范围在-100至100之间),且根与 ...

  4. NOIP 2003解题报告

    第一题(神经网络): 题目大意,给出一些点,每个点都有2个值,c和u,给出一些有向边,权值为w.入度为0的点的c已知,其它点的c未知,每个入度不为0的点node的c等于sum(c[k]*w[k][no ...

  5. NOIP 2006 解题报告

    第一题: 在Mars星球上,每个Mars人都随身佩带着一串能量项链.在项链上有N颗能量珠.能量珠是一颗有头标记与尾标记的珠子,这些标记对应着某个正整数.并且,对于相邻的两颗珠子,前一颗珠子的尾标记一定 ...

  6. Luogu P1082 同余方程(NOIP 2012) 题解报告

    题目传送门 [题目大意] 求关于x的同余方程 ax≡1(mod b)的最小整数解. [思路分析] 由同余方程的有关知识可得,ax≡1(mod b)可以化为ax+by=1,此方程有解当且仅当gcd(a, ...

  7. [日常] NOIp 2018 滚粗记

    考试前预感到自己会滚大粗 然后发现确实滚了个大粗 ==== €€£ WARNING ==== 因为是后补的所以更新速度比较慢 最后决定把半成品扔出来 预计本周末放假会更完吧 2019.2.25 upd ...

  8. NOIP2018退役祭

    退役感受 在写下这个标题的时候,我的心情是复杂的,无非就是感觉像对一位将要赶往战场的士兵说:"你的战争已经输掉了." 退役了,没有什么好说的.无论再怎么抱怨这题出的真烂也无法改变了 ...

  9. NOIP 2018 普及组 解题报告

    目录 标题统计 题目链接 思路 代码 龙虎斗 题目链接: 思路 代码 摆渡车 题目链接: 思路 对称二叉树 题目链接 思路: 先来解释一下为毛现在才来发解题报告: 其实博主是参加过NOIP 2018普 ...

随机推荐

  1. bootstrap的popover插件在focus模式时在Safari浏览器无法使用的bug解决方案

    前言 最近在使用bootstrap的popover插件,效果如下: popover插件的focus模式时表现为当点击按钮时弹出浮动层,在点击浮动层外的任何一处,都隐藏浮动层. 但是在mac下的Safa ...

  2. 彻底理解Toast原理和解决小米MIUI系统上没法弹Toast的问题

    1.Toast的基本使用 Toast在Android中属于系统消息通知,用来提示用户完成了什么操作.或者给用户一个必要的提醒.Toast的官方定义是这样的: A toast provides simp ...

  3. 使用axes函数在matlab绘图中实现图中图的绘制

    使用axes函数在matlab绘图中实现图中图的绘制 有时为了对细节进行详细说明,需要在一个较大坐标轴上绘制一个小图来对局部进行放大以阐述结果. 这可以通过调用axes函数实现. 下面通过绘制 y=1 ...

  4. Competition-based User Expertise Score Estimation-20160520

    1.Information publication:sigir 2011 author:Jing Liu Harbin Institute of TechnologyMicrosoft Researc ...

  5. 调用天气Api实现天气查询

    上面是简单截图: 前台代码: @{ Layout = null; } <!DOCTYPE html> <html> <head> <meta name=&qu ...

  6. linux | 管道符、输出重定向

    1 输出重定向 ll > a.txt 将 ll的结果写入到a.txt 2 管道符 ls -la | grep h* 这条命令的理解为:ls -la 的结果作为gerp h* 的结果 gerp 是 ...

  7. 48-tree 命令总结

  8. MySQL 5.7.9版本sql_mode=only_full_group_by问题

    用到GROUP BY 语句查询时com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Expression #2 of SELECT l ...

  9. 《Javascript DOM编程艺术》 读书笔记 —— 好书,通俗易懂!!!!! 相当的严谨!!!!

    1.javascript弱类型语言,解释性语言. 2.javascript数据类型:字符串(String).数字(Number).布尔(Boolean).数组(Array).对象(Object).空( ...

  10. android 监听短信并发送到服务器

    1. 接受系统的短信广播,操作短信内容. 优点:操作方便,适合简单的短信应用. 缺点:来信会在状态栏显示通知信息. 2. 应用观察者模式,监听短信数据库,操作短信内容.   实例如下: SystemE ...