java使用递归法求n的乘

Java使用递归法求n的阶乘可以通过以下代码实现：

public class Useself {
    public static int maths(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * maths(n - 1);
        }
    }
}

在上述代码中，我们定义了一个静态方法`maths`，该方法接受一个整数参数n，返回n的阶乘。在方法内部，我们使用了递归的方式来计算n的阶乘。当n等于1时，递归结束，返回1；否则，递归调用`maths(n - 1)`来计算n-1的阶乘，然后将n乘以该结果，得到n的阶乘。

在主函数中，我们可以使用以下代码来调用`maths`方法并输出结果：

public class Main {
    public static void main(String[] args) {
        int n = 5;
        System.out.println("调用递归算法计算阶乘的结果是：" + Useself.maths(n));
    }
}

输出结果为：

调用递归算法计算阶乘的结果是：120

相关问题

矩阵连乘问题备忘录法java

矩阵连乘问题是一个著名的动态规划问题，备忘录法是其中一种解决方法。以下是Java实现代码：

public class MatrixChainMultiplication {
    static int[][] dp;
    static int[] p;
    public static void main(String[] args) {
        p = new int[]{30, 35, 15, 5, 10, 20, 25};
        int n = p.length;

        dp = new int[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(dp[i], -1);
        }

        System.out.println(matrixChainOrder(1, n - 1));
    }

    static int matrixChainOrder(int i, int j) {
        if (dp[i][j] != -1) {
            return dp[i][j];
        }

        if (i == j) {
            dp[i][j] = 0;
        } else {
            dp[i][j] = Integer.MAX_VALUE;
            for (int k = i; k < j; k++) {
                dp[i][j] = Math.min(dp[i][j], matrixChainOrder(i, k) + matrixChainOrder(k + 1, j) + p[i - 1] * p[k] * p[j]);
            }
        }
        return dp[i][j];
    }
}

其中，p数组代表每个矩阵的行数或列数，dp数组记录中间结果。matrixChainOrder方法使用递归实现，如果dp数组中已有结果则直接返回，否则根据递推式计算出dp[i][j]的值并存入数组中。最终返回dp[1][n-1]即可。

n！=1*2*3*.....*n; 求只含有奇数的1*3*5*7*9*11*......*n的最后一位； n属于long long int 范围 （保证n为奇数）java

根据引用中的要求，不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）来求n的阶乘。但是可以使用递归和逻辑运算符来实现。具体实现如下：

public int factorial(int n) {
    boolean flag = n > 0 && (n += factorial(n - 1)) > 0;
    return n;
}

对于只含有奇数的1*3*5*7*9*11*......*n，可以发现每一项都是3的倍数，因此只需要求出n/3的余数即可知道最后一位是多少。具体实现如下：

public int lastDigitOfOddFactorial(long n) {
    return (int) Math.pow(2, n / 2) * (n % 2 == 0 ? 1 : -1) % 10;
}