华为2018年校园招聘机试题

package huawei;

import java.util.Scanner;
import java.util.Stack;

/**
 * 给定一个字符串，里边可能包含"()"、"[]"、"{}"三种括号，请编写程序检查该字符串中的括号是否成对出现，且嵌套关系正确。

 * 输出： true：若括号成对出现且嵌套关系正确，或该字符串中无括号字符； false：若未正确使用括号字符。 实现时无需考虑非法输入。

 输入描述:

 输入：字符串

 例子：(1+2)/(0.5+1)

 输出描述:

 输出：true | false

 例子：true

 示例1

 输入

 (1+2)/(0.5+1)

 输出

 True
 **/

public class CampusRecruitmentTest_2017_01 {
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext())
        {
            Stack<Character> stack = new Stack<>();
            String str = sc.nextLine();
            char[] cs = str.toCharArray();
            for (char c : cs) {
                if (c == '(' || c == '{' || c == '[')
                {
                    stack.push(c);
                } else
                {
                    if (c == ')')
                    {
                        if (stack.peek() == '(')
                        {
                            stack.pop();
                        }
                    }
                    if (c == '}')
                    {
                        if (stack.peek() == '{')
                        {
                            stack.pop();
                        }
                    }
                    if (c == ']')
                    {
                        if (stack.peek() == '[')
                        {
                            stack.pop();
                        }
                    }
                }
            }
            if (stack.isEmpty()) {
                System.out.println("true");
            } else {
                System.out.println("false");
            }
        }
    }
}

package huawei;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/**
 *
 打印机任务

 简要描述：
 某个打印机根据打印机队列执行打印任务，打印任务分为九个优先级，分别用数字1~9表示，数字越大优先级越高。打印机每次从队列头部取出第一个任务A，
 然后检查队列余下任务中有没有比A优先级更高的任务，则将任务A放在队列尾部，否则就执行任务A的打印。请编写一个程序，根据输入的打印队列，编出实
 际的打印顺序。

 输入描述：
 函数原型： void printOrder(const int input[], int len, int output[])
 输入参数input表示打印队列，为一个由整数1~9（优先级）组成的数组，数组索引0表示打印队列头部。对于C/C++,参数len表示input数组的长度。
 可以假定输入的参数总是合法有效的，input数组长度有可能为0，但不会是空指针。
 输出为一个表示实际打印顺序的数组，其数组项为打印任务在输入数组中的索引值（从0开始）。
 Java通过返回值输出。C/C++通过输出参数output[]输出，可以假定为存放结果分配了足够的空间

 输入样例：
 9, 3, 5
 输出样例：
 0, 2, 1
 *
 **/



/**
 *分析：
 
 首先记录所求时间它在队列中的位置，用一个队列存储这些任务的优先级，同时也创建一个队列存储对应任务一开始的位置，那么当我们对前一个队列进行
 什么操作时，后一个队列也跟着做什么操作即可，就可以保证两个队列的对应关系——任务对应初始位置。进行模拟时，从第一个队列取出一个任务（同时第
 二个队列也是进行同样的操作），判断该任务是否可以打印（通过循环判断，队列后面的元素任务优先级有木有大于当前任务的优先级即可），如果可以打
 印就将所求打印时间加1，并且判断是否是我们所求时间的位置，如果是，则停止模拟，如果不是则继续以上操作；如果不可以进行打印就将刚才取出来的数
 重新加到队尾（两个队列均是这样操作）。
 */

public class CampusRecruitmentTest_2017_02 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int t = input.nextInt();
        for (int i = 0; i < t; i++) {
            int n = input.nextInt();
            int pos = input.nextInt();

            Queue<Integer> q = new LinkedList<Integer>();
            Queue<Integer> qn = new LinkedList<Integer>();

            for (int j = 0; j < n; j++) {
                int temp = input.nextInt();
                q.add(temp);
                qn.add(j);
            }

            int time = 0;
            while (true) {
                int temp = q.poll();
                int num = qn.poll();
                if (goOnPrint(temp, q)) {
                    time++;
                    if (num == pos)
                        break;
                } else {
                    q.add(temp);
                    qn.add(num);
                }
            }

            System.out.println(time);
        }
    }

    private static boolean goOnPrint(int t, Queue<Integer> q) {
        for (Integer v : q) {
            if (v > t)
                return false;
        }

        return true;
    }
}

package huawei;

import java.util.Scanner;

/**
 简要描述： 
 给定一个M行N列的矩阵（M*N个格子），每个格子中放着一定数量的平安果。 
 你从左上角的各自开始，只能向下或者向右走，目的地是右下角的格子。 
 每走过一个格子，就把格子上的平安果都收集起来。求你最多能收集到多少平安果。 
 注意：当经过一个格子时，需要一次性把格子里的平安果都拿走。 
 限制条件：1<N,M<=50；每个格子里的平安果数量是0到1000（包含0和1000）. 

 输入描述： 
 输入包含两部分： 
 第一行M, N 
 接下来M行，包含N个平安果数量 

 输出描述： 
 一个整数 
 最多拿走的平安果的数量 

 示例： 

 输入 
 2 4 
 1 2 3 40 
 6 7 8 90 

 输出 
 136
 **/
public class CampusRecruitmentTest_2017_03 {
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        while (in.hasNext())
        {
            String s = in.nextLine();
            String[] str = s.split(" ");
            int M = Integer.parseInt(str[0]);
            if (M<=1||M>50)
            {
                break;
            }
            int N = Integer.parseInt(str[1]);
            if (N<=1||N>50)
            {
                continue;
            }
            int num[][] = new int[M][N];
            for (int i = 0; i < M; i++)
            {
                String st = in.nextLine();
                String[] strs = st.split(" ");
                for (int j = 0; j < strs.length; j++)
                {
                    num[i][j] = Integer.parseInt(strs[j]);
                    if(num[i][j]<0||num[i][j]>1000){
                    }
                }
            }
            System.out.println(getMaxValue(num));
        }
    }
    /** 获得最多的平安果*/
    private static int getMaxValue(int[][] num)
    {
        int Row = num.length;
        int Col = num[0].length;
        int[][] dp = new int[Row][Col];
        for (int i = 0; i < Row; i++)
        {
            for (int j = 0; j <= i; j++)
            {
                dp[i][0]+= num[j][0];
            }
        }
        for (int i = 0; i < Col; i++)
        {
            for (int j = 0; j <= i; j++)
            {
                dp[0][i] += num[0][j];
            }
        }
        for (int i = 1; i < Row; i++)
        {
            for (int j = 1; j < Col; j++)
            {
                dp[i][j] = Math.max(dp[i][j - 1] + num[i][j], dp[i - 1][j] + num[i][j]);
            }
        }
        return dp[Row - 1][Col - 1];
    }
}