【LeetCode】Sama的个人记录_66

先明确两点：
1) 如果不按"之"字排列，那么就父子结点的关系就是father=son/2
2) "之"字排列的本质是，隔行进行对称变换

我们的思路就是，"先不按之字排列得到序列，然后隔行对其进行修正"
另外需要注意一个细节，修正时还要考虑序列长度的奇偶，关于这点可以找几个例子写写看

举个例子，对于label=27：
先不按之字排列得到序列：[1, 3, 6, 13, 27]
然后隔行对其进行修正：[1, 2, 6, 10, 27]

class Solution {
    public List<Integer> pathInZigZagTree(int label) {
    	// 先不按之字排列得到序列
        List<Integer> list = new ArrayList<>();
        while (label > 0) {
            list.add(label);
            label /= 2;
        }
        Collections.reverse(list);
        // 然后隔行对其进行修正
        for (int i = list.size() % 2; i < list.size(); i += 2) {
            list.set(i, (int) (Math.pow(2, i) * 3 - 1 - list.get(i)));
        }
        return list;
    }
}

 
 

1) 根据某一个规则进行排序，然后找出最大/最小的K个元素，立即想到使用"优先队列"，即"堆"
2）题目中的另一个条件，每一行的1总是出现在0之前，立即想到使用"二分"进行优化

class Solution {
    public int[] kWeakestRows(int[][] mat, int k) {
        PriorityQueue<int[]> heap = new PriorityQueue<>((o1, o2) -> o1[0] != o2[0] ? o1[0] - o2[0] : o1[1] - o2[1]);
        int m = mat.length;
        int n = mat[0].length;
        for (int i = 0; i < m; i++) {
            heap.offer(new int[] {binarySearch(mat[i]), i});
        }
        int[] res = new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = heap.poll()[1];
        }
        return res;
    }

    private int binarySearch(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        int mid;
        while (left < right) {
            mid = left + (right - left) / 2;
            if (arr[mid] == 1) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return arr[left] == 0 ? left : arr.length;
    }
}

 
 

原地双指针("读写指针")，达到空间O(1)

class Solution_443 {
    public int compress(char[] chars) {
        int len = chars.length;
        // 读/写指针
        int read = 0, write = 0;
        while (read < len) {
            int readStart = read;
            // 如果字符相同，则一直向右读直到最后一个相同字符
            while (read + 1 < len && chars[read + 1] == chars[read]) {
                read++;
            }
            chars[write++] = chars[readStart];
            // 计数1省略即可
            if (readStart != read) {
                int writeStart = write;
                // 统计相同字符个数
                int readCnt = read - readStart + 1;
                // 计数可能是多位的
                while (readCnt > 0) {
                    chars[write++] = (char) (readCnt % 10 + '0');
                    readCnt /= 10;
                }
                // 计数反转回来
                arrayReverse(chars, writeStart, write - 1);
            }
            read++;
        }
        return write;
    }

    private void arrayReverse(char[] chars, int i, int j) {
        while (i < j) {
            char temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
            i++;
            j--;
        }
    }
}

 
 
 
 
 
 
 
 
 
 
 
 
 
 

检索标记：443. 压缩字符串给你一个字符数组 chars ，请使用下述算法压缩：从一个空字符串 s 开始。对于chars 中的每组 连续重复字符 ：如果这一组长度为 1 ，则将字符追加到 s 中。否则，需要向 s 追加字符，后跟这一组的长度。压缩后得到的字符串 s 不应该直接返回 ，需要转储到字符数组 chars 中。需要注意的是，如果组长度为 10 或 10 以上，则在 chars 数组中会被拆分为多个字符。请在 修改完输入数组后 ，返回该数组的新长度。你必须设计并实现一个只使用常量额外空间的算法来解决此问题。1104. 二叉树寻路在一棵无限的二叉树上，每个节点都有两个子节点，树中的节点 逐行 依次按 “之” 字形进行标记。如下图所示，在奇数行（即，第一行、第三行、第五行……）中，按从左到右的顺序进行标记；而偶数行（即，第二行、第四行、第六行……）中，按从右到左的顺序进行标记。给你树上某一个节点的标号 label，请你返回从根节点到该标号为 label 节点的路径，该路径是由途经的节点标号所组成的。1337. 矩阵中战斗力最弱的 K 行给你一个大小为 m * n 的矩阵 mat，矩阵由若干军人和平民组成，分别用 1 和 0 表示。请你返回矩阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。军人 总是 排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。