leetcode-day16

621.给你一个用字符数组 tasks 表示的 CPU 需要执行的任务列表。其中每个字母表示一种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。在任何一个单位时间，CPU 可以完成一个任务，或者处于待命状态。
然而，两个 相同种类 的任务之间必须有长度为整数 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。
你需要计算完成所有任务所需要的 最短时间 。

647.给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
回文字符串 是正着读和倒过来读一样的字符串。
子字符串 是字符串中的由连续字符组成的一个序列。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
中心扩展方法（类似于leetcode 5）：

class Solution {
    public int countSubstrings(String s) {
        int n = s.length(), ans = 0;
        for (int i = 0; i < 2 * n - 1; i++) { //字符串长度为n，得到2*n-1组（包括子字符串长度为奇数和偶数）
            int l = i / 2, r = i / 2 + i % 2; //找规律所得
            while (l >= 0 && r < n && s.charAt(l) == s.charAt(r)) {
                //l指针向左移动，r指针向右移动
                --l;
                ++r;
                ++ans;
            }
        }
        return ans;
    }
}

最长回文子串 Manacher 算法的讲解视频@一俩三四五⭐
Manacher 算法：

class Solution {
    public int countSubstrings(String s) {
        // abaa变成"$#a#b#a#a#!"的样子
        // 解决回文串奇数长度和偶数长度的问题，处理方式是在所有的相邻字符中间插入#，这样可以保证所有找到的回文串都是奇数长度的
        int n = s.length();
        StringBuffer t = new StringBuffer("$#");
        for (int i = 0; i < n; i++) {
            t.append(s.charAt(i));
            t.append('#');
        }
        n = t.length();
        t.append('!');// 这样开头和结尾的两个字符一定不相等，循环就可以在这里终止。

        int[] f = new int[n];// 用f(i)来表示以t的第i位为回文中心，可以拓展出的最大回文半径（臂长）
        int iMax = 0, rMax = 0, ans = 0;// 维护「当前最大的回文的右端点 rMax」以及这个回文右端点对应的回文中心iMax
        for (int i = 1; i < n; i++) {
            // 这里将rMax-i+1和f[对称点]取小，是先要保证这个回文串在当前最大回文串内
            // 初始化f[i]
            f[i] = i <= rMax ? Math.min(rMax - i + 1, f[2 * iMax - i]) : 1;
            // 中心拓展
            while (t.charAt(i + f[i]) == t.charAt(i - f[i])) {
                f[i]++;
            }
            // 动态维护iMax和rMax
            if (i + f[i] - 1 > rMax) {
                iMax = i;
                rMax = i + f[i] - 1;
            }
            // 统计答案,当前贡献为(f[i]-1)/2上取整（因为存在#）
            ans += f[i] / 2;
        }
        return ans;
    }
}

739.给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指在第 i 天之后，才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。
单调栈：

class Solution {
    public int[] dailyTemperatures(int[] T) {
        int[] res = new int[T.length];
        LinkedList<Integer> stack = new LinkedList<>();
        for (int i = T.length - 1; i >= 0; i--) {
            while (!stack.isEmpty() && T[stack.getFirst()] <= T[i])   //存储的是index而不是值
            stack.removeFirst();
            res[i] = stack.isEmpty() ? 0 : stack.getFirst() - i;
            stack.addFirst(i);
        }
        return res;
    }
}

从后往前数组遍历优化：

class Solution {
    public int[] dailyTemperatures(int[] T) {
        int length = T.length;
        int[] result = new int[length];

        //从右向左遍历
        for (int i = length - 2; i >= 0; i--) {
            // 亮点：利用j+=result[j]以及result[j]==0筛掉不满足的来减少遍历次数
            // j+=result[j]是利用已经有的结果进行跳跃
            for (int j = i + 1; j < length; j+= result[j]) {
                if (T[j] > T[i]) {
                    result[i] = j - i;
                    break;
                } else if (result[j] == 0) { //遇到0表示后面不会有更大的值，那当然当前值就应该也为0
                    result[i] = 0;
                    break;
                }
            }
        }
        return result;
    }
}