【华为机试】【Java】最小传输时延

如有问题请留言更正。
■ 题目描述
【最小传输时延】
有MN的节点矩阵，每个节点可以向8个方向（上、下、左、右及四个斜线方向）转发数据包，每个节点转发时会消耗固定时延，
连续两个相同时延可以减少一个时延值（即当有K个相同时延的节点连续转发时可以减少K- 1个时延值），
求左上角（0，0）开始转发数据包到右下角（M-1，N- 1）并转发出的最短时延。
输入描述
第一行两个数字，M、N，接下来有M行，每行有N个数据，表示M N的矩阵。
输出描述
最短时延值。
示例1 输入输出示例仅供调试，后台判题数据一般不包含示例
3 3
0 2 2
1 2 1
2 2 1
输出
3
示例2 输入输出示例仅供调试，后台判题数据一般不包含示例
3 3
2 2 2
2 2 2
2 2 2
输出：
4
（2 + 2 + 2 -（3-1))

public class MinFlow {

    public int getMin(int[][] grids){
        if (grids==null||grids.length==0){
            return 0;
        }
        int rows = grids.length, col = grids[0].length;
        int[][] dp = new int[rows][col];
        dp[0][0] = grids[0][0];
        int k =0;
        for (int i=1;i
            if (grids[i][0]==grids[i-1][0]){
                k++;
            }
            dp[i][0] = dp[i-1][0]+grids[i][0]-k;
            k = 0;
        }
        for (int j=1;j
            if (grids[0][j]==grids[0][j-1]){
                k++;
            }
            dp[0][j] = dp[0][j-1]+grids[0][j]-k;
            k = 0;
        }
        int r=0,c=0;
        for (int i=1;i
            for (int j =1;j
                if (grids[i-1][j]==grids[i][j]){
                    c++;
                }
                if (grids[i][j-1]==grids[i][j]){
                    r++;
                }
                if (grids[i-1][j-1]==grids[i][j]){
                    k++;
                }
                // 上下一致
                int rDp = dp[i-1][j]+grids[i][j]-c;
                // 左右一致
                int cDp = dp[i][j-1]+grids[i][j]-r;
                // 斜上一致
                int jDp = dp[i-1][j-1]+grids[i][j]-k;

                dp[i][j] = Math.min(rDp,Math.min(cDp,jDp));
                c = 0;
                r = 0;
                k = 0;
            }
        }
        return dp[rows-1][col-1];
    }

    public static void main(String[] args) {
        int[][] grids = {
                {2,2,2},
                {2,2,2},
                {2,2,2}
        };
        int ans = new MinFlow().getMin(grids);
        System.out.println(ans);
    }
}