第七题
题目：
标题：日期问题
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
答案：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
String aa=in.nextLine();
int a1,a2,a3;
a1=(int)(aa.charAt(0)-'0')*10+(int)(aa.charAt(1)-'0');
a2=(int)(aa.charAt(3)-'0')*10+(int)(aa.charAt(4)-'0');
a3=(int)(aa.charAt(6)-'0')*10+(int)(aa.charAt(7)-'0');
int b1=0,b2=0,b3=0;
while(true){
if(a2>=13)
break;
if(a3>31)
break;
if((a2==2||a2==4||a2==6||a2==9||a2==11)&&a3>30)
break;
if(a2==2&&a1%4==0&&a3>29)
break;
if(a2==2&&a1%4!=0&&a3>28)
break;
if(a1>=60)
b1+=19*1000000+a1*10000;
else
b1+=20*1000000+a1*10000;
b1+=a2*100;
b1+=a3;
break;
}
while(true){
if(a2>=13)
break;
if(a1>31)
break;
if((a2==2||a2==4||a2==6||a2==9||a2==11)&&a1>30)
break;
if(a2==2&&a3%4==0&&a1>29)
break;
if(a2==2&&a3%4!=0&&a1>28)
break;
if(a3>=60)
b2+=19*1000000+a3*10000;
else
b2+=20*1000000+a3*10000;
b2+=a2*100;
b2+=a1;
break;
}
while(true){
if(a1>=13)
break;
if(a2>31)
break;
if((a1==2||a1==4||a1==6||a1==9||a1==11)&&a2>30)
break;
if(a1==2&&a3%4==0&&a2>29)
break;
if(a1==2&&a3%4!=0&&a2>28)
break;
if(a3>=60)
b3+=19*1000000+a3*10000;
else
b3+=20*1000000+a3*10000;
b3+=a1*100;
b3+=a2;
break;
}
int b4;
if(b1>b2){
b4=b1;
b1=b2;
b2=b4;
}
if(b1>b3){
b4=b1;
b1=b3;
b3=b4;
}
if(b2>b3){
b4=b2;
b2=b3;
b3=b4;
}
if(b1!=0){
System.out.print(b1/10000+"-");
if(b1/100%100<10)
System.out.print(0);
System.out.print(b1/100%100+"-");
if(b1%100<10)
System.out.print(0);
System.out.println(b1%100);
}
if(b2!=0){
System.out.print(b2/10000+"-");
if(b2/100%100<10)
System.out.print(0);
System.out.print(b2/100%100+"-");
if(b2%100<10)
System.out.print(0);
System.out.println(b2%100);
}
if(b3!=0){
System.out.print(b3/10000+"-");
if(b3/100%100<10)
System.out.print(0);
System.out.print(b3/100%100+"-");
if(b3%100<10)
System.out.print(0);
System.out.println(b3%100);
}
}
}这道题没什么难度，既不存在时间复杂度超时也不存在空间复杂度超时，就懒得写分析和思路了，题目只需要以年月日的规则来设置程序即可。
第八题
题目：
标题：包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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，所有奇数都凑不出来，所以有无限多个。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
提交程序时，注意选择所期望的语言类型和编译器类型。
答案：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int[] arr=new int[n];
for(int i=0;i<n;i++){
arr[i]=in.nextInt();//存储输入数据
}
if(n==1&&arr[0]!=1){
System.out.println("INF");//只有一个数且不为1时肯定inf
return;
}
int t1=arr[0],t2;
for(int i=1;i<n;i++){
t2=arr[i];
if(t1<t2){
int xxxx=t1;
t1=t2;
t2=xxxx;
}
t1=p(t1,t2);//p方法用以计算两个数的最大公约数
}
if(t1!=1){//只要最大公约数不为1则INF，原理是拓展欧几里得算法，记着就行
System.out.print("INF");
return;
}
boolean[] bo=new boolean[15000];//对15000个数进行逐一判断，如果可以就true
for(int i=0;i<n;i++){
bo[arr[i]]=true;
}
for(int j=0;j<n;j++){
for(int i=arr[j];i<15000;i++){
//由完全背包问题可得，如果从小往大依次判断，如果这个判断的数可得，那么存在一个数，判断数减去这个数必定等于原始数里的某一个数
if(bo[i-arr[j]]==true)
bo[i]=true;
}
}
int sum=0;
for(int i=1;i<15000;i++){
if(bo[i]==false)
sum++;
}
System.out.println(sum);
}
public static int p(int x,int y){//欧几里得的辗转相除法
int a;
while(true){
a=x%y;
if(a==0)
break;
x=a;
if(x<y){
int t=x;
x=y;
y=t;
}
}
return y;
}
}分析：
难点1：拓展欧几里得如果不会，这道题想破脑子也搞不定（所以这道题笔者认为是考验数学常识性问题，对于普通本科的学生很不友好——因为在这里没有人会提前告诉学生什么是拓展欧几里得，怎么用，定理不会，题目必懵）
难点2：动态规划之完全背包问题——由完全背包问题可得，如果从小往大依次判断，如果这个判断的数可得，那么存在一个数，判断数减去这个数必定等于原始数里的某一个数
自拟了最大数据检测，没有超时。
第九题
题目：
标题： 分巧克力
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
1. 形状是正方形，边长是整数
2. 大小相同
例如一块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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
答案：
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Main{
static int n,k;
static long[][] ar;
static long area;
public static void main(String[] args){
try{
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
//当输入数据很大的时候，要用bufferedreader方法来存储数据（速度快），并且用readLine来存储字符串（回车结束）再用parseInt方法，
//虽然就一个输入代码会比用Scanner复杂的多，但是速度却快几倍甚至几十倍
String[] iu=in.readLine().split(" ");
n=Integer.parseInt(iu[0]);
k=Integer.parseInt(iu[1]);
ar=new long[n][2];
area=0;
for(int i=0;i<n;i++){
String[] aaa=in.readLine().split(" ");
ar[i][0]=Integer.parseInt(aaa[0]);
ar[i][1]=Integer.parseInt(aaa[1]);
area+=ar[i][0]*ar[i][1];
}}
//判断最理想的情况下可以切出的块数，也就是一点巧克力都不剩
catch(Exception e){}
long x=(int)Math.sqrt(area/k);
long y=1;
long p=x;
long sum;
while(true){
sum=0;
for(int i=0;i<n;i++){
sum+=(ar[i][0]/p)*(ar[i][1]/p);
}//判断目前最大的块数可不可行
if(sum<k){
x=p;
p=(x+y)/2;
continue;
}//如果不可行，取最理想化的中间值，判断其是否可行
//使用的方法类似用二分法查找可行的最大数据
if(sum>=k){
y=p;
p=(x+y)/2;
if(p==y){
System.out.print(p);
return;
}//如果可行，取最理想化的进一步中间值，如果中间值和最大值一样，那么说明答案出来了
continue;
}
}
}
}分析：
就本题思路的难点来说，也就是
1.使用二分法查找最大块数。
2.如何定位二分法的初始范围（也就是1到最理想块数之间）。
3.发现题目的巧克力肯定是长方形或者正方形，而要切出正方形的巧克力，也就是说只会和长方形的边长除以正方形边长的结果有关。
而就本题输入特点来说
需要使用BufferedReader，因为输入的数据不仅大，并且还多，Scanner方法虽然使用简单，但是效率低下，因此需要使用BufferedReader——readLine()输入字符串，再拆分字符串为两个int类型数据的一套流办法来解决输入数据过大导致的时间消耗过长。
至于BufferedReader和Scannerd的区别，网上有很多资料，这里就不详细解释了。
第十题
题目：
标题： 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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
答案：
import java.util.ArrayList;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int k=in.nextInt();
ArrayList<Integer> aa=new ArrayList<Integer>();
int sum=0;
aa.add(in.nextInt()%k);
for(int i=1;i<n;i++){
aa.add((aa.get(i-1)+in.nextInt())%k);//只取前面的数加此数的k的余数
}
for(int i=0;i<aa.size();i++){//先找从第一个数到i个数有没有k倍区间
if(aa.get(i)==0)
sum++;
}
for(int i=0;i<aa.size();i++){
int j=i+1;
int p=0;
while(j<aa.size()){
if(aa.get(i)==aa.get(j)){//若两个点的余数相同，则表明这两个点之间的区间是k倍区间
p++;
aa.remove(j);//当找到区间时，避免在下一次遍历使重复抽取此空间，需要去除此空间
j--;
}
j++;
}
if(p>0){//当找到了p个区间是k倍区间，那么相当于有p+1个k倍区间相邻，也就有p+...+1个结合区间
sum+=(p+1)*p/2;
}
}
System.out.println(sum);
}
}
分析：
1.老话，死办法必超时
2.考虑到是余数问题，所以只需要存储其余数即可
3.如何进一步的减少时间复杂度是关键：（i,j）的区间余数等于(x,j)-(x,i)的余数，x<=j,因此可以直接求（0，i）的和来代入每个单位作为其值。
4.得好好感谢这道题的灵感来源：蓝桥杯——历届真题——最大子阵问题，如果看不懂这道题的思路，可以参考最大子阵的解法
8898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
