Matrix

【問題描述】

   矩陣是線性代數中的重要概念，應用領域非常廣泛，在C/C++中，通常將矩陣定義為一個二維陣列。

   本問題中，將輸入兩個矩陣 A 和 B，實現對矩陣的數乘、矩陣加法、矩陣乘法以及行列式的計算。

   如果對矩陣的演算法不瞭解，請查閱相關資料。

【輸入形式】

   輸入的第一行為兩個正整數 M 和 N，分別表示矩陣 A 的行數和列數；

   接下來的 M 行，每行 N 個用空格分隔的整數，表示矩陣 A 的元素值；

   接下來的一行，為一個整數 x,  用於對矩陣 A 進行數乘；

   接下來的一行為兩個正整數 K 和 L, 分別表示矩陣 B 的行數和列數；

   接下來的 K 行，每行為 L 個用空格分隔的整數，表示矩陣 B 的元素值。

【輸出形式】

   輸出的第一部分為 M 行，每行為 N 個用空格分隔的整數，表示 x 數乘 A 的結果；

   接下來(如果有），如果 A 和 B 可以相加，則輸出 M 行，每行為 N 個用空格分隔的整數，表示矩陣 A+B 的結果；

   接下來(如果有），如果 A 和 B 可以相乘，則輸出 M 行，每行為 L 個用空格分隔的整數，表示矩陣 A×B 的結果；

   接下來一行(如果有），如果 A 的行列式存在，則輸出一個整數，表示 A 的行列式的值；

   接下來一行(如果有），如果 B 的行列式存在，則輸出一個整數，表示 B 的行列式的值。

【樣例輸入1】

2 2
29 51
7 84
9
2 9
1 1 4 8 5 7 4 5 9
2 5 5 1 6 1 4 8 6
【樣例輸出1】

261 459
63 756
131 284 371 283 451 254 320 553 567
175 427 448 140 539 133 364 707 567
2079
【樣例輸入2】

5 3
71 15 54
24 56 8
61 34 50
82 94 88
48 7 43
3
5 3
2 1 5
1 7 1
0 1 6
4 1 9
2 8 7
【樣例輸出2】

213 45 162
72 168 24
183 102 150
246 282 264
144 21 129
73 16 59
25 63 9
61 35 56
86 95 97
50 15 50
【樣例輸入3】

4 4
55 73 66 16
57 65 43 25
61 3 15 4
16 94 82 48
7
4 4
6 3 6 7
7 9 5 4
8 3 1 5
5 9 1 3
【樣例輸出3】

385 511 462 112
399 455 301 175
427 21 105 28
112 658 574 336
61 76 72 23
64 74 48 29
69 6 16 9
21 103 83 51
1449 1164 777 1055
1266 1110 735 949
527 291 400 526
1650 1572 696 1042
-2657450
-783
【樣例輸入4】

5 5
0 51 71 79 28
3 10 66 36 57
23 21 6 27 85
1 21 49 62 31
54 31 47 64 21
11
4 3
3 4 5
2 6 0
7 3 9
5 6 9
【樣例輸出4】

0 561 781 869 308
33 110 726 396 627
253 231 66 297 935
11 231 539 682 341
594 341 517 704 231
-299004213
【樣例說明】
【評分標準】
由於&&的存在，在dev上執行會報錯

#include  <iostream>
#include  <cstdlib>
using  namespace  std;
class  matrix
{
private:
        int  rows,  cols;
        int  **p;//二級指標 
public:
        matrix();
        matrix(int  &M,int  &N);
        matrix(matrix  &A,int &&m,int  &n);//&&右值引用，看能不能對錶達式取地址，如果能，則為左值，否則為右值 
        ~matrix();

        matrix  multi(int  x);  //  數乘
        int  det();             //  計算行列式
        void  out();            //輸出矩陣
        void  input();

        matrix  operator+(matrix  &another);  //過載加法運算實現矩陣相加
        matrix  operator*(matrix  &another);  //過載乘法運算實現矩陣相乘
};

matrix::matrix(int  &M,  int  &N)
{
        rows=M,cols=N;//行為M，列為N 
        p=new  int*[rows];//建立一個指標，指向一個指標陣列，指標陣列中的每一個指標又指向一個動態一維陣列。
        //指標陣列，新開闢M個記憶體空間，每個記憶體空間存放一個指標，該指標又指向一個一維陣列 
        for(int i=0;i<M;i++)
        {p[i]=new  int[cols];} //開闢空間，N是這個一維陣列的元素個數 
}

matrix::matrix(matrix  &A,int &&m,  int  &n)//從矩陣A中刪除第m行第n列後得到新的矩陣,這一步用於求行列式，利用拉普拉斯展開 
{   rows=A.rows-1;//新生成的物件A第m行n列被刪除，所以行數列數都要-1 
    cols=A.cols-1;
	p=new int*[rows];//同上開闢空間 
	for(int i=0;i<rows;i++){
		p[i]=new int[cols];
	}
	for(int i=0;i<rows;i++){//由下面求行列式的步驟知m傳入為0，所以每次都是刪除第一行的第n列，所以只要考慮需要賦值的陣列在n列前還是n列後就好 
		for(int j=0;j<cols;j++){
			if(j<n){
			p[i][j]=A.p[i+1][j];//比如n為1，當j等於0時，則原來第二行第一列的元素變成第一行第一列即可，列不用改變 
			}
			else
			{p[i][j]=A.p[i+1][j+1];//加入j為2，則原來第二行第三列的元素要變成第一行第二列，行列都要變 
			}
		}
	} 
	}


matrix::~matrix()
{for(int  i=0;i<rows;i++)
 delete[]  p[i];//先釋放指標陣列中的指標 
 delete[]  p;//再釋放指標陣列，相當於先刪行再刪列 
}

matrix  matrix::multi(int  x)//數乘
{
        matrix  tmp(rows,cols);
        for(int i=0;i<rows;i++){
        	for(int j=0;j<cols;j++){
        		tmp.p[i][j]=p[i][j]*x; 
			}
		}
         return  tmp;
}

void  matrix::out()        //輸出矩陣  逐行輸出，資料間用空格分隔
{   for(int i=0;i<rows;i++){
    for(int j=0;j<cols;j++){
    	cout<<p[i][j]<<' ';
	}
	cout<<endl;}                        
}

void  matrix::input()
{for(int  i=0;  i<rows;  i++)
        for(int  j=0;  j<cols;  j++)
                cin>>p[i][j];

}

matrix  matrix::operator+(matrix  &another)  //過載加法運算實現矩陣相加
{
        matrix  tmp(rows,  cols);
        /*  矩陣對應位置元素相加  */  
        for(int i=0;i<rows;i++){
        	for(int j=0;j<cols;j++){
        		tmp.p[i][j]=p[i][j]+another.p[i][j]; 
			}
		}
         return  tmp;
}

matrix  matrix::operator*(matrix  &another)    //過載乘法運算實現矩陣相乘
{
        matrix  tmp(rows,  another.cols);
        for(int  i=0;i<rows;i++){
        for(int  j=0;j<another.cols;j++) /*  計算A矩陣的第i行與B矩陣的第j列元素對應相乘後之和，作為新矩陣的第i行第j列元素的值  */
       {int sum=0;//i=0時，p的第一行乘以another的第一列 
        for(int k=0;k<cols;k++){//p第一行每一列的元素乘以another第一列每一行的元素 
        sum+=p[i][k]*another.p[k][j];//p的列數一定等於another的行數才能矩陣相乘 
		}             
        tmp.p[i][j]=sum;           
		}
        }
        return  tmp;
}

int  matrix::det()
{
        if  (rows==1)
        return  p[0][0];//行數不能為1 
        else
        {int  result=0,  flag;
        for(int  i=0;  i<cols;  i++)
        {
        flag=(i%2)?-1:1;//如果i%2==0則flag為-1，不然就為1，flag是用來判斷正負號
		//從第一行展開，(-1)^1+列數，如果列數是奇數那麼最後為+，如果是偶數最後為-
        matrix  tmp(*this,0,i);
        result=result+flag*p[0][i]*tmp.det();//使用代數餘子式求行列式的值,遞迴，可以理解為不斷拉普拉斯展開 
        }
        return  result;
        }
}
int  main()
{
        int  M,N;
        //  A矩陣的行和列
        cin>>M>>N;
        matrix  mA(M,N);//生成A矩陣
        //  輸入矩陣值
        mA.input();
        //  輸入數乘值
        int  x;
        cin>>x;
        matrix  mm1=mA.multi(x);
        mm1.out();
        //B矩陣的行和列
        int  K,  L;
        cin>>K>>L;
        matrix  mB(K,  L);    //生成B矩陣
        mB.input();
        /*  求矩陣A和矩陣B的和  */
        if  (M==K  &&  N==L)
        {matrix  mm2=mA+mB;
         mm2.out();
        }
      /*  求矩陣A和矩陣B的乘積矩陣  */
        if  (N==K)
        {matrix  mm3=mA*mB;
         mm3.out();
        }
        /*  矩陣A的行列式的值  */
        if  (M==N)//行列式必須是行數等於列數 
                cout<<mA.det()<<endl;
        if  (K==L)
                cout<<mB.det()<<endl;
        return  0;
}