leetcode329

public class Solution
    {
        bool[,] tags;//用于标记是否已经访问过，false未访问，true已访问
        int[,] records;//用于标记以当前为起点的最长升序列长度(上下左右四向最长的)

        private int MaxOfFour(int a, int b, int c, int d)
        {
            return Math.Max(Math.Max(a, b), Math.Max(c, d));
        }

        private int GetLongestFromPoint(int[,] matrix, int i, int j, int prenum)
        {
            var row = matrix.GetLength(0);
            var column = matrix.GetLength(1);

            if (i < 0 || i >= row || j < 0 || j >= column)
            {
                //坐标不合法
                return 0;
            }

            var curnum = matrix[i, j];//当前坐标
            if (prenum >= curnum)
            {
                return 0;
            }
            else
            {
                if (tags[i, j])//当前节点已经访问，直接返回结果
                {
                    return records[i, j];
                }

                //当前节点尚未访问过
                tags[i, j] = true;//当前节点未访问,将当前节点标记为已经访问

                //向上
                var maxup = 0;
                var up_i = i - 1;
                var up_j = j;
                if (up_i >= 0)
                {
                    maxup = GetLongestFromPoint(matrix, up_i, up_j, curnum);
                }

                //向下
                var maxdown = 0;
                var down_i = i + 1;
                var down_j = j;
                if (down_i < row)
                {
                    maxdown = GetLongestFromPoint(matrix, down_i, down_j, curnum);
                }


                //向左
                var maxleft = 0;
                var left_i = i;
                var left_j = j - 1;
                if (left_j >= 0)
                {
                    maxleft = GetLongestFromPoint(matrix, left_i, left_j, curnum);
                }


                //向右
                var maxright = 0;
                var right_i = i;
                var right_j = j + 1;
                if (right_j < column)
                {
                    maxright = GetLongestFromPoint(matrix, right_i, right_j, curnum);
                }

                var max = 1 + MaxOfFour(maxup, maxdown, maxleft, maxright);
                records[i, j] = max;//标记当前节点的最大升序列长度
                return max;
            }
        }

        public int LongestIncreasingPath(int[,] matrix)
        {
            var row = matrix.GetLength(0);
            var column = matrix.GetLength(1);
            if (row == 0 && column == 0)
            {
                return 0;
            }
            tags = new bool[row, column];
            records = new int[row, column];
            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < column; j++)
                {
                    tags[i, j] = false;
                    records[i, j] = 1;
                }
            }
            int maxlen = 1;//用于记录全局最长升序列长度

            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < column; j++)
                {
                    if (!tags[i, j])//当前节点还没有计算过
                    {
                        GetLongestFromPoint(matrix, i, j, matrix[i, j] - 1);
                    }
                    maxlen = Math.Max(maxlen, records[i, j]);//更新全局最大升序列长度
                }
            }

            return maxlen;
        }
    }