Encode String with Shortest Length

Given a non-empty string, encode the string such that its encoded length is the shortest.

The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times.

Note:

1. k will be a positive integer and encoded string will not be empty or have extra space.
2. You may assume that the input string contains only lowercase English letters. The string's length is at most 160.
3. If an encoding process does not make the string shorter, then do not encode it. If there are several solutions, return any of them is fine.

Example 1:

Input: "aaa"
Output: "aaa"
Explanation: There is no way to encode it such that it is shorter than the input string, so we do not encode it.

Example 2:

Input: "aaaaa"
Output: "5[a]"
Explanation: "5[a]" is shorter than "aaaaa" by 1 character.

Example 3:

Input: "aaaaaaaaaa"
Output: "10[a]"
Explanation: "a9[a]" or "9[a]a" are also valid solutions, both of them have the same length = 5, which is the same as "10[a]".

Example 4:

Input: "aabcaabcd"
Output: "2[aabc]d"
Explanation: "aabc" occurs twice, so one answer can be "2[aabc]d".

Example 5:

Input: "abbbabbbcabbbabbbc"
Output: "2[2[abbb]c]"
Explanation: "abbbabbbc" occurs twice, but "abbbabbbc" can also be encoded to "2[abbb]c", so one answer can be "2[2[abbb]c]".

思路：這題因爲中間任意重複字符都可以形成重複，所以這是一個長度區間型動態規劃，從len最小的開始計算，一直計算到最大的。dp[i][j]代表從i,....j 最小的compress string，dp[i][j] , 可以從兩個方面得到, dp[i][k] + dp[k + 1][j] 如果合起來比當前小，update

如果dp[i][j] 自己能夠組成最小的compression，也需要update。注意判斷最小的compress string的時候，用pattern去判斷，

pattern != null && substr.length() % pattern.length() == 0 && substr.replaceAll(pattern, "").length() == 0) 這句代碼很巧妙，學習了。另外，長度dp的模板要記住：

        for(int len = 1; len <= n; len++) {
            for(int i = 0; i + len - 1 < n; i++) {
                int j = i + len - 1;

class Solution {
    public String encode(String s) {
        int n = s.length();
        String[][] dp = new String[n][n];
        
        for(int len = 1; len <= n; len++) {
            for(int i = 0; i + len - 1 < n; i++) {
                int j = i + len - 1;
                String substr = s.substring(i, j + 1);
                dp[i][j] = substr;
                // 看左右兩邊能否組合成最小的string；
                if(j - i >= 4) {
                    for(int k = i; k < j; k++) {
                        if(dp[i][k].length() + dp[k + 1][j].length() < dp[i][j].length()) {
                            dp[i][j] = dp[i][k] + dp[k + 1][j];
                        }
                    }
                }
                
                // 看自己能否組成最小的string；
                for(int k = 0; k < substr.length(); k++) {
                    // 遍歷所有的可能pattern；
                    String pattern = substr.substring(0, k + 1);
                    if(pattern != null
                      && (substr.length() % pattern.length() == 0)
                      && substr.replaceAll(pattern, "").length() == 0) {
                        String candidate = substr.length() / pattern.length() 
                            + "[" + dp[i][i + k] + "]";
                        if(candidate.length() < dp[i][j].length()) {
                            dp[i][j] = candidate;
                        }
                    }
                }
            }
        }
        return dp[0][n - 1];
    }
}