算法与竞赛(第15章) - 矩阵高级运算

最新推荐文章于 2024-10-02 23:40:03 发布
最新推荐文章于 2024-10-02 23:40:03 发布
阅读量620 收藏 11
点赞数 7
分类专栏： educoder 文章标签： 算法 矩阵 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75078332/article/details/131808799
版权

第1关：矩阵（方阵）行列式

//
//  main.cpp
//  step1
//
//  Created by ljpc on 2018/11/29.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include <iostream>
#include <algorithm>

using namespace std;

int det(int n, int** mat)
{
    int mov = 0;
    int flag;
    int sum = 0;
    if (n == 1) return mat[0][0];
    int** b = new int* [n - 1];
    for (int z = 0; z < n - 1; ++z)
        b[z] = new int[n - 1];
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n - 1; ++j) {
            mov = i > j ? 0 : 1;
            for (int k = 0; k < n - 1; ++k)
                b[j][k] = mat[j + mov][k + 1];
        }
        if (i % 2 == 0) flag = 1;
        else flag = -1;
        sum += flag * mat[i][0] * det(n - 1, b);
    }
    delete[] b;
    return sum;
}

struct Matrix {
    int m, n;
    int** val;
    Matrix() {}
    Matrix(int m_, int n_) {
        m = m_;
        n = n_;
        this->val = (int**)malloc(sizeof(int*) * m);
        for (int i = 0; i < m; i++) {
            this->val[i] = (int*)malloc(sizeof(int) * n);
        }
    }
    void in() {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                scanf("%d", &this->val[i][j]);
            }
        }
    }
    void out() {
        for (int i = 0; i < m; i++) {
            printf("%d", this->val[i][0]);
            for (int j = 1; j < n; j++) {
                printf(" %d", this->val[i][j]);
            }
            printf("\n");
        }
    }
    int Determinant_1() {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        return val[0][0];
        /********* End *********/
    }
    int Determinant_2() {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        return (val[0][0] * val[1][1] - val[0][1] * val[1][0]);
        /********* End *********/
    }
    int Determinant_3() {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        int left = val[0][0] * val[1][1] * val[2][2] + val[0][1] * val[1][2] * val[2][0] + val[1][0] * val[2][1] * val[0][2];
        int right = val[2][0] * val[1][1] * val[0][2] + val[1][0] * val[0][1] * val[2][2] + val[2][1] * val[1][2] * val[0][0];
        return left - right;
        /********* End *********/
    }
    int Inverse_Number(int n, int arr[]) {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        int count = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                if (arr[i] > arr[j]) {
                    count++;
                    break;
                }
            }
        }
        return count;
        /********* End *********/
    }
    int Determinant_n() {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        int res = det(this->n, this->val);
        return res;
        /********* End *********/
    }

    int Determinant() {
        if (this->n == 1) {
            return Determinant_1();
        }
        else if (this->n == 2) {
            return Determinant_2();
        }
        else if (this->n == 3) {
            return Determinant_3();
        }
        else {
            return Determinant_n();
        }
    }

};

int main(int argc, const char* argv[]) {

    int n;
    scanf("%d", &n);
    Matrix A(n, n);
    A.in();

    int det = A.Determinant();
    printf("Det(A)=%d\n", det);

    return 0;
}

第2关：矩阵逆运算

//
//  main.cpp
//  step2
//
//  Created by ljpc on 2018/11/29.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include <iostream>
#include <algorithm>

using namespace std;

#define eps 1e-8
inline int sig(double x){return (x>eps)-(x<-eps); }

struct Matrix{
    int m, n;
    double **val;
    Matrix(){}
    Matrix(int m_, int n_){
        m = m_;
        n = n_;
        this->val = (double**)malloc(sizeof(double*)*m);
        for(int i=0;i<m;i++){
            this->val[i] = (double*)malloc(sizeof(double)*n);
        }
    }
    void in(){
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                scanf("%lf", &this->val[i][j]);
            }
        }
    }
    void out(){
        for(int i=0;i<m;i++){
            printf("%.4lf", this->val[i][0]);
            for(int j=1;j<n;j++){
                printf(" %.4lf", this->val[i][j]);
            }
            printf("\n");
        }
    }
    Matrix operator * (const double r)const{
        int m_ = this->m;
        int n_ = this->n;
        Matrix A = *this;
        Matrix M(m_, n_);
        for(int i=0;i<m_;i++){
            for(int j=0;j<n_;j++){
                M.val[i][j] = A.val[i][j] * r;
            }
        }
        return M;
    }
    Matrix operator * (const Matrix B)const{
        Matrix A = *this;
        Matrix M(A.m, B.n);
        if(A.n!=B.m){
            printf("error\n");
        }
        for(int i=0;i<A.m;i++){
            for(int j=0;j<B.n;j++){
                double sum = 0;
                for(int k=0;k<A.n;k++){
                    sum += A.val[i][k] * B.val[k][j];
                }
                M.val[i][j] = sum;
            }
        }
        return M;
    }
    int Inverse_Number (int n, int arr[]) {
        int num = 0;
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                if(arr[j]>arr[i]){
                    num++;
                }
            }
        }
        return num;
    }
    double Determinant () {
        Matrix D = *this;
        double det = 0;
        int *arr;
        arr = (int*)malloc(sizeof(int)*D.n);
        for(int i=0;i<D.n;i++){
            arr[i] = i;
        }
        do{
            int inv = Inverse_Number(D.n, arr);
            double tmp = (inv%2==0)?1:-1;
            for(int i=0;i<D.n;i++){
                tmp *= D.val[i][arr[i]];
            }
            det += tmp;
        }while(next_permutation(arr, arr+D.n));
        return det;
    }
    
    
    double Cofactor (int x, int y) {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        Matrix C = Matrix(this->n-1,this->n-1);
        for(int i=0;i<x;i++){
            for(int j=0;j<y;j++){
                C.val[i][j] = this->val[i][j];
            }
        }
        for(int i=0;i<x;i++){
            for(int j=y+1;j<this->n;j++){
                C.val[i][j-1] = this->val[i][j];
            }
        }
        for(int i=x+1;i<this->n;i++){
            for(int j=0;j<y;j++){
                C.val[i-1][j] = this->val[i][j];
            }
        }
        for(int i=x+1;i<this->n;i++){
            for(int j=y+1;j<this->n;j++){
                C.val[i-1][j-1] = this->val[i][j];
            }
        }
        double det_c = C.Determinant();
        return det_c;
        /********* End *********/
    }
    
    Matrix Adjugate_Matrix () {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        Matrix A = Matrix(this->n, this->n);
        for(int i=0;i<A.n;i++){
            for(int j=0;j<A.n;j++){
                int flag = ((i+j)%2==0)?1:-1;
                int M_ij = Cofactor(i, j);
                A.val[j][i] = flag * M_ij;
            }
        }
        return A;
        /********* End *********/
    }
    
    Matrix Inverse_Matrix (){
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        double det = Determinant();
        if(det == 0){
            printf("error\n");
            return Matrix();
        }
        Matrix I = Matrix(this->n, this->n);
        Matrix A = Matrix(this->n, this->n);
        A = Adjugate_Matrix();
        I = A * (1./det);
        return I;
        /********* End *********/
    }
    
    bool Identity_Matrix() {
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        for(int i=0;i<this->n;i++){
            for(int j=0;j<this->n;j++){
                if(i==j){
                    if(sig(this->val[i][j]-1)!=0){
                        return false;
                    }
                }else {
                    if(sig(this->val[i][j]-0)!=0){
                        return false;
                    }
                }
            }
        }
        return true;
        /********* End *********/
    }
    
};

int main(int argc, const char * argv[]) {
    
    int n;
    scanf("%d", &n);
    Matrix A(n,n);
    A.in();
    
    Matrix I(n,n);
    I = A.Inverse_Matrix();
    I.out();
    
    Matrix E1(n,n);
    Matrix E2(n,n);
    E1 = A*I;
    E2 = I*A;
    if(E1.Identity_Matrix()==false){
        printf("A*I error\n");
        E1.out();
    }
    if(E2.Identity_Matrix()==false){
        printf("I*A error\n");
        E2.out();
    }
    
    return 0;
}

 第3关：矩阵初等变换

 

//
//  main.cpp
//  step3
//
//  Created by ljpc on 2018/11/29.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include <iostream>
#include <algorithm>

using namespace std;

#define eps 1e-8
inline int sig(double x){return (x>eps)-(x<-eps); }

struct Matrix{
    int m, n;
    double **val;
    Matrix(){}
    Matrix(int m_, int n_){
        m = m_;
        n = n_;
        this->val = (double**)malloc(sizeof(double*)*m);
        for(int i=0;i<m;i++){
            this->val[i] = (double*)malloc(sizeof(double)*n);
        }
    }
    void in(){
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                scanf("%lf", &this->val[i][j]);
            }
        }
    }
    void out(){
        for(int i=0;i<m;i++){
            printf("%.4lf", this->val[i][0]+eps);
            for(int j=1;j<n;j++){
                printf(" %.4lf", this->val[i][j]+eps);
            }
            printf("\n");
        }
    }
    
    Matrix Elementary_Row_Transformation (){
        
        Matrix R = Matrix(this->n, this->n*2);
        for(int i=0;i<this->n;i++){
            for(int j=0;j<this->n;j++)
                R.val[i][j] = this->val[i][j];
            for(int j=this->n;j<this->n*2;j++)
                R.val[i][j] = ((j-this->n)==i)?1:0;
        }
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
        for(int i=0;i<R.m;i++){
            double flag = R.val[i][i];
            for(int j=i;j<R.n;j++){
                R.val[i][j] /= flag;
            }
            for(int k=i+1;k<R.m;k++){
                flag = R.val[k][i];
                for(int j=i;j<R.n;j++){
                    R.val[k][j] -= flag * R.val[i][j];
                }
            }
        }
       
        for(int i=R.m-1;i>=0;i--){
            double flag = R.val[i][i];
            for(int j=i;j<R.n;j++){
                R.val[i][j] /= flag;
            }
            for(int k=i-1;k>=0;k--){
                flag = R.val[k][i];
                for(int j=k;j<R.n;j++){
                    R.val[k][j] -= flag * R.val[i][j];
                }
            }
        }

        /********* End *********/
        
        return R;
    }
    
    Matrix Elementary_Col_Transformation (){
        
        Matrix C = Matrix(this->n*2, this->n);
        for(int j=0;j<this->n;j++){
            for(int i=0;i<this->n;i++)
                C.val[i][j] = this->val[i][j];
            for(int i=this->n;i<this->n*2;i++)
                C.val[i][j] = ((i-this->n)==j)?1:0;
        }
        // 请在这里补充代码，完成本关任务
        /********* Begin *********/
          for(int j=0;j<C.n;j++){
            double flag = C.val[j][j];
            for(int i=j;i<C.m;i++){
                C.val[i][j] /= flag;
            }
            for(int k=j+1;k<C.n;k++){
                flag = C.val[j][k];
                for(int i=j;i<C.m;i++){
                    C.val[i][k] -= flag * C.val[i][j];
                }
            }
        }
        
        for(int j=C.n-1;j>=0;j--){
            double flag = C.val[j][j];
            for(int i=j;i<C.m;i++){
                C.val[i][j] /= flag;
            }
            for(int k=j-1;k>=0;k--){
                double flag = C.val[j][k];
                for(int i=j;i<C.m;i++){
                    C.val[i][k] -= flag * C.val[i][j];
                }
            }
        }

        /********* End *********/
        
        return C;
    }
};

int main(int argc, const char * argv[]) {

    int n;
    scanf("%d", &n);
    Matrix A(n,n);
    A.in();
    
    Matrix R = Matrix(n, n*2);
    R = A.Elementary_Row_Transformation();
    R.out();
    printf("\n");
    
    Matrix C = Matrix(n*2, n);
    C = A.Elementary_Col_Transformation();
    C.out();
    printf("\n");
    
    return 0;
}

k3m1n9
关注
专栏目录
Mathorcup数学建模竞赛第五届-【妈妈杯】A题：基于群智能算法的改进 Webster 交通信号配时优化模型（附一等奖获奖论文和matlab代码实现）
getusushu的博客
12-27 2892
随着我国城市化速度的加快以及城市规模的不断扩大，交通供需矛盾日益突出，在城市交通网络中产生的交通拥堵现象日趋严重，严重影响了社会经济的发展和人民生活水平的提高。为了提高城市道路交通管理水平，改善城市交通秩序，保障公路交通的畅通与安全，当今世界各国普遍使用智能交通系统。在该系统中，核心的问题是交通信号智能控制。平面交叉口是道路交通的主要冲突点，不仅机动车数量多，而且行人和非机动车也在同一平面通过。目前在我国的大、中型城市交通管理中，普遍采用的是单点定时交通信号灯控制。
《算法竞赛进阶指南》矩阵
qq_42635159的博客
09-10 406
矩阵 给定一个M行N列的01矩阵（只包含数字0或1的矩阵），再执行Q次询问，每次询问给出一个A行B列的01矩阵，求该矩阵是否在原矩阵中出现过。 输入格式 第一行四个整数M,N,A,B。 接下来一个M行N列的01矩阵，数字之间没有空格。 接下来一个整数Q。 接下来Q个A行B列的01矩阵，数字之间没有空格。 输出格式 对于每个询问，输出1表示出现过，0表示没有出现过。 数据范围 A≤100，M,N,B≤1000，Q≤1000 输入样例： 3 3 2 2 111 000 111 3 11 00 11 11 00
动态规划之矩阵链乘法（第15章）
weixin_30905133的博客
03-09 300
实验室催促毕业论文进展，所以今天下午我得收拾一下，准备一下毕业论文需要弄的东西。 唉， 感觉自己就是太笨了。 ——题外话。 1.动态规划的原理 [1] 什么情况下使用动态规划？ 　　适合应用动态规方法的求解最优化问题应该具备两个要素：最优子结构和子问题重叠。使用动态规划方法求解最优化问题的第一步就是刻画最优解的结构。如果一个问题的最优解包含子问题的...
《算法竞赛进阶》学习笔记
Rose_max的博客
06-28 1054
N数码判定性问题 大意就是给你两个N数码（N为奇数），判定是否能互相转化的问题 首先展开成一维，空格不计 如 1 2 3 4 5 6 7 0 8转化为1 2 3 4 5 6 7 8 然后判断两个序列的逆序对数奇偶性是否相同，相同则有解 证明： 在空格左右移动的时候，展开序列不改变 在空格上下移动的时候，展开序列中有一个数会前移（后移）n-1位，由于n为奇数则n-1为偶数。于是改...
算法竞赛入门与进阶 （一）枚举
紫芝的博客
04-16 782
枚举1.关键点：不重复不遗漏2.优化：把多余的操作去掉例一：在一个N*N(N&lt;=100)矩阵中求一个最大的正方形使得该正方形的四个顶点都是有字符“#”构成。 #*#*********#*#*#*******#********#**hint：1.两个点确定一个正方形，然后判断其余两个点是否为“#”2.三个点确定一个矩形，若矩形边平行于坐标轴，则只需要两个点#include&lt;bits/...
C++矩阵运算
05-17
根据提供的文件信息，我们可以总结出以下关于“C++矩阵运算”的相关知识点： ### C++中的矩阵类设计 在本示例代码中，作者定义了一个名为`Matrix`的类来表示矩阵，并提供了各种矩阵操作的方法。这包括矩阵的加法、...
刘汝佳《算法竞赛入门经典》---总结
搬家啦x
01-04 2916
刘汝佳：《算法竞赛入门经典》 三步： 基本的数据结构+算法知识； 数论等数学基本知识； 锻炼联想建模能力、知识与实际相结合，解决实际问题！ 第一章：程序设计入门 1.a/b 当a、b为整数时，结果向中间位置靠拢；例如： -8/5 结果为 -1 ； 2.浮点数使用%.3lf 输出； 另外: 整数-浮点数=浮点数 整数/浮点数=浮点数； 3.在竞赛中尽量使用const
第5-3课：Dijkstra 算法
oRbIt 的专栏
09-22 802
Dijkstra 算法是有中文名字的，一般叫做“迪杰斯特拉算法”，该算法是求解单源最短路径问题的经典算法，算不上高效，但确实是最简单的算法。Dijkstra 算法并不难，很多算法书都有详细的说明，但是这些书基本上都是对着一个类似图（1）这样的图作为例子来演示算法。如果要理解算法的原理，通常这样做也就足够了，但是要实现一个可用的算法解决实际问题，还需要跨过几个门槛才行。首先要解决数据模型的问题...
C++ 动态创建二维数组int** B = new int* [n]；
weixin_41733275的博客
02-21 2365
#include <iostream> using namespace std; int main() { //动态创建一维数组 int* A = new int[10]; //int A[10]; //动态创建二维数组 int n = 10,m=10; int** B = new int* [n]; //int* B[n]=new int[m]; int B[n][m...
c 语言多维数组,35 C 语言中的多维数组 - C 语言基础教程
weixin_36340672的博客
05-21 238
C 语言中的多维数组与我们在数学中学习到的多维数组是一致的。如果你还不知道什么是多维数组也没有关系。多维数组可以看成是之前学习过的数组的扩展。它能让你完成一些仅仅依靠一维数组没有办法完成的事情。让很多事情完成的更为简单。1. 多维数组的声明多维数组可以看作是一维数组的扩展。所以，它的声明就是在之前学习的数组，也叫一维数组，之后继续添加大括号，如果添加一组大括号，那么称之为二维数组，以此类推，就构成...
《数学之美》第15章 矩阵运算和文本处理中的两个分类问题
wangsiji_buaa的博客
05-10 1697
1 文本和词汇的矩阵2 奇异值分解的方法和应用场景
ACM竞赛学习整理--矩阵运算
qq_21291397的博客
01-02 540
ACM竞赛学习整理–矩阵运算 了解矩阵类 【任务】 实现矩阵的基本变换 【接口】 结构体：Matrix 成员变量： int n,m 矩阵大小 int a[][] 矩阵内容 重载运算符： +、-、x 成员函数：void clear() 清空矩阵 【代码】 const int MAXN = 1010; const int MAXM = 1010; struct Matrix{ int n,...
《算法竞赛-训练指南》第一章-1.24-pre_二维矩阵求最小子矩阵（O(n^3)）
李硕
08-03 1542
整整一天都在研究这个题目，也总算弄出了一点头目，还有个三维的就从一维到三维全部都看了。我就记得以前我做过这样的题目，是求最大的子序列的和，不过有限制子序列的个数必须达到的数目，我记得当时做的，是用的贪心的思想做的。其实这种题目用贪心也是可以解决的，而且可以迅速的解决。 一会将我的一维数组的贪心的方法贴出来，现在讲一下二维数组的O(N^3)算法。 主要还是用到了sum（x,y）,表示的是
算法竞赛入门——字母重排
just_do_it567的博客
08-14 808
输入一个字典（用******结尾），然后在输入若干单词。每输入一个单词w，你都需要在字典中找到所有可以用w的字母重拍后得到的单词，并按照字典序从小到大的顺序在一行中输出（如果不存在，输出：（）。输入单词之间用空格或者是空行隔开，且所有的输入单词都由不超过6个小写字母组成。注意，字典中的单词不一定按字典序排列。 输入样例： trap given score refund only trap work
矩阵的行列式、秩的意义
热门推荐
lijiayu2015的博客
09-21 4万+
线性代数真是一个很抽象的东西，即使我们很多人都学过，但是我相信绝大部分的都不知道这是干嘛用的，找了不少资料，终于发现了这么一篇好文章，于是强烈希望可以和大家分享，帮助大伙进一步理解矩阵的行列式和秩的本质意义。 1 关于面积：         一种映射  大家会说，面积，不就是长乘以宽么，其实不然。我们首先明确，这里所讨论的面积，是欧几里得空间几何面积的基本单位：平行四边形的面积。平行四边形面积
【理论科学与实践技术】数学与经济管理中的学科与实用算法
最新发布
wnm23的专栏
10-02 795
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1218
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 791
排序是将多个数据，依指定的顺序进行排列的过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值