0.前言

本篇文章主要总结了矩阵的常见运算，以及Java中利用二维数组进行运算的实现

1.矩阵运算

1.矩阵加法

1. 运算前提：多个矩阵的行数和列数相同，我们称它们为同型矩阵，只有是同型矩阵才能进行加减运算。
2. 运算规则：两个矩阵相同位置的元素进行相加。

$$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]+\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]=\left[\begin{array}{ccc}2& 4& 6\\ 8& 10& 12\end{array}\right]$$

2.矩阵减法

1. 运算规则：同矩阵加法，对应元素相减即可。

3.矩阵乘法

1. 运算前提：两个矩阵的乘法仅当第一个矩阵的列数和另一个矩阵的行数相等。
2. 运算规则：两个矩阵，第一个矩阵的行和第二个矩阵的列对应元素相乘再相加，m 行 n 列的矩阵 * n 行 k 列的矩阵，得到一个 m 行 k 列的矩阵。
   $$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]\ast \left[\begin{array}{cc}1& 2\\ 3& 4\\ 5& 6\end{array}\right]=\left[\begin{array}{cc}1\ast 1+2\ast 3+3\ast 5=22& 1\ast 2+2\ast 4+3\ast 6=28\\ 4\ast 1+3\ast 5+6\ast 5=49& 4\ast 2+5\ast 4+6\ast 6=64\end{array}\right]=\left[\begin{array}{cc}22& 28\\ 49& 64\end{array}\right]$$

4.矩阵转置

1. 运算规则：将矩阵的第 i 行 第 j 列 转换为 第 j 行 第 i 列
   $${\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]}^T=\left[\begin{array}{cc}1& 4\\ 2& 5\\ 3& 6\end{array}\right]$$

2.Java实现

public class Matrix {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3}, {4, 5, 6}};
        int[][] b = {{1, 2}, {3, 4}, {5, 6}};

        System.out.println(Arrays.deepToString(randomMatrix(3, 2)));
    }

    /**
     * 生成随机矩阵 m行n列
     * @return
     */
    public static int[][] randomMatrix(int m, int n){
        int[][] ans = new int[m][n];
        // 生成随机矩阵
        Random rand = new Random();
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {
                ans[i][j] = rand.nextInt(10);
            }
        return ans;
    }


    /**
     * 矩阵加减法
     */
    public static int[][] addOrSub(int[][] a, int[][] b, boolean isPlus) {
        // 不满足加减法条件
        if (a.length != b.length || a[0].length != b[0].length) return new int[0][0];

        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[0].length; j++) {
                if (isPlus)
                    a[i][j] += b[i][j];
                else
                    a[i][j] -= b[i][j];
            }
        return a;
    }

    /**
     * 矩阵乘法
     */
    public static int[][] multiply(int[][] a, int[][] b) {
        int m = a.length;
        int n = a[0].length;
        int n1 = b.length;
        int k = b[0].length;
        // 不满足乘法条件
        if (n != n1) return new int[0][0];

        // 构建一个 m 行 k 列的矩阵
        int[][] ans = new int[m][k];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < k; j++) {
                int temp = 0;
                for (int l = 0; l < n; l++) {
                    temp += a[i][l] * b[l][j];
                }
                ans[i][j] = temp;
            }
        }
        return ans;
    }

    /**
     * 转置
     */
    public static int[][] zhi(int[][] a) {
        int m = a.length;
        int n = a[0].length;
        int[][] ans = new int[n][m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                ans[i][j] = a[j][i];
        return ans;
    }
}

import java.util.Random;


class MatrixTower {


    public static void main(String[] args) {

        //声明一个矩阵空间
        int[][] matrix = new int[][]{
                {-1,12,4,0,7,-5,6,7,7,4,0,0,-5,2,-4},
                {-1,65,4,0,7,-5,6,1,7,4,0,0,-15,1,-4},
                {-1,10,4,0,8,-5,2,5,17,4,0,0,-5,6,-4},
                {-1,2,4,0,14,-5,6,3,7,4,0,0,-34,2,-4},
                {-1,47,4,0,26,-5,6,9,7,4,0,0,-9,4,-4},
                {-1,0,14,0,7,-5,6,8,10,4,0,0,4,11,201},
        };


        //矩阵行长度
        int tmp=matrix[0].length;
        int u = matrix.length-1;
        int v = matrix[u][tmp/2]-1;

        // 需求: 最下行 中心列 为中心点 => 起始点
        int startPoint = matrix[u][v];


        //起始点的行


        //起始点的列
        int startPointColumn = 0;

        //得到起始点的列
        for (int i = 0; i <tmp; i++) {
            if (matrix[u][i] == startPoint) {
                startPointColumn = i;
            }
        }


        //随机数类
        Random random = new Random();

        //随即矩阵行
        int randomRow = random.nextInt(matrix.length - 1);
        //随机矩阵列
        int randomColumn = random.nextInt(tmp/2-1);


        maxNumberSum(startPoint, u, startPointColumn, randomColumn, matrix);

    }


    //求移动路径sum
    private static void maxNumberSum(int startPoint, int startPointRow, int startPointColumn,  int randomColumn, int[][] matrix) {


        System.out.println("当前 起始点:" + startPoint);


        //左移动 matrix[length - 1][length / 2 - -] startPointColumn--
        // 右移动 matrix[length - 1][length / 2 ++] startPointColumn++
        // 上移动 matrix[(length - 1)--][length / 2 ] startPointRow--

        //这里默认为 上移动: matrix[(length - 1)--][length / 2] startPointRow--

        System.out.println("矩阵起始行:" + startPointRow);
        System.out.println("矩阵起始列:" + startPointColumn);
        System.out.println("随机列:" + randomColumn);

        System.out.println("移动方式 右移动:");

        //路径和
        int sum = 0;

        do {

            int num = matrix[startPointRow][++startPointColumn];

            System.out.println("向右移动"+randomColumn + "次 经过 元素:" + num);
            sum += num;

        } while (--randomColumn != 0);

        startPoint += sum;

        System.out.println("路径求合:" + startPoint);
    }

}