LeetCode100--统计好三元组、矩阵对角线元素的和、圆形赛道上经过次数最多的扇区

1、统计好三元组

//给你一个整数数组 arr ，以及 a、b 、c 三个整数。请你统计其中好三元组的数量。 
//
// 如果三元组 (arr[i], arr[j], arr[k]) 满足下列全部条件，则认为它是一个 好三元组 。 
//
// 
// 0 <= i < j < k < arr.length 
// |arr[i] - arr[j]| <= a 
// |arr[j] - arr[k]| <= b 
// |arr[i] - arr[k]| <= c 
// 
//
// 其中 |x| 表示 x 的绝对值。 
//
// 返回 好三元组的数量 。 
//
// 
//
// 示例 1： 
//
// 输入：arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3
//输出：4
//解释：一共有 4 个好三元组：[(3,0,1), (3,0,1), (3,1,1), (0,1,1)] 。
// 
//
// 示例 2： 
//
// 输入：arr = [1,1,2,2,3], a = 0, b = 0, c = 1
//输出：0
//解释：不存在满足所有条件的三元组。
// 
//
// 
//
// 提示： 
//
// 
// 3 <= arr.length <= 100 
// 0 <= arr[i] <= 1000 
// 0 <= a, b, c <= 1000 
// 
// Related Topics 数组

直接采用枚举法，将所有三元组都给枚举出来，然后选择符合条件的。

public int countGoodTriplets(int[] arr, int a, int b, int c) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                for (int k = j+1; k < arr.length; k++) {
                    if (Math.abs(arr[i] - arr[j]) <= a
                        && Math.abs(arr[j] - arr[k]) <= b
                        && Math.abs(arr[i] - arr[k]) <= c) {
                        ++count;
                    }
                }
            }
        }
        return count;
    }

 2、矩阵对角线元素的和

//给你一个正方形矩阵 mat，请你返回矩阵对角线元素的和。 
//
// 请你返回在矩阵主对角线上的元素和副对角线上且不在主对角线上元素的和。 
//
// 
//
// 示例 1： 
//
// 
//
// 
//输入：mat = [[1,2,3],
//            [4,5,6],
//            [7,8,9]]
//输出：25
//解释：对角线的和为：1 + 5 + 9 + 3 + 7 = 25
//请注意，元素 mat[1][1] = 5 只会被计算一次。
// 
//
// 示例 2： 
//
// 
//输入：mat = [[1,1,1,1],
//            [1,1,1,1],
//            [1,1,1,1],
//            [1,1,1,1]]
//输出：8
// 
//
// 示例 3： 
//
// 
//输入：mat = [[5]]
//输出：5
// 
//
// 
//
// 提示： 
//
// 
// n == mat.length == mat[i].length 
// 1 <= n <= 100 
// 1 <= mat[i][j] <= 100 
// 
// Related Topics 数组

public int diagonalSum(int[][] mat) {
        int sum = 0;
        int m = mat.length;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                if(i == j){
                    sum += mat[i][j];
                }else if(i == m-j-1 && i != j){
                    sum += mat[i][j];
                }
            }
        }
        return sum;
    }

 3、圆形赛道上经过次数最多的扇区

//给你一个整数 n 和一个整数数组 rounds 。有一条圆形赛道由 n 个扇区组成，扇区编号从 1 到 n 。现将在这条赛道上举办一场马拉松比赛，该马拉松全
//程由 m 个阶段组成。其中，第 i 个阶段将会从扇区 rounds[i - 1] 开始，到扇区 rounds[i] 结束。举例来说，第 1 阶段从 rounds
//[0] 开始，到 rounds[1] 结束。 
//
// 请你以数组形式返回经过次数最多的那几个扇区，按扇区编号 升序 排列。 
//
// 注意，赛道按扇区编号升序逆时针形成一个圆（请参见第一个示例）。 
//
// 
//
// 示例 1： 
//
// 
//
// 输入：n = 4, rounds = [1,3,1,2]
//输出：[1,2]
//解释：本场马拉松比赛从扇区 1 开始。经过各个扇区的次序如下所示：
//1 --> 2 --> 3（阶段 1 结束）--> 4 --> 1（阶段 2 结束）--> 2（阶段 3 结束，即本场马拉松结束）
//其中，扇区 1 和 2 都经过了两次，它们是经过次数最多的两个扇区。扇区 3 和 4 都只经过了一次。 
//
// 示例 2： 
//
// 输入：n = 2, rounds = [2,1,2,1,2,1,2,1,2]
//输出：[2]
// 
//
// 示例 3： 
//
// 输入：n = 7, rounds = [1,3,5,7]
//输出：[1,2,3,4,5,6,7]
// 
//
// 
//
// 提示： 
//
// 
// 2 <= n <= 100 
// 1 <= m <= 100 
// rounds.length == m + 1 
// 1 <= rounds[i] <= n 
// rounds[i] != rounds[i + 1] ，其中 0 <= i < m 
// 
// Related Topics 数组

只与起点和终点对结果有影响，因为在赛道上只能朝着一个方向跑。 

public List<Integer> mostVisited(int n, int[] rounds) {
        ArrayList<Integer> list = new ArrayList<>();
        int length = rounds.length;
        int start = rounds[0];
        int end = rounds[length-1];
        if(start <= end){
            for (int i = start; i <= end; i++) {
                list.add(i);
            }
        }else{
            for (int i = 1; i <= end; i++) {
                list.add(i);
            }
            for (int i = start; i <= n; i++) {
                list.add(i);
            }
        }
        return list;
    }