计算n阶行列式

Myth丶恋晨 2024-03-31 13:10 62阅读 0赞

## 计算n阶行列式 ##

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

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

![在这里插入图片描述][5f8487da323e4c22985adbc95cc509c1.png]

### 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)

[5f8487da323e4c22985adbc95cc509c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d6c010ec0a2e4f2bae24597f0337237c.png