动态规划之最大正方形

最大的以 1 为边界的正方形

给你一个由若干 0 和 1 组成的二维网格 grid，请你找出边界全部由 1 组成的最大 正方形 子网格，并返回该子网格中的元素数量。如果不存在，则返回 0。

[leetcode]

    public int largest1BorderedSquare(int[][] grid) {
        int n = grid.length;
        int[] dp = new int[n];
        for(int i=0;i<n;++i) {
          int[] g = grid[i];
          for(int j=0; j<g.length; ++j) {
              if (g[j]==1) {

                  int k = 0;
                  int m = 0;
                  while(i-k>=0&&j-k>=0) {
                      boolean flag = true;
                      for(int x=i-k;x<=i;++x) {
                          if (grid[x][j-k] != 1) {
                              flag = false;
                              break;
                          }
                      }

                      if(flag) {
                          for(int x=i-k;x<=i;++x) {
                              if (grid[x][j] != 1) {
                                  flag = false;
                                  break;
                              }
                          }
                      }

                      if(flag) {
                          for(int x=j-k;x<=j;++x) {
                              if (grid[i-k][x] != 1) {
                                  flag = false;
                                  break;
                              }
                          }
                      }

                      if (flag) {
                          for(int x=j-k;x<=j;++x) {
                              if (grid[i][x] != 1) {
                                  flag = false;
                                  break;
                              }
                          }
                      }



                      k++;
                      if (flag) {
                        m = k;
                      }
                  }



                  dp[i] = Math.max(m*m, dp[i]);
              }
          }

          if(i>0) dp[i] = Math.max(dp[i-1], dp[i]);
        }

        return dp[n-1];
    }

最大正方形

在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。

leetcode

    public int maximalSquare(char[][] matrix) {
        int n = matrix.length;
        int[] dp = new int[n];
        for(int i=0;i<n;++i) {
            char[] g = matrix[i];
            for(int j=0; j<g.length; ++j) {
                if (g[j]=='1') {

                    int k = 0;
                    boolean flag = true;
                    while(i-k>=0&&j-k>=0&&flag) {

                        for(int x=i-k;x<=i;++x) {
                            if (matrix[x][j-k] != '1') {
                                flag = false;
                                break;
                            }
                        }

                        if(flag) {
                            for(int x=i-k;x<=i;++x) {
                                if (matrix[x][j] != '1') {
                                    flag = false;
                                    break;
                                }
                            }
                        }

                        if(flag) {
                            for(int x=j-k;x<=j;++x) {
                                if (matrix[i-k][x] != '1') {
                                    flag = false;
                                    break;
                                }
                            }
                        }

                        if (flag) {
                            for(int x=j-k;x<=j;++x) {
                                if (matrix[i][x] != '1') {
                                    flag = false;
                                    break;
                                }
                            }
                        }


                        if(flag){
                            k++;
                        }
                    }



                    dp[i] = Math.max(k, dp[i]);
                }
            }

            if(i>0) dp[i] = Math.max(dp[i-1], dp[i]);
        }

        if(n>0) return dp[n-1]*dp[n-1];
        else return 0;
    }