Multiplikation in

10

Ich habe hier nachgesehen und festgestellt, dass die beste Laufzeit für die Multiplikation von zwei Bit-Zahlen , aber ich kann leicht einen Algorithmus feststellen, der in . $n$ $O(n\cdot \log n \cdot 2^{O(\log^* n)}$ $O(n\cdot \log n)$

Schließlich wissen wir, wie man zwei Polynome vom Grad in der Laufzeit multipliziert . Das Multiplizieren von Polynomen ist jedoch dasselbe wie das Multiplizieren von zwei Bit-Zahlen. Wir haben also einen Algorithmus, um zwei Bit-Zahlen in zu multiplizieren . Das einzige Problem, das auftreten kann, ist der Übertrag, aber in jeder Phase können wir das in -Zeit beheben, indem wir einfach das am weitesten rechts stehende Bit und seinen linken Nachbarn bis zum Ende bewegen. Das heißt, unsere Laufzeit soll bleiben $n$ $O(n \log n)$ $n$ $n$ $O(n \log n )$ $O(n)$ . $O(n \cdot \log n)$

Habe ich eine neue (und ziemlich offensichtliche) Entdeckung gemacht? Oder ist die Wikipedia-Seite veraltet? Oder habe ich vielleicht einen Fehler?

runtime-analysis

— TheEmeritus
quelle

Wie kann "wir wissen" "zwei Polynome vom Grad

in

Laufzeit multiplizieren "?

n

$n$

O (n \log n)

$O(n \log n)$

$\hspace{.46 in}$

8

Wie @DavidRicherby bereits betont, entsteht die Verwirrung, weil verschiedene Komplexitätsmaße verwechselt werden. Aber lassen Sie mich etwas näher darauf eingehen.

Wenn man Algorithmen zur Polynommultiplikation über beliebige Ringe untersucht, interessiert man sich normalerweise für die Anzahl der arithmetischen Operationen in dem Ring, die ein Algorithmus verwendet. Insbesondere benötigt der Schönhage-Strassen-Algorithmus bei einigen (kommutativen, einheitlichen) Ringen und zwei Polynomen mit einem Grad kleiner als Multiplikationen und Additionen in um zu berechnen $R$ $f,g \in R[X]$ $n$ $O(n \log{n} \log{\log{n}})$ $R$ $fg \in R[X]$ indem man ungefähr te primitive Wurzeln der Einheit an , um einen größeren Ring und dann unter Verwendung der schnellen Fourier-Transformation über das Produkt in berechnet . $n$ $R$ $D \supset R$ $D$ $D$

Wenn Ihr Ring eine te Wurzel der Einheit enthält, kann dies mithilfe der schnellen Fourier-Transformation direkt über auf -Operationen in beschleunigt werden . Genauer gesagt, über können Sie dies mit tun (ohne die Tatsache zu berücksichtigen, dass dies eine genaue Arithmetik über die komplexen Zahlen erfordern würde). $n$ $O(n \log n)$ $R$ $R$ $\mathbb{Z} \subset \mathbb{C}$ $O(n \log n)$

Die andere Maßnahme, die berücksichtigt werden kann, ist die Bitkomplexität einer Operation. Und das interessiert uns, wenn wir zwei ganze Zahlen der Bitlänge multiplizieren . Hier multiplizieren und addieren die primitiven Operationen zwei Ziffern (mit Übertrag). Wenn Sie also zwei Polynome mit multiplizieren , müssen Sie tatsächlich berücksichtigen, dass die während der Berechnung auftretenden Zahlen nicht mit einer konstanten Anzahl primitiver Operationen multipliziert werden können. Dies und die Tatsache, dass keine te primitive Einheitswurzel für hindert Sie daran, das anzuwenden. $n$ $\mathbb{Z}$ $\mathbb{Z}$ $n$ $n > 2$ $O(n \log n)$ Algorithmus. Sie dies überwinden durch Betrachtung mit den Koeffizienten aus dem Ring , da die Koeffizienten des Polynoms Produkt wird das nicht gebundene überschreiten. Dort (wenn eine Zweierpotenz ist) haben Sie (die Kongruenzklasse von) als te Wurzel der Einheit, und indem Sie den Algorithmus für Koeffizientenmultiplikationen rekursiv aufrufen, können Sie insgesamt primitive (dh Bit-) Operationen. Dies überträgt sich dann auf die ganzzahlige Multiplikation. $f,g$ $\mathbb{Z}/\langle 2^n + 1 \rangle$ $n$ $2$ $n$ $O(n \log n \log \log n)$

$f = \sum_{i=0}^n f_i X^i$ $x \in \mathbb{Z}$

f (x) = (\dots (f_{n} x + f_{n - 1}) x + \dots + \dots) + f_{0}

$f(x) = (\ldots (f_n x + f_{n-1})x + \ldots + \ldots) + f_0$

f

$f$

H = \sum_{i = 1}^{n / 2} f_{n / 2 + i} X^{i}

$H = \sum_{i=1}^{n/2} f_{n/2+i} X^i$

L = \sum_{i = 0}^{n / 2} f_{i} X^{i}

$L = \sum_{i=0}^{n/2} f_{i} X^i$

H

$H$

> n / 2

$>n/2$

L

$L$

\leq n / 2

$\leq n/2$

n

$n$ ist der Einfachheit halber eine Zweierpotenz).

$f(x)$

f (x) = H (x) x^{n / 2} + L (x)

$f(x) = H(x)x^{n/2} + L(x)$

$n$ $n + \log n$

$n/2$ $n/2$ $\Omega(n^2)$ $n$ $O(n)$ $O(n \log^c n) = \tilde{O}(n)$ $c > 0$

— Cornelius Brand
quelle

9

$n$ $O(n\log n)$ $n$ $O(2^{\log^*n}n\log n)$ $n$ $O(n\log n)$

— David Richerby
quelle

5

Ich denke nicht, dass dies das Problem ist. Wenn wir Zahlen als Polynome betrachten, deren "x" die Basis ist, z. B. 2, können wir typischerweise Polynome vom Grad Null (Zahlen kleiner als die Basis) in konstanter Zeit multiplizieren. Ich würde vermuten, dass das Problem darin besteht, dass der O (n * log n) -Algorithmus FFT verwendet und innerhalb des FFT-Algorithmus asymptotisch größere Zahlen auftreten können.

— JKFF