<String> 186 293 294 249

186. Reverse Words in a String II

先反转整个字符串，再反转每个单词（调整顺序也可以）

反转单词的时候：当 j 指到最后一个字符的时候，或者 j 的下一个指向空格，则反转该单词。

class Solution {
    public void reverseWords(char[] s) {
        if(s == null || s.length == 0){
            return;
        }
        reverse(s, 0, s.length - 1);
        int i = 0, j = 0;
        while(j < s.length){
            if(j == s.length - 1 || s[j + 1] == ' '){
                reverse(s, i, j);
                i = j + 2;
            }
            j++;
        }
    }

    void reverse(char[] str, int i, int j){
        while(i < j){
            char c = str[i];
            str[i++] = str[j];
            str[j--] = c;
        }
    }
}

293. Flip Game

把两个连续的++变为--，遍历所有情况即可。当 i  和  i - 1都为 +时，添加 -。

class Solution {
    public List<String> generatePossibleNextMoves(String s) {
        List<String> list = new ArrayList<String>();
        for(int i = 1; i < s.length(); i++){
            if(s.charAt(i - 1) == '+' && s.charAt(i) == '+'){
                list.add(s.substring(0, i - 1) + "--" + s.substring(i + 1, s.length()));
            }
        }
        return list;
    }
}

294. Flip Game II

题眼：Write a function to determine if the starting player can guarantee a win.

题目问的是，1p是否能够保证在一种情况下获胜。

用递归，遍历所有可以出现的第一种情况。在这种情况下如果 !canWin表示对手怎样都不能赢，则1p赢。

如果没有一种情况让1p赢，则他输。

时间复杂度：(n - 1) x (n - 3) x (n - 5) x ..., = O(n!!)

class Solution {
    public boolean canWin(String s) {
        if(s == null || s.length() < 2) return false;

        for(int i = 0; i < s.length() - 1; i++){
            if(s.charAt(i) == '+' && s.charAt(i + 1) == '+'){
                String t = s.substring(0, i) + "--" + s.substring(i + 2, s.length());
                if(!canWin(t)){
                    return true;
                }
            }
        }
        return false;
    }
}

249. Group Shifted Strings

如果是同类型的字符串，则每个字符串的字母与首字母的距离都是相同的。

ab ： offset = a - 'a' = 0,

　　 　　a - offset = a,    key = a

　　　　 b - offset = b。  key = ab

cd ：offset = c - 'a' = 2,

　　　　  c - offset = a,     key = a

　　　　  d - offset = 1 = b。 key = ab

每个单词的首字母与a的距离设为这个单词的偏移量offset，第二个字母 - offset, 第三个字母 - offset，依此类推，得到的字符串设为key值。如果这个单词key在map里有则直接添加进去，否则添加这个key值。

最后把map转移到结果里。

class Solution {
    public List<List<String>> groupStrings(String[] strings) {
        List<List<String>> result = new ArrayList<>();
        Map<String, List<String>> map = new HashMap<>();

        for(String str : strings){
            int offset = str.charAt(0) - 'a';
            String key = "";
            for(int i = 0; i < str.length(); i++){
                char c = (char)(str.charAt(i) - offset);
                if(c < 'a'){
                    c += 26;
                }
                key += c;
            }
            if(!map.containsKey(key)){
                List<String> list = new ArrayList<>();
                map.put(key, list);
            }
            map.get(key).add(str);
        }

        for(String key : map.keySet()){
            List<String> list = map.get(key);
            result.add(list);
        }
        return result;
    }
}