目录
标题：数位和
标题：数字划分
标题：树形显示
标题： 小数第n位
标题：分考场
标题：合根植物
标题：数位和
数学家高斯很小的时候就天分过人。一次老师指定的算数题目是：1 2 ... 100。 高斯立即做出答案：5050!
这次你的任务是类似的。但并非是把一个个的数字加起来，而是对该数字的每一个数位作累加。 这样从1加到100的“和”是：901
从10加到15是：21，也就是：1 0 1 1 1 2 1 3 1 4 1 5，这个口算都可以出结果的。
按这样的“加法”，从1加到1000是多少呢？ 请通过浏览器提交该结果。
当然，我们并不期望你能像高斯一样，发现数字背后深奥的秘密，只要请计算机帮忙，一切都easy!
注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）
代码语言：javascript复制package action;
public class demo {
public static void main(String[] args) {
int sum = 0;
String str = "";
for (int i = 1; i <= 1000; i ) {
str = i;
}
char[] arr = str.toCharArray();
for (int i = 0; i < arr.length; i ) {
sum = arr[i] - '0';
}
System.out.println(sum);
}
}标题：数字划分
w星球的长老交给小明一个任务： 1,2,3...16 这16个数字分为两组。 要求： 这两组数字的和相同， 并且，两组数字的平方和也相同， 并且，两组数字的立方和也相同。
请你利用计算机的强大搜索能力解决这个问题。 并提交1所在的那个分组的所有数字。
这些数字要从小到大排列，两个数字间用一个空格分开。 即类似：1 4 5 8 ... 这样的答案。
注意，只提交这一组数字，不要填写任何多余的内容。
代码语言：javascript复制package action;
import java.util.Vector;
public class demo {
public static void main(String[] args) {
for (int w = 1; w <= (1 << 16) - 1; w = 2) {// 枚举有1出现的数组的所有情况，将其表示成十进制和的形式
Vector<Integer> group1 = new Vector<Integer>();
Vector<Integer> group2 = new Vector<Integer>();
int k;
int s1[] = new int[2];// s[1]表示1所在分组的和，s[0]表示1不在分组的和
int s2[] = new int[2];// s2[1]表示1所在组的平方和，s2[0]表示1不在组的平方和
int s3[] = new int[2];// s3[1]表示1所在组的立方和，s3[0]表示1不在组的立方和
// 将w十进制转为二进制
for (int i = 0; i < 16; i ) {
int m = 1 << i;
if ((w & m) != 0) {// 按位与判断当前数字是否在1分组中
k = 1;
} else
k = 0;
if (k == 1)
group1.add(i 1);
else
group2.add(i 1);
s1[k] = i 1;
s2[k] = (i 1) * (i 1);
s3[k] = (i 1) * (i 1) * (i 1);
}
if (s1[0] == s1[1] && s2[0] == s2[1] && s3[0] == s3[1]) {
for (int i = 0; i < group1.size(); i )
System.out.print(group1.get(i) " ");
System.out.println();
}
}
}
}标题：树形显示
对于分类结构可以用树形来形象地表示。比如：文件系统就是典型的例子。
树中的结点具有父子关系。我们在显示的时候，把子项向右缩进（用空格，不是tab），并添加必要的连接线，以使其层次关系更醒目。
下面的代码就是为了这个目的的，请仔细阅读源码，并填写划线部分缺少的代码。
代码语言：javascript复制import java.util.*;
class MyTree
{
private Map<String, List<String>> map_ch = new HashMap<String, List<String>>();
private Map<String,String> map_pa = new HashMap<String,String>();
public void add(String parent, String child)
{
map_pa.put(child, parent);
List<String> lst = map_ch.get(parent);
if(lst==null){
lst = new ArrayList<String>();
map_ch.put(parent, lst);
}
lst.add(child);
}
public String get_parent(String me){
return map_pa.get(me);
}
public List<String> get_child(String me){
return map_ch.get(me);
}
private String space(int n)
{
String s = "";
for(int i=0; i<n; i ) s = ' ';
return s;
}
private boolean last_child(String x){
String pa = map_pa.get(x);
if(pa==null) return true;
List<String> lst = map_ch.get(pa);
return lst.get(lst.size()-1).equals(x);
}
public void show(String x){
String s = " --" x;
String pa = x;
while(true){
pa = map_pa.get(pa);
if(pa==null) break;
s = ___________________________________ ; // 填空
}
System.out.println(s);
}
public void dfs(String x){
show(x);
List<String> lst = map_ch.get(x);
if(lst==null) return;
for(String it: lst){
dfs(it);
}
}
}
public class TreeView
{
public static void main(String[] args)
{
MyTree tree = new MyTree();
tree.add("root", "dog");
tree.add("root", "cat");
tree.add("root", "duck");
tree.add("dog", "AAdog");
tree.add("dog", "BBdog");
tree.add("dog", "CCdog");
tree.add("AAdog", "AAdog01");
tree.add("AAdog", "AAdog02");
tree.add("cat", "XXcat");
tree.add("cat", "YYcat");
tree.add("XXcat","XXcat-oo");
tree.add("XXcat","XXcat-qq");
tree.add("XXcat-qq", "XXcat-qq-hahah");
tree.add("duck", "TTduck");
tree.add("TTduck", "TTduck-001");
tree.add("TTduck", "TTduck-002");
tree.add("TTduck", "TTduck-003");
tree.add("YYcat","YYcat.hello");
tree.add("YYcat","YYcat.yes");
tree.add("YYcat","YYcat.me");
tree.dfs("root");
}
}对于题目中的测试数据，输出结果: --root --dog | --AAdog | | --AAdog01 | | --AAdog02 | --BBdog | --CCdog --cat | --XXcat | | --XXcat-oo | | --XXcat-qq | | --XXcat-qq-hahah | --YYcat | --YYcat.hello | --YYcat.yes | --YYcat.me --duck --TTduck --TTduck-001 --TTduck-002 --TTduck-003 如有平字体对齐问题，可以参见图【p1.png】
注意，只填写划线部分缺少的代码，不要抄写已有的代码或符号。
填空内容：
代码语言：javascript复制s = (last_child(pa) ? " " : "|") space(4) s;package action;
import java.util.*;
class MyTree {
private Map<String, List<String>> map_ch = new HashMap<String, List<String>>();
private Map<String, String> map_pa = new HashMap<String, String>();
public void add(String parent, String child) {
map_pa.put(child, parent);
List<String> lst = map_ch.get(parent);
if (lst == null) {
lst = new ArrayList<String>();
map_ch.put(parent, lst);
}
lst.add(child);
}
public String get_parent(String me) {
return map_pa.get(me);
}
public List<String> get_child(String me) {
return map_ch.get(me);
}
private String space(int n) {
String s = "";
for (int i = 0; i < n; i )
s = ' ';
return s;
}
private boolean last_child(String x) {
String pa = map_pa.get(x);
if (pa == null)
return true;
List<String> lst = map_ch.get(pa);
return lst.get(lst.size() - 1).equals(x);
}
public void show(String x) {
String s = " --" x;
String pa = x;
while (true) {
pa = map_pa.get(pa);
if (pa == null)
break;
s = s = (last_child(pa) ? " " : "|") space(4) s; // 填空 s = (last_child(pa) ? " " : "|") space(4) s;
}
System.out.println(s);
}
public void dfs(String x) {
show(x);
List<String> lst = map_ch.get(x);
if (lst == null)
return;
for (String it : lst) {
dfs(it);
}
}
}
public class TreeView {
public static void main(String[] args) {
MyTree tree = new MyTree();
tree.add("root", "dog");
tree.add("root", "cat");
tree.add("root", "duck");
tree.add("dog", "AAdog");
tree.add("dog", "BBdog");
tree.add("dog", "CCdog");
tree.add("AAdog", "AAdog01");
tree.add("AAdog", "AAdog02");
tree.add("cat", "XXcat");
tree.add("cat", "YYcat");
tree.add("XXcat", "XXcat-oo");
tree.add("XXcat", "XXcat-qq");
tree.add("XXcat-qq", "XXcat-qq-hahah");
tree.add("duck", "TTduck");
tree.add("TTduck", "TTduck-001");
tree.add("TTduck", "TTduck-002");
tree.add("TTduck", "TTduck-003");
tree.add("YYcat", "YYcat.hello");
tree.add("YYcat", "YYcat.yes");
tree.add("YYcat", "YYcat.me");
tree.dfs("root");
}
}输出效果：
标题： 小数第n位
我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。 如果我们把有限小数的末尾加上无限多个0，它们就有了统一的形式。
本题的任务是：在上面的约定下，求整数除法小数点后的第n位开始的3位数。
输入： 一行三个整数：a b n，用空格分开。a是被除数，b是除数，n是所求的小数后位置（0<a,b,n<1000000000） 输出： 一行3位数字，表示：a除以b，小数后第n位开始的3位数字。
比如： 输入： 1 8 1
程序应该输出： 125
再比如： 输入： 1 8 3
程序应该输出： 500
再比如： 输入： 282866 999000 6
程序应该输出： 914
资源约定： 峰值内存消耗 < 256M CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。 注意：主类的名字必须是：Main，否则按无效代码处理。
代码语言：javascript复制package action;
import java.util.*;
public class demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int len = sc.nextInt();
sc.close();
a = a % b;
String str = "";
int i = len 2;
// 遍历掉大量的无用数据
for (; i > 10; i -= 7) {
a = a * 10000000 % b;
if (a == 0) { // 如果整除则直接跳出
break;
}
}
for (; i > 0; i--) {
if (i <= 3) {
str = str a * 10 / b; // 最后三位使用字符串保存
}
if (a == 0) { // 如果整除则直接跳出
break;
}
a = a * 10 % b;
}
while (str.length() < 3) { // 将字符串的长度补到3
str = str "0";
}
System.out.println(str);
}
}
标题：分考场
n个人参加某项特殊考试。 为了公平，要求任何两个认识的人不能分在同一个考场。 求是少需要分几个考场才能满足条件。
输入格式： 第一行，一个整数n(1<n<100)，表示参加考试的人数。 第二行，一个整数m，表示接下来有m行数据 以下m行每行的格式为：两个整数a，b，用空格分开 (1<=a,b<=n) 表示第a个人与第b个人认识。
输出格式： 一行一个整数，表示最少分几个考场。
例如： 输入： 5 8 1 2 1 3 1 4 2 3 2 4 2 5 3 4 4 5
程序应该输出： 4
再比如： 输入： 5 10 1 2 1 3 1 4 1 5 2 3 2 4 2 5 3 4 3 5 4 5
则程序应该输出： 5
资源约定： 峰值内存消耗 < 256M CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。 注意：主类的名字必须是：Main，否则按无效代码处理。
代码语言：javascript复制package action;
import java.util.*;
public class demo {
public static int n = 0, m = 0, min = 1000;
public static boolean[][] know;
public static int[][] kaochang;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
know = new boolean[n 1][n 1];
kaochang = new int[n 1][n 1];
for (int i = 0; i < m; i ) {
int c = sc.nextInt();
int d = sc.nextInt();
know[c][d] = true;
know[d][c] = true;
}
sc.close();
f(1, 1);
System.out.println(min);
}
public static void f(int a, int b) {// a是考场b是人
if (b >= n 1) {
min = Math.min(a, min);
return;
}
if (a >= min) {
return;
}
A: for (int i = 1; i <= a; i ) {
int j;
for (j = 1; j < b; j ) {
if (kaochang[i][j] != 0) {
if (know[b][j]) {
continue A;
}
}
}
if (j == b) {
kaochang[i][b] = b;
f(a, b 1);
kaochang[i][b] = 0;
}
}
kaochang[a 1][b] = b;
f(a 1, b 1);
kaochang[a 1][b] = 0;
}
}
标题：合根植物
w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。 这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。
如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
输入格式： 第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1<m,n<1000）。 接下来一行，一个整数k，表示下面还有k行数据(0<k<100000) 接下来k行，第行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。
格子的编号一行一行，从上到下，从左到右编号。 比如：5 * 4 的小格子，编号： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
样例输入： 5 4 16 2 3 1 5 5 9 4 8 7 8 9 10 10 11 11 12 10 14 12 16 14 18 17 18 15 19 19 20 9 13 13 17
样例输出： 5
其合根情况参考图[p1.png]
资源约定： 峰值内存消耗 < 256M CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。 注意：主类的名字必须是：Main，否则按无效代码处理。
代码语言：javascript复制package action;
import java.util.*;
public class demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int a, b, c, d;
int[] shu = new int[m * n 1];
int[][] num = new int[n][m];
int k = sc.nextInt();
for (int i = 0; i < shu.length; i ) {
shu[i] = i;
}
for (int i = 0; i < k; i ) {
c = sc.nextInt();
d = sc.nextInt();
a = Math.min(c, d);
b = Math.max(c, d);
if (shu[b] == b) {
shu[b] = shu[a];
} else {
shu[a] = shu[b];
}
}
int count = 0;
for (int i = 1; i < shu.length; i ) {
if (shu[i] == i) {
count ;
}
}
System.out.println(count);
}
}
