字节跳动2018校招大数据方向（第一批）编程题

1：平面最大点

P为给定的二维平面整数点集。定义 P 中某点x，如果x满足 P 中任意点都不在 x 的右上方区域内（横纵坐标都大于x），则称其为“最大的”。求出所有“最大的”点的集合。（所有点的横坐标和纵坐标都不重复, 坐标轴范围在[0, 1e9) 内）

如下图：实心点为满足条件的点的集合。请实现代码找到集合 P 中的所有 ”最大“ 点的集合并输出。

 

输入描述:

第一行输入点集的个数 N， 接下来 N 行，每行两个数字代表点的 X 轴和 Y 轴。
对于 50%的数据,  1 <= N <= 10000;
对于 100%的数据, 1 <= N <= 500000;

输出描述:

输出“最大的” 点集合， 按照 X 轴从小到大的方式输出，每行两个数字分别代表点的 X 轴和 Y轴。

输入例子1:

5
1 2
5 3
4 6
7 5
9 0

输出例子1:

4 6
7 5
9 0

思路：因为要寻找“最大点”，所以首先对所有点的y值进行排序，对于y值相同的点，x值也是有序的，y值最大的点，它必定是最大点，
此时，维护一个prex值，记录现在已找出的“最大点”的集合中最大的x值，对于y值比上一个“最大点”小的点，其x值必定要比prex大，
才为“最大点”，若为“最大点”，把其加入“最大点”集合，同时，更新prex值。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
  
  
class Point implements Comparable<Point>{
    int x;
    int y;
    public Point(int x, int y){
        this.x = x;
        this.y = y;
    }
  
    @Override
    public int compareTo(Point o) {
        return y==o.y ? o.x - x : o.y - y;
    }
}
public class Main {
    public static void main(String[] args) {
  
        Scanner sc  = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        Point[] points = new Point[n];
        for(int i = 0; i < n; i++) {
            points[i] = new Point(sc.nextInt(), sc.nextInt());
            sc.nextLine();
        }
        Arrays.sort(points);
        ArrayList<Point> max = new ArrayList<>();
        max.add(points[0]);
        int prex = points[0].x;
        for(int i = 1; i < n; i++){
            if(points[i].x > prex){
                prex = points[i].x;
                max.add(points[i]);
            }
        }
        max.forEach((Point o) -> System.out.println(o.x + " " + o.y));
  
    }
}

 

这个算法没通过牛客所有的样例，出现了超时。

 

2：数组区间最大值

给定一个数组序列, 需要求选出一个区间, 使得该区间是所有区间中经过如下计算的值最大的一个：

区间中的最小数 * 区间所有数的和最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列  [6 2 1]则根据上述公式, 可得到所有可以选定各个区间的计算值:

 

[6] = 6 * 6 = 36;

[2] = 2 * 2 = 4;

[1] = 1 * 1 = 1;

[6,2] = 2 * 8 = 16;

[2,1] = 1 * 3 = 3;

[6, 2, 1] = 1 * 9 = 9;

 

从上述计算可见选定区间 [6] ，计算值为 36， 则程序输出为 36。

区间内的所有数字都在[0, 100]的范围内;

输入描述:

第一行输入数组序列长度n，第二行输入数组序列。
对于 50%的数据,  1 <= n <= 10000;
对于 100%的数据, 1 <= n <= 500000;

输出描述:

输出数组经过计算后的最大值。

输入例子1:

3
6 2 1

输出例子1:

36

思路：首先要找出区间，计算区间的最小值与区间所有数之和的乘积。而在找区间的过程中，把每一个数都当作子区间的最小值，从当前数
开始，寻找左右边界，即找到比当前值还小的数时停止寻找，在找边界的过程中，同时计算区间的和，最终比较得到能得到最大值的区间，并
输出最大值。

import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
 
        Scanner sc  = new Scanner(System.in);
        int n = sc.nextInt();
        int[] num = new int[n];
        sc.nextLine();
        for(int i = 0; i < n; i++){
            num[i] = sc.nextInt();
        }
 
        int res = 0;
        for(int i = 0; i < n; i++){
            int sum = num[i];
            //左边界
            for(int j = i-1; j >= 0; j--){
                if(num[j] >= num[i]){
                    sum += num[j];
                }else{
                    break;
                }
            }
            //右边界
            for(int j = i+1; j < n; j++){
                if(num[j] >= num[i]){
                    sum += num[j];
                }else{
                    break;
                }
            }
            if(sum * num[i]  > res){
                res = sum * num[i];
            }
 
        }
        System.out.println(res);
 
    }
}

 

3：idea实现的时间点

产品经理(PM)有很多好的idea，而这些idea需要程序员实现。现在有N个PM，在某个时间会想出一个 idea，每个 idea 有提出时间、所需时间和优先等级。对于一个PM来说，最想实现的idea首先考虑优先等级高的，相同的情况下优先所需时间最小的，还相同的情况下选择最早想出的，没有 PM 会在同一时刻提出两个 idea。

同时有M个程序员，每个程序员空闲的时候就会查看每个PM尚未执行并且最想完成的一个idea,然后从中挑选出所需时间最小的一个idea独立实现，如果所需时间相同则选择PM序号最小的。直到完成了idea才会重复上述操作。如果有多个同时处于空闲状态的程序员，那么他们会依次进行查看idea的操作。

求每个idea实现的时间。

输入第一行三个数N、M、P，分别表示有N个PM，M个程序员，P个idea。随后有P行，每行有4个数字，分别是PM序号、提出时间、优先等级和所需时间。输出P行，分别表示每个idea实现的时间点。

输入描述:

输入第一行三个数N、M、P，分别表示有N个PM，M个程序员，P个idea。随后有P行，每行有4个数字，分别是PM序号、提出时间、优先等级和所需时间。全部数据范围 [1, 3000]。

输出描述:

输出P行，分别表示每个idea实现的时间点。

输入例子1:

2 2 5
1 1 1 2
1 2 1 1
1 3 2 2
2 1 1 2
2 3 5 5

输出例子1:

3
4
5
3
9


思路：

使用优先级队列ideaQueue存储每个pm所想要完成的idea，依照idea的提交时间进行排序，Idea mostDesiredIdea(int time)返回的是时间time时，当前pm最想完成的idea，在这个函数中，需要再构建一个优先级队列ideaQueue2，排序原则就是优先级最高，所需时间最小，最早提出，把ideaQueue中所有提交时间小于time的idea入队，mostDesiredIdea的求法就是，若ideaQueue2不为空，取队头元素，若为空则取ideaQueue的对头元素，即提交时间最早的idea（目前的time<这个idea的提交时间），若ideaQueue2取了队头元素还不为空，把里边的元素重新放入队列ideaQueue中。

Idea selectIdea(PM[] pms, int time)的功能是从所有pm想要完成的idea中，挑选出一个idea，程序员进行执行，构建一个优先级队列ideaQueue，排序原则就是所需时间最小，pm序号最小，需要注意，有可能当前的时间time都小于ideaQueue中idea的提交时间，这时，ideaqueue中的排序原则就需要按照提交时间进行排序，即当时间到达提交最早的idea的时间时，执行该idea。取出ideaQueue中的队头元素时，若还不为空，把剩下的元素插入到pm的ideaQueue中。
计算idea的endTime，取最大值的缘故是考虑到当前时间还没到idea的提交时间，而该idea必定是时间到达其提交时间时立马执行的idea，所以取提交时间postTime和程序员执行开始时间的最大值，再加上该idea所需花费的时间costTime，最后更新程序员的nextWorkTime，并把程序员再插入到程序员的优先队列中，程序员的优先队列programmerQueue的排序原则为，nextWorkTime越小。

idea.endTime = Integer.max(idea.postTime, programmer.nextWorkTime) + idea.costTime;
programmer.nextWorkTime = idea.endTime;
programmerQueue.offer(programmer);

代码思想主要来自 https://blog.csdn.net/qq_23666815/article/details/79182805

import java.util.*;


public class Main {

    static class Idea{
        int pm;
        int postTime;
        int prio;
        int costTime;
        int endTime;
        public Idea(int pm, int postTime, int prio, int costTime){
            this.pm = pm;
            this.postTime = postTime;
            this.prio = prio;
            this.costTime = costTime;
        }

    }

    static class PM {
       PriorityQueue<Idea> ideaQueue = new PriorityQueue<>(Comparator.comparingInt(x -> x.postTime));

        //当前time时间下，这个PM最想完成的idea
        Idea mostDesiredIdea(int time){
            PriorityQueue<Idea> ideaQueue2 = new PriorityQueue<>((i1, i2) -> {
               if(i1.prio != i2.prio) return i2.prio - i1.prio;
               else if(i1.costTime != i2.costTime) return i1.costTime - i2.costTime;
               else return i1.postTime - i2.postTime;
            });

            while (ideaQueue.peek() != null && ideaQueue.peek().postTime <= time){
                ideaQueue2.offer(ideaQueue.poll());
            }

            Idea mostDesiredIdea = (ideaQueue2.isEmpty()) ? ideaQueue.poll() : ideaQueue2.poll();
            while (!ideaQueue2.isEmpty()){
                ideaQueue.offer(ideaQueue2.poll());
            }

            return mostDesiredIdea;

        }
    }


    static class Programmer{
        int nextWorkTime;//下次可以工作的时间

        public Programmer(int nextWorkTime){
            this.nextWorkTime = nextWorkTime;
        }
    }


    //从多个PM最想完成的idea中，选择一个PM想要完成的idea

    private static Idea selectIdea(PM[] pms, int time){
        PriorityQueue<Idea> ideaQueue = new PriorityQueue<>((i1, i2) -> {
            //return i1.costTime == i2.costTime ? i1.pm - i2.pm : i1.costTime - i2.costTime;
            if(i1.postTime == i2.postTime || (i1.postTime <= time && i2.postTime <= time)){
                if(i1.costTime != i2.costTime) return i1.costTime - i2.costTime;
                else return i1.pm - i2.pm;
            }
            if(i1.postTime > time && i2.postTime > time) return i1.postTime - i2.postTime;
            if(i1.postTime > time) return 1;
            if(i2.postTime > time) return -1;
            return 0;
        });

        for(int i = 1; i < pms.length; i++){
            Idea desiredIdea = pms[i].mostDesiredIdea(time);
            if(desiredIdea != null){
                ideaQueue.offer(desiredIdea);
            }
        }

        Idea idea =  ideaQueue.poll();
        while (!ideaQueue.isEmpty()){
            Idea tmp = ideaQueue.poll();
            pms[tmp.pm].ideaQueue.offer(tmp);
        }
        return idea;
    }

    public static void main(String[] args) {

        Scanner sc  = new Scanner(System.in);
        int n = sc.nextInt(); //产品经理
        int m = sc.nextInt();//程序员
        int p = sc.nextInt();//任务数

        List<Idea> ideas = new LinkedList<>();
        while(p-- > 0){
            ideas.add(new Idea(sc.nextInt(),sc.nextInt(),sc.nextInt(),sc.nextInt()));
        }
        PM[] pms = new PM[n+1];
        for(int i = 1;i <= n; i++){
            pms[i] = new PM();
        }
        for(Idea idea : ideas){
            pms[idea.pm].ideaQueue.offer(idea);
        }

        PriorityQueue<Programmer> programmerQueue = new PriorityQueue<>(Comparator.comparingInt(x -> x.nextWorkTime));
        for(int i = 0; i < m; i++) programmerQueue.offer(new Programmer(0));
        //int num = 0;
        while(true){
            Programmer programmer = programmerQueue.poll();
            Idea idea = selectIdea(pms, programmer.nextWorkTime);
            if(idea == null) break;
            idea.endTime = Integer.max(idea.postTime, programmer.nextWorkTime) + idea.costTime;
            programmer.nextWorkTime = idea.endTime;
            programmerQueue.offer(programmer);

        }

        for(Idea idea : ideas){
            System.out.println(idea.endTime);
        }

    }

}