1：前面已经搞好了。

2：poj2965 这种开关问题一个点要么点一次要么不点，枚举所有点的方案实行即可

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7. using namespace std;
  8.  
  9. char ss[];
  10. int main()
  11. {
  12.     int d=,tp=;
  13.     for(int i=;i<=;i++)
  14.     {
  15.         scanf("%s",ss+);
  16.         for(int j=;j<=;j++,tp++)
  17.             if(ss[j]=='+')d+=(<<tp);
  18.     }
  19.     int max_line=(<<)-,ans=,zt;
  20.     for(int i=;i<=max_line;i++)
  21.     {
  22.         int k=d,sum=;
  23.         for(int j=;j<=;j++)
  24.         {
  25.             if((i&(<<j))>)
  26.             {
  27.                 sum++;
  28.  
  29.                 int h=j/;
  30.                 for(int _=;_<=;_++)k^=(<<(h*+_));
  31.                 int l=j%;
  32.                 for(int _=;_<=;_+=)k^=(<<(l+_));
  33.  
  34.                 k^=(<<(h*+l));
  35.             }
  36.         }
  37.         if(k==)
  38.         {
  39.             if(ans>sum)
  40.                 ans=sum, zt=i;
  41.         }
  42.     }
  43.     printf("%d\n",ans);
  44.     int x=,y=;
  45.     for(int j=;j<=;j++)
  46.     {
  47.         if((zt&(<<j))>)printf("%d %d\n",x,y);
  48.         y++;if(y==)y=,x++;
  49.     }
  50.     return ;
  51. }

poj2965

3、4、10：手残码农题真心不想做，准备NOIP的时候再做吧

5：poj 3714 平面最近点对问题，分治解决，对于当前已有的最小值确定mid上下左右一个四边形的范围，合并区间时就判定这个四边形范围里面的点即可，闻说这个点数是不会超过8个的。具体实行是在确定了横坐标范围后，把这些点取出，判定时将其按纵坐标排序，一个个求值，这个复杂度是n(logn)^2，假如用归并排序顺便把纵坐标排序会少一个log，但是实际上并没有快多少。至于kdtree。。以后再说

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7. using namespace std;
  8.  
  9. struct point{double x,y;int z;}a[],t[];
  10. bool cmp(point p1,point p2){return p1.x<p2.x;}
  11.  
  12. int tt[];
  13. bool cmp2(int n1,int n2){return a[n1].y<a[n2].y;}
  14. double getdis(int n1,int n2)
  15. {
  16.     return sqrt( (double((a[n1].x-a[n2].x)*(a[n1].x-a[n2].x))) + (double((a[n1].y-a[n2].y)*(a[n1].y-a[n2].y))) );
  17. }
  18. double fenzi(int l,int r)
  19. {
  20.     if(l==r)return (double(<<));
  21.     int mid=(l+r)/;
  22.     double mmin=min(fenzi(l,mid),fenzi(mid+,r));
  23.  
  24.     int i=l,j=mid+,p=l;
  25.     while(i<=mid&&j<=r)
  26.     {
  27.         if(a[i].y<=a[j].y)t[p++]=a[i++];
  28.         else               t[p++]=a[j++];
  29.     }
  30.     while(i<=mid)t[p++]=a[i++];
  31.     while(j<=r)  t[p++]=a[j++];
  32.     for(int i=l;i<=r;i++)a[i]=t[i];
  33.  
  34.     int len=;tt[++len]=mid;
  35.     for(int i=l;i<=r;i++)
  36.         if(( double(abs(a[i].x-a[mid].x)) )<mmin)tt[++len]=i;
  37.  
  38.     for(int i=;i<=len;i++)
  39.         for(int j=i+,clc=;j<=len&&clc<=;j++,clc++)
  40.                 if(a[tt[i]].z!=a[tt[j]].z)
  41.                     mmin=min(mmin,getdis(tt[i],tt[j]));
  42.     return mmin;
  43. }
  44. int main()
  45. {
  46.     int T;
  47.     scanf("%d",&T);
  48.     while(T--)
  49.     {
  50.         int n;
  51.         scanf("%d",&n);
  52.         for(int i=;i<=n;i++)
  53.             scanf("%lf%lf",&a[i].x,&a[i].y), a[i].z=;
  54.         for(int i=n+;i<=n*;i++)
  55.             scanf("%lf%lf",&a[i].x,&a[i].y), a[i].z=;
  56.         sort(a+,a+*n+,cmp);
  57.  
  58.         printf("%.3lf\n",fenzi(,*n));
  59.     }
  60.     return ;
  61. }

poj3714

6：bzoj1271 这道是好题啊！突破口一定是在只有一个是奇数这个条件里面的，那么就是奇偶性的不同，这个时候并没有想到前缀和。知道这个以后就二分答案，看看前缀和是奇数还是偶数就行了。

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7. using namespace std;
  8. typedef long long LL;
  9.  
  10. int n;
  11. struct node
  12. {
  13.     LL l,r,d;
  14. }a[];
  15. bool check(LL tp)
  16. {
  17.     LL sum=;
  18.     for(int i=;i<=n;i++)
  19.         if(a[i].l<=tp)sum+=(min(a[i].r,tp)-a[i].l)/a[i].d+;
  20.     return (sum%==);
  21. }
  22. int main()
  23. {
  24.     int T;
  25.     scanf("%d",&T);
  26.     while(T--)
  27.     {
  28.         scanf("%d",&n);
  29.         for(int i=;i<=n;i++)
  30.             scanf("%lld%lld%lld",&a[i].l,&a[i].r,&a[i].d);
  31.  
  32.         LL l=,r=,ans=-;
  33.         while(l<=r)
  34.         {
  35.             LL mid=(l+r)/,u;
  36.             if(check(mid)==true)
  37.             {
  38.                 r=mid-;
  39.                 ans=mid;
  40.             }
  41.             else l=mid+;
  42.         }
  43.         if(ans==-)printf("Poor QIN Teng:(\n");
  44.         else
  45.         {
  46.             LL c=;
  47.             for(int i=;i<=n;i++)
  48.                 if(a[i].l<=ans&&ans<=a[i].r&&(ans-a[i].l)%a[i].d==)c++;
  49.             printf("%lld %lld\n",ans,c);
  50.         }
  51.     }
  52.     return ;
  53. }

bzoj1271

7：poj3179 这题明显就得写个二维前缀和嘛。。相应的就离散化一下。二分答案，然后两个for一个枚举行一个枚举列的后界，前界尽量往前，这个while往前走就好。

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7. using namespace std;
  8.  
  9. int n,C;
  10. struct node{int x,y;}a[];
  11. int lsxlen,lsylen,lsx[],lsy[];
  12. void LSH()
  13. {
  14.     lsxlen=;
  15.     for(int i=;i<=n;i++)lsx[++lsxlen]=a[i].x;
  16.     sort(lsx+,lsx+lsxlen+);
  17.     lsxlen=unique(lsx+,lsx+lsxlen+)-lsx-;
  18.     for(int i=;i<=n;i++)
  19.          a[i].x=lower_bound(lsx+,lsx+lsxlen+,a[i].x)-lsx;
  20.  
  21.     lsylen=;
  22.     for(int i=;i<=n;i++)lsy[++lsylen]=a[i].y;
  23.     sort(lsy+,lsy+lsylen+);
  24.     lsylen=unique(lsy+,lsy+lsylen+)-lsy-;
  25.     for(int i=;i<=n;i++)
  26.          a[i].y=lower_bound(lsy+,lsy+lsylen+,a[i].y)-lsy;
  27. }
  28. int sum[][];
  29. int getsum(int x,int y,int u,int v)
  30. {
  31.     return sum[x][y]-sum[x][v-]-sum[u-][y]+sum[u-][v-];
  32. }
  33. bool check(int mid)
  34. {
  35.     int rl=;
  36.     for(int rr=;rr<=lsxlen;rr++)
  37.     {
  38.         while(lsx[rr]-lsx[rl]>=mid)rl++;
  39.         int cl=;
  40.         for(int cr=;cr<=lsylen;cr++)
  41.         {
  42.             while(lsy[cr]-lsy[cl]>=mid)cl++;
  43.             if(getsum(rr,cr,rl,cl)>=C)return true;
  44.         }
  45.     }
  46.     return false;
  47. }
  48. int main()
  49. {
  50.     scanf("%d%d",&C,&n);
  51.     for(int i=;i<=n;i++)
  52.         scanf("%d%d",&a[i].x,&a[i].y);
  53.     LSH();
  54.  
  55.     memset(sum,,sizeof(sum));
  56.     for(int i=;i<=n;i++)sum[a[i].x][a[i].y]++;
  57.     for(int i=;i<=lsxlen;i++)
  58.         for(int j=;j<=lsylen;j++)
  59.             sum[i][j]+=sum[i-][j]+sum[i][j-]-sum[i-][j-];
  60.  
  61.     int l=,r=,ans;
  62.     while(l<=r)
  63.     {
  64.         int mid=(l+r)/;
  65.         if(check(mid)==true)
  66.         {
  67.             ans=mid;
  68.             r=mid-;
  69.         }
  70.         else l=mid+;
  71.     }
  72.     printf("%d\n",ans);
  73.     return ;
  74. }

poj3179

8：bzoj1465 bzoj1045: [HAOI2008] 糖果传递&&bzoj3293: [Cqoi2011]分金币

9：明显x、y分开做，y就是中位数，x的话我一开始也是想要从中位数左右延伸，但是fail掉了。。正确的做法是设排完序以后，起点是a，那么我们就是要求的sum=Σabs(a-(x[i]-i))。a就是(x[i]-i)这东西的中位数。

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7. using namespace std;
  8. typedef long long LL;
  9.  
  10. LL a[],b[];
  11. LL myabs(LL x){return x<?-x:x;}
  12. int main()
  13. {
  14.     int n;
  15.     scanf("%d",&n);
  16.     for(int i=;i<=n;i++)
  17.         scanf("%lld%lld",&a[i],&b[i]);
  18.     sort(a+,a+n+);
  19.     sort(b+,b+n+);
  20.     for(int i=;i<=n;i++)a[i]-=i;
  21.     sort(a+,a+n+);
  22.  
  23.     LL sum=;
  24.     for(int i=;i<=n;i++)
  25.         sum+=myabs(a[i]-a[(n+)/]);
  26.     for(int i=;i<=n;i++)
  27.         sum+=myabs(b[i]-b[(n+)/]);
  28.     printf("%lld\n",sum);
  29.     return ;
  30. }

poj1723

11：poj1050这题暴力二维前缀和n^4可A。。。。但是我还是正直的写个个n^3，f[i][j][k]表示现在枚举到第i行，列的区间是j~k的最大值，那么就相当于每一种列的情况都做一次O(n)的一维最大子串。

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7. using namespace std;
  8.  
  9. int a[][],f[][][];
  10. int main()
  11. {
  12.     int n;
  13.     scanf("%d",&n);
  14.     for(int i=;i<=n;i++)
  15.         for(int j=;j<=n;j++)
  16.             scanf("%d",&a[i][j]);
  17.  
  18.     int ans=-;
  19.     memset(f,,sizeof(f));
  20.     for(int i=;i<=n;i++)
  21.     {
  22.         for(int j=;j<=n;j++)
  23.         {
  24.             int sum=;
  25.             for(int k=j;k<=n;k++)
  26.             {
  27.                 sum+=a[i][k];
  28.                 f[i][j][k]=max(f[i-][j][k]+sum,sum);
  29.                 ans=max(ans,f[i][j][k]);
  30.             }
  31.         }
  32.     }
  33.     printf("%d\n",ans);
  34.     return ;
  35. }

poj1050

12：hdu4864 这题超级好题！！！！想了我超久，下午一个小时+晚上两个小时，看到那个价值的算法，肯定觉得会有问题对吧，我发现其实这个价值根本没用，因为价值的大小是按照耗时，耗时相等按照等级排的。思考的时候我类比一下贪心的第1题，那题是一个权，两个限制，现在是两个权，两个限制，不管怎样肯定是先排序，然后在此基础上卡另外一个限制贪心，我写的时候是让机器去找任务，这里就出问题了！不管按照什么排序，怎样的贪心法都会被反例掉，因为在这题里面，机器是为任务服务的，所以应该是任务去找机器，排序过后权值由大到小，一个个找完以后，x区间是单调延伸，前面的机器必然满足x比往后枚举的任务的x大，相当于问题只在于y，那么只需要贪心选择全部中尽量小的即可。再来分析一下正确性，当前任务占用机器，必然比后面的任务占用的机器要多，对于机器被占用，可以视作对答案的贡献均为1，所以可以心安理得的占用机器。对于机器而言，假如不影响当前任务影响后面，那一个替代他的机器一定比他还要优秀，它能影响了当前，肯定在先前也可以影响那个后一种情况中被前一个机器影响的任务。

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7. #include<set>
  8. using namespace std;
  9.  
  10. struct node
  11. {
  12.     int x,y;
  13. }a[],b[];
  14. bool cmp(node n1,node n2)
  15. {
  16.     if(n1.x==n2.x)return n1.y>n2.y;
  17.     return n1.x>n2.x;
  18. }
  19. multiset<int>s;
  20. multiset<int>::iterator o;
  21.  
  22. int main()
  23. {
  24.     int n,m;
  25.     while(scanf("%d%d",&n,&m)!=EOF)
  26.     {
  27.         for(int i=;i<=n;i++)scanf("%d%d",&a[i].x,&a[i].y);
  28.         for(int i=;i<=m;i++)scanf("%d%d",&b[i].x,&b[i].y);
  29.         sort(a+,a+n+,cmp);sort(b+,b+m+,cmp);
  30.  
  31.         s.clear();
  32.         int ans=,tp=;long long val=;
  33.         for(int i=;i<=m;i++)
  34.         {
  35.             while(tp<=n&&a[tp].x>=b[i].x)s.insert(a[tp].y),tp++;
  36.             if(!s.empty())
  37.             {
  38.                 if(*--s.end()>=b[i].y)
  39.                 {
  40.                     int k=*s.lower_bound(b[i].y);
  41.                     int c=s.count(k);s.erase(k);
  42.                     for(int j=;j<c;j++)s.insert(k);
  43.  
  44.                 //    for(o=s.begin();o!=s.end();o++)printf("%d\n",*o);
  45.                     ans++;val+=b[i].x*+*b[i].y;
  46.                 }
  47.             }
  48.         }
  49.         printf("%d %lld\n",ans,val);
  50.     }
  51.     return ;
  52. }

hdu4864 （因为y的范围只有100所以可以暴力枚举，我没想就搞了个set，跑得还比暴力慢-_-!）

0x08 总结与练习的更多相关文章

  1. “0x00,0x08”两个十六进制字符串，转换为整形

    int m_length=0;char buf[2]=={0x00,0x08};memcpy(&m_length,&buf[0],2); m_length=m_length<&l ...

  2. 0x08 MySQL 超详细-索引原理&慢查询优化【转-多图】（重点）

    Content From——Egon's Blog http://www.cnblogs.com/linhaifeng/articles/7274563.html#top 0x01 介绍 为何要有索引 ...

  3. Docker 0x08: Docker 命令

    目录 Docker 命令 run 与 start 区别 docker 进程相关命令 Restful API Docker 命令 docker命令容易混淆几个 run 与 start 区别 run: 会 ...

  4. 【探索】无形验证码 —— PoW 算力验证

    先来思考一个问题:如何写一个能消耗对方时间的程序? 消耗时间还不简单,休眠一下就可以了: Sleep(1000) 这确实消耗了时间,但并没有消耗 CPU.如果对方开了变速齿轮,这瞬间就能完成. 不过要 ...

  5. 对抗密码破解 —— Web 前端慢 Hash

    (更新:https://www.cnblogs.com/index-html/p/frontend_kdf.html ) 0x00 前言 天下武功,唯快不破.但在密码学中则不同.算法越快,越容易破. ...

  6. Summary of Critical and Exploitable iOS Vulnerabilities in 2016

    Summary of Critical and Exploitable iOS Vulnerabilities in 2016 Author:Min (Spark) Zheng, Cererdlong ...

  7. 黑云压城城欲摧 - 2016年iOS公开可利用漏洞总结

    黑云压城城欲摧 - 2016年iOS公开可利用漏洞总结 作者:蒸米,耀刺,黑雪 @ Team OverSky 0x00 序 iOS的安全性远比大家的想象中脆弱,除了没有公开的漏洞以外,还有很多已经公开 ...

  8. Syscan360会议胸牌破解揭秘

    Syscan360会议胸牌破解揭秘 背景 有幸参加今年11月份的上海Syscan360安全会议,会议期间有一个亮点就是360的独角兽团队设计了一款电子badge(胸牌)供参加人员进行破解尝试,类似于美 ...

  9. 领域驱动和MVVM应用于UWP开发的一些思考

    领域驱动和MVVM应用于UWP开发的一些思考 0x00 起因 有段时间没写博客了,其实最近本来是根据梳理的MSDN上的资料(UWP开发目录整理)有条不紊的进行UWP学习的.学习中有了心得体会或遇到了问 ...

随机推荐

  1. 26. Remove Duplicates from Sorted Array[E]删除排序数组中的重复项

    题目 Given a sorted array nums, remove the duplicates in-place such that each element appear only once ...

  2. vcpkg错误分析方法

    最近在使用vcpkg时,经常会碰到CMake错误. 有些以前能编译通过的包, 过一段时间又不能编译错误了. 错误提示一般是CMake错误, 弄得很郁闷. 我采用以下步骤解决了问题: 分析错误 查看错误 ...

  3. linux编译安装ccache3.2.4

    1.下载ccache3.2.4安装包 #cd /opt #wget http://samba.org/ftp/ccache/ccache-3.2.4.tar.gz 2.解压 #.tar.gz 3.创建 ...

  4. Service不完全解析

    本篇的内容并不是介绍service使用方法和生命周期的,而是对其中的一些要点进行记录和分析. 我们都知道,Service是一个在后台执行的应用组件,用于在后台进行长期操作,例如进行网络事务,播放背景音 ...

  5. lua队列实现

    Queue = {} function Queue.newquene() } end function Queue.push(queue, value) queue.count = queue.cou ...

  6. ES6变量的解构赋值

    变量的解构赋值 1.数组的解构赋值 2.对象的解构赋值 3.字符串的解构赋值 4.数值和布尔值的解构赋值 5.函数参数的解构赋值 6.圆括号问题 7.用途 1.数组的解构赋值 ES6 允许写成下面这样 ...

  7. ADODB.RecordSet常用方法查询

    rs = Server.CreateObject("ADODB.RecordSet") rs.Open(sqlStr,conn,1,A) 注:A=1表示读取数据:A=3表示新增.修 ...

  8. OpenStack、KVM、Docker——Docker之后还需要OpenStack吗？

    原文链接:http://news.csdn.net/article_preview.html?preview=1&reload=1&arcid=2823129 Docker从一个新兴的 ...

  9. 使用QT的一些小Tipster

    1.在使用Qt Creator编程时,难免会用到将float类型转换为QString类型的方法:原文 1.1. 将QString类型转化为float类型,很简单 QString data;       ...

  10. What's Dead & Exploded in Swift's exception stack?

    The Swift compiler marks function arguments for a number of reasons, mostly related to internal opti ...