V. Pan discovered a method that can complete the multiplication of 68 x 68 matrices with 132 464 multiplication operations, found another method that can complete the multiplication of 70 x 70 matrices with 143 640 multiplication operations, and also found a method that can complete the matrix multiplication of 72 x 72 with 155 424 multiplication operations. When used for the divide and conquer algorithm of matrix multiplication, which of the above methods will get the best asymptotic run time? How does it perform compared to Strassen's algorithm?
Wen Xin's words:
Since the time complexity of matrix multiplication is O(n^3), the time complexity of the divide and conquer algorithm is also O(n^3). Therefore, the time complexity of these methods is the same, and they are all O(n^3).
Compared to the Strassen algorithm, these methods may perform poorly. The Strassen algorithm can perform 28 multiplications in a matrix multiplication of 7 x 7 and 56 multiplications in a matrix multiplication of 8 x 8. Therefore, the time complexity of the Strassen algorithm is O(n^2), which is faster than the divide and conquer algorithm.
However, the generalization of Strassen's algorithm is not easy, so it is only suitable for small matrix multiplication problems. For large matrix multiplication problems, the divide and conquer algorithm is still one of the widely used algorithms.
Insert image description here
iFLYTEK Spark:
To compare the performance of these three methods, we can calculate the time they take when performing matrix multiplication. For smaller matrices, using the divide and conquer algorithm is generally more efficient than using the Strassen algorithm. Therefore, we can first calculate the asymptotic elapsed time of the three methods discovered by V. Pan when performing 68 x 68, 70 x 70, and 72 x 72 matrix multiplication. We then compare these times with the time of Strassen's algorithm. V. Pan's method of discovery:
132464 multiplication operation completes 68x68 matrix multiplication: T(n) = O(n^3)
143640 multiplication operations complete 70x70 matrix multiplication: T(n) = O(n^3)
155424 multiplication operation completes 72x72 matrix multiplication: T(n) = O(n^3)Strassen's algorithm:
132464 multiplication operation completes 68x68 matrix multiplication: T(n) = O(n^log_2(n)) = O(n^0.959)
143640 multiplication operations complete 70x70 matrix multiplication: T(n) = O(n^log_2(n)) = O(n^0.959)
155424 multiplication operation completes 72x72 matrix multiplication: T(n) = O(n^log_2(n)) = O(n^0.959) From the above calculation results, it can be seen that when used for the divide and conquer algorithm of matrix multiplication, which of the above methods will get the best asymptotic running time? The answer is the three methods discovered by V. Pan. Compared to the Strassen algorithm, they have slightly lower performance, but are still very efficient.
Insert image description here
Huawei Pangu:
For the first problem, V.Pan uses an iterative algorithm in which each step uses 132 464 multiplication operations, so the asymptotic run time can be found very quickly.
For the second problem, V.Pan uses a divide and conquer algorithm in which each step uses 143 640 multiplication operations, so the asymptotic run time can be found faster.
For the third problem, V.Pan uses a parallel algorithm in which each step uses 155 424 multiplication operations, so the asymptotic run time can be found faster.
In terms of asymptotic run time, the performance of the V.Pan algorithm is comparable to the Strassen algorithm, and even slightly better than the Strassen algorithm. This is because the V.Pan algorithm takes less time than the Strassen algorithm at each step, so the total run time may be shorter.
In summary, the asymptotic run time can be found at different time complexities for 68 x 68 matrix multiplication using 132 464 multiplication operations, 70 x 70 matrix multiplication with 143 640 multiplication operations, and 72 x 72 matrix multiplication using 155 424 multiplication operations. When choosing an algorithm, factors such as the size, accuracy, and time requirements of the task need to be considered to choose the most suitable algorithm.
Insert image description here
chatglm：
According to the basic idea of the divide and rule algorithm, a complex problem is divided into multiple subproblems, and the solution of each subproblem is relatively simple. In this case, Pan's method divides the matrix multiplication problem into three subproblems, while Strassen's algorithm divides the matrix multiplication problem into five subproblems.
Since Pan's method requires fewer multiplication operations, it may get better asymptotic run times in divide and conquer algorithms. However, the Strassen algorithm theoretically has better performance because it can divide the problem into more subproblems, and the solution of each subproblem is simpler.
In general, both Pan's method and Strassen's algorithm have certain advantages and limitations in the matrix multiplication problem, and which method is best depends on the scale and complexity of the specific problem. In addition, Pan's approach may require more computation and storage space than Strassen's algorithm, so various factors need to be weighed to select the appropriate algorithm.
Insert image description here
chatgpt：
For the divide and conquer algorithm of matrix multiplication, the Strassen algorithm is usually used, and its time complexity is $O(n^{\log_2 7}) \approx O(n^{2.81})$.
Of the above three methods, the first method can complete a matrix multiplication of 68 x 68, which requires 132464 multiplication operations, and an average of $\frac{132464}{68^3}\approx 0.00053$ multiplication operations per element. The second method can complete a matrix multiplication of 70 x 70, which requires 143640 multiplication operations, and an average of $\frac{143640}{70^3}\approx 0.0005$ multiplication operations per element. The third method can complete a matrix multiplication of 72 x 72, which requires 155424 multiplication operations, and an average of $\frac{155424}{72^3}\approx 0.00049$ per element.
Therefore, the third method works best, requiring the fewest multiplication operations on average for each element. However, the run time of these methods is still poor compared to the Strassen algorithm. According to the time complexity of Strassen's algorithm, when the matrix size $n\geqslant 2^{k}$, its time complexity is $O(n^{k})$, where $k=\log_2 7 \approx 2.81$. Therefore, when the matrix is large, the performance of the Strassen algorithm will be much better than these three methods.
Insert image description here
Fuda architect has a daily question Java should die, and Golang should stand. The latest interview questions involve Golang, Rust, MySQL, REDIS, Cloud Native, Algorithmic, Distributed, Networking, Operating System. 527 original content
Official account