网易 2018 春招实习编程大题

一、牛牛找工作

为了找到自己满意的工作，牛牛收集了每种工作的难度和报酬。牛牛选工作的标准是在难度不超过自身能力值的情况下，牛牛选择报酬最高的工作。在牛牛选定了自己的工作后，牛牛的小伙伴们来找牛牛帮忙选工作，牛牛依然使用自己的标准来帮助小伙伴们。牛牛的小伙伴太多了，于是他只好把这个任务交给了你。

输入描述：

每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数，分别表示工作的数量N(N<=100000)和小伙伴的数量M(M<=100000)。
接下来的N行每行包含两个正整数，分别表示该项工作的难度Di(Di<=1000000000)和报酬Pi(Pi<=1000000000)。
接下来的一行包含M个正整数，分别表示M个小伙伴的能力值Ai(Ai<=1000000000)。
保证不存在两项工作的报酬相同。

思路

先将工作按工作难度排序
同样的工作难度，为了避免报酬不一样，需要取最大值
将工作放入 TreeMap ，可以减少查找的时间复杂度
使用 TreeMap 的 floorKey() 方法来查找，加快查找速度

代码：

import java.util.*;

public class Main{

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // n 个工作
        int m = sc.nextInt();
        int[][] arr = new int[n][2]; //存储工作难度和报酬
        for (int i=0;i<n;i++){ //用一个数组来实现类似的 map，好处在于可以实现排序
            arr[i][0] = sc.nextInt();
            arr[i][1] = sc.nextInt();
        }
        //实现 Comparator 接口，按照数组的第一行元素排序
        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
        //dp 来使相应的工作获利最大，越往后走的工作，本能的，它的钱应该是越多的，避免出现倒挂
        for (int i=1;i<n;i++){
            arr[i][1] = Math.max(arr[i][1],arr[i-1][1]);
        }
        //使用 TreeMap，可以让查找复杂度变为 O(1)
        TreeMap<Integer,Integer> map = new TreeMap<>();
        for (int i=0;i<n;i++){
            map.put(arr[i][0],arr[i][1]);
        }
        for (int i=0;i<m;i++){
            int ability = sc.nextInt();
            // floorKey ，避免出现 map 中的中间值，需要知道比他小的第一个值
            // 返回必须是 Integer 对象，不能用 int 接受返回值
            Integer index = map.floorKey(ability);
            if (index != null){
                System.out.println(map.get(index));
            }
            else {
                System.out.println(0);
            }
        }
    }
}

二、被 3 整除

题目

小Q得到一个神奇的数列: 1, 12, 123,…12345678910,1234567891011…。

并且小Q对于能否被3整除这个性质很感兴趣。

小Q现在希望你能帮他计算一下从数列的第l个到第r个(包含端点)有多少个数可以被3整除。

输入描述

输入包括两个整数l和r(1 <= l <= r <= 1e9), 表示要求解的区间两端。

思路

这里写图片描述

每一个能被 3 整除的数字，它的输入序号模 3 的结果一定是 2 和 0。并且是有规律的 1 2 0 ，可以在这个基础上运用数学计算出，并不一定要用 o(N) 算法遍历。

代码

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int l = sc.nextInt();
        int r = sc.nextInt();
        int count = 0;
        for(int i=l;i<=r;i++){
            if(i%3 != 1){
                count++;
            }
        }
        System.out.println(count);
    }
}

三、安置路灯

题目描述

小Q正在给一条长度为n的道路设计路灯安置方案。

为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用’.’表示, 不需要照亮的障碍物格子用’X’表示。

小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。

小Q希望能安置尽量少的路灯照亮所有’.’区域, 希望你能帮他计算一下最少需要多少盏路灯。

输入描述

输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数
接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。
第二行一个字符串s表示道路的构造,只包含'.'和'X'。

思路

按照安装路灯的规律：
1. 顺序遍历，
2. 如果当前遍历为 ‘.’，那么往后走三个，开始从这里再查找是否是’.’
3. 因为如果当前是’.’ ，那么只需要在它的后面一个设置路灯即可，然后左右两边都不管了
4. 如果是 ‘X’，往后走，忽略它

代码

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int t = Integer.valueOf(sc.nextLine()); // t 表示测试用例数
        while(t-- > 0){
            int n = Integer.valueOf(sc.nextLine().trim()); // n 表示道路的长度
            String s = sc.nextLine(); // s 表示道路的构造
            int count = 0; //表示需要的路灯数
            for(int i=0;i<n;){
                if(s.charAt(i) == '.'){
                    count++;
                    i += 3; //往后走到第三步，
                }
                else{
                    i++;
                }
            }
            System.out.println(count);
        }
    }
}

四、迷路的牛牛

题目描述

牛牛去犇犇老师家补课，出门的时候面向北方，但是现在他迷路了。虽然他手里有一张地图，但是他需要知道自己面向哪个方向，请你帮帮他。

输入描述

每个输入包含一个测试用例。
每个测试用例的第一行包含一个正整数，表示转方向的次数N(N<=1000)。
接下来的一行包含一个长度为N的字符串，由L和R组成，L表示向左转，R表示向右转。

思路

往左走 - 90
往右走 +90
最后根据角度来统计走到的位置
当然，也可以不用 +- 90 ，直接统计一个 result，最后用 Swith{ case:}来做会更简单

代码

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();sc.nextLine();
        String str = sc.nextLine();
        String[] forward = {"N","E","S","W"};
        int count = 0;
        for(int i=0;i<n;i++){
            if(str.charAt(i) == 'L'){
                count -= 90;
            }
            else{
                count += 90;
            }
        }
        if(count > 0){
            int res = (count/90)%4;
            System.out.println(forward[res]);
        }
        else if(count < 0){
            int res = (count/90)%4;
            if(res ==0)//避免出现 -360 这种，造成指针越界
                System.out.println("N");
            else
               System.out.println(forward[res+4]);
        }
        else{//count == 0
            System.out.println(forward[0]);
        }
    }
}

七、牛牛的闹钟

题目描述

牛牛总是睡过头，所以他定了很多闹钟，只有在闹钟响的时候他才会醒过来并且决定起不起床。从他起床算起他需要X分钟到达教室，上课时间为当天的A时B分，请问他最晚可以什么时间起床

输入描述

每个输入包含一个测试用例。
每个测试用例的第一行包含一个正整数，表示闹钟的数量N(N<=100)。
接下来的N行每行包含两个整数，表示这个闹钟响起的时间为Hi(0<=A<24)时Mi(0<=B<60)分。
接下来的一行包含一个整数，表示从起床算起他需要X(0<=X<=100)分钟到达教室。
接下来的一行包含两个整数，表示上课时间为A(0<=A<24)时B(0<=B<60)分。
数据保证至少有一个闹钟可以让牛牛及时到达教室。

思路

思路同牛牛找工作的思路类似
注意点：应该是在对闹钟计算完从响 + x 之后的排序，这样避免 23：xx 的闹钟，最近相加超过 12 点变为 00:xx 出现错误
对闹钟的排序，首先按照第一列排序，如果第一列相同，第二列小的在前面，Arrays.sort() 并重写 Comparator 的 compare 方法实现排序
最后查找闹钟的逻辑也值得注意，当然也许有更好的查找办法

代码

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // n 表示闹钟的数量
        int[][] map = new int[n][2];
        for(int i=0;i<n;i++){
            map[i][0] = sc.nextInt();
            map[i][1] = sc.nextInt();
        }
        int x = sc.nextInt(); //起床后需要 x 到达教室

        Arrays.sort(map, new Comparator<int[]>() { //对 map 按照闹钟排序
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0] == o2[0]){
                    return o1[1] - o2[1];
                }
                return o1[0] - o2[0];
            }
        });

        int hours = sc.nextInt(); //上课开始的小时
        int seconds = sc.nextInt(); // 上课开始的分钟数
        int res = -1;
        for(int i=0;i<n;i++){
            int alarmHour = map[i][0];
            int alarmSeconds = map[i][1] + x;
            int add = alarmSeconds/60;
            if(add>0){//计算闹钟响的时间 + x 之后的时间
                alarmHour += add;
                alarmSeconds = alarmSeconds%60;
            }
 //           if(alarmHour == 24)
 //               alarmHour = 0;
            //与正常的上课时间进行对比
            if(alarmHour <= hours){
                if(alarmHour == hours && alarmSeconds <= seconds){
                    res = i;
                }
                else if(alarmHour < hours){
                    res = i;
                }
            }
            else{
                break;
            }
        }
        if(res != -1)
        System.out.println(map[res][0] + " " + map[res][1]);
    }
}

八、牛牛的背包

题目

牛牛准备参加学校组织的春游, 出发前牛牛准备往背包里装入一些零食, 牛牛的背包容量为w。
牛牛家里一共有n袋零食, 第i袋零食体积为v[i]。
牛牛想知道在总体积不超过背包容量的情况下,他一共有多少种零食放法(总体积为0也算一种放法)。

输入描述

输入包括两行
第一行为两个正整数n和w(1 <= n <= 30, 1 <= w <= 2 * 10^9),表示零食的数量和背包的容量。
第二行n个正整数v[i](0 <= v[i] <= 10^9),表示每袋零食的体积。

代码:位运算暴力破解，只能AC 60%

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // n 表示零食的数量
        int w = sc.nextInt(); // w 表示背包的容量
        int[] v = new int[n]; //每份零食的体积
        for(int i=0;i<n;i++){
            v[i] = sc.nextInt();
        }
     //   Arrays.sort(v); // 对零食的体积进行排序
        //贪心算法
        //位运算找出所有的组合,进行位运算的长度为 n，即零食的数量
        int sum = (int)Math.pow(2,n); //表示总的组合
        int count = 0; // count 表示可行的组合
        for(int i=0;i<sum;i++){
            long tempSum = 0; //表示求和的中间数，有可能超过总数大小
            int copyOfi = i; //复制i，防止中间 i 被改变
            for(int j=n-1;j>=0;j--){//位运算
                if((copyOfi & 1) == 1){
                    tempSum += v[j];
                }
                copyOfi = copyOfi >> 1;
            }
            if(tempSum <= w){
                count++;
            }
        }
        System.out.println(count);
    }
}