拼多多2018校园招聘编程题题解

一、列表补全

[编程题] 列表补全
时间限制：1秒

空间限制：32768K

在商城的某个位置有一个商品列表，该列表是由L1、L2两个子列表拼接而成。当用户浏览并翻页时，需要从列表L1、L2中获取商品进行展示。展示规则如下：

1. 用户可以进行多次翻页，用offset表示用户在之前页面已经浏览的商品数量，比如offset为4，表示用户已经看了4个商品

2. n表示当前页面需要展示的商品数量

3. 展示商品时首先使用列表L1，如果列表L1长度不够，再从列表L2中选取商品

4. 从列表L2中补全商品时，也可能存在数量不足的情况

请根据上述规则，计算列表L1和L2中哪些商品在当前页面被展示了


输入描述:
每个测试输入包含1个测试用例，包含四个整数，分别表示偏移量offset、元素数量n，列表L1的长度l1，列表L2的长度l2。


输出描述:
在一行内输出四个整数分别表示L1和L2的区间start1，end1，start2，end2，每个数字之间有一个空格。
注意，区间段使用半开半闭区间表示，即包含起点，不包含终点。如果某个列表的区间为空，使用[0, 0)表示，如果某个列表被跳过，使用[len, len)表示，len表示列表的长度。

输入例子1:
2 4 4 4
1 2 4 4
4 1 3 3

输出例子1:
2 4 0 2
1 3 0 0
3 3 1 2

题目不难，看懂意思即可，注意分情况讨论，offset可能落在哪个区域。

package 牛客刷题.拼多多2018校招编程.列表补全;

import java.util.Scanner;

/**
 * Created by Administrator on 2018/6/24 0024.
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int offset = scanner.nextInt();
            int n = scanner.nextInt();
            int l1 = scanner.nextInt();
            int l2 = scanner.nextInt();
            int start1 = -1, end1 = -1, start2 = -1, end2 = -1;
            if (offset < l1) {
                if (offset + n <= l1) {
                    start1 = offset;
                    end1 = offset + n;
                    start2 = 0;
                    end2 = 0;
                } else {
                    start1 = offset;
                    end1 = l1;
                    start2 = 0;
                    end2 = (offset + n <= l1 +l2)? offset+n-l1 : l2;
                }
            } else if (offset >= l1 && offset <= l1 + l2) {
                start1 = l1;
                end1 = l1;
                start2 = offset - l1;
                end2 = (offset + n <= l1 + l2)? offset + n -l1 : l2;
            } else {
                start1 = l1;
                end1 = l1;
                start2 = l2;
                end2 = l2;
            }
            System.out.println(start1 + " " + end1 + " " + start2 + " " + end2);
        }
    }
}

二、题目看不懂

三、数三角形

[编程题] 数三角形
时间限制：1秒

空间限制：32768K

给出平面上的n个点，现在需要你求出，在这n个点里选3个点能构成一个三角形的方案有几种。



输入描述:
第一行包含一个正整数n，表示平面上有n个点（n <= 100)
第2行到第n + 1行，每行有两个整数，表示这个点的x坐标和y坐标。(所有坐标的绝对值小于等于100，且保证所有坐标不同）


输出描述:
输出一个数，表示能构成三角形的方案数。

输入例子1:
4
0 0
0 1
1 0
1 1

输出例子1:
4

例子说明1:
4个点中任意选择3个都能构成三角形

嵌套三个循环暴力解，为避免重复，j在i的后面，k在j的后面。判断三点是否能组成三角形。判断三点是否共线。首先如果前两个点重合了，不可能组成三角形。如果前两个点重合，不论k取多少都不能组成三角形。现在判断x2-x1是零的情况。如果前两个点再一条竖直线上，只要第三个点不在这条直线上，肯定能组成三角形。其他情况下，判断乘积公式是否相同即能确定是否在一条直线上，我们要的是不在一条直线上的。

package 牛客刷题.拼多多2018校招编程.数三角形;

import java.util.Scanner;

/**
 * Created by jason on 2018/6/26.
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] points = new int[n][2];
        for (int i = 0; i < n; i++) {
            points[i][0] = scanner.nextInt();
            points[i][1] = scanner.nextInt();
        }
        int count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                for (int k = j+1; k < n; k++) {
                    if (points[i][0] == points[j][0] && points[i][1] == points[j][1]) {
                        break;
                    }
                    if (points[i][0] == points[j][0] && points[j][0] != points[k][0]) {
                        count++;
                        continue;
                    } else {
                        if ((points[j][0] - points[i][0]) *  (points[k][1] - points[j][1]) == (points[k][0] - points[j][0]) * (points[j][1] - points[i][1])) {
                            continue;
                        }
                        count++;
                    }
                }
            }
        }
        System.out.println(count);
    }
}

四、最大乘积

[编程题] 最大乘积
时间限制：1秒

空间限制：32768K

给定一个无序数组，包含正数、负数和0，要求从中找出3个数的乘积，使得乘积最大，要求时间复杂度：O(n)，空间复杂度：O(1) 
输入描述:
第一行是数组大小n，第二行是无序整数数组A[n]


输出描述:
满足条件的最大乘积

输入例子1:
4
3 4 1 2

输出例子1:
24

冒泡排序的方法，先连用三次，得到最大的三个数。
冒泡排序方法，连用两次，得到最小的两个数。因为最小的两个数很有可能是两个负数，负负得正，有可能得到的值是很大的。
这里用到了大数类。

package 牛客刷题.拼多多2018校招编程.最大乘积;

import java.math.BigInteger;
import java.util.Scanner;

/**
 * Created by jason on 2018/6/26.
 * 测试用例
 * 10
 11155489 456897451 12475 4568 -5467 -10145 5426 -54267 4785921 145
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        if (n < 3) {
            return;
        }
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        //冒泡排序求正数的前三个最大值
        //求负数的前两个最小值
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < n-1; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j+1);
                }
            }
        }
        for (int i = 0; i < 2; i++) {
            for (int j = n-1; j >0; j--) {
                if (arr[j] < arr[j-1]) {
                    swap(arr, j , j-1);
                }
            }
        }

        BigInteger num1 = new BigInteger(String.valueOf(arr[n-1]));
        BigInteger num2 = new BigInteger(String.valueOf(arr[n-2]));
        BigInteger num3 = new BigInteger(String.valueOf(arr[n-3]));
        BigInteger res1 = num1.multiply(num2).multiply(num3);
        BigInteger num4 = new BigInteger(String.valueOf(arr[0]));
        BigInteger num5 = new BigInteger(String.valueOf(arr[1]));
        BigInteger res2 = num4.multiply(num5).multiply(num1);
        res1 = res1.compareTo(res2) < 0 ? res2 : res1;
        System.out.println(res1.toString());
        //long num1 = arr[n-1] * arr[n-2] * arr[n-3];
        //long num2 = arr[0] * arr[1] * arr[n-1];
        //long res = Math.max(num1, num2);
        //System.out.println(res);
    }
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

}

五、小熊吃糖

小熊吃糖
时间限制：1秒

空间限制：32768K

有n只小熊，他们有着各不相同的战斗力。每次他们吃糖时，会按照战斗力来排，战斗力高的小熊拥有优先选择权。前面的小熊吃饱了，后面的小熊才能吃。每只小熊有一个饥饿值，每次进食的时候，小熊们会选择最大的能填饱自己当前饥饿值的那颗糖来吃，可能吃完没饱会重复上述过程，但不会选择吃撑。
现在给出n只小熊的战斗力和饥饿值，并且给出m颗糖能填饱的饥饿值。
求所有小熊进食完之后，每只小熊剩余的饥饿值。



输入描述:
第一行两个正整数n和m，分别表示小熊数量和糖的数量。（n <= 10, m <= 100）
第二行m个正整数，每个表示着颗糖能填充的饥饿值。
接下来的n行，每行2个正整数，分别代表每只小熊的战斗力和当前饥饿值。
题目中所有输入的数值小于等于100。


输出描述:
输出n行，每行一个整数，代表每只小熊剩余的饥饿值。

输入例子1:
2 5
5 6 10 20 30
4 34
3 35

输出例子1:
4
0

例子说明1:
第一只小熊吃了第5颗糖
第二只小熊吃了第4颗糖
第二只小熊吃了第3颗糖
第二只小熊吃了第1颗糖

正常思路，贪心法，对小熊和糖果排序即可，好好练习自定义排序的写法。

package 牛客刷题.拼多多2018校招编程.小熊吃糖;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

/**
 * Created by jason on 2018/6/26.
 * 2 5
 5 6 10 20 30
 4 34
 3 35
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        Candy[] candys = new Candy[m];
        for (int i = 0; i < m; i++) {
            Candy candy = new Candy(scanner.nextInt(), -1);
            candys[i] = candy;
        }
        Bear[] bears = new Bear[n];
        for (int i = 0; i < n; i++) {
            Bear bear = new Bear(scanner.nextInt(), scanner.nextInt());
            bears[i] = bear;
        }
        Bear[] copyBears = Arrays.copyOf(bears, bears.length);
        Arrays.sort(bears);
        Arrays.sort(candys, new MyComparator());
        int i = 0;
        while (i < n) {
            for (int j = 0; j < candys.length; j++) {
                if (bears[i].b >= candys[j].v && candys[j].p == -1) {
                    bears[i].b = bears[i].b - candys[j].v;
                    candys[j].p = 0;
                }
            }
            ++i;
        }
        for (int k = 0; k < n; k++) {
            System.out.println(copyBears[k].b);
        }
    }
}

class Bear implements Comparable<Bear>{
    int a; //战斗力
    int b; //饥饿度
    public Bear(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public int compareTo(Bear o) {
        return o.a - this.a;
    }

}

class Candy {
    int v; //糖果的值
    int p; //糖果的标志位，-1代表没被用，0代表以及被吃掉了
    public Candy (int v, int p) {
        this.v = v;
        this.p = p;
    }
}

class MyComparator implements Comparator<Candy> {
    @Override
    public int compare(Candy o1, Candy o2) {
        return o2.v - o1.v;
    }
}