贪心算法解活动安排实验报告

合集下载

算法分析与设计实验报告 实验5:贪心算法的应用

算法分析与设计实验报告 实验5:贪心算法的应用
scanf("%d %d",&d[i].l,&d[i].r); if(d[i].l>d[i].r) swap(d[i].l,d[i].r); }
sort(d,d+n,cmp);//按纵坐标升序排列 last=d[0].r;//记录当前线段被覆盖的最大坐标值
for(int i=1;i<n;i++) { if(d[i].l<=last && d[i].r>=last)//线段 d[i]的右坐标在 last 之后, 左坐标在 Last 之前的情况,即产生了覆盖。此时还要更新 last 坐标
} cout<<n.substr(0,l-s+x)<<endl;//只打印剩下的左边 l-(s-x)个数字 } return 0; } 2. #include<iostream> #include<cstdio> #include <algorithm> using namespace std; struct point {
课程实验报告
课程名称 算法分析与设计 班级 计算 161 实验日期
姓名
何严鸿
学号 20160701 实验成绩 9
实验名称
实验 5:贪心算法的应用

1.理解贪心算法的概念;


2.掌握贪心算法的基本思想。





操作系统:Windows


IDE:Visual C++

(1)删数问题
2018/5/06
{
length=d[i].r-d[i-1].l; last=d[i].r; } else if (d[i].r<=last) //线段 d[i]的右坐标在 last 之内,不产生覆盖 continue; else if (d[i].l>=last) //线段 d[i]的左坐标在 Last 之后,此时 last 之后的部分不会对之前的部分产生影响,更新 last 坐标。length 的值加上之 前的部分 { last=d[i-1].r; length=length+d[i].r-d[i].l; } } cout<<last<<endl; return 0; }

贪心算法 实验报告

贪心算法 实验报告

贪心算法实验报告贪心算法实验报告引言:贪心算法是一种常用的算法设计策略,它通常用于求解最优化问题。

贪心算法的核心思想是在每一步选择中都选择当前最优的解,从而希望最终能够得到全局最优解。

本实验旨在通过实际案例的研究,探索贪心算法的应用和效果。

一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解,而不考虑整体的最优解。

这种贪婪的选择策略通常是基于局部最优性的假设,即当前的选择对于后续步骤的选择没有影响。

贪心算法的优点是简单高效,但也存在一定的局限性。

二、实验案例:零钱兑换问题在本实验中,我们以零钱兑换问题为例,来说明贪心算法的应用。

问题描述:假设有不同面值的硬币,如1元、5元、10元、50元和100元,现在需要支付给客户x元,如何用最少的硬币数完成支付?解决思路:贪心算法可以通过每次选择当前面值最大的硬币来求解。

具体步骤如下:1. 初始化一个空的硬币集合,用于存放选出的硬币。

2. 从面值最大的硬币开始,如果当前硬币的面值小于等于待支付金额,则将该硬币放入集合中,并将待支付金额减去该硬币的面值。

3. 重复步骤2,直到待支付金额为0。

实验过程:以支付金额为36元为例,我们可以通过贪心算法求解最少硬币数。

首先,面值最大的硬币为100元,但36元不足以支付100元硬币,因此我们选择50元硬币。

此时,剩余待支付金额为36-50=-14元。

接下来,面值最大的硬币为50元,但待支付金额为负数,因此我们选择下一个面值最大的硬币,即10元硬币。

此时,剩余待支付金额为-14-10=-24元。

继续选择10元硬币,剩余待支付金额为-24-10=-34元。

再次选择10元硬币,剩余待支付金额为-34-10=-44元。

最后,选择5元硬币,剩余待支付金额为-44-5=-49元。

由于待支付金额已经为负数,我们无法继续选择硬币。

此时,集合中的硬币数为1个50元和3个10元,总共4个硬币。

实验结果:通过贪心算法,我们得到了36元支付所需的最少硬币数为4个。

贪心算法实验报告心得

贪心算法实验报告心得

贪心算法实验报告心得前言贪心算法是一种常见且重要的算法设计思想,通过每一步都选择当下最优的解决方案,以期望最终得到全局最优解。

在学习与实践贪心算法的过程中,我有了许多心得与体会。

什么是贪心算法?贪心算法是一种求解问题的算法思想,它的特点是每一步都选择当前最优的解决方案,而不考虑该选择对以后步骤的影响。

贪心算法通常适用于可以将问题分解为若干个子问题,并且通过每次选择当前最优解来得到整体最优解的情况。

贪心算法的基本步骤贪心算法的基本步骤可以总结为以下几个方面:1.确定问题的解空间,并找到问题的最优解。

贪心算法通常通过穷举法或者利用问题的特殊性质来确定解空间。

2.制定贪心策略。

贪心算法的核心是确定每一步选择的贪心策略,即选择当前最优解。

3.确定贪心策略的正确性。

贪心算法的一个关键问题是如何证明贪心策略的正确性。

可以通过数学证明、反证法或者举反例等方式来进行证明。

4.实现贪心算法。

将贪心策略转化为实际可执行的算法步骤,编写代码来求解问题。

贪心算法实验结果分析在本次实验中,我使用贪心算法解决了一个经典问题:找零钱问题(Change-Making Problem)。

给定一定面额的硬币和需找的金额,我们的目标是使用最少的硬币来完成找零钱。

贪心算法的思路是每次选择面额最大的硬币进行找零。

实验设计1.实验输入:我设计了多组输入来测试贪心算法的性能。

每组输入包括一个需找的金额和一个硬币集合。

2.实验输出:对于每组输入,贪心算法输出一个最优的硬币找零方案,以及使用的硬币数量。

3.实验评价:我使用了实际需找金额与贪心算法计算得到的找零金额的差值来评估算法的准确性,并统计了算法的时间复杂度。

实验结果从多组实验结果中可以观察到,贪心算法在大部分情况下给出了正确的找零金额,并且算法的时间复杂度较低。

结果分析贪心算法在找零钱问题中的应用是合理的。

每次选择面额最大的硬币进行找零,可以快速接近最优解,并且相对其他算法具有较低的时间复杂度。

算法课设实验报告(3篇)

算法课设实验报告(3篇)

第1篇一、实验背景与目的随着计算机技术的飞速发展,算法在计算机科学中扮演着至关重要的角色。

为了加深对算法设计与分析的理解,提高实际应用能力,本实验课程设计旨在通过实际操作,让学生掌握算法设计与分析的基本方法,学会运用所学知识解决实际问题。

二、实验内容与步骤本次实验共分为三个部分,分别为排序算法、贪心算法和动态规划算法的设计与实现。

1. 排序算法(1)实验目的:熟悉常见的排序算法,理解其原理,比较其优缺点,并实现至少三种排序算法。

(2)实验内容:- 实现冒泡排序、快速排序和归并排序三种算法。

- 对每种算法进行时间复杂度和空间复杂度的分析。

- 编写测试程序,对算法进行性能测试,比较不同算法的优劣。

(3)实验步骤:- 分析冒泡排序、快速排序和归并排序的原理。

- 编写三种排序算法的代码。

- 分析代码的时间复杂度和空间复杂度。

- 编写测试程序,生成随机测试数据,测试三种算法的性能。

- 比较三种算法的运行时间和内存占用。

2. 贪心算法(1)实验目的:理解贪心算法的基本思想,掌握贪心算法的解题步骤,并实现一个贪心算法问题。

(2)实验内容:- 实现一个贪心算法问题,如活动选择问题。

- 分析贪心算法的正确性,并证明其最优性。

(3)实验步骤:- 分析活动选择问题的贪心策略。

- 编写贪心算法的代码。

- 分析贪心算法的正确性,并证明其最优性。

- 编写测试程序,验证贪心算法的正确性。

3. 动态规划算法(1)实验目的:理解动态规划算法的基本思想,掌握动态规划算法的解题步骤,并实现一个动态规划算法问题。

(2)实验内容:- 实现一个动态规划算法问题,如背包问题。

- 分析动态规划算法的正确性,并证明其最优性。

(3)实验步骤:- 分析背包问题的动态规划策略。

- 编写动态规划算法的代码。

- 分析动态规划算法的正确性,并证明其最优性。

- 编写测试程序,验证动态规划算法的正确性。

三、实验结果与分析1. 排序算法实验结果:- 冒泡排序:时间复杂度O(n^2),空间复杂度O(1)。

贪心算法背包问题

贪心算法背包问题
算法设计与分析实验报告
题目:贪心算法
背包问题
专业:JAVA 技术 09——02 班 学号:540913100201 姓名:柏顺顺 指导老师:宋胜利
实验三:贪心算法
一、实验目的与要求
1、掌握背包问题的算法 2、初步掌握贪心算法
背包问题
二、实验题:
问题描述:与 0-1 背包问题相似,给定 n 种物品和一个背包。物品 i 的重量是 wi,其价 值为 vi,背包的容量为 c。与 0-1 背包问题不同的是,在选择物品 i 装入背包时,背包问题 的解决可以选择物品 i 的一部分,而不一定要全部装入背包,1< i < n。
JOptionPane.showMessageDialog(null, "重量不能为空!"); return; } else{ if (s1.equals("")){ JOptionPane.showMessageDialog(null, "效益值不能为空!"); return; }else { if (s3.equals("")) JOptionPane.showMessageDialog(null, "总重量不能为空!"); return; } } } catch (Exception e3) { // TODO: handle exception }
}
//可以执行贪心算法了 int [] wCopy = new int [w.length]; int [] pCopy = new int [w.length]; float temp2; int temp1; float totalx=0; float [] x = new float [w.length];//效益和重量的比值 float [] n =new float[w.length];//记录个数 float [] nCopy = new float[w.length]; for(int i=0;i<w.length;i++) { wCopy [i] = w[i]; pCopy [i] = p[i]; } for (int i=0;i<w.length;i++) x[i] = (float) ((p[i]*1.0)/w[i]); for(int i= 0;i<w.length;i++) for(int j=i+1;j<w.length;j++)

单源最短路径(贪心法)实验报告

单源最短路径(贪心法)实验报告

算法分析与设计实验报告第 5 次实验使用贪心法求出给定图各点的最短路径,并计算算法的执行时间,分析算法的有效性。

已知一个有向网络 G=(V,E)和源点 V1,如上所示,求出从源点出发到图中其余顶点的最短路径。

1 用邻接矩阵表示有向图,并进行初始化,同时选择源点;}手动输入实现实验所给图形:随机数产生图的权值:通过这次实验,我回顾了回溯法求解最短路径问题,在其中加入了舍伍德附录:完整代码#include<stdio.h>#include<stdlib.h>#include<time.h>#define maxint 1000int c[200][200]={0};void Dijkstra(int n,int v,int dist[],int prev[]){ bool s[maxint];for(int i=1;i<=n;i++){dist[i]=c[v][i];s[i]=false;if(dist[i]==maxint) prev[i]=0;else prev[i]=v;} //找到第一个可行源点 s[]标志,记录prev[]前一个点dist[v]=0;s[v]=true;for(int i=1;i<n;i++){int temp=maxint;int u=v;for(int j=1;j<=n;j++){if((!s[j])&&(dist[j]<temp)){u=j;temp=dist[j];}}s[u]=true;for(int j=1;j<=n;j++){int newdist=dist[u]+c[u][j];if(newdist<dist[j]){dist[j]=newdist;prev[j]=u;}}}}int main(){int n,v;printf("请输入顶点数: ");scanf("%d",&n);//printf("路径: ");srand(time(0));for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++){/* scanf("%d",&c[i][j]);*/ ///手动输入if(i!=j){if((c[j][i]==0)||(c[j][i]==1000))c[i][j]=rand()%100+1;else c[i][j]=1000;if(c[i][j]>50) c[i][j]=1000;}}}printf("请输入源点: ");scanf("%d",&v);int dist[n+1],prev[n+1];printf("\n路径:\n");for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++)printf("%5d ",c[i][j]);printf("\n");}Dijkstra(n,v,dist,prev);for(int i=1;i<n+1;i++){printf("\n%d到%d的最短路径为:%d",v,i,dist[i]);}}。

《算法设计与分析》课程实验报告 (贪心算法(一))

《算法设计与分析》课程实验报告 (贪心算法(一))

《算法设计与分析》课程实验报告实验序号:07实验项目名称:实验8 贪心算法(一)一、实验题目1.删数问题问题描述:键盘输入一个高精度的正整数N(不超过250 位),去掉其中任意k个数字后剩下的数字按原左右次序将组成一个新的非负整数。

编程对给定的N 和k,寻找一种方案使得剩下的数字组成的新数最小。

若输出前有0则舍去2.区间覆盖问题问题描述:设x1,x2,...xn是实轴上的n个点。

用固定长度为k的闭区间覆盖n个点,至少需要多少个这样的固定长度的闭区间?请你设计一个有效的算法解决此问题。

3.会场安排问题问题描述:假设要在足够多的会场里安排一批活动,并希望使用尽可能少的会场。

设计一个有效的贪心算法进行安排。

(这个问题实际上是著名的图着色问题。

若将每一个活动作为图的一个顶点,不相容活动间用边相连。

使相邻顶点着有不同颜色的最小着色数,相应于要找的最小会场数。

)4.导弹拦截问题问题描述:某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统。

但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能高于前一发的高度。

某天,雷达捕捉到敌国的导弹来袭。

由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹。

给定导弹依次飞来的高度(雷达给出的高度数据是≤50000的正整数),计算这套系统最多能拦截多少导弹,如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

二、实验目的(1)通过实现算法,进一步体会具体问题中的贪心选择性质,从而加强对贪心算法找最优解步骤的理解。

(2)掌握通过迭代求最优的程序实现技巧。

(3)体会将具体问题的原始数据预处理后(特别是以某种次序排序后),常能用贪心求最优解的解决问题方法。

三、实验要求(1)写出题1的最优子结构性质、贪心选择性质及相应的子问题。

(2)给出题1的贪心选择性质的证明。

(3)(选做题):写出你的算法的贪心选择性质及相应的子问题,并描述算法思想。

算法实验报告贪心

算法实验报告贪心

一、实验背景贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择,从而希望导致结果是全局最好或最优的算法策略。

贪心算法并不保证能获得最优解,但往往能获得较好的近似解。

在许多实际应用中,贪心算法因其简单、高效的特点而被广泛应用。

本实验旨在通过编写贪心算法程序,解决经典的最小生成树问题,并分析贪心算法的优缺点。

二、实验目的1. 理解贪心算法的基本原理和应用场景;2. 掌握贪心算法的编程实现方法;3. 分析贪心算法的优缺点,并尝试改进;4. 比较贪心算法与其他算法在解决最小生成树问题上的性能。

三、实验内容1. 最小生成树问题最小生成树问题是指:给定一个加权无向图,找到一棵树,使得这棵树包含所有顶点,且树的总权值最小。

2. 贪心算法求解最小生成树贪心算法求解最小生成树的方法是:从任意一个顶点开始,每次选择与当前已选顶点距离最近的顶点,将其加入生成树中,直到所有顶点都被包含在生成树中。

3. 算法实现(1)数据结构- 图的表示:邻接矩阵- 顶点集合:V- 边集合:E- 已选顶点集合:selected- 最小生成树集合:mst(2)贪心算法实现```def greedy_mst(graph):V = set(graph.keys()) # 顶点集合selected = set() # 已选顶点集合mst = set() # 最小生成树集合for i in V:selected.add(i)mst.add((i, graph[i]))while len(selected) < len(V):min_edge = Nonefor edge in mst:u, v = edgeif v not in selected and (min_edge is None or graph[u][v] < graph[min_edge[0]][min_edge[1]]):min_edge = edgeselected.add(min_edge[1])mst.add(min_edge)return mst```4. 性能分析为了比较贪心算法与其他算法在解决最小生成树问题上的性能,我们可以采用以下两种算法:(1)Prim算法:从任意一个顶点开始,逐步添加边,直到所有顶点都被包含在生成树中。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验3 贪心算法解活动安排问题
一、实验要求
1.要求按贪心法求解问题;
2.要求读文本文件输入活动安排时间区间数据;
3.要求显示结果。

二、实验仪器和软件平台
仪器:带usb接口微机
软件平台:WIN-XP + VC++6.0
三、源程序
#include "stdafx.h"
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
#define N 50
#define TURE 1
#define FALSE 0
int s[N];/*开始时间*/
int f[N];/*结束时间*/
int A[N];/*用A存储所有的*/
int Partition(int *b,int *a,int p,int r);
void QuickSort(int *b,int *a,int p,int r);
void GreedySelector(int n,int *s,int *f,int *A);
int main()
{
int n=0,i;
while(n<=0||n>50)
{
printf("\n");
printf("请输入活动的个数,n=");
scanf("%d",&n);
if(n<=0) printf("请输入大于零的数!");
else if(n>50) printf("请输入小于50的数!");
}
printf("\n请分别输入开始时间s[i]和结束时间f[i]:\n\n");
for(i=1;i<=n;i++)
{
printf("s[%d]=",i,i);
scanf("%d",&s[i]);
printf("f[%d]=",i,i);
scanf("%d",&f[i]);
printf("\n");
}
QuickSort(s,f,1,n); //按结束时间非减序排列
printf("按结束时间非减序排列如下:\n"); /*输出排序结果*/ printf("\n 序号\t开始时间结束时间\n");
printf("-------------------------\n");
for(i=1;i<=n;i++)
printf(" %d\t %d\t %d\n",i,s[i],f[i]);
printf("-------------------------\n");
GreedySelector(n,s,f,A);//贪心算法实现活动安排
printf("安排的活动序号依次为:");
for(i=1;i<=n;i++)
{
if(A[i])
printf("\n%d %d-->%d",i,s[i],f[i]);
}
printf("\n");
system("pause");
return 0;
}
//快速排序
void QuickSort(int *b,int *a,int p,int r)
{
int q;
if(p<r)
{
q=Partition(b,a,p,r);
QuickSort(b,a,p,q-1);/*对左半段排序*/
QuickSort(b,a,q+1,r);/*对右半段排序*/
}
}
//产生中间数
int Partition(int *b,int *a,int p,int r)
{
int k,m,y,i=p,j=r+1;
int x=a[p];y=b[p];
while(1)
{
while(a[++i]<x);
while(a[--j]>x);
if(i>=j)
break;
else
{
k=a[i];a[i]=a[j];a[j]=k;
m=b[i];b[i]=b[j];b[j]=m;
}
}
a[p]=a[j];
b[p]=b[j];
a[j]=x;
b[j]=y;
return j;
}
//贪心算法实现活动安排
void GreedySelector(int n,int *s,int *f,int *A)
{
//用集合A来存储所选择的活动
A[1]=TURE; //默认从第一次活动开始执行
int j=1; //j记录最近一次加入到A中的活动
for(int i=2;i<=n;i++)
{
//f[j]为当前集合A中所有活动的最大结束时间
//活动i的开始时间不早于最近加入到集合A中的j的时间f[j]
if(s[i]>=f[j])
{
A[i]=TURE; //当A[i]=TURE时,活动i在集合A中
j=i;
}
else A[i]=FALSE;
}
}
四、运行结果
五、实验小结
贪心算法总是做出在当前看来最好的选择,也就是说贪心算法并不从整体最优考虑,它所作出的选择只是在某种意义上的局部最优选择。

活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

该问题要求高效地安排一系列争用某一公共资源的活动。

贪心算法提供了一个简单、漂亮的方法使得尽可能多的活动能兼容地使用公共资源。

相关文档
最新文档