Strassen矩阵算法的实现

仅仅针对2的幂次数阶的矩阵，时间复杂度O(n^lg7)

#include <iostream>

using namespace std;


void gerResultStrassen(int **arr, int **brr, int n, int **crr)
{

    if (n == 1)
    {
        crr[0][0] += arr[0][0] * brr[0][0];
    }
    else
    {
        int m = n / 2;
        int **arr11 = new int*[m];
        int **arr12 = new int*[m];
        int **arr21 = new int*[m];
        int **arr22 = new int*[m];


        int **brr11 = new int*[m];
        int **brr12 = new int*[m];
        int **brr21 = new int*[m];
        int **brr22 = new int*[m];

        int **crr11 = new int*[m];
        int **crr12 = new int*[m];
        int **crr21 = new int*[m];
        int **crr22 = new int*[m];

        for (int i = 0; i < m; ++i)
        {
            arr11[i] = new int[m];
            arr12[i] = new int[m];
            arr21[i] = new int[m];
            arr22[i] = new int[m];


            brr11[i] = new int[m];
            brr12[i] = new int[m];
            brr21[i] = new int[m];
            brr22[i] = new int[m];

            crr11[i] = new int[m];
            crr12[i] = new int[m];
            crr21[i] = new int[m];
            crr22[i] = new int[m];

        }//获取矩阵

        //11
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                arr11[i][j] = arr[i][j];
                brr11[i][j] = brr[i][j];
            }
        }
        //22
        for (int i = m; i < n; ++i)
        {
            for (int j = m; j < n; ++j)
            {
                arr22[i - m][j - m] = arr[i][j];
                brr22[i - m][j - m] = brr[i][j];
            }
        }
        //12
        for (int i = 0; i < m; ++i)
        {
            for (int j = m; j < n; ++j)
            {
                arr12[i][j - m] = arr[i][j];
                brr12[i][j - m] = brr[i][j];
            }
        }

        //21
        for (int i = m; i < n; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                arr21[i - m][j] = arr[i][j];
                brr21[i - m][j] = brr[i][j];
            }
        }

        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                crr11[i][j] = 0;
                crr12[i][j] = 0;
                crr21[i][j] = 0;
                crr22[i][j] = 0;
            }
        }

        gerResultStrassen(arr11, brr11, m, crr11);
        gerResultStrassen(arr12, brr21, m, crr11);

        gerResultStrassen(arr11, brr12, m, crr12);
        gerResultStrassen(arr12, brr22, m, crr12);

        gerResultStrassen(arr21, brr11, m, crr21);
        gerResultStrassen(arr22, brr21, m, crr21);

        gerResultStrassen(arr21, brr12, m, crr22);
        gerResultStrassen(arr22, brr22, m, crr22);

        //11
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                crr[i][j] += crr11[i][j];
            }
        }
        //22
        for (int i = m; i < n; ++i)
        {
            for (int j = m; j < n; ++j)
            {
                crr[i][j] += crr22[i - m][j - m];
            }
        }

        //12
        for (int i = 0; i < m; ++i)
        {
            for (int j = m; j < n; ++j)
            {
                crr[i][j] += crr12[i][j - m];
            }
        }
        //21
        for (int i = m; i < n; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                crr[i][j] += crr12[i - m][j];
            }
        }

        for (int i = 0; i < m; ++i)
        {
            delete[] arr11[i];
            delete[] brr11[i];
            delete[] crr11[i];

            delete[] arr12[i];
            delete[] brr12[i];
            delete[] crr12[i];

            delete[] arr21[i];
            delete[] brr21[i];
            delete[] crr21[i];

            delete[] arr22[i];
            delete[] brr22[i];
            delete[] crr22[i];
        }


            delete[] arr11;
            delete[] brr11;
            delete[] crr11;

            delete[] arr12;
            delete[] brr12;
            delete[] crr12;

            delete[] arr21;
            delete[] brr21;
            delete[] crr21;

            delete[] arr22;
            delete[] brr22;
            delete[] crr22;




    }
}

int main()
{
    int n;//矩阵阶数
    cin >> n;
    int **arr = new int*[n];
    int **brr = new int*[n];
    int **crr = new int*[n];

    for (int i = 0; i < n; ++i)
    {
        arr[i] = new int[n];
        brr[i] = new int[n];
        crr[i] = new int[n];
    }//获取矩阵

    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            cin >> arr[i][j];
            crr[i][j] = 0;
        }
    }

    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            cin >> brr[i][j];
        }
    }


    gerResultStrassen(arr, brr, n, crr);

    cout << "输出的结果为\n";
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            cout << crr[i][j]<<" ";
        }
        cout << endl;
    }


    for (int i = 0; i < n; ++i)
    {
        delete[] arr[i];
        delete[] brr[i];
        delete[] crr[i];
    }


        delete[] arr;
        delete[] brr;
        delete[] crr;


    return 0;
}