本文介绍了一位助手小明面临的问题：如何根据老板夫人的购物清单计算所需现金，同时涉及等差素数列的最小公差寻找。算法展示了如何处理取现和计算最小金额，以及在数论领域中的应用。
1.购物单
小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。
老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
你的任务是计算出，小明最少需要取多少现金。
输入
本题无输入，购物单如下，物品名称被隐藏了。
180.90 88
10.25 65
56.14 90
104.65 90
100.30 88
297.15 50
26.75 65
130.62 50
240.28 58
270.62 80
115.87 88
247.34 95
73.21 90
101.00 50
79.54 50
278.44 70
199.26 50
12.97 90
166.30 78
125.50 58
84.98 90
113.35 68
166.57 50
42.56 90
81.90 95
131.78 80
255.89 78
109.17 90
146.69 68
139.33 65
141.16 78
154.74 80
59.42 80
85.44 68
293.70 88
261.79 65
11.30 88
268.27 58
128.29 88
251.03 80
208.39 75
128.88 75
62.06 90
225.87 75
12.89 75
34.28 75
62.16 58
129.12 50
218.37 50
289.69 80
需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。
输出
输出一个整数表示小明要从取款机上提取的金额，单位是元。
来源/分类
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn=1e6+10;
int main()
{
/*double sum=0;
for(int i=1;i<=50;i++)
{
double x;
int p;
scanf("%lf %d",&x,&p);
sum+=x*p/100.0;
//printf("%lf\n",sum);
}
printf("%lf\n",sum);*/
printf("%d\n",5200);
}
2.等差素数列
2,3,5,7,11,13,…是素数序列。
类似：7,37,67,97,127,157 这样全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。
2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。
这是数论领域一项惊人的成果！
有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：
长度为10的等差素数列，其公差最小值是多少？
输出
输出一个整数表示答案
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn=1e6+10;
int v[maxn];
int a[maxn];
int b[maxn];
int k=0;
void init()
{
memset(v,1,sizeof(v));
v[0]=0,v[1]=0;
for(int i=2; i<=maxn; i++)
{
if(v[i])
{
a[k++]=i;
for(int j=2*i; j<=maxn; j+=i) v[j]=0;
}
}
}
int main()
{
init();
int d=1;
for(d=1; d<=maxn; d++)
{
for(int i=0; i<k; i++) //a[i]
{
int f=0;
if(v[a[i]+d])
{
for(int h=2;h<=9;h++)
{
if(v[a[i]+h*d]==0)
{
f=1;
break;
}
}
if(v[a[i]+10*d]) f=1;
}
else f=1;
if(f==0)
{
printf("%d %d\n",a[i],d);
return 0;
}
}
}
printf("%d\n",210);
}
3.承压计算
X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。
其中的数字代表金属块的重量（计量单位较大）。（参考输入中的金字塔）
最下一层的X代表30台极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：2086458231
请你推算出：读数最大的电子秤的示数为多少？
输入
本题无输入
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
输出
输出一个整数表示答案
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
double a[40][40],ans[40],sum=0;
int main()
{
for(int i=1;i<=29;i++)
for(int j=1;j<=i;j++)
cin>>a[i][j];
for(int i=1;i<=29;i++)
{
for(int j=1;j<=i;j++)
{
a[i][j]=a[i][j]+a[i-1][j]*1.0/2+a[i-1][j-1]*1.0/2;
}
}
for(int i=1;i<=30;i++)
{
ans[i]=a[29][i]*1.0/2+a[29][i-1]*1.0/2;
}
sort(ans+1,ans+31);
printf("%.0lf\n",ans[30]*2086458231/ans[1]);
printf("72665192664");
}
4方格分割
题目描述
6x6的方格，沿着格子的边线剪开成两部分。要求这两部分的形状完全相同。如图就是可行的分割法。
试计算：包括这3种分法在内，一共有多少种不同的分割方法。注意：旋转对称的属于同一种分割法。
输出
输出一个整数表示答案
题解：
观察可以知道，分界线上的点在图案上是关于点（3，3）对称的，所以从这个点开始向四个方向搜索，
因为上下方向是对称的，搜的时候会重复计算。左右方向同理，所以最后结果要除以4
答案：509
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int f[4][2]={1,0,0,1,-1,0,0,-1};
int ans=0;
int vis[10][10];
void dfs(int x,int y)
{
if(x==0||y==0||y==6||x==6)
{
ans++;
return ;
}
for(int i=0;i<4;i++)
{
int dx=x+f[i][0];
int dy=y+f[i][1];
int x1=6-dx;
int y1=6-dy;
if(dx>=0&&dx<=6&&dy>=0&&dy<=6&&vis[dx][dy]==0)
{
vis[dx][dy]=vis[x1][y1]=1;
dfs(dx,dy);
vis[dx][dy]=vis[x1][y1]=0;
}
}
}
int main()
{
ans=0;
memset(vis,0,sizeof(vis));
vis[3][3]=1;
dfs(3,3);
printf("%d\n",ans/4);
}
5．取数位
求 1 个整数的第 k 位数字有很多种方法。
以下的方法就是一种。
对于题目中的测试数据，应该打印 5。
请仔细分析源码，并补充划线部分所缺少的代码。
注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。
// 求 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;
}
#include <stdio.h>
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 f(x/10,k++); //填空
}
int main()
{
int x = 23574;
printf("%d\n", f(x,3));
return 0;
}
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;
}
#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] = a[i-1][j-1]+1; //填空
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
int main()
{
printf("%d\n", f("abcdkkk", "baabcdadabc"));
return 0;
}
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
资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意： main函数需要返回0; 只使用ANSI C/ANSI C++ 标准; 不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include 不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
#include <iostream>
#include <algorithm>
using namespace std;
const int year1 = 1900;
const int year2 = 2000;
int mo[13] = {0,31,29,31,30,31,30,31,31,30,31,30,31};
struct node{
int year,month,day;
bool operator == (const node& d)
{
if(year==d.year && month==d.month && day==d.day) return true;
else return false;
}
} data[10];
int cnt,a,b,c;
string str;
bool cmp(node n1,node n2){
if(n1.year == n2.year){
if(n1.month == n2.month){
return n1.day < n2.day;
}
else return n1.month < n2.month;
}
else return n1.year < n2.year;
}
void judgeSave(int y,int m,int d){//判断并保存
if(y < 1960 || y > 2059) return;//年份
if(m < 1 || m > 12) return;//月份
//平年 2月不超过29
if(y%4!=0 || (y%4==0&&y%100==0&&y%400!=0)){
if(m==2 && d >= 29) return;
}
//对应月份的天数不对
if(d > mo[m] ||d < 1) return;
//save
data[cnt].year = y,data[cnt].month = m,data[cnt++].day = d;
}
void solve(){
cin >> str;
for(int i = 0;i < 2;i++) a = a*10+str[i]-'0';
for(int i = 3;i < 5;i++) b = b*10+str[i]-'0';
for(int i = 6;i < 8;i++) c = c*10+str[i]-'0';
judgeSave(a+year1,b,c);
judgeSave(c+year1,b,a);
judgeSave(c+year1,a,b);
judgeSave(a+year2,b,c);
judgeSave(c+year2,b,a);
judgeSave(c+year2,a,b);
sort(data,data+cnt,cmp);//排序
int fcnt = unique(data,data+cnt)-data;//去重
// cout << fcnt << endl;
for(int i = 0;i < fcnt;i++){
printf("%d-%02d-%02d\n",data[i].year,data[i].month,data[i].day);
}
}
int main(){
solve();
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。
样例输入 Copy
2
4
5
样例输出 Copy
6
方法一:
#include<bits/stdc++.h>//万能头文件，基本上包含C和C++里所有的头文件
using namespace std;
int gcd(int a,int b)//求两个数的最大公约数
{
if(b==0)
return a;
gcd(b,a%b);
}
int s[10000],str[1000000]={0};//数组s用来存所给包子数，数组str用来记录:当str[i]等于1时，表示i可以被所给包子数组合而成，所以str的空间大小越大越好，不过开到1000000就可以过所有的数据了
int main()
{
int i,j,k,a,n;
cin>>n;
for(i=0;i<n;i++)
{
cin>>s[i];
str[s[i]]=1;
}
//求所给包子数的最大公约数
k=s[0];
for(i=1;i<n;i++)
{
k=gcd(k,s[i]);
}
if(k==1)
{
for(i=0;i<n;i++)
{
for(j=1;j+s[i]<100000;j++)
{
if(str[j]==1)
{
str[j+s[i]]=1;//j+s[i]可以被组合而成
}
}
}
int sum=0;
//遍历一次数组str
for(i=1;i<100000;i++)
{
if(str[i]!=1)
sum++;
}
cout<<sum;
}
else
cout<<"INF";
}
方法二：
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
using namespace std;
const int maxn=100000;
int a[110];
int dp[maxn];
int gcd(int a,int b)
{
if(b==0) return a;
return gcd(b,a%b);
}
int main()
{
int n;
scanf("%d",&n);
scanf("%d",&a[1]);
int g=a[1];
memset(dp,0,sizeof(dp));
for(int i=2;i<=n;i++)
{
scanf("%d",&a[i]);
g=gcd(g,a[i]);
}
if(g!=1)
{
printf("INF\n");
return 0;
}
dp[0]=1;
for(int i=1;i<=n;i++)
for(int j=a[i];j<=100000;j++)
if(dp[j-a[i]])
dp[j]=1;
int ans=0;
for(int i=1;i<=100000;i++)
if(!dp[i]) ans++;
cout<<ans<<endl;
}
9.分巧克力
题意描述
儿童节那天有 K 位小朋友到小明家做客。
小明拿出了珍藏的巧克力招待小朋友们。
小明一共有 N 块巧克力，其中第 i 块是 Hi×Wi 的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出 K 块巧克力分给小朋友们。
切出的巧克力需要满足：
形状是正方形，边长是整数
大小相同
例如一块 6×5 的巧克力可以切出 6 块 2×2 的巧克力或者 2 块 3×3 的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小明计算出最大的边长是多少么？
输入格式
第一行包含两个整数 N 和 K。
以下 N 行每行包含两个整数 Hi 和 Wi。
输入保证每位小朋友至少能获得一块 1×1 的巧克力。
输出格式
输出切出的正方形巧克力最大可能的边长。
数据范围
1≤N,K≤105,
1≤Hi,Wi≤105
输入样例：
2 10
6 5
5 6
输出样例：
2
思路
同样是一道二分的题，能够切成的蛋糕的数量等于宽度/边长*高度/边长，这个时候我们就可以直接二分答案。
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int n,k;
int a[100000],b[100000];
bool check(int x)
{
int sum=0;
for(int i=1;i<=n;i++)
{
sum+=(a[i]/x)*(b[i]/x);
}
if(sum>=k) return true;
else return false;
}
int main()
{
int l=1,r=0;
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
{
scanf("%d%d",&a[i],&b[i]);
r=max(r,max(a[i],b[i]));
}
//printf("%d//\n",r);
int mid;
while(r-l>=0.000001)
{
mid=(r+l+1)/2;
if(check(mid))
{
l=mid;
}
else r=mid-1;
}
printf("%d\n",l);
}
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
资源约定
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
题目思路
求区间[l,r]的和是k的倍数的个数。求区间和，我们可以通过前缀和来求出。我们规定sum[i]表示第1个元素到第i个元素的和。那么sum[r] - sum[l-1]就是区间[l,r]的和。区间[l,r]的和是k的倍数即(sum[r] - sum[l-1])%k == 0 即sum[r]%k == sum[l-1]%k
那么，我们求出每个前缀和，在求的过程中取模，两个相等的前缀和就能组成一个k倍区间。我们可以在计算完前缀和以后，使用两层for循环来计数k倍区间的个数。但是由于数据量较大，这样是会超时的。那么我们是否能在计算前缀和的过程中来记录k倍区间的个数呢？
我们用一个数组cnt[i]表示当前位置之前，前缀和取模后等于i的个数。举个例子：
数列 1 2 3 4 5 mod = 2
对前1个数的和取模， 为1 之前有0个前缀和取模后为1，个数+0
对前2个数的和取模， 为1 之前有1个前缀和取模后为1，个数+1
对前3个数的和取模， 为0 之前有0个前缀和取模后为0, 个数+0
对前4个数的和取模， 为0 之前有1个前缀和取模后为0，个数+1
对钱5个数的和取模， 为1 之前有2个前缀和取模后为1，个数+2
到目前为止ans = 4。但是ans应该等于6，因为这样计算后，我们漏掉了前i个数的和取模是k的倍数的情况，即[0,i]区间和是k的倍数，因此，我们要在ans = 4 的基础上 加上前缀和取模后为0的个数 即ans+2 = 6;
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
const int N = 1e5+5;
ll n,k;
ll a[N],sum[N],cnt[N];
void solve()
{
/*对于区间(i-j)如果前i个的和sum(i)和前j个的和sum(j)对k取模相等，那么i-j区间的数的*和一定是k的倍数**/
scanf("%lld%lld",&n,&k);
for(int i = 1; i <= n; i++)
{
scanf("%lld",&a[i]);
sum[i] = sum[i-1]+a[i];
}
ll res = 0;
for(int i = 1; i <= n; i++)
{
res += cnt[sum[i]%k];
cnt[sum[i]%k] ++;
}
//因为这样计算后，我们漏掉了前i个数的和取模是k的倍数的情况，即[0,i]区间和是k的倍数
cout <<res+cnt[0]<< endl;
}
int main()
{
solve();
return 0;
}
扫一扫
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
