【力扣周赛】第 108 场双周赛

https://leetcode.cn/contest/biweekly-contest-108/

Q1：6913. 最长交替子序列

https://leetcode.cn/problems/longest-alternating-subarray/

思路——分组循环

分组循环：

外层循环，枚举子数组的起点
每层循环，扩展子数组的右端点。

数据范围很小，只有 100。
可以枚举每个子数组。

实际操作时，可以枚举左边界，判断条件扩展右边界。

竞赛时代码

class Solution {
    public int alternatingSubarray(int[] nums) {
        int n = nums.length, ans = -1;
        // 枚举左端点，尝试扩展右端点
        for (int l = 0; l < n; ++l) {
            int r = l, t = 1;
            while (r + 1 < n && nums[r + 1] - nums[r] == t) {
                t *= -1;
                r++;
            }
            // 答案要求长度 > 1
            if (r - l + 1 >= 2) ans = Math.max(ans, r - l + 1);
        } 
        return ans;
    }
}

代码优化

class Solution {
    public int alternatingSubarray(int[] nums) {
        int n = nums.length, ans = -1;
        // 枚举左端点，尝试扩展右端点
        for (int l = 0; l < n; ++l) {
            int r = l, t = 1;
            while (r + 1 < n && nums[r + 1] - nums[r] == t) {
                t *= -1;
                r++;
            }
            // 答案要求长度 > 1
            if (r - l + 1 >= 2) ans = Math.max(ans, r - l + 1);
            l = Math.max(l, r - 1);     // 小优化
        } 
        return ans;
    }
}

每次更新 l 不一定需要 l = l + 1，而是根据 r 扩展到的位置来更新 l。
即 $l=Math.max(l,r-1);$

Q2：6469. 重新放置石块

https://leetcode.cn/problems/relocate-marbles/

思路——模拟

每个位置的石头每次移动会被全部移走，因此每个位置石头的数量无所谓。

使用哈希集合存储石头位置即可。

竞赛时代码

class Solution {
    public List<Integer> relocateMarbles(int[] nums, int[] moveFrom, int[] moveTo) {
        Set<Integer> s = Arrays.stream(nums).boxed().collect(Collectors.toSet());
        for (int i = 0; i < moveFrom.length; ++i) { // 移动石头
            s.remove(moveFrom[i]);
            s.add(moveTo[i]);
        }
        return s.stream().sorted().toList();        // 返回答案
    }
}

Q3：6923. 将字符串分割为最少的美丽子字符串

https://leetcode.cn/problems/partition-string-into-minimum-beautiful-substrings/

解法1—— dfs回溯 + 剪枝 + 判断

爆搜出每一种分割方式（中间加了剪枝）
检查是否合理并更新答案。

class Solution {
    static int ans = 20;
    static Set<Long> set = new HashSet();   // 处理出所有5的幂
    static {
        long v = 1;
        while (v < Long.MAX_VALUE / 5) {
            set.add(v);
            v *= 5;
        }
    }
    
    
    public int minimumBeautifulSubstrings(String s) {
        ans = 20;
        dfs(0, s, 0, 0);
        return ans == 20? -1: ans;
    }
    
    public static void dfs(int i, String s, int last, int cnt) {
        if (last == s.length()) {
            ans = Math.min(ans, cnt);
            return;
        }
        if (i >= s.length()) return;
        if (s.charAt(last) == '0') return;
        // 不选i
        dfs(i + 1, s, last, cnt);
        
        String ss = s.substring(last, i + 1);
        long v = Long.parseLong(ss, 2);
        // 检查能不能选
        if (!set.contains(v)) return;
        // 选i
        dfs(i + 1, s, i + 1, cnt + 1);
    }
}

解法2——记忆化搜索&动态规划

https://leetcode.cn/problems/partition-string-into-minimum-beautiful-substrings/solution/on2-ji-yi-hua-sou-suo-dao-di-tui-by-endl-99lb/

代码1——记忆化搜索⭐⭐⭐⭐⭐

定义 dfs(i) 表示划分从 s[i] 开始的后缀，最少要划分成多少段。

class Solution {
    static List<String> pow5 = new ArrayList();
    static int inf = 0x3f3f3f3f, n;
    static int[] memo;
    static String s;
    // 处理出所有二进制长度<=15的 5的幂
    static {
        for (int v = 1; v < (1 << 15); v *= 5) {
            pow5.add(Integer.toBinaryString(v));
        }
    }

    public int minimumBeautifulSubstrings(String s) {
        this.s = s;
        n = s.length();
        memo = new int[n];
        Arrays.fill(memo, -1);
        int ans = dfs(0);
        return ans != inf? ans: -1;
    }

    public static int dfs(int i) {
        if (i == n) return 0;
        if (s.charAt(i) == '0') return inf;
        if (memo[i] != -1) return memo[i];
        int res = inf;
        // 枚举每个5的幂
        for (String v: pow5) {
            if (i + v.length() > n) break;  // 不够长
            if (v.equals(s.substring(i, i + v.length()))) {
                res = Math.min(res, dfs(i + v.length()) + 1);
            }
        }
        return memo[i] = res;
    }
}

学习到的技巧

提前处理所有二进制长度<=15的 5的幂

处理方式如下

for (int v = 1; v < (1 << 15); v *= 5) {
    pow5.add(Integer.toBinaryString(v));
}

因为 15 < 32，所以 v 一定不会超过 int 范围。

要想找到所有二进制长度 <= 15 的，只需要保证 v < (1 << 15)。

---

Integer.toBinaryString(v) 可以返回 v 的二进制字符串。

枚举每个5的幂而不是枚举当前位置切割不切割

// 枚举每个5的幂
for (String v: pow5) {
    if (i + v.length() > n) break;  // 不够长
    if (v.equals(s.substring(i, i + v.length()))) {
        res = Math.min(res, dfs(i + v.length()) + 1);
    }
}

代码2——动态规划

将上面的记忆化搜索代码可以翻译成递推dp的形式。

class Solution {
    static List<String> pow5 = new ArrayList();
    // 处理出所有二进制长度<=15的 5的幂
    static {
        for (int v = 1; v < (1 << 15); v *= 5) {
            pow5.add(Integer.toBinaryString(v));
        }
    }

    public int minimumBeautifulSubstrings(String s) {
        int n = s.length();
        int[] dp = new int[n + 1];
        Arrays.fill(dp, n + 1);
        dp[n] = 0;
        for (int i = n - 1; i >= 0; --i) {
            if (s.charAt(i) == '0') continue;   // 不能带有前导零
            for (String v: pow5) {
                if (i + v.length() > n) break;
                if (v.equals(s.substring(i, i + v.length()))) dp[i] = Math.min(dp[i], dp[i + v.length()] + 1);
            }
        }
        return dp[0] != n + 1? dp[0]: -1;
    }
}

动态规划的时间复杂度 = 状态个数 × 单个状态的计算时间。

Q4：6928. 黑格子的数目

https://leetcode.cn/problems/number-of-black-blocks/

由于数据范围的原因
枚举coordinates，每次会影响周围最多4个2*2区域的内容
因此时间复杂度可以控制在 $O(n)$

用哈希表存储已有黑点的情况防止空间不够。

class Solution {
    int[] dx = {1, 1, -1, -1}, dy = {1, -1, 1, -1};
    
    public long[] countBlackBlocks(int m, int n, int[][] coordinates) {
        long[] ans = new long[5];
        ans[0] = (long)(m - 1) * (n - 1);   // 初始值，默认没有黑点
        Set<String> s = new HashSet();
        for (int[] c: coordinates) {
            int x = c[0], y = c[1];
            for (int k = 0; k < 4; ++k) {   // 枚举被影响的四个2*2区域
                int cnt = 1;
                int nx = x + dx[k], ny = y + dy[k];
                if (nx < 0 || ny < 0 || nx >= m || ny >= n) continue;
                if (s.contains(nx + " " + y)) cnt++;
                if (s.contains(nx + " " + ny)) cnt++;
                if (s.contains(x + " " + ny)) cnt++;
                ans[cnt]++;
                ans[cnt - 1]--;
            }
            s.add(x + " " + y);
        }

        return ans;
    }
}

代码优化

https://leetcode.cn/problems/number-of-black-blocks/solution/mei-ju-by-endlesscheng-0mnx/

优化不了一点！ 就按上面的写法写就行。

在这里插入代码片

成绩记录

AK 了就是胜利！（只可惜写错了3次！）

https://lccn.lbao.site/