算法设计实验报告(川大陈瑜)
算法设计与分析实验报告三篇
算法设计与分析实验报告一实验名称统计数字问题评分实验日期2014 年11 月15 日指导教师姓名专业班级学号一.实验要求1、掌握算法的计算复杂性概念。
2、掌握算法渐近复杂性的数学表述。
3、掌握用C++语言描述算法的方法。
4．实现具体的编程与上机实验，验证算法的时间复杂性函数。
二.实验内容统计数字问题1、问题描述一本书的页码从自然数1 开始顺序编码直到自然数n。
书的页码按照通常的习惯编排，每个页码都不含多余的前导数字0。
例如，第6 页用数字6 表示，而不是06 或006 等。
数字计数问题要求对给定书的总页码n，计算出书的全部页码中分别用到多少次数字0，1，2， (9)2、编程任务给定表示书的总页码的10 进制整数n (1≤n≤109) 。
编程计算书的全部页码中分别用到多少次数字0，1，2， (9)三.程序算法将页码数除以10，得到一个整数商和余数，商就代表页码数减余数外有多少个1—9作为个位数，余数代表有1—余数本身这么多个数作为剩余的个位数，此外，商还代表1—商本身这些数出现了10次，余数还代表剩余的没有计算的商的大小的数的个数。
把这些结果统计起来即可。
四.程序代码#include<iostream.h>int s[10]; //记录0~9出现的次数int a[10]; //a[i]记录n位数的规律void sum(int n,int l,int m){ if(m==1){int zero=1;for(int i=0;i<=l;i++) //去除前缀0{ s[0]-=zero;zero*=10;} }if(n<10){for(int i=0;i<=n;i++){ s[i]+=1; }return;}//位数为1位时,出现次数加1//位数大于1时的出现次数for(int t=1;t<=l;t++)//计算规律f(n)=n*10^(n-1){m=1;int i;for(i=1;i<t;i++)m=m*10;a[t]=t*m;}int zero=1;for(int i=0;i<l;i++){ zero*= 10;} //求出输入数为10的n次方int yushu=n%zero; //求出最高位以后的数int zuigao=n/zero; //求出最高位zuigaofor(i=0;i<zuigao;i++){ s[i]+=zero;} //求出0~zuigao-1位的数的出现次数for(i=0;i<10;i++){ s[i]+=zuigao*a[l];} //求出与余数位数相同的0~zuigao-1位中0~9出现的次数//如果余数是0,则程序可结束,不为0则补上所缺的0数,和最高位对应所缺的数if(yushu==0) //补上所缺的0数,并且最高位加1{ s[zuigao]++;s[0]+=l; }else{ i=0;while((zero/=10)>yushu){ i++; }s[0]+=i*(yushu+1);//补回因作模操作丢失的0s[zuigao]+=(yushu+1);//补回最高位丢失的数目sum(yushu,l-i-1,m+1);//处理余位数}}void main(){ int i,m,n,N,l;cout<<"输入数字要查询的数字:";cin>>N;cout<<'\n';n = N;for(i=0;n>=10;i++){ n/=10; } //求出N的位数n-1l=i;sum(N,l,1);for(i=0; i<10;i++){ cout<< "数字"<<i<<"出现了:"<<s[i]<<"次"<<'\n'; }}五.程序调试中的问题调试过程，页码出现报错。
算法设计题_实验报告
一、实验目的1. 理解和掌握最优路径搜索算法的基本原理和实现方法。
2. 能够根据实际问题选择合适的算法，并对其进行优化和改进。
3. 提高算法分析和设计能力，以及编程实现能力。
二、实验内容本次实验要求设计并实现一种最优路径搜索算法，以解决迷宫问题。
迷宫由二维数组表示，其中1表示障碍，0表示通路。
要求算法能够从入口位置出发，找到到达出口的最短路径。
三、实验原理1. Dijkstra算法：Dijkstra算法是一种基于贪心策略的最短路径算法，适用于图中所有边的权重都为非负值的情况。
算法的基本思想是从起点出发，逐步扩展到相邻节点，计算到达每个节点的最短路径长度，并记录下到达该节点的最短路径。
2. A搜索算法：A搜索算法是一种启发式搜索算法，结合了Dijkstra算法和最佳优先搜索算法的优点。
算法的基本思想是在Dijkstra算法的基础上，引入启发函数来估计从当前节点到目标节点的距离，从而优先搜索那些更有可能到达目标节点的路径。
四、实验过程1. 算法设计（1）Dijkstra算法实现：1）初始化：设置一个距离数组dist[]，用于存储从起点到各个节点的最短路径长度，初始时将起点到自身的距离设为0，其余节点设为无穷大。
2）更新距离：从距离数组中选取距离最小的节点，将其标记为已访问，并将该节点到其相邻节点的距离进行更新。
3）重复步骤2），直到找到目标节点或所有节点都已访问。
（2）A搜索算法实现：1）初始化：设置一个开放列表openList和封闭列表closedList，分别用于存储待搜索节点和已搜索节点。
将起点加入openList，并设置其f值（g值+启发函数值）。
2）搜索过程：从openList中选取f值最小的节点，将其标记为当前节点，并将其加入closedList。
3）更新相邻节点：对于当前节点的相邻节点，计算其g值、h值和f值，如果相邻节点不在closedList中，且其f值小于openList中对应节点的f值，则将其加入openList。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
算法分析与设计实验报告
算法分析与设计实验报告算法分析与设计实验报告一、引言算法是计算机科学的核心，它们是解决问题的有效工具。
算法分析与设计是计算机科学中的重要课题，通过对算法的分析与设计，我们可以优化计算机程序的效率，提高计算机系统的性能。
本实验报告旨在介绍算法分析与设计的基本概念和方法，并通过实验验证这些方法的有效性。
二、算法分析算法分析是评估算法性能的过程。
在实际应用中，我们常常需要比较不同算法的效率和资源消耗，以选择最适合的算法。
常用的算法分析方法包括时间复杂度和空间复杂度。
1. 时间复杂度时间复杂度衡量了算法执行所需的时间。
通常用大O表示法表示时间复杂度，表示算法的最坏情况下的运行时间。
常见的时间复杂度有O(1)、O(log n)、O(n)、O(n log n)和O(n^2)等。
其中，O(1)表示常数时间复杂度，O(log n)表示对数时间复杂度，O(n)表示线性时间复杂度，O(n log n)表示线性对数时间复杂度，O(n^2)表示平方时间复杂度。
2. 空间复杂度空间复杂度衡量了算法执行所需的存储空间。
通常用大O表示法表示空间复杂度，表示算法所需的额外存储空间。
常见的空间复杂度有O(1)、O(n)和O(n^2)等。
其中，O(1)表示常数空间复杂度，O(n)表示线性空间复杂度，O(n^2)表示平方空间复杂度。
三、算法设计算法设计是构思和实现算法的过程。
好的算法设计能够提高算法的效率和可靠性。
常用的算法设计方法包括贪心算法、动态规划、分治法和回溯法等。
1. 贪心算法贪心算法是一种简单而高效的算法设计方法。
它通过每一步选择局部最优解，最终得到全局最优解。
贪心算法的时间复杂度通常较低，但不能保证得到最优解。
2. 动态规划动态规划是一种将问题分解为子问题并以自底向上的方式求解的算法设计方法。
它通过保存子问题的解，避免重复计算，提高算法的效率。
动态规划适用于具有重叠子问题和最优子结构的问题。
3. 分治法分治法是一种将问题分解为更小规模的子问题并以递归的方式求解的算法设计方法。
常见算法设计实验报告(3篇)
第1篇一、实验目的通过本次实验，掌握常见算法的设计原理、实现方法以及性能分析。
通过实际编程，加深对算法的理解，提高编程能力，并学会运用算法解决实际问题。
二、实验内容本次实验选择了以下常见算法进行设计和实现：1. 排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。
2. 查找算法：顺序查找、二分查找。
3. 图算法：深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim算法、Kruskal算法）。
4. 动态规划算法：0-1背包问题。
三、实验原理1. 排序算法：排序算法的主要目的是将一组数据按照一定的顺序排列。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。
2. 查找算法：查找算法用于在数据集中查找特定的元素。
常见的查找算法包括顺序查找和二分查找。
3. 图算法：图算法用于处理图结构的数据。
常见的图算法包括深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim算法、Kruskal算法）等。
4. 动态规划算法：动态规划算法是一种将复杂问题分解为子问题，通过求解子问题来求解原问题的算法。
常见的动态规划算法包括0-1背包问题。
四、实验过程1. 排序算法（1）冒泡排序：通过比较相邻元素，如果顺序错误则交换，重复此过程，直到没有需要交换的元素。
（2）选择排序：每次从剩余元素中选取最小（或最大）的元素，放到已排序序列的末尾。
（3）插入排序：将未排序的数据插入到已排序序列中适当的位置。
（4）快速排序：选择一个枢纽元素，将序列分为两部分，使左侧不大于枢纽，右侧不小于枢纽，然后递归地对两部分进行快速排序。
（5）归并排序：将序列分为两半，分别对两半进行归并排序，然后将排序好的两半合并。
（6）堆排序：将序列构建成最大堆，然后重复取出堆顶元素，并调整剩余元素，使剩余元素仍满足最大堆的性质。
2. 查找算法（1）顺序查找：从序列的第一个元素开始，依次比较，直到找到目标元素或遍历完整个序列。
关于算法的实验报告(3篇)
第1篇一、实验目的1. 理解快速排序算法的基本原理和实现方法。
2. 掌握快速排序算法的时间复杂度和空间复杂度分析。
3. 通过实验验证快速排序算法的效率。
4. 提高编程能力和算法设计能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理快速排序算法是一种分而治之的排序算法，其基本思想是：选取一个基准元素，将待排序序列分为两个子序列，其中一个子序列的所有元素均小于基准元素，另一个子序列的所有元素均大于基准元素，然后递归地对这两个子序列进行快速排序。
快速排序算法的时间复杂度主要取决于基准元素的选取和划分过程。
在平均情况下，快速排序的时间复杂度为O(nlogn)，但在最坏情况下，时间复杂度会退化到O(n^2)。
四、实验内容1. 快速排序算法的代码实现2. 快速排序算法的时间复杂度分析3. 快速排序算法的效率验证五、实验步骤1. 设计快速排序算法的C++代码实现，包括以下功能：- 选取基准元素- 划分序列- 递归排序2. 编写主函数，用于生成随机数组和测试快速排序算法。
3. 分析快速排序算法的时间复杂度。
4. 对不同规模的数据集进行测试，验证快速排序算法的效率。
六、实验结果与分析1. 快速排序算法的代码实现```cppinclude <iostream>include <vector>include <cstdlib>include <ctime>using namespace std;// 生成随机数组void generateRandomArray(vector<int>& arr, int n) {srand((unsigned)time(0));for (int i = 0; i < n; ++i) {arr.push_back(rand() % 1000);}}// 快速排序void quickSort(vector<int>& arr, int left, int right) { if (left >= right) {return;}int i = left;int j = right;int pivot = arr[(left + right) / 2]; // 选取中间元素作为基准 while (i <= j) {while (arr[i] < pivot) {i++;}while (arr[j] > pivot) {j--;}if (i <= j) {swap(arr[i], arr[j]);i++;j--;}}quickSort(arr, left, j);quickSort(arr, i, right);}int main() {int n = 10000; // 测试数据规模vector<int> arr;generateRandomArray(arr, n);clock_t start = clock();quickSort(arr, 0, n - 1);clock_t end = clock();cout << "排序用时：" << double(end - start) / CLOCKS_PER_SEC << "秒" << endl;return 0;}```2. 快速排序算法的时间复杂度分析根据实验结果，快速排序算法在平均情况下的时间复杂度为O(nlogn)，在最坏情况下的时间复杂度为O(n^2)。
算法设计实训报告
算法设计实训报告一、引言在本次算法设计实训中，我将介绍一个旨在解决实际问题的算法。
这个算法的目标是提高某一特定任务的效率和准确性。
通过该算法的实施，我们希望能够为解决实际问题提供一个有效的解决方案。
二、问题描述我们面临的问题是如何在给定的时间内完成一系列任务，并确保任务的完成质量。
这些任务可能涉及到不同的领域，如生产制造、交通调度、资源分配等。
然而，由于任务量庞大、资源有限以及各种限制条件的存在，我们需要一个高效的算法来解决这个问题。
三、算法设计为了解决这个问题，我们设计了一个基于贪心算法的任务调度算法。
该算法根据任务的优先级和可用资源来安排任务的执行顺序。
具体而言，算法的实施过程如下：1. 初始化：根据任务的优先级和资源需求，将任务按照优先级从高到低排序，并将资源分配情况进行初始化。
2. 任务调度：从优先级最高的任务开始，依次选择可用资源最多的任务进行执行。
如果存在多个任务可用资源相同的情况，选择执行时间最短的任务。
3. 资源更新：执行完一个任务后，更新可用资源情况，并将已完成任务从待执行任务列表中移除。
4. 完成判断：重复步骤2和步骤3，直到所有任务都执行完毕。
四、算法优势相比于其他算法，我们的算法具有以下优势：1. 高效性：我们的算法通过贪心策略选择最优任务，能够快速找到当前情况下的最优解，从而提高任务的执行效率。
2. 灵活性：我们的算法可以根据不同的任务优先级和资源需求进行调整，并能够适应不同领域的任务调度需求。
3. 可扩展性：我们的算法能够处理大规模任务调度问题，并能够根据需要进行扩展和改进。
五、实验结果我们在实验中使用了真实的任务数据，并与其他算法进行了比较。
实验结果表明，我们的算法在任务完成时间和资源利用率方面表现出色，优于其他算法。
六、结论通过本次算法设计实训，我们成功地设计了一个基于贪心算法的任务调度算法，用于解决实际问题。
该算法在任务执行效率和资源利用率方面具有明显优势，可为解决实际问题提供一个有效的解决方案。
《算法设计与分析》实验报告模板 (1)
《算法设计与分析》实验报告
学号：姓名：
实验一分治法求解众数问题
一、实验目的
1.掌握分治法的设计思想并能熟练应用；
2.理解分治与递归的关系。
二、实验题目
在一个序列中出现次数最多的元素称为众数，根据分治法的思想设计算法寻找众数。
三、实验程序
四、程序运行结果
实验二动态规划法求解单源最短路径问题
一、实验目的
1.深刻掌握动态规划法的设计思想；
2.熟练应用以上算法思想求解相关问题。
二、实验题目
设有一个带权有向连通图，可以把顶点集划分成多个互不相交的子集，使得任一条边的两个顶点分属不同子集，称该图为多段图。
采用动态规划法求解多段图从源点到终点的最小代价路径。
三、实验程序
四、程序运行结果
实验三贪心法求解单源点最短路径问题
一、实验目的
1.掌握贪心法的设计思想；
2.分析比较同一个问题采用不同算法设计思想求解的结果。
二、实验题目
设有一个带权有向连通图，可以把顶点集划分成多个互不相交的子集，使得任一条边的两个顶点分属不同子集，称该图为多段图。
采用贪心法求解多段图从源点到终点的最小代价路径。
三、实验程序
四、程序运行结果
实验四回溯法求解0/1背包问题
一、实验目的
1.掌握回溯法的设计思想；
2.掌握解空间树的构造方法，以及在求解过程中如何存储求解路径；
二、实验题目
给定n种物品和一个容量为C的背包，选择若干种物品（物品不可分割），使得装入背包中物品的总价值最大。
采用回溯法求解该问题。
三、实验程序
四、程序运行结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《算法设计》课程报告课序号： 01 学号： 2012141461134姓名：刘佳玉任课教师：陈瑜评阅成绩：评阅意见：提交报告时间：2014年 6 月 16 日贪心算法1、问题描述（这是我在soj上找的一道题，以前没做出来，现在用贪心的思想做出来了）约翰要去钓鱼。
他有h小时可用（1≤h≤16），在这个地区有n个湖泊（2≤n≤25），所有的湖泊沿着一条单行道可到达。
约翰从湖泊1开始，他可以在任何湖泊结束。
他只能从一个湖，到下一个，但他没有必要停在任何湖除非他想停。
对于每个i = 1，……，n-1，ti 表示从湖i到湖i+1的5分钟的时间间隔（0 < ti < = 192）。
例如，t3 = 4意味着它从湖3湖4需要20分钟的时间。
为了帮助他们规划自己的钓鱼旅行，约翰已经收集了一些关于湖泊信息。
对于每个湖泊的i，能钓到的鱼在最初的5分钟的数量，用fi表示（fi > = 0），是已知的。
每钓5分钟的鱼，能钓到的鱼在接下来的5分钟的间隔降低一个恒定的数di（di＞＝0）。
如果能钓到的鱼在一个时间区的数量小于或等于di，将不会有更多的鱼留在湖里在下一个时间间隔。
为了简化规划，约翰认为没有人会在影响他期待钓到的鱼的数量的湖里钓鱼。
写一个程序来帮助约翰计划他的最大化期望钓到的鱼的数量的钓鱼之旅。
在每个湖花费的时间数必须是5的倍数。
这个问题包含多个测试案例！一个多输入的第一行是一个整数N，然后一个空白行后的N个输入块。
每个输入块由问题描述中的格式表示的。
每个输入块之间有一个空行。
输出格式包含N个输出块。
输出块之间要有一个空白行。
输入在输入中，会给你一个案例输入的数量。
每一种情况下，以n开始，其次是h，接下来有一行n个整数指定fi（1 < =i< = n），然后有一行n个整数di（1≤i＜＝n），最后，有一行n - 1的整数ti（1≤i＜＝n-1）。
输入在n=0的情况下终止。
输出对于每个测试案例，输出在每个湖花费的时间数量，以逗号分隔，为实现计划的能钓到的鱼的最大数量（你必须把整个计划输出在一行，即使超过80个字符）。
这是一个包含预期能钓到的鱼的数量。
如果存在多个计划，选择一个花尽可能长的时间在湖1的计划，即使没有鱼能钓在一些时间里。
如果不行，选择一个花尽可能长的时间湖2的计划，等等。
每个案例之间有一个空行。
2、算法分析看到这个题目后，你可能毫无思绪，怎样钓才能钓最多呢？请仔细看题，题目中说，沿湖是一条单行道，只能前进，不能后退，所以我要使前面钓的鱼最多，但如果不和后面的湖比较，怎么知道我前面掉的鱼是最佳的呢？我们不妨假设，我们只走到湖i（1<=i<=n），我们把花在路上的时间减去，这样就相当与我们可以再湖1和湖i之间任意选择一个湖钓鱼，这样每一个时间间隔我们在哪钓鱼通过比较一下不就清楚了吗，用一个循环找到最多到湖i钓鱼的最优解，然后这个问题就迎刃而解了。
3、程序源代码#include<iostream>#include<cstdio>#include<cstdlib>#include<cstring>#include<cmath>#include<algorithm>#include<queue>using namespace std;int f[30]; //能钓到的鱼的数量在某一时间块int d[30]; //在某一时间块钓鱼后湖里的鱼减少的数量int t[30]; //从湖i到湖i+1的时间int s[30]; //最佳情况下在每个湖停留的时间int fc[30]; //只到湖i钓鱼时各个湖能钓到的鱼的数量int sc[30]; //只到湖i钓鱼时各个湖停留的时间int main(){int T; //输入模块数int n; //湖的数量int h; //时间int i,j,k;int sum; //只到湖i钓鱼能钓到的鱼的总量int maxh; //从湖1到湖i能钓到的最大数量的鱼的湖 int maxn; //当前能钓到的鱼的最大数量，初始为-1； int temp; //钓鱼花的时间int kase=1; //案例数printf("输入案例的数量：\n");scanf("%d",&T);while(T--){printf("\n");printf("案例%d:\n",kase++);printf("输入湖泊的数量(0结束该组案例)：\n"); while(scanf("%d",&n)==1&&n){printf("输入钓鱼的时间：\n");scanf("%d",&h);h*=12; //以每5分钟为一个时间单位printf("输入初始时每个湖泊中的鱼的数量：\n");for(i=1;i<=n;i++){scanf("%d",&f[i]);}printf("输入每个湖泊在钓过一次鱼后鱼减少的数量：\n");for(i=1;i<=n;i++){scanf("%d",&d[i]);}printf("输入从湖泊i到湖泊i+1的时间：\n");for(i=2;i<=n;i++){scanf("%d",&t[i]);}t[1]=0; //从湖1到湖1的时间为0maxn=-1; //初始maxn的值for(i=1;i<=n;i++){for(j=1;j<=n;j++){fc[j]=f[j]; //复制能钓到的鱼的数量}for(j=1;j<=n;j++){sc[j]=0; //开始时每个湖停留的时间为0}h=h-t[i]; //除去路上用的时间就是钓鱼的时间//printf("h:%d\n",h); //查看h的值sum=0; //初始只到湖i是能钓到的鱼的总数for(k=1;k<=h;k++){maxh=1; //当前时间段能钓到最多鱼的湖for(j=1;j<=i;j++){if(fc[j]>fc[maxh]){maxh=j;}}if(fc[maxh]<=0){break; //如果最大能钓到的鱼的数量<=0，那么就停止钓鱼，把时间花在湖1}sum+=fc[maxh]; //钓到的鱼的总量fc[maxh]-=d[maxh]; //在湖maxh钓到的鱼的数量减少sc[maxh]+=5; //在湖maxn停留的时间加5}//printf("sum:%d\n",sum);if(sum>maxn) // 保存最优解{temp=0;maxn=sum;for(j=1;j<=n;j++){s[j]=sc[j];temp+=sc[j];}s[1]=s[1]+h*5-temp; //将剩余时间停留在湖1}/*for(j=1;j<=n;j++) //查看当前最优解{printf("%d ",s[j]);}printf("\n");*/}printf("输出在每个湖泊停留的时间：\n");for(i=1;i<=n;i++) //输出{printf("%d",s[i]);if(i!=n){printf(", ");}}printf("\n");printf("能钓到的鱼的最大数量: %d\n",maxn);printf("\n");printf("输入湖泊的数量(0结束该组案例)：\n"); }}return 0;}4、测试数据与运行结果样本输入12110 12 524410 15 20 170 3 4 31 2 34410 15 50 300 3 4 31 2 3样本输出45 5Number of fish expected: 31240 0 0 0Number of fish expected: 480 115 10 50 35Number of fish expected: 724 测试截图：5、算法复杂性分析与讨论课程名称：计算机算法设计与分析学生姓名：刘佳玉学生学号：2012141461134由于有三个for循环：for(i=1;i<=n;i++)for(k=1;k<=h;k++)for(j=1;j<=i;j++)算法复杂度O（n）=k*n^2。
由于这道题的n比较小，所以O（n^2）的算法也可以解决。
如果使用堆优化，可以更快，其O（n）=k*n*logn。
-10-。