标题：纸牌三角形
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。
A
9 6
4 8
3 7 5 2
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。
题解：
本题实际上就是对1-9进行全排列。但是题目说了要如果考虑旋转、镜像后相同的算同一种，所以先除以3再除以2，最后算出来的结果要除以6才是我们所得的答案
代码
import java.util.Scanner;
public class Main {
public static int count=0;;
public static void main(String[] args) {
int a[]= {1,2,3,4,5,6,7,8,9};
perm(a,0,8);
System.out.println(count/6);
}
public static void perm(int a[],int k,int n) {
if(k==n) {//在全部拍完的时候在进行三边的比较
if(a[0]+a[1]+a[2]+a[3]==a[3]+a[4]+a[5]+a[6]&&a[0]+a[1]+a[2]+a[3]==a[6]+a[7]+a[8]+a[0]) {
count++;
}}
for(int i=k;i<=n;i++) {
int t=a[k];a[k]=a[i];a[i]=t;
perm(a,k+1,n);
t=a[i];a[i]=a[k];a[k]=t;
}
}
}
代码二（dfs搜索）：
import java.util.Scanner;
public class Main {
static int sum = 0;
static int a[] = new int[9];//表示A-9的纸牌
static int vis[] = new int[10];//表示纸牌是否使用
public static void main(String[] args) {
dfs(0);
System.out.println(sum/3/2);
}
public static void dfs(int n) {//n表示当前要操作的位置
if(n==9){
if(arr[0]+arr[1]+arr[2]+arr[3]==arr[3]+arr[4]+arr[5]+arr[6] && arr[3]+arr[4]+arr[5]+arr[6]==arr[6]+arr[7]+arr[8]+arr[0]){
sum++;//如果是等边三角形，则sum++
}
return ;
}
for(int i=1;i<=9;i++){
if(vis[i]==0){//如果纸牌未被使用过
a[n]=i;//将第n个位置放置第i个纸牌
vis[i]=1;//表示第i纸牌已经被使用
dfs(n+1);//进入下一个位置
vis[i]=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
请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要填写任何多余的内容。
思路：
通过题目给出每块原料的重量都十分精确地平均落在下方的两个金属块上，我们知道在每一层的数字都会平均分给下一层的左边和右边两个元素上。
很明显这题首先要将这个金字塔数给他存入到一个二维数组中，a[30][30]
然后我们观察到，每一层数字的个数等于其层次的个数。每一次我们都将扫描到的a[]i[j]/2赋值给a[i+1][j]和a[i+1][j+1]上。
最后我们可以看到输入的最小值与题目不符合，原因在于电子秤的计量单位问题，
因此我们要想得到最大值就需要将电子秤上得到的2086458231/最小值*最大值就得到了我们真正电子秤显示的示数
代码：
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
double a[][]=new double[30][30];
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j <= i; j++) {
a[i][j] = cin.nextInt();
}
}
for (int i = 0; i < 29; i++) {
for (int j = 0; j <= i; j++) {
double k=1.0*a[i][j]/2;
a[i+1][j]+=k;
a[i+1][j+1]+=k;
}
}
Arrays.sort(a[29]);
System.out.println(a[29][0]);
System.out.println(a[29][29]);
System.out.println((double)2086458231*1.0*a[29][29]/a[29][0]);
//3.8863313030451536最小值
//135.34946863353252最大值
//7.2665192664E10//真正的最大值
}
}
魔法状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
思路代码
# 取数位
求1个整数的第k位数字有很多种方法。
以下的方法就是一种。
对于题目中的测试数据，应该打印5。
请仔细分析源码，并补充划线部分所缺少的代码。
注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。。
```java
public class 取数位 {
static int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}
// 取x的第k位数字
static int f(int x, int k){
if(len(x)-k==0) return x%10;
//-------------此处需要填的内容为？
return f(x/10,k);
}
public static void main(String[] args)
{
int x = 23513;
System.out.println(f(x,3));
}
}
标题：最大公共子串
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“abcdkkk” 和 “baabcdadabc”，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。
public class 最大公共子串 {
static int f(String s1, String s2)
{
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
int[][] a = new int[c1.length+1][c2.length+1];
int max = 0;
for(int i=1; i<a.length; i++){
for(int j=1; j<a[i].length; j++){
if(c1[i-1]==c2[j-1]) {
//****填写内容****填空
a[i][j]=a[i-1][j-1]+1;
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
public static void main(String[] args){
int n = f("abcdkkk", "baabcdadabc");
System.out.println(n);
}
}
注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。
观察可以看出该题的代码是动态规划的类型；
标题：日期问题
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在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
思路：
首先我们需要定义一个字符串，并将其转换成int类型的三个数，分别代表年月日
然后我们还需要进行年月日是否匹配校验，通过题目中1960年1月1日至2059年12月31日。我们可以看到年份在0-59之内是个2000年以后的年份 60-99年是个1900年的年份。因此我们可以对年份进行加操作来得到yyyy的格式，
然后我们就要根据年份是否是闰年来对月份中的日是否合适进行判断了。这里我们就只需要判断不符合的情况进行去除就可以啦。此题的解释就到这里。哦对了，还有在输出结果时题目还要求去重和排序，我们可以考虑用Java特有功能的TreeSet来实现去重和排序
详情看代码吧
代码：
package one_day_mt;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main {
//闰年的判断
public static boolean isLeap(int a) {
{return a%4==0&&a%100!=0||a%400==0;}
}
public static String f(int a,int b,int c) {
if(a>=0&&a<=59) a+=2000;
else if(a>=60&&a<=99) a+=1900;
else return "";//进行年的转换
if(b>12||a<1) return "";//对于月份的不合法判断
if(c<1||c>31) return "";//对于日的不合法判断
boolean _isLeap=isLeap(a);
switch(b) {
case 2:
if(_isLeap&&c>29)return "";
if(!_isLeap&&c>28)return "";
break;
case 4:
if(c>30)return "";
break;
case 6:
if(c>30)return "";
break;
case 9:
if(c>30)return "";
break;
case 11:
if(c>30)return "";
break;
}
String _a=a+"";String _b=b+"";String _c=c+"";//将int※转换成String
//题目要求按照AA/BB/CC
// 因此需要判断
if(_a.length()==1) _a= "0"+_a;
if(_b.length()==1) _b= "0"+_b;
if(_c.length()==1) _c= "0"+_c;
return _a+"-"+_b+"-"+_c;
}
public static void main(String[] args){
Scanner cin=new Scanner(System.in);
String S=cin.next();
int a=0,b=0,c=0;
a=(S.charAt(0)-'0')*10+(S.charAt(1)-'0');
b=(S.charAt(3)-'0')*10+(S.charAt(4)-'0');
c=(S.charAt(6)-'0')*10+(S.charAt(7)-'0');
//3种情况
String case1=f(a,b,c);
String case2=f(c,b,a);
String case3=f(c,a,b);
//多个日期按从早到晚排列。
//需要用到TreeSet
//TreeSet具有去重和排序的作用
Set<String> ans=new TreeSet<String>();
//进行添加到TreeSet操作
if(case1!="") ans.add(case1);
if(case2!="") ans.add(case2);
if(case3!="") ans.add(case3);
//循环打印
for(String s:ans) {
System.out.println(s);
}
}
}
标题：包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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，所有奇数都凑不出来，所以有无限多个。
思路：
对于包子凑数，首先就要知道在若干笼中的个数如果是不是互质数（公因数只有1的情况），那么他的解就有无穷多个，比如4，6就不是互质数，所以输出INF，如果是互质数，那么才可以统计凑不出来的数，因此我们首先需要一个判断是不是互质数的函数咯gbc，然后通过完全背包来导出公式，（可以用Boolean类型的数组）我们知道当客人想要的包子数为0时，是肯定可以凑出来的，然后，对于商家卖的包子数量的数组下标也是可以凑出来的。
代码：
import java.util.Scanner;
public class Main {
public static int gbc(int a,int b) {
if(b==0)return a;
return gbc(b,a%b);
}
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
int g=0;//存放公约数
int n=cin.nextInt();
int a[]=new int[101];
boolean dp[]=new boolean[10000];//dp数组
dp[0]=true;//包子数为0一定可以凑出来
for(int i=1;i<=n;i++) {
a[i]=cin.nextInt();
if(i==1) {
g=a[i];//初始化最大公约数
}else {
g=gbc(a[i],g);
}
//完全背包的递推公式
for(int j=0;j<10000-a[i];j++) {
if(dp[j]) {
dp[j+a[i]]=true;
}
}
}
if(g!=1) {
System.out.println("INF");
return ;
}//不互质，就会有无穷多个解法
int count=0;//统计凑不出来的数量
for(int i=0;i<10000;i++) {
if(!dp[i]) {
count++;
}
}
System.out.println(count);
}}
别人的解法
链接: 完全背包解此题.
分巧克力
儿童节那天有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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
思路：
思路很简单，通过枚举正方形长度来进行计数；
但是如果通过数据的范围我们仅仅通过枚举不可以使得时间在1s以内，
因此采用二分加枚举，
即每次二分找一个中间长度的正方形巧克力长度进行去切，如果大于K个小朋友我们就把长度赋值给ans，并且把长度在一次往上找，看看有没有更大的了。否则将区间像下找。
代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
int N=cin.nextInt();
int K=cin.nextInt();
int h[]=new int[10000];
int w[]=new int[10000];
for(int i=0;i<N;i++) {
h[i]=cin.nextInt();
w[i]=cin.nextInt();
}
int r=10001;
int l=1;
int ans=0;
while(l<=r) {
int mid=(l+r)/2;
int count=0;
//每块巧克力都按照len来切割
for(int i=0;i<N;i++) {
count+=(h[i]/mid)+(w[i]/mid);
}
if(count>=K) {
l=mid+1;
ans=mid;
}else {
r=mid-1;
}
}
System.out.println(ans);
}}
标题： 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
思路
1.暴力法
定义一个数组和两个哨兵，每次加一个元素，并判断能否除以K，能除count++，并且，内层循环结束就要初始化t。
2.
代码
暴力法
这种方法在N，K特别大的时候就会超时。不能拿满分
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();
int i,j;
int Ai[] = new int[N];
int count = 0;
int s = 0,t = 0;
for(int m=0;m<Ai.length;m++) {
Ai[m] = in.nextInt();
}
for(int m=0;m<N;m++) {
for(j=m;j<N;j++) {
t = t+Ai[j];
if(t%k == 0)
count++;
}
t =0;
}
System.out.println(count);
}
}
前缀和
思路：
我们可以通过前缀和把Ai数组的前i项和进行保存到S数组里面，则S数组就是前Ai项和。如果我们想要得到i到j区间的和就直接是S[j]-S[i-1].然后除k，判断是否可以整除，用count来记录。
代码：
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();
int i,j;
int Ai[] = new int[100010];
int s[]=new int[100010];//前缀和
s[0]=0;
int count = 0;
for( i=1;i<=N;i++) {
Ai[i] = in.nextInt();
s[i]=s[i-1]+Ai[i];
}
for( i=1;i<=N;i++) {
for(j=i;j<=N;j++) {
//i和j之间的区间和等于s[j]-s[i-1];
if((s[j]-s[i-1])%k==0) {
count++;
}
}
}
System.out.println(count);
}
}
满分代码：
思路：
根据数学公式：同余的两个数只差也可以整除模，比如7%3=1，16%3=1，（16-7）%3=1.因此我们只需要把s[j]-s[i-1]改为（s[j]-s[i-1]）%k,然后统计这些数的个数，在进行排列即可。排列需要用到map。
import java.util.HashMap;
import java.util.Map;
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();
int i,j;
int Ai[] = new int[100010];
int s[]=new int[100010];//前缀和
Map<Integer,Long> cnt=new HashMap<Integer,Long>();//同余的个数统计
s[0]=0;
int count = 0;
cnt.put(0, 1l);
for( i=1;i<=N;i++) {
Ai[i] = in.nextInt();
s[i]=(s[i-1]+Ai[i])%k;
if(cnt.get(s[i])==null) {//将同余的数大小相等的放在字典里面
cnt.put(s[i], 1l);
}else {
cnt.put(s[i], cnt.get(s[i])+1);
}
}
long ans=0;
for(i=0;i<k;i++) {//余数必在0-k-1之间
Long ansI=cnt.get(i);
if(ansI==null)ansI=0l;
ans+=ansI*(ansI-1)/2;//随机选两个
//例如所有前缀和中%k=3的有3个，那么他们任选2可得一个k区间，C32
}
System.out.println(ans);
}
}
