[LeetCode] 358. Rearrange String k Distance Apart 按距离k间隔重排字符串

Given a non-empty string str and an integer k, rearrange the string such that the same characters are at least distance k from each other.

All input strings are given in lowercase letters. If it is not possible to rearrange the string, return an empty string "".

Example 1:

str = "aabbcc", k = 3

Result: "abcabc"

The same letters are at least distance 3 from each other.

Example 2:

str = "aaabc", k = 3 

Answer: ""

It is not possible to rearrange the string.

Example 3:

str = "aaadbbcc", k = 2

Answer: "abacabcd"

Another possible answer is: "abcabcda"

The same letters are at least distance 2 from each other.

Credits:
Special thanks to @elmirap for adding this problem and creating all test cases.

给一个非空字符串和一个距离k，按k的距离间隔从新排列字符串，使得相同的字符之间间隔最少是k。

解法1：先用 HashMap 或者Array 对字符串里的字符按出现次数进行统计，按次数由高到低进行排序。出现次数最多的字符个数记为max_cnt，max_cnt - 1 是所需要的间隔数。把剩下字符按出现次数多的字符开始，把每一个字符插入到间隔中，以此类推，直到所有字符插完。然后判断每一个间隔内的字符长度，如果任何一个间隔<k，则不满足，返回""，如果都满足则返回这个新的字符串。

解法2：还是先统计字符出现的次数，按出现次数排列组成最大堆。然后每次从堆中去取topk 的字符排入结果，相应的字符数减1，如此循环，直到所有字符排完。

public class Solution {  
    public String rearrangeString(String str, int k) {  
        if (k <= 0) return str;  
        int[] f = new int[26];  
        char[] sa = str.toCharArray();  
        for(char c: sa) f[c-'a'] ++;  
        int r = sa.length / k;  
        int m = sa.length % k;  
        int c = 0;  
        for(int g: f) {  
            if (g-r>1) return "";  
            if (g-r==1) c ++;  
        }  
        if (c>m) return "";  
        Integer[] pos = new Integer[26];  
        for(int i=0; i<pos.length; i++) pos[i] = i;  
        Arrays.sort(pos, new Comparator<Integer>() {  
           @Override 
           public int compare(Integer i1, Integer i2) {  
               return f[pos[i2]] - f[pos[i1]];  
           }  
        });  
        char[] result = new char[sa.length];  
        for(int i=0, j=0, p=0; i<sa.length; i++) {  
            result[j] = (char)(pos[p]+'a');  
            if (-- f[pos[p]] == 0) p ++;  
            j += k;  
            if (j >= sa.length) {  
                j %= k;  
                j ++;  
            }  
        }  
        return new String(result);  
    }  
}　　

Python: T: O(n) S: O(n)

class Solution(object):
    def rearrangeString(self, str, k):
        cnts = [0] * 26;
        for c in str:
            cnts[ord(c) - ord('a')] += 1
 
        sorted_cnts = []
        for i in xrange(26):
            sorted_cnts.append((cnts[i], chr(i + ord('a'))))
        sorted_cnts.sort(reverse=True)
 
        max_cnt = sorted_cnts[0][0]
        blocks = [[] for _ in xrange(max_cnt)]
        i = 0
        for cnt in sorted_cnts:
            for _ in xrange(cnt[0]):
                blocks[i].append(cnt[1])
                i = (i + 1) % max(cnt[0], max_cnt - 1)
 
        for i in xrange(max_cnt-1):
            if len(blocks[i]) < k:
                return ""
 
        return "".join(map(lambda x : "".join(x), blocks))

Python: T: O(nlogc), c is the count of unique characters. S: O(c)

from collections import defaultdict
from heapq import heappush, heappop<br>
class Solution(object):
    def rearrangeString(self, str, k):
        if k == 0:
            return str
 
        cnts = defaultdict(int)
        for c in str:
            cnts[c] += 1
 
        heap = []
        for c, cnt in cnts.iteritems():
            heappush(heap, [-cnt, c])
 
        result = []
        while heap:
            used_cnt_chars = []
            for _ in xrange(min(k, len(str) - len(result))):
                if not heap:
                    return ""
                cnt_char = heappop(heap)
                result.append(cnt_char[1])
                cnt_char[0] += 1
                if cnt_char[0] < 0:
                    used_cnt_chars.append(cnt_char)
            for cnt_char in used_cnt_chars:
                heappush(heap, cnt_char)
 
        return "".join(result)　　

C++：

class Solution {  
public:  
    string rearrangeString(string s, int k) {  
        if (k == 0) {  
            return s;  
        }  
        int len = s.size();    
        string result;  
        map<char, int> hash;                                // map from char to its appearance time  
        for(auto ch: s) {  
            ++hash[ch];  
        }  
        priority_queue<pair<int, char>> que;                // using priority queue to pack the most char first  
        for(auto val: hash) {  
            que.push(make_pair(val.second, val.first));  
        }  
        while(!que.empty()) {    
            vector<pair<int, int>> vec;   
            int cnt = min(k, len);   
            for(int i = 0; i < cnt; ++i, --len) {           // try to pack the min(k, len) characters sequentially   
                if(que.empty()) {                           // not enough distinct charachters, so return false  
                    return "";    
                }  
                auto val = que.top();    
                que.pop();    
                result += val.second;    
                if(--val.first > 0) {                       // collect the remaining characters  
                    vec.push_back(val);  
                }  
            }    
            for(auto val: vec) {  
                que.push(val);  
            }  
        }    
        return result;    
    }  
};  