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

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.实验评价:我使用了实际需找金额与贪心算法计算得到的找零金额的差值来评估算法的准确性,并统计了算法的时间复杂度。
实验结果从多组实验结果中可以观察到,贪心算法在大部分情况下给出了正确的找零金额,并且算法的时间复杂度较低。
结果分析贪心算法在找零钱问题中的应用是合理的。
每次选择面额最大的硬币进行找零,可以快速接近最优解,并且相对其他算法具有较低的时间复杂度。
贪心算法程序设计

贪心算法程序设计贪心算法程序设计1. 什么是贪心算法贪心算法(Greedy Algorithm)是一种常见的算法思想,它在每一步选择中都采取当前状态下的最优选择,从而希望最终达到全局最优解。
贪心算法的核心思想是局部最优解能导致全局最优解。
2. 贪心算法的基本步骤贪心算法的基本步骤如下:1. 定义问题的优化目标。
2. 将问题分解成子问题。
3. 选择当前最优的子问题解,将子问题的解合并成原问题的解。
4. 检查是否达到了问题的优化目标,如果没有达到,则回到第二步,继续寻找下一个最优子问题解。
5. 在所有子问题解合并成原问题解后,得到问题的最优解。
3. 贪心算法的应用场景贪心算法的应用非常广泛,几乎可以用于解决各种优化问题。
以下几个常见的应用场景:1. 零钱找零问题:给定一定面额的纸币和硬币,如何找零使得所需纸币和硬币的数量最小?2. 区间调度问题:给定一些活动的开始时间和结束时间,如何安排活动使得可以办理的活动数量最大?3. 背包问题:给定一些具有重量和价值的物品,如何选择物品使得背包的总价值最大?4. 最小树问题:给定一个带权无向图,如何找到一棵树,使得它的边权之和最小?5. 哈夫曼编码问题:给定一组字符和相应的频率,如何构造一个满足最低编码长度限制的二进制编码?4. 贪心算法的优缺点贪心算法的优点是简单、高效,可以快速得到一个近似最优解。
而且对于一些问题,贪心算法能够得到全局最优解。
贪心算法的缺点在于它不一定能够得到全局最优解,因为在每一步只考虑局部最优解,无法回溯到之前的选择。
5. 贪心算法的程序设计在使用贪心算法进行程序设计时,通常需要以下几个步骤:1. 定义问题的优化目标。
2. 将问题分解成子问题,并设计子问题的解决方案。
3. 设计贪心选择策略,选择局部最优解。
4. 设计贪心算法的递推或迭代公式。
5. 判断贪心算法是否能够得到全局最优解。
6. 编写程序实现贪心算法。
6.贪心算法是一种常见的算法思想,它在每一步选择中都采取当前状态下的最优选择,从而希望最终达到全局最优解。
贪心算法基本步骤

贪心算法基本步骤贪心算法是一种非常常用的算法思想,广泛应用于算法设计中。
本文将介绍贪心算法的基本步骤、实现方式、应用场景以及优缺点。
一、基本步骤贪心算法的基本步骤可概括为:定义最优解的性质->利用贪心策略获得局部最优解->将局部最优解合并成一个整体最优解。
具体来说,一般包括以下几个步骤:1. 确定问题的最优解性质:要知道问题的最优解应该具有怎样的性质或特征,这些性质可以用于判断一个解是否符合规则或结果是否符合要求。
2. 构造候选解集:根据最优解的性质,不断构造可行的候选解集合,并通过一定的方法筛选出其中的解。
3. 选择最优解:从候选解集中选择一个最优解。
4. 验证最优解:通过验证最优解是否合法(满足约束条件)以及是否为问题的最优解,来验证贪心策略的正确性。
二、实现方式贪心算法的实现方式是比较灵活的,有些问题可以通过贪心策略来解决,有些则不行。
一般而言,如果问题的最优解具有贪心选择性质(即每一步的局部最优解能导致全局最优解),则采用贪心策略是可行的。
对于一些场景,我们可以通过规律来得到贪心策略。
例如:1. 集合覆盖问题:从未被覆盖的地方中选择一个覆盖点集最大的点,并删除所有覆盖的集合;2. 分数背包问题:选择性价比最高的物品,先吸纳尽量多的物品,再考虑其他物品。
三、应用场景1. 背包问题:针对背包问题和其变种,常见的贪心策略有分数背包(与完全和01背包有区别)和完全背包问题;2. 活动安排问题:在一些课程、项目或活动间选择,使得能够安排最多活动;3. 区间选择问题:在一些区间间选择相互不重叠的区间,使得能够选出最大的区间数;4. 集合覆盖问题:在一些集合中选择最少的集合,使得能够覆盖所有元素。
四、优缺点优点:1. 算法简单:贪心算法通常比较简单,易于理解和实现;2. 运算速度快:其时间复杂度一般较低,运算速度很快;3. 可以作为其他算法的优化:贪心策略可以应用于其他算法的优化中。
缺点:1. 不一定能够得到最优解:贪心策略仅考虑当前的局部最优解,对于全局最优解可能产生影响;2. 单一性:贪心算法的结果是唯一的,难以应对变化条件的需要,一旦局部最优解不满足当前的情况,算法就会失去原先的效果;3. 实现困难:对于有些问题,贪心算法并不是很好实现,涉及到更多的问题分析和模型的构造。
多机调度问题贪心算法c语言

多机调度问题贪心算法c语言一、引言多机调度问题是指将一组作业分配给多台机器,使得完成所有作业的时间最短。
在实际生产中,多机调度问题是一个常见的优化问题。
贪心算法是解决多机调度问题的一种有效方法。
本文将介绍贪心算法在C语言中的应用。
二、问题描述假设有n个作业需要分配给m台机器进行加工处理,每个作业需要的时间不同,每台机器的处理速度也不同。
现在需要设计一个算法,将这些作业分配给这些机器进行加工处理,并使得完成所有作业所需时间最短。
三、贪心算法思路贪心算法是一种基于局部最优解来构造全局最优解的思想。
对于多机调度问题,我们可以采用以下贪心策略:1. 将所有作业按照所需时间从大到小排序;2. 将第一个作业分配给第一台机器;3. 对于剩余的作业,选择当前处理时间最短的那台机器进行分配;4. 重复步骤3直到所有作业都被分配完毕。
四、C语言实现下面是C语言实现多机调度问题贪心算法的代码:#include <stdio.h>#include <stdlib.h>#define MAX_JOB 1000#define MAX_MACHINE 1000int cmp(const void *a, const void *b) {return *(int *)b - *(int *)a;}int main() {int n, m, job[MAX_JOB], machine[MAX_MACHINE] = {0}; scanf("%d%d", &n, &m);for (int i = 0; i < n; i++) {scanf("%d", &job[i]);}qsort(job, n, sizeof(int), cmp);for (int i = 0; i < n; i++) {int min_time = machine[0], min_index = 0;for (int j = 1; j < m; j++) {if (machine[j] < min_time) { min_time = machine[j]; min_index = j;}}machine[min_index] += job[i]; }int max_time = machine[0];for (int i = 1; i < m; i++) {if (machine[i] > max_time) { max_time = machine[i];}}printf("%d\n", max_time);return 0;}五、代码解析1. 宏定义和头文件引入:```#define MAX_JOB 1000#define MAX_MACHINE 1000#include <stdio.h>#include <stdlib.h>```定义了最大作业数和最大机器数,并引入了标准输入输出库和标准库。
贪心算法通过每次选择局部最优解来达到全局最优

贪心算法通过每次选择局部最优解来达到全局最优贪心算法是一种常用的解决优化问题的算法。
它通过每次选择局部最优解来达到全局最优的目标。
在本文中,我们将介绍贪心算法的原理、应用场景以及优缺点。
一、原理贪心算法的基本原理非常简单:每一步都选择当前状态下的局部最优解,最终得到的结果就是全局最优解。
贪心算法不考虑过去的选择对未来的影响,只关注眼前的最佳选择。
二、应用场景贪心算法在各个领域都有广泛的应用,下面我们将以几个常见的实际问题来说明。
1. 图的最小生成树问题在一个连通无向图中,找到一个包含所有节点且权值最小的无回路子图,这个问题称为最小生成树问题。
贪心算法可以通过每次选择权值最小的边来逐步构建最小生成树。
2. 分糖果问题有一组孩子和一组糖果,每个孩子有一个需求因子和每个糖果有一个大小。
当糖果的大小不小于孩子的需求因子时,孩子可以获得该糖果。
目标是尽可能多地满足孩子的需求,贪心算法可以通过给每个孩子分配满足其需求因子的最小糖果来达到最优解。
3. 区间调度问题给定一个任务列表,每个任务有一个开始时间和结束时间。
目标是安排任务的执行顺序,使得尽可能多的任务能够被完成。
贪心算法可以通过选择结束时间最早的任务来实现最优解。
以上只是一些贪心算法的应用场景,实际上贪心算法可以用于解决各种优化问题。
三、优缺点1. 优点①简单:贪心算法的思路相对简单,容易理解和实现。
②高效:由于只考虑局部最优解,贪心算法的时间复杂度较低,通常能够在较短的时间内得到一个接近最优解的结果。
③可用于近似求解:由于贪心算法不保证得到全局最优解,但可以用于求解近似最优解的问题。
2. 缺点①不保证全局最优解:贪心算法只考虑眼前的最优选择,无法回溯和修正过去的选择,因此不能保证得到全局最优解。
②局部最优解无法转移:在某些情况下,局部最优解并不一定能够转移到全局最优解,导致贪心算法得到的结果偏离最优解。
③对问题的要求较高:由于贪心算法需要找到适合的局部最优解,因此问题必须具备一定的特殊性,而一些问题无法使用贪心算法解决。
4-贪心法

应用实例
活动安排问题—算法设计与分析
template<class Type> void GreedySelector(int n, Type s[], Type f[], bool A[]) { A[1] = true; int j = 1; for (int i=2;i<=n;i++) { if (s[i]>=f[j]) { A[i]=true; j=i; } else A[i]=false; } }
贪心法的正确性问题
针对具体问题不同,贪心策略的选择可能有多种 ,如何选择合适的贪心策略并证明该策略的正确 性是贪心算法设计中的一个关键问题。 一般可以通过对算法步数的归纳或通过对问题规 模的归纳来证明贪心法的正确性。
应用实例
活动安排问题
有n个活动申请使用同一个礼堂,每项活动有一个开始时间和一 个截止时间,如果任何两个活动不能同时举行,问如何选择这 些活动,从而使得被安排的活动数量达到最多? 设S={1, 2, …, n}为活动的集合,si和fi分别为活动i的开始和截止 时间,i=1, 2, …, n。定义 活动i与j相容:si ≥ fj或sj ≥fi, i≠j 求S最大的两两相容的活动子集。 蛮力法 动态规划方法
若硬币的面值改为一角一分、五分和一分,要找给顾客的 是一角五分,情况如何?
贪心算法的基本思想
顾名思义,贪心算法总是作出在当前看来最好的 选择。也就是说贪心算法并不从整体最优考虑, 它所作出的选择只是在某种意义上的局部最优选 择。 贪心算法不能对所有问题都得到整体最优解,但 对许多问题它能产生整体最优解。 在一些情况下,即使贪心算法不能得到整体最优 解,其最终结果却是最优解的很好近似。
4—贪心法 Greedy Approach
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告课程算法设计与分析实验实验名称贪心算法设计与应用第 1 页一、实验目的理解贪心算法的基本原理,掌握贪心算法设计的基本方法及其应用;二、实验内容(一)Huffman编码和译码问题:1.问题描述给定n个字符在文件中的出现频率,利用Huffman树进行Huffman编码和译码。
设计一个程序实现:1.输入含n(n<=10)个字符的字符集S以及S中各个字符在文件中的出现频率,建立相应的Huffman树,求出S中各个字符的Huffman编码。
2.输入一个由S中的字符组成的序列L,求L的Huffman 编码。
3. 输入一个二进制位串B,对B进行Huffman译码,输出对应的字符序列;若不能译码,则输出无解信息。
提示:对应10 个字符的Huffman树的节点个数<211。
2.测试数据Inputn=5字符集合S={a, b, c, d, e},对应的频率分别为a: 20b: 7c: 10d: 4e: 18字符序列L=ebcca二进制位串B=01100111010010OutputS中各个字符的Huffman编码:(设Huffman树中左孩子的权<=右孩子的权)a: 11b: 010c: 00d: 011e: 10L的Huffman 编码:10010000011B对应的字符序列: dcaeeb若输入的B=01111101001,则无解(二) 加油问题(Problem Set 1702):1.问题描述一个旅行家想驾驶汽车从城市A到城市B(设出发时油箱是空的)。
给定两个城市之间的距离dis、汽车油箱的容量c、每升汽油能行驶的距离d、沿途油站数n、油站i离出发点的距离d[i]以及该站每升汽油的价格p[i],i=1,2,…,n。
设d[1]=0<d[2]<…<d[n]。
要花最少的油费从城市A到城市B,在每个加油站应加多少油,最少花费为多少?2.具体要求Input输入的第一行是一个正整数k,表示测试例个数。
接下来几行是k个测试例的数据,每个测试例的数据由三行组成,其中第一行含4个正整数,依次为A和B两个城市之间的距离d1、汽车油箱的容量c(以升为单位)、每升汽油能行驶的距离d2、沿途油站数n (1<=n<=200);第二行含n个实数d1, d2,…,d n ,表示各油站离出发点的距离(d1=0);第三行含n个实数p1, p2,…, pn,表示各油站每升汽油的价格。
同一行的数之间用一个空格隔开。
Output对于每个测试例输出一行,含一个实数,表示从城市A到城市B所要花费的最少油费(输出的结果精确到小数点后一位)。
若问题无解,则输出“No Solution”。
3.测试数据21500 50 10 40 300.0 800.0 1200.04.05.0 4.0 4.51000 40 10 30 500.0 750.04.55.0 4.2Sample Output640.0No Solution4.设计与实现的提示(1)注意考虑无解的情况(2)对终点站可进行特殊处理5.扩展内容(1) 演示时建议采用可视化界面(2) The Express Mail(Problem Set 1755)(三) 黑白点的匹配(Problem Set 1714):(选作题)4.问题描述设平面上分布着n个白点和n个黑点,每个点用一对坐标(x, y)表示。
一个黑点b=(xb,yb)支配一个白点w=(xw, yw)当且仅当xb>=xw和yb>=yw。
若黑点b支配白点w,则黑点b和白点w可匹配(可形成一个匹配对)。
在一个黑点最多只能与一个白点匹配,一个白点最多只能与一个黑点匹配的前提下,求n个白点和n个黑点的最大匹配对数。
5.具体要求输入的第一行是一个正整数k,表示测试例个数。
接下来几行是k个测试例的数据,每个测试例的数据由三行组成,其中第一行含1个正整数n(n<16);第二行含2n个实数xb1, yb1,xb2, yb2,…, xbn, ybn, (xbi, ybi),i=1, 2, …,n表示n个黑点的坐标;第三行含2n个实数xw1, yw1,xw2, yw2,…, xwn, ywn,(xwi , ywi),i=1, 2, …, n表示n个白点的坐标。
同一行的实数之间用一个空格隔开。
Output对于每个测试例输出一行,含一个整数,表示n个白点和n个黑点的最大匹配对数。
6.测试数据输入:135.0 3.0 5.0 -1.0 4.0 4.02.03.5 2.0 2.0 -2.0 -2.0输出:37.扩展内容(1) 建议采用可视化界面三、实验环境硬件:Windows XP计算机、鼠标、键盘、显示器开发环境:Microsoft Visual C++ 6.0四、实验步骤(描述实验步骤及中间的结果或现象。
在实验中做了什么事情,怎么做的,发生的现象和中间结果)①、点击开始菜单中的程序-Microsoft Visual C++ 6.0点击菜单栏中的文件—新建—文件—C++ Source File ,在文件名(N)中写入“实验五.(1).cpp”,再点击确定.②、编写程序如下:#include "stdio.h"#include "stdlib.h"#include "string.h"#define MAX 100struct HafNode{char ch;int weight;int parent,lchild,rchild;}*HaffmanTree;struct Coding{char bit[MAX];char ch;int weight;}*HaffmanCode;/*------------------------//构造哈弗曼树-----------------------------*/void Haffman(int n)//构造哈弗曼树{int i,j,x1,x2,s1,s2;for(i=n+1;i<=2*n-1;i++){s1=s2=10000;x1=x2=0;for(j=1;j<=i-1;j++){if(HaffmanTree[j].parent==0&&HaffmanTree[j].weight<s1) {s2=s1;x2=x1;s1=HaffmanTree[j].weight;x1=j;}else if(HaffmanTree[j].parent==0&&HaffmanTree[j].weight<s2) {s2=HaffmanTree[j].weight;x2=j;}}HaffmanTree[x1].parent=i;HaffmanTree[x2].parent=i;HaffmanTree[i].weight=s1+s2;HaffmanTree[i].lchild=x1;HaffmanTree[i].rchild=x2;}}/*---------------------------//构造哈弗曼编码------------------------*/void Haffman_Code(int n){int start,c,f,i,j,k;char *cd;cd=(char *)malloc(n*sizeof(char));HaffmanCode=(struct Coding *)malloc((n+1)*sizeof(struct Coding)); cd[n-1]='\0';for(i=1;i<=n;++i){start=n-1;for(c=i,f=HaffmanTree[i].parent;f!=0;c=f,f=HaffmanTree[f].parent)if(HaffmanTree[f].lchild==c)cd[--start]='0';elsecd[--start]='1';for(j=start,k=0;j<n;j++){HaffmanCode[i].bit[k]=cd[j];k++;}HaffmanCode[i].ch=HaffmanTree[i].ch;HaffmanCode[i].weight=HaffmanTree[i].weight;}free(cd);}int CreatHuffman(){int i,n,m;printf("请输入字符集大小n:\n");scanf("%d",&n);m=2*n-1;HaffmanTree=(struct HafNode *)malloc(sizeof(struct HafNode)*(m+1));for(i=1;i<=n;i++){printf("请输入第%d个字符和权值: ",i);scanf("%s%d",&HaffmanTree[i].ch,&HaffmanTree[i].weight);HaffmanTree[i].parent=0;HaffmanTree[i].lchild=0;HaffmanTree[i].rchild=0;}for(i=n+1;i<=m;i++){HaffmanTree[i].ch ='#';HaffmanTree[i].lchild=0;HaffmanTree[i].parent=0;HaffmanTree[i].rchild=0;HaffmanTree[i].weight=0;}Haffman(n);Haffman_Code(n);return n;}/*-----------------------输出每个字符的哈弗曼编码------------------------------*/void output(int n){printf("\n\n");int i;for(i=1;i<=n;i++){printf("%c的哈弗曼编码是:%s\n",HaffmanCode[i].ch,HaffmanCode[i].bit);}}/*------------------------------对字符进行编码---------------------------*/void Char_Change(int m)//对字符进行编码{int n,i,j;char string[50],*p;printf("请输入字符串:");scanf("%s",string);n=strlen(string);//n为输入的字符串的长度printf("字符串的编码为: ");for(i=1,p=string;i<=n;i++,p++){for(j=1;j<=m;j++){if(HaffmanCode[j].ch==*p)//输入的字符串逐个与哈弗曼树的字符比对printf("%s",HaffmanCode[j].bit);}}printf("\n");}/*---------------------------对输入的编码进行译码---------------------*/int Code_Change(int n){int i,t;char code[1000];printf("请输入编码: ");scanf("%s",code);printf("编码的字符串为: ");for(i=0;code[i]!='\0';){t=2*n-1;while(code[i]!='\0'){if(code[i]-'0'==1){if(HaffmanTree[t].rchild!=0){t=HaffmanTree[t].rchild;}else{printf("No solution!\n");return 0;}}else{if(HaffmanTree[t].lchild!=0){t=HaffmanTree[t].lchild;}else{printf("No solution!\n");return 0;}}if(HaffmanTree[t].lchild==0&&HaffmanTree[t].rchild==0){printf("%c",HaffmanTree[t].ch);i++;if(code[i]=='\0')return 0;elsebreak;}i++;}}}/*-----------------------主函数-----------------------------*/void main(){int n;printf("---------------开始程序------------------\n\n");n=CreatHuffman();output(n);//输出每个字符的编码printf("--------------对字符进行编码--------------\n\n");Char_Change(n);//执行编码操作printf("--------------对编码进行译码--------------\n\n");Code_Change(n);//执行译码操作printf("\n");}③、点击开始菜单中的程序-Microsoft Visual C++ 6.0点击菜单栏中的文件—新建—文件—C++ Source File ,在文件名(N)中写入“实验五.(2).cpp”,再点击确定.④、编写程序如下:#include<stdio.h>#define MAX 20/*----------------------*/void look(float dis[],float pir[],int n,int d2,int oil)//dis[i]表示第i个站点离起点的距离,pir[i]表示每升油的价格{//n表示站点个数,d2表示每升油可走的距离,oil表示邮箱容量int i,j,k;float pirce=0.0,c1=0,x,c2;for(j=0;j<=n;j++){for(i=j+1;i<=n;i++){if(pir[i]<pir[j])//在剩余的站点中找到油价小于第一个的站点{k=i;c2=(dis[k]-dis[j])/d2;//从开始站到符合条件站点所需要的油量if(c2>=oil){x=oil-c1;//加满油}else{x=c2-c1;//需要的油量减去剩余的油量if(x<0)//若剩余的油量够走到符合条件的站点,则不需要再加油{x=0;}}pirce=pirce+pir[j]*x;break;}}c1=c1+x-((dis[j+1]-dis[j])/d2);//剩余油量}printf("%.1f",pirce);}/*----------------------*/void main(){int k,i,j,n[MAX],c[MAX],d1[MAX],d2[MAX],length[MAX],flag[MAX];float A[MAX][MAX],B[MAX][MAX];printf("输入测试例个数: \n");scanf("%d",&k);for(i=0;i<k;i++){printf("输入第%d个数据:\n",i+1);flag[i]=0;scanf("%d %d %d %d",&d1[i],&c[i],&d2[i],&n[i]);length[i]=c[i]*d2[i];for(j=0;j<n[i];j++){scanf("%f",&A[i][j]);}A[i][n[i]]=d1[i]*1.0;for(j=0;j<n[i];j++){scanf("%f",&B[i][j]);}B[i][n[i]]=0.0;printf("\n");for(j=n[i];j>0;j--){if(A[i][j]-A[i][j-1]>length[i]){flag[i]=1;}}if(flag[i]==1){printf("第%d次结果: ",i+1);printf("NO solution!\n");}else{printf("第%d次结果: ",i+1);printf("最少油费: ");look(A[i],B[i],n[i],d2[i],c[i]);}printf("\n");printf("\n");}}⑤、点击开始菜单中的程序-Microsoft Visual C++ 6.0点击菜单栏中的文件—新建—文件—C++ Source File ,在文件名(N)中写入“实验五.(3)黑白点问题.cpp”,再点击确定.⑥、编写程序如下:#include<stdio.h>#define INT_MAX 1000000struct point{float x;float y;int tag;}w[10],b[10];void bubble_sort(point w[], int n){int j, k, h;point t;for (h=n-1; h>0; h=k) /*循环到没有比较范围*/{for (j=0, k=0; j<h; j++) /*每次预置k=0,循环扫描后更新k*/{if (w[j].x> w[j+1].x) /*大的放在后面,小的放到前面*/{t = w[j];w[j] = w[j+1];w[j+1]= t; /*完成交换*/k = j; /*保存最后下沉的位置。