【比赛重现】从NOIP2004说开去
今天做题目，有很多题目都不会，距离今年的NOIP也只有一两百天的时间了，对于自己的水平我也是知晓的，不可能在今年有很好的成绩，但是我还是要坚持下去，毕竟，不到最后，什么也说不准。经过一些思考，我认为，真题是最重要的，只有准确把握的真题的方法与思路，才能真正地掌握一场比赛的全貌，因此，今天，从NOIP2004说开去
相对而言，NOIP2004是比较简单的，并且，这是我出生的那一年，既然，我是从那一年开始的，那么，我的故事便从2004年开始。
T1 津津的储蓄计划
【问题描述】
津津的零花钱一直都是自己管理。每个月的月初妈妈给津津300元钱，津津会预算这个月的花销，并且总能做到实际花销和预算的相同。
为了让津津学习如何储蓄，妈妈提出，津津可以随时把整百的钱存在她那里，到了年末她会加上20%还给津津。因此津津制定了一个储蓄计划：每个月的月初，在得到妈妈给的零花钱后，如果她预计到这个月的月末手中还会有多于100元或恰好100元，她就会把整百的钱存在妈妈那里，剩余的钱留在自己手中。
例如11月初津津手中还有83元，妈妈给了津津300元。津津预计11月的花销是180元，那么她就会在妈妈那里存200元，自己留下183元。到了11月月末，津津手中会剩下3元钱。
津津发现这个储蓄计划的主要风险是，存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初，津津手中的钱加上这个月妈妈给的钱，不够这个月的原定预算。如果出现这种情况，津津将不得不在这个月省吃俭用，压缩预算。
现在请你根据2004年1月到12月每个月津津的预算，判断会不会出现这种情况。如果不会，计算到2004年年末，妈妈将津津平常存的钱加上20%还给津津之后，津津手中会有多少钱。
【输入文件】
输入文件save.in包括12行数据，每行包含一个小于350的非负整数，分别表示1月到12月津津的预算。
【输出文件】
输出文件save.out包括一行，这一行只包含一个整数。如果储蓄计划实施过程中出现某个月钱不够用的情况，输出-X，X表示出现这种情况的第一个月；否则输出到2004年年末津津手中会有多少钱。
【样例输入1】
290
230
280
200
300
170
340
50
90
80
200
60
【样例输出1】
-7
【样例输入2】
290
230
280
200
300
170
330
50
90
80
200
60
【样例输出2】
1580
题解
模拟
当初第一次做这道题的时候还是在2018年的一月份吧，很怀念了，当时花了好长时间才做出来，然后第二次做是在2018年的国庆节在武汉培训的时候，这道题是一道模拟题，分析一下就能做出来了
#include <iostream>
using namespace std;
int main()
{
int i,yq,haiyouqian,gq=300,sq=0,cq=0;
double lq=0;
for (i=1;i<=12;i++)
{
cin>>yq;
haiyouqian=gq+sq;
if (haiyouqian<yq)
{
cout<<-i<<endl;
break;
}
cq+=(haiyouqian-yq)/100;
sq=(haiyouqian-yq)%100;
}
lq=cq*100*1.2;
if (i>12)
cout<<(int)lq+sq<<endl;
return 0;
}
T2 合并果子
【问题描述】
在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。
每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。
因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。
例如有3种果子，数目依次为1，2，9。可以先将 1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为 12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。
【输入文件】
输入文件fruit.in包括两行，第一行是一个整数n（1 <= n <= 10000），表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai（1 <= ai <= 20000）是第i种果子的数目
【输出文件】
输出文件fruit.out包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于(2^{31})。
【样例输入】
3
1 2 9
【样例输出】
15
【数据规模】
对于30%的数据，保证有n <= 1000；
对于50%的数据，保证有n <= 5000；
对于全部的数据，保证有n <= 10000。
题解
贪心 优先队列
优先合并比较小的两堆，运用优先队列存储再好不过，只不过存的时候要存一个相反的负数，这样才能保证堆顶是两个比较小的数
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
priority_queue <int> heap;
int n;
long long ans;
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
int x;
cin>>x;
heap.push(-x);
}
for(int i=1;i<=n-1;i++)
{
int a,b;
a=heap.top();
heap.pop();
b=heap.top();
heap.pop();
ans+=(a+b);
heap.push(a+b);
}
cout<<-ans<<endl;
return 0;
}
T3 合唱队形
【问题描述】
N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1, 2, …, K，他们的身高分别为T1, T2, …, TK，则他们的身高满足T1 < T2 < … < Ti , Ti > Ti+1 > … > TK (1 <= i <= K)。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
【输入文件】
输入文件chorus.in的第一行是一个整数N（2 <= N <= 100），表示同学的总数。第一行有n个整数，用空格分隔，第i个整数Ti（130 <= Ti <= 230）是第i位同学的身高（厘米）。
【输出文件】
输出文件chorus.out包括一行，这一行只包含一个整数，就是最少需要几位同学出列。
【样例输入】
8
186 186 150 200 160 130 197 220
【样例输出】
4
【数据规模】
对于50%的数据，保证有n <= 20；
对于全部的数据，保证有n <= 100。
题解
动态规划
运用的实际上是基本模型最长上升子序列，从左往右做一个最长上升子序列，再从有往左做一个最长上升子序列，然后从中间枚举断点，计算这种情况下的最多能留下多少人，对所有的断点所对应的值取一个max，然后最后的答案就是n-max了
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
int n;
int a[105],b[105];
int f[105],g[105];
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
b[n-i+1]=a[i];
}
for(int i=1;i<=n;i++)
{
f[i]=1;
for(int j=1;j<=i;j++)
{
if(a[i]>a[j])
f[i]=max(f[i],f[j]+1);
}
}
for(int i=1;i<=n;i++)
{
g[i]=1;
for(int j=1;j<=i;j++)
{
if(b[i]>b[j])
g[i]=max(g[i],g[j]+1);
}
}
int ans=-999;
for(int i=1;i<=n;i++)
ans=max(ans,f[i]+g[n-i+1]-1);
cout<<n-ans<<endl;
return 0;
}
T4 虫食算
【问题描述】
所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子：
43#98650#45
+ 8468#6633
44445506978
其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二行的数字是5。
现在，我们对问题做两个限制：
首先，我们只考虑加法的虫食算。这里的加法是N进制加法，算式中三个数都有N位，允许有前导的0。
其次，虫子把所有的数都啃光了，我们只知道哪些数字是相同的。我们将相同的数字用相同的字母表示，不同的数字用不同的字母表示。如果这个算式是N进制的，我们就取英文字母表中的前N个大写字母来表示这个算式中的0到N-1这N个不同的数字（但是这N个字母并不一定顺序地代表0到N-1）。输入数据保证N个字母分别至少出现一次。
BADC
+ CBDA
DCCC
上面的算式是一个4进制的算式。很显然，我们只要让ABCD分别代表0123，便可以让这个式子成立了。你的任务是，对于给定的N进制加法算式，求出N个不同的字母分别代表的数字，使得该加法算式成立。输入数据保证有且仅有一组解。
【输入文件】
输入文件alpha.in包含4行。第一行有一个正整数N（N <= 26），后面的3行每行有一个由大写字母组成的字符串，分别代表两个加数以及和。这3个字符串左右两端都没有空格，从高位到低位，并且恰好有N位。
【输出文件】
输出文件alpha.out包含一行。在这一行中，应当包含唯一的那组解。解是这样表示的：输出N个数字，分别表示A，B，C……所代表的数字，相邻的两个数字用一个空格隔开，不能有多余的空格。
【样例输入】
5
ABCED
BDACE
EBBAA
【样例输出】
1 0 3 4 2
【数据规模】
对于30%的数据，保证有N <= 10；
对于50%的数据，保证有N <= 15；
对于全部的数据，保证有N <= 26。
题解
搜索+剪枝or 高斯消元？
我们可以这么想，枚举0~n-1的全排列，然后将数字一个一个带入，这样就可以了？
啊不，不可以，这样绝对会超时，因为(Nleq 26),计算量为(26!*26)，这个数非常大，所以我们考虑一下剪枝，我们可以提前知道对于某一个数位上的两个字母，枚举的时候判断一下
如果这一位加一和不加一都不满足等式的话，那么这个肯定不成立，剪掉
如果最高位的两个字母相加有进位，那么还是不成立
有了这两条剪枝就能做出来了
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int N=30;
int n,k;
char e[3][N];
int q[N],path[N];
bool st[N];
bool check()//检查是否符合等式
{
for(int i=n-1,t=0;i>=0;i--)
{
int a=e[0][i]-'A',b=e[1][i]-'A',c=e[2][i]-'A';
if(path[a]!=-1&&path[b]!=-1&&path[c]!=-1)
{
a=path[a],b=path[b],c=path[c];
if(t!=-1)
{
if((a+b+t)%n!=c) return false;
if(!i&&a+b+t>n) return false;
t=(a+b+t)/n;
}
else
{
if((a+b+0)%n!=c&&(a+b+1)%n!=c)
return false;
if(!i&&a+b>=n)
return false;
}
}
else t=-1;
}
return true;
}
bool dfs(int u)//枚举函数
{
if(u==n)
return true;
for(int i=0;i<n;i++)
{
if(!st[i])
{
st[i]=true;
path[q[u]]=i;
if(check()&&dfs(u+1))return true;
st[i]=false;
path[q[u]]=-1;
}
}
return false;
}
int main()
{
cin>>n;
for(int i=0;i<3;i++)
scanf("%s",e[i]);
for(int i=n-1;i>=0;i--)
for(int j=0;j<3;j++)
{
int t=e[j][i]-'A';
if(!st[t])
{
st[t]=true;
q[k++]=t;//q记录的是字母出现的顺序
}
}
memset(st,false,sizeof(st));//代表这个数字是不是被用过
memset(path,-1,sizeof(path));//代表这个字母是不是被赋值
dfs(0);
for(int i=0;i<n;i++)
cout<<path[i]<<" ";
cout<<endl;
return 0;
}