0字符串中等 LeetCode767. 重构字符串

767. 重构字符串

描述

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

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

示例 1:

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

输入: s = "aaab"
输出: ""
 

提示:

1 <= s.length <= 500
s 只包含小写字母

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

分析

判断能不能重构很简单，但是构造出重构后的字符串复杂一些。
构造的时候首先要把下标是偶数的先填充，因为下标是偶数的个数大于等于是奇数的下标个数。
填完奇数再去填写偶数的下标。(超过了s的字符串长度就把index变成1，从奇数下标1开始填充，每各2填一次)

class Solution {
    public String reorganizeString(String s) {
        int[] times = new int[26];
        for (int i = 0; i < s.length(); i++) {
            int index = s.charAt(i) - 'a';
            times[index]++;
        }
        int max = 0;
        List<int[]> list = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            if (times[i] > times[max]) {
                max = i;
            }
            if (times[i] > 0) {
                list.add(new int[]{i,times[i]});
            }
        }
        if (times[max] > (s.length()+1) / 2) {
            return "";
        }
        char[] chars = new char[s.length()];
        int index = 0;
        for (int i = 0; i < times[max]; i++) {
            chars[index] = (char)(max+'a');
            index += 2;
        }
        times[max] = 0;
        for (int i = 0; i < 26; i++) {
            while (times[i]-- > 0) {
                char c = (char)(i+'a');
                if (index >= s.length()) {
                    index = 1;
                }
                chars[index] = c;
                index += 2;
            }
        }
        return new String(chars);
    }
}

class Solution {
    public String reorganizeString(String s) {
        int[] times = new int[26];
        for (int i = 0; i < s.length(); i++) {
            int index = s.charAt(i) - 'a';
            times[index]++;
        }
        int max = 0;
        List<int[]> list = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            if (times[i] > times[max]) {
                max = i;
            }
            if (times[i] > 0) {
                list.add(new int[]{i,times[i]});
            }
        }
        if (times[max] > (s.length()+1) / 2) {
            return "";
        }
        Collections.sort(list,(a,b)->{
            return b[1] - a[1];
        });
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();
        StringBuffer ans = new StringBuffer();
        for (int i = 0; i < list.size(); i++) {
            int[] arr =list.get(i);
            char c = (char)(arr[0]+'a');
            for (int j = 0; j < arr[1]; j++) {
                if (sb1.length() < (s.length()+1) / 2) {
                    sb1.append(c);
                } else {
                    sb2.append(c);
                }
            }
        }
        for (int i = 0; i < sb2.length(); i++) {
            ans.append(sb1.charAt(i));
            ans.append(sb2.charAt(i));
        }
        if (sb1.length() > sb2.length()) {
            ans.append(sb1.charAt(sb1.length()-1));
        }
        return ans.toString();
    }
}