代码1：

1. 第一个两层for，分配空间的同时初始化dp
2. maxside维护当前最大正方形的边长
3. 第二个两层for，一步一步从小问题推往大问题，动态规划步骤

状态转移式 ：
matrix【i】【j】 == 0，则dp【i】【j】 = 0
matrix【i】【j】 == 1，则dp【i】【j】 = dp[i][j] = min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1]) + 1 等于1的时候同时维护一下maxside

func maximalSquare(matrix [][]byte) int {
    dp := make([][]int, len(matrix))
    maxSide := 0
    for i := 0; i < len(matrix); i++ {
        dp[i] = make([]int, len(matrix[i]))
        for j := 0; j < len(matrix[i]); j++ {
            dp[i][j] = int(matrix[i][j] - '0')
            if dp[i][j] == 1 {
                maxSide = 1
            }
        }
    }

    for i := 1; i < len(matrix); i++ {
        for j := 1; j < len(matrix[i]); j++ {
            if dp[i][j] == 1 {
                dp[i][j] = min(min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1
                if dp[i][j] > maxSide {
                    maxSide = dp[i][j]
                }
            }
        }
    }
    return maxSide * maxSide
}

func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

代码2：

1. 代码2没有在初始化的同时扩容，并且没有将所有mat里的数据导入到dp中
2. min函数写错，正确为min2，或者写成min1那种形式

func maximalSquare(mat [][]byte) int {
    ans := 0
    m := len(mat)
    n := len(mat[0])
    dp := make([][]int,m)
    for i := range dp {
        dp[i] = make([]int,n)
    }
    for i := 0; i < m; i++ {
        dp[i][0] = int(mat[i][0] - '0')
        if mat[i][0] == '1' {
            ans = 1
        }
    }
    for i := 0; i < n; i++ {
        dp[0][i] = int(mat[0][i] - '0')
        if mat[0][i] == '1' {
            ans = 1
        }
    }
    for i := 1; i < m; i++ {
        for j := 1; j < n; j++ {
            if mat[i][j] == '0' {
                dp[i][j] = 0
            }else {
                //dp[i][j] = min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1]) + 1
                dp[i][j] = min1(dp[i-1][j],min1(dp[i][j-1],dp[i-1][j-1])) + 1
                ans = max(ans,dp[i][j])
            }
        }
    }
    return ans * ans
}
func min(a,b,c int) int {
    if a < b && a < c {
        return a
    }
    if b < a && b < c {
        return b 
    }
    return c
}

func min2(a,b,c int) int {
    if a <= b && a <= c {
        return a
    }
    if b <= a && b <= c {
        return b 
    }
    return c
}

func min1(a,b int) int {
    if a < b {
        return a
    }
    return b
}

func max(a,b int) int {
    if a < b {
        return b 
    }
    return a
}