最速下降法c語言
真不容易啊，怕是沒人弄了!
優先順序調度演算法程序:
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
typedef struct node
{
char name[10]; /*進程標識符*/
int prio; /*進程優先數*/
int round; /*進程時間輪轉時間片*/
int cputime; /*進程佔用CPU時間*/
int needtime; /*進程到完成還要的時間*/
int count; /*計數器*/
char state; /*進程的狀態*/
struct node *next; /*鏈指針*/
}PCB;
PCB *finish,*ready,*tail,*run; /*隊列指針*/
int N; /*進程數*/
/*將就緒隊列中的第一個進程投入運行*/
firstin()
{
run=ready; /*就緒隊列頭指針賦值給運行頭指針*/
run->state='R'; /*進程狀態變為運行態*/
ready=ready->next; /*就緒對列頭指針後移到下一進程*/
}
/*標題輸出函數*/
void prt1(char a)
{
if(toupper(a)=='P') /*優先數法*/
printf(" name cputime needtime priority state\n");
else
printf(" name cputime needtime count round state\n");
}
/*進程PCB輸出*/
void prt2(char a,PCB *q)
{
if(toupper(a)=='P') /*優先數法的輸出*/
printf(" %-10s%-10d%-10d%-10d %c\n",q->name,
q->cputime,q->needtime,q->prio,q->state);
else/*輪轉法的輸出*/
printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,
q->cputime,q->needtime,q->count,q->round,q->state);
}
/*輸出函數*/
void prt(char algo)
{
PCB *p;
prt1(algo); /*輸出標題*/
if(run!=NULL) /*如果運行指針不空*/
prt2(algo,run); /*輸出當前正在運行的PCB*/
p=ready; /*輸出就緒隊列PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
p=finish; /*輸出完成隊列的PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
getch(); /*壓任意鍵繼續*/
}
/*優先數的插入演算法*/
insert1(PCB *q)
{
PCB *p1,*s,*r;
int b;
s=q; /*待插入的PCB指針*/
p1=ready; /*就緒隊列頭指針*/
r=p1; /*r做p1的前驅指針*/
b=1;
while((p1!=NULL)&&b) /*根據優先數確定插入位置*/
if(p1->prio>=s->prio)
{
r=p1;
p1=p1->next;
}
else
b=0;
if(r!=p1) /*如果條件成立說明插入在r與p1之間*/
{
r->next=s;
s->next=p1;
}
else
{
s->next=p1; /*否則插入在就緒隊列的頭*/
ready=s;
}
}
/*輪轉法插入函數*/
insert2(PCB *p2)
{
tail->next=p2; /*將新的PCB插入在當前就緒隊列的尾*/
tail=p2;
p2->next=NULL;
}
/*優先數創建初始PCB信息*/
void create1(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL; /*就緒隊列頭指針*/
finish=NULL; /*完成隊列頭指針*/
run=NULL; /*運行隊列指針*/
printf("Enter name and time of process\n"); /*輸入進程標識和所需時間創建PCB*/
for(i=1;i<=N;i++)
{
p=malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='w';
p->prio=50-time;
if(ready!=NULL) /*就緒隊列不空調用插入函數插入*/
insert1(p);
else
{
p->next=ready; /*創建就緒隊列的第一個PCB*/
ready=p;
}
}
clrscr();
printf(" output of priority:\n");
printf("************************************************\n");
prt(alg); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
/*輪轉法創建進程PCB*/
void create2(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("Enter name and time of round process\n");
for(i=1;i<=N;i++)
{
p=malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->count=0; /*計數器*/
p->state='w';
p->round=2; /*時間片*/
if(ready!=NULL)
insert2(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
clrscr();
printf(" output of round\n");
printf("************************************************\n");
prt(alg); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
/*優先數調度演算法*/
priority(char alg)
{
while(run!=NULL) /*當運行隊列不空時，有進程正在運行*/
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->prio=run->prio-3; /*每運行一次優先數降低3個單位*/
if(run->needtime==0) /*如所需時間為0將其插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F'; /*置狀態為完成態*/
run=NULL; /*運行隊列頭指針為空*/
if(ready!=NULL) /*如就緒隊列不空*/
firstin(); /*將就緒對列的第一個進程投入運行*/
}
else /*沒有運行完同時優先數不是最大，則將其變為就緒態插入到就緒隊列*/
if((ready!=NULL)&&(run->prio<ready->prio))
{
run->state='W';
insert1(run);
firstin(); /*將就緒隊列的第一個進程投入運行*/
}
prt(alg); /*輸出進程PCB信息*/
}
}
/*時間片輪轉法*/
roundrun(char alg)
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->count=run->count+1;
if(run->needtime==0)/*運行完將其變為完成態，插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就緒對列不空，將第一個進程投入運行*/
}
else
if(run->count==run->round) /*如果時間片到*/
{
run->count=0; /*計數器置0*/
if(ready!=NULL) /*如就緒隊列不空*/
{
run->state='W'; /*將進程插入到就緒隊列中等待輪轉*/
insert2(run);
firstin(); /*將就緒對列的第一個進程投入運行*/
}
}
prt(alg); /*輸出進程信息*/
}
}
/*主函數*/
main()
{
char algo; /*演算法標記*/
clrscr();
printf("type the algorithm:P/R(priority/roundrobin)\n");
scanf("%c",&algo); /*輸入字元確定演算法*/
printf("Enter process number\n");
scanf("%d",&N); /*輸入進程數*/
if(algo=='P'||algo=='p')
{
create1(algo); /*優先數法*/
priority(algo);
}
else
if(algo=='R'||algo=='r')
{
create2(algo); /*輪轉法*/
roundrun(algo);
}
}
⑵ 在C語言中，什麼是迭代法
迭代法也稱輾轉法，是一種不斷用變數的舊值遞推新值的過程，跟迭代法相對應的是直接法，即一次性解決問題。迭代法又分為精確迭代和近似迭代。「二分法」和「牛頓迭代法」屬於近似迭代法。迭代演算法是用計算機解決問題的一種基本方法。它利用計算機運算速度快、適合做重復性操作的特點，讓計算機對一組指令（或一定步驟）進行重復執行，在每次執行這組指令（或這些步驟）時，都從變數的原值推出它的一個新值。
迭代是數值分析中通過從一個初始估計出發尋找一系列近似解來解決問題（一般是解方程或者方程組）的過程，為實現這一過程所使用的方法統稱為迭代法（Iterative Method）。
一般可以做如下定義：對於給定的線性方程組x=Bx+f（這里的x、B、f同為矩陣，任意線性方程組都可以變換成此形式），用公式x(k+1）=Bx(k)+f（括弧中為上標，代表迭代k次得到的x，初始時k=0)逐步帶入求近似解的方法稱為迭代法（或稱一階定常迭代法）。如果k趨向無窮大時limx（k）存在，記為x*，稱此迭代法收斂。顯然x*就是此方程組的解，否則稱為迭代法發散。
跟迭代法相對應的是直接法（或者稱為一次解法），即一次性的快速解決問題，例如通過開方解決方程x +3= 4。一般如果可能，直接解法總是優先考慮的。但當遇到復雜問題時，特別是在未知量很多，方程為非線性時，我們無法找到直接解法（例如五次以及更高次的代數方程沒有解析解，參見阿貝耳定理），這時候或許可以通過迭代法尋求方程（組）的近似解。
最常見的迭代法是牛頓法。其他還包括最速下降法、共軛迭代法、變尺度迭代法、最小二乘法、線性規劃、非線性規劃、單純型法、懲罰函數法、斜率投影法、遺傳演算法、模擬退火等等。
利用迭代演算法解決問題，需要做好以下三個方面的工作：
確定迭代變數
在可以用迭代演算法解決的問題中，至少存在一個直接或間接地不斷由舊值遞推出新值的變數，這個變數就是迭代變數。
建立迭代關系式
所謂迭代關系式，指如何從變數的前一個值推出其下一個值的公式（或關系）。迭代關系式的建立是解決迭代問題的關鍵，通常可以順推或倒推的方法來完成。
對迭代過程進行控制
在
什麼時候結束迭代過程？這是編寫迭代程序必須考慮的問題。不能讓迭代過程無休止地重復執行下去。迭代過程的控制通常可分為兩種情況：一種是所需的迭代次數
是個確定的值，可以計算出來；另一種是所需的迭代次數無法確定。對於前一種情況，可以構建一個固定次數的循環來實現對迭代過程的控制；對於後一種情況，需
要進一步分析出用來結束迭代過程的條件。
舉例
例 1 ：一個飼養場引進一隻剛出生的新品種兔子，這種兔子從出生的下一個月開始，每月新生一隻兔子，新生的兔子也如此繁殖。如果所有的兔子都不死去，問到第 12 個月時，該飼養場共有兔子多少只？
分析：這是一個典型的遞推問題。我們不妨假設第 1 個月時兔子的只數為 u 1 ，第 2 個月時兔子的只數為 u 2 ，第 3 個月時兔子的只數為 u 3 ，……根據題意，「這種兔子從出生的下一個月開始，每月新生一隻兔子」，則有
u 1 = 1 ， u 2 = u 1 + u 1 × 1 = 2 ， u 3 = u 2 + u 2 × 1 = 4 ，……
根據這個規律，可以歸納出下面的遞推公式：
u n = u(n － 1）× 2 (n ≥ 2）
對應 u n 和 u(n － 1），定義兩個迭代變數 y 和 x ，可將上面的遞推公式轉換成如下迭代關系：
y=x*2
x=y
讓計算機對這個迭代關系重復執行 11 次，就可以算出第 12 個月時的兔子數。參考程序如下：
cls
x=1
for i=2 to 12
y=x*2
x=y
next i
print y
end
例 2 ：阿米巴用簡單分裂的方式繁殖，它每分裂一次要用 3 分鍾。將若干個阿米巴放在一個盛滿營養參液的容器內， 45 分鍾後容器內充滿了阿米巴。已知容器最多可以裝阿米巴 220,220個。試問，開始的時候往容器內放了多少個阿米巴？請編程序算出。
分析：根據題意，阿米巴每 3 分鍾分裂一次，那麼從開始的時候將阿米巴放入容器裡面，到 45
分鍾後充滿容器，需要分裂 45/3=15 次。而「容器最多可以裝阿米巴2^ 20 個」，即阿米巴分裂 15 次以後得到的個數是
2^20。題目要求我們計算分裂之前的阿米巴數，不妨使用倒推的方法，從第 15 次分裂之後的 2^20 個，倒推出第 15 次分裂之前（即第 14
次分裂之後）的個數，再進一步倒推出第 13 次分裂之後、第 12 次分裂之後、……第 1 次分裂之前的個數。
設第 1 次分裂之前的個數為 x 0 、第 1 次分裂之後的個數為 x 1 、第 2 次分裂之後的個數為 x 2 、……第 15 次分裂之後的個數為 x 15 ，則有
x 14 =x 15 /2 、 x 13 =x 14 /2 、…… x n-1 =x n /2 (n ≥ 1）
因為第 15 次分裂之後的個數 x 15 是已知的，如果定義迭代變數為 x ，則可以將上面的倒推公式轉換成如下的迭代公式：
x=x/2 （x 的初值為第 15 次分裂之後的個數 2^20）
讓這個迭代公式重復執行 15 次，就可以倒推出第 1 次分裂之前的阿米巴個數。因為所需的迭代次數是個確定的值，我們可以使用一個固定次數的循環來實現對迭代過程的控制。參考程序如下：
cls
x=2^20
for i=1 to 15
x=x/2
next i
print x
end
ps:java中冪的演算法是Math.pow（2,20）；返回double，稍微注意一下
例 3 ：驗證谷角猜想。日本數學家谷角靜夫在研究自然數時發現了一個奇怪現象：對於任意一個自然數 n ，若 n 為偶數，則將其除以 2 ；若 n 為奇數，則將其乘以 3 ，然後再加 1。如此經過有限次運算後，總可以得到自然數 1。人們把谷角靜夫的這一發現叫做「谷角猜想」。
要求：編寫一個程序，由鍵盤輸入一個自然數 n ，把 n 經過有限次運算後，最終變成自然數 1 的全過程列印出來。
分析：定義迭代變數為 n ，按照谷角猜想的內容，可以得到兩種情況下的迭代關系式：當 n 為偶數時， n=n/2 ；當 n 為奇數時， n=n*3+1。用 QBASIC 語言把它描述出來就是：
if n 為偶數 then
n=n/2
else
n=n*3+1
end if
這就是需要計算機重復執行的迭代過程。這個迭代過程需要重復執行多少次，才能使迭代變數 n 最終變成自然數 1
，這是我們無法計算出來的。因此，還需進一步確定用來結束迭代過程的條件。仔細分析題目要求，不難看出，對任意給定的一個自然數 n
，只要經過有限次運算後，能夠得到自然數 1 ，就已經完成了驗證工作。因此，用來結束迭代過程的條件可以定義為：n=1。參考程序如下：
cls
input "Please input n=";n
do until n=1
if n mod 2=0 then
rem 如果 n 為偶數，則調用迭代公式 n=n/2
n=n/2
print "—";n;
else
n=n*3+1
print "—";n;
end if
loop
end
迭代法開平方：
#include<stdio.h>
#include<math.h>
void main()
{
double a,x0,x1;
printf("Input a:\n");
scanf("%lf",&a);//為什麼在VC6.0中不能寫成「scanf("%f",&a）；」？
if(a<0)
printf("Error!\n");
else
{
x0=a/2;
x1=(x0+a/x0)/2;
do
{
x0=x1;
x1=(x0+a/x0)/2;
}while(fabs(x0-x1）>=1e-6）；
}
printf("Result:\n");
printf("sqrt(%g)=%g\n",a,x1）；
}
求平方根的迭代公式：x1=1/2*(x0+a/x0）。
演算法：1.先自定一個初值x0，作為a的平方根值，在我們的程序中取a/2作為a的初值；利用迭代公式求出一個x1。此值與真正的a的平方根值相比，誤差很大。
⒉把新求得的x1代入x0中，准備用此新的x0再去求出一個新的x1.
⒊利用迭代公式再求出一個新的x1的值，也就是用新的x0又求出一個新的平方根值x1，此值將更趨近於真正的平方根值。
⒋比較前後兩次求得的平方根值x0和x1，如果它們的差值小於我們指定的值，即達到我們要求的精度，則認為x1就是a的平方根值，去執行步驟5；否則執行步驟2，即循環進行迭代。
迭代法是用於求方程或方程組近似根的一種常用的演算法設計方法。設方程為f(x)=0，用某種數學方法導出等價的形式x=g(x），然後按以下步驟執行：
⑴ 選一個方程的近似根，賦給變數x0；
⑵ 將x0的值保存於變數x1，然後計算g(x1），並將結果存於變數x0；
⑶ 當x0與x1的差的絕對值還小於指定的精度要求時，重復步驟⑵的計算。
若方程有根，並且用上述方法計算出來的近似根序列收斂，則按上述方法求得的x0就認為是方程的根。上述演算法用C程序的形式表示為：
【演算法】迭代法求方程的根
{ x0=初始近似根；
do {
x1=x0；
x0=g(x1）； /*按特定的方程計算新的近似根*/
} while (fabs(x0-x1）>Epsilon）；
printf（「方程的近似根是%f\n」，x0）；
}
迭代演算法也常用於求方程組的根，令
X=（x0，x1，…，xn-1）
設方程組為：
xi=gi(X) (I=0，1，…，n-1）
則求方程組根的迭代演算法可描述如下：
【演算法】迭代法求方程組的根
{ for (i=0;i
x=初始近似根；
do {
for (i=0;i
y=x;
for (i=0;i
x=gi(X);
for (delta=0.0,i=0;i
if (fabs(y-x)>delta) delta=fabs(y-x）；
} while (delta>Epsilon）；
for (i=0;i
printf（「變數x[%d]的近似根是 %f」，I，x）；
printf（「\n」）；
}
具體使用迭代法求根時應注意以下兩種可能發生的情況：
⑴ 如果方程無解，演算法求出的近似根序列就不會收斂，迭代過程會變成死循環，因此在使用迭代演算法前應先考察方程是否有解，並在程序中對迭代的次數給予限制；
⑵ 方程雖然有解，但迭代公式選擇不當，或迭代的初始近似根選擇不合理，也會導致迭代失敗。
遞歸
遞歸是設計和描述演算法的一種有力的工具，由於它在復雜演算法的描述中被經常採用，為此在進一步介紹其他演算法設計方法之前先討論它。
能採用遞歸描述的演算法通常有這樣的特徵：為求解規模為N的問題，設法將它分解成規模較小的問題，然後從這些小問題的解方便地構造出大問題的解，並且這些規模較小的問題也能採用同樣的分解和綜合方法，分解成規模更小的問題，並從這些更小問題的解構造出規模較大問題的解。特別地，當規模N=1時，能直接得解。
【問題】 編寫計算斐波那契（Fibonacci）數列的第n項函數fib（n）。
斐波那契數列為：0、1、1、2、3、……，即：
fib(0)=0;
fib⑴=1;
fib(n)=fib(n-1）+fib(n-2） （當n>1時）。
寫成遞歸函數有：
int fib(int n)
{ if (n==0) return 0;
if (n==1） return 1;
if (n>1） return fib(n-1）+fib(n-2）；
}
遞歸演算法的執行過程分遞推和回歸兩個階段。在遞推階段，把較復雜的問題（規模為n）的求解推到比原問題簡單一些的問
題（規模小於n）的求解。例如上例中，求解fib(n），把它推到求解fib(n-1）和fib(n-2）。也就是說，為計算fib(n），必須先計算
fib(n-1）和fib(n-
2），而計算fib(n-1）和fib(n-2），又必須先計算fib(n-3）和fib(n-4）。依次類推，直至計算fib⑴和fib(0），分別能
立即得到結果1和0。在遞推階段，必須要有終止遞歸的情況。例如在函數fib中，當n為1和0的情況。
在回歸階段，當獲得最簡單情況的解後，逐級返回，依次得到稍復雜問題的解，例如得到fib⑴和fib(0）後，返回得到fib⑵的結果，……，在得到了fib(n-1）和fib(n-2）的結果後，返回得到fib(n）的結果。
在編寫遞歸函數時要注意，函數中的局部變數和參數知識局限於當前調用層，當遞推進入「簡單問題」層時，原來層次上的參數和局部變數便被隱蔽起來。在一系列「簡單問題」層，它們各有自己的參數和局部變數。
由於遞歸引起一系列的函數調用，並且可能會有一系列的重復計算，遞歸演算法的執行效率相對較低。當某個遞歸演算法能較方便地轉換成遞推演算法時，通常按遞推演算法編寫程序。例如上例計算斐波那契數列的第n項的函數fib(n）應採用遞推演算法，即從斐波那契數列的前兩項出發，逐次由前兩項計算出下一項，直至計算出要求的第n項。
【問題】 組合問題
問題描述：找出從自然數1、2、……、n中任取r個數的所有組合。例如n=5，r=3的所有組合為：⑴5、4、3 ⑵5、4、2 ⑶5、4、1
⑷5、3、2 ⑸5、3、1 ⑹5、2、1
⑺4、3、2 ⑻4、3、1 ⑼4、2、1
⑽3、2、1
分析所列的10個組合，可以採用這樣的遞歸思想來考慮求組合函數的演算法。設函數為void comb(int
m,int
k）為找出從自然數1、2、……、m中任取k個數的所有組合。當組合的第一個數字選定時，其後的數字是從餘下的m-1個數中取k-1數的組合。這就將求m
個數中取k個數的組合問題轉化成求m-1個數中取k-1個數的組合問題。設函數引入工作數組a[
]存放求出的組合的數字，約定函數將確定的k個數字組合的第一個數字放在a[k]中，當一個組合求出後，才將a[
]中的一個組合輸出。第一個數可以是m、m-1、……、k，函數將確定組合的第一個數字放入數組後，有兩種可能的選擇，因還未去頂組合的其餘元素，繼續遞
歸去確定；或因已確定了組合的全部元素，輸出這個組合。細節見以下程序中的函數comb。
【程序】
# include
# define MAXN 100
int a[MAXN];
void comb(int m,int k)
{ int i,j;
for (i=m;i>=k;i--)
{ a[k]=i;
if (k>1）
comb(i-1,k-1）；
else
{ for (j=a[0];j>0;j--)
printf（「%4d」，a[j]);
printf（「\n」）；
}
}
}
void main()
{ a[0]=3;
comb（5,3）；
}
【問題】 背包問題
問題描述：有不同價值、不同重量的物品n件，求從這n件物品中選取一部分物品的選擇方案，使選中物品的總重量不超過指定的限制重量，但選中物品的價值之和最大。
設n
件物品的重量分別為w0、w1、…、wn-1，物品的價值分別為v0、v1、…、vn-1。採用遞歸尋找物品的選擇方案。設前面已有了多種選擇的方案，並
保留了其中總價值最大的方案於數組option[ ]，該方案的總價值存於變數maxv。當前正在考察新方案，其物品選擇情況保存於數組cop[
]。假定當前方案已考慮了前i-1件物品，現在要考慮第i件物品；當前方案已包含的物品的重量之和為tw；至此，若其餘物品都選擇是可能的話，本方案能達
到的總價值的期望值為tv。演算法引入tv是當一旦當前方案的總價值的期望值也小於前面方案的總價值maxv時，繼續考察當前方案變成無意義的工作，應終止
當前方案，立即去考察下一個方案。因為當方案的總價值不比maxv大時，該方案不會被再考察，這同時保證函數後找到的方案一定會比前面的方案更好。
對於第i件物品的選擇考慮有兩種可能：
⑴ 考慮物品i被選擇，這種可能性僅當包含它不會超過方案總重量限制時才是可行的。選中後，繼續遞歸去考慮其餘物品的選擇。
⑵ 考慮物品i不被選擇，這種可能性僅當不包含物品i也有可能會找到價值更大的方案的情況。
按以上思想寫出遞歸演算法如下：
try（物品i，當前選擇已達到的重量和，本方案可能達到的總價值tv)
{ /*考慮物品i包含在當前方案中的可能性*/
if（包含物品i是可以接受的）
{ 將物品i包含在當前方案中；
if (i
try(i+1,tw+物品i的重量，tv);
else
/*又一個完整方案，因為它比前面的方案好，以它作為最佳方案*/
以當前方案作為臨時最佳方案保存；
恢復物品i不包含狀態；
}
/*考慮物品i不包含在當前方案中的可能性*/
if （不包含物品i僅是可男考慮的）
if (i
try(i+1,tw,tv-物品i的價值）；
else
/*又一個完整方案，因它比前面的方案好，以它作為最佳方案*/
以當前方案作為臨時最佳方案保存；
}
為了理解上述演算法，特舉以下實例。設有4件物品，它們的重量和價值見表：
物品 0 1 2 3
重量 5 3 2 1
價值 4 4 3 1
並設限制重量為7。則按以上演算法，下圖表示找解過程。由圖知，一旦找到一個解，演算法就進一步找更好的佳。如能判定某個查找分支不會找到更好的解，演算法不會在該分支繼續查找，而是立即終止該分支，並去考察下一個分支。
按上述演算法編寫函數和程序如下：
【程序】
# include
# define N 100
double limitW,totV,maxV;
int option[N],cop[N];
struct { double weight;
double value;
}a[N];
int n;
void find(int i,double tw,double tv)
{ int k;
/*考慮物品i包含在當前方案中的可能性*/
if (tw+a.weight<=limitW)
{ cop=1;
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv;
}
cop=0;
}
/*考慮物品i不包含在當前方案中的可能性*/
if (tv-a.value>maxV)
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv-a.value;
}
}
void main()
{ int k;
double w,v;
printf（「輸入物品種數\n」）；
scanf（（「%d」，&n);
printf（「輸入各物品的重量和價值\n」）；
for (totv=0.0,k=0;k
{ scanf（「%1f%1f」，&w,&v);
a[k].weight=w;
a[k].value=v;
totV+=V;
}
printf（「輸入限制重量\n」）；
scanf（「%1f」，&limitV);
maxv=0.0;
for (k=0;k find(0,0.0,totV);
for (k=0;k
if (option[k]) printf（「%4d」，k+1）；
printf（「\n總價值為%.2f\n」，maxv);
}
作為對比，下面以同樣的解題思想，考慮非遞歸的程序解。為了提高找解速度，程序不是簡單地逐一生成所有候選解，而是
從每個物品對候選解的影響來形成值得進一步考慮的候選解，一個候選解是通過依次考察每個物品形成的。對物品i的考察有這樣幾種情況：當該物品被包含在候選
解中依舊滿足解的總重量的限制，該物品被包含在候選解中是應該繼續考慮的；反之，該物品不應該包括在當前正在形成的候選解中。同樣地，僅當物品不被包括在
候選解中，還是有可能找到比目前臨時最佳解更好的候選解時，才去考慮該物品不被包括在候選解中；反之，該物品不包括在當前候選解中的方案也不應繼續考慮。
對於任一值得繼續考慮的方案，程序就去進一步考慮下一個物品。
【程序】
# include
# define N 100
double limitW;
int cop[N];
struct ele { double weight;
double value;
} a[N];
int k,n;
struct { int ;
double tw;
double tv;
}twv[N];
void next(int i,double tw,double tv)
{ twv.=1;
twv tw=tw;
twv tv=tv;
}
double find(struct ele *a,int n)
{ int i,k,f;
double maxv,tw,tv,totv;
maxv=0;
for (totv=0.0,k=0;k
totv+=a[k].value;
next(0,0.0,totv);
i=0;
While (i>=0)
{ f=twv.;
tw=twv tw;
tv=twv tv;
switch(f)
{ case 1: twv.++;
if (tw+a.weight<=limitW)
if (i
{ next(i+1,tw+a.weight,tv);
i++;
}
else
{ maxv=tv;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
case 0: i--;
break;
default: twv.=0;
if (tv-a.value>maxv)
if (i
{ next(i+1,tw,tv-a.value);
i++;
}
else
{ maxv=tv-a.value;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
}
}
return maxv;
}
void main()
{ double maxv;
printf（「輸入物品種數\n」）；
scanf（（「%d」，&n);
printf（「輸入限制重量\n」）；
scanf（「%1f」，&limitW);
printf（「輸入各物品的重量和價值\n」）；
for (k=0;k
scanf（「%1f%1f」，&a[k].weight,&a[k].value);
maxv=find(a,n);
printf（「\n選中的物品為\n」）；
for (k=0;k
if (option[k]) printf（「%4d」，k+1）；
printf（「\n總價值為%.2f\n」，maxv);
}
⑶ c語言貪吃蛇的速度控製程序怎麼編
可以Sleep函數設置延時來控制貪吃蛇的速度。
函數名： Sleep
功 能： 執行掛起一段時間
用 法： void Sleep(DWORD dwMilliseconds);
在VC中使用帶上頭文件
#include <windows.h>
（ Sleep函數存放頭文件：WinBase.h）
在gcc編譯器中，使用的頭文件因gcc版本的不同而不同
#include <unistd.h>
Sleep()單位為毫秒，sleep()單位為秒（如果需要更精確可以用usleep單位為微秒）
返回值
若進程/線程掛起到參數所指定的時間則返回0，若有信號中斷則返回剩餘秒數。常式：
/*--------------------snake.h--------------------*/
#ifndefSNAKE_H
#defineSNAKE_H
#defineLEFT'a'
#defineRIGHT'd'
#defineDOWN's'
#defineUP'w'
#defineESC27
#defineN200/*蛇的最大長度*/
charkey;/*控制按鍵*/
structFood
{
intx;/*食物的橫坐標*/
inty;/*食物的縱坐標*/
intyes;/*判斷是否要出現食物的變數*/
}food;/*食物的結構體*/
structSnake
{
intx[N];
inty[N];
intnode;/*蛇的節數*/
intdirection;/*蛇移動方向*/
intlife;/*蛇的生命,0活著,1死亡*/
}snake;
#endif
/*--------------------snake.c--------------------*/
#include<graphics.h>
#include<stdlib.h>
#include<conio.h>
#include<time.h>
#include<stdio.h>
#include"snake.h"
intscore=0;
intgamespeed=100;//蛇運行速度
staticvoidInit(void);/*圖形驅動*/
staticvoidClose(void);/*圖形結束*/
staticvoidGame_interface(void);/*游戲界面*/
staticvoidGameOver(void);/*結束游戲*/
staticvoidGamePlay(void);/*游戲過程*/
staticvoidPrScore(void);/*輸出成績*/
/*主函數*/
intmain(void)
{
Init();
Game_interface();
GamePlay();
Close();
return0;
}
/*圖形驅動*/
staticvoidInit(void)
{
intgd=9,gm=2;
initgraph(&gd,&gm,"");
cleardevice();
}
/*開始畫面，左上角坐標為（50，40），右下角坐標為（610，460）的圍牆*/
staticvoidGame_interface(void)
{
inti;
setcolor(LIGHTCYAN);/*setbkcolor(LIGHTGREEN);*/
setlinestyle(PS_SOLID,0,1);/*設置線型*/
for(i=50;i<=600;i+=10)/*畫邊框*/
{
rectangle(i,40,i+10,49);/*上邊框*/
rectangle(i,451,i+10,460);/*下邊框*/
}
for(i=40;i<=450;i+=10)
{
rectangle(50,i,59,i+10);/*左邊框*/
rectangle(601,i,610,i+10);/*右邊框*/
}
}
/*游戲主函數*/
staticvoidGamePlay(void)
{
inti;
srand(time(NULL));/*隨機數發生器*/
food.yes=1;/*1表示需要出現新食物,0表示已經存在食物*/
snake.life=0;/*活著*/
snake.direction=1;/*方嚮往右*/
snake.x[0]=100;
snake.y[0]=100;
snake.x[1]=110;
snake.y[1]=100;
snake.node=2;/*節數*/
PrScore();/*輸出得分*/
while(1)/*可以重復玩游戲,壓ESC鍵結束*/
{
while(!kbhit())/*在沒有按鍵的情況下,蛇自己移動*/
{
if(food.yes==1)/*需要出現新食物*/
{
food.x=rand()%400+60;
food.y=rand()%350+60;
while(food.x%10!=0)/*食物隨機出現後必須讓食物能夠在整格內,這樣才可以讓蛇吃到*/
food.x++;
while(food.y%10!=0)
food.y++;
food.yes=0;/*畫面上有食物了*/
}
if(food.yes==0)/*畫面上有食物了就要顯示*/
{
setcolor(GREEN);
rectangle(food.x,food.y,food.x+10,food.y-10);
}
for(i=snake.node-1;i>0;i--)/*蛇的每個環節往前移動,也就是貪吃蛇的關鍵演算法*/
{
snake.x[i]=snake.x[i-1];
snake.y[i]=snake.y[i-1];
}
/*1,2,3,4表示右,左,上,下四個方向,通過這個判斷來移動蛇頭*/
switch(snake.direction)
{
case1:
snake.x[0]+=10;
break;
case2:
snake.x[0]-=10;
break;
case3:
snake.y[0]-=10;
break;
case4:
snake.y[0]+=10;
break;
}
/*從蛇的第四節開始判斷是否撞到自己*/
for(i=3;i<snake.node;i++)
{
if((snake.x[i]==snake.x[0])&&(snake.y[i]==snake.y[0]))
{
GameOver();/*顯示失敗*/
snake.life=1;
break;
}
}
if((snake.x[0]<55)||(snake.x[0]>595)||(snake.y[0]<55)||(snake.y[0]>455))/*蛇是否撞到牆壁*/
{
GameOver();/*本次游戲結束*/
snake.life=1;/*蛇死*/
}
if(snake.life==1)/*以上兩種判斷以後,如果蛇死就跳出內循環，重新開始*/
break;
if((snake.x[0]==food.x)&&(snake.y[0]==food.y))/*吃到食物以後*/
{
setcolor(BLACK);/*把畫面上的食物東西去掉*/
rectangle(food.x,food.y,food.x+10,food.y-10);
snake.x[snake.node]=-20;
snake.y[snake.node]=-20;
/*新的一節先放在看不見的位置,下次循環就取前一節的位置*/
snake.node++;/*蛇的身體長一節*/
food.yes=1;/*畫面上需要出現新的食物*/
score+=10;
PrScore();/*輸出新得分*/
}
setcolor(RED);/*畫出蛇*/
for(i=0;i<snake.node;i++)
rectangle(snake.x[i],snake.y[i],snake.x[i]+10,snake.y[i]-10);
Sleep(gamespeed);/*用延遲控制貪吃蛇速度*/
setcolor(BLACK);/*用黑色去除蛇的的最後一節*/
rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
snake.x[snake.node-1]+10,snake.y[snake.node-1]-10);
}/*endwhile（!kbhit）*/
if(snake.life==1)/*如果蛇死就跳出循環*/
break;
key=getch();/*接收按鍵*/
if(key==ESC)break;/*按ESC鍵退出*/
switch(key)
{
caseUP:
if(snake.direction!=4)/*判斷是否往相反的方向移動*/
snake.direction=3;
break;
caseRIGHT:
if(snake.direction!=2)
snake.direction=1;
break;
caseLEFT:
if(snake.direction!=1)
snake.direction=2;
break;
caseDOWN:
if(snake.direction!=3)
snake.direction=4;
break;
}
}/*endwhile(1)*/
}
/*游戲結束*/
staticvoidGameOver(void)
{
cleardevice();
PrScore();
setcolor(RED);
setfont(56,0,"黑體");
outtextxy(200,200,"GAMEOVER");
getch();
}
/*輸出成績*/
staticvoidPrScore(void)
{
charstr[10];
setfillstyle(YELLOW);
bar(50,15,220,35);
setcolor(BROWN);
setfont(16,0,"宋體");
sprintf(str,"score:%d",score);
outtextxy(55,16,str);
}
staticvoidClose(void)
{
closegraph();
}