Leetcode之重构字符串

题目：

给定一个字符串S，检查是否能重新排布其中的字母，使得两相邻的字符不同。

若可行，输出任意可行的结果。若不可行，返回空字符串。

示例 1:

输入: S = "aab"
输出: "aba"
示例 2:

输入: S = "aaab"
输出: ""
注意:

S 只包含小写字母并且长度在[1, 500]区间内。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reorganize-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码：

方法一——自己的方法：

class Solution {
public:

void Adjustdown(vector<int>&v,vector<int>&c, int index){
    if(index*2+1>v.size()-1)return;
    int value=c[v[index]];
    int l=2*index+1,r=2*index+2,m=0;

    if(r>v.size()-1||c[v[l]]>c[v[r]])m=l;
    else m=r;
    if(value<c[v[m]]){
    int temp=v[index];
    v[index]=v[m];
    v[m]=temp;}
    Adjustdown(v,c,m);
}
void buildheap(vector<int>&c, vector<int>& v){
    int len=c.size()-1;
    for(int i=len/2;i>=0;i--){
        Adjustdown(v,c,i);
    }

}
string reorganizeString(string S) {
    int len=S.length();
    if(len<=1)return S;
    vector<int> c(26,0);
    for(int i=0;i<len;i++){
        c[S[i]-'a']+=1;
    }
    vector<int> v;
    for(int i=0;i<26;i++){
        v.push_back(i);
    }
    buildheap(c,v);
    string res="";
    for(int i=0;i<len;i++){
        if(res.back()!='a'+v[0]){
            char ch='a'+v[0];
            c[v[0]]--;
            if(c[v[0]]<0)return "";
            res.push_back(ch);
            Adjustdown(v,c,0);
        }else{
            int k=c[v[1]]>=c[v[2]]?1:2;
            char ch='a'+v[k];
            c[v[k]]--;
            if(c[v[k]]<0)return "";
            res.push_back(ch);
            Adjustdown(v,c,k);
        }
    }
    return res;
}
};

方法二——最大优先权队列：

class Solution {
public:
string reorganizeString(string S) {
    string res = "";
        unordered_map<char, int> m;
        priority_queue<pair<int, char>> q;
        for (char c : S) ++m[c];
        for (auto a : m) {
            if (a.second > (S.size() + 1) / 2) return "";
            q.push({a.second, a.first});
        }
        while (q.size() >= 2) {
            auto t1 = q.top(); q.pop();
            auto t2 = q.top(); q.pop();
            res.push_back(t1.second);
            res.push_back(t2.second);
            if (--t1.first > 0) q.push(t1);
            if (--t2.first > 0) q.push(t2);
        }
        if (q.size() > 0) res.push_back(q.top().second);
        return res;
}
};

方法三——编码，错位填充方法：

class Solution {
public:
    string reorganizeString(string S) {
        int n = S.size(), idx = 1;
        vector<int> cnt(26, 0);
        for (char c : S) cnt[c - 'a'] += 100;
        for (int i = 0; i < 26; ++i) cnt[i] += i;
        sort(cnt.begin(), cnt.end());
        for (int num : cnt) {
            int t = num / 100;
            char ch = 'a' + (num % 100);
            if (t > (n + 1) / 2) return "";
            for (int i = 0; i < t; ++i) {
                if (idx >= n) idx = 0;
                S[idx] = ch;
                idx += 2;
            }
        }
        return S;
    }
};

   思路：

   上面面这种解法的原理和上面的很类似，就是写法上很秀，堪比陈独秀。这里使用了一个长度为 26 的一位数组 cnt 来代替上面的 HashMap 进行统计字母的出现次数，然后比较秀的一点是，把上面的映射对儿压缩成了一个整数，做法是将次数乘以了 100，再加上当前字母在一位数字中的位置坐标i，这样一个整数就同时 encode 了次数和对应字母的信息了，而且之后 decode 也很方便。数组 cnt 更新好了后，需要排个序，这一步就是模拟上面解法中最大堆的自动排序功能。不过这里是数字小的在前面，即先处理出现次数少的字母。这里除了和上面一样检测次数不能大于总长度的一半的操作外，还有一个小 trick，就是构建字符串的时候，是从第二个位置开始的。这里构建的字符串是直接对原字符串S进行修改的，因为 cnt 数组建立了之后，字符串S就没啥用了。用一个变量 idx 来表示当前更新字母的位置，初始化为1，表示要从第二个位置开始更新。因为出现次数最多的字母一定要占据第一个位置才行，这就是留出第一个位置的原因。这里很叼的一点，就是隔位更新，这样能保证相同的字母不相邻，而且当 idx 越界后，拉回到起始位置0，这就有点遍历循环数组的感觉。举个栗子来说吧，比如 "aaabbc"，更新顺序为：

    _ c _ _ _ _

    _ c _ b _ _

    _ c _ b _ b

    a c _ b _ b

    a c a b _ b

    a c a b a b

想法：建堆，搜堆