[LeetCode] 767. Reorganize String

Given a string s, rearrange the characters of s so that any two adjacent characters are not the same.

Return any possible rearrangement of s or return "" if not possible.

Example 1:

Input: s = "aab"
Output: "aba"

Example 2:

Input: s = "aaab"
Output: ""

Constraints:

• 1 <= s.length <= 500
• s consists of lowercase English letters.

重构字符串。

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

返回 s 的任意可能的重新排列。若不可行，返回空字符串 "" 。

影子题358。思路是 priority queue + hashmap。hashmap 存的是每个字符和他们出现的次数；priority queue 存的是 hashmap 的 entry，但是是一个按照字符出现次数来排序的一个 maxheap，也就是说出现次数越多的字符会在 heap 顶端。先遍历一遍 input，存入字符和他们各自出现的次数之后，也同时把每个 hashmap entry 存入 pq。有一个 corner cases 是在遍历 input 字符串的时候，如果有任何一个字符的出现次数大于 input 的一半则返回空字符串，因为一定无法满足题意。corner case 处理完之后就开始从 pq 往外弹出元素。先弹出一个，记为 first，判断如果上一个被 attach 的字符也是 first 的话则再弹出一个 second 字符。加了哪个字符，就对其 mapvalue-- 并判断是否需要再加回 maxheap，直到 pq 为空。

时间O(nlogn)

空间O(n)

Java实现

class Solution {
    public String reorganizeString(String s) {
        int n = s.length();
        HashMap<Character, Integer> map = new HashMap<>();
        for (char c : s.toCharArray()) {
            int count = map.getOrDefault(c, 0) + 1;
            // impossible
            if (count > (n + 1) / 2) {
                return "";
            }
            map.put(c, count);
        }

        PriorityQueue<int[]> queue = new PriorityQueue<>((a, b) -> b[1] - a[1]);
        for (char c : map.keySet()) {
            queue.offer(new int[] { c, map.get(c) });
        }

        StringBuilder sb = new StringBuilder();
        while (!queue.isEmpty()) {
            int[] first = queue.poll();
            if (sb.length() == 0 || first[0] != sb.charAt(sb.length() - 1)) {
                sb.append((char) first[0]);
                if (--first[1] > 0) {
                    queue.offer(first);
                }
            } else {
                int[] second = queue.poll();
                sb.append((char) second[0]);
                if (--second[1] > 0) {
                    queue.offer(second);
                }
                queue.offer(first);
            }
        }
        return sb.toString();
    }
}

 

另一种做法是创建一个 hashmap 先记录每个字母出现的频率，再创建一个跟 input 字符串等长的数组开始往里面放字母。首先放出现次数最多的字母，并且放的时候，每两个字母之间隔开一个位置，类似 [0, 2, 4, 6...] 这样的放置方法。出现次数最多的字母处理完之后，其他的字母也是隔开一个位置这样的方式，放入数组剩下的位置里面。为什么出现次数最多的字母是一个比较特殊的情形是因为最极端的情况，出现次数最多的字母有可能占据 input 长度的一半，而占据 input 长度的一半也就意味着是没法按照题目要求重构的。

时间O(n)

空间O(n)

Java实现

class Solution {
    public String reorganizeString(String S) {
        int[] hash = new int[26];
        for (int i = 0; i < S.length(); i++) {
            hash[S.charAt(i) - 'a']++;
        }
        int max = 0;
        int letter = 0;
        for (int i = 0; i < hash.length; i++) {
            if (hash[i] > max) {
                max = hash[i];
                letter = i;
            }
        }
        // corner case
        if (max > (S.length() + 1) / 2) {
            return "";
        }
        char[] res = new char[S.length()];
        int index = 0;
        while (hash[letter] > 0) {
            res[index] = (char) (letter + 'a');
            index += 2;
            hash[letter]--;
        }
        for (int i = 0; i < hash.length; i++) {
            while (hash[i] > 0) {
                if (index >= res.length) {
                    index = 1;
                }
                res[index] = (char) (i + 'a');
                index += 2;
                hash[i]--;
            }
        }
        return String.valueOf(res);
    }
}

 

相关题目

358. Rearrange String k Distance Apart

767. Reorganize String

LeetCode 题目总结