【Lintcode】1041. Reorganize String

题目地址：

https://www.lintcode.com/problem/reorganize-string/description

给定一个字符串$s$，问是否能重排其字母使得相邻字母不同。题目保证只含小写字母。如果存在，则返回任一解，不存在合法解则返回空串。

思路和证明参考https://blog.csdn.net/qq_46105170/article/details/109377535。那道题是距离$k$范围内不能有相同字母，这道题其实就是令$k=2$。算法如下：
1、先统计一下$s$各个字母出现次数，以数组$c$存，接着开一个最大堆，将$s$中出现的字母全入堆，出现次数多的优先，次数一样则字典序小的优先；
2、只要堆不空，就进行两个两个append字母的操作。从堆中poll出两个字母，append到一个StringBuilder后面。每次append的时候，更新$c$（即计数减去$1$），并且如果该字母计数还剩，则存入一个list。同时，每次append的时候检查一下是否有相邻字母相同了，如果发现了，直接返回空串，不存在解。append了两个之后，将list里的字母加回堆中，接着进行下一轮的两个两个append的操作。
3、堆空了则退出循环，返回得到的StringBuilder。

代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;

public class Solution {
    /**
     * @param s: a string
     * @return: return a string
     */
    public String reorganizeString(String s) {
        // write your code here
        StringBuilder sb = new StringBuilder();
        
        int[] count = new int[26];
        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i) - 'a']++;
        }
        
        PriorityQueue<Character> maxHeap = new PriorityQueue<>((c1, c2) -> {
            if (count[c1 - 'a'] != count[c2 - 'a']) {
                return -Integer.compare(count[c1 - 'a'], count[c2 - 'a']);
            } else {
                return Character.compare(c1, c2);
            }
        });
        
        // 将s中出现的字母入堆
        for (int i = 0; i < count.length; i++) {
            if (count[i] > 0) {
                maxHeap.offer((char) ('a' + i));
            }
        }
        
        List<Character> list = new ArrayList<>();
        
        while (!maxHeap.isEmpty()) {
            for (int i = 0; i < 2; i++) {
            	// 堆空了直接退出循环
                if (maxHeap.isEmpty()) {
                    break;
                }
                
                char ch = maxHeap.poll();
                sb.append(ch);
                // 如果append了ch会使得sb不合法，则说明不存在合法解，返回空串
                if (sb.length() >= 2 && sb.charAt(sb.length() - 1) == sb.charAt(sb.length() - 2)) {
                    return "";
                }
                
                count[ch - 'a']--;
                if (count[ch - 'a'] > 0) {
                    list.add(ch);
                }
            }
            
            maxHeap.addAll(list);
            // 将还有剩余的字母加入堆后要清空list
            list.clear();
        }
        
        return sb.toString();
    }
}

时间复杂度$O(l_s)$，空间$O(1)$。