LeetCode70--三维形体的表面积、缀点成线、访问所有点的最小时间

1.三维形体的表面积

//给你一个 n * n 的网格 grid ，上面放置着一些 1 x 1 x 1 的正方体。 
//
// 每个值 v = grid[i][j] 表示 v 个正方体叠放在对应单元格 (i, j) 上。 
//
// 放置好正方体后，任何直接相邻的正方体都会互相粘在一起，形成一些不规则的三维形体。 
//
// 请你返回最终这些形体的总表面积。 
//
// 注意：每个形体的底面也需要计入表面积中。 
//
// 
//
// 
// 
//
// 示例 1： 
//
// 
//输入：grid = [[2]]
//输出：10
// 
//
// 示例 2： 
//
// 
//输入：grid = [[1,2],[3,4]]
//输出：34
// 
//
// 示例 3： 
//
// 
//输入：grid = [[1,0],[0,2]]
//输出：16
// 
//
// 示例 4： 
//
// 
//输入：grid = [[1,1,1],[1,0,1],[1,1,1]]
//输出：32
// 
//
// 示例 5： 
//
// 
//输入：grid = [[2,2,2],[2,1,2],[2,2,2]]
//输出：46
// 
//
// 
//
// 提示： 
//
// 
// n == grid.length 
// n == grid[i].length 
// 1 <= n <= 50 
// 0 <= grid[i][j] <= 50 
// 
// Related Topics 几何 数学

 这个是计算每个单元块上的自己贡献的面积，包括底面和顶面还需要判断其上下左右和它接触的其他单元格，如果比它高，那就不需要进行计算了，记为0.如果比它矮，那就计算其露出来的高度。

public int surfaceArea(int[][] grid) {
        int[] dr = new int[] {0, 1, 0, -1};
        int[] dc = new int[] {1, 0, -1, 0};

        int N = grid.length;
        int ans = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if(grid[i][j]>0){
                    //如果这个网格中的值不为零，那么就加上顶面和底面两个面
                    ans += 2;
                    for (int k = 0; k < 4; k++) {
                        int nr = i + dr[k];
                        int nc = j + dc[k];
                        int nv = 0;
                        if(nr >= 0 && nr < N && nc >= 0 && nc < N){
                            nv = grid[nr][nc];
                        }
                        ans += Math.max(grid[i][j]-nv, 0);
                    }
                }
            }
        }
        return ans;
    }

2.缀点成线

//在一个 XY 坐标系中有一些点，我们用数组 coordinates 来分别记录它们的坐标，其中 coordinates[i] = [x, y] 表示横坐标为
// x、纵坐标为 y 的点。 
//
// 请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 true，否则请返回 false。 
//
// 
//
// 示例 1： 
//
// 
//
// 输入：coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
//输出：true
// 
//
// 示例 2： 
//
// 
//
// 输入：coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]
//输出：false
// 
//
// 
//
// 提示： 
//
// 
// 2 <= coordinates.length <= 1000 
// coordinates[i].length == 2 
// -10^4 <= coordinates[i][0], coordinates[i][1] <= 10^4 
// coordinates 中不含重复的点 
// 
// Related Topics 几何 数组 数学

这个就用两个点求出一个解析式，然后看之后的点符不符合这个式子 

public boolean checkStraightLine(int[][] coordinates) {
        int N = coordinates.length;
        if(coordinates[1][0] == coordinates[0][0]){
            for (int i = 2; i < N; i++) {
                if(coordinates[i][0] != coordinates[1][0]){
                    return false;
                }
            }
            return true;
        }
        float y = coordinates[1][1] - coordinates[0][1];
        float x = coordinates[1][0] - coordinates[0][0];
        double k = y/x;
        double b = coordinates[0][1] - k * coordinates[0][0];
        for (int i = 2; i < N; i++) {
            if(k*coordinates[i][0]+b != coordinates[i][1]){
                return false;
            }
        }
        return true;
    }

3.访问所有点的最小时间

//平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi] 。请你计算访问所有这些点需要的 最小时间（以秒为单位）。 
//
// 你需要按照下面的规则在平面上移动： 
//
// 
// 每一秒内，你可以：
// 
// 沿水平方向移动一个单位长度，或者 
// 沿竖直方向移动一个单位长度，或者 
// 跨过对角线移动 sqrt(2) 个单位长度（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。 
// 
// 
// 必须按照数组中出现的顺序来访问这些点。 
// 在访问某个点时，可以经过该点后面出现的点，但经过的那些点不算作有效访问。 
// 
//
// 
//
// 示例 1： 
//
// 
//
// 
//输入：points = [[1,1],[3,4],[-1,0]]
//输出：7
//解释：一条最佳的访问路径是： [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> 
//[-1,0]   
//从 [1,1] 到 [3,4] 需要 3 秒 
//从 [3,4] 到 [-1,0] 需要 4 秒
//一共需要 7 秒 
//
// 示例 2： 
//
// 
//输入：points = [[3,2],[-2,2]]
//输出：5
// 
//
// 
//
// 提示： 
//
// 
// points.length == n 
// 1 <= n <= 100 
// points[i].length == 2 
// -1000 <= points[i][0], points[i][1] <= 1000 
// 
// Related Topics 几何 数组

这个直接通过找规律得到的，首先我们走斜线，走到离下一个点最近的地方，这个时候我们的一个坐标的值和下一个点的是一样的，然后我们再直行，其实走的时间就是相差最大的两个坐标差值。

public int minTimeToVisitAllPoints(int[][] points) {
        int ans = 0;
        int N = points.length;
        for (int i = 1; i < N; i++) {
            ans += Math.max(Math.abs(points[i][1] - points[i - 1][1]), Math.abs(points[i][0] - points[i - 1][0]));
        }
        return ans;
    }