五月训练 Day15

最新推荐文章于 2026-01-05 22:36:07 发布

原创最新推荐文章于 2026-01-05 22:36:07 发布 · 267 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #c++

Leetcode 训练专栏收录该内容

22 篇文章

订阅专栏

文章目录

0. Leetcode 565. 数组嵌套

索引从0开始长度为N的数组A，包含0到N - 1的所有整数。找到最大的集合S并返回其大小，其中 S[i] = {A[i], A[A[i]], A[A[A[i]]], … }且遵守以下的规则。
假设选择索引为i的元素A[i]为S的第一个元素，S的下一个元素应该是A[A[i]]，之后是A[A[A[i]]]… 以此类推，不断添加直到S出现重复的元素。

分析与解答

本题可以直接按题意搜索每个下标作为起始下标时的最大长度，但此时会超时。容易发现直接搜索过程中重复搜索了子下标的最大长度信息，因此可以使用递归记录该信息：

class Solution {
public:
    int searchLen(vector<bool>& visited, vector<int>& idxLen, vector<int>& nums, int idx) {
        if (idxLen[idx] > 0) {
            return idxLen[idx];
        }

        if (visited[nums[idx]]) {
            // 出现路径中的重复元素，当前长度为 0，且重置 map
            if (nums[idx] == idx) {
                idxLen[idx] = 0;
            } else {
                idxLen[idx] = 1;
            }
        } else {
            visited[idx] = true;
            // 与路径未重复，则为 nums[idx] 对应最大长度 + 1
            idxLen[idx] = searchLen(visited, idxLen, nums, nums[idx]) + 1;
        }

        return idxLen[idx];
    }

    int arrayNesting(vector<int>& nums) {
        int result(0);
        // 记录从每个数字出发的最大长度（搜索时填上路径上所有数字的最大长度）
        vector<int> idxLen;
        vector<bool> visited;
        idxLen.resize(nums.size(), -1);
        visited.resize(nums.size(), false);
        for (int i = 0; i < nums.size(); ++i) {
            int curIdx = searchLen(visited, idxLen, nums, i);
            if (curIdx > result) {
                result = curIdx;
            }
        }

        return result;
    }
};

当然，上述方法中使用了递归与额外的空间 idxLen 记录子下标长度。进一步分析可以发现，出现在任何一个最大长度循环中的数，都不会出现在另一个最大长度循环中。因此可以将直接记录每个数是否搜索：

class Solution {
public:
    int arrayNesting(vector<int>& nums) {
        int result(0);
        // 记录从每个数字出发的最大长度（搜索时填上路径上所有数字的最大长度）
        vector<bool> visited;
        visited.resize(nums.size(), false);
        for (int i = 0; i < nums.size(); ++i) {
            if (!visited[i]) { // 当前数字未被搜索过
                int curIdx = i;
                int len(0);
                do {
                    visited[curIdx] = true;
                    curIdx = nums[curIdx];
                    len++;
                } while (nums[curIdx] != nums[i]);
                result = result > len? result: len;
            }
        }

        return result;
    }
};

该方法时间复杂度为 $O (N)$

1. Leetcode 401. 二进制手表

二进制手表顶部有 4 个 LED 代表小时（0-11），底部的 6 个 LED 代表分钟（0-59）。每个 LED 代表一个 0 或 1，最低位在右侧。
给你一个整数 turnedOn ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以按任意顺序返回答案。
小时不会以零开头：
例如，“01:00” 是无效的时间，正确的写法应该是 “1:00” 。
分钟必须由两位数组成，可能会以零开头：
例如，“10:2” 是无效的时间，正确的写法应该是 “10:02” 。

分析与解答

暴力搜索，直接搜索所有的时与分，若对应位数满足要求则记入结果中：

class Solution {
public:
    int bitNum(int num) {
        int oneNums(0);
        while (num != 0) {
            num = num & num - 1;
            oneNums++;
        }

        return oneNums;
    }

    vector<string> readBinaryWatch(int turnedOn) {
        vector<string> result;

        for (int h = 0; h < 12; ++h) {
            for (int min = 0; min < 60; ++min) {
                if (bitNum(h) + bitNum(min) == turnedOn) {
                    string res;
                    if (min >= 10) {
                        res = to_string(h) + ":" + to_string(min);
                    } else {
                        res = to_string(h) + ":" + to_string(0) + to_string(min);
                    }
                    result.push_back(res);
                }
            }
        }

        return result;
    }
};

算法时间复杂度为 $O (C)$
dfs 方法没有捋顺，下月再战

2. Leetcode 1079. 活字印刷

你有一套活字字模 tiles，其中每个字模上都刻有一个字母 tiles[i]。返回你可以印出的非空字母序列的数目。
注意：本题中，每个活字字模只能使用一次。

分析与解答

通过深度有限搜索模拟取字符的操作即可。这里加深了对回溯的理解：因为深度有限搜索在向下搜索时，需要改变当前状态（本题中改变了 chMap[k] 的个数），而外层的 for 循环要求在搜索当前层时状态要保持一致，因此才有 dfs 后的 chMap[k]++ 以恢复到当前层的状态。
因此不管深度有限搜索是如何实现的，总会在状态改变后有一个状态回溯操作 😃

class Solution {
    map<string, int> tileMap; // 字符与出现次数的哈希表

public:
    int dfs(map<char, int>& chMap, int depth) {
        if (depth == 1) {
            int result(0);
            // 最后一层中所有不同的字符都可完成一个序列
            for (const auto& [k, v]: chMap) {
                if (v > 0) {
                    result++;
                }
            }
            return result; // 可行的序列个数
        }

        int result(0);
        // 取出一个字符后 dfs 递推取下一个
        for (const auto& [k, v]: chMap) {
            if (chMap[k] > 0) {
                chMap[k]--;
                result += dfs(chMap, depth - 1); // 继续取出
                chMap[k]++; // 回溯到当前状态，继续 for 循环
            }
        }

        return result;
    }

    int numTilePossibilities(string tiles) {
        map<char, int> chMap;
        for (auto ch: tiles) {
            chMap[ch]++;
        }
        int result(0);
        for (int i = 0; i <= tiles.size(); ++i) {
            result += dfs(chMap, i);
        }

        return result;
    }
};

3. Leetcode 1219. 黄金矿工

你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为 m * n 的网格 grid 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量；如果该单元格是空的，那么就是 0。
为了使收益最大化，矿工需要按以下规则来开采黄金：
每当矿工进入一个单元，就会收集该单元格中的所有黄金。
矿工每次可以从当前位置向上下左右四个方向走。
每个单元格只能被开采（进入）一次。
不得开采（进入）黄金数目为 0 的单元格。
矿工可以从网格中任意一个有黄金的单元格出发或者是停止。

分析与解答

使用一个矩阵标记当前格子是否开采，以每个黄金格子为起点进行深度优先搜索，当搜索到边界时返回黄金价值 $0$ ，若不在边界，则将当前格子标记为已搜索，并向该格子四周搜索，取最大值，之后回溯状态，将当前格子标记为未搜索，供上一层搜索使用：

class Solution {
public:
    int dfs(vector<vector<int>>& grid, int i, int maxI, int j, int maxJ, vector<vector<int>>& visited) {
        if (i == maxI || j == maxJ || i < 0 || j < 0 || visited[i][j] || grid[i][j] == 0) {
            return 0; // 到达搜索边界
        }

        int result(0), maxResult(0);
        // 标记当前格子
        visited[i][j] = true;
        // 搜索四个方向并取结果最大的
        result = dfs(grid, i + 1, maxI, j, maxJ, visited);
        maxResult = maxResult > result? maxResult: result;
        result = dfs(grid, i - 1, maxI, j, maxJ, visited);
        maxResult = maxResult > result? maxResult: result;
        result = dfs(grid, i, maxI, j + 1, maxJ, visited);
        maxResult = maxResult > result? maxResult: result;
        result = dfs(grid, i, maxI, j - 1, maxJ, visited);
        maxResult = maxResult > result? maxResult: result;
        // 回溯状态，供上一层使用
        visited[i][j] = false;

        return maxResult + grid[i][j];
    }

    int getMaximumGold(vector<vector<int>>& grid) {
        vector<vector<int>> visited;
        int maxI(grid.size()), maxJ(0);
        visited.resize(grid.size()); // 标记矩阵
        for (int i = 0; i < grid.size(); ++i) {
            maxJ = grid[i].size();
            visited[i].resize(grid[i].size(), false);
        }

        int result(0);
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < maxJ; ++j) {
                if (grid[i][j] != 0) {
                    int curResult = dfs(grid, i, maxI, j, maxJ, visited);
                    result = result > curResult? result: curResult;
                }
            }
        }

        return result;
    }
};