2019-03-14 13:01:50
浏览数 (1)
01 括号匹配：
代码语言：javascript
复制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 打印队列：
代码语言：javascript
复制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 平安果
代码语言：javascript
复制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];
}
}
