中科大软院算法导论最近点对算法_C++
中科大算法导论期末试卷及答案

解:存在������1(n) + ������2(������) = ������(max(������1(������), ������2(������) 证明: ������1(������) = ������(������1(n)) 则存在 a1>0,a2>0, n1>0 使得 n>n1 时有 ������1 ∗ ������1(n) < ������1(������) < ������2 ∗ ������1(n) ������2(������) = ������(������2(n)) 则存在 b1>0,b2>0, n2>0 使得 n>n2 时有 ������1 ∗ ������2(n) < ������2(������) < ������2 ∗ ������2(n) 取 c1=min(a1,b1) >0, c2=2*max(a2,b2) >0, n0=max(n1,n2)>0 当 n>n0 时,有 ������1(n) + ������2(������) > ������1 ∗ ������1(n) + ������1 ∗ ������2(n)
= ������2(������������ − 5 ������������������������) − 2������ > 2������3 − 2������ > 2������0(������02 − 1) =12 即当 c=7, n0=2 时,对 n>n0, 5������2������������������������ + 2������ < ������������3恒成立, 5������2������������������������ + 2������ = ������(������3)
算法导论 答案 (2)

算法导论答案算法导论概述《算法导论》是一本经典的计算机科学教材,由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein合著。
这本书详细介绍了算法的设计、分析和实现,并涵盖了算法导论领域的许多重要概念和技术。
本文将为你提供一些关于《算法导论》中一些常见问题的答案。
1. 什么是算法?算法是一系列明确定义的步骤,用于解决特定问题或完成特定任务。
它可以是一个计算过程、一个程序或一个有限的操作序列。
算法通常用于计算和数据处理领域,是计算机科学的核心概念。
2. 为什么学习算法很重要?学习算法的重要性体现在以下几个方面:•提高问题解决能力:算法是解决问题的有效工具。
学习算法可以帮助我们思考和理解问题,并设计出相应的解决方案。
•优化计算性能:算法的设计和分析可以帮助我们提高计算的效率和性能。
合适的算法可以在短时间内处理大规模数据集和复杂计算任务。
•促进技术创新:算法是许多技术和应用的基石,包括人工智能、机器学习、数据挖掘等。
学习算法可以为我们打开更多的研究和创新机会。
3. 《算法导论》提供了哪些内容?《算法导论》这本书详细介绍了算法的基本概念和设计技巧,并提供了许多典型算法的实现和分析。
以下是该书的一些主要内容:•算法分析:对算法进行时间复杂度和空间复杂度的理论分析,帮助我们评估算法的效率和性能。
•排序和查找算法:介绍了各种排序算法(如插入排序、归并排序、快速排序)和查找算法(如二分查找、哈希表)。
•图算法:讨论了图的表示方法和图搜索算法(如深度优先搜索、广度优先搜索)以及最短路径算法(如Dijkstra算法)等。
•动态规划和贪心算法:介绍了动态规划和贪心算法的原理和应用,用于解决具有最优子结构性质的问题。
•分治算法和递归思想:讲解了分治算法的基本原理,并提供了许多使用递归思想解决问题的例子。
•NP完全问题:探讨了NP完全问题的性质和求解方法,引导了读者进入计算复杂性理论的领域。
算法导论求n个点的最小距离

算法导论求n个点的最小距离2010-01-20 17:23在中文算法导论649页算法:0:把所有的点按照横坐标排序1:用一条竖直的线L将所有的点分成两等份2:递归算出左半部分的最近两点距离d1,右半部分的最近两点距离d2,取d=min(d1,d2)3:算出“一个在左半部分,另一个在右半部分”这样的点对的最短距离d3。
4:结果=min(d1,d2,d3)关键就是这第3步。
貌似这需要n^2的时间,把左边每个点和右边每个点都对比一下。
其实不然。
秘密就在这里。
首先,两边的点,与分割线L的距离超过d的,都可以扔掉了。
其次,即使两个点P1,P2(不妨令P1在左边,P2在右边)与分割线L的距离(水平距离)都小于d,如果它们的纵坐标之差大于d,也没戏。
就是这两点使得搜索范围大大减小:对于左半部分的,与L的距离在d之内的,每个P1来说:右半部分内,符合以上两个条件的点P2最多只有6个!原因就是:d是两个半平面各自内,任意两点的最小距离,因此在同一个半平面内,任何两点距离都不可能超过d。
我们又要求P1和P2的水平距离不能超过d,垂直距离也不能超过d,在这个d*2d 的小方块内,最多只能放下6个距离不小于d的点。
因此,第3步总的比较距离的次数不超过n*6。
第3步的具体做法是:3.1 删除所有到L的距离大于d的点。
O(n)3.2 把右半平面的点按照纵坐标y排序。
O(nlogn)3.3 对于左半平面内的每个点P1,找出右半平面内纵坐标与P1的纵坐标的差在d以内的点P2,计算距离取最小值,算出d3。
O(n*6) = O(n)因为3.2的排序需要O(nlogn),所以整个算法的复杂度就是O(n((logn)^2))。
改进:我们对3.2这个排序的O(nlogn)不太满意。
既然整个算法是递归的,我们可以利用第2步的子递归中已经排好序的序列,在第3.2部归并这两个子列,这样3.2的复杂度变成了O(n)。
这样,整个算法就是O(nlogn)的。
算法导论知识点总结

算法导论知识点总结算法是计算机科学领域的重要概念,它是解决问题的一种有效方式。
在计算机科学中,算法的设计和分析是非常重要的,它涉及到了计算机程序的性能、效率和可靠性。
算法导论是计算机科学和工程领域的一门重要课程,它涵盖了算法的基本概念、设计原则和分析方法。
本文将对算法导论的一些重要知识点进行总结。
一、算法导论的基本概念1. 算法的定义和特点算法是解决问题的一种方法或步骤,它由一系列的操作和指令组成,可以在有限时间内解决问题。
算法的特点包括:输入、输出、有限性、确定性和有效性。
2. 算法的时间复杂度和空间复杂度算法的时间复杂度是一个算法运行所需要的时间成本,通常用大O符号来表示;算法的空间复杂度是一个算法所需要的内存空间大小。
3. 算法设计的基本方法算法的设计方法包括:贪心法、分治法、动态规划、回溯法、分支限界法等。
4. 算法的分析方法算法的分析包括:最坏情况分析、平均情况分析、最好情况分析等。
二、算法导论的主要内容1. 基本数据结构基本数据结构是算法导论中非常重要的内容,包括:数组、链表、栈、队列、树、图等。
2. 排序和查找算法排序算法包括:冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序等。
查找算法包括:顺序查找、二分查找、哈希查找、树查找等。
3. 字符串匹配算法字符串匹配算法包括:朴素匹配算法、KMP算法、Boyer-Moore算法、Rabin-Karp算法等。
4. 图算法图算法包括:图的遍历、最短路径、最小生成树、拓扑排序、关键路径等。
5. 动态规划动态规划是一种重要的算法设计方法,适用于多阶段决策问题和最优化问题。
6. 贪心算法贪心算法是一种简单而有效的算法设计方法,通常适用于某些特定问题、具有贪心选择性质的问题。
7. 分治法分治法是一种重要的算法设计方法,通常适用于将大问题分解成小问题来解决的问题。
8. 线性规划线性规划是一种数学解法,通常用于解决最优化问题。
9. 概率算法概率算法是一种基于概率和随机性的算法设计方法,通常适用于复杂问题和近似解决问题。
中科大软件学院算法复习概念综合题

一、概念题:(1)排序算法时间复杂度:排序算法最好最坏平均插入O(n)O(n2)O(n2)归并O(nlogn)O(nlogn)O(nlogn)快排O(nlogn)O(n2)O(nlogn)排序算法空间复杂度:1、所有简单排序和堆排序都是0(1)2、快速排序为0(logn),要为递归程序执行过程栈所需的辅助空间3、归并排序和基数排序所需辅助空间最多,为O(n)(2)渐近记号1、渐近确界:Θ(g(n))={f(n):存在正常数c1和c2和n0,使对所有的n>= n0,都有0<=c1g(n)<=f(n)<=c2g(n)}。
大Θ记号给出函数的渐进确界。
2、渐近下界:Ω(g(n))={f(n):存在正常数c和n0,使对所有的n>=n0,都有0<=cg(n)<=f(n)}。
大Ω记号给出函数的渐进下界。
3、渐近上界:O(g(n))={f(n):存在正常数c和n0,使对所有的n>=n0,都有0<=f(n)<=cg(n)}。
大O记号给出函数的渐进上界。
(3)二叉查找树:执行基本操作的时间与树的高度成正比。
搜索、插入、删除的复杂度等于树高,期望O(lgn),最坏O(n)(数列有序,树退化成线性表)(4)红黑树:1、时间复杂度:基本动态集合操作:O(log n),n是树中元素的数目。
2、性质:1)节点是红色或黑色。
2)根节点是黑色。
3)每个叶节点(NIL节点)是黑色的。
4)如果一个结点是红的,则它的两个儿子都是黑的(不能有两个连续红结点)5)从任一节点到其子孙结点的所有路径都包含相同数目的黑色节点。
3、相关概念,定理:1)黑高度:从某个结点出发(不包括该结点)到达一个叶结点的任意一条路径上,黑色结点的个数称为该结点x的黑高度,bh(x)。
红黑树的黑高度定义为其根节点的黑高度。
2)一颗有n个内结点的红黑树的高度至多为2lg(n+1)。
(用2-3-4树理解)3)在一颗黑高度为K的红黑树中,总结点数最多有22k+1-1,此时内结点最多为22k-1(满二叉树,红黑交替),内结点最少有2k-14)RB-INSERT-FIXUP操作所作的旋转不超过两次,RB-DELETE-FIXUP所作的操作至多三次旋转(5)动态规划:1、装配线调度:FASTEST-WAY时间复杂度O(n)2、矩阵链乘法:MATRIX-CHAIN-ORDER时间复杂度O(n3)3、最长公共子序列:LCS-LENGTH时间复杂度为O(mn),m、n为序列的长度4、最优二叉查找树:OPTIMAL-BST时间复杂度为O(n3)(6)贪心算法:1、活动选择问题:初试时活动已按结束时间排序,O(n),否则可在O(nlgn)内排序2、哈夫曼编码:Q用最小二叉堆实现,运行时间在O(nlgn)3、任务调度问题:时间复杂度为O(n2),因为算法中O(n)次独立性检查中每一次都有花O(n)的时间(7)二项堆:1、可合并堆时间复杂度过程二叉堆(最坏)二项堆(最坏)Fibonacci(平摊)MAKE-HEAPΘ(1)Θ(1)Θ(1)INSERTΘ(lgn)Ω(lgn)Θ(1)MINIMUMΘ(1)Ω(lgn)Θ(1) EXTRACT-MINΘ(lgn)Θ(lgn)O(lgn) UNIONΘ(n)Θ(lgn)Θ(1) DECREASE-KEYΘ(lgn)Θ(lgn)Θ(1) DELETEΘ(lgn)Θ(lgn)O(lgn)2、二项树B k是一种递归定义的树,由两颗B k-1连接而成,其中一颗树的根是另一颗树的根的最左孩子性质:1)共有2k个结点2)树的高度为k3)在深度i处恰有(上k,下i)(因此叫二项树)个结点,其中i=0,...,k;4)根的度数为k,它大于任何其他结点的度数,并且,如果对根的子女从左到右编号为k-1,k-2,...,0,子女i是子树Bi的根。
二分法计算点集最近的两个点及距离

二分法计算点集最近的两个点及距离文章标题:探讨二分法在计算点集中最近的两个点及其距离中的应用在计算机科学和算法领域中,二分法是一种非常常见且有效的算法,它在许多问题的解决中发挥着重要作用。
其中,二分法在计算点集中最近的两个点及其距离时,也有着极其重要的应用。
本文将深入探讨二分法在这一问题中的应用,从简单到复杂、由浅入深地介绍二分法的原理,探讨其在计算最近点对时的实际应用,并分享一些个人观点和理解。
一、什么是二分法让我们简要介绍一下二分法的基本原理。
二分法,英文名为Binary Search,是一种在有序数组中查找特定元素的搜索算法。
其基本原理是每次将待查找区间对半分,然后确定要查找的值在哪一半,从而缩小查找范围,直到找到要查找的值或确定值不存在为止。
二、二分法在计算最近点对中的应用在计算最近点对的问题中,给定一个包含n个点的集合,需要找到集合中距离最近的两个点,并计算它们的距离。
对于这一问题,我们可以借助二分法来解决。
具体而言,我们可以首先根据点的横坐标对点集进行排序,然后利用二分法在排好序的点集中寻找最近点对。
由于排好序的点集在空间中具有一定的顺序关系,因此可以利用这一特性来优化查找过程,从而减少计算量。
在利用二分法查找最近点对时,我们可以将点集等分成两部分,然后分别在左右两部分中寻找最近点对。
然后再考虑中间部分的情况,这样就可以递归地求解最近点对的问题。
通过不断地将点集分割、计算和比较,最终可以找到整个点集中最近的两个点,并计算它们的距离。
三、二分法在计算最近点对中的实际应用二分法在计算最近点对的算法中有着广泛的实际应用价值。
通过巧妙地利用二分法,可以在较快的时间内找到点集中最近的两个点,并计算它们的距离。
这对于许多计算机图形学、空间数据分析等领域都具有重要意义。
在实际应用中,我们可以结合二分法和分治法来处理最近点对的问题,从而提高算法的效率和精度。
通过合理地设计算法流程和数据结构,可以使二分法在计算最近点对问题中发挥出色的效果。
给定平面上的n个点,求距离最近的两个点的距离。c语言
给定平面上的n个点,求距离最近的两个点的距离。
c语言给定平面上的n个点,我们需要找到距离最近的两个点之间的距离。
这是一个常见的计算几何问题,在计算机科学中有很多有效的算法可以解决这个问题。
在本文中,我们将使用C语言来实现一个简单但有效的算法来求解这个问题。
首先,我们需要定义一个点的结构体来表示平面上的点。
点结构体可以包含两个成员变量,分别表示x和y坐标。
cstruct point {double x;double y;};接下来,我们需要实现一个计算两点之间距离的函数。
根据欧几里得距离公式,两点之间的距离可以通过下列公式计算得出:cdouble distance(struct point p1, struct point p2) {double dx = p1.x - p2.x;double dy = p1.y - p2.y;return sqrt(dx * dx + dy * dy);}现在我们已经有了计算距离的函数,接下来我们将介绍一种简单但有效的算法来找到距离最近的两个点。
我们首先需要将所有的点按照x坐标进行排序。
使用快速排序算法可以很高效地实现这一步。
cvoid quickSort(struct point arr[], int low, int high) {if (low < high) {int pivot = partition(arr, low, high);quickSort(arr, low, pivot - 1);quickSort(arr, pivot + 1, high);}}int partition(struct point arr[], int low, int high) {struct point pivot = arr[high];int i = (low - 1);for (int j = low; j <= high - 1; j++) {if (arr[j].x <= pivot.x) {i++;swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return (i + 1);}void swap(struct point* a, struct point* b) {struct point temp = *a;*a = *b;*b = temp;}在完成排序之后,我们可以使用分治算法来找到最近的两个点。
最近点对算法
最近点对算法1. 简介最近点对算法(Closest Pair Algorithm)是一种用于找到平面上最近的两个点的算法。
该算法可以在给定一组点的情况下,找到距离最近的两个点,并计算出它们之间的距离。
最近点对问题在计算几何学、图像处理、数据挖掘等领域中具有广泛应用。
例如,在地理信息系统中,可以使用最近点对算法来查找距离最近的两个地理位置;在机器视觉中,可以使用该算法来寻找图像中距离最接近的两个特征点。
2. 算法思想最近点对算法采用分治策略,将问题划分为多个子问题,并通过递归求解子问题来得到整体解。
其基本思想可以概括为以下步骤:1.将所有点按照横坐标进行排序。
2.将排序后的点集平均划分为左右两部分,分别称为P_left和P_right。
3.分别在P_left和P_right中递归求解最近点对。
4.在左右两部分求得的最近点对中,选择距离更小的那一对作为候选解。
5.在区间[P_left[-1].x, P_right[0].x]内,查找可能的更近点对。
6.比较候选解与新找到的更近点对,选择距离更小的那一对作为最终解。
3. 算法实现3.1 数据结构在实现最近点对算法时,需要定义合适的数据结构来表示点。
常见的表示方法是使用二维数组或类对象。
以下是使用类对象来表示点的示例代码:class Point:def __init__(self, x, y):self.x = xself.y = y3.2 算法步骤3.2.1 排序首先,将所有点按照横坐标进行排序。
可以使用快速排序或归并排序等算法来实现排序功能。
def sort_points(points):# 使用快速排序按照横坐标进行排序# ...3.2.2 分治求解将排序后的点集平均划分为左右两部分,并递归求解最近点对。
def closest_pair(points):n = len(points)# 如果点集中只有两个点,则直接返回这两个点和它们之间的距离if n == 2:return points, distance(points[0], points[1])# 如果点集中只有三个点,则直接计算出最近点对if n == 3:d1 = distance(points[0], points[1])d2 = distance(points[0], points[2])d3 = distance(points[1], points[2])if d1 <= d2 and d1 <= d3:return [points[0], points[1]], d1elif d2 <= d1 and d2 <= d3:return [points[0], points[2]], d2else:return [points[1], points[2]], d3# 将点集平均划分为左右两部分mid = n // 2P_left = points[:mid]P_right = points[mid:]# 分别在左右两部分递归求解最近点对closest_pair_left = closest_pair(P_left)closest_pair_right = closest_pair(P_right)# 在左右两部分求得的最近点对中,选择距离更小的那一对作为候选解if closest_pair_left[1] < closest_pair_right[1]:min_pair, min_distance = closest_pair_leftelse:min_pair, min_distance = closest_pair_right3.2.3 查找更近点对在区间[P_left[-1].x, P_right[0].x]内,查找可能的更近点对。
最近点对算法
最近点对算法
最近点对算法是一种计算平面上最近的两个点的算法。
该算法是计算机科学中的一个基本问题,也是计算几何学的研究方向之一。
最近点对问题是指在平面上给定n个点,找出其中距离最近的两个点。
该问题的一个简单暴力解法是对每对点进行距离计算,然后选取距离最小的一对。
但该算法的时间复杂度为O(n^2),当n较大时效率较低。
因此,研究者提出了更高效的算法。
其中一种著名的解法是分治法,该算法的时间复杂度为O(nlogn)。
该算法的思路是将点集分成两个子集,然后递归地计算每个子集中的最近点对,并找出跨越两个子集的最近点对。
除分治法外,还有其他更优秀的最近点对算法,如随机增量法、基于网格的算法等。
最近点对算法在计算机科学、地理信息系统、机器人技术等领域有广泛应用。
- 1 -。
算法导论参考答案
算法导论参考答案算法导论参考答案算法导论是计算机科学领域中一本经典的教材,被广泛应用于计算机科学和工程的教学和研究中。
它涵盖了算法设计和分析的基本概念,以及各种常见算法的实现和应用。
本文将为读者提供一些算法导论中常见问题的参考答案,以帮助读者更好地理解和掌握这门课程。
1. 什么是算法?算法是一系列解决问题的步骤和规则。
它描述了如何将输入转换为输出,并在有限的时间内完成。
算法应具备正确性、可读性、健壮性和高效性等特点。
2. 如何分析算法的效率?算法的效率可以通过时间复杂度和空间复杂度来衡量。
时间复杂度表示算法执行所需的时间量级,常用的时间复杂度有O(1)、O(n)、O(logn)、O(nlogn)和O(n^2)等。
空间复杂度表示算法执行所需的额外空间量级,通常以字节为单位。
3. 什么是渐进符号?渐进符号用于表示算法的时间复杂度或空间复杂度的增长趋势。
常见的渐进符号有大O符号、Ω符号和Θ符号。
大O符号表示算法的上界,Ω符号表示算法的下界,Θ符号表示算法的平均情况。
4. 什么是分治法?分治法是一种算法设计策略,将问题分解为若干个子问题,并对子问题进行独立求解,最后将子问题的解合并得到原问题的解。
典型的分治算法有归并排序和快速排序。
5. 什么是动态规划?动态规划是一种通过将问题分解为相互重叠的子问题来求解的方法。
它通常用于求解具有重叠子问题和最优子结构性质的问题。
典型的动态规划算法有背包问题和最短路径问题。
6. 什么是贪心算法?贪心算法是一种通过每一步选择局部最优解来求解整体最优解的方法。
贪心算法通常不能保证得到全局最优解,但在某些问题上能够得到近似最优解。
典型的贪心算法有霍夫曼编码和最小生成树算法。
7. 什么是图算法?图算法是一类用于解决图结构相关问题的算法。
图由节点和边组成,节点表示对象,边表示对象之间的关系。
图算法包括图的遍历、最短路径、最小生成树和网络流等问题的求解。
8. 什么是NP完全问题?NP完全问题是一类在多项式时间内无法求解的问题。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
for (i=l-L+1;i<=l;i++) for (j=l+1;j<=l+R;j++) { if (y[record[j]]-y[record[i]]<Min||-Min<y[record[j]]-y[record[i]]) { mi=lengthf(x[i],y[record[i]],x[j],y[record[j]]); if (mi<Min) { Min=mi; rem1=i; rem2=j; } } }
if (a>=b) return b;
else return a;
} ////////////////////////////对平面数组排序//////////////////////////// void sort(int A[]) {
int i,j; for (i=0;i<N;i++)
record[i]=i; for (j=1;j<N;j++) {
// cout<<"min="<<min<<endl; //cout<<"rem1="<<rem1<<endl<<"rem2="<<rem2<<endl;
}
} return Min; } /***********************************************************************/ //////////////////////////////////主函数/////////////////////////////////// int main() { //double a; randnum(); cout<<"***************************遍历法*************************"<<endl; exhaustion(); cout<<"***************************分治法*************************"<<endl; sort(x); divide(0,N-1); cout<<"元素组中最短距离为:"<<endl; cout<<"min="<<Min<<endl; return 0; }
//三个点时求最大值 return mlength; }
double divide(int left,int right)
{
if (right-left<=2)
{
Min=merge(left,right);
}
else
{
double l1,l2,mi;
//l1 记录划分区域后左半面最小距离,l2
记录右半面最小距离,min 为两者中较小者,m 为全部中的最小者
i=j; while (i>=0&&A[i]<A[i-1])
{ swap(A[i],A[i-1]); swap(record[i-1],record[i]); i--;
} } cout<<"排序后的元素数组:"<<endl; for (i=0;i<N;i++)
cout<<A[i]<<' '; cout<<endl; for (i=0;i<N;i++)
分治法是把一个大的问题划分成相似的小问题,采用递归的思想。找中线把 n 个元 素分成左右两部分元素分别求得两边的最短距离,然后取两者中的最小者记为 l,在中线两 边分别取 l 的距离,记录该距离范围内点的个数,中线左边有 L 个元素,右边有 R 个元素, 求左边元素到右边元素的距离看其是否小于之前记录的最短距离,小则记录下来,此时的右
实验四 求最近点对算法
1.算法设计思路:
设共有 n 个点,找其中距离最近的两点及其距离。 (1)蛮力法: 蛮力法的思路是把所有点之间距离比较找出中间最小的。先假设最短距离是第一个
元素和第二个元素的距离,然后求第一个元素与其后的(n-1)个元素各自的距离,若比之 前记录的最短距离小则记录当前值···求第 i 个元素与其后的(n-i)个元素各自的距离,记 录之前所得到的所有距离中的最小值,直到计算到第(n-1)个元素与第 n 个元素的距离, 此时记录的距离即为这 n 个元素中的最短距离。 (2)分治法:
边元素只取 y 值和左边元素 y 值距离小于 l 的(减少循环次数)。循环结束即可找到最小的 距离。
2.程序代码:
#include<iostream>
#include<cstdlib>
#include<ctime>
#include<cmath>
using std::cout;
using std::endl;
cout<<record[i]<<' '; cout<<end////////////////////穷举法找最小点对/////////////////////////////// double exhaustion() {
int i,j,k1,k2; double num; double length; num=10000; k1=k2=-1; for (j=0;j<N-1;j++) {
cout<<"(x1,y1)="<<'('<<x[k1]<<','<<y[k1]<<')'<<endl<<"(x2,y2)="<<'('<<x[k2]<<','<<y[k2]<<')' <<endl;
return num;
} ////////////////////////////////////分治法/////////////////////////////// /*************************************************************************/
double merge(int left,int right) {
double mlength; if (right==left)
mlength=10e-6; if (right==left+1)
mlength=lengthf(x[right],y[record[right]],x[left],y[record[left]]); if (right-left==2)
l1=divide(left,l);
l2=divide(l+1,right);
if (l1<l2)
{
Min=l1;
//cout<<"两半面最短距离是:"<<min;
} else {
Min=l2; //cout<<"两半面最短距离是:"<<min; } ///////////////////得到右半块元素数 R //cout<<"min="<<min<<endl; for (i=l+1;i<N;i++) { if (x[i]-x[l]<=Min)
3.实验数据及实验结果:
实验数据: 随机产生的五个点坐标分别为:(1,3),(4,2),(3,0),(2,0),(0,3) 实验结果:用蛮力法得到平面数组最短距离为:min=1
用分治法得到平面数组最短距离为:min=1
4.实验总结:
从本次试验中得到的领悟是:分治法事把问题分解成两个相似小问题,子问题和原 来的大问题解决方法一样所以可以用递归,分治法重要是找到递归出口,什么时候递归结束, 一般都有元素个数的限制。并且通过这次试验巩固了排序算法。
int rem1,rem2,l;
//记录获得最短距离对应的两个点
//int il,jl,ir,jr;
int i,j;
int R,L;
R=L=0;
//记录划分小区域后的左半块和右半
块个有多少元素
l1=l2=Min=100;
l=(right-left+1)/2-1;
//中线位置
///////////////////////////////////////////////////
for (i=j+1;i<N;i++) {
length=lengthf(x[i],y[i],x[j],y[j]); if (length<num) {
num=length; k1=i; k2=j; } } } cout<<"平面数组最短距离是:"<<endl; cout<<"min="<<num<<endl; cout<<"对应数组下标及点坐标为:"<<endl; cout<<"i="<<k1<<','<<k2<<endl;