12.7-12.13

12月7日

861.翻转矩阵后的得分

class Solution {
    public int matrixScore(int[][] A) {
        //1最多的时候数最大，先让最大位都为1
        int m = A.length, n = A[0].length;
        //最大位都为1的总和
        int ans = (1<<(n - 1)) * m;
        //遍历除第一列的所有列，让其每列的1最多
        for (int j = 1; j < n; j ++) {
            int num = 0;
            for (int i = 0; i < m; i ++) {
                //需判断它的最大位是否已经颠倒过
                num += A[i][0] == 1 ? A[i][j] : 1 - A[i][j];
            }
            ans += Math.max(num, m-num) * (1<<(n-j-1));
        }
        return ans;
    }
}

12月8日

842.将数组拆分为斐波那契数列

class Solution {
    public List<Integer> splitIntoFibonacci(String S) {
        List<Integer> ans = new ArrayList();
        backTrack(S.toCharArray(), ans, 0);
        return ans;
    }
    public boolean backTrack(char[] arr, List<Integer> ans, int index) {
        //递归结束条件
        if(index == arr.length && ans.size() >= 3) {
            return true;
        }
        for(int i = index; i < arr.length; i ++) {
            //如果是两位以上数且0开头，则退出
            if(arr[index] == '0' && i > index) {
                break;
            }
            //截取数
            long n = sToInt(arr, index, i+1);
            if(n > Integer.MAX_VALUE){
                break;
            }
            int size = ans.size();
            //如果截取的数大于ans里前两个数的和，退出
            if(size >= 2 && n > ans.get(size-2) + ans.get(size-1)) {
                break;
            }
            //如果ans中的数小于2个，直接添加截取的数，如果截取的数等于ans中前两个数的和，也添加入队
            if(size <= 1 || n == ans.get(size-2) + ans.get(size-1)) {
                ans.add((int)n);
                //递归判断剩下的数，如果出现不满足的，则出队
                if(backTrack(arr, ans, i + 1)) {
                    return true;
                } else {
                    ans.remove(ans.size() - 1);
                }
            }
        }
        return false;
    }
    //相当于截取字符串S中的子串然后转换为十进制数字
    private long sToInt(char[] arr, int start, int end) {
        long res = 0;
        for (int i = start; i < end; i++) {
            res = res * 10 + arr[i] - '0';
        }
        return res;
    }
}

12月9日

62.不同路径

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] temp = new int[m][n];
        for(int i = 0; i < m; i ++) {
            for(int j = 0; j < n; j ++) {
                if(i == 0 || j == 0) {
                    temp[i][j] = 1;
                    continue;
                } else {
                    temp[i][j] = temp[i - 1][j] + temp[i][j - 1];
                }
            }
        }
        return temp[m-1][n-1];
    }
}

12月10日

/*
分别计算5、10的个数，因为20不用于找零，可以不统计数量
如果5和10少于0则返回false
*/
class Solution {
    public boolean lemonadeChange(int[] bills) {
        int five = 0, ten = 0;
        for(int i = 0; i < bills.length; i ++) {
            if(bills[i] == 5) {
                five ++;
            }else if(bills[i] == 10) {
                five --;
                ten ++;
            }else{
                if(ten > 0) {
                    ten --;
                    five --;
                } else {
                    five -=3;
                }
            }
            if(five < 0 || ten < 0) {
                return false;
            }
        }
        return true;
    }
}

12月11日

649.Dota2参议院

/*
先统计Radiant(天辉)和 Dire(夜魇)的下标
比较下标，下标小的可以参加第二轮投票，即重新入队
*/
class Solution {
    public String predictPartyVictory(String senate) {
        Queue<Integer> r = new LinkedList<>();
        Queue<Integer> d = new LinkedList<>();
        char[] s = senate.toCharArray();
        for(int i = 0; i < s.length; i ++) {
            if(s[i] == 'R') {
                r.offer(i);
            } else {
                d.offer(i);
            }
        }
        while(!r.isEmpty() && !d.isEmpty()) {
            int t1 = r.remove();
            int t2 = d.remove();
            if(t1 < t2) {
                r.offer(t1 + s.length);
            } else {
                d.offer(t2 + s.length);
            }
        }
        return d.isEmpty() ? "Radiant" : "Dire";
    }
}

12月13日

217.存在重复元素

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for(int i : nums) {
            set.add(i);
        }
        return set.size() < nums.length;
    }
}

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for(int i = 0; i < nums.length - 1; i ++) {
            if(nums[i] == nums[i+1]) {
                return true;
            }
        }
        return false;
    }
}