秋招面/笔试题目集合——03

第一题

思路：暴力递归——》记忆化搜索

public class 第一题03 {
    public static void main(String[] args) {
        int[] a = {2,1,6,5,7,3};
        int[] b = {3,3,4,4,6,6};
        boolean res1 = canSorted1(a, b);
        boolean res2 = canSorted2(a, b);
        System.out.println(res1);
        System.out.println(res2);
    }
    public static boolean canSorted1(int[] A,int[] B){
        if (A == null || A.length < 2){
            return true;
        }
        return process1(A,B,1,false) || process1(A,B,1,true);
    }

    private static boolean process1(int[] a, int[] b, int index, boolean swap) {
        if (index == a.length){
            return true;
        }
        int cur = swap ? b[index - 1] : a[index - 1];
        boolean p1 = a[index] > cur && process1(a, b, index + 1, false);
        boolean p2 = b[index] > cur && process1(a, b, index + 1, true);
        return p1 || p2;
    }
    public static boolean canSorted2(int[] A,int[] B){
        if (A == null || A.length < 2){
            return true;
        }
        int[][] dp = new int[A.length][2];
        return process2(A,B,1,false, dp) || process2(A,B,1,true,dp);
    }

    private static boolean process2(int[] a, int[] b, int index, boolean swap, int[][] dp) {
        if (index == a.length){
            return true;
        }
        int sw = swap ? 1 : 0;
        if (dp[index][sw] == 1){
            return true;
        }
        if (dp[index][sw] == 2){
            return false;
        }
        int cur = swap ? b[index - 1] : a[index - 1];
        boolean p1 = a[index] > cur && process2(a, b, index + 1, false, dp);
        boolean p2 = b[index] > cur && process2(a, b, index + 1, true, dp);
        boolean p = p1 || p2;
        dp[index][sw] = p ? 1 : 2;
        return dp[index][sw] == 1;
    }
}

第二题

思路：贪心

public class 第二题03 {
    public static void main(String[] args) {
        int[] arr = {1,3,9,10,13,21,23,36};
        int res = minSplit(arr, 2, 4);
        System.out.println(res);
    }
    public static int minSplit(int[] arr,int k,int x){
        int n = arr.length;
        int[] need = new int[n];
        int index = 0;
        int splitCount = 1;
        for (int i = 0;i < n - 1;i++){
            if (arr[i + 1] - arr[i] > x){
                need[index++] = arr[i + 1] - arr[i];
                splitCount++;
            }
        }
        Arrays.sort(need,0,index);
        for (int i = 0;i < index;i++){
            int count = (need[i] - 1) / x;
            if (k >= count){
                k -= count;
                splitCount--;
            }else {
                break;
            }
        }
        return splitCount;
    }
}

第三题

思路：拓扑排序 + 广播

public class 第三题03 {
    public static int[] finishTime(int n,int[] time,int[][] matrix){
        ArrayList<ArrayList<Integer>> nexts = new ArrayList<>();//邻接表
        for (int i = 0;i < n;i++){
            nexts.add(new ArrayList<>());
        }
        int[] in = new int[n];//入度
        for (int[] line : matrix){
            nexts.get(line[1]).add(line[0]);
            in[line[0]]++;
        }
        Queue<Integer> zeroQueue = new LinkedList<>();//入度为0的队列
        int[] ans = new int[n];
        for (int i = 0;i < n;i++){
            if (in[i] == 0){
                zeroQueue.add(i);
            }
        }
        while (!zeroQueue.isEmpty()){//拓扑排序 + 广播
            int cur = zeroQueue.poll();
            ans[cur] += time[cur];
            for (int next : nexts.get(cur)){
                ans[next] = Math.max(ans[cur],ans[next]);
                in[next]--;
                if (in[next] == 0){
                    zeroQueue.add(next);
                }
            }
        }
        return ans;
    }
}