【九度】2014年王道论坛计算机考研机试全真模拟考试解题报告

1、题目1553：时钟
时间限制：1 秒内存限制：128 兆特殊判题：否提交：764解决：321
题目描述：
如图，给定任意时刻，求时针和分针的夹角(劣弧所对应的角)。

输入：
输入包含多组测试数据，每组测试数据由一个按hh:mm表示的时刻组成。
输出：
对于每组测试数据，输出一个浮点数，代表时针和分针的夹角（劣弧对应的角），用角度表示，结果保留两位小数。
样例输入：
03:00
14:45
样例输出：
90.00
172.50
来源：
2014年王道论坛计算机考研机试全真模拟考试
简单题，分别模拟时针和0点之间的度数，分针和0点之间的度数。
其中时针和0之间的度数，由两部分组成。1)、当前整点当前时间点(double)hour/12*360，当然记得转double，超过12点记得转换hour -= 12。2)、分钟数占一个小时百分比。每个小时间隔是360/12 = 30度，(double)minute/60*30。
分针和0之间的度数，(double)minute / 60 * 360;
二者大减小，或者求绝对值abs，如果大于180度，记得转换。

Java AC

import java.util.Scanner;
import java.util.regex.Pattern;
 
public class Main {
    /*
     * 2014年3月16日21:18:33
     */
    public static void main(String[] args) throws Exception{
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String time = scanner.next();
            String timeMsg[] = time.split(Pattern.quote(":"));
            int hour = Integer.parseInt(timeMsg[0]);
            int minute = Integer.parseInt(timeMsg[1]);
            if(hour > 12){
                hour -= 12;
            }
            double degree1 = (double)hour / 12 * 360 + (double)minute / 60  * 30;
            double degree2 = (double)minute / 60 * 360;
            double max = Math.max(degree1, degree2);
            double min = Math.min(degree1, degree2);
            double result = max - min;
            if(result > 180){
                result = 360 - result;
            }
            System.out.printf("%.2f\n",result);
        }
    }
}
 
/**************************************************************
    Problem: 1553
    User: wzqwsrf
    Language: Java
    Result: Accepted
    Time:450 ms
    Memory:15852 kb
****************************************************************/

2、题目1554：区间问题
时间限制：1 秒内存限制：128 兆特殊判题：否提交：921解决：68
题目描述：
给定一个数组，判断数组内是否存在一个连续区间，使其和恰好等于给定整数k。
输入：
输入包含多组测试用例，每组测试用例由一个整数n(1<=n<=10000)开头，代表数组的大小。
接下去一行为n个整数，描述这个数组，整数绝对值不大于100。
最后一行为一个整数k(大小在int范围内)。
输出：
对于每组测试用例，若存在这个连续区间，输出其开始和结束的位置，s，e(s <= e)。
若存在多个符合条件的输出，则输出s较小的那个，若仍然存在多个，输出e较小的那个。
若不存在，直接输出"No"。
样例输入：
5
-1 2 3 -4 9
5
3
-1 2 -3
7
2
-1 1
0
样例输出：
2 3
No
1 2
来源：
2014年王道论坛计算机考研机试全真模拟考试
解题思路：
暂时给出这两种思路吧，一个时间复杂度不是很好。一个很耗空间。如果以后有好的思路，会继续优化。
1、暴力搜索，O(N*N)，肯定会超时。但是对暴力搜索稍微优化，判断如果k比连续子数组和的最大值还大，比最小值还小，那么肯定无解了，直接输出No。否则在暴力搜索，最长时间O(N*N)，C++过了。
2、稍微有点动态规划的思想，求出sumArr。这样一转换，就是在一个数组中，求解之差为k的两数是否存在，如果存在，输出index。
1、C++ AC

#include <stdio.h>
const int maxn = 10002;
int array[maxn];
 
int main(){
    int n, k, i, j;
    while(scanf("%d",&n) != EOF){
        int max = -100;
        int min = 100;
        int tempMax = 0;
        int tempMin = 0;
        for(i = 0; i < n; i++){
            scanf("%d", &array[i]);
            if(tempMax < 0){
                tempMax = array[i];
            }else{
                tempMax += array[i];
            }
            max = max > tempMax ? max : tempMax;
            if(tempMin > 0){
                tempMin = array[i];
            }else{
                tempMin += array[i];
            }
            min = min < tempMin ? min : tempMin;
        }
        scanf("%d",&k);
        if(k < min || k > max){
            printf("No\n");
            continue;
        }
        bool flag = false;
        for(i = 0; i < n; i++){
            int tempSum = 0;
            for(j = i; j < n; j++){
                tempSum += array[j];
                if(tempSum == k){
                    flag = true;
                    printf("%d ",(i+1));
                    printf("%d\n",(j+1));
                    break;
                }
            }
            if(flag){
                break;
            }
        }
        if(!flag){
            printf("No\n");
        }
    }
    return 0;
}
/**************************************************************
    Problem: 1554
    User: wzqwsrf
    Language: C++
    Result: Accepted
    Time:990 ms
    Memory:1060 kb
****************************************************************/

2、Java AC

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public class Main {
    /*
     * 1554
     */
    public static void main(String[] args) throws Exception {
        StreamTokenizer st = new StreamTokenizer(new BufferedReader(
                new InputStreamReader(System.in)));
        while (st.nextToken() != StreamTokenizer.TT_EOF) {
            int n = (int) st.nval;
            int array[] = new int[n+1];
            int sumArr[] = new int[n+1];
            Map<Integer, Integer> sumMap = new HashMap<Integer, Integer>();
            for(int i = 1; i <= n; i++){
                st.nextToken();
                array[i] = (int)st.nval;
                sumArr[i] = sumArr[i-1] + array[i];
                if (!sumMap.containsKey(sumArr[i])) {
                    sumMap.put(sumArr[i], i);
                }
            }
            st.nextToken();
            int k = (int) st.nval;
            boolean flag = false;
            List<Node> nodeList = new ArrayList<Node>();
            int start = 0;
            int end = 0;
            for (int i = n; i > 0; i--) {
                if (sumArr[i] == k) {
                    flag = true;
                    start = 1;
                    end = i;
                    Node node = new Node(start, end);
                    nodeList.add(node);
                    continue;
                }
                if (i == 1 && sumArr[i] != k) {
                    continue;
                }
                int tempNum = sumArr[i] - k;
                if (sumMap.containsKey(tempNum)) {
                    int tempStart = sumMap.get(tempNum)+1;
                    if (tempStart > i) {
                        continue;
                    }
                    flag = true;
                    start = sumMap.get(tempNum)+1;
                    end = i;
                    Node node = new Node(start, end);
                    nodeList.add(node);
                }
            }
            if(!flag){
                System.out.println("No");
                continue;
            }
            Collections.sort(nodeList);
            Node node = nodeList.get(0);
            System.out.println(node.start + " " + node.end);
        }
    }
    private static class Node implements Comparable<Node>{
        int start ;
        int end;
        public Node(int start, int end) {
            super();
            this.start = start;
            this.end = end;
        }
        public int compareTo(Node o) {
            if (this.start == o.start) {
                return this.end - o.end;
            }else {
                return this.start - o.start;
            }
        }
    }
}
 
/**************************************************************
    Problem: 1554
    User: wangzhenqing
    Language: Java
    Result: Accepted
    Time:2810 ms
    Memory:132680 kb
****************************************************************/

3、题目1555：重复子串
时间限制：3 秒内存限制：256 兆特殊判题：否提交：396解决：41
题目描述：
给定一个由小写字母组成的字符串，求它的所有连续子串中，出现过至少两次，且至少有一对出现的重复子串是不重合的连续子串个数。
如给定字符串aaaa，aa和a，符合条件，aaa不符合条件(出现重合)，故答案为2。
输入：
输入包含多组测试用例，每组测试用例包含一个字符串，由小写字母组成，其长度不大于1000。
输出：
对于每组测试数据，输出一个整数，代表符合条件的子串个数。
样例输入：
aaaa
aaa
样例输出：
2
1
来源：
2014年王道论坛计算机考研机试全真模拟考试
其实我很久都看懂题目是什么意思。
好嘛，有点晦涩难懂。
题目的意思应该是求解，字符串s的子串。但是这个子串是有要求的。
1、这个子串出现过至少两次。
2、子串合并起来应该是s本身或者是s的子串。
举例来说，aaaa，子串为aaa，aa和a，其中aaa也出现了2次，就是0到3位置以及2到4位置，但是aaa重合才能够成s，所以aaa不是。
再比如abab，子串有a，b，ab以及aba和bab。a，b和ab都出现了2次，并且互相不重合。
基本思路，声明一个set，用来存放满足条件的子串。
双重循环，时间复杂度是O(N*N)，其实不到n，最多也就n/2*n。
针对每个从i处开始长度为j的子串，有以下操作：
1）、如果这个子串已经在set中存在了，就没必要在判断了，直接continue。
2）、判断在剩余的字符串中是否存在。这里对Java来说，可以采用indexOf方法判断一个字符串是不是另一个字符串的子串。
如果存在，那么set中add就可以了。
如果不存在，这里注意剪枝。因为从i开始长度为j的字符串在余下的字符串中已经不存在了，所以长度即使再增加，也不会存在了，直接break就退出当前循环了。
最后set的长度就是满足条件的子串的个数。
C++太渣了，不太会处理字符串，先给出Java吧。
Java AC

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.HashSet;
import java.util.Set;
 
public class Main {
    /*
     * 1555 2014年3月19日22:07:16
     */
    public static void main(String[] args) throws Exception {
        StreamTokenizer st = new StreamTokenizer(new BufferedReader(
                new InputStreamReader(System.in)));
        while (st.nextToken() != StreamTokenizer.TT_EOF) {
            Set<String> set = new HashSet<String>();
            String input = st.sval;
            int len = input.length();
            for (int i = 0; i < len; i++) {
                int j = 1;
                while (j * 2 + i <= len) {
                    String before = input.substring(i, i + j);
                    if (set.contains(before)) {
                        j++;
                        continue;
                    }
                    String next = input.substring(i + j);
                    if (next.indexOf(before) != -1) {
                        set.add(before);
                        j++;
                    }else{
                        break;
                    }
                }
            }
            System.out.println(set.size());
        }
    }
}
 
/**************************************************************
    Problem: 1555
    User: wzqwsrf
    Language: Java
    Result: Accepted
    Time:970 ms
    Memory:25924 kb
****************************************************************/

4、题目1556：机场管制
时间限制：1 秒内存限制：128 兆特殊判题：否提交：66解决：11
题目描述：
已知飞机降落由二个阶段组成：
1:接受进近管制。
2:降落
现给定一天中飞机进入进近管制区准备降落的情况，根据规则输出对飞机的管制命令。
规则如下：
A.飞机信息由二部分组成：1.航班号(由不多于10个字符的字符串组成)。2.优先级（分为A,B,C三等）。
B.当跑道空闲时,已经进入进近管制区的飞机可以降落,其中优先级为A的飞机优先降落,B次之,C再次.相同优先级的飞机,先进入管制区的优先降落.
C.有三条跑道（1,2,3）可以使用，当对某飞机发出可以在某条跑道降落的命令后，二十分钟内该跑道将不被使用。即，若在9:31分对某飞机发出可在该跑道降落的命令后，至少在9:51分才能重新命令其它飞机在该跑道降落。
D.为防止低优先级的飞机在空中等待的时间过长,规定每过二十分钟,将B优先级中进入管制区时间最早的飞机提升到A，同时将C优先级中进入管制区时间最早的飞机提升到B，若没有则不提升。同时设定其进入进近管制区的时间为当前时间。一天中第一次提升时间为00:20,第二次为00:40，依此类推。
E.当跑道空闲时,优先使用1号跑道,2号跑道次之,3号跑道再次。
注意：
1.当飞机的优先级被提升到k,而重新设定其到达时间时,恰好有一架优先级为k的飞机到达,则优先级被提升的飞机的到达时间被视为早于该刚到达的飞机(数值上仍保持一致).
2.在每一分钟其逻辑顺序如下，若有飞机可以降落，使其降落。若有飞机需要被提升优先级，则提升优先级。最后处理刚进入管制区的飞机。命令的输出也按照该逻辑。
3.处理的最低时间间隔为分钟。
4.同时的降落按照跑道1、2、3的顺序输出命令。同时的升级先输出B升级A，再输出C升级B。
输入：
输入包含多组测试数据,每组测试数据由一个整数n(1<= n <= 200)开头,表示总计的航班数。
接下去n行，每行表示一个航班，格式为
hh:mm name level
表示优先级为level的航班name，在时间hh：mm进入管制区。name保证不会重复。
飞机按照时间递增的顺序给出，不存在两架飞机同时到达的情况。可能的时间区间为00:00到23:39，这里不考虑跨00:00飞机。
输出：
对于不同的情况，输出如下命令
当飞机name进入管制区时输出：
hello name.@hh:mm
当飞机name允许在k号跑道降落时输出
name,landing on runway k.@hh:mm
当飞机name的优先级从k提升到j时，输出
name,level up from k to j.@hh:mm
其中hh:mm为发出该条命令的时间
样例输入：
10
10:00 AC100 C
10:01 AC765 C
10:02 AC777 C
10:03 AC009 C
10:04 AC101 C
10:05 AC327 B
10:06 AC328 A
10:07 AC001 B
10:08 AC002 B
10:09 AC003 B
样例输出：
hello AC100.@10:00
AC100,landing on runway 1.@10:01
hello AC765.@10:01
AC765,landing on runway 2.@10:02
hello AC777.@10:02
AC777,landing on runway 3.@10:03
hello AC009.@10:03
hello AC101.@10:04
hello AC327.@10:05
hello AC328.@10:06
hello AC001.@10:07
hello AC002.@10:08
hello AC003.@10:09
AC327,level up from B to A.@10:20
AC009,level up from C to B.@10:20
AC328,landing on runway 1.@10:21
AC327,landing on runway 2.@10:22
AC001,landing on runway 3.@10:23
AC002,level up from B to A.@10:40
AC101,level up from C to B.@10:40
AC002,landing on runway 1.@10:41
AC003,landing on runway 2.@10:42
AC009,landing on runway 3.@10:43
AC101,level up from B to A.@11:00
AC101,landing on runway 1.@11:01
来源：
2014年王道论坛计算机考研机试全真模拟考试
这个应该是典型的模拟题，瞬间联想到题目1540：麦霸(解题思路可以参考Jobdu 题目1540：麦霸)，但是好像想错方向了。
麦霸这个题可以根据当前时间进行判断是否要做操作(这个题也可以将list改为队列)。本题循环的应该是当前时间，参考了别人写的代码。
基本思路应该是：
1、有三个队列，存的是三个级别的进入管制区的飞机。
2、有三个时间，存的是当前跑道释放的时间。
3、每个时间点，需要做三件事。
1)、判断当前管制区是否有飞机，跑道是否有空余。如果二者条件都符合，将当前队列中的第一架飞机落地。
2)、判断当前时间点是否需要升级飞机的级别。
3)、判断是否有飞机进入管制区。
这三件事情的先后顺序是根据题目的要求来的。
Java 超时
C++ AC

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
const int maxlen = 12;
const int maxn = 202;
const int maxTime = 24*60;
struct Plane{
    int time;
    char name[maxlen];
    char level;
};
Plane planes[maxn];
queue<Plane> queueArr[3];
int n, hour, minute;
int runArr[3];
 
int main(){
    int i,j;
    while(scanf("%d", &n)!=EOF){
        for(i = 0; i < n; i++){
            scanf("%2d:%2d %s %c", &hour, &minute, planes[i].name, &planes[i].level);
            planes[i].time = hour * 60 + minute;
        }
        memset(runArr, 0, sizeof(runArr));
        for(i = 0; i < 3; i++){
            while(!queueArr[i].empty()){
                queueArr[i].pop();
            }
        }
        int curTime = planes[0].time;
        i = 0;
        for(; curTime < maxTime; curTime++){
            hour = curTime / 60;
            minute = curTime % 60;
            int rank1 = -1;
            for(j = 0; j < 3; j++) {
                if(!queueArr[j].empty()){
                    rank1 = j;
                    break;
                }
            }
            int rank2 = -1;
            for (j = 0; j < 3; j++) {
                if (runArr[j] <= curTime) {
                    rank2 = j;
                    break;
                }
            }
            if(rank1 != -1 && rank2 != -1){
                Plane plane = queueArr[rank1].front();
                queueArr[rank1].pop();
                runArr[rank2] = curTime + 20;
                printf("%s,landing on runway %d.@%02d:%02d\n", plane.name, rank2+1, hour, minute);
            }
              
            if (curTime % 20 == 0) {
                if (!queueArr[1].empty()) {
                    Plane plane = queueArr[1].front();
                    queueArr[1].pop();
                    plane.level = 'A';
                    plane.time = curTime;
                    queueArr[0].push(plane);
                    printf("%s,level up from B to A.@%02d:%02d\n", plane.name, hour, minute);
                }
                if (!queueArr[2].empty()) {
                    Plane plane = queueArr[2].front();
                    queueArr[2].pop();
                    plane.level = 'B';
                    plane.time = curTime;
                    queueArr[1].push(plane);
                    printf("%s,level up from C to B.@%02d:%02d\n", plane.name, hour, minute);
                }
            }
            if (i < n && planes[i].time == curTime) {
                if (planes[i].level == 'A') {
                    queueArr[0].push(planes[i]);
                }
                if (planes[i].level == 'B') {
                    queueArr[1].push(planes[i]);
                }
                if (planes[i].level == 'C') {
                    queueArr[2].push(planes[i]);
                }
                printf("hello %s.@%02d:%02d\n", planes[i].name, hour, minute);
                i++;
            }
        }
    }
    return 0;
}
/**************************************************************
    Problem: 1556
    User: wzqwsrf
    Language: C++
    Result: Accepted
    Time:50 ms
    Memory:1056 kb
****************************************************************/

5、题目1557：和谐答案
时间限制：3 秒内存限制：128 兆特殊判题：否提交：226解决：26
题目描述：
在初试即将开始的最后一段日子里，laxtc重点练习了英语阅读的第二部分，他发现了一个有意思的情况。
这部分的试题最终的答案总是如下形式的：
1.A;2.C;3.D;4.E;5.F。即共有六个空格，每个空格填入一个相应的字母代表这个空格他所选择的答案，且空格中的字母不存在重复。若每个空格选择的答案都是严格递增的，则laxtc认为这个答案是和谐的，如1.A;2.C;3.D;4.E;5.F;反之，若答案中存在不递增的情况，则他认为这组答案是不和谐的，如1.A;2.C;3.B;4.E;5.F;laxtc总是希望他所选择的答案是和谐的。由于laxtc的英语并不怎么好，所以他也经常会空着一些空格，如1.A2.;3.B;4.E;5.F;此时，只要排除掉空格后的剩余部分依然是递增的，那么laxtc也认为它是和谐的。
已知共有n个空格，laxtc已经为每一个空格选择好了Ci个候选对象。laxtc想知道他最多能填写几个空格，同时保持最终答案是和谐的。
输入：
输入包含多组测试数据。每组测试数据由一个整数n（1 <= n <= 100000）开头,表示共有n个位置。
接下来共有n行数字，第i行表示laxtc为第i个空格选择的候选答案(可能会有重复的答案)。由两部分组成。第一部分为一个整数t（1 <= t <= 5），表示该空格共有t个候选答案。第二部分为t个整数，代表laxtc为该空格选择的候选答案序号（由于题数过多，这里用数字代替字母，数字在int范围内）。
输出：
输出为一个整数，代表laxtc得到的最大和谐答案组的长度，长度即填写的空格数。
样例输入：
5
5 1 2 3 4 5
5 1 2 3 4 5
5 1 2 3 4 5
5 1 2 3 4 5
5 1 2 3 4 5
5
4 1 2 3 4
4 2 3 4 5
2 2 3
2 4 5
1 1
样例输出：
5
4
提示：
来源：
2014年王道论坛计算机考研机试全真模拟考试
解题思路：
这个题有点像LIS，但是好像又不太像。
其实整体上的思路并不是很复杂，但是比较难想，采用的还是动态规划的思想。
dp[i]表示的是第i个位置，所填写的答案，这个答案是在实时更新的。
举个例子说吧。
比如有以下样例输入
5
3 1 2 3
2 8 9
3 4 5 7
2 10 6
1 3
最初开始的时候，dp都为Integer.MAX_VALUE，以下展示dp变化。
dp[0] = 1;
dp[1] = 8;
dp[1] = 4;(这一步发现其实前面的位置可以输入的数字可以更小，所以就更新了dp[1]的值。)
dp[2] = 6;
dp[1] = 3;
最后的结果其实就是3。
每当输入一组候选答案的时候，找到每个候选答案在已选答案中的位置，如果有更小的答案可选择，就更新。如果发现可以拓展，就拓展答案的长度，最后就是结果。

C++ AC

#include <stdio.h>
const int size = 5;
int n,i,j;
int array[size];
int posArr[size];
int colNum;
 
int searchPosition(int *dp, int low, int high, int target) {
    int mid = 0;
    while (low <= high) {
        mid = (low + high) >> 1;
        if(dp[mid] == target){
            return mid;
        }
        if(dp[mid] > target){
            high = mid - 1;
        }else {
            low = mid + 1;
        }
    }
    return low;
}
 
int main(){
    while(scanf("%d",&n) != EOF){
        int *dp = new int[n];
        for(i = 0; i < n; i++){
            dp[i] = 10000000;
        }
        int low = 0;
        int high = 0;
        for(i = 0; i < n; i++){
            scanf("%d",&colNum);
            for(j = 0; j < colNum; j++){
                scanf("%d",&array[j]);
                posArr[j] = searchPosition(dp, low, high, array[j]);
            }
            for (j = 0; j < colNum; j++) {
                dp[posArr[j]] = dp[posArr[j]] < array[j] ? dp[posArr[j]] : array[j];
                high = high > posArr[j] + 1 ? high : posArr[j] + 1;
            }
        }
        printf("%d\n",high);
    }
    return 0;
}
 
/**************************************************************
    Problem: 1557
    User: wangzhenqing
    Language: C++
    Result: Accepted
    Time:1400 ms
    Memory:2584 kb
****************************************************************/

Java AC

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Arrays;
 
public class Main {
    /*
     * 1557
     */
    public static void main(String[] args) throws Exception {
        StreamTokenizer st = new StreamTokenizer(new BufferedReader(
                new InputStreamReader(System.in)));
        while (st.nextToken() != StreamTokenizer.TT_EOF) {
            int n = (int) st.nval;
            int array[] = new int[5];
            int posArr[] = new int[5];
            int dp[] = new int[n];
            Arrays.fill(dp, Integer.MAX_VALUE);
            int low = 0;
            int high = 0;
            for (int i = 0; i < n; i++) {
                st.nextToken();
                int colNum = (int)st.nval;
                for (int j = 0; j < colNum; j++) {
                    st.nextToken();
                    array[j] = (int)st.nval;
                    posArr[j] = searchPosition(dp, low, high, array[j]);
                }
                for (int j = 0; j < colNum; j++) {
                    dp[posArr[j]] = dp[posArr[j]] < array[j] ? dp[posArr[j]] : array[j];
                    high = high > posArr[j] + 1 ? high : posArr[j] + 1;
                }
            }
            System.out.println(high);
        }
    }
 
    private static int searchPosition(int[] dp, int low, int high, int target) {
        int mid = 0;
        while (low <= high) {
            mid = (low + high) >> 1;
            if(dp[mid] == target){
                return mid;
            }
            if(dp[mid] > target){
                high = mid - 1;
            }else {
                low = mid + 1;
            }
        }
        return low;
    }
}
 
/**************************************************************
    Problem: 1557
    User: wangzhenqing
    Language: Java
    Result: Accepted
    Time:2320 ms
    Memory:26708 kb
****************************************************************/