解決以下哪個問題的常規演算法

⑴ 解決問題的步驟 演算法

1、分析問題。

用電腦來解決問題時，首先電腦要對問題進行定性、定量的分析，然後才能設計演算法。定性分析法是對問題進行「質」的方面的分析，確定問題的性質，定量分析法，是對要解決的問題的數量特徵、數量關系與數量變化進行分析的方法。

2、設計演算法。

演算法（Algorithm）是指解題方案的准確而完整的描述，是一系列解決問題的清晰指令，演算法代表著用系統的方法描述解決問題的策略機制。也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。

不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。

3、編寫程序。

設計完演算法後，就要使用某種程序設計語言編寫程序代碼，並最終得到相應結果。編程的語言包括匯編語言、機器語言和高級語言。高級語言中最簡單、最常用的是Visual Basic語言和Pascal語言。

⑵ 我自學C程序設計，第二章習題 4.用傳統流程圖表示求解以下問題的演算法

不是打擊你的信心，其實學習C語言還是有老師教的好，因為有一些內容需要老師的講解才能夠理解，當然，興趣是最好的老師。不過我冒昧問你一下你學習C是為了什麼呢？是單純的興趣還是以後想深入研究的？如果是後者的話還是需要進入具體的學習才行，光靠自己的話可能不是很順利，不過建議你可以在網上找一些有關的大學的講座視頻，對你的學習有幫助；最後再提醒一下，其實我老師並沒有要求我們一定要嚴格地畫好流程圖，只要你把解決問題的思路編出來就行了，流程圖只是你解決問題的步驟而已；

⑶ 在解決下列各問題的演算法中,一定用到循環結構的是( )A、求函數當時的值...

利用演算法規則解決問題,如果一個問題出現了重復執行的步驟,則須用到循環結構,由此規則對四個選項進行探究得出正確結論即可.
解:由循環結構的特徵對四界上選項進行判斷
選項用不到循環結構,代入求值,用順序結構就可解決;
選項一定用到循環結構,用二分法求最值,取中點驗證函數值的符號等步驟要重復執行;
選項用不到循環結構,用順序結構即可解決問題;
選項用不到循環結構,將給定的三個實數按從小到大排列,用判斷結構就可解決問題;
故選.
本題考查設計程序框圖解決實際問題,解題的關鍵是對所面對的問題的演算法進行分析,探討其解決的方式以確定用那種結構將其表達出來.

⑷ 看下面的四段話，其中是解決問題的演算法的是（）A．把高一5班的同學分成兩組，高個子參加籃球賽，矮個

演算法是一系列解決問題的清晰指令．所以：
A選項：身高沒有明確，所以A錯誤；
B選項：學生的身高明確，解決了學生打球問題，所以B正確；
C選項：做飯不一定用米，所以C不正確；
D選項：從2開始寫起，後一個數為前一個數與2的和，不斷地寫，寫出所有偶數，這是不可能進行的，所以D不正確；
故選：B．

⑸ lIG演算法解決了apriori演算法的什麼問題

關聯分析是一種在大規模數據集中尋找有趣關系的任務。Apriori是解決這一問題的基本演算法。這個演算法也是數據挖掘的入門演算法。
Apriori演算法的功能是尋找所有支持度不小於minsup的項集。項集的支持度是指包含該項集的事務所佔所有事務的比例。
頻繁項集就是指滿足給定的最小支持度的項集。Apriori的關鍵在於它使用了一種分層的完備搜索演算法。

⑹ 解決某問題有三種演算法，復雜性分別為……問在同樣時間內可處理問題的大小，結果怎麼來的求步驟。如圖

S1速度和規模成正比例線性關系，很好理解
S2換個說法：當計算規模增大到多少時計算時間變為原來的10倍，那麼對於時間復雜度是N²的演算法來說，時間的增長幅度是計算規模增長幅度的平方，假設規模到K的時候，時間增長10倍，那麼就有（K平方/S2平方）=10 得 k/s2=√10 的k=3.16*S2
S3: 對於₂ⁿ的時間復雜度來說，同樣假設規模到K的時候，時間增長10倍，那麼就有(2的K次方/2的S3次方)=10 得k=s3+log₂10=S3+3.32

⑺ 大數據最常用的演算法有哪些

奧地利符號計算研究所(Research Institute for Symbolic Computation，簡稱RISC)的Christoph Koutschan博士在自己的頁面上發布了一篇文章，提到他做了一個調查，參與者大多數是計算機科學家，他請這些科學家投票選出最重要的演算法，以下是這次調查的結果，按照英文名稱字母順序排序。

大數據等最核心的關鍵技術：32個演算法

1、A* 搜索演算法——圖形搜索演算法，從給定起點到給定終點計算出路徑。其中使用了一種啟發式的估算，為每個節點估算通過該節點的最佳路徑，並以之為各個地點排定次序。演算法以得到的次序訪問這些節點。因此，A*搜索演算法是最佳優先搜索的範例。

2、集束搜索(又名定向搜索，Beam Search)——最佳優先搜索演算法的優化。使用啟發式函數評估它檢查的每個節點的能力。不過，集束搜索只能在每個深度中發現最前面的m個最符合條件的節點，m是固定數字——集束的寬度。

3、二分查找(Binary Search)——在線性數組中找特定值的演算法，每個步驟去掉一半不符合要求的數據。

4、分支界定演算法(Branch and Bound)——在多種最優化問題中尋找特定最優化解決方案的演算法，特別是針對離散、組合的最優化。

5、Buchberger演算法——一種數學演算法，可將其視為針對單變數最大公約數求解的歐幾里得演算法和線性系統中高斯消元法的泛化。

6、數據壓縮——採取特定編碼方案，使用更少的位元組數(或是其他信息承載單元)對信息編碼的過程，又叫來源編碼。

7、Diffie-Hellman密鑰交換演算法——一種加密協議，允許雙方在事先不了解對方的情況下，在不安全的通信信道中，共同建立共享密鑰。該密鑰以後可與一個對稱密碼一起，加密後續通訊。

8、Dijkstra演算法——針對沒有負值權重邊的有向圖，計算其中的單一起點最短演算法。

9、離散微分演算法(Discrete differentiation)。

10、動態規劃演算法(Dynamic Programming)——展示互相覆蓋的子問題和最優子架構演算法

11、歐幾里得演算法(Euclidean algorithm)——計算兩個整數的最大公約數。最古老的演算法之一，出現在公元前300前歐幾里得的《幾何原本》。

12、期望-最大演算法(Expectation-maximization algorithm，又名EM-Training)——在統計計算中，期望-最大演算法在概率模型中尋找可能性最大的參數估算值，其中模型依賴於未發現的潛在變數。EM在兩個步驟中交替計算，第一步是計算期望，利用對隱藏變數的現有估計值，計算其最大可能估計值;第二步是最大化，最大化在第一步上求得的最大可能值來計算參數的值。

13、快速傅里葉變換(Fast Fourier transform，FFT)——計算離散的傅里葉變換(DFT)及其反轉。該演算法應用范圍很廣，從數字信號處理到解決偏微分方程，到快速計算大整數乘積。

14、梯度下降(Gradient descent)——一種數學上的最優化演算法。

15、哈希演算法(Hashing)。

16、堆排序(Heaps)。

17、Karatsuba乘法——需要完成上千位整數的乘法的系統中使用，比如計算機代數系統和大數程序庫，如果使用長乘法，速度太慢。該演算法發現於1962年。

18、LLL演算法(Lenstra-Lenstra-Lovasz lattice rection)——以格規約(lattice)基數為輸入，輸出短正交向量基數。LLL演算法在以下公共密鑰加密方法中有大量使用：背包加密系統(knapsack)、有特定設置的RSA加密等等。

19、最大流量演算法(Maximum flow)——該演算法試圖從一個流量網路中找到最大的流。它優勢被定義為找到這樣一個流的值。最大流問題可以看作更復雜的網路流問題的特定情況。最大流與網路中的界面有關，這就是最大流-最小截定理(Max-flow min-cut theorem)。Ford-Fulkerson 能找到一個流網路中的最大流。

20、合並排序(Merge Sort)。

21、牛頓法(Newton』s method)——求非線性方程(組)零點的一種重要的迭代法。

22、Q-learning學習演算法——這是一種通過學習動作值函數(action-value function)完成的強化學習演算法，函數採取在給定狀態的給定動作，並計算出期望的效用價值，在此後遵循固定的策略。Q-leanring的優勢是，在不需要環境模型的情況下，可以對比可採納行動的期望效用。

23、兩次篩法(Quadratic Sieve)——現代整數因子分解演算法，在實踐中，是目前已知第二快的此類演算法(僅次於數域篩法Number Field Sieve)。對於110位以下的十位整數，它仍是最快的，而且都認為它比數域篩法更簡單。

24、RANSAC——是「RANdom SAmple Consensus」的縮寫。該演算法根據一系列觀察得到的數據，數據中包含異常值，估算一個數學模型的參數值。其基本假設是：數據包含非異化值，也就是能夠通過某些模型參數解釋的值，異化值就是那些不符合模型的數據點。

25、RSA——公鑰加密演算法。首個適用於以簽名作為加密的演算法。RSA在電商行業中仍大規模使用，大家也相信它有足夠安全長度的公鑰。

26、Sch?nhage-Strassen演算法——在數學中，Sch?nhage-Strassen演算法是用來完成大整數的乘法的快速漸近演算法。其演算法復雜度為：O(N log(N) log(log(N)))，該演算法使用了傅里葉變換。

27、單純型演算法(Simplex Algorithm)——在數學的優化理論中，單純型演算法是常用的技術，用來找到線性規劃問題的數值解。線性規劃問題包括在一組實變數上的一系列線性不等式組，以及一個等待最大化(或最小化)的固定線性函數。

28、奇異值分解(Singular value decomposition，簡稱SVD)——在線性代數中，SVD是重要的實數或復數矩陣的分解方法，在信號處理和統計中有多種應用，比如計算矩陣的偽逆矩陣(以求解最小二乘法問題)、解決超定線性系統(overdetermined linear systems)、矩陣逼近、數值天氣預報等等。

29、求解線性方程組(Solving a system of linear equations)——線性方程組是數學中最古老的問題，它們有很多應用，比如在數字信號處理、線性規劃中的估算和預測、數值分析中的非線性問題逼近等等。求解線性方程組，可以使用高斯—約當消去法(Gauss-Jordan elimination)，或是柯列斯基分解( Cholesky decomposition)。

30、Strukturtensor演算法——應用於模式識別領域，為所有像素找出一種計算方法，看看該像素是否處於同質區域( homogenous region)，看看它是否屬於邊緣，還是是一個頂點。

31、合並查找演算法(Union-find)——給定一組元素，該演算法常常用來把這些元素分為多個分離的、彼此不重合的組。不相交集(disjoint-set)的數據結構可以跟蹤這樣的切分方法。合並查找演算法可以在此種數據結構上完成兩個有用的操作：

查找：判斷某特定元素屬於哪個組。

合並：聯合或合並兩個組為一個組。

32、維特比演算法(Viterbi algorithm)——尋找隱藏狀態最有可能序列的動態規劃演算法，這種序列被稱為維特比路徑，其結果是一系列可以觀察到的事件，特別是在隱藏的Markov模型中。

以上就是Christoph博士對於最重要的演算法的調查結果。你們熟悉哪些演算法?又有哪些演算法是你們經常使用的?

⑻ 誰知到高精度演算法（加減乘除）pascal的常規方法啊

所謂的高精度運算,是指參與運算的數(加數,減數,因子……）范圍大大超出了標准數據類型（整型，實型）能表示的范圍的運算。例如，求兩個200位的數的和。這時，就要用到高精度演算法了。在這里，我們先討論高精度加法。高精度運算主要解決以下三個問題：
一、加數、減數、運算結果的輸入和存儲
運算因子超出了整型、實型能表示的范圍，肯定不能直接用一個數的形式來表示。在Pascal中，能表示多個數的數據類型有兩種：數組和字元串。
數組：每個數組元素存儲1位（在優化時，這里是一個重點！），有多少位就需要多少個數組元素；用數組表示數的優點：每一位都是數的形式，可以直接加減；運算時非常方便。用數組表示數的缺點：數組不能直接輸入；輸入時每兩位數之間必須有分隔符，不符合數值的輸入習慣；
字元串：字元串的最大長度是255，可以表示255位。用字元串表示數的優點：能直接輸入輸出，輸入時，每兩位數之間不必分隔符，符合數值的輸入習慣；用字元串表示數的缺點：字元串中的每一位是一個字元，不能直接進行運算，必須先將它轉化為數值再進行運算；運算時非常不方便；
綜合以上所述，對上面兩種數據結構取長補短：用字元串讀入數據，用數組存儲數據：
var s1,s2:string;
a,b,c:array [1..260] of integer;
i,l,k1,k2:integer;
begin
write('input s1:');readln(s1);
write('input s2:');readln(s2);
{————讀入兩個數s1，s2，都是字元串類型}
l:=length(s1);{求出s1的長度，也即s1的位數；有關字元串的知識。}
k1:=260;
for i:=l downto 1 do
begin
a[k1]:=ord(s1)-48;{將字元轉成數值}
k1:=k1-1;
end;
k1:=k1+1;
{————以上將s1中的字元一位一位地轉成數值並存在數組a中；低位在後（從第260位開始），高位在前（每存完一位，k1減1），完後，k1指向最高位}
對s2的轉化過程和上面一模一樣。
二、運算過程
在往下看之前，大家先列豎式計算35+86。
注意的問題：
（1）運算順序：兩個數靠右對齊；從低位向高位運算；先計算低位再計算高位；
（2）運算規則：同一位的兩個數相加再加上從低位來的進位，成為該位的和；這個和去掉向高位的進位就成為該位的值；如上例：3+8+1=12，向前一位進1，本位的值是2；可藉助MOD、DIV運算完成這一步；
（3）最後一位的進位：如果完成兩個數的相加後，進位位值不為0，則應添加一位；
（4）如果兩個加數位數不一樣多，則按位數多的一個進行計算；
if k1>k2 then k:=k1 else k:=k2;
y:=0;
for i:=260 downto k do
begin
x:=a+b+y;
c:=x mod 10;
y:=x div 10;
end;
if y<>0 then begin k:=k-1;c[k]:=y; end;
三、結果的輸出（這也是優化的一個重點）
按運算結果的實際位數輸出
for i:=k to 260 do write(c);
writeln;
例子：求兩個數的加法
program sum;
var s,s1,s2:string;
a,b,c:array [1..260] of integer;
i,l,k1,k2:integer;
begin
write('input s1:');readln(s1);
write('input s2:');readln(s2);
l:=length(s1);
k1:=260;
for i:=l downto 1 do
begin
a[k1]:=ord(s1)-48;
k1:=k1-1;
end;
k1:=k1+1;
l:=length(s2);
k2:=260;
for I+:=l downto 1 do
begin
b[k2]:=ord(s2)-48;
k2:=k2-1;
end;
k2:=k2+1;
if k1>k2 then k:=k2 else k:=k1;
y:=0;
for i:=260 downto k do
begin
x:=a+b+y;
c:=x mod 10;
y:=x div 10;
end;
if y<>0 then begin k:=k-1;c[k]:=y;
end;
for i:=k to 260 do write(c);
writeln;
end.
四、優化：
以上的方法的有明顯的缺點：
（1）浪費空間：一個整型變數（-32768~32767）只存放一位（0~9）；
（2）浪費時間：一次加減只處理一位；
針對以上問題，我們做如下優化：一個數組元素存放四位數；（integer的最大范圍是32767，5位的話可能導致出界）。具體方法：
l:=length(s1);
k1:=260;
repeat {————有關字元串的知識}
s:=(s1,l-3,4);
val(s,a[k1],code);
k1:=k1-1;
s1:=(s1,1,l-4);
l:=l-4;
until l<=0;
k1:=k1+1;
而因為這個改進，演算法要相應改變：
（1）運算時：不再逢十進位，而是逢萬進位（mod 10000; div 10000);
（2）輸出時：最高位直接輸出，其餘各位，要判斷是否足夠4位，不足部分要補0；例如：1，23，2345這樣三段的數，輸出時，應該是100232345而不是1234567。
改進後的演算法：
program sum;
var s1,s2,s:string;
a,b,c:array [1..260] of integer;
i,l,k1,k2,code:integer;
begin
write('input s1:');readln(s1);
write('input s2:');readln(s2);
l:=length(s1);
k1:=260;
repeat {————有關字元串的知識}
s:=(s1,l-3,4);
val(s,a[k1],code);
k1:=k1-1;
s1:=(s1,1,l-4);
l:=l-4;
until l<=0;
k1:=k1+1;
l:=length(s2);
k2:=260;
repeat
s:=(s2,l-3,4);
val(s,b[k2],code);
k2:=k2-1;
s2:=(s2,1,l-4);
l:=l-4;
until l<=0;
k2:=k2+1;
if k1<k2 then k:=k1 else k:=k2;
y:=0;
for i:=260 downto k do
begin
x:=a+b+y;
c:=x mod 10000;
y:=x div 10000;
end;
if y<>0 then begin k:=k-1;c[k]:=y;end;
write(c[k]);
for i:=k+1 to 260 do
begin
if c<1000 then write('0');
if c<100 then write('0');
if c<10 then write('0');
write(c);
end;
writeln;
end.
減法：和高精度加法相比，減法在差為負數時處理的細節更多一點：當被減數小於減數時，差為負數，差的絕對值是減數減去被減數；在程序實現上用一個變數來存儲符號位，用另一個數組存差的絕對值。
2、演算法流程：
（1）讀入被減數S1，S2（字元串）；
（2）置符號位：判斷被減數是否大於減數：大則將符號位置為空；小則將符號位置為「-」，交換減數與被減數；
（3）被減數與減數處理成數值，放在數組中；
（4）運算：
A、取數；
B、判斷是否需要借位；
C、減，將運算結果放到差數組相應位中；
D、判斷是否運算完成：是，轉5；不是，轉A；
（5）列印結果：符號位，第1位，循環處理第2到最後一位；
3、細節：
▲如何判斷被減數與減數的大小：字元串知識
（1）首先將兩個字元串的位數補成一樣(因為字元串的比較是從左邊對齊的；兩個字元串一樣長才能真正地比較出大小)：短的在左邊補0
k1:=length(s1);
k2:=length(s2);
if k1>k2 then for i:=1 to k1-k2 do s2:='0'+s2
else for i:=1 to k2-k1 do s1:='0'+s1;
（2）接著比較大小：直接比較字元串大小
fh:='';
if s1<s2 then begin fh:='-';s:=s1; s1:=s2; s2:=s; end;
{————s1存被減數，fh存符號}
▲將字元串處理成數值：
l:=length(s1);{求出s1的長度，也即s1的位數；有關字元串的知識。}
k1:=260;
for i:=l downto 1 do
begin
a[k1]:=ord(s1)-48;{將字元轉成數值}
k1:=k1-1;
end;
k1:=k1+1;
▲運算（減法跟加法比較，減法退位處理跟加法進位處理不一樣）：
a.處理退位；
跟加法一樣，在for語句外面先將退位清零，
用被減數再減去退位，
{注意：由於每一個數位不一定都得向前一位借位，所以這里退位得清零。例如，234-25，個位需借位，而十位不用}
接著，再判斷，當被減數某一位不夠減時，則需加上前一位退位過來的數。
{注意：由於這里採用優化方法，所以退一位，就等於後一位加上10000。）
最後，再拿一個數組來存儲兩個減數的差。
jw:=0;
for i:=260 downto k1 do
begin
a:=a-jw; {此處jw為下一位從I位的借位}
jw:=0; {此處jw為I 位準備向上一位的借位}
if a<b then
begin
jw:=1;
a:=a+10000;
end;
c:=a-b;
end;
▲列印結果：
先找到差的第一個非零數，如果差的所有位數都為零，就直接輸出零。
如果不是，就輸出符號位和差的第一位。
剩下部分，列印補足零:
因為優化後的高精度減法,是把每四個數位分成一段,而每一段則必須有四個
數,當有一段不足四個數時,就得用"0"補足.(如:第一位是'1',第二位是'34',第三位是'345',第四位是'8', 則應寫為'1003403450008').注意:第一位不用補零,(如:第一位為'3',則寫成'3').
while (c[k]=0) and (k<=260) do k:=k+1;
if k>260 then write('0')
else begin
write(fh,c[k]);{k是差的第1位；}
for i:=k+1 to 260 do
begin
if c<1000 then write('0');
if c<100 then write('0');
if c<10 then write('0');
write(c);
end;
end;
參考程序：
program Zfjianfa;
const n=25;
var s1,s2,s3,s4,s:string;
a,b,c:array[1..n] of integer;
i,k1,k2,l,code,jw:integer;
cq:char;
begin
readln(s1);
readln(s2);
k1:=length(s1);
k2:=length(s2);
if k1>k2 then for i:=1 to k1-k2 do s2:='0'+s2
else for i:=1 to k2-k1 do s1:='0'+s1;
cq:=' ';
if s1<s2 then begin cq:='-'; s:=s1; s1:=s2; s2:=s; end;
l:=length(s1);
k1:=n;
repeat
s3:=(s1,l-3,4);
val(s3,a[k1],code);
k1:=k1-1;
delete(s1,l-3,4);
l:=l-4;
until l<=0;
k1:=k1+1;
i:=length(s2);
k2:=n;
repeat
s4:=(s2,i-3,4);
val(s4,b[k2],code);
k2:=k2-1;
delete(s2,i-3,4);
i:=i-4;
until i<=0;
k2:=k2+1;
jw:=0;
for i:=n downto k1 do
begin
a:=a-jw;
jw:=0;
if a<b then begin
jw:=1;
a:=a+10000;
end;
c:=a-b;
end;
while (c[k1]=0) and (k1<=n) do
k1:=k1+1;
if k1>n then writeln('0')
else begin
write(cq,c[k1]);
for i:=k1+1 to n do
begin
if c<1000 then write('0');
if c<100 then write('0');
if c<10 then write('0');
write(c);
end;
end;
writeln;
end.
高精度乘法基本思想和加法一樣。其基本流程如下：
①讀入被乘數s1，乘數s2
②把s1、s2分成4位一段，轉成數值存在數組a,b中；記下a,b的長度k1,k2；
③i賦為b中的最低位；
④從b中取出第i位與a相乘，累加到另一數組c中；（注意：累加時錯開的位數應是多少位？）
⑤i:=i-1；檢測i值：小於k2則轉⑥,否則轉④
⑥列印結果
參考程序：
program chengfa;
const n=100;
type ar=array [1..n] of integer;
var a,b:ar; k1,k2,k:integer;
c:array [1..200] of integer;
s1,s2:string;
procere fenge(s:string;var d:ar; var kk:integer); {將s分割成四位一組存放在d中，返回的kk值指向d的最高位}
var ss:string;
i,code:integer;
begin
i:=length(s);
kk:=n;
repeat
ss:=(s,i-3,4);
val(ss,d[kk],code);
kk:=kk-1;
s:=(s,1,i-4);
i:=i-4;
until i<0;
kk:=kk+1;
end;
procere init;
var i:integer;
begin
for i:=1 to n do begin a:=0; b:=0; end;
for i:=1 to 2*n do c:=0;
write('input 2 numbers:');
readln(s1);
readln(s2);
fenge(s1,a,k1);
fenge(s2,b,k2);
end;
procere jisuan;
var i,j,m:integer; x,y,z,jw:longint;
begin
i:=n; k:=2*n;
repeat
x:=b; z:=0; m:=k; jw:=0;
for j:=n downto k1 do
begin
y:=a[j];
z:=c[m];
x:=x*y+z+jw;
jw:=x div 10000;
c[m]:=x mod 10000;
m:=m-1;
x:=b;
end;
if jw<>0 then c[m]:=jw else m:=m+1;
i:=i-1;
k:=k-1;
until i<k2;
k:=m;
end;
procere daying;
var i:integer;
begin
write(c[k]);
for i:=k+1 to 2*n do
begin
if c<1000 then write('0');
if c<100 then write('0');
if c<10 then write('0');
write(c);
end;
writeln;
end;
begin
init;
jisuan;
daying;
end.
教材「基礎編」P87高精乘法參考程序：
program ex3_1;
var
a,b,c:array[0..1000] of word;
procere init;
var
s:string;
ok,i,j:integer;
begin
readln(s);
a[0]:=length(s);
for i:=1 to a[0] do
val(s[a[0]-i+1],a,ok);
readln(s);
b[0]:=length(s);
b[0]:=length(s);
for i:=1 to b[0] do
val(s[b[0]-i+1],b,ok);
end;
procere highmul;
var i,j,k:integer;
begin
c[0]:=a[0]+b[0];
for i:=1 to b[0] do
for j:=1 to a[0]+1 do
begin
inc(c[i+j-1],a[j]*b mod 10);
c[i+j]:=c[i+j]+(a[j]*b div 10)+(c[i+j-1] div 10);
c[i+j-1]:=c[i+j-1] mod 10;
end;
end;
procere print;
var i:integer;
begin
while c[c[0]]=0 do dec(c[0]);
for i:=c[0] downto 1 do
write(c);
writeln;
end;
begin
init;
highmul;
print;
end.
高精度除法：
1）.高精度除以整型數據(integer);
程序如下:
program HighPrecision3_Multiply1;
const
fn_inp='hp5.inp';
fn_out='hp5.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x,y:hp;
z,w:integer;
procere PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s);
end;
procere init;
var
st:string;
i:integer;
begin
assign(input,fn_inp);
reset(input);
readln(st);
x.len:=length(st);
for i:=1 to x.len do { change string to HP }
x.s:=ord(st[x.len+1-i])-ord('0');
readln(z);
close(input);
end;
procere Divide(a:hp;b:integer;var c:hp;var d:integer);
{ c:=a div b ; d:=a mod b }
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
len:=a.len;
d:=0;
for i:=len downto 1 do { from high to low }
begin
d:=d*10+a.s;
c.s:=d div b;
d:=d mod b;
end;
while(len>1) and (c.s[len]=0) do dec(len);
c.len:=len;
end;
procere main;
begin
Divide(x,z,y,w);
end;
procere out;
begin
assign(output,fn_out);
rewrite(output);
PrintHP(y);
writeln;
writeln(w);
close(output);
end;
begin
init;
main;
out;
end.
2）.高精度除以高精度
程序如下:
program HighPrecision4_Multiply2;
const
fn_inp='hp6.inp';
fn_out='hp6.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x:array[1..2] of hp;
y,w:hp; { x:input ; y:output }
procere PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s);
end;
procere init;
var
st:string;
j,i:integer;
begin
assign(input,fn_inp);
reset(input);
for j:=1 to 2 do
begin
readln(st);
x[j].len:=length(st);
for i:=1 to x[j].len do { change string to HP }
x[j].s:=ord(st[x[j].len+1-i])-ord('0');
end;
close(input);
end;
procere Subtract(a,b:hp;var c:hp); { c:=a-b, suppose a>=b }
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
if a.len>b.len then len:=a.len { get the bigger length of a,b }
else len:=b.len;
for i:=1 to len do { subtract from low to high }
begin
inc(c.s,a.s-b.s);
if c.s<0 then
begin
inc(c.s,10);
dec(c.s[i+1]); { add 1 to a higher position }
end;
end;
while(len>1) and (c.s[len]=0) do dec(len);
c.len:=len;
end;
function Compare(const a,b:hp):integer;
{
1 if a>b
0 if a=b
-1 if a < b
}
var len:integer;
begin
if a.len>b.len then len:=a.len { get the bigger length of a,b }
else len:=b.len;
while(len>0) and (a.s[len]=b.s[len]) do dec(len);
{ find a position which have a different digit }
if len=0 then compare:=0 { no difference }
else compare:=a.s[len]-b.s[len];
end;
procere Multiply10(var a:hp); { a:=a*10 }
var i:Integer;
begin
for i:=a.len downto 1 do
a.s[i+1]:=a.s;
a.s[1]:=0;
inc(a.len);
while(a.len>1) and (a.s[a.len]=0) do dec(a.len);
end;
procere Divide(a,b:hp;var c,d:hp); { c:=a div b ; d:=a mod b }
var i,j,len:integer;
begin
fillchar(c,sizeof(c),0);
len:=a.len;
fillchar(d,sizeof(d),0);
d.len:=1;
for i:=len downto 1 do
begin
Multiply10(d);
d.s[1]:=a.s; { d:=d*10+a.s }
{ c.s:=d div b ; d:=d mod b; }
{ while(d>=b) do begin d:=d-b;inc(c.s) end }
while(compare(d,b)>=0) do
begin
Subtract(d,b,d);
inc(c.s);
end;
end;
while(len>1)and(c.s[len]=0) do dec(len);
c.len:=len;
end;
procere main;
begin
Divide(x[1],x[2],y,w);
end;
procere out;
begin
assign(output,fn_out);
rewrite(output);
PrintHP(y);
writeln;
PrintHP(w);
writeln;
close(output);
end;
begin
init;
main;
out;
end.

⑼ 機器學習一般常用的演算法有哪些

機器學習是人工智慧的核心技術，是學習人工智慧必不可少的環節。機器學習中有很多演算法，能夠解決很多以前難以企的問題，機器學習中涉及到的演算法有不少，下面小編就給大家普及一下這些演算法。

一、線性回歸

一般來說，線性回歸是統計學和機器學習中最知名和最易理解的演算法之一。這一演算法中我們可以用來預測建模，而預測建模主要關注最小化模型誤差或者盡可能作出最准確的預測，以可解釋性為代價。我們將借用、重用包括統計學在內的很多不同領域的演算法，並將其用於這些目的。當然我們可以使用不同的技術從數據中學習線性回歸模型，例如用於普通最小二乘法和梯度下降優化的線性代數解。就目前而言，線性回歸已經存在了200多年，並得到了廣泛研究。使用這種技術的一些經驗是盡可能去除非常相似（相關）的變數，並去除噪音。這是一種快速、簡單的技術。

二、Logistic 回歸

它是解決二分類問題的首選方法。Logistic 回歸與線性回歸相似，目標都是找到每個輸入變數的權重，即系數值。與線性回歸不同的是，Logistic 回歸對輸出的預測使用被稱為 logistic 函數的非線性函數進行變換。logistic 函數看起來像一個大的S，並且可以將任何值轉換到0到1的區間內。這非常實用，因為我們可以規定logistic函數的輸出值是0和1並預測類別值。像線性回歸一樣，Logistic 回歸在刪除與輸出變數無關的屬性以及非常相似的屬性時效果更好。它是一個快速的學習模型，並且對於二分類問題非常有效。

三、線性判別分析（LDA）

在前面我們介紹的Logistic 回歸是一種分類演算法，傳統上，它僅限於只有兩類的分類問題。而LDA的表示非常簡單直接。它由數據的統計屬性構成，對每個類別進行計算。單個輸入變數的 LDA包括兩個，第一就是每個類別的平均值，第二就是所有類別的方差。而在線性判別分析，進行預測的方法是計算每個類別的判別值並對具備最大值的類別進行預測。該技術假設數據呈高斯分布，因此最好預先從數據中刪除異常值。這是處理分類預測建模問題的一種簡單而強大的方法。

四、決策樹

決策樹是預測建模機器學習的一種重要演算法。決策樹模型的表示是一個二叉樹。這是演算法和數據結構中的二叉樹，沒什麼特別的。每個節點代表一個單獨的輸入變數x和該變數上的一個分割點。而決策樹的葉節點包含一個用於預測的輸出變數y。通過遍歷該樹的分割點，直到到達一個葉節點並輸出該節點的類別值就可以作出預測。當然決策樹的有點就是決策樹學習速度和預測速度都很快。它們還可以解決大量問題，並且不需要對數據做特別准備。

五、樸素貝葉斯

其實樸素貝葉斯是一個簡單但是很強大的預測建模演算法。而這個模型由兩種概率組成，這兩種概率都可以直接從訓練數據中計算出來。第一種就是每個類別的概率，第二種就是給定每個 x 的值，每個類別的條件概率。一旦計算出來，概率模型可用於使用貝葉斯定理對新數據進行預測。當我們的數據是實值時，通常假設一個高斯分布，這樣我們可以簡單的估計這些概率。而樸素貝葉斯之所以是樸素的，是因為它假設每個輸入變數是獨立的。這是一個強大的假設，真實的數據並非如此，但是，該技術在大量復雜問題上非常有用。所以說，樸素貝葉斯是一個十分實用的功能。

六、K近鄰演算法

K近鄰演算法簡稱KNN演算法，KNN 演算法非常簡單且有效。KNN的模型表示是整個訓練數據集。KNN演算法在整個訓練集中搜索K個最相似實例（近鄰）並匯總這K個實例的輸出變數，以預測新數據點。對於回歸問題，這可能是平均輸出變數，對於分類問題，這可能是眾數類別值。而其中的訣竅在於如何確定數據實例間的相似性。如果屬性的度量單位相同，那麼最簡單的技術是使用歐幾里得距離，我們可以根據每個輸入變數之間的差值直接計算出來其數值。當然，KNN需要大量內存或空間來存儲所有數據，但是只有在需要預測時才執行計算。我們還可以隨時更新和管理訓練實例，以保持預測的准確性。

七、Boosting 和 AdaBoost

首先，Boosting 是一種集成技術，它試圖集成一些弱分類器來創建一個強分類器。這通過從訓練數據中構建一個模型，然後創建第二個模型來嘗試糾正第一個模型的錯誤來完成。一直添加模型直到能夠完美預測訓練集，或添加的模型數量已經達到最大數量。而AdaBoost 是第一個為二分類開發的真正成功的 boosting 演算法。這是理解 boosting 的最佳起點。現代 boosting 方法建立在 AdaBoost 之上，最顯著的是隨機梯度提升。當然，AdaBoost 與短決策樹一起使用。在第一個決策樹創建之後，利用每個訓練實例上樹的性能來衡量下一個決策樹應該對每個訓練實例付出多少注意力。難以預測的訓練數據被分配更多權重，而容易預測的數據分配的權重較少。依次創建模型，每一個模型在訓練實例上更新權重，影響序列中下一個決策樹的學習。在所有決策樹建立之後，對新數據進行預測，並且通過每個決策樹在訓練數據上的精確度評估其性能。所以說，由於在糾正演算法錯誤上投入了太多注意力，所以具備已刪除異常值的干凈數據十分重要。

八、學習向量量化演算法（簡稱 LVQ）

學習向量量化也是機器學習其中的一個演算法。可能大家不知道的是，K近鄰演算法的一個缺點是我們需要遍歷整個訓練數據集。學習向量量化演算法（簡稱 LVQ）是一種人工神經網路演算法，它允許你選擇訓練實例的數量，並精確地學習這些實例應該是什麼樣的。而學習向量量化的表示是碼本向量的集合。這些是在開始時隨機選擇的，並逐漸調整以在學習演算法的多次迭代中最好地總結訓練數據集。在學習之後，碼本向量可用於預測。最相似的近鄰通過計算每個碼本向量和新數據實例之間的距離找到。然後返回最佳匹配單元的類別值或作為預測。如果大家重新調整數據，使其具有相同的范圍，就可以獲得最佳結果。當然，如果大家發現KNN在大家數據集上達到很好的結果，請嘗試用LVQ減少存儲整個訓練數據集的內存要求

⑽ 計算機解決問題的演算法有哪三種

應該是定點運算，浮點運算和邏輯運算吧。