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[n][m];
        int array_result[][] =new int[m][n];
        //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;}
    }
}

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