2021,noip考点总结，加油

今年的题目“据说”不是很难，不过我是：

的球啊！！！

废话不说了，上“餐”！！！

先整几个代码，都是提高的，想看普及的，去我的“另一个"！！！

砝码称重

题目描述

查看题目信息

在现代质量计量中，砝码是质量量值传递的标准量具。

假设有1g、2g、3g、5g、10g、20g的砝码各若干枚（其总重≤1000）。

你的任务是：根据给定的砝码（可能有多种不同的砝码，且同一种砝码可能有多个），计算可以称出的不同重量的个数。

输入格式

只有一行，为6个用空格隔开的正整数，分别表示6种砝码各自的数量。

输出格式

只有一行N，表示用这些砝码能称出的不同重量的个数，但不包含一个砝码也不用的情况。

样例输入

1 1 0 0 0 0

样例输出

问题提示

【样例说明】

可以称出的重量：1g、2g、1g+2g=3g，共三种。

代码

#include<iostream>
using namespace std;
int h[10001]={0};
int main()
{

   int a,b,c,d,e,f;
   int n1,n2,n3,n4,n5,n6,ans=0;
   cin>>n1>>n2>>n3>>n4>>n5>>n6;
   for(a=0;a<=n1;a++)
   {
       for(b=0;b<=n2;b++)
       {
           for(c=0;c<=n3;c++)
           {
               for(d=0;d<=n4;d++)
               {
                   for(e=0;e<=n5;e++)
                   {
                       for(f=0;f<=n6;f++)
                       {
                           int sum=a+2*b+3*c+5*d+10*e+20*f;
                           h[sum]=1;
                       }
                   }
               }
           }
       }
   }
   for(int i=1;i<=1000;i++)
   {
       if(h[i]!=0)
       {
           ans++;
       }
   }
   cout<<ans;
}

火柴棒等式

题目描述

查看题目信息

输入格式

输入共1行，有一个整数n（n≤24）。

输出格式

输出共1行，表示能拼成的不同等式的数目。

样例输入

样例输出

样例输入

样例输出

问题提示

【样例1说明】

2个等式为0+1=1和1+0=1。

【样例2说明】

9个等式为：

0+4=4

0+11=11

1+10=11

2+2=4

2+7=9

4+0=4

7+2=9

10+1=11

11+0=11

#include <iostream>
using namespace std;
int x[1001] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6}, b[4];
int n, tot = 0;
void search(int l)
{
int i;
for(i = 0; i <= 999; ++i) //让每一个数都成为一次加数
{
if(n - x[i] >= 0)
{
b[l] = i; //令当前数字存为加数
n = n - x[i];
if(l == 3)
{
if(b[1] + b[2] == b[3] && n == 0) {
               tot++; //满足条件就累加
               //   cout<<b[1]<<"+"<<b[2]<<"="<<b[3]<<endl; 可以展示那个等式满足条件
               }
}
else search(l + 1); //递归第二个加数和两个加数的和
n = n + x[i]; //回溯
}
}
}
int main(){
int i;
cin >> n;
n = n - 4; //“+”和“=”需要四根火柴棒
for(i = 10; i <= 999; ++i)
x[i] = x[i/10] + x[i%10]; //算出每个数的笔画
   search(1);
cout << tot;
return 0;
}

再来俩简单的

机器人翻译

题目描述

查看题目信息

小晨的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。

这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。

假设内存中有M个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存入的单词数不超过M，软件会将新单词存入一个未使用的内存单元；若内存中已存入M个单词，软件会清空最早进入内存的那个单词，腾出单元来，存放新单词。

假设一篇英语文章的长度为N个单词。给定这篇待译文章，翻译软件需要去外存查找多少次词典？假设在翻译开始前，内存中没有任何单词。

输入格式

输入文件共2行，每行中两个数之间用一个空格隔开。

第一行为两个正整数M和N，代表内存容量和文章的长度。

第二行为N个非负整数，按照文章的顺序，每个数（大小不超过1000）代表一个英文单词。文章中两个单词是同一个单词，当且仅当它们对应的非负整数相同。

输出格式

仅一行，包含一个整数，为软件需要查词典的次数。

样例输入

3 7
1 2 1 5 4 4 1

样例输出

样例输入

2 10
8 824 11 78 11 78 11 78 8 264

样例输出

问题提示

【样例1说明】

整个查字典过程如下：每行表示一个单词的翻译，冒号前为本次翻译后的内存状况：

空：内存初始状态为空。

1． 1：查找单词1 并调入内存。

2． 1 2：查找单词 2 并调入内存。

3． 1 2：在内存中找到单词 1。

4． 1 2 5：查找单词 5 并调入内存。

5． 2 5 4：查找单词 4 并调入内存替代单词 1。

6． 2 5 4：在内存中找到单词 4。

7． 5 4 1：查找单词 1 并调入内存替代单词 2。

共计查了 5次词典。

【数据范围】

对于 10% 的数据：M = 1， N ≤ 5。

对于 100% 的数据：0< M ≤ 100， 0 < N ≤ 1000。

#include<bits/stdc++.h>
using namespace std;
int h[1010];
int main()
{
   int m,n,a,ans=0;
   queue<int> q;
   cin>>m>>n;
   for(int i=1;i<=n;i++){
       cin>>a;
       if(h[a]) continue;
       q.push(a);
       h[a]=1;
       ans++;
       if(q.size()>m)
       {
           h[q.front()]=0;
           q.pop();
       }
   }
   cout<<ans;
   return 0;
}
统计数字

题目描述

查看题目信息

某次科研调查时得到了n个自然数，每个数均不超过1500000000。已知不相同的数不超过10000个，现在需要统计这些自然数各自出现的次数，并按照自然数从小到大的顺序输出统计结果。

输入格式

第1行一个正整数n，表示自然数的个数。

第2~n+1行，每行一个自然数。

输出格式

包含m行，m为n个自然数中不相同数的个数。请按照自然数从小到大的顺序输出，每行输出两个正整数，分别是自然数和该数出现的次数，之间用一个空格隔开。

样例输入

样例输出

问题提示

对于40% 的数据满足：1≤n≤1000 ；

对于80% 的数据满足：1≤n≤50000 ；

对于100% 的数据满足：1≤n≤200000 。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int num[1000100];
int main()
{
int n;
scanf("%d",&n);
for(int i = 1 ; i <= n ; i ++)
scanf("%d",&num[i]);
sort( num+1 , num+n+1 );
int tot = 0;
for(int i = 1 ; i <= n ; i ++)
{
if(num[i] != num[i-1])
printf("%d",num[i]);
if(num[i] != num[i+1])
{
printf(" %d\n",++tot);
tot = 0;
}
else
{
tot ++;
}
}
return 0;
}

难得来几个

拼数（让我想起了）

题目描述

查看题目信息

设有N个正整数（N≤100，每个数均在int范围内），将它们连接成一排组成一个最大的多位整数。

例如：N=3时，3个正整数13、312、343，连接成的最大整数为34331213。

又如：N=4时，4个正整数7、13、4、246，连接成的最大整数为7424613。

输入格式

第一行一个正整数N；

第二行包含N个正整数，之间用一个空格隔开。

输出格式

一行一个正整数，表示连接成的最大正整数。

样例输入

3
13 312 343

样例输出

34331213

#include<bits/stdc++.h>
using namespace std;
using namespace std;
const int MaxN = 10000;//先设计个数，呵呵；
string str[MaxN];
int n;//int个数；
bool cmp(string a, string b)
{
   string s1 = a + b, s2 = b + a;
   return s1 > s2;
}
int main()
{

   cin >> n;
   for(int i = 0; i < n; ++i)
       cin >> str[i];
   sort(str, str + n, cmp);
   string ans = str[0] ;
   for(int i = 1; i < n; ++i)
       ans += str[i];
   cout << ans << endl;
   return 0;
}

合并果子

题目描述

查看题目信息

在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。

每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。

因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。

例如有3种果子，数目依次为1、2、9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。

输入格式

共两行：

第一行是一个整数n（1≤n≤10000），表示果子的种类数。

第二行包含n个整数，用空格分隔，第i个整数ai（1≤ai≤20000）是第i种果子的数目。

输出格式

一个整数，也就是最小的体力耗费值。输入数据保证这个值小于231 。

样例输入

3
1 2 9

样例输出

问题提示

对于30％的数据，保证有n≤1000；

对于50％的数据，保证有n≤5000；

对于全部的数据，保证有n≤10000。

#include<bits/stdc++.h>
using namespace std;
int main(){

int t, n, m=0 ;
int i = 0, j = 0;
cin>>n;
int sum[n];

for(i = 0; i<n;i++){
cin>>sum[i];
}

for(i = 0; i<n-1;i++){
for(j = 0; j<n-i-1; j++){
if(sum[j]>sum[j+1]){
t = sum[j];
sum[j] = sum[j+1];
sum[j+1] = t;
}
}
}
for(i = 1;i<n;++i){
sum[i] += sum[i-1];
m += sum[i];
for(j = i+1;j<n&&sum[j]<sum[j-1];++j){
t = sum[j-1];
sum[j-1] = sum[j];
sum[j] = t;
}
}

cout<<m;

return 0;
}

数的划分

题目描述

查看题目信息

将整数n分成k份，且每份不能为空，任意两份不能相同（不考虑顺序）。

例如：n=7，k=3，下面三种分法被认为是相同的。

1，1，5；

1，5，1；

5，1，1；

问有多少种不同的分法。

输入格式

两个整数n和k（6<n<=200，2<=k<=6），中间用单个空格隔开。

输出格式

一个整数，即不同的分法。

样例输入

7 3

样例输出

问题提示

四种分法为：

1，1，5；

1，2，4；

1，3，3；

2，2，3。

#include<bits/stdc++.h>
using namespace std;
int sum;
void dfs(int x,int s,int t)
{if(s==1)
{sum++;
return ;
}
for(int i=x;i<=t/s;i++)
dfs(i,s-1,t-i);
}
int main()
{int n,k;
cin>>n>>k;
dfs(1,k,n);
cout<<sum<<endl;
return 0;}

大家给菜鸡一个☟☟吧！！！

下面送大家几个“小问题”

篝火晚会

如果确定下了其中一个元素的对应位置，那么所有元素的对应位置都已经确定了。可以证明此时最小代价就是不在自己位置上（vi≠ivi≠i）的元素数量。
于是有一个想法就是枚举元素的对应位置。这样会T。

实际上只需要知道与自身目标位置差相同的元素数量最多是多少即可。因为总可以通过指定该元素来让它与目标差为0，即不需要置换它们。

双栈排序

我们判断一下什么情况是不可排序的。

记序列中的数的下标为ii，值为 aiai，进入的栈是 cici （cici = 1表示进入第一个栈， cici = 2表示进入第二个栈）

一个序列不可排序，当且仅当需要某个数 axax 弹出时，有大于axax的数压在栈 cxcx 中 axax 的上面，导致 axax 不可弹出。

形式化地，也就是存在 x<y<zx<y<z，且 az<ax<ayaz<ax<ay， cx=cycx=cy 。

其中数的下标是不可改变的，值也是不可改变的，而 cici（即进入的栈）是可以改变的。

于是我们只需要对于上述的每一个三元组(x,y,z)(x,y,z)使cx≠cycx≠cy即可排除这种情况。问题转化为二分图染色，判是否是二分图即可。

最优贸易

如果图是DAG，那么肯定有一个DP的做法。可以发现在一个强连通分量内只有值最小的和值最大的两个点可能有贡献，于是考虑缩强，对于每一个强连通分量记最大值和最小值，缩完之后就可以DP啦。

引水入城

可以发现第一行每个地方流出去的水在最后一行一定是一段连续区间，否则就一定不能完全覆盖。做最小线段覆盖即可。BFS或DFS的时候注意扫过的点的标记要打清楚！！！

选择客栈

应该有很多姿势，反正瞎扫一遍就好了。我是用后缀和+枚举中间点来做的。

Mayan游戏

码农模拟，貌似我出了一组数据可以叉好多人超时？

计算系数

二项式定理

聪明的质检员

不难发现存在单调性，于是二分。用前缀和优化check。

观光公交

感性地想，每一个加速器一定要尽量放在人多经过的地方。发现一个性质：每个人的贡献=到达Bi的时间-出现的时间Ti，和什么时候上车没有关系。考虑在一条边上加速的贡献一定是一段连续区间,起点是这条边的终点，而区间的终点一定是等人的时间≥到达的时间的地方。于是可以对于每一个点算出它最长的贡献区间（即有多少个终点贡献会减少-1），然后前缀和维护人数。这样O(k*n)居然可过。

vigenere密码

应该是可以模拟搞出来的，但是我这个智障转成同余方程来做啦，反正能A。。。

国王游戏

刚开始考虑二分。对于一个二分的答案x，将每个人左手和右手乘起来，那么判定就是是否每个人的前面所有人（包括自己）的左手乘起来除以自己的右手小于等于x，然而这样复杂度会挂。经过观察可以发现按照每个人左右手乘积升序排序一定是最小的（假设不是升序，那么移动任意一对逆序对答案不会更差），然后就可以贪心而不用二分啦。

同余方程

exgcd 模板题

借教室

线段树常数小也许可以卡时通过？
如果处理第x个时教室数量出现负数，那么x以后肯定也存在负数，于是二分。就差分处理订单，最后扫一遍看有没有负数。

疫情控制

有一个重要性质：军队只有两种运动方式，要么不断往上走，要么往上走到根，然后越过根，进入另一个第二层的子节点停下来！

证明很显然，毕竟往下走一定不会比往上走覆盖得广。

然后二分答案。对于不能走到根的就一直往上，然后停下来。对于能走到根的进行分类，如果走到根就不能回到自己路径上的第二层子节点并且第二层子节点没覆盖，就直接让它停在第二层子节点。否则就先放在根。

然后对于所有放在根的军队按剩余时间排序，把所有第二层子节点按和根的距离排序，一一对应判断即可。
上述题目有的来自于endlessway的题目，小编只是给了个答案而已！！！

送个ascal表

没有几个粉丝，现在成了

不说了，涨粉去了，溜了溜了，886！！！

记得2套件：三联，收藏886！！！