『壹』 如何快捷計算大數乘法
首先，編程是最快的方法。
如果有計算器，可以將兩個30 位的數自右側起，每 7 位分割一次，
相當於把兩個數轉化為10000000 進制。
0000014 1592653 5897932 3846264 3383279
0000050 2884197 1693993 7510582 0974944
然後按照筆算乘法的規則，列豎式，把每個 7 位數當作一個 1 位數，
乘法和加法用前文提及的15位計算器計算。
比如最右側一位就是 3383279*0974944 = （進位 0329850） 7561376
這樣作 25 次乘法即可完成。
『貳』 如何實現大數相乘
網上搜的，評分較高的。
/*--------------------------------------------------------------------------
*函數名稱： 大數乘法
*函數過程：1 輸入兩個大數作為字元串
* 2 作一個雙向鏈表
* 3 兩個指針分別指向數字字元串的最低位
* 4 以第一個數的最低的一個位乘以第二個數的所有項存於鏈表中
* 5 鏈表首指針移
* 6 重復4，5依次從最低位乘到最高位
* 7 乘完後因為最低位是鏈表首，最後一位是鏈表尾。所以在逆順輸出鏈表。
* 4 直到循環結束
*入口參數：numa，numb，result字元串
*出口參數：無
*--------------------------------------------------------------------------*/
void multiply(char *numa, char *numb ,char *result)//用來儲結果的)//計算乘積
{
char *pna = findend(numa);//指向numa的一個指針。point numa pna 指向乘數的最低位，
char *pnb = findend(numb);//指向numb的一個指針 //pnb 指向被乘數的最低位，
int along=(int)strlen(numa);//標記數字a的長度；
int blong=(int)strlen(numb);//標記數字b的長度；
int carry=0,temp_result;//存貯進位 和臨時結果的
Node *head, // 用於存貯頭指針
*pstart, // 用於存貯計算時的首指針
*pnew, //作於申請新結點
*pgo; //作為每計算完一行時，回到下一行起始節點用,移位標致來用
head = pstart =new Node;//初始化首結點和頭結點。
pstart -> data = 0;
pstart -> next = NULL;
pstart -> ahead = NULL;
while (along--)
{
pgo = pstart;//保存進位點
blong = (int)strlen(numb);//初始化長度
pnb = findend(numb); //初始化指針
while ((blong-- && (blong>=0))|| carry != 0)
{
if(!pstart->next)//如果當前為空結點，則申請新結點
{
pnew = new Node;
pnew -> data = 0;
pnew -> next = NULL;
pnew -> ahead = pstart;
pstart -> next = pnew;
}
if(blong<0)temp_result = carry ;//處理只有進位的情況
else temp_result =(pstart->data+(*pna-48)*(*pnb-48)+carry);//自身值+新值+進位作為新值
pstart -> data = temp_result%10; //存貯個位
carry = temp_result/10; //存貯進位
pstart = pstart -> next; //結點移動
pnb--; //指針移向被乘數高位
}
pstart = pgo->next; //前進一個位置；
pna--; //指針移向乘數高位
}
pstart =head;//尋找鏈表的結尾點
while(pstart->next != 0)
{
pstart->data += 48;//!!<<<因為我們的輸出是字元。所以再此加上48>>>> 逆順輸出
pstart = pstart->next ;
}
int tip = 0;//轉為字元串用
pstart = pstart->ahead ;//找有效字
while(pstart != 0)//輸出正序的結果；
{
result[tip++] = pstart->data;
pstart = pstart->ahead ;
}
result[tip] = '\0';
pstart =head; //釋放空間
while(pstart->next != 0)
{
pnew = pstart->next ;delete pstart;
pstart =pnew;
}
return ;
}
『叄』 大數相乘 快速演算法
大數乘的最快演算法是快速傅立葉變換法，這有一個，但不是我本人寫的。
#include <iostream>
#include <cmath>
#include <complex>
#include <cstring>
using namespace std;
const double PI = acos(-1);
typedef complex<double> cp;
typedef long long int64;
const int N = 1 << 16;
int64 a[N], b[N], c[N << 1];
void bit_reverse_(cp a[], int n, cp b[])
{
int i, j, k, u, m;
for (u = 1, m = 0; u < n; u <<= 1, ++m);
for (i = 0; i < n; ++i)
{
j = i; k = 0;
for (u = 0; u < m; ++u, j >>= 1)
k = (k << 1) | (j & 1);
b[k] = a[i];
}
}
void FFT(cp _x[], int n, bool flag)
{
static cp x[N << 1];
bit_reverse_(_x, n, x);
int i, j, k, kk, p, m;
for (i = 1, m = 0; i < n; i <<= 1, ++m);
double alpha = 2 * PI;
if (flag) alpha = -alpha;
for (i = 0, k = 2; i < m; ++i, k <<= 1)
{
cp wn = cp(cos(alpha / k), sin(alpha / k));
for (j = 0; j < n; j += k)
{
cp w = 1, u, t;
kk = k >> 1;
for (p = 0; p < kk; ++p)
{
t = w * x[j + p + kk];
u = x[j + p];
x[j + p] = u + t;
x[j + p + kk] = u - t;
w *= wn;
}
}
}
memcpy(_x, x, sizeof(cp) * n);
}
void polynomial_multiply(int64 a[], int na, int64 b[], int nb, int64 c[], int &nc)
{
int i, n;
i = max(na, nb) << 1;
for (n = 1; n < i; n <<= 1);
static cp x[N << 1], y[N << 1];
for (i = 0; i < na; ++i) x[i] = a[i];
for (; i < n; ++i) x[i] = 0;
FFT(x, n, 0);
for (i = 0; i < nb; ++i) y[i] = b[i];
for (; i < n; ++i) y[i] = 0;
FFT(y, n, 0);
for (i = 0; i < n; ++i) x[i] *= y[i];
FFT(x, n, 1);
for (i = 0; i < n; ++i)
{
c[i] =(int64)(x[i].real() / n + 0.5);
}
for (nc = na + nb - 1; nc > 1 && !c[nc - 1]; --nc);
}
const int LEN = 5, MOD = 100000;
void convert(char *s, int64 a[], int &n)
{
int len = strlen(s), i, j, k;
for (n = 0, i = len - LEN; i >= 0; i -= LEN)
{
for (j = k = 0; j < LEN; ++j)
k = k * 10 + (s[i + j] - '0');
a[n++] = k;
}
i += LEN;
if (i)
{
for (j = k = 0; j < i; ++j)
k = k * 10 + (s[j] - '0');
a[n++] = k;
}
}
void print(int64 a[], int n)
{
printf("%I64d", a[--n]);
while (n) printf("%05I64d", a[--n]);
puts("");
}
char buf[N + 10];
int main()
{
int na, nb, nc;
while (scanf("%s", buf) != EOF)
{
bool sign = false;
if (buf[0] == '-')
{
sign = !sign;
convert(buf + 1, a, na);
}
else convert(buf, a, na);
scanf("%s", buf);
if (buf[0] == '-')
{
sign = !sign;
convert(buf + 1, b, nb);
}
else convert(buf, b, nb);
polynomial_multiply(a, na, b, nb, c, nc);
int64 t1, t2;
t1 = 0;
for (int i = 0; i < nc; ++i)
{
t2 = t1 + c[i];
c[i] = t2 % MOD;
t1 = t2 / MOD;
}
for (; t1; t1 /= MOD) c[nc++] = t1 % MOD;
if (sign) putchar('-');
print(c, nc);
}
return 0;
}
『肆』 乘法的簡便方法
乘法的簡便方法有：結合法，折數法，分解法，改數法。如計算下列算式：16×25×25
因為4×25＝100，而16＝4×4，由此可將兩個4分別與兩個25相乘，即原式可轉化為(4×25)x(4×25)。
16×25×25＝(4×25)x(4×25）
＝100×100
＝10000
『伍』 乘法簡便計算的方法規律
乘法（multiplication），是指將相同的數加起來的快捷方式。其運算結果稱為積，「x」是乘號。從哲學角度解析，乘法是加法的量變導致的質變結果。整數（包括負數），有理數（分數）和實數的乘法由這個基本定義的系統泛化來定義。
乘法也可以被視為計算排列在矩形（整數）中的對象或查找其邊長度給定的矩形的區域。 矩形的區域不取決於首先測量哪一側，這說明了交換屬性。 兩種測量的產物是一種新型的測量，例如，將矩形的兩邊的長度相乘給出其面積，這是尺寸分析的主題。
乘法是四則運算之一
例如4乘5，就是4增加了5倍率，也可以說成5個4連加。
使用鉛筆和紙張乘數的常用方法需要一個小數字（通常為0到9的任意兩個數字）的存儲或查詢產品的乘法表，但是一種農民乘法演算法的方法不是。
將數字乘以多於幾位小數位是繁瑣而且容易出錯的。發明了通用對數以簡化這種計算。幻燈片規則允許數字快速乘以大約三個准確度的地方。從二十世紀初開始，機械計算器，如Marchant，自動倍增多達10位數。現代電子計算機和計算器大大減少了用手倍增的需要。
3×5表示5個3相加
5x3表示3個5相加。
注意：1.在如上乘法表示什麼中，常把乘號後面的因數做為乘號前因數的倍數。
2.參見wiki中對乘數和被乘數的定義
另：乘法的新意義：乘法不是加法的簡單記法
Ⅰ 乘法原理：如果因變數f與自變數x1,x2,x3,….xn之間存在直接正比關系並且每個自變數存在質的不同，缺少任何一個自變數因變數f就失去其意義，則為乘法。
在概率論中，一個事件，出現結果需要分n個步驟，第1個步驟包括M1個不同的結果，第2個步驟包括M2個不同的結果，……，第n個步驟包括Mn個不同的結果。那麼這個事件可能出現N=M1×M2×M3×……×Mn個不同的結果。
Ⅱ 加法原理：如果因變數f與自變數(z1,z2,z3…, zn)之間存在直接正比關系並且每個自變數存在相同的質，缺少任何一個自變數因變數f仍然有其意義，則為加法。
在概率論中，一個事件，出現的結果包括n類結果，第1類結果包括M1個不同的結果，第2類結果包括M2個不同的結果，……，第n類結果包括Mn個不同的結果，那麼這個事件可能出現N=M1+M2+M3+……+Mn個不同的結果。
以上所說的質是按照自變數的作用來劃分的。
此原理是邏輯乘法和邏輯加法的定量表述。
法則
兩數相乘，同號得正，異號得負，並把絕對值相乘。
運算定律
整數的乘法運算滿足：交換律，結合律， 分配律，消去律。
隨著數學的發展， 運算的對象從整數發展為更一般群。
群中的乘法運算不再要求滿足交換律。 最有名的非交換例子，就是哈密爾頓發現的四元數群。 但是結合律仍然滿足。
1.乘法交換律： ，註：字母與字母相乘，乘號不用寫，或者可以寫成·。
2.乘法結合律： ，
3.乘法分配律： 。
『陸』 乘法簡便運算技巧
乘法簡便運算方法
一、結合法
一個數連續乘兩個一位數，可根據情況改寫成用這個數乘這兩個數的積的形式，使計算簡便。
例1 計算：19×4×5
19×4×5
＝19×（4×5）
＝19×20
＝380
在計算時，添加一個小括弧可以使計算簡便。因為括弧前是乘號，所以括弧內不變號。
二、分解法
一個數乘一個兩位數，可根據情況把這個兩位數分解成兩個一位數相乘的形式，再用這個數連續乘兩個一位數，使計算簡便。
例2 計算：45×18
48×18
＝45×（2×9）
＝45×2×9
＝90×9
＝810
將18分解成2×9的形式，再將括弧去掉，使計算簡便。
三、拆數法
有些題目，如果一步一步地進行計算，比較麻煩，我們可以根據因數及其他數的特徵，靈活運用拆數法進行簡便計算。
例3 計算：99×99＋199
（1）在計算時，可以把199寫成99＋100的形式，由此得到第一種簡便演算法：
99×99＋199
＝99×99＋99＋100
＝99×（99＋1）＋100
＝99×100＋100
＝10000
（2）把99寫成100－1的形式，199寫成100＋（100－1）的形式，可以得到第二種簡便演算法：
99×99＋199
＝（100－1）×99＋（100－1）＋100
＝（100－1）×（99＋1）＋100
＝（100－1）×100＋100
＝10000
四、改數法
有些題目，可以根據情況把其中的某個數進行轉化，創造條件化繁為簡。
例4 計算：25×5×48
25×5×48
＝25×5×4×12
＝（25×4）×（5×12）
＝100×60
＝6000
把48轉化成4×12的形式，使計算簡便。
例5 計算：16×25×25
因為4×25＝100，而16＝4×4，由此可將兩個4分別與兩個25相乘，即原式可轉化為：（4×25）×（4×25）。
16×25×25
＝（4×25）×（4×25）
＝100×100
＝10000
『柒』 乘法的簡便方法是什麼
一、30以內的兩個兩位數乘積的心算速算
1、兩個因數都在20以內，任意兩個20以內的兩個兩位數的積，都可以將其中一個因數的」尾數」移加到另一個因數上，然後補一個0，再加上兩「尾數」的積。例如：
11×11=120+1×1=121 12×13=150+2×3=156 13×13=160+3×3=169 14×16=200+4×6=224 16×18=240+6×8=288
2、兩個因數分別在10至20和20至30之間對於任意這樣兩個因數的積，都可以將較小的一個因數的「尾數」的2倍移加到另一個因數上，然後補一個0，再加上兩「尾數」的積。例如：
22×14=300+2×4=308
23×13=290+3×3=299
26×17=400+6×7=442
28×14=360+8×4=392
29×13=350+9×3=377
多位數乘法的快速計算方法如下：
1、 十幾乘十幾：口訣：頭乘頭，尾加尾，尾乘尾。例：12×14=？解: 1×1=12＋4＝62×4＝812×14=168註：個位相乘，不夠兩位數要用0佔位。
2、 頭相同，尾互補(尾相加等於10)：口訣：一個頭加1後，頭乘頭，尾乘尾。例：23×27=？解：2＋1＝32×3＝63×7＝2123×27=621註：個位相乘，不夠兩位數要用0佔位。
3、 第一個乘數互補，另一個乘數數字相同：口訣：一個頭加1後，頭乘頭，尾乘尾。例：37×44=？解：3+1=44×4=167×4=2837×44=1628註：個位相乘，不夠兩位數要用0佔位。
4、 幾十一乘幾十一：口訣：頭乘頭，頭加頭，尾乘尾。例：21×41=？解：2×4=82+4=61×1=121×41=861
5、 11乘任意數：口訣：首尾不動下落，中間之和下拉。例：11×23125=？解：2+3=53+1=41+2=32+5=72和5分別在首尾11×23125=254375註：和滿十要進一。
乘法原理：
如果因變數f與自變數x1,x2,x3,….xn之間存在直接正比關系並且每個自變數存在質的不同，缺少任何一個自變數因變數f就失去其意義，則為乘法。
在概率論中，一個事件，出現結果需要分n個步驟，第1個步驟包括M1個不同的結果，第2個步驟包括M2個不同的結果，……，第n個步驟包括Mn個不同的結果。那麼這個事件可能出現N=M1×M2×M3×……×Mn個不同的結果。
設 A是 m×n 的矩陣。
可以通過證明 Ax=0 和A'Ax=0 兩個n元齊次方程同解證得 r(A'A)=r(A)
1、Ax=0 肯定是 A'Ax=0 的解，好理解。
2、A'Ax=0 → x'A'Ax=0 → (Ax)' Ax=0 →Ax=0
故兩個方程是同解的。
同理可得 r(AA')=r(A')
另外 有 r(A)=r(A')
所以綜上 r(A)=r(A')=r(AA')=r(A'A)
『玖』 大數乘法 用什麼演算法啊
大數乘法基本上是乘法豎式筆算的代碼化。
基本功能有3個
1.
大數的數組表示。
2.
大數乘以小數，得到大數。
3.
大數加大數，得到大數。
對於1，其實就是int數組的每個元素存儲若干位。比如每個元素保存4個十進制位。[0]存儲個十百千，[1]存儲萬、十萬、百萬、千萬，諸如此類。一個數組保存一個大數。因此需要一個額外的int變數記錄當前數組用了多少個元素（類似於字元串長度）。
對於2，「小數」指的是能用一個int保存的數。注意這里只限4個二進制位（和1里提到的位數一致）。
比如1
2345
6789這個數字，[0]保存6789，[1]保存2345，[2]保存1。長度3。
這個大數乘以小數，比如9999，過程就是[0]
*
9999，即6789
*
9999
=
6788
3211，積的低四位（%10000）3211保存到積（大數）的[0]，剩下6788的進位到[1]。
然後2345
*
9999
= 2344
7655，加上剛才進位上來的6788得到2345
4443，其中4443保存到積（大數）的[1]中，2345進位到[2]。
以此類推。
對於3，基本只要一個for，對位相加然後注意進位就行了。
大數乘以大數，其實就是第一個大數先乘以第二個大數的[0]（大數乘小數，上面的2），得到一個大數a0；然後第一個大數乘以第二個大數的[1]，又得到一個大數a1……最後再將a0、a1、……加起來（也就是大數加法，上面的3）。加的時候要注意，a1的[0]要和a0的[1]對齊，a2的[0]要和a1的[1]和a0的[2]對齊……這個也和我們豎式筆算一樣。
ps：上面的演算法基本上是「10000進制數」的計算方式。如果數組的每個元素只保存1個十進制位，那就是10進制數。之所以用10000進制，純粹是程序員感覺上好一些。最有效的利用，是每個int保存2的15次方，也就是32768進制。要注意到，如果用10進制計算的話，程序的計算耗時會變成10000進制的16倍，也就是效率變成1/16。
ps2：用int數組的話，位數最多隻能是4位。因為5位數相乘可能得到11位數，超出了int表示範圍。