1763. 最长的美好子字符串

当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。比方说，"abABB" 是美好字符串，因为 'A' 和 'a' 同时出现了，且 'B' 和 'b' 也同时出现了。然而，"abA" 不是美好字符串因为 'b' 出现了，而 'B' 没有出现。

给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。

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

枚举

import java.util.Scanner;

class Solution {
    public String longestNiceSubstring(String s) {
        String ans = "";
        for (int i = 0; i < s.length(); ++i) {
            int big = 0;
            int small = 0;
            for (int j = i; j < s.length(); ++j) {
                if (Character.isUpperCase(s.charAt(j))) {
                    big |= (1 << (s.charAt(j) - 'A'));
                } else {
                    small |= (1 << (s.charAt(j) - 'a'));
                }
                if ((big ^ small) == 0) {
                    if (ans.length() < j - i + 1) {
                        ans = s.substring(i, j + 1);
                    }
                }
            }
        }

        return ans;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            System.out.println(new Solution().longestNiceSubstring(in.next()));
        }
    }
}

分治

import java.util.Scanner;

class Solution {

    private int index = 0;

    private int length = 0;

    public String longestNiceSubstring(String s) {
        if (s == null || s.length() == 0) {
            return s;
        }
        solve(s, 0, s.length() - 1);
        return s.substring(index, index + length);
    }

    private void solve(String s, int start, int end) {
        if (end - start + 1 <= Math.max(length, 1)) {
            return;
        }
        int lower = 0, upper = 0;
        for (int i = start; i <= end; ++i) {
            if (Character.isUpperCase(s.charAt(i))) {
                upper |= (1 << (s.charAt(i) - 'A'));
            } else {
                lower |= (1 << (s.charAt(i) - 'a'));
            }
        }

        if ((lower ^ upper) == 0) {
            index = start;
            length = end - start + 1;
            return;
        }

        int allow = lower & upper;

        int left = start, right;

        while (left <= end) {
            while (left <= end && !isAllow(s.charAt(left), allow)) {
                left++;
            }
            right = left;
            while (right <= end && isAllow(s.charAt(right), allow)) {
                right++;
            }
            solve(s, left, right - 1);
            left = right;
        }
    }

    private boolean isAllow(char c, int allow) {
        if (Character.isLowerCase(c)) {
            return (allow & (1 << (c - 'a'))) != 0;
        } else {
            return (allow & (1 << (c - 'A'))) != 0;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            System.out.println(new Solution().longestNiceSubstring(in.next()));
        }
    }
}

滑动窗口

import java.util.Scanner;

class Solution {

    private int length = 0;
    private int index = 0;

    public String longestNiceSubstring(String s) {
        int types = 0;
        for (int i = 0; i < s.length(); ++i) {
            types |= 1 << (Character.toLowerCase(s.charAt(i)) - 'a');
        }
        types = Integer.bitCount(types);
        for (int i = 1; i <= types; ++i) {
            check(s, i);
        }
        return s.substring(index, index + length);
    }

    public void check(String s, int typeNum) {
        int[] lowerCnt = new int[26];
        int[] upperCnt = new int[26];
        int less = 0, total = 0;
        int left = 0, right = 0;
        while (right < s.length()) {
            int dight = Character.toLowerCase(s.charAt(right)) - 'a';
            boolean lower = Character.isLowerCase(s.charAt(right));
            if (lower) {
                lowerCnt[dight]++;
            } else {
                upperCnt[dight]++;
            }
            if (lowerCnt[dight] + upperCnt[dight] == 1) {
                less++;
                total++;
            }
            if (lower && lowerCnt[dight] == 1 && upperCnt[dight] >= 1) {
                less--;
            } else if (!lower && upperCnt[dight] == 1 && lowerCnt[dight] >= 1) {
                less--;
            }
            while (total > typeNum) {
                dight = Character.toLowerCase(s.charAt(left)) - 'a';
                lower = Character.isLowerCase(s.charAt(left));
                if (lower) {
                    lowerCnt[dight]--;
                    if (lowerCnt[dight] == 0 && upperCnt[dight] >= 1) {
                        less++;
                    }
                } else {
                    upperCnt[dight]--;
                    if (upperCnt[dight] == 0 && lowerCnt[dight] >= 1) {
                        less++;
                    }
                }
                if (lowerCnt[dight] == 0 && upperCnt[dight] == 0) {
                    total--;
                    less--;
                }
                left++;
            }
            if (less == 0 && right - left + 1 > length) {
                index = left;
                length = right - left + 1;
            }
            right++;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            System.out.println(new Solution().longestNiceSubstring(in.next()));
        }
    }
}