1、求先来先服务调度算法的源代码，C/C++版的都行，尽量短啊！！！能调试的
//FIFO
#include<iostream>
using namespace std;
int pagenum=0; ///内存的页面数
int total=0; ///要访问的叶面总数
int lacknumber=0; ///缺页的总数
void main()
{
int array[20]; //生成一个内存空间并进行分配，且初始化为空-1,不用0去初始化，是因为等待序列初始化是0
for(int x=0;x<20;x++)
{
array[x]=-1;
}
int seque[20]={0};//生成一个虚拟空间初始化为空，即等待队列
cout<<"请输入内存的页面数:";
cin>>pagenum;
cout<<"请输入页面的访问顺序(输入-1结束):";
//输入的页面访问序列，进入等待队列
for(int i=0;i<20;i++)
{
int num;
cin>>num;
if(num!=-1)
{
seque[i]=num;
total++;//计算总的进程数
}
else
{
seque[i]=num;
break;
}
}
cout<<"总的页面数为"<<total<<endl;//总的页面数
cout<<"---------进入FIFO页面调度----------------"<<endl;
int j=0;
for(i=0;i<pagenum;i++) //刚开始置换前pagenum个空页面
{
//刚开始，不存在内存中的，都算缺页
if(i<pagenum & array[i] != seque[i])
{
array[i]=seque[i];
cout<<"页面"<<seque[i]<<"进入内存"<<endl;
cout<<"缺页! 此时页面内容为";
for(int j=0;j<pagenum;j++)
{
cout<<array[j]<<" ";
}
cout<<"(-1代表没有内容)"<<endl;
}
cout<<endl;
}
//队列和进入页表内容比较
int kk=0;
for(i=pagenum;i<total;i++)//假如说分了三个内存页，从此开始三个内存页已被占满，就要考虑命中或替换了
{
int flag=0;//作为标志，如果=0说明不存在，则要进行替换，反之命中
for(int k=0;k<pagenum;k++)//此for循环实现的是把要进入内存的页和内存页中的数比较，看是否有
{ //若有则把flag置成1 。
if(array[k]==seque[i])
{
flag=1; //存在
break;
}
}
cout<<endl;
if(flag==1)//利用flag标志判断，若等于1则说明有，就不用替换了，
{
cout<<"页面"<<seque[i]<<"进入内存，命中!"<<endl;
cout<<"此时页面内容为";
for(int j=0;j<pagenum;j++)
{
cout<<array[j]<<" ";
}
}
cout<<endl;
if(flag==0)//另一种就是内存没有的情况了，就要把最先进的弹出
{
int tem=array[kk];//kk初始值为0，说明是内存分配页的那个数组，把数组的第一个，也就是0要单元的那个数替换
array[kk]=seque[i];
cout<<"页面"<<seque[i]<<"进入内存"<<endl;
cout<<"缺页!页面"<<tem<<"被替换"<<endl;
cout<<"此时页面内容为";
for(int j=0;j<pagenum;j++)
{
cout<<array[j]<<" ";
}
cout<<endl;
kk++; //kk++意思是：假如分配内存三个页面，每次进行kk++说明有一个要进入内存页中，刚开始kk=0，指内存页的第一个
//内存页，也就是最先进来的那个页被替换了，+1说明要把原来在数组二号中的数替换，+1说明要替换第三个了，
//而内存页也就三页，当下次再替换的时候就要替换第四页除以3的余了，而余就是0，也就是下边kk==pagenum把
//kk置0了。
lacknumber++; //缺页数
if(kk==pagenum)
{
kk=0;
}
}
}
lacknumber=pagenum+lacknumber;
cout<<"缺页率="<<lacknumber<<"/"<<total<<"="<<float(lacknumber)/float(total)<<endl;
}
2、遗传算法解决有时间窗的车辆调度问题源程序出错，求教
动态规划算法一般是n步叠代计算局部最优解，每一步叠代需要计算m个子项，那么时间复杂度就是O(m*n)。 如果只保存一步叠代的结果，空间复杂度就是O(m)；如果需要保存k步叠代结果，空间复杂度就是O(m*k)。
3、求遗传算法车辆调度优化问题的建模模型和MATLAB源代码
1、要看你组合优化是属于哪种问题，一般的组合优化都是混合整数线性或非线性的，那么就不行了，因此要对遗传算法改进才能计算。2、如果有现成的工具箱求解你的组合优化问题肯定要方便些，但碰到具体问题，可能要对参数进行一些设置更改，所以最好能有编程基础，那样就可以自己修改工具箱里面的参数或策略了对你的补充问题，组合优化问题一般都是用matlab和lingo实现吧。建议买一本数学建模的书看一看，都涉及到组合优化问题，也可以下载论文看看。lingo对编程要简单些，主要是求混合规划，缺点是似乎还不能用上多目标问题，一般的组合优化都属于多目标问题。但是matlab功能强大的多。
4、谁有车间作业调度问题遗传算法的MATLAB源码，要完整的程序哦~
function [Zp,Y1p,Y2p,Y3p,Xp,LC1,LC2]=JSPGA(M,N,Pm,T,P)
%--------------------------------------------------------------------------
% JSPGA.m
% 车间作业调度问题遗传算法
%--------------------------------------------------------------------------
% 输入参数列表
% M 遗传进化迭代次数
% N 种群规模(取偶数)
% Pm 变异概率
% T m×n的矩阵，存储m个工件n个工序的加工时间
% P 1×n的向量，n个工序中，每一个工序所具有的机床数目
% 输出参数列表
% Zp 最优的Makespan值
% Y1p 最优方案中，各工件各工序的开始时刻，可根据它绘出甘特图
% Y2p 最优方案中，各工件各工序的结束时刻，可根据它绘出甘特图
% Y3p 最优方案中，各工件各工序使用的机器编号
% Xp 最优决策变量的值，决策变量是一个实数编码的m×n矩阵
% LC1 收敛曲线1，各代最优个体适应值的记录
% LC2 收敛曲线2，各代群体平均适应值的记录
% 最后，程序还将绘出三副图片：两条收敛曲线图和甘特图（各工件的调度时序图）
%第一步：变量初始化
[m,n]=size(T);%m是总工件数，n是总工序数
Xp=zeros(m,n);%最优决策变量
LC1=zeros(1,M);%收敛曲线1
LC2=zeros(1,N);%收敛曲线2
%第二步：随机产生初始种群
farm=cell(1,N);%采用细胞结构存储种群
for k=1:N
X=zeros(m,n);
for j=1:n
for i=1:m
X(i,j)=1+(P(j)-eps)*rand;
end
end
farm{k}=X;
end
counter=0;%设置迭代计数器
while counter
%第三步：交叉
newfarm=cell(1,N);%交叉产生的新种群存在其中
Ser=randperm(N);
for i=1:2:(N-1)
A=farm{Ser(i)};%父代个体
B=farm{Ser(i+1)};
Manner=unidrnd(2);%随机选择交叉方式
if Manner==1
cp=unidrnd(m-1);%随机选择交叉点
%双亲双子单点交叉
a=[A(1:cp,:);B((cp+1):m,:)];%子代个体
b=[B(1:cp,:);A((cp+1):m,:)];
else
cp=unidrnd(n-1);%随机选择交叉点
a=[A(:,1:cp),B(:,(cp+1):n)];%双亲双子单点交叉
b=[B(:,1:cp),A(:,(cp+1):n)];
end
newfarm{i}=a;%交叉后的子代存入newfarm
newfarm{i+1}=b;
end
%新旧种群合并
FARM=[farm,newfarm];
%第四步：选择复制
FITNESS=zeros(1,2*N);
fitness=zeros(1,N);
plotif=0;
for i=1:(2*N)
X=FARM{i};
Z=COST(X,T,P,plotif);%调用计算费用的子函数
FITNESS(i)=Z;
end
%选择复制采取两两随机配对竞争的方式，具有保留最优个体的能力
Ser=randperm(2*N);
for i=1:N
f1=FITNESS(Ser(2*i-1));
f2=FITNESS(Ser(2*i));
if f1<=f2
farm{i}=FARM{Ser(2*i-1)};
fitness(i)=FITNESS(Ser(2*i-1));
else
farm{i}=FARM{Ser(2*i)};
fitness(i)=FITNESS(Ser(2*i));
end
end
%记录最佳个体和收敛曲线
minfitness=min(fitness)
meanfitness=mean(fitness)
LC1(counter+1)=minfitness;%收敛曲线1，各代最优个体适应值的记录
LC2(counter+1)=meanfitness;%收敛曲线2，各代群体平均适应值的记录
pos=find(fitness==minfitness);
Xp=farm{pos(1)};
%第五步：变异
for i=1:N
if Pm>rand;%变异概率为Pm
X=farm{i};
I=unidrnd(m);
J=unidrnd(n);
X(I,J)=1+(P(J)-eps)*rand;
farm{i}=X;
end
end
farm{pos(1)}=Xp;
counter=counter+1
end
%输出结果并绘图
figure(1);
plotif=1;
X=Xp;
[Zp,Y1p,Y2p,Y3p]=COST(X,T,P,plotif);
figure(2);
plot(LC1);
figure(3);
plot(LC2);
5、谁能提供VB写的遗传算法解决车辆调度问题的代码！急需！！！
MFC的。。。PUDN上应该有VB的
6、优先级调度算法程序代码
FIFO的方法用下边的Queue改写一下。
///////////////////// Queue.h //////////////////////////////
#ifndef QUEUE_H
#define QUEUE_H
namespace MyLibrary
{
#define MYLIBRARY_DEBUG
// MYLIBRARY_DEBUG 为测试而用
#ifdef MYLIBRARY_DEBUG
#include <iostream>
using std::ostream;
#endif
/// type def
#ifndef FALSE
#define FALSE false
#endif
#ifndef TRUE
#define TRUE true
#endif
typedef size_t size_type;
typedef bool BOOL;
/// 声明
template <typename _Ty> class Queue;
#ifdef MYLIBRARY_DEBUG
template <typename _Ty>
ostream & operator << ( ostream & , const Queue<_Ty> & );
#endif
//////////////////////// class ////////////////////////////
template <typename _Ty>
class Queue
{
//友元声明
#ifdef MYLIBRARY_DEBUG
friend ostream & operator << <> ( ostream &, const Queue<_Ty> & );
#endif
private:
//嵌套类定义
class QueueItem
{
public:
QueueItem( _Ty data ):_prior(0),_next(0),_data(data){}
public:
QueueItem * _prior; //前向指针
QueueItem * _next; //后向指针
_Ty _data; //数据
};
private:
//数据集
typename Queue<_Ty>::QueueItem * _head; //头结点指针
typename Queue<_Ty>::QueueItem * _tail; //尾结点指针
size_type _size; //长度
static const _Ty _temp; //只做空数据
public:
//构造析构集...
inline Queue():_head(0),_tail(0),_size(0){}
inline Queue( const Queue<_Ty> & );
inline ~Queue(){ while( !empty() )del(); }
public:
//外部操作接口集
inline const size_type size ( void ) const;
inline const BOOL empty ( void ) const;
inline const Queue & add ( const _Ty & );
inline const BOOL del ( void );
inline const BOOL del ( _Ty & );
inline const _Ty & get ( void )const;
public:
//重载操作符集
inline const Queue<_Ty> & operator = ( const Queue<_Ty> & );
inline const Queue<_Ty> & operator += ( const Queue<_Ty> & );
inline const Queue<_Ty> & operator += ( const _Ty & );
inline const Queue<_Ty> operator + ( const Queue<_Ty> & );
inline const Queue<_Ty> operator + ( const _Ty & );
inline const BOOL operator == ( const Queue<_Ty> & )const;
inline const BOOL operator != ( const Queue<_Ty> & )const;
};
template <typename _Ty>
inline const Queue<_Ty>
Queue<_Ty>::operator + ( const _Ty & value )
{
Queue<_Ty> temp = *this;
return temp+=value;
}
template <typename _Ty>
inline const Queue<_Ty> &
Queue<_Ty>::operator += ( const _Ty & value )
{
this->add( value );
return * this;
}
template <typename _Ty>
inline const Queue<_Ty>
Queue<_Ty>::operator + ( const Queue<_Ty> & queue )
{
// q=q1+q2;
if( queue.empty() )
{
return * this;
}
else
{
Queue<_Ty> temp = *this;
return temp += queue;
}
}
template <typename _Ty>
inline const Queue<_Ty> &
Queue<_Ty>::operator += ( const Queue<_Ty> & queue )
{
if( ! queue.empty() )
{
for( const typename Queue<_Ty>::QueueItem * it = queue._head;
it != queue._tail;
it = it->_prior )
{
this->add( it->_data );
}
this->add( queue._tail->_data );
}
return * this;
}
template <typename _Ty>
inline const BOOL
Queue<_Ty>::operator != ( const Queue<_Ty> & queue )const
{
if( queue.size() != this->size() )
{
return TRUE;
}
else
{
const typename Queue<_Ty>::QueueItem * youit = queue._tail;
const typename Queue<_Ty>::QueueItem * myit = this->_tail;
for(; myit != this->_head; myit=myit->_next,youit=youit->_next)
{
if( myit->_data != youit->_data )
{
return TRUE;
}
}
return (queue._head->_data != this->_head->_data)?TRUE:FALSE;
}
}
template <typename _Ty>
inline const BOOL
Queue<_Ty>::operator == ( const Queue<_Ty> & queue )const
{
if( queue.size() != this->size() )
{
return FALSE;
}
else
{
const typename Queue<_Ty>::QueueItem * youit = queue._tail;
const typename Queue<_Ty>::QueueItem * myit = this->_tail;
for(; myit != this->_head; myit=myit->_next,youit=youit->_next)
{
if( myit->_data != youit->_data )
{
return FALSE;
}
}
return (queue._head->_data != this->_head->_data)?FALSE:TRUE;
}
}
template <typename _Ty>
inline const Queue<_Ty> &
Queue<_Ty>::operator = ( const Queue<_Ty> & queue )
{
if( &queue == this )
{
return *this;
}
else
{
while( ! this->empty() )
{
this->del();
}
for( const typename Queue<_Ty>::QueueItem * it = queue._head;
it != queue._tail;
it = it->_prior )
{
this->add( it->_data );
}
this->add( queue._tail->_data );
return * this;
}
}
template <typename _Ty>
const _Ty Queue<_Ty>::_temp = _Ty();
template <typename _Ty>
inline const _Ty &
Queue<_Ty>::get( void )const
{
if( this->empty() )
return _temp; //返回表的空数据
else
{
return this->_head->_data;
}
}
template <typename _Ty>
inline const BOOL
Queue<_Ty>::del( void )
{
if( this->empty() )
return FALSE;
else
{
const typename Queue<_Ty>::QueueItem * temp = _head;
_head = _head->_prior;
--_size;
delete temp;
return TRUE;
}
}
template <typename _Ty>
inline const BOOL
Queue<_Ty>::del( _Ty & value )
{
if( this->empty() )
return FALSE;
else
{
const typename Queue<_Ty>::QueueItem * temp = _head;
value = temp->_data;
_head = _head->_prior;
--_size;
delete temp;
return TRUE;
}
}
template <typename _Ty>
inline const size_type
Queue<_Ty>::size(void)const
{
return _size;
}
template <typename _Ty>
inline const BOOL
Queue<_Ty>::empty( void )const
{
return (_size)?FALSE:TRUE;
}
template <typename _Ty>
inline const Queue<_Ty> &
Queue<_Ty>::add( const _Ty & value )
{
typename Queue<_Ty>::QueueItem * temp =
new typename Queue<_Ty>::QueueItem( value );
if( empty() )
{
_head = _tail = temp;
++_size;
}
else
{
temp->_next = _tail;
_tail->_prior = temp;
_tail = temp;
++_size;
}
return *this;
}
template <typename _Ty>
inline Queue<_Ty>::Queue( const Queue<_Ty> & queue )
:_head(0),_tail(0),_size(0)
{
if( this == &queue )
return;
for( const typename Queue<_Ty>::QueueItem * iter = queue._head;
iter != queue._tail;
iter = iter->_prior )
{
this->add( iter->_data );
}
this->add( queue._tail->_data );
return;
}
#ifdef MYLIBRARY_DEBUG
template <typename _Ty>
inline ostream & operator << ( ostream & os, const Queue<_Ty> & queue )
{
os<<"Queue("<<queue.size()<<"):\n";
os<<"head--->";
if( !queue.empty() )
{
for( const typename Queue<_Ty>::QueueItem * it = queue._head;
it != queue._tail;
it = it->_prior )
{
os<<it->_data<<" ";
}
os<<queue._tail->_data;
}
os<<"<---tail\n";
return os;
}
#endif
}////////// end namespace MyLibrary
#endif