分配演算法

❶ 求一平均分配演算法

先將所有人的錢求和，得到Sum1
然後用Sum1加上你要分的錢（900），得到Sum
再用Sum除以總人數N，得到平均數A
最後每個人得到的錢應該是A-Mi，Mi為第i個人原有的錢。
註：Mi>A的就不分了，當然也不能剝奪他原有的錢。

❷ 在動態分區分配方式中，可利用哪些分區分配演算法

動態分區分配演算法：
1.首次適應演算法（FF/first fit）
2.循環首次適應演算法（next fit）
3.最佳適應演算法（best fit）
從最小的分區開始分配
4.最壞適應演算法（worst fit）
從最大的分區開始分配
5.快速適應演算法/分類搜索法(quick fit)
將空閑分區根據其容量的大小進行分類

❸ 動態分區分配的演算法有哪些

動態分區分配演算法：
1.首次適應演算法（FF/first fit）
2.循環首次適應演算法（next fit）
3.最佳適應演算法（best fit）
從最小的分區開始分配
4.最壞適應演算法（worst fit）
從最大的分區開始分配
5.快速適應演算法/分類搜索法(quick fit)
將空閑分區根據其容量的大小進行分類

❹ 頻率分配有哪些演算法

一種啟發式頻率分配演算法
2．1 遺傳演算法的原理
遺傳演算法(Genetic Algorithms GA)是根據生物學上的染色體基因因子構成機制而產生的。1975年Holland教授首次提出了GA的思想，從而吸引了大批的研究者，迅速推廣到優化、搜索、機器學習等方面。遺傳演算法是一種全局優化演算法，其僅以目標函數值為搜索依據，通過群體優化搜索和隨機執行基本遺傳運算，實現遺傳群體的不斷進化，適合解決組合優化問題和復雜非線性問題[6]。
利用遺傳演算法解最優化問題，首先應對可行域中的點進行編碼（一般採用二進制編碼），然後在可行域中隨機挑選一些編碼組成作為進化起點的第一代編碼組，並計算每個解的目標函數值，也就是編碼的適應度。接著就像自然界中一樣，利用選擇機制從編碼組中隨機挑選編碼作為繁殖過程前的編碼樣本。選擇機制應保證適應度較高的解能夠保留較多的樣本；而適應度較低的解則保留較少的樣本，甚至被淘汰。在接下去的繁殖過程中，遺傳演算法提供了交叉和變異兩種運算元對挑選後的樣本進行交換。交叉運算元交換隨機挑選的兩個編碼的某些位，變異運算元則直接對一個編碼中的隨機挑選的某一位進行反轉。這樣通過選擇和繁殖就產生了下一代編碼組。重復上述選擇和繁殖過程，直到結束條件得到滿足為止。進化過程最後一代中的最優解就是用遺傳演算法解最優化問題所得到的最終結果。
實踐表明，遺傳演算法解最優化問題的計算效率比較高、適用范圍相當廣。為了解釋這一現象，Holland給出了模式定理。所謂模式，就是某些碼位取相同值的編碼的集合。模式定理說明在進化過程的各代碼中，屬於適應度高、階數低且長度短的圖式的編碼數量將隨代數以指數形式增長[6]。最近的研究則表明，上述遺傳演算法經適當改進後對任意優化問題以概率1收斂於全局最優解[5]。

❺ 求關於分配人員的演算法

給個思路吧，代碼懶得寫了。統計擁有a技能的人數a1人，然後把a1平均分配，然後在剩下的人中統計b技能人數b1，再分別統計出五組b技能的人數，把b1分配到五組中，使得五組b的技能的人數盡可能平均，cde技能如此按照b的方法分配。

❻ 什麼是最優適應分配演算法

分區分配演算法(Partitioning Placement Algorithm) ，共有3種。分別為最佳適應演算法、首次適應演算法、循環首次適應演算法。

1、最佳適應演算法（Best Fit）：
它從全部空閑區中找出能滿足作業要求的、且大小最小的空閑分區，這種方法能使碎片盡量小。為適應此演算法，空閑分區表（空閑區鏈）中的空閑分區要按大小從小到大進行排序，自表頭開始查找到第一個滿足要求的自由分區分配。該演算法保留大的空閑區，但造成許多小的空閑區。

2、首次適應演算法（First Fit）：
從空閑分區表的第一個表目起查找該表，把最先能夠滿足要求的空閑區分配給作業，這種方法目的在於減少查找時間。為適應這種演算法，空閑分區表（空閑區鏈）中的空閑分區要按地址由低到高進行排序。該演算法優先使用低址部分空閑區，在低址空間造成許多小的空閑區，在高地址空間保留大的空閑區。

3、循環首次適應演算法(Next Fit)：
該演算法是首次適應演算法的變種。在分配內存空間時，不再每次從表頭（鏈首）開始查找，而是從上次找到空閑區的下一個空閑開始查找，直到找到第一個能滿足要求的的空閑區為止，並從中劃出一塊與請求大小相等的內存空間分配給作業。該演算法能使內存中的空閑區分布得較均勻。

❼ 求 本問題的 分配演算法

/*先分配任務 A B C D E 每一堆x/n+1;次序放入數組Task[N][x/n+1];
閱卷人: a b c d e 次序一定放數組Teacher[N][x/n+1];
大致流程
第1次閱卷：a b c d e
第2次閱卷：b c d e a
第3次閱卷：c d e a b
..........
將閱卷人看成一個n位二進制數，循環左移m次（m<n)即可，肯定保證閱卷人不會月到重復的卷子； */
#include<iostream>
#include<Cstdlib>
using namespace std;

#define X 103 //試卷數量
#define N 5 //閱卷人數
#define HEAP (X/N+1) //每個人平均任務量
#define M 3 //閱卷次數
//以上變數的值可以修改

//把X張卷子中平均劃分為N個任務；
void partition(int Task[][HEAP])
{
for(int i=0;i<X;i++)
Task[i/HEAP][i%HEAP]=i;

}
//把第m個任務分給第K個閱卷人；
void assign(int Task[][HEAP],int m,int Teacher[][HEAP],int k)
{
for(int i=0;i<HEAP;i++)
{
Teacher[k][i]=Task[m][i];
cout<<Task[m][i]<< " ";
if(i!=0&&i%10==0) //控制換行
cout<<endl;
}
}

int main()
{
int Task[N][HEAP]={0}; //定義能夠存放N任務的二維數組；
int Teacher[N][HEAP]={0}; //定義能夠閱N個任務的標記閱卷人數組；
int i=0,j=0,count;

partition(Task); //把X張卷子中平均劃分為N個任務；

/*其實下面只有三行代碼，為了運行界面而家上去的，下面代碼中
i變數的變化代表閱卷次數，j變數的變化代表閱卷人的循環左移，count
變數代表編號從0到N個任務*/
cout<<"\n*******簡單閱卷系統************\n\n";
for( i=0 ;i<M;i++)
{
cout<<"\n****************************************\n\n";
cout<<"第 "<<i+1<<" 次閱卷開始:\n";

for(j=i,count=0;count<N;j=(j+1)%N,count++)
{
cout<<"The Teacher "<<j<<" check the exam:\n";
assign(Task,count,Teacher,j); //把第count個任務分給第j個閱卷人；
cout<<"\n-------------------------------------\n";
}
cout<<"第 "<<i+1<<" 次閱卷結束!!!\n";
}

return 0;
}
以上的代碼可運行，希望能對你有所幫助！！！

❽ 求用C語言寫出首次適應分配演算法的分配過程~

/********************************
內存管理模擬程序
*******************************/
#include<iostream.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include <time.h>
#include <windows.h>
/*定義宏*/
#define TotalMemSize 1024 /*劃分的物理塊的大小，地址范圍0~1023*/
#define MinSize 2 /*規定的不再分割的剩餘分區的大小*/
#define getpch(type) (type*)malloc(sizeof(type))

/*定義內存塊*/
typedef struct memBlock
{
struct memBlock *next;/*指向下一個塊*/
int stAddr; /*分區塊的初始地址*/
int memSize; /*分區塊的大小*/
int status; /*分區塊的狀態，0：空閑，1：以被分配*/
}MMB;

/*定義全局變數*/
MMB *idleHead=NULL; /*空閑分區鏈表的頭指針*/
MMB *usedHead=NULL; /*分配分區鏈表的頭指針*/
MMB *usedRear=NULL; /*分配分區鏈表的鏈尾指針*/
MMB *np; /*循環首次適應演算法中指向即將被查詢的空閑塊*/

int idleNum=1;/*當前空閑分區的數目*/
int usedNum=0;/*當前已分配分區的數目*/

MMB *memIdle=NULL; /*指向將要插入分配分區鏈表的空閑分區*/
MMB *memUsed=NULL; /*指向將要插入空閑分區鏈表的已分配分區*/

int flag=1;/*標志分配是否成功，1：成功*/

/*函數聲明*/
void textcolor (int color);/*輸出著色*/
void InitMem();/*初始化函數*/
int GetUseSize(float miu,float sigma); /*獲得請求尺寸*/

MMB *SelectUsedMem(int n);/*選擇待釋放的塊*/

void AddToUsed();/*將申請到的空閑分區加到分配分區鏈表中*/
int RequestMemff(int usize); /*請求分配指定大小的內存,首次適應演算法*/
int RequestMemnf(int usize); /*請求分配指定大小的內存,循環首次適應演算法*/

void AddToIdle();/*將被釋放的分配分區加到空閑分區鏈表中(按地址大小）*/
void ReleaseMem(); /*釋放指定的分配內存塊*/

/*主函數*/
void main()
{
int sim_step;
float miu,sigma; /*使隨機生成的請求尺寸符合正態分布的參數*/
int i;
int a;

MMB *p;
/* double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0; */
textcolor(11);
printf("\n\t\t內存管理模擬程序\n\n");
/* InitMem();*/
while(true)
{
double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0;
InitMem();
textcolor(12);
printf("\n\n首次適應演算法： 0");
printf("\n循環首次適應演算法： 1\n");
textcolor(11);
printf("\n請選擇一種演算法：");
scanf("%d",&a);
textcolor(15);
printf("\n輸入一定數量的步數：(sim_step)");
scanf("%d",&sim_step);
printf("\n 輸入使隨機生成的請求尺寸符合正態分布的參數：miu,sigma ");
scanf("%f,%f",&miu,&sigma);
for(i=1;i<=sim_step;i++)
{
textcolor(10);
printf("\n\n#[%d]\n",i);
do{
usesize=GetUseSize(miu,sigma);
while((usesize<0)||(usesize>TotalMemSize))
{
usesize=GetUseSize(miu,sigma);
}
textcolor(13);
printf("\n\n申請的內存尺寸為：%d",usesize);
printf("\n此時可用的空閑分區有 %d 塊情況如下：",idleNum);
p=idleHead;
textcolor(15);
while(p!=NULL)
{
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
TotalSize+=usesize;
if(a==0)
step=RequestMemff(usesize);
else
step=RequestMemnf(usesize);
TotalStep+=step;
n++;
}while(flag==1);
p=usedHead;
while(p!=NULL)
{
TotalUSize+=p->memSize;
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
textcolor(11);
if(TotalUSize!=0)
{
Ratio=TotalUSize/TotalMemSize;
TotalUSize=0;
printf("\n內存利用率NO.%d :%f%c",i,100*Ratio,'%');
}
else
{
Ratio=0;
printf("\n內存利用率NO.%d :%c%c",i,'0','%');
}
TotalRatio+=Ratio;
ReleaseMem();
}
if(n!=0)
{
textcolor(10);
aveStep=TotalStep/n;
aveSize=TotalSize/n;
aveRatio=TotalRatio/sim_step;
printf("\n平均搜索步驟：%f",aveStep);
printf("\n平均請求尺寸：%f",aveSize);
printf("\n平均內存利用率：%f",aveRatio);
}
}
}
// 輸出著色 /////////////////////////////////////////
void textcolor (int color)
{
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color );
}

/******************************
函數名：InitMem()
用途：把內存初始化為一整塊空閑塊
****************************************/
void InitMem()
{
MMB *p;
p=getpch(MMB);
p->memSize=TotalMemSize;
p->stAddr=0;
p->status=0;
p->next=NULL;
idleHead=p;
np=idleHead;
usedHead=NULL;
usedRear=NULL;
idleNum=1;
usedNum=0;
flag=1;
memIdle=NULL;
memUsed=NULL;

}

/******************************
函數名：GetUseSize(float miu,float sigma)
用途：獲得請求尺寸；
參數說明：float miu,float sigma ：正態分布的參數
返回值:申請尺寸的大小；
****************************************************/
int GetUseSize(float miu,float sigma)
{
float r1,r2;
float u,v,w;
float x,y;
do
{
r1=rand()/32767.0;
r2=rand()/32767.0;

u=2*r1-1;
v=2*r2-1;

w=u*u+v*v;
}while(w>1);
x=u*sqrt(((-log(w))/w));
y=v*sqrt(((-log(w))/w));
return miu+sigma*x;
}

/******************************
函數名：*SelectUsedMem(int n)
用途：選擇待釋放的塊(0~n-1)
返回值：指向待釋放的塊的指針；
****************************************************/
MMB *SelectUsedMem(int n)
{
MMB *p;
int i,j;
if(n>0)
{
i = rand()%n ;
textcolor(5);
printf("\n\n當前已分配分區總數為：%d",n);
printf("\n待釋放塊的序號為：%d\n",i );
p=usedHead;
if(p!=NULL)
{
for(j=i;j>0;j--)
p=p->next;
return(p);
}
else
return(NULL);
}
else
{
printf("\n當前沒有可釋放的資源！\n");
}
}
/******************************
函數名：AddToUsed()
用途：將申請到的空閑分區加到分配分區鏈表中
***************************************************************/
void AddToUsed()
{
MMB *p;
memIdle->status=1;
if(usedHead==NULL)
{
usedHead=memIdle;
usedRear=usedHead;

}
else
{
usedRear->next=memIdle;
usedRear=memIdle;
}
usedNum++;
printf("\n當前分配分區共有%d塊！",usedNum);
p=usedHead;
while(p!=NULL)
{
printf("\n始址:%d \t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
}
/******************************
函數名：RequestMemff(int usize)
參數說明：usize：請求尺寸的大小；
用途：請求分配指定大小的內存,首次適應演算法
返回值：搜索步驟
***************************************************************/
int RequestMemff(int usize)
{
MMB *p1,*p2,*s;
int step;
int suc=0;
int size1,size2;

if(idleHead==NULL)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
return 0;
}
else
{
if((idleHead->memSize)>usize)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;

idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;

idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
step=1;
flag=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();

}
else
{
p1=idleHead;
step=1;
p2=p1->next;
while(p2!=NULL)
{
if((p2->memSize)>usize)
{
size2=(p2->memSize)-usize;
if(size2<=MinSize)
{
p1->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;

}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;

}
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
p2=NULL;
}
else
{
p1=p1->next;
p2=p2->next;
step++;
}
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
}
}
}
return step;
}

/******************************
函數名：AddToIdle()
用途：將被釋放的分配分區加到空閑分區鏈表中(按地址遞增順序排列）
***************************************************************/
void AddToIdle()
{
MMB *p1,*p2;
int insert=0;
if((idleHead==NULL))
{
idleHead=memUsed;
idleNum++;
np=idleHead;
}
else
{
int Add=(memUsed->stAddr)+(memUsed->memSize);
if((memUsed->stAddr<idleHead->stAddr)&&(Add!=idleHead->stAddr))
{
memUsed->next=idleHead;
idleHead=memUsed;
idleNum++;
}
else
{

if((memUsed->stAddr<idleHead->stAddr)&&(Add==idleHead->stAddr))
{
idleHead->stAddr=memUsed->stAddr;
idleHead->memSize+=memUsed->memSize;

}
else
{
p1=idleHead;
p2=p1->next;
while(p2!=NULL)
{
if(memUsed->stAddr>p2->stAddr)
{
p1=p1->next;
p2=p2->next;
}
else
{
int Add1=p1->stAddr+p1->memSize;
int Add2=p2->stAddr-memUsed->memSize;
if((Add1==memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
p1->memSize=p1->memSize+memUsed->memSize;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p2->memSize=p2->memSize+memUsed->memSize;
p2->stAddr=memUsed->stAddr;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
memUsed->next=p2;
p1->next=memUsed;
if(np->stAddr==p2->stAddr)
np=p1->next;
idleNum++;
}
if((Add1==memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p1->memSize=p1->memSize+memUsed->memSize+p2->memSize;
p1->next=p2->next;
if((np->stAddr)==(p2->stAddr))
np=p1;
idleNum--;
}
p2=NULL;
insert=1;
}
}
if(insert==0)
{
p1->next=memUsed;
idleNum++;
}
}
}
}
}

/******************************
函數名：ReleaseMem()
用途：釋放指定的分配內存塊
***************************************************************/
void ReleaseMem()
{
MMB *q1,*q2;
MMB *s;
if(usedNum==0)
{
printf("\n當前沒有分配分區!");
return;
}
else
{
s=SelectUsedMem(usedNum);
if(s!=NULL)
{

if(s->stAddr==usedHead->stAddr)
{
memUsed=usedHead;
usedHead=usedHead->next;
memUsed->next=NULL;
AddToIdle();
usedNum--;
}
else
{
q1=usedHead;
q2=q1->next;
while(q2!=NULL)
{
if(q2->stAddr!=s->stAddr)
{
q1=q1->next;
q2=q2->next;
}
else
{
q1->next=q2->next;
memUsed=q2;
memUsed->next=NULL;
if(q1->next==NULL)
usedRear=q1;
AddToIdle();
usedNum--;
q2=NULL;
}
}
}
}
}
}

/******************************
函數名：RequestMemnf(int usize)
參數說明：usize：請求尺寸的大小；
用途：請求分配指定大小的內存,循環首次適應演算法
返回值：搜索步驟
***************************************************************/
int RequestMemnf(int usize)
{
MMB *p2,*p,*s;
int step;
int iNum=0;
int suc=0;
int size1,size2,size3;

if(idleHead==NULL)
{
flag=0;
printf("\n分配失敗！");
return 0;
}
else
{
iNum=idleNum;
while(iNum>0)
{
iNum--;
if((np->memSize)>usize)
{
/*指針指向的空閑塊滿足條件,且正好為頭指針*/
if(np->stAddr==idleHead->stAddr)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;
idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
if((idleHead==NULL)||(idleHead->next==NULL))
np=idleHead;
else
np=idleHead->next;

}
else/*指針指向的空閑塊滿足條件,不為頭指針*/
{
size2=(np->memSize)-usize;
if(size2<=MinSize) /*從空閑鏈表中刪除*/
{
p=idleHead;
while(p->next->stAddr!=np->stAddr)
p=p->next;
p->next=np->next;
memIdle=np;
memIdle->next=NULL;
np=p;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=np->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;

np->memSize=np->memSize-usize;
np->stAddr=np->stAddr+usize;
}
if(np->next==NULL)
np=idleHead;
else
np=np->next;
}
step=1;
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
iNum=0;
}
else /*當前指針指向的空閑區不滿足條件*/
{
step=1;
p2=np->next;
if(p2==NULL)
{
np=idleHead;
iNum--;
}
else
{
if((p2->memSize)>usize)
{
size3=(p2->memSize)-usize;
if(size3<=MinSize)
{
np->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;
}
flag=1;
suc=1;
printf("\n分配成功！");
AddToUsed();
if(p2->next==NULL)
np=idleHead;
else
np=p2->next;
p2=NULL;
iNum=0;
}
else
{
np=np->next;
p2=p2->next;
iNum--;
step++;
}
}
}
// iNum--;
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
}
}
return step;
}

❾ 求平均分配演算法

這一百個數放在一個數組中且已經排好序，先計算出這一百個數的和，然後根據你分的份數計算出每份需所有數的大致和應為多少，然後就用一個循環，從第一個元素往後面加，當加到超過上面計算的每份和時就得到分得的一份，後面依次這樣，就得到分得的每份！

❿ 常見的權重分配演算法是怎麼樣的

AHP層級法。

層次分析法（Analytic Hierarchy Process，簡稱AHP）是美國運籌學家、匹茲堡大學T. L. Saaty教授在20世紀70年代初期提出的， AHP是對定性問題進行定量分析的一種簡便、靈活而又實用的多准則決策方法。

它的特點是把復雜問題中的各種因素通過劃分為相互聯系的有序層次，使之條理化，根據對一定客觀現實的主觀判斷結構（主要是兩兩比較）把專家意見和分析者的客觀判斷結果直接而有效地結合起來，將一層次元素兩兩比較的重要性進行定量描述。

用途舉例

例如，某人准備選購一台電冰箱，他對市場上的6種不同類型的電冰箱進行了解後，在決定買哪一款式時，往往不是直接進行比較，因為存在許多不可比的因素，而是選取一些中間指標進行考察。例如電冰箱的容量、製冷級別、價格、型式、耗電量、外界信譽、售後服務等。

然後再考慮各種型號冰箱在上述各中間標准下的優劣排序。藉助這種排序，最終作出選購決策。在決策時，由於6種電冰箱對於每個中間標準的優劣排序一般是不一致的，因此，決策者首先要對這7個標準的重要度作一個估計，給出一種排序。

然後把6種冰箱分別對每一個標準的排序權重找出來，最後把這些信息數據綜合，得到針對總目標即購買電冰箱的排序權重。