LeetCode第358题_K距离间隔重排字符串

最新推荐文章于 2025-08-14 23:25:10 发布

@蓝莓果粒茶

最新推荐文章于 2025-08-14 23:25:10 发布

阅读量1k

点赞数 23

CC 4.0 BY-SA版权

分类专栏：算法文章标签： leetcode 算法职场和发展 c# 学习 python c++

本文链接：https://blog.csdn.net/qq_40263592/article/details/149696925

算法专栏收录该内容

354 篇文章

订阅专栏

LeetCode 第358题：K距离间隔重排字符串

📖 文章摘要

本文详细解析LeetCode第358题"K距离间隔重排字符串"，这是一道贪心算法问题。文章提供了基于优先队列的解法，包含C#、Python、C++三种语言实现，配有详细的算法分析和性能对比。适合想要提升贪心算法和字符串处理能力的读者。

核心知识点： 贪心算法、优先队列、字符串处理、哈希表
难度等级： 困难
推荐人群： 具有一定算法基础，想要提升贪心算法应用能力的程序员

题目描述

给定一个字符串 s 和一个整数 k，你需要重新排列字符串，使得相同的字符之间至少间隔 k 个字符。如果无法重新排列，则返回空字符串。

示例

示例 1：

输入：s = "aabbcc", k = 3
输出："abcabc"
解释：相同的字符之间至少间隔3个字符

示例 2：

输入：s = "aaabc", k = 3
输出：""
解释：无法重新排列使得相同的字符之间间隔3个字符

提示

1 <= s.length <= 3 * 10^4
s 只包含小写英文字母
0 <= k <= s.length

解题思路

本题可以使用贪心算法和优先队列解决：

统计每个字符的出现次数
使用优先队列按照出现次数排序
每次取出k个不同的字符
如果无法取出k个不同字符，则返回空字符串

时间复杂度： O(n log n)，其中n是字符串长度
空间复杂度： O(n)

图解思路

算法步骤分析表

步骤	操作	说明
1	统计字符频率	使用哈希表记录每个字符出现次数
2	构建优先队列	按频率降序排列字符
3	取出字符	每次取出k个不同字符
4	更新频率	将取出的字符频率减1后重新入队

示例分析表

输入	步骤	结果
“aabbcc”, k=3	1. 统计频率 2. 构建队列 3. 取出字符	“abcabc”
“aaabc”, k=3	1. 统计频率 2. 构建队列 3. 无法取出k个字符	“”

代码实现

C# 实现

public class Solution {
    public string RearrangeString(string s, int k) {
        if (k == 0) return s;
        
        // 统计字符频率
        Dictionary<char, int> freq = new Dictionary<char, int>();
        foreach (char c in s) {
            if (!freq.ContainsKey(c)) freq[c] = 0;
            freq[c]++;
        }
        
        // 构建优先队列
        var pq = new PriorityQueue<char, int>();
        foreach (var pair in freq) {
            pq.Enqueue(pair.Key, -pair.Value);
        }
        
        StringBuilder result = new StringBuilder();
        while (pq.Count > 0) {
            List<char> temp = new List<char>();
            int count = Math.Min(k, pq.Count);
            
            // 取出k个不同字符
            for (int i = 0; i < count; i++) {
                char c = pq.Dequeue();
                result.Append(c);
                freq[c]--;
                if (freq[c] > 0) {
                    temp.Add(c);
                }
            }
            
            // 如果无法取出k个字符且还有剩余字符，则无法重排
            if (count < k && temp.Count > 0) {
                return "";
            }
            
            // 将取出的字符重新入队
            foreach (char c in temp) {
                pq.Enqueue(c, -freq[c]);
            }
        }
        
        return result.ToString();
    }
}

Python 实现

import heapq
from collections import Counter

class Solution:
    def rearrangeString(self, s: str, k: int) -> str:
        if k == 0:
            return s
            
        # 统计字符频率
        counter = Counter(s)
        
        # 构建优先队列
        heap = [(-count, char) for char, count in counter.items()]
        heapq.heapify(heap)
        
        result = []
        while heap:
            temp = []
            count = min(k, len(heap))
            
            # 取出k个不同字符
            for _ in range(count):
                if not heap:
                    return ""
                neg_count, char = heapq.heappop(heap)
                result.append(char)
                if neg_count + 1 < 0:
                    temp.append((neg_count + 1, char))
            
            # 如果无法取出k个字符且还有剩余字符，则无法重排
            if count < k and temp:
                return ""
            
            # 将取出的字符重新入队
            for item in temp:
                heapq.heappush(heap, item)
                
        return ''.join(result)

C++ 实现

class Solution {
public:
    string rearrangeString(string s, int k) {
        if (k == 0) return s;
        
        // 统计字符频率
        unordered_map<char, int> freq;
        for (char c : s) {
            freq[c]++;
        }
        
        // 构建优先队列
        priority_queue<pair<int, char>> pq;
        for (const auto& pair : freq) {
            pq.push({pair.second, pair.first});
        }
        
        string result;
        while (!pq.empty()) {
            vector<pair<int, char>> temp;
            int count = min(k, (int)pq.size());
            
            // 取出k个不同字符
            for (int i = 0; i < count; i++) {
                auto [f, c] = pq.top();
                pq.pop();
                result += c;
                if (--f > 0) {
                    temp.push_back({f, c});
                }
            }
            
            // 如果无法取出k个字符且还有剩余字符，则无法重排
            if (count < k && !temp.empty()) {
                return "";
            }
            
            // 将取出的字符重新入队
            for (const auto& pair : temp) {
                pq.push(pair);
            }
        }
        
        return result;
    }
};