1. 什麼是最優適應分配演算法
分區分配演算法(Partitioning Placement Algorithm) ，共有3種。分別為最佳適應演算法、首次適應演算法、循環首次適應演算法。
1、最佳適應演算法（Best Fit）：
它從全部空閑區中找出能滿足作業要求的、且大小最小的空閑分區，這種方法能使碎片盡量小。為適應此演算法，空閑分區表（空閑區鏈）中的空閑分區要按大小從小到大進行排序，自表頭開始查找到第一個滿足要求的自由分區分配。該演算法保留大的空閑區，但造成許多小的空閑區。
2、首次適應演算法（First Fit）：
從空閑分區表的第一個表目起查找該表，把最先能夠滿足要求的空閑區分配給作業，這種方法目的在於減少查找時間。為適應這種演算法，空閑分區表（空閑區鏈）中的空閑分區要按地址由低到高進行排序。該演算法優先使用低址部分空閑區，在低址空間造成許多小的空閑區，在高地址空間保留大的空閑區。
3、循環首次適應演算法(Next Fit)：
該演算法是首次適應演算法的變種。在分配內存空間時，不再每次從表頭（鏈首）開始查找，而是從上次找到空閑區的下一個空閑開始查找，直到找到第一個能滿足要求的的空閑區為止，並從中劃出一塊與請求大小相等的內存空間分配給作業。該演算法能使內存中的空閑區分布得較均勻。
2. 求多個矩陣聯乘的最優演算法!
程序功能：用分而治之演算法計算兩個n維矩陣相乘的結果
其中n必須是2的正整數次冪。
運行過程：首先，根據提示輸入矩陣的維數n
其次，根據提示分別輸入矩陣A和B
最後，顯示矩陣A和矩陣B以及其相乘結果矩陣C
****************************************/
#include "stdio.h"
#define mytype int//矩陣元素的數據類型
#define myinputmode "%d"//矩陣元素的輸入格式
#define myprintmode "%4d"//矩陣元素的輸出格式
/*以上參數的設置可根據所計算矩陣的元素的數值類型進行相應改變
如更改為浮點型數據則可以使用下面的設置
#define mytype float
#define myinputmode "%f"
#define myprintmode "%6.2f"
*/
/////////////////////////////////////////
/****************************************
函數名：is2
參數：m為長整型整數
功能：檢測m是否是2的正整數次冪
返回值：返回布爾型變數
true則表示m為2的正整數次冪
false則表示m不是2的正整數次冪
****************************************/
bool is2(long m)
{
if(m<0)return false;
if(m>=2)
{
if((m%2)==0) return is2(m/2);
else return false;
}
else
{
if(m==1)return true;
else return false;
}
return false;
}
/////////////////////////////////////////
/****************************************
函數名：inputmatrix
參數：M為指向數組的指針，用來存儲輸入的矩陣
m長整型，是數組M所存矩陣的維數
name字元型數組，是需要進行數據輸入的矩陣的名字
功能：矩陣數據輸入的函數，通過輸入矩陣的每個元素將
矩陣存入數組
返回值：無
****************************************/
void inputmatrix(mytype * M,long m,char *name)
{
long i,j;
for(i=0;i<m;i++)
for(j=0;j<m;j++)
{
printf("Please input the %s(%d,%d):",name,i+1,j+1);
getchar();
scanf(myinputmode,&M[i*m+j]);
}
}
/////////////////////////////////////////
/****************************************
函數名：printmatrix
參數：M為指向數組的指針，數組中存儲著矩陣
m長整型，是數組M所存矩陣的維數
name字元型數組，是需要進行數據輸入的矩陣的名字
功能：矩陣數據輸出顯示的函數，將矩陣元素一一顯示一在屏幕上
返回值：無
****************************************/
void printmatrix(mytype * M,long m,char *name)
{
long i,j;
printf("\nMatrix %s:\n",name);
for(i=0;i<m;i++)
{
for(j=0;j<m;j++)
{
printf(myprintmode,M[i*m+j]);
}
printf("\n");
}
}
/////////////////////////////////////////
/****************************************
函數名：Matrix_add_sub
參數：A，B為指向數組的指針，數組中存儲著矩陣
C為指向數組的指針，用來存儲運算結果
m長整型，是數組A、B、C所存矩陣的維數
add為布爾型變數，為true則C=A+B，為false則C=A-B
功能：根據add值對A、B進行加減運算並將結果存入C
返回值：無
****************************************/
void Matrix_add_sub(mytype * A,mytype * B,mytype * C,long m,bool add)
{
long i;
for(i=0;i<m*m;i++)
{
if(add)
C[i]=A[i]+B[i];
else
C[i]=A[i]-B[i];
}
}
/////////////////////////////////////////
/****************************************
函數名：GetHalfValue
參數：B為指向數組的指針，數組中存儲著矩陣。其中B是指向m維矩陣中的一個元素。
A為指向數組的指針，用來接收B中的四分之一數據
m長整型，是數組B所指矩陣的維數
功能：從B所在位置向左和向右取矩陣的m/2維的子矩陣（子矩陣中包括B所指元素）並存入A
返回值：無
****************************************/
void GetHalfValue(mytype * A,mytype * B,long m)
{
long i,j;
for(i=0;i<m/2;i++)
{
for(j=0;j<m/2;j++)
{
A[i*m/2+j]=B[i*m+j];
}
}
}
/////////////////////////////////////////
/****************************************
函數名：UpdateHalfValue
參數：B為指向數組的指針，數組中存儲著矩陣。其中B是指向m維矩陣中的一個元素。
A為指向數組的指針，存儲著一個m/2維矩陣
m長整型，是數組B所指矩陣的維數
功能：把A矩陣所有元素存入從B所在位置向左和向右的m/2維的子矩陣（子矩陣中包括B所指元素）
返回值：無
****************************************/
void UpdateHalfValue(mytype * A,mytype * B,long m)
{
long i,j;
for(i=0;i<m/2;i++)
{
for(j=0;j<m/2;j++)
{
B[i*m+j]=A[i*m/2+j];
}
}
}
/////////////////////////////////////////
/****************************************
函數名：Matrix_multiplication
參數：A，B為指向數組的指針，數組中存儲著矩陣。
C為指向數組的指針，用來存儲計算結果
m長整型，是指針A、B所指矩陣的維數
功能：用分而治之演算法和Strassen方法計算A與B的乘積並存入C
返回值：無
****************************************/
void Matrix_multiplication(mytype * A,mytype * B,mytype * C,long m)
{
if(m>2)//當矩陣維數大於2時
{
//將矩陣A、B分為四個小矩陣，分別為A1、A2、A3、A4、B1、B2、B3、B4
mytype *A1=new mytype[m*m/4],*A2=new mytype[m*m/4],*A3=new mytype[m*m/4],*A4=new mytype[m*m/4],*B1=new mytype[m*m/4],*B2=new mytype[m*m/4],*B3=new mytype[m*m/4],*B4=new mytype[m*m/4],*C1=new mytype[m*m/4],*C2=new mytype[m*m/4],*C3=new mytype[m*m/4],*C4=new mytype[m*m/4];
GetHalfValue(A1,&A[0],m);
GetHalfValue(A2,&A[m/2],m);
GetHalfValue(A3,&A[m*m/2],m);
GetHalfValue(A4,&A[m*m/2+m/2],m);
GetHalfValue(B1,&B[0],m);
GetHalfValue(B2,&B[m/2],m);
GetHalfValue(B3,&B[m*m/2],m);
GetHalfValue(B4,&B[m*m/2+m/2],m);
//利用Strassen方法計算D、E、F、G、H、I、J
mytype *D=new mytype[m*m/4],*E=new mytype[m*m/4],*F=new mytype[m*m/4],*G=new mytype[m*m/4],*H=new mytype[m*m/4],*I=new mytype[m*m/4],*J=new mytype[m*m/4];
mytype *temp1=new mytype[m*m/4],*temp2=new mytype[m*m/4];
//D=A1(B2-B4)
Matrix_add_sub(B2,B4,temp1,m/2,false);
Matrix_multiplication(A1,temp1,D,m/2);
//E=A4(B3-B1)
Matrix_add_sub(B3,B1,temp1,m/2,false);
Matrix_multiplication(A4,temp1,E,m/2);
//F=(A3+A4)B1
Matrix_add_sub(A3,A4,temp1,m/2,true);
Matrix_multiplication(temp1,B1,F,m/2);
//G=(A1+A2)B4
Matrix_add_sub(A1,A2,temp1,m/2,true);
Matrix_multiplication(temp1,B4,G,m/2);
//H=(A3-A1)(B1+B2)
Matrix_add_sub(A3,A1,temp1,m/2,false);
Matrix_add_sub(B1,B2,temp2,m/2,true);
Matrix_multiplication(temp1,temp2,H,m/2);
//I=(A2-A4)(B3+B4)
Matrix_add_sub(A2,A4,temp1,m/2,false);
Matrix_add_sub(B3,B4,temp2,m/2,true);
Matrix_multiplication(temp1,temp2,I,m/2);
//J=(A1+A4)(B1+B4)
Matrix_add_sub(A1,A4,temp1,m/2,true);
Matrix_add_sub(B1,B4,temp2,m/2,true);
Matrix_multiplication(temp1,temp2,J,m/2);
//利用Strassen方法計算C1、C2、C3、C4
//C1=E+I+J-G
Matrix_add_sub(E,I,temp1,m/2,true);
Matrix_add_sub(J,G,temp2,m/2,false);
Matrix_add_sub(temp1,temp2,C1,m/2,true);
//C2=D+G
Matrix_add_sub(D,G,C2,m/2,true);
//C3=E+F
Matrix_add_sub(E,F,C3,m/2,true);
//C4=D+H+J-F
Matrix_add_sub(D,H,temp1,m/2,true);
Matrix_add_sub(J,F,temp2,m/2,false);
Matrix_add_sub(temp1,temp2,C4,m/2,true);
//將計算結果存入數組C
UpdateHalfValue(C1,&C[0],m);
UpdateHalfValue(C2,&C[m/2],m);
UpdateHalfValue(C3,&C[m*m/2],m);
UpdateHalfValue(C4,&C[m*m/2+m/2],m);
//釋放內存
delete[] A1,A2,A3,A4,B1,B2,B3,B4,C1,C2,C3,C4,D,E,F,G,H,I,J,temp1,temp2;
}
else
{
//當矩陣維數小於2時用Strassen方法計算矩陣乘積
mytype D,E,F,G,H,I,J;
//D=A1(B2-B4)
D=A[0]*(B[1]-B[3]);
//E=A4(B3-B1)
E=A[3]*(B[2]-B[0]);
//F=(A3+A4)B1
F=(A[2]+A[3])*B[0];
//G=(A1+A2)B4
G=(A[0]+A[1])*B[3];
//H=(A3-A1)(B1+B2)
H=(A[2]-A[0])*(B[0]+B[1]);
//I=(A2-A4)(B3+B4)
I=(A[1]-A[3])*(B[2]+B[3]);
//J=(A1+A4)(B1+B4)
J=(A[0]+A[3])*(B[0]+B[3]);
//C1=E+I+J-G
C[0]=E+I+J-G;
//C2=D+G
C[1]=D+G;
//C3=E+F
C[2]=E+F;
//C4=D+H+J-F
C[3]=D+H+J-F;
}
}
/////////////////////////////////////////
int main()
{
long n;
//提示輸入n維矩陣的維數
printf("Please input the dimension of the Matrix.(n):");
//獲得用戶輸入的n維矩陣維數
scanf("%d",&n);
while(!is2(n))//檢查維數是否是2的冪，不是則要求重新輸入
{
printf("Please reinput the dimension of the Matrix.(n):");
scanf("%d",&n);
}
//開辟空間存儲用來存儲n維矩陣元素
mytype *A=new mytype[n*n];
mytype *B=new mytype[n*n];
mytype *C=new mytype[n*n];
//輸入矩陣A、B
inputmatrix(A,n,"A");
inputmatrix(B,n,"B");
if(n>1)//矩陣維數大於1則用分而治之演算法計算
Matrix_multiplication(A,B,C,n);
else//矩陣維數為1則直接計算
*C=(*A)*(*B);
//輸出矩陣A、B、C
printmatrix(A,n,"A");
printmatrix(B,n,"B");
printmatrix(C,n,"C");
//釋放內存
delete[] A,B,C;
getchar();getchar();
return 1;
}
3. 請問數錢的貪婪演算法怎樣確保得到最優解
貪婪演算法：總是作出在當前看來是最好的選擇。也就是說，不從整體最優上加以考慮，它所做出的僅是在某種意義上的局部最優解。
（註：貪婪演算法不是對所有問題都能得到整體最優解，但對范圍相當廣泛的許多問題它能產生整體最優解。但其解必然是最優解的很好近似解。
基本思路：——從問題的某一個初始解出發逐步逼近給定的目標，以盡可能快的地求得更好的解。當達到某演算法中的某一步不能再繼續前進時，演算法停止
實現該演算法的過程：
從問題的某一初始解出發；
while 能朝給定總目標前進一步 do
求出可行解的一個解元素；
由所有解元素組合成問題的一個可行解；
基本要素：
1、 貪婪選擇性質：所求問題的整體最優解可以通過一系列局部最優的選擇，即貪婪選擇來達到。（與動態規劃的主要區別）
採用自頂向下，以迭代的方式作出相繼的貪婪選擇，每作一次貪婪選擇就將所求問題簡化為一個規模更小的子問題。
對於一個具體問題，要確定它是否具有貪婪選擇的性質，我們必須證明每一步所作的貪婪選擇最終導致問題的最優解。通常可以首先證明問題的一個整體最優解，是從貪婪選擇開始的，而且作了貪婪選擇後，原問題簡化為一個規模更小的類似子問題。然後，用數學歸納法證明，通過每一步作貪婪選擇，最終可得到問題的一個整體最優解。
2、最優子結構性質:包含子問題的最優解
1、 設有n個活動的安排，其中每個活動都要求使用同一資源，如演講會場，而在同一時間只允許一個活動使用這一資源。每個活動都有使用的起始時間和結束時間。問：如何安排可以使這間會場的使用率最高。
活動 起始時間 結束時間
1 1 4
2 3 5
3 0 6
4 5 7
5 3 8
6 5 9
7 6 10
8 8 11
9 8 12
10 2 13
11 12 14
演算法：一開始選擇活動1，然後依次檢查活動一i是否與當前已選擇的所有活動相容，若相容則活動加入到已選擇的活動集合中，否則不選擇活動i,而繼續檢查下一活動的相容性。即：活動i的開始時間不早於最近加入的活動j的結束時間。
Prodere plan;
Begin
n:=length[e];
a {1};
j:=1;
for i:=2 to n do
if s[i]>=f[j] then
begin a a∪{i};
j:=i;
end
end;
例1 [找零錢] 一個小孩買了價值少於1美元的糖，並將1美元的錢交給售貨員。售貨員希望用數目最少的硬幣找給小孩。假設提供了數目不限的面值為2 5美分、1 0美分、5美分、及1美分的硬幣。售貨員分步驟組成要找的零錢數，每次加入一個硬幣。選擇硬幣時所採用的貪婪准則如下：每一次選擇應使零錢數盡量增大。為保證解法的可行性（即：所給的零錢等於要找的零錢數），所選擇的硬幣不應使零錢總數超過最終所需的數目。
假設需要找給小孩6 7美分，首先入選的是兩枚2 5美分的硬幣，第三枚入選的不能是2 5美分的硬幣，否則硬幣的選擇將不可行（零錢總數超過6 7美分），第三枚應選擇1 0美分的硬幣，然後是5美分的，最後加入兩個1美分的硬幣。
貪婪演算法有種直覺的傾向，在找零錢時，直覺告訴我們應使找出的硬幣數目最少（至少是接近最少的數目）。可以證明採用上述貪婪演算法找零錢時所用的硬幣數目的確最少（見練習1）。
4. 怎樣應用貪心演算法求得最優解
動態規劃要求。。具有最優子結構，記f[i]最優時，f[i - 1]的解也最優。。。最終可以得到最優解
貪心演算法，一般只能得到近優解或者局部最優解。。
5. 數學建模怎樣處理一堆數據然後求出最優解
優化問題的話可以考慮用lingo求解，語法不難，看一個例子就會了，問題復雜的話需要比較長的時間，起碼是半個小時，有的還要一晚上，因為它是不停迭代求解。也可以用MATLAB進行演算法求解，比較著名的有模擬退火演算法，蟻群演算法，粒子群演算法等等，都有現成的程序。
6. 求數獨游戲最優演算法，該怎麼處理
一般的標准數獨的普通演算法就是暴搜，公認比較好的演算法就是舞蹈鏈Dancing Links，一些簡單的題目暴搜結合邏輯解法的剪枝可能時間優勢更大，幾年前最快的數獨演算法是一個叫周運棟的中國人的zsolve，具體演算法不詳，目前沒聽說還有更快的演算法 。
7. 什麼是網格搜索法如何用它來優化學習演算法
網格搜索法是指定參數值的一種窮舉搜索方法，通過將估計函數的參數通過交叉驗證的方法進行優化來得到最優的學習演算法。
即，將各個參數可能的取值進行排列組合，列出所有可能的組合結果生成「網格」。然後將各組合用於SVM訓練，並使用交叉驗證對表現進行評估。在擬合函數嘗試了所有的參數組合後，返回一個合適的分類器，自動調整至最佳參數組合，可以通過clf.best_params_獲得參數值
8. 求最優解的演算法
拉蛤螂日乘子法或線性規劃和非線性規劃，都可以得到最優解。
9. 迷宮問題得到最優演算法的條件是什麼
源程序：//base.h#include#include#include#defineTRUE1#defineFALSE0#defineOK1#defineERROR0#defineOVERFLOW-2typedefintStatus;//stack.h#include"base.h"#defineINIT_SIZE100//存儲空間初始分配量#defineINCREMENT10//存儲空間分配增量typedefstruct{//迷宮中r行c列的位置intr;intc;}PostType;typedefstruct{intord;//當前位置在路徑上的序號PostTypeseat;//當前坐標intdi;//往下一坐標的方向}SElemType;//棧元素類型typedefstruct{SElemType*base;//棧基址,構造前銷毀後為空SElemType*top;//棧頂intstackSize;//棧容量}Stack;//棧類型StatusInitStack(Stack&S){//構造空棧sS.base=(SElemType*)malloc(INIT_SIZE*sizeof(SElemType));if(!S.base)exit(OVERFLOW);//存儲分配失敗S.top=S.base;S.stackSize=INIT_SIZE;returnOK;}//InitStackStatusStackEmpty(StackS){//若s為空返回TRUE,否則返回FALSEif(S.top==S.base)returnTRUE;returnFALSE;}//StackEmptyStatusPush(Stack&S,SElemTypee){//插入元素e為新的棧頂元素if(S.top-S.base>=S.stackSize){//棧滿，加空間S.base=(SElemType*)realloc(S.base,(S.stackSize+INCREMENT)*sizeof(SElemType));if(!S.base)exit(OVERFLOW);//存儲分配失敗S.top=S.base+S.stackSize;S.stackSize+=INCREMENT;}*S.top++=e;returnOK;}//pushStatusPop(Stack&S,SElemType&e){//若棧不空刪除棧//頂元素用e返回並返回OK，否則返回ERRORif(S.top==S.base)returnERROR;e=*--S.top;returnOK;}//PopStatusDestroyStack(Stack&S){//銷毀棧S,free(S.base);S.top=S.base;returnOK;
10. 請牛人指點，如何以最優的演算法，對兩點間的距離進行排序
開一個計數數組vis[i]，一開始清零，然後輸入第一個數列，每輸入一個數x，就vis[x]++。這樣vis[i]代表i這個數字出現的次數。然後輸入第二個數列，每輸入一個數x，就vis[x]--，處理過程中檢查vis[x]是不是負數，如果是則說明兩個數列不相等，處理完之後，若vis[i]中全為0，說明相等。時間復雜度O(N)，空間復雜度O(maxnum) 當數據的數值范圍不大的時候可以使用這個方法。