leetcode695

public class Solution
    {
        public int MaxAreaOfIsland(int[,] grid)
        {
            var row = grid.GetLength();//
            var coloum = grid.GetLength();//
            bool[,] Visited = new bool[row, coloum];
            Queue<KeyValuePair<int, int>> Q = new Queue<KeyValuePair<int, int>>();

            int max = ;
            for (int i = ; i < row; i++)
            {
                for (int j = ; j < coloum; j++)
                {
                    int island = ;
                    if (!Visited[i, j])
                    {
                        Q.Enqueue(new KeyValuePair<int, int>(i, j));
                    }
                    while (Q.Any())
                    {
                        var pair = Q.Dequeue();
                        if (Visited[pair.Key, pair.Value])//此节点已经处理过
                        {
                            continue;
                        }
                        else
                        {
                            Visited[pair.Key, pair.Value] = true;//处理当前节点
                            if (grid[pair.Key, pair.Value] == )
                            {
                                island++;
                                //将此节点是1，则将这个节点的上下左右都取出来，
                                var up_point = new KeyValuePair<int, int>(pair.Key - , pair.Value);
                                var left_point = new KeyValuePair<int, int>(pair.Key, pair.Value - );
                                var down_point = new KeyValuePair<int, int>(pair.Key + , pair.Value);
                                var right_point = new KeyValuePair<int, int>(pair.Key, pair.Value + );
                                //如果是合法数值，则进队
                                if (up_point.Key >=  && !Visited[up_point.Key, up_point.Value] && grid[up_point.Key, up_point.Value] == )
                                {
                                    Q.Enqueue(up_point);
                                }
                                if (left_point.Value >=  && !Visited[left_point.Key, left_point.Value] && grid[left_point.Key, left_point.Value] == )
                                {
                                    Q.Enqueue(left_point);
                                }
                                if (down_point.Key <= row -  && !Visited[down_point.Key, down_point.Value] && grid[down_point.Key, down_point.Value] == )
                                {
                                    Q.Enqueue(down_point);
                                }
                                if (right_point.Value <= coloum -  && !Visited[right_point.Key, right_point.Value] && grid[right_point.Key, right_point.Value] == )
                                {
                                    Q.Enqueue(right_point);
                                }
                            }
                        }

                    }
                    //当前岛屿查询结束，更新最大岛
                    if (max < island)
                    {
                        max = island;
                    }
                }
            }

            return max;
        }
    }

本题属于分支限界的题目，广度优先进行搜索。利用访问的数组Visited，记录已经走过的路径，以减少重复计算。