编写程序实现： 1、输于两个n×n的矩阵A和B,实现乘积运算，并输出运算结果和计算时间； 2、逐渐增大矩阵A和B的规模，分析运算时间的变化。 3、用分治法的实现矩阵乘积运算，比较使用分治法前后的计算量差异。

以下是Python实现：

1. 实现矩阵乘积运算并输出运算结果和计算时间：

import numpy as np
import time

# 生成两个随机矩阵A和B
n = 100
A = np.random.rand(n, n)
B = np.random.rand(n, n)

# 矩阵乘积运算
start = time.time()
C = np.dot(A, B)
end = time.time()
print("矩阵乘积运算结果为：")
print(C)
print("矩阵乘积运算时间为：", end - start, "秒")

2. 逐渐增大矩阵A和B的规模，分析运算时间的变化：

import numpy as np
import time

for n in range(100, 1001, 100):
    # 生成两个随机矩阵A和B
    A = np.random.rand(n, n)
    B = np.random.rand(n, n)

    # 矩阵乘积运算
    start = time.time()
    C = np.dot(A, B)
    end = time.time()
    print("矩阵规模为", n, "时，矩阵乘积运算时间为：", end - start, "秒")

3. 用分治法的实现矩阵乘积运算，比较使用分治法前后的计算量差异：

import numpy as np
import time

# 分治法实现矩阵乘积运算
def divide_conquer(A, B):
    n = len(A)
    if n == 1:
        return A * B
    else:
        A11 = A[:n//2, :n//2]
        A12 = A[:n//2, n//2:]
        A21 = A[n//2:, :n//2]
        A22 = A[n//2:, n//2:]
        B11 = B[:n//2, :n//2]
        B12 = B[:n//2, n//2:]
        B21 = B[n//2:, :n//2]
        B22 = B[n//2:, n//2:]

        C11 = divide_conquer(A11, B11) + divide_conquer(A12, B21)
        C12 = divide_conquer(A11, B12) + divide_conquer(A12, B22)
        C21 = divide_conquer(A21, B11) + divide_conquer(A22, B21)
        C22 = divide_conquer(A21, B12) + divide_conquer(A22, B22)
        
        C = np.vstack((np.hstack((C11, C12)), np.hstack((C21, C22))))
        return C

# 生成两个随机矩阵A和B
n = 100
A = np.random.rand(n, n)
B = np.random.rand(n, n)

# 矩阵乘积运算
start = time.time()
C = divide_conquer(A, B)
end = time.time()
print("分治法矩阵乘积运算结果为：")
print(C)
print("分治法矩阵乘积运算时间为：", end - start, "秒")
print("普通矩阵乘积运算时间为：", np.sum(A*B)/n**2, "秒")

通过比较普通矩阵乘积运算时间和分治法矩阵乘积运算时间，可以看出分治法在矩阵规模较大时具有更高的效率。