leetcode 14

public class DungenonGame {
    public static int needMin(int[][] matrix) {
        return process(matrix, matrix.length, matrix[0].length, 0, 0);
    }

    public static int process(int[][] matrix, int N, int M, int row, int col) {
        if (row == N - 1 && col == M - 1) {
            return matrix[N - 1][M - 1] < 0 ? (-matrix[N - 1][M - 1] + 1) : 1;
        }
        if (row == N - 1) {
            int rightNeed = process(matrix, N, M, row, col + 1);
            if (matrix[row][col] < 0) {
                return -matrix[row][col] + rightNeed;
            } else if (matrix[row][col] > rightNeed) {
                return 1;
            } else {
                return rightNeed - matrix[row][col];
            }
        }

        if (col == M - 1) {
            int downNeed = process(matrix, N, M, row + 1, col);
            if (matrix[row][col] < 0) {
                return -matrix[row][col] + downNeed;
            } else if (matrix[row][col] > downNeed) {
                return 1;
            } else {
                return downNeed - matrix[row][col];
            }
        }


        int minNextNeed = Math.min(process(matrix, N, M, row, col + 1), process(matrix, N, M, row + 1, col));
        if (matrix[row][col] < 0) {
            return -matrix[row][col] + minNextNeed;
        } else if (matrix[row][col] > minNextNeed) {
            return 1;
        } else {
            return minNextNeed - matrix[row][col];
        }
    }
}

public class CherryPickup {
    public static int comeGoMaxPathSum(int[][] matrix){
        return process(matrix,0,0,0);
    }

    //A和B同时走 A往下右  B往右下走
    //A的位置Ar Ac
    //B的位置Br Ar+Ac-Br
    //A和B迈出的步子一样多 所以
    //如果A和B到同一个格子，只计算一次
    public static int process(int[][] matrix,int Ar,int Ac,int Br){
        int N = matrix.length;
        int M =matrix[0].length;
        //到了右下角
        if(Ar == matrix.length -1 && Ac == matrix[0].length){
            return matrix[Ar][Ac];
        }

        int Bc = Ar+Ac-Br;
        //还没到右下角 四种情况
        //A下 B右
        //A下 B下
        //A右 B右
        //A右 B下
        int ADownRight = -1;
        if(Ar + 1 < N && Br + 1 < M){
            ADownRight  = process(matrix,Ar+1,Ac,Br);
        }

        int ADownBDown = -1;
        if(Ar + 1 < N && Br+1<N){
            ADownBDown = process(matrix,Ar+1,Ac,Br+1);
        }

        int ArightBright = -1;
        if(Ac + 1 < M && Bc + 1 < M){
            ADownRight = process(matrix,Ar,Ac+1,Br);
        }
        int ARightBDown = -1;
        if(Ac + 1 < M && Br+1<N){
            ARightBDown = process(matrix,Ar,Ar+1,Br+1);
        }

        int nextBest = Math.max(Math.max(ADownRight,ADownBDown),Math.max(ArightBright,ARightBDown));
        if(Ar == Br){//A和B走到同一个位置 计算一次
            return matrix[Ar][Ac] + nextBest;
        }
        //A和B互不相交的位置
        return  matrix[Ar][Ac] + matrix[Br][Bc] + nextBest;
    }
}