thảo luận Leetcode mỗi ngày

class Solution:
    def islandPerimeter(self, grid: List[List[int]]) -> int:
        perimeter = 0
        m = len(grid)
        n = len(grid[0])
        directions = [[0, -1], [0, 1], [ -1, 0], [1, 0]]
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 0:
                    continue

                perimeter += 4
                for dx, dy in directions:
                    newRow = dx + i
                    newColumn = dy + j
                    if 0 <= newRow < m and 0 <= newColumn < n and grid[newRow][newColumn] == 1:
                        perimeter -= 1
        
        return perimeter

class Solution {

    /**
     * @param Integer[][] $grid
     * @return Integer
     */
    function islandPerimeter($grid) {
        $per = 0;
        foreach ($grid as $i => $r) {
            foreach ($r as $j => $c) {
                if ($c) {
                    $per += 4;
                    if ($grid[$i][$j-1]) $per--; // left
                    if ($grid[$i][$j+1]) $per--; // right
                    if ($grid[$i+1][$j]) $per--; // up
                    if ($grid[$i-1][$j]) $per--; // down
                }
            }
        }

        return $per;
    }
}

class Solution {
    int res = 0;
    public int islandPerimeter(int[][] grid) {
        int row = 0, col = 0;
        loop : for(row = 0; row < grid.length; row++) {
            for(col = 0; col < grid[0].length; col++) {
                if(grid[row][col] != 0) break loop;
            }
        }
        DFS(grid, row, col);
        return res;
    }

    private void helper(int[][] grid, int row, int col) {
        if(Math.min(row, col) < 0 || row >= grid.length || col >= grid[0].length) {
            res++;
            return;
        }
        if(grid[row][col] == 0) {
            res++;
            return;
        }
        if(grid[row][col] < 0) return;

        grid[row][col] = -1;
        DFS(grid, row, col+1);
        DFS(grid, row+1, col);
        DFS(grid, row, col-1);
        DFS(grid, row-1, col);
    }
}

class Solution {
    public int islandPerimeter(int[][] grid) {
        int rows = grid.length;
        int cols = grid[0].length;
        int perimeter=0;
        int[][] adjs = new int[rows][cols];
        for(int i = 0;i<rows;i++ ){
            for(int j=0;j<cols;j++){
                if(grid[i][j]==1){
                    if(j+1<cols && grid[i][j+1]==1){
                        adjs[i][j]++;
                        adjs[i][j+1]++;
                    }
                    if(i+1<rows && grid[i+1][j]==1){
                        adjs[i][j]++;
                        adjs[i+1][j]++;
                    }
                  
                    perimeter+=4 - adjs[i][j];
                }
                
            }
        }
        return perimeter;
    }
}

class Solution:
    def islandPerimeter(self, grid: List[List[int]]) -> int:
        result = 0
        m, n = len(grid), len(grid[0])
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    result += 4
                    if i - 1 >= 0 and grid[i - 1][j] == 1:
                        result -= 1
                    if j - 1 >= 0 and grid[i][j - 1] == 1:
                        result -= 1
                    if i + 1 < m and grid[i + 1][j] == 1:
                        result -= 1
                    if j + 1 < n and grid[i][j + 1] == 1:
                        result -= 1
        return result

var islandPerimeter = function(grid) {
    let p = 0;
    let n = grid.length;
    let m = grid[0].length;
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < m; j++) {
            if (grid[i][j] == 1) {
                p += 4;
                if (i > 0 && grid[i-1][j] == 1) p -= 1;
                if (i < n - 1 && grid[i+1][j] == 1) p -= 1;
                if (j > 0 && grid[i][j-1] == 1) p -= 1;
                if (j < m - 1 && grid[i][j+1] == 1) p -= 1;
            }
        }
    }

    return p;
};

class Solution {
    public int islandPerimeter(int[][] grid) {
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    return dfs(grid, i, j);
                }
            }
        }
        return 0;
    }
    private int dfs(int[][] grid, int i, int j){
        if( i < 0 || j < 0 ||i >= grid.length || j >= grid[0].length || grid[i][j] == 0){
            return 1;
        }
        if(grid[i][j] == -1) return 0;
        grid[i][j] = -1;
        return dfs(grid, i, j + 1) + dfs(grid, i + 1, j)+ dfs(grid, i, j - 1) + dfs(grid, i - 1, j);
    }
}

    int sum = 0;
    for (int row = 0; row < grid.length; row++) {
      for (int col = 0; col < grid[row].length; col++) {
        if (grid[row][col] == 1) {
          sum += 4;
        }
        if (col > 0 && grid[row][col] == 1 && grid[row][col] == grid[row][col - 1]) {
          sum -= 2;
        }
        if (row > 0 && grid[row][col] == 1 && grid[row - 1][col] == grid[row][col]) {
          sum -= 2;
        }
      }
    }

    return sum;

class Solution {
    public int islandPerimeter(int[][] grid) {
        int ans = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    ans += 4;
                    if (i > 0 && grid[i-1][j] == 1) {
                        ans -= 2;
                    }
                    if (j > 0 && grid[i][j-1] == 1) {
                        ans -= 2;
                    }
                }
            }
        }
        return ans;
    }
}

class Solution {
public:
    void dfs(vector<vector<int>>& grid, int r, int c, int &p, int m,int n)
    {
        if(r<0 || c<0 || r>=n || c>=m || grid[r][c] == 0 ) { ++p ; return; }
        if(grid[r][c] == 2) return;
        if(grid[r][c] == 1) grid[r][c] = 2;
        dfs(grid, r+1, c, p, m, n);
        dfs(grid, r-1, c, p, m, n);
        dfs(grid, r, c+1, p, m, n);
        dfs(grid, r, c-1, p, m, n);
        return;
    }
    int islandPerimeter(vector<vector<int>>& grid) {
        auto n = grid.size();
        auto m = grid[0].size();
        auto r=0; auto c=0;
        auto p = 0;
        for(r=0;r<n;++r)
        {
            for(c=0;c<m;++c)
            {
                if(grid[r][c] == 1)
                {
                    dfs(grid, r, c ,p, m, n);
                    return p;
                }
            }
        }
        return 0;
    }
};

    /**
     * Time: O(mn)
     * Space: O(1)
     */
    public int islandPerimeter(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0)
            return 0;

        int count = 0;

        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    count += 4;

                    if (j - 1 >= 0 && grid[i][j - 1] == 1) {
                        count -= 2;
                    }

                    if (i - 1 >= 0 && grid[i - 1][j] == 1) {
                        count -= 2;
                    }
                }
            }
        }

        return count;
    }

class Solution:
    def islandPerimeter(self, grid: List[List[int]]) -> int:
        ans = 0
        dirs = [(1, 0), (0, 1), (-1, 0), (0, -1)]
        n = len(grid)
        m = len(grid[0])
        for row in range(n):
            for col in range(m):
                if grid[row][col] == 1:
                    ans += 4
                    for (i, j) in dirs:
                        nextRow = row + i
                        nextCol = col + j
                        if 0 <= nextRow < n and 0 <= nextCol < m:
                            ans -= grid[nextRow][nextCol]
        return ans

var islandPerimeter = function(grid) {
    let count = 0;
    let row = grid.length;
    let col = grid[0].length;

    function dfs(i, j) {
        if (i < 0 || i >= row || j < 0 || j >= col || grid[i][j] === 0) {
            count++;
            return;
        }
        if(grid[i][j] === -1) return;

        if (grid[i][j] === 1) {
            grid[i][j] = -1;
            dfs(i, j - 1);
            dfs(i, j + 1);
            dfs(i - 1, j);
            dfs(i + 1, j);
        }
    }

    let found = false;
    for (let i = 0; i < row; i++) {
        for (let j = 0; j < col; j++) {
            if (grid[i][j] === 1) {
                dfs(i, j);
                found = true;
                break;
            }
        }
        if (found) break;
    }

    return count;
};

class Solution {
    int globalSum;
    
    public int islandPerimeter(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        globalSum = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    dfs(i, j, -1, -1, grid);
                    return globalSum;
                }
            }
        }

        return globalSum;
    }

    private void dfs(int row, int col, int rowParent, int colParent, int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;

        int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

        if (row < 0 || row >= m || col < 0 || col >= n || grid[row][col] == 0) {
            globalSum++;
            return;
        }

        if (grid[row][col] == -1) return;

        grid[row][col] = -1;

        for (int[] dir: dirs) {
            int nextRow = row + dir[0];
            int nextCol = col + dir[1];

            dfs(nextRow, nextCol, row, col, grid);
        }
    }
}

int islandPerimeter(vector<vector<int>>& grid) {
    int ret = 0;
    int r = grid.size(), c = grid[0].size();
    for(auto i = 0; i < r; ++i) {
        for(auto j = 0; j < c; ++j) {
            if (!grid[i][j]) continue;
            if (i == 0   || !grid[i-1][j]) ret++;
            if (i == r-1 || !grid[i+1][j]) ret++;
            if (j == 0   || !grid[i][j-1]) ret++;
            if (j == c-1 || !grid[i][j+1]) ret++;
        }
    }

    return ret;
}

class Solution:
    def islandPerimeter(self, grid: List[List[int]]) -> int:
        self.row = len(grid)
        self.col = len(grid[0])
        def perimeterCell(grid, i, j):
            result = 0
            if i == 0 or grid[i-1][j] == 0:
                result += 1
            if j == 0 or grid[i][j-1] == 0:
                result += 1
            if i == self.row - 1 or grid[i+1][j] == 0:
                result += 1
            if j == self.col - 1 or grid[i][j+1] == 0:
                result += 1
            return result
        result = 0
        for i in range(self.row):
            for j in range(self.col):
                if grid[i][j]:
                    result += perimeterCell(grid, i, j)
        return result