2019年9月22号vivo秋招后台开发编程题

因为面科大讯飞的时候被问有没有写博客的习惯，然后给他分享了自己的有道云笔记，想想还是写写博客，鼓励自己，帮助有需要的人吧，vivo笔试就一小时，本菜鸡只能写完第一题，第二题约瑟夫环，一开始没想到数学通解，直接做第三题，结果第三题并不简单，一开始想着用贪心，但是使用贪心算法我又不能证明合法性，又跳回准备用暴力解法解，居然没撕出来，想想大概率凉了，23号一早到实验室就为了这些事重新撕这三道题，第三题给出贪心算法解题思路，希望大佬轻拍且指正，唉，非科班的刷题就是这么朴实无华且枯燥。

第一题：

测试样例：2 1 3 5 6 2

输出：2

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

public class VivoCode1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] strs = sc.nextLine().trim().split(" ");
        sc.close();
        int[] arr = new int[strs.length];
        for (int i = 0; i < strs.length; i++) {
            arr[i] = Integer.valueOf(strs[i]);
        }
        System.out.println(process(arr));
    }

    private static int process(int[] arr) {
        if (arr == null || arr.length == 0) return -1;
        if (arr.length == 1) return 0;
        // dp[i]代表起点到达i的最少步数
        int[] dp = new int[arr.length];
        // 认为所有点不可达
        Arrays.fill(dp, -1);
        // 起点必达
        dp[0] = 0;
        // 计算每个点的最少步数
        for (int i = 1; i < dp.length; i++) {
            // 到达前面所有 可达 点 能到达目标点 且 到达当前点的步数最小 的+1
            for (int j = 0; j < i; j++) {
                if (dp[j] != -1 && j + arr[j] >= i) {
                    // dp[i]默认为-1，代表不可达，第一次可达时，置数
                    if (dp[i] == -1) dp[i] = dp[j] + 1;
                    dp[i] = Math.min(dp[i], dp[j] + 1);
                }
            }
        }
        return dp[dp.length - 1];
    }
}

第二题：

测试样例： 6 3

输出：3 6 4 2 5 1

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class VivoCode2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        sc.close();
        System.out.println(process(n, m));
    }

    private static String process(int n, int m) {
        StringBuffer res = new StringBuffer();
        List<Integer> list = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            list.add(i + 1);
        }
        int count = 1;
        int index = 0;
        while (list.size() != 0) {
            count++;
            index++;
            index %= list.size();
            if (count == m) {
                count = 1;
                res.append(list.get(index)).append(" ");
                list.remove(index);
            }
        }
        return res.toString().trim();
    }
}

第三题：

给出贪心算法，我没做过测试，就单纯认为，在不加数量约束时，怎么保证两边相差最小，先排序，再补轻的矿车

再根据约束条件，不得不向少的车加矿

自己写的样例： 1 5 7 8 9 13

理想输出：5 7 9       1 8 13   结果为1

我的输出   1 7 9        5 8 13   结果为9

样例未通过，路过的大佬提供点思路吧

package vivo;

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

public class VivoCode3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] strs = sc.nextLine().trim().split(" ");
        sc.close();
        int[] arr = new int[strs.length];
        for (int i = 0; i < strs.length; i++) {
            arr[i] = Integer.valueOf(strs[i]);
        }
        Arrays.sort(arr);
        System.out.println(process(arr));
    }

    private static int process(int[] weight) {
        if (weight == null || weight.length == 0) return 0;
        if (weight.length == 1) return weight[0];
        int leftWeight = weight[0];
        int rightWeight = weight[1];
        int leftCount = 1;
        int rightCount = 1;
        for (int i = 3; i < weight.length; i++) {
            // 如果两矿车的矿数量一致，接下来的矿石放在不重的一边
            if (leftCount == rightCount) {
                if (leftWeight <= rightCount) {
                    leftCount++;
                    leftWeight += weight[i];
                } else {
                    rightCount++;
                    rightWeight += weight[i];
                }
            } else if (leftCount > rightCount) {
                rightCount++;
                rightWeight += weight[i];
            } else {
                leftCount++;
                leftWeight += weight[i];
            }
        }
        return Math.abs(leftWeight - rightWeight);
    }
}