计算n阶行列式

计算n阶行列式

实现原理：拉普拉斯展开式。

分析：我们分析拉普拉斯展开式会发现，这个就是一个递归的过程，因为它存在最小子项。

c++ 版

#include<bits/stdc++.h>
using namespace std;

// 每次进来的余子项是不断变小的 然后行数k也是不断变小的
vector<vector<int> >surplus(vector<vector<int> > arr, int k)
{
    vector<vector<int> > tmp; // 这个tmp就是最后筛选过后生成的更小的矩阵
    for (int i = 1; i < arr.size(); ++i) // 根据拉普拉斯定理，这里是从行列式的第二行开始
    {
        vector<int> t; // 经过筛选之后的每一行存放到这里面 
        for (int j = 0; j < arr[0].size(); ++ j)
        {
        	// 根据拉普拉斯公式，会在生成子矩阵的时候，会过滤掉列号相同的，这里的k就是列号
            if (j == k) continue; 
            t.push_back(arr[i][j]);
        }
        tmp.push_back(t);
    }
    return tmp;
}
int func(vector<vector<int> > arr, int n)
{
    int res = 0;
    // 当行列式的n为1的时候，那么就是直接放回这个行列式的值
    if (n == 1) return arr[0][0];
    // 如果n为2的时候 就是交叉相乘再相减    
    else if (n == 2) return arr[0][0] * arr[1][1] - arr[0][1] * arr[1][0];
    else
    {
    // 然后就是剩下的情况，很显然这是用的递归的思路来做的
        for (int i = 0; i < n; i ++) res += pow(-1, i) * arr[0][i] * func(surplus(arr, i), n - 1);
    }   // surplus函数就是计算余子式的
    return res;
}
int main()
{
    int n;
    vector<vector<int> > arr;
    cout << "请输入你要计算的行列式的行数：";
    cin >> n;
    for (int i = 0; i < n; i ++)
    {
        cout << "第" << i + 1 << "行：";
        vector<int> tmp;
        for (int j = 0; j < n; j ++)
        {
            int t;
            cin >> t;
            tmp.push_back(t);
        }
        arr.push_back(tmp);
    }
    int res = 0;
    res = func(arr, n);
    cout << res << endl;
    return 0;
}

JAVA版

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        int[][] arr = new int[n][n];
        for (int i = 0; i < n; i++) {
            String[] s = scanner.nextLine().split(" ");
            for (int j = 0; j < n; j++) {
                arr[i][j] = Integer.parseInt(s[j]);
            }
        }
        int res;
        res = function(arr, n);
        System.out.println(res);
    }

    //递归函数
    private static int function(int[][] arr, int n) {
        int res=0;
        if (n==1){
            return arr[0][0];
        }else if (n==2){
            //递归终止条件
            return arr[0][0]*arr[1][1]-arr[0][1]*arr[1][0];
        }else {
            //递归
            for (int i=0;i<n;i++){
                res+=Math.pow(-1,i)*arr[0][i]*function(yuzishi(i,arr),n-1);
            }
        }
        return res;
    }
    //得到对应的余子式
    private static int[][] yuzishi(int i,int[][] arr){
        int[][] temp=new int[10][10];
        for (int k=1;k<arr.length;k++){
            for (int j=0,y=0;j<arr[0].length;j++){
                if (j==i){
                    continue;
                }
                temp[k-1][y++]=arr[k][j];
            }
        }
        return temp;
    }
}

Python 版

import math
def surplus(arr, k, n):
    temp = [[0] * n for i in range(n)]
    for i in range(1, n):
        t = 0
        for j in range(n):
            if (j == k):
                continue
            temp[i - 1][t] = arr[i][j]
            t += 1
    return temp

def func(arr, n):
    if (n == 1):
        return arr[0][0]
    elif (n == 2):
        return arr[0][0] * arr[1][1] - arr[0][1] * arr[1][0]
    else:
        res = 0
        for i in range(n):
            res += math.pow(-1, i) * arr[0][i] * func(surplus(arr, i, n), n - 1)
    return res

n = int(input())
s = [0] * n
for i in range(n):
    t = list(map(int, input().split()))
    s[i] = t 
res = func(s, n)    
print(res)