豆包MarsCode算法比赛（ABCD）

A

思路：模拟

复杂度：O(N)

public class A {
    static int[] dp = new int[26];
    static {
        dp[1] = dp[2] = 1;
        for (int i = 3; i <= 25; i++) {
            dp[i] = dp[i-3] + dp[i-2] + dp[i-1];
        }
    }
    public static int solution(int n) {
        // write code here
        return dp[n];
    }
}

B

思路：枚举每个'?'，然后枚举变成a-z中的哪个字符，注意不能变成跟邻项相同的。

复杂度：O(N * 26)

public class B {
    public static String solution(String s) {
        // write code here
        char[] cs = s.toCharArray();
        for (int i = 0; i < cs.length; i++) {
            if (cs[i] == '?') {
                int t = 0;
                for (int j = 0; j < 26; j++) {
                    if (i > 0 && cs[i-1] == (char) ('a' + j)) {
                        continue;
                    }
                    if (i + 1 < cs.length && cs[i+1] == (char) ('a' + j)) {
                        continue;
                    }
                    t = j;
                    break;
                }
                cs[i] = (char) ('a' + t);
            }
        }
        return String.valueOf(cs);
    }

}

C

思路：二维前缀和 + 枚举边长

复杂度：O(N * M * min(N,M))

public class C {
    static int[][] matrixSum(int[][] a) {
        int m = a.length;
        int n = a[0].length;
        int[][] g = new int[m + 1][n + 1];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int x = i + 1;
                int y = j + 1;
                g[x][y] = a[i][j] + g[x-1][y] + g[x][y-1] - g[x-1][y-1];
            }
        }
        return g;
    }
    public static int solution(int[][] gems, int M) {
        // write code here
        int[][] g = matrixSum(gems);

        int n = gems.length;
        int m = gems[0].length;
        int maxLen = 0;
        for (int len = 1; len <= Math.min(n, m); len++) {
            for (int i = 1; i <= n - len + 1; i++) {
                for (int j = 1; j <= m - len + 1; j++) {
                    int x2 = i + len - 1;
                    int y2 = j + len - 1;
                    int sum = g[x2][y2]
                            - g[i - 1][y2]
                            - g[x2][j - 1]
                            + g[i - 1][j - 1];
                    if (sum <= M) {
                        maxLen = Math.max(maxLen, len);
                    }
                }
            }

        }
        return maxLen;
    }
}

D

思路：动态规划，定义dp[i][j]为前i个序列选择开头j个石头的最大价值。

复杂度：O(N * M)

public class D {

    static int[][] dp;
    static int[] cc;
    static int[] ss;

    public static int solution(int[] stones, int[] c) {
        // write code here
        int n = c.length;
        int m = stones.length;
        cc = c;
        ss = stones;
        dp = new int[n+1][m+1];
        for (int[] row : dp) {
            Arrays.fill(row, Integer.MIN_VALUE);
        }
        return dfs(0, 0);
    }

    static int dfs(int i, int j) {
        if (i >= cc.length) return 0;
        if (dp[i][j] != Integer.MIN_VALUE) return dp[i][j];
        int r = i - j; // 右边已经取的数量
        int k = ss.length - r - 1;
        int res1 = dfs(i + 1, j + 1) + cc[i] * ss[j];
        int res2 = dfs(i + 1, j) + cc[i] * ss[k];
        return dp[i][j] = Math.max(res1, res2);
    }
}