精华内容
下载资源
问答
  • 信息安全算法设计实验之一 //#include "stdafx.h" #include<iostream> #include<time.h> #include<stdlib.h> #include<cstring> using ...

    信息安全算法设计实验之一

    //#include "stdafx.h"
    #include<iostream>
    #include<time.h>
    #include<stdlib.h>
    #include<cstring>
    using namespace std;
    int a[10][10];
    int x, y;
    int random()//随机产生1~3范围中的一个数,代表走的方向
    {
    	return rand() % 4;
    }
    void process(int e)//e代表走的方向
    {
    	if (e == 1)
    	{
    		if ((x & 1)==0 && (x >= 2 && y >= 2))//若当前点是该行第奇数个点三角形往下走,第偶数个点三角形往上走
    			x--, y--;
    		else								//还要判断是否越界
    			if (x <= 7 && y <= 7)
    				x++, y++;
    	}
    	if (e == 2)//往左走
    		if (x >= 2)//还要保证不越界
    			x--;
    	if (e == 3)//往右走
    		if (x <= 7)//还要保证不越界
    			x++;
    }
    bool judge()//判断所有三角形是否都已经走过
    {
    	for (int i = 1; i <= 8; i++)
    		for (int j = 1; j <= i; j++)
    			if (a[i][j] == 0) return 0;
    	return 1;
    }
    void print()
    {
    	for (int i = 1; i <= 8; i++)
    	{
    		for (int j = 1; j <= i; j++)
    			cout << a[i][j] << ' ';
    		cout << endl;
    	}
    }
    int main()
    {
    	srand(time(0));
    	int T = 100;//老师要求模拟运行100次
    	long long ans = 0;
    	for(int i=1;i<=T;i++)
    	{
    		cout << "第" << i << "次:\n";
    		int cnt = 0;
    		x = 1; y = 1;
    		memset(a, 0, sizeof(a));
    		while (1)
    		{
    			process(random());
    			a[x][y]++;
    			for (int i = 1; i <= 8; i++)
    			{
    				for (int j = 1; j <= i; j++)
    					cout << a[i][j] << ' ';
    				cout << endl;
    			}
    			if (judge())//判断所有三角形是否都已经走过
    			{
    				print();
    				break;
    			}
    			else cnt++;
    		}
    		cout <<"总步数:" <<cnt << endl << endl;
    		ans += cnt;
    	}
    	cout <<"平均次数为:"<< fixed << double(ans) / 100 << endl;
    	system("pause");
    	return 0;
    }
    

     

    展开全文
  • 银行家算法的实验与测试,附有实验报告。课程作业用。
  • 算法设计与分析 实验报告

    千次阅读 2017-04-10 10:24:17
    算法设计与分析实验报告题目一:矩阵相乘题目二:最长公共子序列题目一:矩阵相乘一.问题描述给定n个矩阵{A1,A2,... ,An},其中这n个矩阵是可相乘的,i=1,2,...,n-1。算出这n个矩阵的相乘积A1A2 。。。An...



    算法设计与分析
    实验报告



    题目一:矩阵相乘
    题目二:最长公共子序列


    题目一:矩阵相乘
    一.问题描述
    给定n个矩阵{A1,A2,... ,An},其中这n个矩阵是可相乘的,i=1,2,...,n-1。算出这n个矩阵的相乘积A1A2 。。。An。
    补充:如果两个矩阵A和B是可相乘的,那么A的列数要和B的行数是相同的,否则,这两个矩阵是不可相乘的。它们的相乘结果矩阵C的行数是A的行数,而列数是B的列数。
    二.问题分析
    由于矩阵乘法满足结合律,故连乘积的计算可以有许多不同的计算次序。这种计算次序可以用加括号的方式来确定。若一个矩阵连乘积的计算次序已完全确定,也就是说该连乘积已完全加括号,则我们可以通过反复调用两个矩阵相乘的标准算法计算出矩阵连乘积。
    1.分析最优解的结构
    为了方便起见,我们将矩阵连乘AiAi+1 。。。Aj记为A[i:j]。经分析,计算      A[1:n]的一个最优次序所包含的计算矩阵子链A[1:k]和A[k:n]的次序也是最优的。因此,矩阵连乘计算次序问题的最优解包含着子问题的最优解。
    2.建立递归关系
    用矩阵m[n][n]来存放A[i:j]相乘的计算次数,用p[n+1]用来存放矩阵的行数和列数。
      0                                       i=j
                                        
    min={ m[i][k]+m[k+1][j]+pi-1pkpj }        i3.计算最优值
       另外,用一个数组s[n][n]来记录相应m[i][j]的分割下标
    注:数组元素的下标都是从0开始的,而不是1
    void MatrixChain(int *p, int n, int **m, int **s) {
        int i, j, r, k, t;
        for(i = 0; i < n; i++) {
            m[i][i] = 0;
            s[i][i] = 0;
        }
        for(r = 1; r < n; r++) {
            for(i = 0; i < n-r; i++) {
                j = i+r;
                m[i][j] = m[i][i]+m[i+1][j]+p[i]*p[i+1]*p[j+1];
                s[i][j] = i;
                for(k = i+1; k < j; k++) {
                    t = m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1];
                    if(t < m[i][j]) {
                        m[i][j] = t;
                        s[i][j] = k;
                    }
                }
            }
        }
    4.构造最优解
    根据上一步的m和s中的值,构造出最优解。
    void Traceback(int i, int j, int **s) {
        if(i == j) {
            return;
        }
        Traceback(i, s[i][j], s);
        Traceback(s[i][j]+1, j, s);
        cout<<"Multiply A"<    cout<<"and A"<<(s[i][j] +1)<<","<}
    三.程序源代码
    使用c++语言来实现
    #include
    #include
    #define X 10        //The count of array
    #define M 10        //The Row
    #define N 10        //The Column
    #define Stack_Size 20
    using namespace std;
    void MatrixChain(int *p, int n, int **m, int **s) {
        int i, j, r, k, t;
        for(i = 0; i < n; i++) {
            m[i][i] = 0;
            s[i][i] = 0;
        }
        for(r = 1; r < n; r++) {
            for(i = 0; i < n-r; i++) {
                j = i+r;
                m[i][j] = m[i][i]+m[i+1][j]+p[i]*p[i+1]*p[j+1];
                s[i][j] = i;
                for(k = i+1; k < j; k++) {
                    t = m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1];
                    if(t < m[i][j]) {
                        m[i][j] = t;
                        s[i][j] = k;
                    }
                }
            }
        }
    }
    void Traceback(int i, int j, int **s) {
        if(i == j) {
            return;
        }
        Traceback(i, s[i][j], s);
        Traceback(s[i][j]+1, j, s);
        cout<<"Multiply A"<    cout<<"and A"<<(s[i][j] +1)<<","<}
    int main()
    {
        ifstream fin("data.in");
        int i, j, data[X][M][N], p[X+1], pos, count;
        int **m, **s;
        m = new int*[X+1];
        s = new int*[X+1];
        for(i = 0; i < X+1; i++) {
            m[i] = new int[X+1];
            s[i] = new int[X+1];
        }
        for(i = 0; i < X+1; i++) {
            for(j = 0; j < X+1; j++) {
                m[i][j] = s[i][j] = 0;
            }
        }
        if(!fin.is_open()) {
            cout<<"Can not open the file data.in"<        return 1;
        }
        //read the data from the file
        fin>>count;
        for(pos = 0; pos < count; pos++) {
            fin>>p[pos]>>p[pos+1];
        }
        MatrixChain(p, count, m, s);
        Traceback(0, count-1, s);
        fin.close();
        for(i = 0; i < X+1; i++) {
            delete m[i];
            delete s[i];
        }
        delete m;
        delete s;
        return 0;
    }
    四.输入
    输入的一个名为”data.in”的文件,其中的一个测试内容为:
    5
    4 5
    5 3
    3 3
    3 4
    4 6
    五.输出
    在屏幕上输出的结果是
    Multiply A0,0and A1,1
    Multiply A2,2and A3,3
    Multiply A2,3and A4,4
    Multiply A0,1and A2,4
    题目二:最长公共子序列
    一.问题描述
        一个给定序列的子序列是在该序列中删去若干元素后得到的序列。在本题中,给定了两个序列X和Y,当另一个序列Z既是X的子序列又是Y的子序列时,我们就称Z为X和Y的公共子序列。当然这可能会有许多种,而我们又把其中最长的一个称为最长公共子序列。在本题中我们给了X和Y的序列,要计算出X和Y的最长公共子序列。
    二.问题分析
    1.最长公共子序列的结构
    设序列X={x1,x2,...,xm},Y={y1,y2,...,yn},它们的最长公共子序列是           Z={z1,z2,...,zk},则
     若xm=yn,则zk=xm=yn,且zk-1是Xm-1和Yn-1的最长公共子序列
    若xm≠yn,且zk≠xm,则z是Xm-1和Y的最长公共子序列
    若xm≠yn,且zk≠Yn,则z是X和Yn-1的最长公共子序列
    2.子问题的递归结构
    0                       i=0,j=0
    c[i-1][j-1]+1               i,j>0;xi=yj
    max{c[i][j-1],c[i-1][j]}       i,j>0;xi≠yj
    三.程序源代码
    使用c++语言来完成
    #include
    #include
    #include
    using namespace std;
    #define N 100
    ofstream fout;
    void LCSLength(int m, int n, char *x, char *y, int **c, int **b)
    {
        int i, j;

        for(i = 1; i <= m; i++) {
            c[i][0] = 0;
        }
        for(i = 1; i <= n; i++) {
            c[0][i] = 0;
        }
        for(i = 1; i <= m; i++) {
            for(j = 1; j <= n; j++) {
                if(x[i] == y[j]) {
                    c[i][j] = c[i-1][j-1]+1;
                    b[i][j] = 0;
                } else if(c[i-1][j] >= c[i][j-1]) {
                    c[i][j] = c[i-1][j];
                    b[i][j] = 1;
                } else {
                    c[i][j] = c[i][j-1];
                    b[i][j] = 2;
                }
            }
        }
    }
    void LCS(int i, int j, char *x, int **b) {
        if(i == 0 || j == 0) {
            return;
        }
        if(b[i][j] == 0) {
            LCS(i-1, j-1, x, b);
            fout<    } else if(b[i][j] == 1) {
            LCS(i-1, j, x, b);
        } else {
            LCS(i, j-1, x, b);
        }
    }
    int main() {
        ifstream fin("data.in");
        char *x, *y;
        int m, n, **c, **b, i, j;
        x = new char[N];
        y = new char[N];
        c = new int*[N];
        b = new int*[N];
        for(i = 0; i < N; i++) {
            c[i] = new int[N];
            b[i] = new int[N];
        }
        if(!fin.is_open()) {
            cout<<"Can not open the file \'data.in\'"<        return 1;
        }
        fout.open("data.out");
        if(!fout.is_open()) {
            cout<<"Can not open the file \'data.in\'"<        return 1;
        }
        while(!fin.eof()) {
            fin.getline(x, N);
            fin.getline(y, N);
        }
        m = strlen(x);
        n = strlen(y);
        for(i = 0; i <= m; i++) {
            for(j = 0; j <= n; j++) {
                c[i][j] = b[i][j] = 0;
            }
        }
        LCSLength(m, n, x, y, c, b);
        LCS(m, n, x, b);
        fin.close();
        fout.close();
        delete x;
        delete y;
        for(i = 0; i < N; i++) {
            delete c[i];
            delete b[i];
        }
        delete c;
        delete b;
        return 0;
    }
    四.输入
    文件”data.in’’
    sunjiangangoksunjiangnag
    baixiaotongabasdfasfassunjiangns
    五.输出
    文件”data.out”
    iangasunjiangn
     
    <script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"2","bdMiniList":false,"bdPic":"","bdStyle":"0","bdSize":"16"},"share":{}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new Date()/36e5)];</script>
    阅读(2432) | 评论(0) | 转发(0) |
    给主人留下些什么吧!~~
    评论热议
    展开全文
  • 页面置换算法课题实验报告

    千次阅读 2019-05-28 00:20:18
    安全1601_沈香港_16281077_操作系统lab4页面置换算法实验目的以及基本要求一、概要设计1.1模块1.2功能二、实现2.1数据结构设计2.2随机生成页面访问序列2.3模拟运行OPT页面替换算法2.4模拟运行LRU页面替换算法2.5模拟...

    页面置换算法

    说明:本实验在加深理解的基础上有参考孙汉武同学实验结果

    实验目的以及基本要求

    设计和实现最佳置换算法、先进先出置换算法、最近最久未使用置换算法、页面缓冲置换算法以及改进的CLOCK置换算法;通过页面访问序列随机发生器实现对上述算法的测试及性能比较。

    一、概要设计

    1.1模块

    我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮

    1.2功能

    (1)随机生成页面访问序列

    (2)模拟运行OPT页面替换算法

    (3)模拟运行LRU页面替换算法

    (4)模拟运行FIFO页面替换算法

    (5)模拟运行PBA页面替换算法

    (6)模拟运行改进CLOCK页面替换算法

    二、实现

    2.1数据结构设计

    typedef struct WorkItem
    {
    	int seq;
    	int priority;
    	char Used;//访问位
    	char Modified;//修改位
    }WorkItem;
    

    按照实验要求的固定属性
    16位,1k页面大小
    模拟的物理内存32块

    typedef struct MemSchedule
    {
    	WorkItem* WorkSpace = NULL;
    	int *VisitSeq = NULL;
    	int N = 64;
    	int p = 0;
    	//工作集大小
    	int e = 5;
    	int m = 1;
    	//定义访问序列长度o
    	int length;
    	//当前已使用物理块数
    	int work_len = 0;
    	//发生替换的物理块号
    	int change = 0;
    	float t, r;
    	//   队列长度
    	int queue_free_len = 0;
    	int queue_modified_len = 0;
    	WorkItem free[2];
    	WorkItem Modified[2];
    }MemSchedule;
    

    2.2随机生成页面访问序列

    生成访问页面序列

    MemSchedule GeneVisitSeq(int l)
    {
    	MemSchedule schedule1;
    	schedule1.t = rand() % 1000 / 1000.0;
    	schedule1.VisitSeq = (int *)malloc(l * sizeof(schedule1.m));
    	printf("生成随机内存访问序列:\n");
    	for (int i = 0; i<l; i++)
    	{
    		for (int j = 0; j<schedule1.m; j++)
    		{
    			schedule1.VisitSeq[i*schedule1.m + j] = rand() % schedule1.e + schedule1.p;
    			printf("%d ", schedule1.VisitSeq[i*schedule1.m + j]);
    		}
    		schedule1.r = rand() % 1000 / 1000.0;
    		if (schedule1.r<schedule1.t)
    		{
    			schedule1.p = (schedule1.p + 1) % schedule1.N;
    		}
    	}
    	printf("\n");
    	schedule1.length = l*schedule1.m;
    	schedule1.WorkSpace = (WorkItem *)malloc(schedule1.e * sizeof(WorkItem));
    	return schedule1;
    }
    

    2.3模拟运行OPT页面替换算法

    有关算法的分析
    当要调入一页而必须淘汰旧页时,应该淘汰以后不再访问的页,或距现在最长时间后要访问的页面。它所产生的缺页数最少,然而,却需要预测程序的页面引用串,这是无法预知的,不可能对程序的运行过程做出精确的断言,不过此理论算法可用作衡量各种具体算法的标准。
    算法流程图如下
    在这里插入图片描述

    代码如下

    int Opt(MemSchedule s1)
    {
    	//start和finish用于记录时间
    	clock_t start, finish;
    	//num表示优先级,每访问一个指令加一,所以优先级最低的就是最久没有被访问的到的,选择其替换
    	int miss = 0;
    	start = clock();
    	printf("***************最佳置换算法*****************\n");
    	printf("seq\t");
    	for (int i = 0; i<s1.e; i++)
    	{
    		printf("%d\t", i + 1);
    	}
    	printf("\n");
    	for (int i = 0; i<s1.length; i++)
    	{
    		int pointer = s1.VisitSeq[i];
    		printf("%d:\t", pointer);
    		//判断当前是否还有空闲物理块
    		if (s1.work_len<s1.e)
    		{
    			//此处的flag用于判断当前访问的序列是已经在内存中
    			int flag = 0;
    			//扫描一遍当前的内存块,进行更新优先级操作和查询下一个访问的页号是否在内存中
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				if (s1.WorkSpace[m].seq == pointer)
    					//若序列在内存中则将flag置为1
    					flag = 1;
    			}
    			if (flag == 1)
    			{
    				//若下一个访问的页号在内存中,则没有发生缺页,不需要发生替换,change值表示这一次没有
    				//缺页
    				s1.change = -1;
    			}
    			if (flag == 0)
    			{
    				//如下一个要访问的页号不在内存中,则发生缺页,需要直接将新的页号放入下一个空闲块中
    				//首先更新全部优先级
    				//直接将下一个空闲快替换
    				s1.WorkSpace[s1.work_len].seq = pointer;
    				//将替换变化了的内存块号写入
    				s1.change = s1.work_len;
    				//将已使用的内存数量加一
    				s1.work_len++;
    			}
    			//打印信息
    			for (int k = 0; k<s1.work_len; k++)
    			{
    				//如果发生了页面置换,则打印带@的信息
    				if (k == s1.change)
    				{
    					printf("%d@\t", s1.WorkSpace[k].seq);
    					//缺页率加一
    					miss++;
    				}
    				else
    					printf("%d\t", s1.WorkSpace[k].seq);
    			}
    			//剩下空闲的页面全部打印*
    			for (int j = 0; j<s1.e - s1.work_len; j++)
    			{
    				printf("*\t");
    			}
    
    		}
    		else
    		{
    			//表示没有空闲内存块
    			//还是使用flag表示当前物理块在内存中是否出现
    			int flag = 0;
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				if (s1.WorkSpace[m].seq == pointer)
    					flag = 1;
    			}
    			if (flag == 1)
    			{
    				//表示内存块已经出现过
    				s1.change = -1;
    			}
    			if (flag == 0)
    			{
    				//min表示最小优先级的那个内存块号
    				int min_pri = 0xffffff;
    				for (int m = 0; m<s1.work_len; m++)
    				{
    					int n = SearchVisitSqe(s1.VisitSeq, i - 1, s1.WorkSpace[m].seq, 0, s1.length - s1.work_len + m);
    					s1.WorkSpace[m].priority = n;
    					if (n < min_pri)
    					{
    						s1.change = m;
    						min_pri = n;
    					}
    				}
    				//表示发生替换变化的块号s1.change
    				s1.WorkSpace[s1.change].seq = pointer;
    			}
    			for (int m = 0; m<s1.e; m++)
    			{
    				if (m == s1.change)
    				{
    					printf("%d@\t", s1.WorkSpace[m].seq);
    					miss++;
    				}
    				else
    					printf("%d\t", s1.WorkSpace[m].seq);
    			}
    		}
    		printf("\n");
    		finish = clock();
    	}
    
    	printf("******************算法评估**************\n");
    	printf("缺页率:\t%.2f %%\n", (miss*1.0) / s1.length * 100);
    	printf("时间开销:\t%.2f ms\n", (double)(finish - start));
    	free(s1.WorkSpace);
    	free(s1.VisitSeq);
    	return 0;
    }
    

    实验结果
    在这里插入图片描述

    2.4模拟运行LRU页面替换算法

    算法说明
    最近最少使用,简单来说就是将数据块中,每次使用过的数据放在数据块的最前端,然后将存在的时间最长的,也就是数据块的末端的数据剔除掉这就是LRU算法。
    算法流程图
    在这里插入图片描述
    算法代码实现

    int LRU(MemSchedule s1)
    {
    	//start和finish用于记录时间
    	clock_t start, finish;
    	//num表示优先级,每访问一个指令加一,所以优先级最低的就是最久没有被访问的到的,选择其替换
    	int miss = 0;
    	start = clock();
    	printf("***************LRU*****************\n");
    	printf("seq\t");
    	for (int i = 0; i<s1.e; i++)
    	{
    		printf("%d\t", i + 1);
    	}
    	printf("\n");
    	for (int i = 0; i<s1.length; i++)
    	{
    		int pointer = s1.VisitSeq[i];
    		printf("%d:\t", pointer);
    		//判断当前是否还有空闲物理块
    		if (s1.work_len<s1.e)
    		{
    			//此处的flag用于判断当前访问的序列是已经在内存中
    			int flag = 0;
    			//扫描一遍当前的内存块,进行更新优先级操作和查询下一个访问的页号是否在内存中
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				if (s1.WorkSpace[m].seq == pointer)
    					//若序列在内存中则将flag置为1
    					flag = 1;
    			}
    			if (flag == 1)
    			{
    				//若下一个访问的页号在内存中,则没有发生缺页,不需要发生替换,change值表示这一次没有
    				//缺页
    				s1.change = -1;
    			}
    			if (flag == 0)
    			{
    				//如下一个要访问的页号不在内存中,则发生缺页,需要直接将新的页号放入下一个空闲块中
    				//首先更新全部优先级
    				//直接将下一个空闲快替换
    				s1.WorkSpace[s1.work_len].seq = pointer;
    				//将替换变化了的内存块号写入
    				s1.change = s1.work_len;
    				//将已使用的内存数量加一
    				s1.work_len++;
    			}
    			//打印信息
    			for (int k = 0; k<s1.work_len; k++)
    			{
    				//如果发生了页面置换,则打印带@的信息
    				if (k == s1.change)
    				{
    					printf("%d@\t", s1.WorkSpace[k].seq);
    					//缺页率加一
    					miss++;
    				}
    				else
    					printf("%d\t", s1.WorkSpace[k].seq);
    			}
    			//剩下空闲的页面全部打印*
    			for (int j = 0; j<s1.e - s1.work_len; j++)
    			{
    				printf("*\t");
    			}
    
    		}
    		else
    		{
    			//表示没有空闲内存块
    			//还是使用flag表示当前物理块在内存中是否出现
    			int flag = 0;
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				if (s1.WorkSpace[m].seq == pointer)
    					flag = 1;
    			}
    			if (flag == 1)
    			{
    				//表示内存块已经出现过
    				s1.change = -1;
    			}
    			if (flag == 0)
    			{
    				//min表示最小优先级的那个内存块号
    				int min_pri = -10000;
    				for (int m = 0; m<s1.work_len; m++)
    				{
    					int n = SearchVisitSqe(s1.VisitSeq, i, s1.WorkSpace[m].seq, 1, i);
    					s1.WorkSpace[m].priority = n;
    					if (n > min_pri)
    					{
    						s1.change = m;
    						min_pri = n;
    					}
    				}
    				//表示发生替换变化的块号s1.change
    				s1.WorkSpace[s1.change].seq = pointer;
    			}
    			for (int m = 0; m<s1.e; m++)
    			{
    				if (m == s1.change)
    				{
    					printf("%d@\t", s1.WorkSpace[m].seq);
    					miss++;
    				}
    				else
    					printf("%d\t", s1.WorkSpace[m].seq);
    			}
    		}
    		printf("\n");
    		finish = clock();
    	}
    
    	printf("******************算法评估**************\n");
    	printf("缺页率:\t%.2f %%\n", (miss*1.0) / s1.length * 100);
    	printf("时间开销:\t%.2f ms\n", (double)(finish - start));
    	free(s1.WorkSpace);
    	free(s1.VisitSeq);
    	return 0;
    }
    

    代码执行结果
    在这里插入图片描述

    2.5模拟运行FIFO页面替换算法

    算法简介
    优先淘汰最早进入内存的页面,亦即在内存中驻留时间最久的页面。该算法实现简单,只需把调入内存的页面根据先后次序链接成队列,设置一个指针总指向最早的页面。但该算法与进程实际运行时的规律不适应,因为在进程中,有的页面经常被访问。
    算法流程图
    在这里插入图片描述
    实验代码

    int Fifo(MemSchedule s1)
    {
    	clock_t start, finish;
    	start = clock();
    	int miss = 0;
    	printf("***************先入先出算法*****************\n");
    	printf("seq\t");
    	for (int i = 0; i<s1.e; i++)
    	{
    		printf("%d\t", i + 1);
    	}
    	printf("\n");
    	for (int i = 0; i<s1.length; i++)
    	{
    		//pointer指向当前正在访问的物理序列
    		int pointer = s1.VisitSeq[i];
    		printf("%d:\t", pointer);
    		//判断当前是否还有空闲物理块
    		if (s1.work_len<s1.e)
    		{
    			//表示还有剩余的空闲物理块
    			int flag = 0;//flag用于标记下一个页号是否在物理块中
    						 //扫描一遍工作集,查看下一个页号是否存在
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				s1.WorkSpace[m].priority--;
    				if (s1.WorkSpace[m].seq == pointer)
    					//若序列在内存中则将flag置为1
    				{
    					flag = 1;
    					s1.WorkSpace[m].priority = s1.e;
    				}
    			}
    			if (flag == 1)
    			{
    				//若下一个访问的页号在内存中,则没有发生缺页,不需要发生替换,change值表示这一次没有
    				//缺页
    				s1.change = -1;
    			}
    			if (flag == 0)
    			{
    				//如下一个要访问的页号不在内存中,则发生缺页,需要直接将新的页号放入下一个空闲块中
    				//首先更新全部优先级
    				//直接将下一个空闲快替换
    				s1.WorkSpace[s1.work_len].seq = pointer;
    				s1.WorkSpace[s1.work_len].priority = s1.e;
    				//将替换变化了的内存块号写入
    				s1.change = s1.work_len;
    				//将已使用的内存数量加一
    				s1.work_len++;
    			}
    			//打印信息
    			for (int k = 0; k<s1.work_len; k++)
    			{
    				//如果发生了页面置换,则打印带@的信息
    				if (k == s1.change)
    				{
    					printf("%d@\t", s1.WorkSpace[k].seq);
    					//缺页率加一
    					miss++;
    				}
    				else
    					printf("%d\t", s1.WorkSpace[k].seq);
    			}
    			//剩下空闲的页面全部打印*
    			for (int j = 0; j<s1.e - s1.work_len; j++)
    			{
    				printf("*\t");
    			}
    
    
    		}
    		else
    		{
    			//表示没有空闲物理块
    			//还是使用flag表示当前访问页号是否在内存块中
    			int flag = 0;
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				//每访问一个新的页面,所有优先级全部下降一
    				s1.WorkSpace[m].priority--;
    				if (s1.WorkSpace[m].seq == pointer)
    				{
    					flag = 1;
    					s1.WorkSpace[m].priority = s1.e;
    
    				}
    			}
    			if (flag == 1)
    			{
    				//表示内存块已经出现过
    				s1.change = -1;
    			}
    			if (flag == 0)
    			{
    				//min表示最小优先级的那个内存块号
    				int min_pri = 0xffffff;
    				for (int m = 0; m<s1.work_len; m++)
    				{
    					//和其他算法的区别只有优先级排序计算的方式不同
    					int n = s1.WorkSpace[m].priority;
    					if (n < min_pri)
    					{
    						s1.change = m;
    						min_pri = n;
    					}
    				}
    				//表示发生替换变化的块号s1.change
    				s1.WorkSpace[s1.change].seq = pointer;
    				//设置新换入的页面优先级为work_len
    				s1.WorkSpace[s1.change].priority = s1.e;
    			}
    			for (int m = 0; m<s1.e; m++)
    			{
    				if (m == s1.change)
    				{
    					printf("%d@\t", s1.WorkSpace[m].seq);
    					miss++;
    				}
    				else
    					printf("%d\t", s1.WorkSpace[m].seq);
    			}
    
    
    		}
    		printf("\n");
    	}
    	finish = clock();
    	printf("******************算法评估**************\n");
    	printf("缺页率:\t%.2f %%\n", (miss*1.0) / s1.length * 100);
    	printf("时间开销:\t%.2f ms\n", (double)(finish - start));
    	free(s1.WorkSpace);
    	free(s1.VisitSeq);
    	return  0;
    }
    

    实验结果截图
    在这里插入图片描述

    2.6模拟运行PBA页面替换算法

    算法说明
    用 FIFO 算法选择被置换页,选择换出的页面不是立即换出,而是放入两个链表之一,如果页面未被修改,就将其归入到空闲页面链表的末尾,否则将其归入已修改页面链表末尾。
    算法代码实现

    int PBA(MemSchedule s1)
    {
      clock_t start, finish;
      start = clock();
      int miss = 0;
      printf("***************PBA*****************\n");
      printf("seq\t");
      for (int i = 0; i<s1.e; i++)
      {
      	printf("%d\t", i + 1);
      }
      printf("\n");
      for (int i = 0; i<s1.length; i++)
      {
      	//pointer指向当前正在访问的物理序列
      	int pointer = s1.VisitSeq[i];
      	printf("%d:\t", pointer);
      	//判断当前是否还有空闲物理块
      	if (s1.work_len<s1.e)
      	{
      		//表示还有剩余的空闲物理块
      		int flag = 0;//flag用于标记下一个页号是否在物理块中
      					 //扫描一遍工作集,查看下一个页号是否存在
      		for (int m = 0; m<s1.work_len; m++)
      		{
      			s1.WorkSpace[m].priority--;
      			if (s1.WorkSpace[m].seq == pointer)
      				//若序列在内存中则将flag置为1
      			{
      				flag = 1;
      				s1.WorkSpace[m].priority = s1.e;
      			}
      		}
      		if (flag == 1)
      		{
      			//若下一个访问的页号在内存中,则没有发生缺页,不需要发生替换,change值表示这一次没有
      			//缺页
      			s1.change = -1;
      		}
      		if (flag == 0)
      		{
      			//如下一个要访问的页号不在内存中,则发生缺页,需要直接将新的页号放入下一个空闲块中
      			//首先更新全部优先级
      			//直接将下一个空闲快替换
      			s1.WorkSpace[s1.work_len].seq = pointer;
      			s1.WorkSpace[s1.work_len].priority = s1.e;
      			//将替换变化了的内存块号写入
      			s1.change = s1.work_len;
      			//将已使用的内存数量加一
      			s1.work_len++;
      		}
      		//打印信息
      		for (int k = 0; k<s1.work_len; k++)
      		{
      			//如果发生了页面置换,则打印带@的信息
      			if (k == s1.change)
      			{
      				printf("%d@\t", s1.WorkSpace[k].seq);
      				//缺页率加一
      				miss++;
      			}
      			else
      				printf("%d\t", s1.WorkSpace[k].seq);
      		}
      		//剩下空闲的页面全部打印*
      		for (int j = 0; j<s1.e - s1.work_len; j++)
      		{
      			printf("*\t");
      		}
    
    
      	}
      	else
      	{
      		//表示没有空闲物理块
      		//还是使用flag表示当前访问页号是否在内存块中
      		int flag = 0;
      		for (int m = 0; m<s1.work_len; m++)
      		{
      			//每访问一个新的页面,所有优先级全部下降一
      			s1.WorkSpace[m].priority--;
      			if (s1.WorkSpace[m].seq == pointer)
      			{
      				flag = 1;
      				s1.WorkSpace[m].priority = s1.e;
    
      			}
      		}
      		if (flag == 1)
      		{
      			//表示内存块已经出现过
      			s1.change = -1;
      		}
      		if (flag == 0)
      		{
      			//min表示最小优先级的那个内存块号
      			int min_pri = 0xffffff;
      			for (int m = 0; m<s1.work_len; m++)
      			{
      				//和其他算法的区别只有优先级排序计算的方式不同
      				int n = s1.WorkSpace[m].priority;
      				if (n < min_pri)
      				{
      					s1.change = m;
      					min_pri = n;
      				}
      			}
      			//表示发生替换变化的块号s1.change
      			s1.WorkSpace[s1.change].seq = pointer;
      			//设置新换入的页面优先级为work_len
      			s1.WorkSpace[s1.change].priority = s1.e;
      		}
      		for (int m = 0; m<s1.e; m++)
      		{
      			if (m == s1.change)
      			{
      				printf("%d@\t", s1.WorkSpace[m].seq);
      				miss++;
      			}
      			else
      				printf("%d\t", s1.WorkSpace[m].seq);
      		}
    
    
      	}
      	printf("\n");
      }
      finish = clock();
      printf("******************算法评估**************\n");
      printf("缺页率:\t%.2f %%\n", (miss*1.0) / s1.length * 100);
      printf("时间开销:\t%.2f ms\n", (double)(finish - start));
      free(s1.WorkSpace);
      free(s1.VisitSeq);
      return  0;
    }
    

    代码实现结果
    在这里插入图片描述

    2.7模拟运行改进CLOCK页面替换算法

    算法说明
    在将一个页面换出时,如果该页已被修改过,便须将该页重新写回到磁盘上;但如果该页未被修改过,则不必将它拷回磁盘。在改进型Clock算法中,除须考虑页面的使用情况外,还须在增加一个因素,即置换代价,这样页面换出时,既要是未使用过的页面,又要是未被修改过的页面。把同时满足这两个条件的页面作为首选淘汰的页面。由访问位A和修改位M可以组合成下面四种类型的页面:
    1类(A=0,M=0):表示该页最近既未被访问,又未被修改,是最佳淘汰页。
    2类(A=0,M=0):表示该页最近未被访问,但已被修改,并不是很好的淘汰页。
    3类(A=1,M=0):表示该页最近已被访问,但未被修改,该页有可能在被访问。
    4类(A=1,M=1):表示该页最近已被访问且被修改,该页可能再被访问。

    算法实现代码

    int Clock(MemSchedule s1)
    {
    	int miss = 0;
    	clock_t start, finish;
    	start = clock();
    	printf("***************改进Clock算法*****************\n");
    	printf("seq\t");
    	for (int i = 0; i<s1.e; i++)
    	{
    		printf("[%d]UM\t", i + 1);
    	}
    	printf("\n");
    	for (int i = 0; i<s1.length; i++)
    	{
    		//pointer指向下一个将要访问的页号
    		int pointer = s1.VisitSeq[i];
    		printf("%d:\t", pointer);
    		//判断当前是否还有空闲物理块
    		if (s1.work_len < s1.e)
    		{
    			//表示还有空闲物理块
    			int flag = 0;//表示下一个要访问的页号是否在内存块中
    			int flag1 = 0;//标记与下一个页号相同的内存块号
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				if (s1.WorkSpace[m].seq == pointer)
    					//若序列在内存中则将flag置为1
    				{
    					flag = 1;
    					flag1 = m;
    					break;
    
    				}
    			}
    			if (flag == 1)
    			{
    				//若下一个访问的页号在内存中,则没有发生缺页,不需要发生替换,change值表示这一次没有
    				//缺页
    				s1.change = -1;
    				s1.WorkSpace[flag1].Modified = 'Y';
    			}
    			if (flag == 0)
    			{
    				//如下一个要访问的页号不在内存中,则发生缺页,需要直接将新的页号放入下一个空闲块中
    				//首先更新全部优先级
    				//直接将下一个空闲快替换
    				s1.WorkSpace[s1.work_len].seq = pointer;
    				//将刚刚调入内存的物理块号的使用位设置为1
    				s1.WorkSpace[s1.work_len].Used = 'Y';
    				s1.WorkSpace[s1.work_len].Modified = 'N';
    				//将替换变化了的内存块号写入
    				s1.change = s1.work_len;
    				//将已使用的内存数量加一
    				s1.work_len++;
    			}
    			//打印信息
    			for (int k = 0; k<s1.work_len; k++)
    			{
    				//如果发生了页面置换,则打印带@的信息
    				if (k == s1.change)
    				{
    					printf("[%d]%c%c@\t", s1.WorkSpace[k].seq, s1.WorkSpace[k].Used, s1.WorkSpace[k].Modified);
    					//缺页率加一
    					miss++;
    				}
    				else
    					printf("[%d]%c%c\t", s1.WorkSpace[k].seq, s1.WorkSpace[k].Used, s1.WorkSpace[k].Modified);
    			}
    			//剩下空闲的页面全部打印*
    			for (int j = 0; j<s1.e - s1.work_len; j++)
    			{
    				printf("*\t");
    			}
    
    
    
    		}
    		else
    		{
    			//此处表示没有空闲页面的情况
    			//还是使用flag表示新调入的页面是否在内存中已经有了
    			int flag = 0;
    			int flag1 = 0;//flag1记录下一个要访问的页面在内存中的块号
    			for (int m = 0; m<s1.work_len; m++)
    			{
    				if (s1.WorkSpace[m].seq == pointer)
    				{
    					flag = 1;
    					flag1 = m;
    					break;
    				}
    			}
    			if (flag == 1)
    			{
    				//表示内存块已经出现过
    				s1.WorkSpace[flag1].Modified = 'Y';
    				s1.change = -1;
    			}
    			if (flag == 0)
    			{
    				//表示内存块中没有出现过
    				for (int t = 0; t<2; t++)
    				{
    					int flag = 0;
    					for (int m = 0; m<s1.work_len; m++)
    					{
    						if (s1.WorkSpace[m].Used == 'N' && s1.WorkSpace[m].Modified == 'N')
    						{
    							s1.change = m;
    							flag = 1;
    							break;
    						}
    					}
    					if (flag == 0)
    					{
    						for (int m = 0; m<s1.work_len; m++)
    						{
    							if (s1.WorkSpace[m].Used == 'N' && s1.WorkSpace[m].Modified == 'Y')
    							{
    								s1.change = m;
    								flag = 1;
    								break;
    							}
    							s1.WorkSpace[m].Used = 'N';
    						}
    					}
    					if (flag != 0)
    						break;
    
    				}
    				s1.WorkSpace[s1.change].seq = pointer;
    				s1.WorkSpace[s1.change].Used = 'Y';
    				s1.WorkSpace[s1.change].Modified = 'N';
    
    			}
    			//打印信息
    			for (int k = 0; k<s1.work_len; k++)
    			{
    				//如果发生了页面置换,则打印带@的信息
    				if (k == s1.change)
    				{
    					printf("[%d]%c%c@\t", s1.WorkSpace[k].seq, s1.WorkSpace[k].Used, s1.WorkSpace[k].Modified);
    					//缺页率加一
    					miss++;
    				}
    				else
    					printf("[%d]%c%c\t", s1.WorkSpace[k].seq, s1.WorkSpace[k].Used, s1.WorkSpace[k].Modified);
    			}
    		}
    		printf("\n");
    	}
    	finish = clock();
    	printf("******************算法评估**************\n");
    	printf("缺页率:\t%.2f %%\n", (miss*1.0) / s1.length * 100);
    	printf("时间开销:%.2f ms\n", (double)(finish - start));
    	free(s1.WorkSpace);
    	free(s1.VisitSeq);
    	return 0;
    }
    

    代码实现结果
    在这里插入图片描述

    展开全文
  • 掌握回溯算法思想 掌握回溯递归原理 了解回溯法典型问题 二、实验内容 编写一个简单的程序,解决8皇后问题。 批处理作业调度问题 [问题描述]给定n个作业的集合J=(J1, J2, … , Jn)。每一个作业Ji都有两项任务需要...

    一、实验目的

    1. 掌握回溯算法思想
    2. 掌握回溯递归原理
    3. 了解回溯法典型问题

    二、实验内容

    1. 编写一个简单的程序,解决8皇后问题。
    2. 批处理作业调度问题
      [问题描述]给定n个作业的集合J=(J1, J2, … , Jn)。每一个作业Ji都有两项任务需要分别在2台机器上完成。每一个作业必须先由机器1处理,然后再由机器2处理。作业Ji需要机器i的处理时间为tji,i=1,2, … ,n; j=1,2。
      对于一个确定的作业调度,设Fji是作业i在机器i上完成处理的时间。则所有作业在机器2上完成处理的时间和成为该作业调度的完成时间和。
      在这里插入图片描述
      批处理作业调度问题要求对于给定的n个作业,制定一个最佳的作业调度方案,使其完成时间和达到最小。
      要求输入:
      1)作业数 2)每个作业完成时间表:
      在这里插入图片描述
      要求输出: 1)最佳完成时间 2)最佳调度方案
      提示:算法复杂度为O(n!),建议在测试的时候n值不要太大,可以考虑不要超过12。
    3. 数字全排列问题
      任意给出从1到N的N个连续的自然数,求出这N个自然数的各种全排列。如N=3时,共有以下6种排列方式:123,132,213,231,312,321。
      注意:数字不能重复,N由键盘输入(N<=9)。

    三、算法思想分析

    1. 8皇后问题
      基本思想为一个基本的回溯,从最开始的空棋盘先放一个棋子,然后根据放置的棋子推演出一个新的局面,然后下下一行的棋子,一直递归的下下去直到最后一行下好,这样一个情况就产生成功;如果在中途的某一行没有地方可以下子,则恢复上一局面,在上一行重新下子,这样通过树形的穷举,即回溯的状态空间树,就可以将所有可能都推演一遍。
      实现时的算法描述为:
      在这里插入图片描述
      安全算法描述:
      判断竖直线,主对角线,副对角线是否有棋子
    2. 批处理作业调度问题
      基本思想为一个排序树,根据排序树每次推演的情况得到该情况所需调度时间,并与当前最优方案比较,如果调度时间更小,则将当前最小时间与当前情况储存,直到所有情况都已经推演完毕,最后输出结果。
      排列树思想基于一个交换的过程,每次推演时将当前结点与未使用的结点进行交换,得到多种情况,每种情况同样递归调用算法进行推演,最后每个结点都推演过自己的子集,这样所有的情况就能推演全。
      算法描述
      在这里插入图片描述
    3. 数字全排列问题
      基本思想完全就是一个排列树,每次完成一次推演输出当前情况即可。
      排列树算法描述请见第二题算法思想概述,在这里不再赘述。

    四、实验过程分析
    本次实验重点练习了回溯的相关内容,而回溯算法由于其有线索的性质,可以通过一个线索递归调用函数将所有情况推演出,而非单纯的去穷举,这样在穷举过程中就可以有条理地交与机器去执行。在实验中由于理解不够,在做皇后问题时忘记了对现场的恢复,一度导致整个局面十分混乱,归根结底是对回溯的思想理解的不透,在将8皇后完整地实现之后,在做排列树时就相对有针对性了,虽然推演的方法不同,但根据判定—改线索向下推进—递归调用自身—恢复现场的方法,可以对排列树的思想较快的理解,这是我十分可喜的收获。
    同时通过本次实验,我深切感受到了回溯法的算法复杂度确实较大,如8皇后问题需要秒为单位的时间才能解决,这和之前的时间比是十分长的。

    五、算法源代码及用户屏幕
    1.8皇后问题
    ①代码

    #include <iostream>
    using namespace std;
    #define NUM 50
    int queen(int res[], int i, int chess[][NUM], int column[], int left[], int right[], int n) 	{
    	for (int j = 0; j < n; j++) {
    		//判断是否安全
    		if (!column[j] && !left[i + j] && !right[i - j + n]) {
    			//放皇后
    			chess[i][j] = column[j] = left[i + j] = right[i - j + n] = 1;
    			//判断是否到最后一行
    			if (i == n - 1) {
    				res[0]++;
    				cout << "situation " << res[0] << endl;
    				for (int i = 0; i < n; i++) {
    					for (int j = 0; j < n; j++) {
    						if (j == n - 1)cout << chess[i][j] << endl;
    						else cout << chess[i][j] << " ";
    					}
    				}
    				cout << endl;
    			}
    			//如果没有,下挖
    			else queen(res, i + 1, chess, column, left, right, n);
    			//去皇后
    			chess[i][j] = column[j] = left[i + j] = right[i - j + n] = 0;
    		}
    	}
    	return res[0];
    }
    int main() {
    	int n;
    	cout << "Please input the size of chessboard: ";
    	cin >> n;
    	int chess[NUM][NUM] = { 0 };
    	int column[n] = { 0 };
    	int left[2 * n] = { 0 };
    	int right[2 * n] = { 0 };
    	int count = 0;
    	int res[1] = { 0 };
    	res[0] = queen(res, 0, chess, column, left, right, n);
    	cout << "the total number of the situation is: " << res[0];
    	system("pause");
    	return 0;
    }
    

    ②用户界面
    首先输入棋盘格数,然后回车返回各个情况的内容与所有情况的个数。
    在这里插入图片描述
    在这里插入图片描述
    2. 批处理作业调度问题
    ①代码

    #include <iostream>
    using namespace std;
    #define NUM 100
    void jobScheduling(int jobs[][NUM], int m, int i, int min[], int temp[]) {
    
    	if (i > m) {
    		for (int i = 1; i <= m; i++) {
    			cout << temp[i] << " ";
    		}
    		int sum = 0;
    		for (int j = 1; j <= m; j++) {
    			for (int k = 1; k <= j; k++) {
    				sum += jobs[k][1];
    			}
    			sum += jobs[j][2];
    		}
    		cout << sum << endl;
    		if (sum < min[0]) {
    			min[0] = sum;
    			for (int j = 1; j <= m; j++) {
    				min[j] = temp[j];
    			}
    		}
    	}
    	else {
    		for (int t = i; t <= m; t++) {
    			//交换
    			for (int k = 1; k <= 2; k++) {
    				int temp = jobs[t][k];
    				jobs[t][k] = jobs[i][k];
    				jobs[i][k] = temp;
    			}
    			int tmp = temp[t];
    			temp[t] = temp[i];
    			temp[i] = tmp;
    			//递归向下调度
    			jobScheduling(jobs, m, i + 1, min, temp);
    			//恢复现场
    			for (int k = 1; k <= 2; k++) {
    				int temp = jobs[t][k];
    				jobs[t][k] = jobs[i][k];
    				jobs[i][k] = temp;
    			}
    			tmp = temp[t];
    			temp[t] = temp[i];
    			temp[i] = tmp;
    		}
    	}
    }
    int main() {
    	int m;
    	cout << "Please input the number of jobs: ";
    	cin >> m;
    	cout << "Please input the time of each job and each machine: ";
    	int jobs[NUM][NUM];
    	int min[m + 1];
    	int temp[m + 1];
    	min[0] = 1000;
    	for (int i = 1; i < m + 1; i++) {
    		min[i] = i;
    		temp[i] = i;
    	}
    	for (int i = 1; i <= m; i++) {
    		for (int j = 1; j <= 2; j++) {
    			cin >> jobs[i][j];
    		}
    	}
    	jobScheduling(jobs, m, 1, min, temp);
    	cout << "the minimum of the total scheduling time is: " << min[0] << endl;
    	cout << "the scheduling mechod is: ";
    	for (int i = 1; i <= m; i++) {
    		cout << min[i] << " ";
    	}
    	system("pause");
    	return 0;
    }
    

    ②用户界面
    首先输入作业个数,然后输入每个作业在机器1与机器2上运行的时间,然后回车输出每个情况的结果与所求的最小时间结果与对应情况。
    在这里插入图片描述
    3. 数字全排列问题
    ①代码

    #include<iostream>
    using namespace std;
    #define NUM 20
    void allSort(int i, int n, int num[]) {
    	if (i >= n) {
    		for (int i = 0; i < n; i++) {
    			cout << num[i] << " ";
    		}
    		cout << endl;
    	}
    	else {
    		for (int t = i; t < n; t++) {
    			int temp = num[t];
    			num[t] = num[i];
    			num[i] = temp;
    
    			allSort(i + 1, n, num);
    
    			temp = num[t];
    			num[t] = num[i];
    			num[i] = temp;
    		}
    	}
    }
    int main() {
    	int num;
    	cout << "Please input the number: ";
    	cin >> num;
    	int n[num];
    	for (int i = 0; i < num; i++) {
    		n[i] = i + 1;
    	}
    	allSort(0, num, n);
    	system("pause");
    	return 0;
    }
    

    ②用户界面
    首先输入数字个数,然后回车显示所有情况。
    在这里插入图片描述

    展开全文
  • 基于JAVA的银行家算法实现实验报告

    千次阅读 2020-04-03 21:59:58
    一、实验概述 1. 实验名称 基于JAVA平台的银行家算法实现 ...(3)理解和掌握安全序列、安全算法。 3. 实验内容 银行家算法: 银行家算法最初级原为银行系统设计,以确保银行在发放现金贷款时,不会发生...
  • 操作系统 进程调度-银行家算法实验报告

    千次阅读 多人点赞 2020-06-19 09:56:25
    实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生,以加深对课堂上所讲授的知识的理解。 二、 实验要求 ...
  • 实验五 银行家算法 一实验目的和要求 理解死锁概念银行家算法及安全检测算法 在Linux操作系统下用C++进行编程 利用C++设计实现银行家算法的基本过程 验证银行家算法对于避免死锁的作用 二实验方法内容 算法设计思路 ...
  • 实验三_银行家算法 完整课程设计

    热门讨论 2011-05-31 10:29:24
    实验三_银行家算法实验三_银行家算法实验三_银行家算法实验三_银行家算法实验三_银行家算法实验三_银行家算法实验三_银行家算法实验三_银行家算法
  • 相应的任务,并独立完成实验报告。 3、实验内容 设计的数据库系统可从以下题目中选择,但不限定于以下题目,可自由选择。要求独立完成下列系统所需的 数据库的需求分析、概念结构设计、逻辑结构设计、...
  • 信息安全实验-古典密码算法

    千次阅读 2019-06-08 19:27:46
    1、实验步骤 古典密码算法曾被广泛应用,大都比较简单,使用手工和机械操作来实现加密和解密。 (1)替代密码 替代密码算法的原理是使用替代法进行加密,就是对明文中的字符用其他字符替代后形成密文。例如,明文...
  • 对称密码算法DES,非对称密码算法RSA,实验报告!~包含源码和截图
  • 算法设计与分析实验报告,附已通过源码,供学习参考,共勉♪ 目录摘要如下: 1.问题描述 2.实验目的 3.实验原理 4.实验设计 (包括输入格式、算法、输出格式) 5.实验结果与分析 (除了截图外,实验结果还用...
  • 创建服务器的开发 算法:冒泡排序、选择排序、插入排序、堆排序、树、图 Mysql安装使用,数据类型、DDL语句建库建表 数据库库、表设计思路及数据库开发 使用pymysql驱动,创建ORM,CRUD操作和事务 连接池实现和...
  • 信息安全基础综合实验总共包含有二大块的内容,分为小组作业(小组作业有四项任务,为Fermat素性检验算法、中国剩余定理、密钥分配以及SM3的实现)和个人作业(SM2加密算法的实现),我也会分别通过五篇博客来分别...
  • 【注意】代码在文末,以下为详细实验报告 【实验目的】   银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性;若...
  • 实验二 固件程序设计 1.MDK 实验要求 0. 注意不经老师允许不准烧写自己修改的代码 1. 两人(个别三人)一组 2. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章,1.1-1.5安装MDK,JLink驱动,注意,要...
  • 完成一个DES 算法的**详细设计**,内容包括:算法原理概述;总体结构; 数据结构;类-C语言算法过程
  • 银行家算法实验

    千次阅读 2020-07-10 23:21:45
    银行家算法 一、实验目的 加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用银行家算法,有效的...
  • 实验三 分类算法实验 代码已开源:[https://github.com/LinXiaoDe/ArtificialIntelligence/tree/master/lab3](https://github.com/LinXiaoDe/ArtificialIntelligence/tree/master/lab3) 在本实验中,我手工实现了...
  • 银行家算法c++课程设计

    千次阅读 2017-05-30 22:29:40
    课程设计报告名称     1. 课程设计内容  本实验实现“银行家算法” 银行家算法的作用是防止发生死锁,提前检测出系统是否安全,如果系统安全,银行家算法还会求出系统的安全序列。银行家算法中银行家对客户相当...
  • 数据库实验报告

    千次阅读 2018-11-11 19:29:17
    《数据库系统原理课程设计》 讲 义                 黑龙江大学计算机科学技术学院 黑龙江大学软件学院  2018年3月     课程简介 一、开设本课程设计的目的 数据库系统原理是软件工程...
  • 首先声明,以下代码参考了这位大牛。...接着是对银行家算法优化的说明:(直接粘贴自己实验报告上的) 安全算法:满足available和need的关系后,即满足安全性检查进行请求分配。满足request和need的关系以及request和av
  • 机器学习(10): Apriori算法 小结及实验

    千次阅读 多人点赞 2019-07-29 16:14:25
    文章目录1 Apriori算法简介2 关联分析简介2.1 关联分析2.2 频繁项集的度量标准2.2.1 支持度2.2.2 置信度2.3 关联规则3 Apriori算法原理3.1 先验原理3.2 Apriori 算法流程4 实验4.1 使用Apriori算法来发现频繁项集...
  • 实验内容与要求用C或C++语言实现下列要求,并写出实验报告,报告内容包括:题目、目的、内容和要求、程序清单、运行情况(输入、输出)、总结。 系统中有进程P0、P1、P2、P3、P4,三种资源数量分别为 A=10、 B=5、C=7,...
  • 实验成绩评定方式包含实验报告成绩、实验过程成绩两个部分,其中实验过程成绩占60%、实验报告成绩占40%,如果其中任何一个部分成绩不及格,则总成绩按不及格处理。 5.10 实验报告 按照实验目的、实验内容、实验要求...
  • 「 黑龙江大学 」操作系统实验报告

    千次阅读 2019-05-23 14:50:38
    封皮(略) 一、进程控制 1.1目的 模拟操作系统内核对进程的控制和管理:包括进程的创建。 1.2内容 ...能够模拟进程的创建与撤销过程;...按先进先出方式管理就绪和...1.4算法设计及流程图 System.out.print("杈撳...
  • 操作系统实验四 银行家算法

    万次阅读 多人点赞 2015-11-30 17:00:30
    操作系统实验四 银行家算法一、实验目的 1、 理解银行家算法。 2、 掌握进程安全性检查的方法与资源分配的方法。 二、实验内容与基本要求编制模拟银行家算法的程序,并以下面给出的例子验证所编写的程序的正确性...
  • 实验二、银行家算法

    2017-11-06 00:04:00
    (一) 目的和要求 银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。本实验要求用高级语言编写一个银行家的模拟算法。通过本实验可以对预防死锁和银行家算法有更深刻的认识。...2、 设计安全算法 设...
  • 银行家算法课程设计

    千次阅读 2018-01-13 23:27:14
    目 录         1 课程设计目的 ………………...4 课程设计之银行家算法原理 …………………………………… 4 5 源程序结构分析及代码实现 …………………………………… 6 6 课程设计总结 …………………

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,229
精华内容 6,091
关键字:

安全算法的设计实验报告