java常见算法

1.妙妙奇趣屋  dp

给你一个由数字和运算符组成的字符串 expression ，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以 按任意顺序 返回答案。

示例 1：

输入：expression = "2-1-1"
输出：[0,2]
解释：
((2-1)-1) = 0 
(2-(1-1)) = 2
示例 2：

输入：expression = "2*3-4*5"
输出：[-34,-14,-10,-10,10]
解释：
(2*(3-(4*5))) = -34 
((2*3)-(4*5)) = -14 
((2*(3-4))*5) = -10 
(2*((3-4)*5)) = -10 
(((2*3)-4)*5) = 10

class Solution {
    public List<Integer> diffWaysToCompute(String s) {

        if (s.length() == 0)
            return new ArrayList<>();

        List<Integer> res = new ArrayList<>();
        int num = 0;
        int index = 0;
        while (index < s.length() && !isLitter(s.charAt(index))) {

            num = num * 10 + s.charAt(index) - '0';
            index++;
        }

        if (index == s.length()) {

            res.add(num);
            return res;
        }

        for (int i = 0; i < s.length(); i++) {

            if (isLitter(s.charAt(i))) {


                List<Integer> l1 = diffWaysToCompute(s.substring(0, i));
                List<Integer> l2 = diffWaysToCompute(s.substring(i + 1));

                for (int j = 0; j < l1.size(); j++) {

                    for (int k = 0; k < l2.size(); k++) {

                        char o = s.charAt(i);
                        res.add(get(l1.get(j), o, l2.get(k)));
                    }
                }
            }
            
        }
        return res;
    }



    public int get(int a,char c,int b) {

        switch (c) {

            case '+':
                return a + b;

            case '*':
                return a * b;

            case '-':
                return a - b;

            
        }
        return -1;
    }

    public boolean isLitter(char c) {

        return c == '+' || c == '-' || c == '*';
    }
}

2.广度优先搜索

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};

    public void solve(char[][] board) {
        int n = board.length;
        if (n == 0) {
            return;
        }
        int m = board[0].length;
        Queue<int[]> queue = new LinkedList<int[]>();
        for (int i = 0; i < n; i++) {
            if (board[i][0] == 'O') {
                queue.offer(new int[]{i, 0});
                board[i][0] = 'A';
            }
            if (board[i][m - 1] == 'O') {
                queue.offer(new int[]{i, m - 1});
                board[i][m - 1] = 'A';
            }
        }
        for (int i = 1; i < m - 1; i++) {
            if (board[0][i] == 'O') {
                queue.offer(new int[]{0, i});
                board[0][i] = 'A';
            }
            if (board[n - 1][i] == 'O') {
                queue.offer(new int[]{n - 1, i});
                board[n - 1][i] = 'A';
            }
        }
        while (!queue.isEmpty()) {
            int[] cell = queue.poll();
            int x = cell[0], y = cell[1];
            for (int i = 0; i < 4; i++) {
                int mx = x + dx[i], my = y + dy[i];
                if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != 'O') {
                    continue;
                }
                queue.offer(new int[]{mx, my});
                board[mx][my] = 'A';
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'A') {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
    }
}

3.

现有一份 n + m 次投掷单个 六面 骰子的观测数据，骰子的每个面从 1 到 6 编号。观测数据中缺失了 n 份，你手上只拿到剩余 m 次投掷的数据。幸好你有之前计算过的这 n + m 次投掷数据的 平均值 。

给你一个长度为 m 的整数数组 rolls ，其中 rolls[i] 是第 i 次观测的值。同时给你两个整数 mean 和 n 。

返回一个长度为 n 的数组，包含所有缺失的观测数据，且满足这 n + m 次投掷的 平均值 是 mean 。如果存在多组符合要求的答案，只需要返回其中任意一组即可。如果不存在答案，返回一个空数组。

k 个数字的 平均值 为这些数字求和后再除以 k 。

注意 mean 是一个整数，所以 n + m 次投掷的总和需要被 n + m 整除。

示例 1：

输入：rolls = [3,2,4,3], mean = 4, n = 2
输出：[6,6]
解释：所有 n + m 次投掷的平均值是 (3 + 2 + 4 + 3 + 6 + 6) / 6 = 4 。
示例 2：

输入：rolls = [1,5,6], mean = 3, n = 4
输出：[2,3,2,2]
解释：所有 n + m 次投掷的平均值是 (1 + 5 + 6 + 2 + 3 + 2 + 2) / 7 = 3 。

class Solution {
    public int[] missingRolls(int[] rolls, int mean, int n) {

        int len = rolls.length;
        int sum = mean * (len + n);
        int nowSUN = 0;

        for (int i = 0; i < len; i++) {

            nowSUN += rolls[i];
        }

        int countSun = sum - nowSUN;

        if (countSun < n || countSun > 6 * n) {
            return new int[0];
        }

        int max = countSun / n;
        int min = countSun % n;

        int[] res = new int[n];

        for (int i = 0; i < n; i++) {

            res[i] = max + (i < min ?1:0);
        }

        return res;
    }
}

4.

一位老师正在出一场由 n 道判断题构成的考试，每道题的答案为 true （用 'T' 表示）或者 false （用 'F' 表示）。老师想增加学生对自己做出答案的不确定性，方法是 最大化 有 连续相同 结果的题数。（也就是连续出现 true 或者连续出现 false）。

给你一个字符串 answerKey ，其中 answerKey[i] 是第 i 个问题的正确结果。除此以外，还给你一个整数 k ，表示你能进行以下操作的最多次数：

每次操作中，将问题的正确答案改为 'T' 或者 'F' （也就是将 answerKey[i] 改为 'T' 或者 'F' ）。
请你返回在不超过 k 次操作的情况下，最大 连续 'T' 或者 'F' 的数目。

示例 1：

输入：answerKey = "TTFF", k = 2
输出：4
解释：我们可以将两个 'F' 都变为 'T' ，得到 answerKey = "TTTT" 。
总共有四个连续的 'T' 。
示例 2：

输入：answerKey = "TFFT", k = 1
输出：3
解释：我们可以将最前面的 'T' 换成 'F' ，得到 answerKey = "FFFT" 。
或者，我们可以将第二个 'T' 换成 'F' ，得到 answerKey = "TFFF" 。
两种情况下，都有三个连续的 'F' 。

class Solution {
    public int maxConsecutiveAnswers(String answerKey, int k) {
        return Math.max(getMax(answerKey,k,'T'),getMax(answerKey,k,'F'));
    }

    public int getMax(String s,int k,char a) {

        int len = s.length();
        int res = 0;
        for (int left = 0,right = 0,sum = 0;right < len;right++) {

            sum += (s.charAt(right) != a ? 1 : 0);

            while (sum > k) {

                sum -= (s.charAt(left++) != a ?1:0);
            }

            res = Math.max(res,right-left+1);
        }

        return res;
    }
}