sig演算法

⑴ 怎樣求大組合數（取模）（ACM演算法）

這種題目然做過的，
意思比較簡單，就由 m 個共 0 和 n 個 1 組成一個串，但從左到右要1出現的次數不少於0出現的次數。
由大牛的演算法： 結果就是 C(m+n, n) - C(m+n, m-1) 再取模，我們可以對式子化簡一下就是：
(n+m)！*
(n-m+1) / ((m)！* (n+1)！)
再取模，但由於組合數很大，直接用大數乘除就會超時了，看了別人的報告才知道原來可以用素數化簡快速求模的， n! = 2^p[i] *
3^p[i] * 5^p[i]*...... 再求模就可以很快了~(^ = ^)~。。。

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define M 2000005
#define mm 20100501
bool sig[M];
int prime[150000], p[150000], len; // prime 記錄素數， p 記錄素數的冪 len 記錄長度
void getprime() // 篩法找素數
{
int i,j,k=0;
prime[k++] = 2;
for(i=3; i<=M; i+=2)
{
if( !sig[i] )
{
prime[k++] = i;
for(j=i; j<=M; j+=i)
sig[j] = 1;
}
}
}
void get(int k, int s) // K! 的素數分解, S為指數的加減(分母，分子)
{
int i, mid;
for(i=0; prime[i]<=k && prime[i]; i++)
{
mid = k;
while(mid)
{
if(s)
p[i] += mid/prime[i];
else
p[i] -= mid/prime[i];
mid /= prime[i];
}
}
if(len < i)
len = i;
}
__int64 cal() // 計算結果 (prime[i...]^p[i...]) % mm
{
__int64 i,ans = 1;
for(i=0; i<=len; i++)
{
if( p[i] )
{
__int64 t = prime[i], b = p[i], ret = 1;
while(b) //計算 (t^b) % mm
{
if(b%2) ret *= t %mm;
t = t*t%mm;
b /= 2;
}
ans = ( ans*ret ) % mm;
}
}
return ans;
}
int main()
{
int t,m,n,i,mid;
__int64 ans;
getprime();
cin>>t;
while(t--)
{
cin>>n>>m;
len = 0;
memset(p, 0, sizeof(p));
mid = n-m+1; //先前要把 n-m+1 的因子加進 P 中去才能使 (m+n)! / ((m)!*(n+1)!) 整除
for(i=0; mid>1; i++)
{
if( mid%prime[i] == 0)
{
while(mid%prime[i]==0)
{
p[i] += 1;
mid /= prime[i];
}
}
}
get(m+n, 1);
get(m, 0);
get(n+1, 0);
ans = cal();
printf("%I64d\n", ans);
}
return 0;
}

可以用素數分解法，
先求出上面和下面的素數表示，然後約分後，再用求冪公式

⑵ 怎樣用公開密鑰演算法實現數字簽名要實現具有保密性的數字簽名呢

發送方A用自己的秘密密鑰簽名並用接受者B的公開密鑰加密，B收到報文後用自己的秘密密鑰解密，再用A的公開密鑰核實簽名

⑶ 操作系統進程調度演算法(數組)c++

1.程序演算法
struct PCB
{
int pname;
int pri;
int runtime;
int waitting;
struct PCB*next;
}
pcb[7];
struct PCB*running,ready,wait;
int sin=0;
main()
{ 創建PCB[3]--PCB[9]並插入ready隊列；／*pname分別為3--9,
pri=0,runtime=10,waittime=0 */
for(;;)/*系統程序，完成初始化和處理機分派功能*/

{cast{sig=0:swtch;
sig=1:waiter;
sig=3:proc3;
sig=4:proc4;
sig=5:proc5;
sig=6:proc6;
sig=7:proc7;
sig=8:proc8;
sig=9:proc9;}
}
}

2.進程調度程序
swtch()
{
while(ready==NULL)wakeup();
移出就緒隊列第一個PCB;
送running指針；
若pri=1,則runntime=4,否則runtime=10;
將running→pname送sig
}

3。 將進程等待函數
wait()
{將運行進程插入wait隊列，優先數置1；
sig=0;
}
4。進程喚醒函數
wakeup()
{
將wait隊列中所有的PCB中waittime減1；
將wait隊列中的所有的waittime=0的PCB揭除；
插入到ready隊列中第一個優先順序為0的PCB前面
｝

⑷ 想聽大家對於一道密碼設計的數學建模題

公鑰密碼又稱為雙鑰密碼和非對稱密碼，是1976年由Daffy和Hellman在其「密碼學新方向」一文中提出的，見劃時代的文獻：
W.Diffie and M.E.Hellman, New Directrions in Cryptography, IEEE Transaction on Information Theory, V.IT-22.No.6, Nov 1976, PP.644-654
單向陷門函數是滿足下列條件的函數f：
(1)給定x，計算y=f(x)是容易的；
(2)給定y, 計算x使y=f(x)是困難的。
(所謂計算x=f-1(Y)困難是指計算上相當復雜，已無實際意義。)
(3)存在δ，已知δ 時,對給定的任何y，若相應的x存在，則計算x使y=f(x)是容易的。
註：1*. 僅滿足(1)、(2)兩條的稱為單向函數；第(3)條稱為陷門性，δ 稱為陷門信息。
2*. 當用陷門函數f作為加密函數時，可將f公開，這相當於公開加密密鑰。此時加密密鑰便稱為公開鑰，記為Pk。 f函數的設計者將δ 保密，用作解密密鑰，此時δ 稱為秘密鑰匙，記為Sk。由於加密函數時公開的，任何人都可以將信息x加密成y=f(x)，然後送給函數的設計者（當然可以通過不安全信道傳送）；由於設計者擁有Sk，他自然可以解出x=f-1(y)。
3*.單向陷門函數的第(2)條性質表明竊聽者由截獲的密文y=f(x)推測x是不可行的。
Diffie和Hellman在其里程碑意義的文章中，雖然給出了密碼的思想，但是沒有給出真正意義上的公鑰密碼實例，也既沒能找出一個真正帶陷門的單向函數。然而，他們給出單向函數的實例，並且基於此提出Diffie-Hellman密鑰交換演算法。這個演算法是基於有限域中計算離散對數的困難性問題之上的：設F為有限域，g∈ F是F的乘法群F*=F\{0}=<g>。並且對任意正整數x，計算gx是容易的；但是已知g和y求x使y= gx，是計算上幾乎不可能的。這已問題稱為有限域F上的離散對數問題。公鑰密碼學種使用最廣泛的有限域為素域FP.
對Diffie-Hellman密鑰交換協議描述：Alice和Bob協商好一個大素數p，和大的整數g，1<g<p，g最好是FP中的本原元，即FP*＝<g>。p和g無須保密，可為網路上的所有用戶共享。
當Alice和Bob要進行保密通信時，他們可以按如下步驟來做：
(1)Alice送取大的隨機數x，並計算
X=gx(mod P)
(2)Bob選取大的隨機數x，並計算X  = gx (mod P)
(3)Alice將X傳送給Bob；Bob將X 傳送給Alice。
(4)Alice計算K=(X )X(mod P);Bob計算K  ＝（X) X (mod P),易見，K=K  =g xx (mod P)。
由(4)知，Alice和Bob已獲得了相同的秘密值K。雙方以K作為加解密鑰以傳統對稱密鑰演算法進行保密通信。
註：Diffie-Hellman密鑰交換演算法擁有美國和加拿大的專利。
3 RSA公鑰演算法
RSA公鑰演算法是由Rivest,Shamir和Adleman在1978年提出來的（見Communitions of the ACM. Vol.21.No.2. Feb. 1978, PP.120-126)該演算法的數學基礎是初等數論中的Euler（歐拉)定理，並建立在大整數因子的困難性之上。
將Z/(n）表示為 Zn，其中n=pq; p,q為素數且相異。若
Z*n{g∈ Zn|(g,n)=1}，易見Z*n為  (n)階的乘法群，且有 g  (n)1(mod n)，而  (n)=(p-1)(q-1).
RSA密碼體制描述如下：
首先，明文空間P＝密文空間C=Zn.(見P175).
A.密鑰的生成
選擇p,q，p,q為互異素數，計算n=p*q,  (n)=(p-1)(q-1), 選擇整數e使( (n),e)=1,1<e< (n)),計算d,使d=e-1(mod  (n))),公鑰Pk={e,n};私鑰Sk={d,p,q}。
注意，當0<M<n時,M (n) =1(mod n)自然有：
MK (n)+1M(mod n), 而ed  1 (mod  (n)),易見(Me)d  M(mod n)
B.加密 (用e,n)明文：M<n 密文：C=Me(mod n).
C.解密 (用d,p,q)
密文：C 明文：M=Cd（mod n)
註：1*, 加密和解密時一對逆運算。
2*, 對於0<M<n時，若(M,n) ≠ 1，則M為p或q的整數倍，假設M=cp，由(cp,q)=1 有 M (q)  1(mod q) M  (q)  (p)  1(mod q)
有M (q) = 1+kq 對其兩邊同乘M=cp有
有M (q)＋1=M+kcpq=M+kcn於是
有M (q)＋1  M(mod n)
例子：若Bob選擇了p=101和q＝113，那麼，n=11413,  (n)=100×112＝11200；然而11200＝26×52×7，一個正整數e能用作加密指數，當且僅當e不能被2，5，7所整除（事實上，Bob不會分解φ(n)，而且用輾轉相除法（歐式演算法）來求得e，使（e, φ(n)=1)。假設Bob選擇了e=3533，那麼用輾轉相除法將求得：
d=e -1  6597(mod 11200), 於是Bob的解密密鑰d=6597.
Bob在一個目錄中公開n=11413和e=3533, 現假設Alice想發送明文9726給Bob，她計算：
97263533(mod 11413)=5761
且在一個信道上發送密文5761。當Bob接收到密文5761時，他用他的秘密解密指數（私鑰）d＝6597進行解密：57616597（mod 11413)=9726
註：RSA的安全性是基於加密函數ek(x)=xe(mod n)是一個單向函數，所以對的人來說求逆計算不可行。而Bob能解密的陷門是分解n=pq，知 (n)=(p-1)(q-1)。從而用歐氏演算法解出解密私鑰d.
4 RSA密碼體制的實現
實現的步驟如下：Bob為實現者
(1)Bob尋找出兩個大素數p和q
(2)Bob計算出n=pq和 (n)=(p-1)(q-1).
(3)Bob選擇一個隨機數e(0<e<  (n))，滿足（e，  (n)）＝1
(4)Bob使用輾轉相除法計算d=e-1(mod  (n))
(5)Bob在目錄中公開n和e作為她的公開鑰。
密碼分析者攻擊RSA體制的關鍵點在於如何分解n。若分
解成功使n=pq，則可以算出φ(n)＝（p-1)(q-1)，然後由公
開的e，解出秘密的d。（猜想：攻破RSA與分解n是多項式
等價的。然而，這個猜想至今沒有給出可信的證明！！！）
於是要求：若使RSA安全，p與q必為足夠大的素數，使
分析者沒有辦法在多項式時間內將n分解出來。建議選擇
p和q大約是100位的十進制素數。 模n的長度要求至少是
512比特。EDI攻擊標准使用的RSA演算法中規定n的長度為
512至1024比特位之間，但必須是128的倍數。國際數字
簽名標准ISO/IEC 9796中規定n的長度位512比特位。
為了抵抗現有的整數分解演算法，對RSA模n的素因子
p和q還有如下要求：
(1)|p-q|很大，通常 p和q的長度相同；
(2)p-1 和q-1分別含有大素因子p1和q1
(3)P1-1和q1-1分別含有大素因子p2和q2
(4)p+1和q+1分別含有大素因子p3和q3

為了提高加密速度，通常取e為特定的小整數，如EDI國際標准中規定 e＝216＋1，ISO/IEC9796中甚至允許取e＝3。這時加密速度一般比解密速度快10倍以上。 下面研究加解密算術運算，這個運算主要是模n的求冪運算。著名的「平方-和-乘法」方法將計算xc(mod n)的模乘法的數目縮小到至多為2l，這里的l是指數c的二進製表示比特數。若設n以二進制形式表示有k比特，即k=[log2n]+1。 由l≤ k，這樣xc(mod n)能在o(k3)時間內完成。（注意，不難看到，乘法能在o(k2)時間內完成。）

平方－和－乘法演算法：
指數c以二進制形式表示為：

c=
Xc=xc0×（x2)c1×…×(x2t-1)ct-1
預計算： x2=xx
x4=x22=x2x2
.
.
.
x2t-1 =x2t-2*x2t-2
Xc計算：把那些ci=1對應的x2i全部乘在一起，便得xc。至
多用了t-1次乘法。請參考書上的177頁，給出計算
xc(mod n)演算法程序：
A=xc c=c0+c12+..+ct-12t-1= [ct-1,....,c1,c0]2
5 RSA簽名方案

簽名的基本概念
傳統簽名（手寫簽名）的特徵：
（1）一個簽名是被簽文件的物理部分；
（2）驗證物理部分進行比較而達到確認的目的。(易偽造)
（3）不容易忠實地「」!!!
定義： (數字簽名方案）一個簽名方案是有簽署演算法與驗
證演算法兩部分構成。可由五元關系組（P,A,K,S,V）來刻化：
(1)P是由一切可能消息(messages)所構成的有限集合；
(2)A是一切可能的簽名的有限集合；
(3)k為有限密鑰空間，是一些可能密鑰的有限集合；
(4)任意k ∈K，有簽署演算法Sigk ∈ S且有對應的驗證演算法Verk∈V,對每一個
Sigk:p A 和Verk:P×A {真，假} 滿足條件：任意x∈ P,y∈ A.有簽名方案的一個簽名：Ver(x,y)= ｛
註：1*.任意k∈K, 函數Sigk和Verk都為多項式時間函數。
2*.Verk為公開的函數，而Sigk為秘密函數。
3*.如果壞人（如Oscar)要偽造Bob的對X的簽名，在計算上是不可能的。也即,給定x，僅有Bob能計算出簽名y使得Verk(x,y)＝真。
4*.一個簽名方案不能是無條件安全的，有足夠的時間，Oscar總能偽造Bob的簽名。
RSA簽名：n=pq,P=A=Zn,定義密鑰集合K={(n,e,p,q,d)}|n=pq,d*e1(mod (n))}
注意：n和e為公鑰；p,q,d為保密的（私鑰）。對x∈P, Bob要對x簽名，取k∈K。Sigk(x) xd(mod n)y(mod n)
於是
Verk(x,y)=真 xye(mod n)
（注意：e,n公開；可公開驗證簽名(x,y)對錯！！也即是否為Bob的簽署）
註：1*.任何一個人都可對某一個簽署y計算x=ek(y)，來偽造Bob對隨機消息x的簽名。
2*.簽名消息的加密傳遞問題：假設Alice想把簽了名的消息加密送給Bob，她按下述方式進行：對明文x，Alice計算對x的簽名，y=SigAlice(x)，然後用Bob的公開加密函數eBob,算出
Z=eBob(x,y) ,Alice 將Z傳給Bob，Bob收到Z後，第一步解密，
dBob(Z)=dBobeBob(x,y)=(x,y)
然後檢驗
VerAlice(x,y)= 真
問題：若Alice首先對消息x進行加密，然後再簽名，結果
如何呢？Y=SigAlice(eBob(x))
Alice 將（z,y)傳給Bob，Bob先將z解密，獲取x;然後用
VerAlice檢驗關於x的加密簽名y。這個方法的一個潛在問
題是，如果Oscar獲得了這對（z,y)，他能用自己的簽名來
替代Alice的簽名
y=SigOscar(eBob(x))
(注意：Oscar能簽名密文eBob(x)，甚至他不知明文x也能做。Oscar傳送（z,y )給Bob,Bob可能推斷明文x來自Oscar。所以，至今人么還是推薦先簽名後加密。）
6.EIGamal方案

EIGamal公鑰密碼體制是基於離散對數問題的。設P
至少是150位的十進制素數，p-1有大素因子。Zp為有限域，
若α為Zp中的本原元，有Zp* ＝<α>。若取β∈Zp*=Zp\{0}，
如何算得一個唯一得整數a,（要求，0≤a≤ p-2)，滿足
αa=β(mod p)
將a記為a=logαβ
一般來說，求解a在計算上是難處理的。
Zp*中的Egamal公鑰體制的描述：設明文空間為P=Zp*,密文空
間為C=Zp*×Zp*,定義密鑰空間K={(p, α,a, β )|β=αa(mod p)}
公開鑰為：p, α ,β
秘密鑰（私鑰）：a
Alice 取一個秘密隨機數k∈ Zp-1，對明文x加密
ek(x,k)=(y1,y2)
其中， y1=αk(mod p),y2=xβk(mod p)
Bob解密，
dk(y1,y2)=y2(y1α)-1(mod p)
註：1*.容易驗證y2(y1α)-1=x(αa)k(αka)-1=x !!
2*.利用EIGamal加密演算法可給出基於此的簽名方案：
Alice 要對明文x進行簽名，她首先取一個秘密隨機數k作
為簽名
Sigk(x,k)=( ,  )
其中 ＝αk(mod p), =(x-a )k-1(mod p-1)
對x, ∈Zp*和 ∈ Zp-1，定義Verk(x, ,)＝真等價於
βα＝αx(mod p)
要說明的是，如果正確地構造了這個簽名，那麼驗證將
是成功的，因為
βα＝ αa αk (mod p)= αa+k (mod p)
由上面知道， ＝（x- a)k-1(mod p-1)可以推出
k=x- a(mod p-1)有a+kx(mod p)
所以 β  ＝ αx (mod p)
該簽名方案已經被美國NIST(國家標准技術研究所）確定為簽名標准（1985）。

有關RSA方面的內容，請訪問網址：
www.RSAsecurity.com

⑸ 漸進sig和精確sig怎麼算

很早之前的問題了，我來回答下吧：卡方檢驗一般是看精確雙側，除非你在理論上有所依據時，可以看精確單側。在2X2表格中，特別是某格的預期次數要小於等於5的2X2表，需要看修正的卡方，其中以Fisher的較為准確。

⑹ 如何理解貝葉斯估計

根據貝葉斯公式，進行統計推斷，
在垃圾郵件分類方面應用很廣，方法簡單，具有很好的穩定性和健壯性

⑺ 數字簽名程序生成的是什麼舉例說明！

數字簽名程序生成的是什麼？舉例說明！
：需要包含的包
import java.security.*;
import java.io.*;
import java.util.*;
import java.security.*;
import java.security.cert.*;
import sun.security.x509.*
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;

二：從文件中讀取證書
用keytool將.keystore中的證書寫入文件中，然後從該文件中讀取證書信息
CertificateFactory cf=CertificateFactory.getInstance("X.509");
FileInputStream in=new FileInputStream("out.csr");
Certificate c=cf.generateCertificate(in);

String s=c.toString();
三：從密鑰庫中直接讀取證書
String pass="123456";
FileInputStream in=new FileInputStream(".keystore");
KeyStore ks=KeyStore.getInstance("JKS");
ks.load(in,pass.toCharArray());
java.security.cert.Certificate c=ks.getCertificate(alias);//alias為條目的別名

四：JAVA程序中顯示證書指定信息
System.out.println("輸出證書信息:\n"+c.toString());
System.out.println("版本號:"+t.getVersion());
System.out.println("序列號:"+t.getSerialNumber().toString(16));
System.out.println("主體名："+t.getSubjectDN());
System.out.println("簽發者："+t.getIssuerDN());
System.out.println("有效期："+t.getNotBefore());
System.out.println("簽名演算法："+t.getSigAlgName());
byte [] sig=t.getSignature();//簽名值
PublicKey pk=t.getPublicKey();
byte [] pkenc=pk.getEncoded();
System.out.println("公鑰");
for(int i=0;ipkenc.length;i++)System.out.print(pkenc[i]+",");

五：JAVA程序列出密鑰庫所有條目
String pass="123456";
FileInputStream in=new FileInputStream(".keystore");
KeyStore ks=KeyStore.getInst......

瀘唨尤孚咢懎摻彇塂搑垟枛環抰噠

⑻ matlab如何實現數組中任意個數元素的求和！

給你提供一個暴力演算法，思路是：循環開始，把28個數隨機打亂，分別取第一個數，前2個、前3個、前4個......數求和，當找到求和滿足的為止，循環結束,數組a和那個和自己輸入，代碼：
clc;
clear;
%一維數組
a=[];
%要滿足的目標和
target=50;
sig=1;
while
sig
xuhao=randperm(28);
xuhao_a=a(xuhao);
for
i=1:28
si=sum(xuhao_a(1:i));
if
si==target
index=xuhao(1:i);
index_a=a(index);
sig=0;
break;
end
end
end
index=sort(index);
disp('達到目標求和的數在數組中序號');
disp(index);
disp('滿足要求的數');
disp(index_a);
雖然思路是暴力演算法，但幸虧你的數據不大，結果出的還是很快的

⑼ 用C++編程實現兩個調度演算法（如SJF、時間片輪轉法、優先權調度、、、）謝謝！

#include<stdio.h>
#include<time.h>
#include<stdlib.h>

/*********************以下是全局數據結構和變數***********************/
/*PCB 結構*/
struct PCB{
int pname;
int pri;
int runtime;
int waittime;
struct PCB *next;
}pcb[7];

/* 運行指針*/
struct PCB *running;

/*高優先順序就緒隊列頭指針*/
struct PCB *Hready;

/*低優先順序隊列頭指針*/
struct PCB *Lready;

/*等待隊列頭指針*/
struct PCB *wait;

int sig=0;

/**************************以下是函數說明****************************/
/*利用循環實現延遲*/
void delay();

/*模擬進程3－9*/
void proc(struct PCB *running);

/*將node插入到head所指示的隊列的尾部*/
void InsertIntoQueueTail(struct PCB ** head,struct PCB *node);

/*進程調度函數*/
int proc_switch();

/*進程等待函數*/
void proc_wait();

/*進程喚醒函數*/
int proc_wakeup();

/************************以下是函數定義及注釋************************/
/*主函數*/
main()
{
int i;
/*初始化，創建進程3－9，置低優先順序，等待時間為0，
依次插入低優先順序隊列*/
for(i = 0;i < 7;i++){
pcb[i].pname = i+3;
pcb[i].pri = 0;
pcb[i].waittime = 0;
InsertIntoQueueTail(&Lready,&pcb[i]);
}
/*等待隊列和高優先順序隊列為空*/
wait = NULL;
Hready=NULL;

printf("\nThe process_switch begin:\n");
/*模擬進程調度開始*/
for(;;)
{
switch(sig){
case 0:/*無進程等待調度，列印信息並返回*/
if(!proc_switch())
{
printf("No Process to run,press any key to return:\n");
getchar();
}
break;
case 1:proc_wait();
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:proc(running);
break;
default:printf("\nerror!");
exit(-1);
}
}
}

/*功能：延遲一個時間片*/
/*入口參數：無*/
/*出口參數：無*/
void delay()
{
int i,j;
for(i=0;i<20000;i++)
for(j=0;j<10000;j++)
{
}
}

/*功能：進程3－9*/
/*入口參數：運行指針*/
/*出口參數：無*/
void proc(struct PCB * running)
{
int i;
srand( (unsigned)time( NULL ) );
/*顯示當前運行的進程的id*/
printf("\nNow Process %d is running\n",running->pname);
/*當前進程執行running->runtime個時間片*/
for(i=running->runtime;i>0;i--){
/*顯示剩餘的時間片*/
printf("%d time slice(s) left\n",i);
/*延遲*/
delay();
proc_wakeup();
/*產生一個1到1000的隨機數，若該隨機數小餘100，當前進程等待，*/
if((rand()%1000+1)<100){
printf("Process %d begins to wait.\n",running->pname);
sig=1;
return;
}
}
/*顯示時間片耗盡，進程轉為低優先順序就緒狀態*/
printf("Time slices for process %d exhausted.\n",running->pname);
InsertIntoQueueTail(&Hready,running);
sig=0;
return;

}
/*功能：將一個節點插入隊列尾部*/
/*入口參數：隊列頭指針地址head，待插入結點node*/
/*出口參數：無*/
void InsertIntoQueueTail(struct PCB **head,struct PCB *node)
{
struct PCB *p;
node->next=NULL;
/*被插入隊列為空*/
if(*head==NULL){
*head=node;
return;
}
/*被插入隊列不為空*/
else{
p=*head;
/*找到隊列的最後一個結點*/
while(p->next!=NULL) p=p->next;
p->next=node;
}
}

/*功能：進程調度*/
/*入口參數：無*/
/*出口參數：若調度成功，返回1，否則返回0*/

int proc_switch()
{
/*若高優先順序就緒隊列和低優先順序就緒隊列均為空，則循環執行進程喚醒*/
while(Hready == NULL && Lready == NULL)
if(!proc_wakeup()) return 0;

/*若高優先順序就緒隊列非空，則執行其第一個進程，分配2個時間片*/
if(Hready != NULL){
running = Hready;
Hready = Hready -> next;
running->runtime = 2;
}
/*若高優先順序就緒隊列為空，則執行低優先順序就緒隊列的第一個進程，
分配5個時間片*/
else{
running = Lready;
Lready=Lready -> next;
running -> runtime = 5;
}
/*別調度進程的id賦給sig*/
sig = running -> pname;
return 1;
}

/*功能：進程等待。將當前運行進程置高優先順序，等待時間為20，
插入等待隊列尾部*/
/*入口參數：無*/
/*出口參數：無*/
void proc_wait()
{
struct PCB *p;
running->pri=1;
running->waittime=20;
InsertIntoQueueTail(&wait,running);
sig=0;
return;
}

/*功能：進程喚醒*/
/*入口參數：無*/
/*出口參數：若等待隊列為空，則返回0，否則返回1*/
int proc_wakeup()
{
struct PCB *p,*last,*MoveToReady;
p = wait;
/*等待隊列為空，返回0*/
if(p == NULL) return 0;

/*延遲*/
delay();
/*等待隊列中每個進程的等待時間減1*/
while(p != NULL){
p -> waittime -= 1;
p=p->next;
}
p=wait;
/*從等待隊列中摘除等待時間為0的進程，插入到高優先順序就緒隊列的尾部*/
while(p!=NULL){
if(p -> waittime == 0){
MoveToReady = p;
if (p == wait)
wait = p->next;
else
last -> next = p->next;
p = p -> next;
InsertIntoQueueTail(&Hready,MoveToReady);
}
else{

p = p -> next;
}
}
sig =0;
return 1;
}

⑽ （計算機操作系統）wait操作和signal操作什麼意思

規定在拿到左側的筷子後，先檢查右面的筷子是否可用。如果不可用，則先放下左側筷子， 等一段時間再重復整個過程。 分析：當出現以下情形，在某一個瞬間，所有的哲學家都同時啟動這個演算法，拿起左側的筷 子，而看到右側筷子不可用，又都放下左側筷子，等一會兒，又同時拿起左側筷子……如此 這樣永遠重復下去。對於這種情況，所有的程序都在運行，但卻無法取得進展，即出現飢餓， 所有的哲學家都吃不上飯。 (2) 描述一種沒有人餓死（永遠拿不到筷子）演算法。 考慮了四種實現的方式（A、B、C、D）： A．原理：至多隻允許四個哲學家同時進餐,以保證至少有一個哲學家能夠進餐,最終總會釋 放出他所使用過的兩支筷子,從而可使更多的哲學家進餐。以下將room 作為信號量，只允 許4 個哲學家同時進入餐廳就餐，這樣就能保證至少有一個哲學家可以就餐，而申請進入 餐廳的哲學家進入room 的等待隊列，根據FIFO 的原則，總會進入到餐廳就餐，因此不會 出現餓死和死鎖的現象。 偽碼： semaphore chopstick[5]=; semaphore room=4; void philosopher(int i) } B．原理：僅當哲學家的左右兩支筷子都可用時,才允許他拿起筷子進餐。 方法1：利用AND 型信號量機制實現：根據課程講述，在一個原語中，將一段代碼同時需 要的多個臨界資源，要麼全部分配給它，要麼一個都不分配，因此不會出現死鎖的情形。當 某些資源不夠時阻塞調用進程;由於等待隊列的存在，使得對資源的請求滿足FIFO 的要求， 因此不會出現飢餓的情形。 偽碼： semaphore chopstick[5]=; void philosopher(int I) } 方法2：利用信號量的保護機制實現。通過信號量mutex對eat（）之前的取左側和右側筷 子的操作進行保護，使之成為一個原子操作，這樣可以防止死鎖的出現。 偽碼： semaphore mutex = 1 ; semaphore chopstick[5]=; void philosopher(int I) }