ccf2015试题（java）

ccf2015试题（java）

刚刚考完ccf的试题。。。还是基础掌握的不扎实，五道题4个小时,只做出来三道题，而且没有考虑复杂的情况。。考试时间匆忙，所以没加注释。

/*
问题1
问题描述
　　旋转是图像处理的基本操作，在这个问题中，你需要将一个图像逆时针旋转90度。
　　计算机中的图像表示可以用一个矩阵来表示，为了旋转一个图像，只需要将对应的矩阵旋转即可。
输入格式
　　输入的第一行包含两个整数n, m，分别表示图像矩阵的行数和列数。
　　接下来n行每行包含m个整数，表示输入的图像。
输出格式
　　输出m行，每行包含n个整数，表示原始矩阵逆时针旋转90度后的矩阵。
样例输入
2 3
1 5 3
3 2 4
样例输出
3 4
5 2
1 3
评测用例规模与约定
　　1 ≤ n, m ≤ 1,000，矩阵中的数都是不超过1000的非负整数。*/

//我的实现
import java.util.Scanner;

public class Main {
public static void main(String[] args){
Main m = new Main();
m.exam_1();
}

public void exam_1(){
int n=0,m=0;

Scanner s = new Scanner(System.in);
//get n and m
while(true){
n = s.nextInt();
m = s.nextInt();

if(n>=1 && n<=1000 && m>=1 && m<=1000)
break;
}

int array[][] = new int
[m];
int array_result[][] =new int[m]
;
//get content
for(int row=0;row<n;row++){
for(int clo=0;clo<m;clo++){
array[row][clo] = s.nextInt();
}
}

for(int row_a=0;row_a<n;row_a++){
int temp[] = new int[m];

for(int clo_a=0;clo_a<m;clo_a++){
temp[clo_a] = array[row_a][clo_a];
}

for(int clo_b=row_a;clo_b<n;clo_b++){
for(int row_b=m-1;row_b>=0;row_b--){
array_result[row_b][clo_b] = temp[m-1-row_b];
}
}

}
for(int row=0;row<m;row++){
for(int clo=0;clo<n;clo++){
if(clo == n-1)
System.out.print(array_result[row][clo]);
else
System.out.print(array_result[row][clo]+" ");
}
System.out.println();
}

}
}

/*第二题
问题描述
　　给定n个整数，请统计出每个整数出现的次数，按出现次数从多到少的顺序输出。
输入格式
　　输入的第一行包含一个整数n，表示给定数字的个数。
　　第二行包含n个整数，相邻的整数之间用一个空格分隔，表示所给定的整数。
输出格式
　　输出多行，每行包含两个整数，分别表示一个给定的整数和它出现的次数。按出现次数递减的顺序输出。如果两个整数出现的次数一样多，则先输出值较小的，然后输出值较大的。
样例输入
12
5 2 3 3 1 3 4 2 5 2 3 5
样例输出
3 4
2 3
5 3
1 1
4 1
评测用例规模与约定
　　1 ≤ n ≤ 1000，给出的数都是不超过1000的非负整数。
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Scanner;

public class Main {
public static void main(String[] args){
Main m = new Main();
m.exam_2();
}
public void exam_2(){
int num = 0;
HashMap<String,Integer> result =
new HashMap<String,Integer>();
Scanner s = new Scanner(System.in);
while(true){
num = s.nextInt();
if(num>=1 && num<=1000)
break;
}

int array[] = new int[num];
for(int i=0;i<array.length;i++)
array[i] = s.nextInt();

for(int i:array){
Integer time = result.get(Integer.toString(i));
if(time == null){
result.put(Integer.toString(i),1);
}else{
result.put(Integer.toString(i), ++time);
}
}

Iterator<Entry<String,Integer>> itEntry = result.entrySet().iterator();
ArrayList<String> strArr = new ArrayList<String>();
while(itEntry.hasNext()){
strArr.add(itEntry.next().getKey());
}
int v_arr[] = new int[strArr.size()];
int temp_ = 0;
for(String s2:strArr){
v_arr[temp_] = result.get(s2);
temp_++;
}

for(int k=1;k<v_arr.length;k++)
for(int i=0;i<v_arr.length-k;i++){
if(v_arr[i]<v_arr[i+1]){
int temp = v_arr[i];
v_arr[i] = v_arr[i+1];
v_arr[i+1] = temp;
}
}

int index = 0;

while(!result.isEmpty()){
for(String s2:strArr){
if(result.get(s2) != null)
if(result.get(s2) == v_arr[index]){
System.out.println(s2+" "+v_arr[index]);
result.remove(s2);
index++;
}
}
}

}
}

第三题是关于时间换算的，就是规定一个日期是周几，然后让你推算某年某月第x个周周几的几号类似这样的问题。。。看得头疼，就直接跳过去看第四题了。

第四题是有关于树的一道题。。大概思路是求树最远的两个叶子节点之间的距离（再考虑题目中的一些设定）,没有记录题目，就直接上代码。代码里面没有考虑临界问题。。写的不完善

2015年3月30日10:35:49补充

缺少一种情况的考虑，即

1

2

3

4 5

像这样的情况，一层二层三层都只有一个结点，算法的结果是2。但是正确结果应该是3，应该在

main

方法中将max与level最大层数进行下比较。。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Scanner;

public class Main {
public static void main(String[] args){
Main m = new Main();
ArrayList<TreeNode> arr = m.createTree();
int res = m.getSingle(arr);
int[] arr_in = m.getLastLevel(arr);

int max = arr_in[0]+arr_in[1]-2-2*(res-1);
System.out.println(max);
}

public ArrayList<TreeNode> createTree(){
int comput_num=0,router_num = 0;

Scanner s = new Scanner(System.in);

router_num = s.nextInt();
comput_num = s.nextInt();

ArrayList<TreeNode> treeArr = new ArrayList<TreeNode>();
//      TreeNode root = new TreeNode(1);
//      treeArr.add(root);
int index = 0;
for(int i=1;i<=comput_num+router_num;i++){
treeArr.add(new TreeNode(i));
}
TreeNode root = treeArr.get(0);
for(TreeNode t:treeArr){
if(t.getNum() == 1)
continue;

int temp = s.nextInt();
TreeNode t_temp = getNodeByIndex(temp,treeArr);
t_temp.addChild(t);
}

return treeArr;
}

public int getSingle(ArrayList<TreeNode> treeArr){
HashMap<String,Integer> ha = new HashMap<String,Integer>();
for(TreeNode t:treeArr){
Integer key = t.getLevel();
Integer time = ha.get(Integer.toString(key));
if(time == null){
ha.put(Integer.toString(key),1);
}else{
ha.put(Integer.toString(key), ++time);
}
}
int res = 0;
Iterator<Entry<String,Integer>> itEntry = ha.entrySet().iterator();
while(itEntry.hasNext()){
if(itEntry.next().getValue() == 1)
res++;
}

int level_max = treeArr.get(0).getLevel();
TreeNode temp = treeArr.get(0);
for(TreeNode t:treeArr){
if(level_max<t.getLevel()){
level_max = t.getLevel();
temp = t;
}
}

if(ha.get(Integer.toString(level_max)) == 1)
res--;

return res;
}

public int[] getLastLevel(ArrayList<TreeNode> treeArr){
int level_max = treeArr.get(0).getLevel();
TreeNode temp = treeArr.get(0);
for(TreeNode t:treeArr){
if(level_max<t.getLevel()){
level_max = t.getLevel();
temp = t;
}
}
treeArr.remove(temp);

int level_sec = treeArr.get(0).getLevel();
TreeNode temp_sec = treeArr.get(0);
for(TreeNode t:treeArr){
if(level_sec<t.getLevel()){
level_sec = t.getLevel();
temp_sec = t;
}
}
return new int[]{level_max,level_sec};
}

private TreeNode getNodeByIndex(int index,ArrayList<TreeNode> treeArr){
for(TreeNode t:treeArr){
if(t.getNum() == index)
return t;
}
return null;
}

class TreeNode{
private ArrayList<TreeNode> childNode;
private int num;
private int level;

public TreeNode(int num){
this.num = num;
this.level = 1;
childNode = new ArrayList<TreeNode>(0);
}
public TreeNode(){
this.num = 0;
childNode = new ArrayList<TreeNode>(0);
}

public ArrayList<TreeNode> getChildArr(){
return this.childNode;
}
public int getNum(){return this.num;}

public void addChild(TreeNode child){
this.childNode.add(child);
child.setLevel(this.level+1);
}
public void setNum(int num){
this.num = num;
}
public int getLevel(){return this.level;}
public void setLevel(int level){this.level = level;}
}
}

第五题是一个无向图的最短路径（需要额外考虑题目中的设定，所以比单纯的图的最短路径要难一些，没做出来）。