Leetcode P699 Java使用枚举解决， 简单易懂

Leetcode P699 Java使用枚举解决， 简单易懂

ideas

首先我们要创建几个变量，一个负责返回最终的数据，一个负责每个正方形的信息，一个负责记录所有加载过的正方形，一个负责记录最大的高度

        //返回内容
        List<Integer> res = new ArrayList<>();
        //记录每个方块的定位下标和宽和高
        /**
         * data[0]  定位下标
         * data[1]  正方形的边长结束的下标
         * data[2]  最占用的高
         */
        List<int[]> data = new ArrayList<>();
        //用来记录堆叠的最高的高
        int max = 0;

接下来就遍历每个要进行操作的正方形，在遍历过程中我们要设置一个变量，用来记录所有加载过的正方形最大的高

//记录所有加载过的正方形最高的高
int high = 0;

接下来查看所有加载过的正方形，为了计算出题目要求的height of the current tallest stack of squares.

如果当前正方形的定位下标+正方形长度还没有 当前遍历的正方形的定位坐标大OR当前正方形的起点坐标大于之前加载过的正方形边长的结束下标就证明出没有发生堆叠现象，就进行下一次循环 用>= 是因为会遍历过的正方形截止下标在4，初始下标也在4，他们只是发生了相邻关系，并没有发生堆叠的关系

if (arr[1] <= positions[i][0] || positions[i][0] + positions[i][1] <= arr[0]){
    continue;
}
  //如果没有发生重叠 就判断当前高大，还是正方形的边长大
  //获取遍历过的正方形最高的高
  high = Math.max(high,arr[2]);

将上述遍历过的正方形最高的高 + 当前正方形的边长 计算出当前正方形可能发生的重叠的情况的高，如果没有发生重叠的情况那么high还是0，如果发生了重叠的情况那么就是重叠，接下来判断是最大的堆叠的高度高还是当前正方形所重叠的高度高和重新计算的堆积最大的高度

high += positions[i][1];
max  = Math.max(high,max);

把当前正方和放去加载列表，和当前最大堆积的高放入返回集合

            data.add(new int[]{positions[i][0],positions[i][0]+positions[i][1],high});
            res.add(max);

code

package leccod;

import java.util.ArrayList;
import java.util.List;

public class P699 {
    public static void main(String[] args) {
        System.out.println(new P699().fallingSquares(new int[][]{{1, 2}, {2, 3}, {6, 1}}));
    }

    public List<Integer> fallingSquares(int[][] positions) {
        //返回内容
        List<Integer> res = new ArrayList<>();
        //记录每个方块的定位下标和宽和高
        /**
         * data[0]  初始化下标
         * data[1]  正方形的边长结束的下标
         * data[2]  最占用的高
         */
        List<int[]> data = new ArrayList<>();
        //用来记录堆叠的最高的高
        int max = 0;

        for (int i = 0; i < positions.length; i++) {
            //记录所有加载过的正方形最高的高
            int high = 0;
            //查看加载过的正方形，为了计算高
            for (int j = 0; j < data.size(); j++) {
                int[] arr = data.get(j);
                /**
                 * 如果当前正方形的定位下标+正方形长度还没有 当前遍历的正方形的定位坐标大
                 * 或者
                 * 当前正方形的起点坐标大于之前加载过的正方形边长的结束下标
                 * 就证明出没有发生堆叠现象，就进行下一次循环
                 * 使用>= 是因为会遍历过的正方形截止下标在4，初始下标也在4，他们只是发生了相邻关系，并没有发生堆叠的关系
                 */
                System.out.println("positions[i][0] + positions[i][1]="+(positions[i][0] + positions[i][1])+"<= arr[0]="+arr[0]);
                System.out.println("arr[1]"+arr[1]  +"<= positions[i][0]="+positions[i][0]);

                if (arr[1] <= positions[i][0] || positions[i][0] + positions[i][1] <= arr[0]){
                    continue;
                }
                System.out.println("发生堆叠");
                //如果没有发生重叠 就判断当前高大，还是正方形的边长大
                //获取遍历过的正方形最高的高
                high = Math.max(high,arr[2]);
            }

            //将上述遍历过的正方形最高的高 + 当前正方形的边长 计算出当前正方形可能发生的重叠的情况的高，
            //如果没有发生重叠的情况那么high还是0，如果发生了重叠的情况那么就是重叠
            //接下来判断是最大的堆叠的高度高还是当前正方形所重叠的高度高和重新计算的堆积最大的高度
            high += positions[i][1];

            max  = Math.max(high,max);
            //把当前正方和放去加载列表，和当前最大堆积的高放入返回集合
            data.add(new int[]{positions[i][0],positions[i][0]+positions[i][1],high});
            res.add(max);
        }

        return res;
    }
}