用java写出下面题目：将mxn大小的矩形分成若干个正方形，求出最小的正方形个数

以下是用 Java 实现的代码，使用了递归和动态规划：

public class MinSquareNumber {
    public int minSquare(int m, int n) {
        // base case: 如果矩形为正方形，则返回 1
        if (m == n) {
            return 1;
        }
        
        // 动态规划
        int[][] dp = new int[m+1][n+1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == j) {
                    dp[i][j] = 1;
                } else {
                    dp[i][j] = Integer.MAX_VALUE;
                }
                for (int k = 1; k <= i/2; k++) {
                    dp[i][j] = Math.min(dp[i][j], dp[i-k][j] + dp[k][j]);
                }
                for (int k = 1; k <= j/2; k++) {
                    dp[i][j] = Math.min(dp[i][j], dp[i][j-k] + dp[i][k]);
                }
            }
        }
        
        return dp[m][n];
    }
    
    // 递归实现
    public int minSquareRec(int m, int n) {
        // base case: 如果矩形为正方形，则返回 1
        if (m == n) {
            return 1;
        }
        
        int res = Integer.MAX_VALUE;
        // 枚举所有可能的正方形大小
        for (int i = 1; i <= Math.min(m, n); i++) {
            // 分割成两个矩形，递归求解
            int left = minSquareRec(i, n);
            int right = minSquareRec(m-i, n);
            res = Math.min(res, left + right);
            
            // 分割成两个矩形，递归求解
            int top = minSquareRec(m, i);
            int bottom = minSquareRec(m, n-i);
            res = Math.min(res, top + bottom);
        }
        
        return res;
    }
}

其中 `minSquare()` 方法使用了动态规划，时间复杂度为 $O(m^2n^2)$，空间复杂度为 $O(mn)$；`minSquareRec()` 方法使用了递归，时间复杂度为 $O(\min(m,n)^{\max(m,n)})$，空间复杂度为 $O(\max(m,n))$。在实际应用中，推荐使用动态规划方法。