01 括號匹配：

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");
}
        }
    }
}

02 列印佇列：

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;
}
}

03 平安果

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];
}
}