算法上机实验报告
西南交通大学数值分析上机实验报告
数值分析上机实习报告学号：姓名：专业：联系电话：任课教师：序 (3)一、必做题 (4)1、问题一 (4)1.1 问题重述 (4)1.2 实验方法介绍 (4)1.3 实验结果 (5)2、问题二 (7)2.1 问题重述 (7)2.2 实验原理 (7)雅各比算法：将系数矩阵A分解为：A=L+U+D，则推到的最后迭代公式为： (8)2.3 实验结果 (8)二、选做题 (10)3、问题三 (10)3.1 问题重述 (10)3.2 实验原理 (10)3.3 实验结果 (11)总结 (11)序伴随着计算机技术的飞速发展，所有的学科都走向定量化和准确化，从而产生了一系列的计算性的学科分支，而数值计算方法就是解决计算问题的桥梁和工具。
数值计算方法，是一种研究并解决数学问题的数值近似解方法，是在计算机上使用的解数学问题的方法。
为了提高计算能力，需要结合计算能力与计算效率，因此，用来解决数值计算的软件因为高效率的计算凸显的十分重要。
数值方法是用来解决数值问题的计算公式，而数值方法的有效性需要根据其方法本身的好坏以及数值本身的好坏来综合判断。
数值计算方法计算的结果大多数都是近似值，但是理论的严密性又要求我们不仅要掌握将基本的算法，还要了解必要的误差分析，以验证计算结果的可靠性。
数值计算一般涉及的计算对象是微积分，线性代数，常微分方程中的数学问题，从而对应解决实际中的工程技术问题。
在借助MA TLAB、JA V A、C++ 和VB软件解决数学模型求解过程中，可以极大的提高计算效率。
本实验采用的是MATLAB软件来解决数值计算问题。
MA TLAB是一种用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境，其对解决矩阵运算、绘制函数/数据图像等有非常高的效率。
本文采用MATLAB对多项式拟合、雅雅格比法与高斯－赛德尔迭代法求解方程组迭代求解，对Runge-Kutta 4阶算法进行编程，并通过实例求解验证了其可行性，使用不同方法对计算进行比较，得出不同方法的收敛性与迭代次数的多少，比较各种方法的精确度和解的收敛速度。
上机实验报告(精选11篇)
上机实验报告篇1用户名se××××学号姓名学院①实验名称：②实验目的：③算法描述（可用文字描述，也可用流程图）：④源代码：（.c的文件）⑤用户屏幕（即程序运行时出现在机器上的画面）：2．对c文件的要求：程序应具有以下特点：a可读性：有注释。
b交互性：有输入提示。
c结构化程序设计风格：分层缩进、隔行书写。
3.上交时间：12月26日下午1点-6点，工程设计中心三楼教学组。
请注意：过时不候哟！四、实验报告内容0．顺序表的插入。
1.顺序表的删除。
2．带头结点的单链表的\'插入。
3.带头结点的单链表的删除。
注意：1.每个人只需在实验报告中完成上述4个项目中的一个，具体安排为：将自己的序号对4求余，得到的数即为应完成的项目的序号。
例如：序号为85的同学，85%4=1，即在实验报告中应完成顺序表的删除。
2.实验报告中的源代码应是通过编译链接即可运行的。
3.提交到个人空间中的内容应是上机实验中的全部内容。
上机实验报告篇2一、《软件技术基础》上机实验内容1．顺序表的建立、插入、删除。
2．带头结点的单链表的建立（用尾插法）、插入、删除。
二、提交到个人10m硬盘空间的内容及截止时间1．分别建立二个文件夹，取名为顺序表和单链表。
2．在这二个文件夹中，分别存放上述二个实验的相关文件。
每个文件夹中应有三个文件(.c文件、.obj文件和.exe文件)。
3. 截止时间：12月28日（18周周日）晚上关机时为止，届时服务器将关闭。
三、实验报告要求及上交时间（用a4纸打印）1．格式：《计算机软件技术基础》上机实验报告用户名se××××学号姓名学院①实验名称：②实验目的：③算法描述（可用文字描述，也可用流程图）：④源代码：（.c的文件）⑤用户屏幕（即程序运行时出现在机器上的画面）：2．对c文件的要求：程序应具有以下特点：a 可读性：有注释。
b 交互性：有输入提示。
算法实验报告结果分析
一、实验背景随着计算机科学技术的不断发展，算法作为计算机科学的核心内容之一，其重要性日益凸显。
为了验证和评估不同算法的性能，我们进行了一系列算法实验，通过对比分析实验结果，以期为后续算法研究和优化提供参考。
二、实验方法本次实验选取了三种常见的算法：快速排序、归并排序和插入排序，分别对随机生成的数据集进行排序操作。
实验数据集的大小分为10000、20000、30000、40000和50000五个级别，以验证算法在不同数据量下的性能表现。
实验过程中，我们使用Python编程语言实现三种算法，并记录每种算法的运行时间。
同时，为了确保实验结果的准确性，我们对每种算法进行了多次运行，并取平均值作为最终结果。
三、实验结果1. 快速排序快速排序是一种高效的排序算法，其平均时间复杂度为O(nlogn)。
从实验结果来看，快速排序在所有数据量级别下均表现出较好的性能。
在数据量较小的10000和20000级别，快速排序的运行时间分别为0.05秒和0.1秒；而在数据量较大的40000和50000级别，运行时间分别为0.8秒和1.2秒。
总体来看，快速排序在各个数据量级别下的运行时间均保持在较低水平。
2. 归并排序归并排序是一种稳定的排序算法，其时间复杂度也为O(nlogn)。
实验结果显示，归并排序在数据量较小的10000和20000级别下的运行时间分别为0.15秒和0.25秒，而在数据量较大的40000和50000级别，运行时间分别为1.5秒和2.5秒。
与快速排序相比，归并排序在数据量较小的情况下性能稍逊一筹，但在数据量较大时，其运行时间仍然保持在较低水平。
3. 插入排序插入排序是一种简单易实现的排序算法，但其时间复杂度为O(n^2)。
实验结果显示，插入排序在数据量较小的10000和20000级别下的运行时间分别为0.3秒和0.6秒，而在数据量较大的40000和50000级别，运行时间分别为8秒和15秒。
可以看出，随着数据量的增加，插入排序的性能明显下降。
迷宫问题_上机实验报告
一、实验目的1. 熟悉迷宫问题的基本概念和解决方法。
2. 掌握一种或多种迷宫求解算法。
3. 通过编程实践，提高算法设计和编程能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容迷宫问题是指在一个二维网格中，给定起点和终点，求解从起点到终点的路径。
本实验采用深度优先搜索（DFS）和广度优先搜索（BFS）两种算法进行迷宫求解。
1. 深度优先搜索（DFS）（1）算法原理：DFS算法是一种非确定性算法，其基本思想是沿着一个分支一直走到底，直到无法继续为止，然后回溯到上一个节点，再选择另一个分支继续走。
（2）算法步骤：a. 初始化迷宫，将起点设置为当前节点，将终点设置为目标节点。
b. 创建一个栈，将起点入栈。
c. 当栈不为空时，执行以下操作：a. 弹出栈顶元素，将其标记为已访问。
b. 判断是否为终点，如果是，则输出路径并结束算法。
c. 获取当前节点的上下左右邻居节点，如果邻居节点未被访问，则将其入栈。
d. 当栈为空时，算法结束。
（3）代码实现：```pythondef dfs(maze, start, end):stack = [start]visited = set()path = []while stack:node = stack.pop()if node == end:return path + [node]visited.add(node)for neighbor in get_neighbors(maze, node): if neighbor not in visited:stack.append(neighbor)path.append(node)return Nonedef get_neighbors(maze, node):x, y = nodeneighbors = []if x > 0 and maze[x-1][y] == 0:neighbors.append((x-1, y))if y > 0 and maze[x][y-1] == 0:neighbors.append((x, y-1))if x < len(maze)-1 and maze[x+1][y] == 0:neighbors.append((x+1, y))if y < len(maze[0])-1 and maze[x][y+1] == 0:neighbors.append((x, y+1))return neighbors```2. 广度优先搜索（BFS）（1）算法原理：BFS算法是一种确定性算法，其基本思想是从起点开始，按照一定顺序遍历所有节点，直到找到终点。
数值计算方法上机实验报告
数值计算方法上机实验报告
一、实验目的
本次实验的主要目的是熟悉和掌握数值计算方法，学习梯度下降法的
原理和实际应用，熟悉Python语言的编程基础知识，掌握Python语言的
基本语法。
二、设计思路
本次实验主要使用的python语言，利用python下的numpy，matplotlib这两个工具，来实现数值计算和可视化的任务。
1. 首先了解numpy的基本使用方法，学习numpy的矩阵操作，以及numpy提供的常见算法，如矩阵分解、特征值分解等。
2. 在了解numpy的基本操作后，可以学习matplotlib库中的可视化
技术，掌握如何将生成的数据以图表的形式展示出来。
3. 接下来就是要学习梯度下降法，首先了解梯度下降法的主要原理，以及具体的实际应用，用python实现梯度下降法给出的算法框架，最终
可以达到所期望的优化结果。
三、实验步骤
1. 熟悉Python语言的基本语法。
首先是熟悉Python语言的基本语法，学习如何使用Python实现变量
定义，控制语句，函数定义，类使用，以及面向对象编程的基本概念。
2. 学习numpy库的使用方法。
其次是学习numpy库的使用方法，学习如何使用numpy库构建矩阵，学习numpy库的向量，矩阵操作，以及numpy库提供的常见算法，如矩阵分解，特征值分解等。
3. 学习matplotlib库的使用方法。
数学的上机实验报告
实验题目：线性代数求解方程组一、实验目的1. 理解线性代数中方程组的求解方法。
2. 掌握利用计算机求解线性方程组的算法。
3. 熟悉数学软件（如MATLAB、Python等）在数学问题中的应用。
二、实验内容本次实验主要利用数学软件求解线性方程组。
线性方程组是线性代数中的一个基本问题，其求解方法有很多种，如高斯消元法、矩阵求逆法等。
本实验以高斯消元法为例，利用MATLAB软件求解线性方程组。
三、实验步骤1. 编写高斯消元法算法程序。
2. 输入方程组的系数矩阵和常数项。
3. 调用程序求解方程组。
4. 输出解向量。
四、实验代码及分析1. 高斯消元法算法程序```matlabfunction x = gaussElimination(A, b)[n, m] = size(A);assert(n == m, 'The matrix A must be square.');assert(n == length(b), 'The length of b must be equal to the number of rows in A.');% 初始化解向量x = zeros(n, 1);% 高斯消元for i = 1:n-1% 寻找最大元素[~, maxIdx] = max(abs(A(i:n, i)));maxIdx = maxIdx + i - 1;% 交换行A([i, maxIdx], :) = A([maxIdx, i], :);b([i, maxIdx]) = b([maxIdx, i]);% 消元for j = i+1:nfactor = A(j, i) / A(i, i);A(j, i:n) = A(j, i:n) - factor A(i, i:n); b(j) = b(j) - factor b(i);endend% 回代求解for i = n:-1:1x(i) = (b(i) - A(i, i+1:n) x(i+1:n)) / A(i, i); endend```2. 输入方程组的系数矩阵和常数项```matlabA = [2, 1, -1; 1, 2, 1; -1, 1, 2];b = [8; 5; 2];```3. 调用程序求解方程组```matlabx = gaussElimination(A, b);```4. 输出解向量```matlabdisp('解向量为：');disp(x);```五、实验结果与分析实验结果：```解向量为：2-13```实验分析：通过高斯消元法，我们成功求解了给定的线性方程组。
离散数学上机实验报告
离散数学上机实验报告《离散数学》实验报告姓名：学号：班级：实验一连结词逻辑运算一.实验目的实现二元合取、析取、蕴涵和等价表达式的计算。
熟悉连接词逻辑运算规则，利用程序语言实现逻辑这几种逻辑运算。
二.实验内容从键盘输入两个命题变元P和Q的真值，求它们的合取、析取、蕴涵和等价四种运算的真值。
要求对输入内容进行分析，如果不符合0、1条件需要重新输入，程序有良好的输入输出界面。
三.实验环境使用Microsoft Visual C++6.0为编程软件，采用称C/C++语言为编程语言实现。
四.实验过程1.算法分析:合取：p，q都为1的时候为1，其他为0析取：p，q都为0的时候为0，其他为1蕴含：p为1，q为0时为0，其他为1等价：p，q同真同假2.程序代码:#include<stdio.h>int main()int P,Q,a,b,c,d,p,q;printf(" P的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++)printf("\t%d",P);}printf("\n Q的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++)printf("\t%d",Q);}printf("\n 非P的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++){if(P==0)/*判断非P的值*/ p=1;elseprintf("\t%d",p);}}printf("\n 非Q的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++){if(Q==1)/*判断非Q的值*/q=0;elseq=1;printf("\t%d",q);}}printf("\n P与Q的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++){if(Q==0||P==0)/*判断P与Q的值*/elsea=1;printf("\t%d",a);}}printf("\n P或Q的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++){if(Q==1||P==1)/*判断P或Q的值*/ b=1;elseb=0;printf("\t%d",b);}}printf("\nP蕴含Q的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++){if(P==1&&Q==0)/*判断P蕴含Q的值*/ c=0;elsec=1;printf("\t%d",c);}}printf("\nP等价Q的值");for(P=0;P<2;P++){for(Q=0;Q<2;Q++){if(P==Q)/*判断P等价Q的值*/d=1;elsed=0;printf("\t%d",d);}}printf("\n");return 0;3.实验数据及结果分析:实验二关系的复合运算及逆运算一.实验目的熟悉关系的复合运算和逆运算，编程实现关系复合运算和逆运算算法。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程实验报告课程名称：算法设计与分析专业班级：信息安全1303学号：U**********名：***指导教师：***报告日期：2015-6-16计算机科学与技术学院目录目录 (2)实验一最近点对问题 (1)1.1实验内容与要求 (1)1.2算法设计 (1)1.3 实验结果与分析 (2)1.4编程技术与方法 (3)1.5 源程序及注释 (3)实验二大整数乘法 (8)2.1实验内容与要求 (8)2.2算法设计 (9)2.3 实验结果与分析 (12)2.4编程技术与方法 (12)2.5 源程序及注释 (12)实验三单源点 (14)3.1实验内容与要求 (14)3.2算法设计 (14)3.3 实验结果与分析 (14)3.4编程技术与方法 (16)3.5 源程序及注释 (16)实验四最优二分检索树 (19)4.1实验内容与要求 (19)4.2算法设计 (19)4.3实验结果与分析 (20)4.4源程序及注释 (22)五、实验心得与体会 (25)六、参考书目 (27)实验一最近点对问题1.1实验内容与要求已知平面上分布着点集P中的n个点p1,p2,...p n，点i的坐标记为(x i,y i)，1≤i≤n。
两点之间的距离取其欧式距离，记为22)()(),(jijijiyyxxppd-+-=问题：找出一对距离最近的点。
注：允许两个点位于同一个位置，此时两点之间的距离为0要求：用分治法实现最近点对的问题。
1.2算法设计（1）首先将所有的点按照x坐标排序。
排序过程需要O(nlogn)的时间，不会从整体上增加时间复杂度的数量级。
（2）划分：由于点已经按x坐标排序，所以空间上可以“想象”画一条垂线，作为分割线，将平面上的点集分成左、右两半P L和P R。
如下图所示：分割线PL记, d L:P L中的最近点对距离；d R:P R中的最近点对距离；d C:跨越分割线的最近点对距离。
则，最近的一对点或者在P L中，或者在P R中，或者一个在P L中而另一个在P R中（跨越分割线）。
设点按它们的y坐标排序，如果p i和某个p j的y坐标相差大于δ，那么这样的p i可以终止计算，继续处理p i+1。
算法描述如下：for i=1 to numPointsInStrip dofor j=i+1 to numPointsInStrip doif p i and p j's y-coordinates differ by more than δbreak;else if dist(p i,p j)<δδ = dist(p i,p j);1.3 实验结果与分析实验数据：（1）点对数目：6（2）点对坐标：（1,3）（2,5）（3,12）（5,8）（6,9）（7,15）运行结果：如图显示的是最近点对<5.00,8.00><6.00,9.00>的距离为1.411.4编程技术与方法纵观整个过程，首先要对X坐标排序时间为O（NlogN），这是分治之前的预处理。
然后问题分成了N/2规模，然后用Q（N）的复杂度得到中间的最近点对，然后可以在常数时间内得到最终的点对与最近值。
So。
T（N）=2T（N/2）+O（N），可以得到该算法的时间为O（NlogN）,在用分治法之前首先对Y坐标进行冒泡排序，将左右|d|范围里的点按Y值排序，然后依次从每个点出发做水平线，并在其之上d的距离做水平线，这样得到了一个2d*d 的矩形，显然，在此矩形之外的点无需开率啦，可以证明，矩形内最多容下8个点（包括自己本身）。
所以意味着在排好序的Y坐标点中，只需要考虑其后的7个点就行了，此外已有人证明了事实上只需要考虑其后的4个点就行啦。
可见，这些的时间复杂度最多Q （N）。
1.5 源程序及注释#include <stdio.h>#include <stdlib.h>#include <math.h>#define MAXLEN 200int init(float *x,float *y,int *ind){int n,i;while(1==scanf("%d",&n)){if(n > 1) break;printf("n invalid!\n");}for(i=0;i<n;i++){scanf("%f%f",x+i,y+i);ind[i]=i;}return n;}void pre_sort(float *x,float *y,int *ind,int n){//must finish in O(nlogn) but here using normorl sort method //bubble sortint i,j;int tmp;float tmp_y,tmp_x;for(i=0;i<n;i++)for(j=n-1;j > i;j--)if(x[j-1] > x[j]){//swap xtmp_x=x[j-1];x[j-1]=x[j];x[j]=tmp_x;//swap ytmp_y=y[j-1];y[j-1]=y[j];y[j]=tmp_y;//swap ind no need now!/*tmp=ind[j-1];ind[j-1]=ind[j];ind[j]=tmp;*/}for(i=0;i<n;i++)for(j=n-1;j > i;j--)if(y[j-1] > y[j]){//swap ytmp_y=y[j-1];y[j-1]=y[j];y[j]=tmp_y;//swap indtmp=ind[j-1];ind[j-1]=ind[j];ind[j]=tmp;}}float get_pair_len(float x1,float y1,float x2,float y2){return sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));}void find_closest_pair(int st,int ed,float *x,float *y,int *ind,float *closest,float *x1,float *y1,float *x2,float *y2){//key codeif(ed-st == 1){//only 2 point*closest=get_pair_len(x[ind[0]],y[0],x[ind[1]],y[1]);*x1=x[ind[0]];*y1=y[0];*x2=x[ind[1]];*y2=y[1];}else if(ed-st ==2){//only 3 pointfloat len;*closest=get_pair_len(x[ind[0]],y[0],x[ind[1]],y[1]);*x1=x[ind[0]];*y1=y[0];*x2=x[ind[1]];*y2=y[1];len=get_pair_len(x[ind[0]],y[0],x[ind[2]],y[2]);if(len < *closest){*closest=len;*x1=x[ind[0]];*y1=y[0];*x2=x[ind[2]];*y2=y[2];}len=get_pair_len(x[ind[1]],y[1],x[ind[2]],y[2]);if(len < *closest){*closest=len;*x1=x[ind[1]];*y1=y[1];*x2=x[ind[2]];*y2=y[2];}}else{//at least 4 pointsint i,cl,cr,ct;int mid;float t_c1,t_c2;float t_c1_x1,t_c1_y1,t_c1_x2,t_c1_y2;float t_c2_x1,t_c2_y1,t_c2_x2,t_c2_y2;float *yl,*yr,*yct;int *indl,*indr,*indct;mid=(st+ed)/2;yl=(float*)malloc((mid-st+1)*sizeof(float));indl=(int*)malloc((mid-st+1)*sizeof(int));yr=(float*)malloc((ed-mid)*sizeof(float));indr=(int*)malloc((ed-mid)*sizeof(int));if(!yl || !yr || !indl || !indr) exit(-2);//non enough mmfor(i=0,cl=0,cr=0;i<=ed-st;i++){//store new order y&indif(ind[i] <= mid){yl[cl]=y[i];indl[cl]=ind[i];cl++;}else{yr[cr]=y[i];indr[cr]=ind[i];cr++;}}//dividedfind_closest_pair(st,mid,x,yl,indl,&t_c1,&t_c1_x1,&t_c1_y1,&t_c1_x2,&t_c1_y2);find_closest_pair(mid+1,ed,x,yr,indr,&t_c2,&t_c2_x1,&t_c2_y1,&t_c2_x2,&t_c2_y2);if(t_c1 < t_c2){*closest=t_c1;*x1=t_c1_x1;*y1=t_c1_y1;*x2=t_c1_x2;*y2=t_c1_y2;}else{*closest=t_c2;*x1=t_c2_x1;*y1=t_c2_y1;*x2=t_c2_x2;*y2=t_c2_y2;}//get the closest pair between the two part(L&R)int v,ve;float closest_tmp;float part_line=(x[mid]+x[mid+1])/2.0;yct=(float*)malloc((ed-st+1)*sizeof(float));indct=(int*)malloc((ed-st+1)*sizeof(int));//get all the y in the rectfor(i=0,ct=0;i<=ed-st;i++)if(x[ind[i]]>part_line-*closest && x[ind[i]]<part_line+*closest ){yct[ct]=y[i];indct[ct]=ind[i];ct++;}//check followed the 4 pointsif(ct > 1){for(i=0;i< ct-1;i++){ve=(i+4 < ct-1 ? i+4:ct-1);v=i+1;while(v<=ve && yct[v]-yct[i] <=*closest){closest_tmp=get_pair_len(x[indct[i]],yct[i],x[indct[v]],yct[v]);if(closest_tmp < *closest){*closest=closest_tmp;*x1=x[indct[i]];*y1=yct[i];*x2=x[indct[v]];*y2=yct[v];}v++;}}}free(yl);free(yr);free(indl);free(indr);free(yct);free(indct);}}int main(){float X[MAXLEN],Y[MAXLEN];int IND[MAXLEN],n;n=init(X,Y,IND);float closest,x1,y1,x2,y2;pre_sort(X,Y,IND,n);find_closest_pair(0,n-1,X,Y,IND,&closest,&x1,&y1,&x2,&y2);printf("the closest value is:%-4.2f (%-4.2f,%-4.2f) (%-4.2f,%-4.2f)\n",closest,x1,y1,x2,y2);return 0;}实验二大整数乘法2.1实验内容与要求利用分治法设计一个计算两个n位的大整数相乘的算法，要求计算时间低于O(n2)。