solve problem Max Area Of Island

Author: P-ppc

README.md

@@ -79,6 +79,7 @@ All solutions will be accepted!
 |349|[Intersection Of Two Arrays](https://leetcode-cn.com/problems/intersection-of-two-arrays/description/)|[java/py/js](./algorithms/IntersectionOfTwoArrays)|Easy|
 |268|[Missing Number](https://leetcode-cn.com/problems/missing-number/description/)|[java/py/js](./algorithms/MissingNumber)|Easy|
 |788|[Rotated Digits](https://leetcode-cn.com/problems/rotated-digits/description/)|[java/py/js](./algorithms/RotatedDigits)|Easy|
+|695|[Max Area Of Island](https://leetcode-cn.com/problems/max-area-of-island/description/)|[java/py/js](./algorithms/MaxAreaOfIsland)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/MaxAreaOfIsland/README.md

@@ -0,0 +1,2 @@
+# Max Area Of Island
+This problem is easy to solve by DFS

algorithms/MaxAreaOfIsland/Solution.java

@@ -0,0 +1,60 @@
+class Solution {
+    public int maxAreaOfIsland(int[][] grid) {
+        int maxArea = 0;
+        Map<String, Integer> dfsMap = new HashMap<String, Integer>();
+        
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1 && dfsMap.get(String.valueOf(i) + "X" + String.valueOf(j)) == null) {
+                    int area = 0;
+                    List<Map<String, Integer>> stack = new ArrayList<Map<String, Integer>>();
+                    Map<String, Integer> origin = new HashMap<String, Integer>();
+                    origin.put("x", j);
+                    origin.put("y", i);
+                    stack.add(origin);
+                    
+                    while (stack.size() > 0) {
+                        Map<String, Integer> point = stack.get(stack.size() - 1);
+                        stack.remove(stack.size() - 1);
+                        
+                        int x = point.get("x"),
+                            y = point.get("y");
+                        
+                        if (dfsMap.get(String.valueOf(y) + "X" + String.valueOf(x)) == null) {
+                            area++;
+                            dfsMap.put(String.valueOf(y) + "X" + String.valueOf(x), 1);
+                            
+                            if (y >= 1 && grid[y - 1][x] == 1) {
+                                point = new HashMap<String, Integer>();
+                                point.put("x", x);
+                                point.put("y", y - 1);
+                                stack.add(point);
+                            }
+                            if (y + 1 < grid.length && grid[y + 1][x] == 1) {
+                                point = new HashMap<String, Integer>();
+                                point.put("x", x);
+                                point.put("y", y + 1);
+                                stack.add(point);
+                            }
+                            if (x >= 1 && grid[y][x - 1] == 1) {
+                                point = new HashMap<String, Integer>();
+                                point.put("x", x - 1);
+                                point.put("y", y);
+                                stack.add(point);
+                            }
+                            if (x + 1 < grid[0].length && grid[y][x + 1] == 1) {
+                                point = new HashMap<String, Integer>();
+                                point.put("x", x + 1);
+                                point.put("y", y);
+                                stack.add(point);
+                            }
+                        }
+                    }
+                    
+                    maxArea = Math.max(maxArea, area);
+                }
+            }
+        }
+        return maxArea;
+    }
+}

algorithms/MaxAreaOfIsland/solution.js

@@ -0,0 +1,36 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var maxAreaOfIsland = function(grid) {
+    let maxArea = 0,
+        dfsMap = {}
+    
+    for (let i = 0; i < grid.length; i++) {
+        for (let j = 0; j < grid[0].length; j++) {
+            if (grid[i][j] === 1 && dfsMap[`${i}X${j}`] === undefined) {
+                let stack = [{ x: j, y: i }],
+                    area = 0
+                
+                while (stack.length > 0) {
+                    let point = stack.pop(),
+                        x = point['x'],
+                        y = point['y']
+                    
+                    if (dfsMap[`${y}X${x}`] === undefined) {
+                        area++
+                        dfsMap[`${y}X${x}`] = 1
+                        
+                        if (y >= 1 && grid[y - 1][x] === 1) stack.push({ x, y: y - 1 })
+                        if (y + 1 < grid.length && grid[y + 1][x] === 1) stack.push({ x, y: y + 1})
+                        if (x >= 1 && grid[y][x - 1] === 1) stack.push({ x: x - 1, y })
+                        if (x + 1 < grid[0].length && grid[y][x + 1] === 1) stack.push({ x: x + 1, y })
+                    }
+                }
+                
+                maxArea = Math.max(maxArea, area)
+            }
+        }
+    }
+    return maxArea
+};

algorithms/MaxAreaOfIsland/solution.py

@@ -0,0 +1,33 @@
+class Solution(object):
+    def maxAreaOfIsland(self, grid):
+        """
+        :type grid: List[List[int]]
+        :rtype: int
+        """
+        max_area = 0
+        dfs_map = {}
+        for i in range(0, len(grid)):
+            for j in range(0, len(grid[0])):
+                if grid[i][j] == 1 and dfs_map.get(str(i) + 'X' + str(j)) == None:
+                    stack = [{ 'i': i, 'j': j }]
+                    area = 0
+                    while len(stack) > 0:
+                        point = stack.pop()
+                        i = point['i']
+                        j = point['j']
+                        if dfs_map.get(str(i) + 'X' + str(j)) == 1:
+                            continue
+                        else:
+                            area += 1
+                            dfs_map[str(i) + 'X' + str(j)] = 1
+                            
+                        if i >= 1 and grid[i - 1][j] == 1:
+                            stack.append({ 'i': i - 1, 'j': j })
+                        if i + 1 < len(grid) and grid[i + 1][j] == 1:
+                            stack.append({ 'i': i + 1, 'j': j })
+                        if j >= 1 and grid[i][j - 1] == 1:
+                            stack.append({ 'i': i, 'j': j - 1 })
+                        if j + 1 < len(grid[0]) and grid[i][j + 1] == 1:
+                            stack.append({ 'i': i, 'j': j + 1 })
+                    max_area = max(max_area, area)         
+        return max_area