蓝桥杯java训练题（1）

625这个数字很特别，625的平方等于390625，刚好其末3位是625本身，除了625，还有其他的3位数有这个特征吗？
请编写程序，寻找所有这样的3位数：它的平方的末3位是这个数字本身。
输出结果中，从小到大，每个找到的数字占一行。比如那个625就输出为：625

package 蓝桥杯;

public class test3 {
	public static void main(String[] arg)
	{
		for(int i=100;i<=999;i++)
		{
			int doublee=i*i;
			if(doublee%1000==i)
				System.out.println(i);
				
		}
	}

}

ps:注意点：（1）3位数（审题清楚）
（2）取整数的末3位，直接%1000.

2.考虑方程式： a∧3 + b∧3 =c∧3 + d ∧3
其中：“∧”表示乘方。a, b ,c,d 是互不相同的小于30的正整数。这个方程有很多解。比如：a=1, b=12, c=9, d=10 就是一个解。因为：1的立方加12的立方等于1729，而9的立方加10的立方也等于1729. 当然，a=12,b=1,c=9,d=10显然也是解。
如果不计abcd交换次序的情况，这算同一个解。你的所有小于30的不同的正整数解。把 a b c d 按从小到大排列，用逗号分隔，每个解占用一行。比如，刚才的解输出为：1，9，10，12
不同解间的顺序可以不考虑。

package 蓝桥杯;


public class test41 {
	public static void main(String[] arg)
	{
		int three[]=new int[30];
		for(int i=1;i<30;i++)
		{
			three[i]=i*i*i;
		}
		for(int a=1;a<=26;a++)
		{
			for(int b=a+1;b<=27;b++)
			{
				for(int c=b+1;c<=28;c++)
				{
					for(int d=c+1;d<=29;d++)
					{
						if((three[a]+three[d])==(three[b]+three[c]))	
						{
							System.out.println(a+","+b+","+c+","+d);
						}
					}
				}
			}
		}
	}

}

ps:按从小到大输出，不妨我们假设a<b<c<d ,则 a∧3 +d∧3=b∧3 + c∧3.

3.整数的分划问题。
如，对于正整数n=6 , 可以分划为：
6
5+1
4+2，4+1+1
3+3，3+2+1，3+1+1+1
2+2+2，2+2+1+1，2+1+1+1+1
1+1+1+1+1+1
现在的问题是，对于给定的正整数n，编写算法打印所有划分，用户从键盘输入n（范围1~10）程序输出该整数的所有划分。

一，

package 蓝桥杯;

import java.util.*;

public class test5 {
	private static LinkedList<String> str=new LinkedList<String>();
	public static void main(String[] args)
	{
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入一个1~10的整数：");
		int input =scanner.nextInt();
		test5.integerDivide(input,input);
	}
	
	private static void integerDivide(int limit, int max) {
		
		if(1==max)
		{
			str.add(String.valueOf(1));
			formatResult(str);
			str.removeLast();
			return;
		}
		if(0==max)
		{
			formatResult(str);
			return;
		}
		for(int i=limit;i>=1;--i)
		{
			if(i<=max)
			{
				str.add(String.valueOf(i));
				integerDivide(i,max-i);
				str.removeLast();
			}
		}
	}

	private static void formatResult(LinkedList<String> s) {
		System.out.print(s.getFirst());
		for(int i=1;i<s.size();i++)
			System.out.print("+"+s.get(i));
		System.out.println();
		
	}
}

二，

package 蓝桥杯;

import java.util.LinkedList;
import java.util.Scanner;

public class test51 {
	private static LinkedList<String> arg=new LinkedList<String>();
	public static void main(String[] args)
	{
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入一个1~10的整数：");
		int n=scanner.nextInt();
		devide(n);
		
	}
	public static void devide(int n)
	{
		if(n==0)
		{
			printresult(arg);
			return;
		}
		if(n==1)
		{
			arg.add(String.valueOf(1));
			printresult(arg);
			arg.removeLast();
			return;
		}
		for(int i=n;i>=1;i--)
		{
			if((arg.size()>0&&i<=Integer.valueOf(arg.getLast())||arg.size()==0))
			{
				arg.add(String.valueOf(i));
				devide(n-i);
				arg.removeLast();
			}
		}
	}
	
	public static void printresult(LinkedList<String> arg)
	{
		System.out.print(arg.getFirst());
		for(int i=1;i<arg.size();i++)
			System.out.print("+"+arg.get(i));
		System.out.println();
	}

}

PS：思考
1.每个式子组成的长度未知，所以这里用LinkedList类型，LinkedList用链表实现，可以起到类似动态数组的作用。
2.根据题目提示，得到加法式的首位数字由 n 到 1，所以想到用 for 循环来处理。
3.整体思路：逐级递归，直到最小结构。比如：当n=6时，加法式第一位数字取 4，则后面只需加上对 2（6-4）的分解。那什么时候为最小结构呢？我们知道对0 和 1 ，我们都是不需要再分解的，所以我们单独考虑 0和 1 的情况（即最小结构）。
4.对于递归中的数，如果我们不加以约束，则很可能会出现这种情况：

5.如果过分约束，则又会出现这种情况：

6.也即要保证加法式前面的数都大于等于后面的数，且不重不漏，要下一番思考。

正确结果：