1.购物单
小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
180.90 88折
10.25 65折
56.14 9折
104.65 9折
100.30 88折
297.15 半价
26.75 65折
130.62 半价
240.28 58折
270.62 8折
115.87 88折
247.34 95折
73.21 9折
101.00 半价
79.54 半价
278.44 7折
199.26 半价
12.97 9折
166.30 78折
125.50 58折
84.98 9折
113.35 68折
166.57 半价
42.56 9折
81.90 95折
131.78 8折
255.89 78折
109.17 9折
146.69 68折
139.33 65折
141.16 78折
154.74 8折
59.42 8折
85.44 68折
293.70 88折
261.79 65折
11.30 88折
268.27 58折
128.29 88折
251.03 8折
208.39 75折
128.88 75折
62.06 9折
225.87 75折
12.89 75折
34.28 75折
62.16 58折
129.12 半价
218.37 半价
289.69 8折
需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。
请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。
特别提醒：不许携带计算器入场，也不能打开手机。
答案：52 。
思路：将数据处理一下 ，可以用记事本的替换功能 ，不用自己手动一个一个的处理 。下面是处理完以后的数据 。
#include <stdio.h>
int main()
{
printf("%lf", 180.90 *0.88
+10.25 *0.65
+56.14 * 0.9
+104.65 * 0.9
+100.30 *0.88
+297.15 * 0.5
+26.75 *0.65
+130.62 * 0.5
+240.28 *0.58
+270.62 * 0.8
+115.87 *0.88
+247.34 *0.95
+73.21 * 0.9
+101.00 * 0.5
+79.54 * 0.5
+278.44 * 0.7
+199.26 * 0.5
+12.97 * 0.9
+166.30 *0.78
+125.50 *0.58
+84.98 * 0.9
+113.35 *0.68
+166.57 * 0.5
+42.56 * 0.9
+81.90 *0.95
+131.78 * 0.8
+255.89 *0.78
+109.17 * 0.9
+146.69 *0.68
+139.33 *0.65
+141.16 *0.78
+154.74 * 0.8
+59.42 * 0.8
+85.44 *0.68
+293.70 *0.88
+261.79 *0.65
+11.30 *0.88
+268.27 *0.58
+128.29 *0.88
+251.03 * 0.8
+208.39 *0.75
+128.88 *0.75
+62.06 * 0.9
+225.87 *0.75
+12.89 *0.75
+34.28 *0.75
+62.16 *0.58
+129.12 * 0.5
+218.37 * 0.5
+289.69 * 0.8
);
}
2.等差素数列
2,3,5,7,11,13,…是素数序列。
类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。
2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。
这是数论领域一项惊人的成果！
有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：
长度为10的等差素数列，其公差最小值是多少？
注意：需要提交的是一个整数，不要填写任何多余的内容和说明文字。
————————————————
答案：210 。
思路 ：我们先生成一定范围的素数 ，然后枚举公差 ，枚举起点 ，找到符合条件的序列 ，输出公差即可 。
#include <stdio.h>
int a[1000000];
int ok(int x)
{
for(int i=2;i*i<=x;i++)
{
if(x%i==0)
return 0;
}
return 1;
}
void su()
{
for(int i=2;i<1000000;i++)
{
if(ok(i))
a[i]=1;
}
}
int main()
{
su();
int flag=0;
for(int d=1;d<100000;d++) //枚举公差
{
for(int j=2;j<=100000;j++) //枚举起点
{
int t=0;
for(int i=0;i<10;i++)
{
if(a[j+i*d]) {
t++;
continue ;
}
else {
break;
}
}
if(t==10) {
flag=1;
break;
}
}
if(flag)
{
printf("%d",d);
break;
}
}
return 0;
}
标题：承压计算
X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：2086458231
请你推算出：读数最大的电子秤的示数为多少？
答案 ：72665192664
思路：这题就是一个递归 或者说动态规划 。我们需要先把这个金字塔的数储存起来 ，怎么储存呢？通过题目我们知道 ，下面的每一项都和这个数肩上的两个值有关 ，那么我们可以这样储存 ：
然后通过递归，得到第三十层的每个数值 ，找出这一层中最大值和最小值 ，然后根据题目给的数值 ，根据比例得到最大值的示数 。
#include <stdio.h>
double a[35][35],aaa=-1,bbb=1e9;
double max(double x,double y)
{
return x>y?x:y;
}
double min(double x,double y)
{
return x<y?x:y;
}
int main()
{
for(int i=1;i<=29;i++)
{
for(int j=1;j<=i;j++)
{
scanf("%lf",&a[i][j]);
}
}
for(int i=2;i<=30;i++)
{
for(int j=1;j<=i;j++)
{
a[i][j]+=(a[i-1][j-1]+a[i-1][j])/2;
}
}
for(int i=1;i<=30;i++)
{
aaa=max(aaa,a[30][i]);
bbb=min(bbb,a[30][i]);
}
printf("%.0lf\n",aaa/bbb*2086458231);
return 0;
}
4.方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：p1.png, p2.png, p3.png 就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
答案：509 。
思路： 这个题第一次见但可能会有点蒙 ，我们应该怎么形成两个完全对称的图形呢？我们应该沿着线走 ，枚举点 。仔细分析应该可以发现 ，如果两个图形对称的话，那么必过点（3,3）。那么我们从（3,3）开始走 ，每次走两个完全相反的方向 ，每当走到边缘的时候 ，就会形成两个对称的图形 。想到这里 ，题就解决了 。题目说的旋转重复的情况 ，我们除以4即可 。
#include <stdio.h>
int next[4][2]={0,1,1,0,0,-1,-1,0};
int a[7][7];
long long ans;
void dfs(int x1,int y1,int x2,int y2)
{
if((!x1||!y1)||(!x2||!x2)||x1==6||x2==6||y1==6||y2==6)
{
ans++;
return ;
}
int tx1,tx2;
int ty1,ty2;
for(int i=0;i<4;i++)
{
tx1=x1+next[i][0];
ty1=y1+next[i][1];
tx2=x2+next[(i+2)%4][0];
ty2=y2+next[(i+2)%4][1];
if(tx1==tx2&&ty1==ty2) continue ;
if(!a[tx1][ty1]&&!a[tx2][ty2]&&tx1>=0&&tx2>=0&&ty1>=0&&ty2>=0&&tx1<7&&tx2<7&&ty1<7&&ty2<7)
{
a[tx1][ty1]=1;
a[tx2][ty2]=1;
dfs(tx1,ty1,tx2,ty2);
a[tx1][ty1]=0;
a[tx2][ty2]=0;
}
}
}
int main()
{
a[3][3]=1;
dfs(3,3,3,3);
printf("%lld",ans/4);
return 0;
}
5.取数位
求1个整数的第k位数字有很多种方法。
以下的方法就是一种。
/
/ 求x用10进制表示时的数位长度
int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}
// 取x的第k位数字
int f(int x, int k){
if(len(x)-k==0) return x%10;
return _____________________; //填空
}
int main()
{
int x = 23574;
printf("%d\n", f(x,3));
return 0;
}
对于题目中的测试数据，应该打印5。
请仔细分析源码，并补充划线部分所缺少的代码。
注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。
答案 :f(x/10,k) .
思路 ：这题应该不难想吧 。当剩下的位数不等于k的时候 ，除以十 。直到符合条件 。
6.最大公共子串
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“abcdkkk” 和 “baabcdadabc”，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。
#include <stdio.h>
#include <string.h>
#define N 256
int f(const char* s1, const char* s2)
{
int a[N][N];
int len1 = strlen(s1);
int len2 = strlen(s2);
int i,j;
memset(a,0,sizeof(int)*N*N);
int max = 0;
for(i=1; i<=len1; i++){
for(j=1; j<=len2; j++){
if(s1[i-1]==s2[j-1]) {
a[i][j] = __________________________; //填空
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
int main()
{
printf("%d\n", f("abcdkkk", "baabcdadabc"));
return 0;
}
注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字
答案 ： a[i-1][j-1]+1
7.日期问题
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。
比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。
给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
输入
一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9)
输出
输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。
样例输入
02/03/04
样例输出
2002-03-04
2004-02-03
2004-03-02
思路：本题情况数很多 ，做法也有很多，说一种我觉得比较简单的吧。首先，我们读入三个整数 ，用scanf("%d/%d/%d",&a,&b,&c);的方式便可以把三个整数保存起来了 ，输出的时候我们用printf("%02d-%02d-%02d",a,b,c);的方式，不足两位的用零补齐。我们要做的就是从19600101开始枚举，一直枚举到20591231。判断数据是否是一个合法的日期，然后再判断读入的a,b,c是否可以组成这个日期，如果可以，输出日期即可 。
#include <stdio.h>
int ri[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int a,b,c;
int ok(int x,int y,int z)
{
int tz;
if(y>12) return 0; //月份不合法
if((x%4==0&&x%100!=0)||(x%400==0)) //闰年
{
if(y==2) tz=ri[2]+1;
else tz=ri[y];
if(z>tz||!z) return 0;
}
else
{
tz=ri[y];
if(z>tz||!z) return 0;
}
return 1;
}
int main()
{
scanf("%d/%d/%d",&a,&b,&c);
for(int i=19600101;i<=20591231;i++)
{
int year =i/10000,month = i % 10000 / 100,day=i%100;
if(ok(year ,month ,day)) //日期合法
{
if((a==year%100&&b==month&&c==day)||(a==month&&b==day&&c==year%100)||(a==day&&b==month&&c==year%100)) //年月日 月日年 日月年
{
printf("%02d-%02d-%02d\n",year,month,day);
}
}
}
return 0;
}
8：包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。
每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。
当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。
小明想知道一共有多少种数目是包子大叔凑不出来的。
输入
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)
输出
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。
例如，
输入：
2
4
5
程序应该输出：
6
再例如，
输入：
2
4
6
程序应该输出：
INF
样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。
思路 ：可以用完全背包来做，但是这里介绍另一种思路。假设我们输入的n个数，他们的最大公约数都不是1 。即 ：他们都是偶数或者都是奇数 。那么 ，肯定有无数多个数是凑不出来的 。直接输出INF即可 。反之 ，我们找到n个数中最小的那个数 ，一旦我们所凑出来的连续数据长度等于这个最小数 ，那么后面的所有数 ，都可以被凑出来了，对不对？想到这里 ，本题就解决了 。
#include <stdio.h>
int a[105],b[1000005],flag,t=1e9,ans,n;
int gcd(int x,int y)
{
return !y?x:gcd(y,x%y);
}
int min(int x,int y)
{
return x<y?x:y;
}
int main()
{
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
b[a[i]]=1;
t=min(t,a[i]);
}
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(gcd(a[i],a[j])==1)
{
flag=1;
break;
}
}
if(flag) break;
}
if(!flag)
{
printf("INF");
return 0;
}
int p=0;
for(int i=1;i<=1000000;i++)
{
if(b[i])
{
p++;
for(int j=0;j<n;j++)
{
b[i+a[j]]=1;
}
}
else
{
p=0;
ans++;
}
if(p==t) break;
}
printf("%d",ans);
return 0;
}
9： 分巧克力
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
- 形状是正方形，边长是整数
- 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。
输出
输出切出的正方形巧克力最大可能的边长。
样例输入：
2 10
6 5
5 6
样例输出：
2
思路：本题需要确定所能得到的最大边长，使得生成的巧克力数量不少于k.考虑到本题数据范围为10的5次方，暴力超时，则应该采用二分查找答案的方法，如果此边长可以生成的巧克力数量不低于k，则向上缩小搜索范围（不妨理解为寻找右边界）。一个nm规格的矩形可以生产几个aa规格的正方形呢？容易得出规律，应该为(n/a)(m/a)块*
#include <stdio.h>
int n,k,h[100005],w[100005],t=1;r=1e5+1,mid;
int ok(int x)
{
int ans=0;
for(int i=1;i<=n;i++)
{
int a=h[i]/x;
int b=w[i]/x;
ans+=a*b; //一个x*y的矩形能分成x/i*y/i个i*i的正方形
}
if(ans>=k) return 1;
return 0;
}
int main()
{
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
{
scanf("%d%d",&h[i],&w[i]);
}
while(t<r) //二分查找符合要求的边长
{
mid=(t+r)/2;
if(ok(mid)) t=mid+1;
else r=mid;
}
printf("%d",t-1);
return 0;
}
10： k倍区间
给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
你能求出数列中总共有多少个K倍区间吗？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)
输出
输出一个整数，代表K倍区间的数目。
例如，
输入：
5 2
1
2
3
4
5
程序应该输出：
6
思路：题干要求我们求得是k的倍数区间，我们可以用s[i]储存前i个数，用s[i]-s[j-1]表示区间【j,i】的和。然后我们利用两层for循环枚举区间范围，寻找符合要求的区间。至此，问题似乎解决了，But题干所给的数据范围是1e5,双层循环肯定会超时，那么怎么办呢？我们来分析一下问题，题干让我们寻找的是满足（s[i]-s[j-1])%k= =0的情况，上述算法之所以会超时，原因在于需要枚举i,j的范围，那么我们是否换种思路。即求s[i]%k= =s[j-1]%k的情况有多少。因为求s[i]%k= =s[j-1]%k的情况并不需要进行枚举，只需把s[i]%=k储存 桶排序 最后再加上这个数本身就是k的倍数的情况即可。
#include <stdio.h>
long long a[100005],s[100005],v[100005],n,k,ans,temp; //满足条件 (s[r]-s[l-1])%k==0 即(s[r]%k)==(s[i-1]%k) 则符合条件
int main()
{
scanf("%lld%lld",&n,&k);
for(int i=0;i<n;i++)
{
scanf("%lld",&temp);
s[i]=(s[i-1]+temp)%k;
ans+=v[s[i]];
v[s[i]]++;
}
ans+=v[0];
printf("%lld",ans);
return 0;
}
