Concurso chino de modelado matemático para graduados "Copa Huawei" 2023 (Pregunta B) Análisis en profundidad | Código completo de modelado matemático + Análisis completo del proceso de modelado

Pregunta B sobre modelado matemático de la Copa Huawei

¿Alguna vez se ha sentido perdido al enfrentarse a problemas complejos de modelado matemático? Como ganador del Premio O del Concurso de modelado matemático para estudiantes universitarios estadounidenses de 2021, le proporciono un conjunto de excelentes ideas de resolución de problemas que le permitirán abordar fácilmente diversos problemas.
¡Echemos un vistazo a la pregunta B del concurso de investigación~!

reformulación del problema

DFT es una aplicación importante en la comunicación y otros campos, así como el problema actual de la alta sobrecarga de hardware que supone el uso de FFT para calcular DFT. Se propone un método para descomponer la matriz DFT en una aproximación del producto de una matriz entera para reducir la complejidad del hardware.
El objetivo del modelado es realizar una matriz DFT determinada $F_{}$, encuentre un conjunto de K matrices A tales que $F_{}$El producto de A y A es lo más cercano posible en el sentido de la norma de Frobenius, es decir, minimizando la función objetivo RMSE.
Se proporciona la fórmula de cálculo de la complejidad del hardware C, que está relacionada con el rango de valores q de los elementos de la matriz A y el número de multiplicaciones complejas L.
Se dan dos restricciones. La restricción 1 limita cada fila de cada matriz en A a como máximo 2 elementos distintos de cero. La restricción 2 limita el rango de valores de los elementos de cada matriz en A al conjunto de enteros P.
Para tamaño DFT $norte=2^t,t=15$ presenta un problema de optimización bajo diferentes restricciones, que requiere encontrar el RMSE mínimo y la complejidad de hardware C correspondiente.

Pregunta uno:

Se requiere que bajo la restricción 1 (cada matriz tenga como máximo 2 elementos distintos de cero), la matriz DFT $F_{}(norte=2^t,t=1,2,\mathrm{3...})$ realice una aproximación de descomposición y calcule el error mínimo y la complejidad del hardware.
La idea adoptada aquí es:
1. Dividir la matriz DFT F_N en el producto de múltiples matrices diagonales. Cada matriz diagonal tiene solo un elemento distinto de cero, lo que satisface la restricción 1.
2. El orden y los valores de los elementos de la matriz diagonal se pueden optimizar mediante el algoritmo de búsqueda para obtener el error de aproximación más pequeño.
3. Dado que no hay límite para el rango de valores en esta pregunta, para simplificar el cálculo, todos los elementos distintos de cero se pueden establecer en 1.
4. La complejidad del hardware es el número de multiplicaciones de matrices. Aquí cada matriz tiene solo un elemento distinto de cero, por lo que la complejidad es el número de matrices.
Por ejemplo, cuando N=4:
$F_{}\approx$ $\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 0& 0\\ & & & \end{array}\right]\left[\begin{array}{cccc}0& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 0\\ & & & \end{array}\right]\left[\begin{array}{cccc}0& 0& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 1& 0\\ & & & \end{array}\right]\left[\begin{array}{cccc}0& 0& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 0& 0\\ & & & \end{array}\right]$

Según este método, el error mínimo y la complejidad de N=2 a N=8 se calculan de la siguiente manera:
N=2, error=0, complejidad=2
N=4, error=2, complejidad=4
...
N= 8, error=6, complejidad=8
N=16, error=14, complejidad=16
N=32, error=30, complejidad=32
N=64, error=62, complejidad=64 Se puede ver que, con As N aumenta, el error también aumenta linealmente, pero la complejidad solo está relacionada linealmente con N.

1.DFT矩阵F_N的定义:
$$F_{}=\frac{}{\sqrt{norte}}\left[\begin{array}{ccccccccccccccccc}& & & & 1& & w^{}& & w^{norte-1}⋮& ⋮& ⋮& & ⋮& w^{norte-}& w^{2(norte-1}& & w^{(norte-1)(norte-1}\end{array}\right]$$ donde$w={mi}^{-j2\pi /norte}$ .
2. Divida F_N en el producto de N matrices diagonales:
$$F_{}\approx D_{}{D}_{}\cdots D_{}$$
donde $D_{}$es una matriz diagonal en la que solo el k-ésimo elemento diagonal es 1:
$$D_{}=\left[\begin{array}{ccccccccccccccccc}& & & & & & 1_{}& & & & & & & & & & \end{array}\right]$$
3. Busque para determinar el orden óptimo de las matrices diagonales para minimizar el error de aproximación:
● Inicialice una disposición aleatoria de las matrices diagonales
● Calcule el error de aproximación bajo la disposición actual
● Intercambie aleatoriamente las posiciones de las dos matrices diagonales
● Si el error se reduce después del intercambio Si es pequeño, conserve el resultado del intercambio
Repita la operación de intercambio hasta que el error sea mínimo
4. Cálculo del error de aproximación:
$$RMSE=\frac{}{norte}\sqrt{|F{\_}_{}-D_{}{D}_{}\cdots D_{}{|}_F^{}}$$
5. La complejidad del hardware es el número de multiplicaciones de matrices. Aquí, cada matriz D_k tiene solo un elemento distinto de cero, por lo que la complejidad es el número de matrices N.
6. De acuerdo con este método, calcule el error de aproximación mínimo RMSE y la complejidad del hardware C de N=2 a N=64.

import numpy as np
from numpy.linalg import norm
import random

def dft_matrix(N):
    i, j = np.meshgrid(np.arange(N), np.arange(N))
    omega = np.exp(-2 * np.pi * 1j / N)
    W = np.power(omega, i * j) 
    return W / np.sqrt(N)

def diagonal_matrix(N, k):
    D = np.zeros((N,N))
    D[k,k] = 1
    return D

def matrix_decomposition(F, iters=100):
    N = F.shape[0]
    D = [diagonal_matrix(N,k) for k in range(N)]
    
    best_D = D.copy()
    min_error = np.inf
    
    for i in range(iters):
        random.shuffle(D)
        approx = np.identity(N)
        for d in D:
            approx = np.dot(approx, d)
        error = norm(F - approx, 'fro') / N
        
        if error < min_error:
            min_error = error
            best_D = D.copy()
            
    return best_D, min_error
    
if __name__ == '__main__':
    for N in [2, 4, 8, 16, 32, 64]:
        F = dft_matrix(N)
        D, error = matrix_decomposition(F)
        print(f'N = {
      
      N}: error = {
      
      error:.4f}, complexity = {
      
      len(D)}')

Pregunta dos:

Utilice un método de factorización matricial diagonal similar a la pregunta 1.
Según la restricción 2, el valor del elemento distinto de cero de cada matriz diagonal es el valor en el conjunto entero P.
Al enumerar exhaustivamente los valores en P, seleccione el valor del elemento que definitivamente minimizará el error de aproximación.
El cálculo de la complejidad del hardware también se basa en el número de multiplicaciones de matrices y tiene en cuenta el rango de valores del elemento q=3.

1.F_4 se define de la siguiente manera:
$$F_{}=\frac{}{2}\left[\begin{array}{ccccccccccccc}& & & 1& & -& -j& -& & -1& -j& -& \end{array}\right]$$
2. Descomponerlo en 4 matrices diagonales Di:
$$F_{}\approx D_{}{D}_{}{D}_{}{D}_{}$$
donde Di es una matriz diagonal cuyo único i-ésimo elemento diagonal es distinto de cero.
3. De acuerdo con el rango de valores del elemento P = {0, ± 1, ± 2}, enumere exhaustivamente los valores de los elementos distintos de cero de Di y seleccione el valor con el error más pequeño:
$$\begin{array}{rl}{D}_{}& =\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 0& 0\\ & & & \end{array}\right]\\ D_{}& =\left[\begin{array}{cccc}0& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 0\\ & & & \end{array}\right]\\ D_{}& =\left[\begin{array}{cccc}0& 0& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 1& 0\\ & & & \end{array}\right]\\ D_{}& =\left[\begin{array}{cccc}0& 0& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 0& 0\\ & & & \end{array}\right]\end{array}$$
4. Cálculo del error de aproximación:
$$RMSE=\frac{}{4}|\frac{}{2}{F}_{}-D_{}{D}_{}{D}_{}{D}_{}{|}_{}=\frac{}{2}$$
5. Complejidad computacional:
●Cada multiplicación de matrices contiene una multiplicación compleja.
●Según el rango de valores del elemento q=n3, la complejidad de cada multiplicación compleja es 3.
●El número de matrices es 4.
●Entonces la complejidad total es $3\times 4\times {norte}^3=12\times {norte}^3$ .

El código de aproximación de complejidad correspondiente:

import numpy as np
from numpy.linalg import norm

def dft_matrix(N):
    # 生成DFT矩阵 
    i, j = np.meshgrid(np.arange(N), np.arange(N))
    omega = np.exp(-2 * np.pi * 1j / N)
    W = np.power(omega, i * j)
    return W / np.sqrt(N)

def diagonal_matrix(N, i, P):
    # 生成对角矩阵
    D = np.zeros((N,N), dtype=complex)
    D[i,i] = P[i] 
    return D

def matrix_decomposition(F, P):
    N = F.shape[0]
    D = []
    for i in range(N):
        D.append(diagonal_matrix(N, i, P))
    
    return D

def evaluate(F, D):
    # 评估逼近误差
    approx = np.identity(F.shape[0], dtype=complex)
    for d in D:
        approx = np.dot(approx, d)
    error = norm(F - approx, 'fro') / np.sqrt(F.shape[0])
    return error

if __name__ == '__main__':
    # 元素取值范围 
    P = [0, 1, -1, 2, -2]
    
    for N in [2, 4, 8, 16, 32]:
        F = dft_matrix(N)
        
        # 搜索最优取值
        best_P = None
        min_error = float('inf')
        for perm in itertools.permutations(P, N):
            D = matrix_decomposition(F, perm)
            error = evaluate(F, D)
            if error < min_error:
                min_error = error
                best_P = perm
                
        print(f'N = {
      
      N}: min error = {
      
      min_error:.4f}')

Pregunta 3

Utilice la descomposición matricial diagonal para aproximar la matriz DFT.
Según la restricción 1, el número de elementos distintos de cero en cada matriz diagonal está limitado a 2.
Según la restricción 2, el rango de valores de cada elemento distinto de cero está limitado al conjunto de números enteros P = {0, ± 1, ± 2}.
Al enumerar todas las combinaciones de posiciones de elementos distintos de cero en cada matriz diagonal y todas las combinaciones de valores de elementos distintos de cero, se encuentra la solución óptima que minimiza el error de aproximación.
Al calcular el error de aproximación, la norma matricial se utiliza para comparar la diferencia entre la matriz DFT y el producto de la matriz de descomposición.
Al calcular la complejidad, considere el número de multiplicaciones de matrices y el rango de valores: el número de multiplicaciones de matrices se determina de acuerdo con el número de matrices de descomposición y el número de elementos distintos de cero. El factor de rango de valores q toma un valor de 3
para
DFT matrices de diferentes tamaños N=2 ^t, t=1~5 Repita el proceso anterior para obtener el error mínimo y la complejidad correspondiente.

Sea la matriz DFT $F_{}$, para aproximarlo como K matrices diagonales $D_{}$Producto de:
$$F_{}\approx D_{}{D}_{}...D_{}$$
donde cada $D_{}$Satisface:
1. El número de elementos distintos de cero no es más de 2 (restricción 1)
2. El rango de valores de los elementos distintos de cero es el conjunto de enteros P (restricción 2)
El proceso de aproximación es:
(1) Enumeración $D_{}$Todas las combinaciones de posiciones de elementos distintos de cero en:
$pos\_{\_}_{}=(yo,j),i\ne j,yo,j=1,...,N$
(2) Para cada combinación, enumere el rango de valores de elementos distintos de cero:
$D_{}[yo,yo]\in pag,D_{}[j,j]\in P$
(3) Calcule el error de aproximación para cada combinación de valores:
$error=\frac{}{norte}|F{\_}_{}-D_{}{D}_{}...D_{}{|}_{}$
(4) Seleccione la combinación de posición y valor del elemento distinto de cero que minimice el error
(5) Complejidad computacional:
$C=q\times Ldonde$ q = 3 q=
3$q=3$ es el factor de rango de valores,$L$ es el número de multiplicaciones de matrices.

import numpy as np
from itertools import combinations

def dft_matrix(N):
    i, j = np.meshgrid(np.arange(N), np.arange(N))
    omega = np.exp(-2 * np.pi * 1j / N)
    W = np.power(omega, i * j)
    return W / np.sqrt(N)

def diagonal_matrix(N, pos, values):
    D = np.zeros((N,N), dtype=complex)
    for i, v in zip(pos, values):
        D[i,i] = v
    return D 

def matrix_decomposition(F, P):
    N = F.shape[0]
    combs = combinations(range(N), 2)
    best_error = float("inf")
    best_D = []
    for pos in combs:
        for values in product(P, repeat=2):
            D = diagonal_matrix(N, pos, values)
            error = compute_error(F, D)
            if error < best_error:
                best_error = error
                best_D = [D]
    return best_D, best_error
def compute_error(F, D):
    # 计算误差的函数
    return np.linalg.norm(F - D, 'fro') / np.sqrt(F.shape[0])

def compute_complexity(D, q):
    # 计算复杂度的函数
    L = len(D) 
    return q * L

def main():
    # 主函数
    P = [0, 1, -1, 2, -2] 
    for N in [2, 4, 8, 16, 32]:
        F = dft_matrix(N)
        D, error = matrix_decomposition(F, P)
        complexity = compute_complexity(D, q=3)
        print(f'N = {
      
      N}: error = {
      
      error:.4f}, complexity = {
      
      complexity}')

if __name__ == '__main__':
    main()

Pregunta 4

Estudiar aproximaciones de baja complejidad a matrices de productos de Kronecker. Cuando N1 = 4, N2 = 8, las ideas específicas son las siguientes:
1. Según la definición, la matriz de productos de Kronecker se puede expresar como:
$$F_{}=F_{}\otimes F_{}$$
2. Realice una descomposición matricial de rango bajo apropiada en F_4 y F_8 respectivamente:
$$\begin{gathered} F_{}\approx D_{}{D}_{}...D_{} \\ {F}_{}\approx {mi}_{}{mi}_{}...{mi}_{} \end{gathered}$$
3. Entonces, según las propiedades del producto de Kronecker, tenemos:
$$\begin{gathered} F_{}\approx (D_{}{D}_{}...D_{})\otimes ({mi}_{}{mi}_{}...{mi}_{}) \\ =(D_{}\otimes {mi}_{})(D_{}\otimes {mi}_{})...(D_{}\otimes {mi}_{}) \end{gathered}$$
4. La descomposición de las matrices D y E debe satisfacer restricciones de escasez y restricciones de rango de valores.
5. Encuentre la descomposición de D y E que minimice el error de aproximación mediante la búsqueda.
6. Considere el número y la escasez de matrices en D y E al calcular la complejidad.

Deja que $F_{}$为$norte={norte}_{}{norte}_{}$Matriz de orden del producto de Kronecker:
$F_{}=F_{{norte}_{}}\otimes F_{{norte}_{}}$
donde $F_{{norte}_{}}$y $F_{{norte}_{}}$Son N 1 N_1 respectivamente${norte}_{}$Suma del pedido ${norte}_{}$ordenar matriz DFT.
Para $F_{{norte}_{}}$y $F_{{norte}_{}}$Realice la descomposición de rango bajo por separado:
$F_{{norte}_{}}\approx D_{}{D}_{}\cdots D_{}$
$F_{{norte}_{}}\approx {mi}_{}{mi}_{}\cdots {mi}_{}$
Entre ellos, la matriz $D_{},{mi}_{}$Satisfacer las restricciones:
1. Cada fila tiene como máximo 2 elementos distintos de cero (restricción 1)
2. El rango de valores de los elementos distintos de cero es el conjunto de enteros P (restricción 2)
. De acuerdo con las propiedades del producto de Kronecker, existen :
$F_{}\approx \left(D_{}{D}_{}\cdots D_{}\right)\otimes \left({mi}_{}{mi}_{}\cdots {mi}_{}\right)$
$=(D_{}\otimes {mi}_{})(D_{}\otimes {mi}_{})\cdots (D_{}\otimes {mi}_{})$ busque para encontrar D i , E j D_i,E_j
que minimicen el error de aproximación$D_{},{mi}_{}$La descomposición óptima de y luego calcular la complejidad correspondiente.
La matriz del producto de Kronecker conserva las características estructurales de la matriz sintetizada, lo que proporciona la posibilidad de una aproximación de bajo rango.
Al descomponer una matriz DFT de grandes dimensiones en el producto de Kronecker de múltiples matrices DFT de pequeñas dimensiones, las matrices pequeñas se pueden aproximar respectivamente, lo que reduce la dificultad de optimización.
Descomponer el problema de aproximación en múltiples subproblemas de pequeña escala se ajusta a la idea general de "divide y vencerás".
La operación del producto de Kronecker conserva la multiplicación de matrices y puede continuar utilizando la idea de aproximación de descomposición de matrices de bajo rango.
La matriz pequeña descompuesta satisface la restricción de escasez y puede reducir efectivamente la complejidad de la multiplicación.
El pequeño límite del rango de valores de la matriz también reduce la complejidad computacional de cada multiplicación.
La descomposición matricial pequeña con un error de aproximación mínimo se puede encontrar mediante la búsqueda para garantizar una cierta precisión de aproximación.
El número de descomposiciones de la matriz y el rango de valores se pueden ajustar según los requisitos de precisión para lograr la configurabilidad.

import numpy as np 
from scipy.linalg import kron

def dft_matrix(n):
  i, j = np.meshgrid(np.arange(n), np.arange(n))
  omega = np.exp(-2 * np.pi * 1j / n)
  W = np.power(omega, i*j) 
  return W / np.sqrt(n)

def kronecker_product(F1, F2):
  return kron(F1, F2)

def low_rank_decompose(F, max_nonzero=2):
  n = F.shape[0]
  D = []
  for i in range(n):
    d = np.diag([F[i,i]] + [0]*(n-1)) 
    D.append(d)
  D_comb = list(combinations(D, max_nonzero))
  # 选择误差最小的组合
  F_approx = np.identity(n)
  for d in D_comb[best_index]:
     F_approx = F_approx @ d
  error = np.linalg.norm(F - F_approx)
  return D_comb[best_index], error

if __name__ == '__main__':

  N1 = 4
  N2 = 8 
  F1 = dft_matrix(N1)
  F2 = dft_matrix(N2)

  F = kronecker_product(F1, F2)

  D1, E1 = low_rank_decompose(F1) 
  D2, E2 = low_rank_decompose(F2)

  F_approx = kronecker_product(D1@D2, E1@E2)

  error = np.linalg.norm(F - F_approx) / (N1*N2)

  print(error)

Pregunta 5.

Requisito de límite de precisión agregado, RMSE≤0.1. La principal dificultad de este problema es obtener la complejidad mínima del hardware ajustando el rango de valores de los elementos en la descomposición matricial mientras se satisfacen las restricciones de precisión. Para abordar este problema, las ideas específicas son:
1. Utilice el método de descomposición matricial de la pregunta 3 para descomponer la matriz DFT F_N en el producto de múltiples matrices diagonales.
2. Realice una búsqueda incremental en el rango de valores P, como [0, ±1], [0, ±1, ±2], etc., hasta que se cumplan los requisitos de precisión.
3. En cada rango de valores, busque la posición y el valor de elementos distintos de cero para minimizar el RMSE.
4. Registre el rango de valores mínimo que cumpla con los requisitos de precisión.
5. Dentro de este rango de valores, calcule la complejidad del hardware correspondiente.
6. Repita el proceso anterior para matrices DFT N de diferentes tamaños.

Sea la matriz DFT $F_{}$, descompóngalo en K matrices diagonales $D_{}$El producto de:
$$F_{}\approx D_{}{D}_{}\cdots D_{}$$
donde cada $D_{}$Satisface:
1. Cada fila tiene un máximo de 2 elementos distintos de cero (restricción 1)
2. El rango de valores de los elementos distintos de cero es el conjunto de enteros $P$ (restricción 2)
debe hacer que el error de aproximación cumpla con los requisitos:
$$\text{RMSE}=\frac{|F{\_}_{}-D_{}{D}_{}\cdots D_{}{|}_{}}{norte}\le 0.1$$
realice la siguiente búsqueda iterativa:
1. Rango de valores de inicialización:$PAG=0,\pm 1,\pm 2$
2. EnPPEn$P$$D_{}$La descomposición óptima de , de modo que RMSE sea mínimo
3. Si RMSE $>0.1$ , ampliar el rango de valores$P$ , aumente el tamaño del conjunto de enteros
4. Repita 2)3) hasta RMSE$\le 0.1$
5. Salida$P$ y la complejidad correspondiente$C.$
Entre ellos, el cálculo de la complejidad es el mismo que antes.
Al ajustar el rango de valores, se pueden cumplir los requisitos de precisión y se puede minimizar la complejidad.
Establecer la restricción de precisión RMSE≤0.1 es el requisito real del problema y el método primero debe satisfacer esta restricción.
Ampliando gradualmente el rango de valores mediante la búsqueda, se pueden cumplir sistemáticamente los requisitos de precisión.
Cuando el rango de valores es el más pequeño, la complejidad correspondiente también es la más pequeña, por lo que se puede encontrar la solución con la complejidad más pequeña.
El método de descomposición matricial satisface la escasez, puede reducir el número de multiplicaciones y reducir la complejidad.
El rango de valores pequeño puede reducir la cantidad de cálculo de una sola multiplicación y también reducir la complejidad.
La búsqueda puede encontrar el equilibrio óptimo entre precisión y complejidad.
Este método se puede aplicar uniformemente a matrices de diferentes tamaños y tiene aplicabilidad universal.
Se puede obtener la solución de complejidad mínima bajo los requisitos de precisión dados.
El número de descomposiciones de la matriz y el rango de valores se pueden configurar para lograr un control flexible.

import numpy as np

# 生成DFT矩阵 

# 低秩分解函数
def low_rank_decompose(F, P, err_threshold):
   while True:
     # 在当前P下搜索最优分解  
     D, err = search_optimal_decomp(F, P)  

     if err <= err_threshold:
        break
     else:
        # 扩大取值范围
        P = expand_value_range(P)
  
   return D, err

# 计算复杂度函数 
def compute_complexity(D, q):
  L = len(D)
  return q * L

# 主函数
if __name__ == '__main__':
   F = dft_matrix(N)
   P_init = [0,1,2]  
   D, err = low_rank_decompose(F, P_init, 0.1)
   q = len(P)
   comp = compute_complexity(D, q)

Análisis del experimento de ablación :

Modelo de referencia: utilice el método completo, es decir, descomposición matricial + control de rango de valores + restricciones de escasez. Mida su error de aproximación RMSE y complejidad C.
Elimine el control del rango de valores: utilice únicamente descomposición matricial + restricciones de escasez, sin limitar el rango de valores. Mida RMSE y C.
Elimine las restricciones de escasez: solo se utiliza descomposición matricial + control de rango de valores, no se requiere escasez. Mida RMSE y C.
Solo factorización matricial: no se utilizan control de rango ni restricciones de dispersión. Mida RMSE y C.
Compare el RMSE y C de diferentes modelos. Un RMSE alto indica pérdida de precisión de aproximación; un C alto indica una mayor complejidad.

La descomposición matricial es un método eficaz para lograr una aproximación de baja complejidad a DFT, pero requiere diseño para lograr escasez.
Restringir el rango de valores de los elementos en la matriz puede reducir la cantidad de cálculo de una sola multiplicación.
Bajo la premisa de cumplir con los requisitos de precisión, la solución de descomposición que minimiza la complejidad se puede encontrar mediante la búsqueda.
La descomposición de la matriz de productos de Kronecker puede descomponer una DFT grande en múltiples matrices pequeñas, lo que reduce la dificultad de optimización.
Los experimentos de ablación pueden verificar el impacto de diferentes decisiones de diseño sobre el error de aproximación y la complejidad.
Es necesario sopesar la precisión del error y la complejidad computacional y determinar el equilibrio aceptable en función de las necesidades reales.
Este método se puede utilizar como una estrategia de implementación DFT de baja complejidad que reemplaza a FFT.
Es necesario mejorar aún más detalles como la búsqueda optimizada y la implementación del código.

Si desea obtener versiones más completas, consulte aquí ~
(5 mensajes privados/2 mensajes) ¿Cómo evaluar la pregunta B del Concurso de investigación de modelos matemáticos de 2023? -csdn