【案例1】

【题目描述难度非常高】

【思路解析】

因为要求额外空间复杂度为O(1)，所以我们只能使用有限几个变量，来得到整个数组所在的城市距离首都的距离。因为数组paths[i]表示，i城市指向paths[i]城市，我们可以利用这个指向关系（next为下次要去的城市，last为当前城市。并且在往前遍历时，要记录回去的信息，即paths[next的值]=last的值，这样我们就可以再通过last和next往回走），一直往前遍历，直到next==paths[next]，或者paths[next] < 0,我们便开始往回走，并且回走时，如果城市i距离首都为x，则给paths[i]赋值为-x。

然后得到了这个距离数组后，再通过判断距离数组的正负来统计距离（通过指向关系来进行循环计数）的个数。

【代码实现】

import java.util.Arrays;

/**
 * @ProjectName: study3
 * @FileName: Ex1
 * @author:HWJ
 * @Data: 2023/9/14 22:30
 */
public class Ex1 {
    public static void main(String[] args) {
        int[] paths = {9, 1, 4, 9, 0, 4, 8, 9, 0, 1};
        pathToDistance(paths);
        distanceToCount(paths);
        System.out.println(Arrays.toString(paths));
    }

    public static void pathToDistance(int[] paths) {
        int n = paths.length;
        int capital = -1;
        for (int start = 0; start < n; start++) {
            if (paths[start] == start) {
                capital = start;
            } else if (paths[start] > -1) {
                int last = start;
                int next = paths[last];
                while (paths[next] != next && paths[next] > -1) {
                        int num = paths[next];
                        paths[next] = last;
                        last = next;
                        next = num;
                }
                int i = paths[next] == next ? 0 : paths[next];
                while (last != start) {
                    int num = paths[last];
                    paths[last] = --i;
                    last = num;
                }
                paths[last] = --i;
            }
        }
        paths[capital] = 0;
    }

    public static void distanceToCount(int[] paths){
        for (int i = 0; i < paths.length; i++) {
            int cur = paths[i];
            paths[i] = Math.max(paths[i], 0);
            while (cur <= 0){
                int next = paths[-cur];
                if (next < 0){
                    paths[-cur] = 1;
                    cur = next;
                }else {
                    paths[-cur]++;
                    break;
                }
            }

        }
    }
}

【案例2】

【题目描述分糖果问题】

一群孩子做游戏，现在请你根据游戏得分来发糖果，要求如下：

每个孩子不管得分多少，起码分到一个糖果。
任意两个相邻的孩子之间，得分较多的孩子必须拿多一些糖果。
【进价】要求相邻的两个孩子如果得分相同，得到的糖果应该相同。
要求时间复杂度为O(N)

【思路解析】

我们可以通过得分数组得到一个得分的折线图（即升降情况），然后通过从左向右遍历这个升降情况得到每个人应该分到的糖果数。然后通过从右向左遍历这个升降情况得到每个人应该分到的糖果数。然后对应求最大即为每个孩子的糖果数。遍历时要求升序糖果数++，如果降序或者保持不变，使糖果数变回1.

【进价思路分析】

我们可以通过得分数组得到一个得分的折线图（即升降情况），然后通过从左向右遍历这个升降情况得到每个人应该分到的糖果数。然后通过从右向左遍历这个升降情况得到每个人应该分到的糖果数。然后对应求最大即为每个孩子的糖果数。遍历时要求升序糖果数++，如果降序使糖果数变回1，如果保持不变，则使糖果数保持不变。

【代码实现】

/**
 * @ProjectName: study3
 * @FileName: Ex2
 * @author:HWJ
 * @Data: 2023/9/15 0:07
 */
public class Ex2 {
    public static void main(String[] args) {
        int[] scores = {1, 2, 2};
        System.out.println(candy1(scores));
        System.out.println(candy2(scores));
    }

    public static int candy1(int[] scores){
        int[] left = new int[scores.length];
        int[] right = new int[scores.length];
        left[0] = 1;
        for (int i = 1; i < scores.length; i++) {
            if(scores[i] > scores[i - 1]){
                left[i] = left[i - 1] + 1;
            }else {
                left[i] = 1;
            }
        }
        right[scores.length - 1] = 1;
        for (int i = scores.length - 2; i >= 1; i--) {
            if(scores[i] > scores[i + 1]){
                right[i] = right[i + 1] + 1;
            }else {
                right[i] = 1;
            }
        }
        int res = 0;
        for (int i = 0; i < scores.length; i++) {
            res += Math.max(left[i], right[i]);
        }
        return res;
    }

    public static int candy2(int[] scores){
        int[] left = new int[scores.length];
        int[] right = new int[scores.length];
        left[0] = 1;
        for (int i = 1; i < scores.length; i++) {
            if(scores[i] > scores[i - 1]){
                left[i] = left[i - 1] + 1;
            }else if (scores[i] < scores[i - 1]){
                left[i] = 1;
            }else {
                left[i] = left[i - 1];
            }
        }
        right[scores.length - 1] = 1;
        for (int i = scores.length - 2; i >= 1; i--) {
            if(scores[i] > scores[i + 1]){
                right[i] = right[i + 1] + 1;
            }else if (scores[i] < scores[i + 1]){
                right[i] = 1;
            }else {
                right[i] = right[i + 1];
            }
        }
        int res = 0;
        for (int i = 0; i < scores.length; i++) {
            res += Math.max(left[i], right[i]);
        }
        return res;
    }
}

【超级进阶非常难】

要求时间复杂度为O(N), 额外空间复杂度为O(1)。实现特别困难。

【案例3】

【题目描述】

【思路解析】二叉树递归套路类题目

第一种思路，列出所有可能性，然后在递归时得到所有可能性，然后不断汇总求最优解。

能获得最优解的可能性如下：

（1）x结点以下都被照亮（包含x结点），且x上不放灯。

（2）x结点以下都被照亮（包含x结点），且x上放灯。

（3）x结点以下都被照亮（不包含x结点），但x上放灯。（因为这种情况可能引出下一个最优解，在x的父上放灯，影响的结点更多）。

第二种思路，我们在传递的时候已知最优解需要的是什么信息，利用贪心加速常数时间。

比如当左孩子和右孩子，未被覆盖时，x上必须放灯，如果左孩子和右孩子，被覆盖且放灯，则x上一定不放灯。如果左孩子和右子，被覆盖但没放灯，则x未被覆盖。

【代码实现】

/**
 * @ProjectName: study3
 * @FileName: Ex3
 * @author:HWJ
 * @Data: 2023/9/15 0:16
 */
public class Ex3 {
    public static void main(String[] args) {

    }

    public static class Node{
        Node left;
        Node right;
    }

    public static class ReturnData{
        public int unCovered;
        public int coveredNoCamera;
        public int coveredHasCamera;

        public ReturnData(int unCovered, int coveredNoCamera, int coveredHasCamera) {
            this.unCovered = unCovered;
            this.coveredNoCamera = coveredNoCamera;
            this.coveredHasCamera = coveredHasCamera;
        }
    }

    public static int getMin(Node head){
        ReturnData data = process(head);
        return Math.min(data.unCovered, Math.min(data.coveredHasCamera, data.coveredNoCamera));
    }

    public static ReturnData process(Node node){
        if (node == null){
            return new ReturnData(Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
        }
        ReturnData left = process(node.left);
        ReturnData right = process(node.right);
        int unCovered = left.coveredNoCamera + right.coveredNoCamera;
        int coveredNoCamera = Math.min(left.coveredHasCamera + right.coveredHasCamera,
                Math.min(left.coveredHasCamera + right.coveredNoCamera,
                        left.coveredNoCamera + right.coveredHasCamera));
        int coveredHasCamera = Math.min(left.unCovered,
                Math.min(left.coveredHasCamera, left.coveredNoCamera)) +
                Math.min(right.unCovered,
                        Math.min(right.coveredHasCamera, right.coveredNoCamera)) + 1;
        return new ReturnData(unCovered, coveredNoCamera, coveredHasCamera);
    }

    public enum Status{
        UNCOVERED, COVERED_NO_CAMERA, COVERED_HAS_CAMERA;
    }

    public static class ReturnData2{
        public Status status;
        public int cameras;

        public ReturnData2(Status status, int cameras) {
            this.status = status;
            this.cameras = cameras;
        }
    }

    public static int getMin2(Node head){
        ReturnData2 data = process2(head);
        return data.cameras + (data.status == Status.UNCOVERED ? 1 : 0);
    }

    public static ReturnData2 process2(Node node){
        if (node == null){
            return new ReturnData2(Status.COVERED_NO_CAMERA, 0);
        }
        ReturnData2 left = process2(node.left);
        ReturnData2 right = process2(node.right);
        int cameras = left.cameras + right.cameras;
        if (left.status == Status.UNCOVERED || right.status == Status.UNCOVERED){
            return new ReturnData2(Status.COVERED_HAS_CAMERA, cameras + 1);
        }
        if (left.status == Status.COVERED_HAS_CAMERA && right.status == Status.COVERED_HAS_CAMERA){
            return new ReturnData2(Status.COVERED_NO_CAMERA, cameras);
        }
        return new ReturnData2(Status.UNCOVERED, cameras);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1011467.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！