LeetCode每日一题(2014. Longest Subsequence Repeated k Times)

关注

最新推荐文章于 2026-03-03 17:57:53 发布 · 118 阅读

原创 ·

本内容遵循 CC 4.0 BY-SA 版权协议

YOLOv5 改进点总览：轻量化、高精度的背后有哪些魔改？ YOLOv5是由Ultralytics团队开发的高效目标检测模型，其核心改进包括：主干网络采用CSPDarknet53提升梯度传播效率；特征融合使用PANet增强小目标识别；输出结构采用解耦头设计优化定位和分类任务。此外，YOLOv5通过CIoU损失函数、Mosaic数据增强和SimOTA标签分配机制进一步提升性能。模型支持多种推理格式（ONNX/TensorRT等），并具备自动锚框匹配和多尺度训练功能，使其在轻量化（yolov5s仅7MB）与高性能（最高51.2% mAP）间取得平衡，但缺乏正式论文支撑是阅读详情

You are given a string s of length n, and an integer k. You are tasked to find the longest subsequence repeated k times in string s.

A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.

A subsequence seq is repeated k times in the string s if seq _ k is a subsequence of s, where seq _ k represents a string constructed by concatenating seq k times.

For example, “bba” is repeated 2 times in the string “bababcba”, because the string “bbabba”, constructed by concatenating “bba” 2 times, is a subsequence of the string “bababcba”.
Return the longest subsequence repeated k times in string s. If multiple such subsequences are found, return the lexicographically largest one. If there is no such subsequence, return an empty string.

Example 1:

Input: s = “letsleetcode”, k = 2
Output: “let”

Explanation: There are two longest subsequences repeated 2 times: “let” and “ete”.
“let” is the lexicographically largest one.

Example 2:

Input: s = “bb”, k = 2
Output: “b”

Explanation: The longest subsequence repeated 2 times is “b”.

Example 3:

Input: s = “ab”, k = 2
Output: “”
Explanation: There is no subsequence repeated 2 times. Empty string is returned.

Constraints:

n == s.length
2 <= n, k <= 2000
2 <= n < k * 8
s consists of lowercase English letters.

限制条件中的 2 <= n < k * 8 是这题的关键，两边同时除以 k 得到 n/k < 8, 也就是我们最终答案的长度不会超过 8。我们首先对 s 中的 char 进行 freq 计数，只有 freq/k > 0 的 char 才可能出现在答案中。我们将这些 char 和对应的 freq 收集起来，然后从 length = n / k 开始，以字母顺序倒序排列这些 char，组成长度为 length 的字符串，然后检验这些字符串是不是在 s 中出现 k 次，如果符合直接返回，因为我们的 length 是递减的，并且我们是按字母顺序倒序来组合的。


impl Solution {
    fn is_match(origin: &[char], target: &[char]) -> bool {
        let mut oi = 0;
        let mut ti = 0;
        while oi < origin.len() {
            if origin[oi] != target[ti] {
                oi += 1;
                continue;
            }
            if ti == target.len() - 1 {
                return true;
            }
            ti += 1;
            oi += 1;
        }
        false
    }

    fn match_permutation(counts: &mut Vec<(char, i32)>, target: &mut Vec<char>, indices: &mut Vec<usize>, k: usize, i: usize, origin: &[char]) -> Option<String> {
        if i == target.len() {
            if Solution::is_match(origin, &target.repeat(k)) {
                return Some(target.into_iter().map(|c| *c).collect());
            }
            return None;
        }
        let counts_length = counts.len();
        for _ in 0..counts_length {
            if counts[indices[i]].1 == 0 {
                indices[i] += 1;
                indices[i] %= counts_length;
                continue;
            }
            counts[indices[i]].1 -= 1;
            target[i] = counts[indices[i]].0;
            if let Some(ans) = Solution::match_permutation(counts, target, indices, k, i + 1, origin) {
                return Some(ans);
            }
            counts[indices[i]].1 += 1;
            indices[i] += 1;
            indices[i] %= counts_length;
        }
        None
    }

    pub fn longest_subsequence_repeated_k(s: String, k: i32) -> String {
        let counts = s.chars().fold(vec![0; 26], |mut l, c| {
            l[c as usize - 97] += 1;
            l
        });
        let mut max_length = 0;
        let mut counts: Vec<(char, i32)> = counts
            .into_iter()
            .enumerate()
            .filter(|&(_, n)| n / k > 0)
            .map(|(i, n)| {
                max_length += n / k;
                ((i + 97) as u8 as char, n / k)
            })
            .collect();
        counts.reverse();
        let origin: Vec<char> = s.chars().collect();
        for l in (1..=max_length).rev() {
            if let Some(ans) = Solution::match_permutation(&mut counts, &mut vec!['-'; l as usize], &mut vec![0; l as usize], k as usize, 0, &origin) {
                return ans;
            }
        }
        "".into()
    }
}