算法设计与分析实验报告c++实现(最近点对问题、循环赛日程安排问题、排序问题、棋盘覆盖问题)

最新推荐文章于 2024-10-08 10:57:33 发布
最新推荐文章于 2024-10-08 10:57:33 发布
阅读量955 收藏 13
点赞数 14
分类专栏： 课程作业 文章标签： 算法 c++ 排序算法 贪心算法 动态规划 数据结构 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45741872/article/details/137675964
版权

一、实验目的

1．加深学生对分治法算法设计方法的基本思想、基本步骤、基本方法的理解与掌握；
2．提高学生利用课堂所学知识解决实际问题的能力；
3．提高学生综合应用所学知识解决实际问题的能力。

二、实验任务

1、最近对问题
设p1=(x1, y1), p2=(x2, y2), …, pn=(xn, yn)是平面上n个点构成的集合S，设计算法找出集合S中距离最近的点对。
（1）分别用蛮力法和分治法求解最近对问题；
（2）分析算法的时间性能，设计实验程序验证分析结论。
2、循环赛日程安排问题
设有n=2k个选手要进行网球循环赛，要求设计一个满足以下要求的比赛日程表：
（1）每个选手必须与其他n-1个选手各赛一次；
（2）每个选手一天只能赛一次。

3、排序问题
目前已知有几十种排序算法，请查找资料，并尽可能多地实现多种排序算法，并分析算法的时间复杂度。比较各种算法的优劣（冒泡排序、选择排序、插入排序、二分插入排序、希尔排序、归并排序、堆排序、快速排序等，需比较分析各种算法的时间复杂度及排序的稳定性）

4、用分治策略，设计解棋盘覆盖问题的一个简洁算法

三、实验设备及编程开发工具

编程开发工具：Microsoft Visual c++

四、实验过程设计（算法设计过程）

（一）最近对问题

1、基本算法思想
蛮力法：在蛮力法实现最近点对问题中，将问题简化：距离最近的点对可能多于一对，找出一对即可，另外只考虑二维平面中的情况。此处考虑到直接用公式计算其距离（欧几里得距离）。通过遍历所有点集，计算出每一个点对的距离，计算出最近的距离并输出。避免同一对点计算两次，只考虑i<j的点对(pi,pj)。
分治法：在利用分治法思想解决此问题时，首先考虑将最近对问题进行分治，设计其分治策略。将集合S分成两个子集S1和S2，根据平衡子问题原则，每个子集中的点数大致都为n/2。这样分治后，最近点对将会出现三种情况：在S1中，在S2中或者最近点对分别在集合S1和S2中。利用递归分析法分别计算前两种情况，第三种方法另外分析。求解出三类子情况后，再合并三类情况，比较分析后输出三者中最小的距离。
2、源程序

#include<iostream>
#include<stdio.h>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<windows.h>
using namespace std;
 
struct point {
    double x;
    double y;
}P[100];
double distance(point p1, point p2) {
    return sqrt((p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y));
}
bool cmp1(point p1, point p2) {
    return p1.x < p2.x;
}
bool cmp2(point p1, point p2) {
    return p1.y < p2.y;
}
//蛮力法
double get_min(int n)
{
    double min = sqrt((P[0].x - P[1].x)*(P[0].x - P[1].x) + (P[0].y - P[1].y)*(P[0].y - P[1].y));//设置第一个计算值最短距离
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            double t = sqrt((P[i].x - P[j].x)*(P[i].x - P[j].x) + (P[i].y - P[j].y)*(P[i].y - P[j].y));
            if (min>t)
                min = t;
        }//循环比较计算值
    }
    return min;
}
//分治法
double nearest_pair(point S[],int left,int right) {
    cout << left << " " << right << endl;
    if (right-left == 1) {
        return distance(S[right], S[left]);
    }
    if (right - left == 2) {
        double d1 = distance(S[right], S[left]);
        double d2 = distance(S[right], S[right + 1]);
        double d3 = distance(S[right + 1], S[left]);
        d2 = min(d1, d2);
        d3 = min(d2, d3);
        return d3;
    }
    int m = (right+left) / 2;
    double d1 = nearest_pair(S,left, m);
    double d2 = nearest_pair(S, m+1,right);
    //sort(S+right, S+left, cmp2);
    double d = min(d1, d2);
    int l = left, r = right;
    while (S[l].x < S[m].x - d && l <= right);
        l++;
    while (S[r].x > S[m].x + d && r>=left)
        r++;
    sort(S + 1, S + r + 1, cmp2);
    double d3;
    for (int i = l; i <= r; i++) {
        for (int j = i + 1; j <= r; j++) {
            if (S[j].y - S[i].y >= d) {
                break;
            }
            else {
                d3 = distance(S[i], S[j]);
                if (d3 < d)
                    d = d3;
            }
        }
    }
    return d;
}
int main()
{
    int n;
    cout << "Input n:";//设置平面中点的个数
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cout << "Input the " << i << "th number:";
        cin >> P[i].x >> P[i].y;
    }//逐个设置第i个点的坐标
    sort(P + 1, P + n+1, cmp1);
    for ( i = 1; i <= n; i++) {
        cout << P[i].x << " " << P[i].y << endl;
    }
    double m = get_min(n);
    cout <<"蛮力法结果："<< m << endl;//蛮力法输出结果
    double m2 = nearest_pair(P, 1, n);
    cout <<"分治法结果：" <<m2 << endl;//分治法输出结果
    system("pause");
    return 0;
}

（二）循环赛日程安排问题

1、基本算法思想
假设n位选手被顺序编号为1,2,…,n，比赛的日程表是一个n行n-1列的表格，i行j列的表格内容是第i号选手在第j天的比赛对手。
根据分而治之的原则，可从其中一半选手(2^(n-1位)的比赛日程，导出全体n位选手的日程，最终细分到只有两位选手的比赛日程出发。
2、源程序

#include<stdio.h>
#include<math.h>
#define N 50
void GameTable(int k,int array[][N]);
void print(int k,int array[][N]);         //输出二维数组 
main()
{
    int k;
    int array[N][N];
    printf("参赛选手的人数为n（n=2^k），请输入k 的值：");
    do
    {
         scanf("%d",&k);
        if(k>0)
        {
            GameTable(k,array);
            print(k,array);
        }
        else
          printf("您输入的数据有误,请重新输入"); 
    }while(k!=0);//排除输入错误k值

}
void GameTable(int k,int array[][N])//数组下标从1开始
{
    int i,j,s,t;
    int n=1;
    for(i=1;i<=k;i++)
        n*=2;                       //求总人数
    for(i=1;i<=n;i++)
        array[1][i]=i;                  //第一行排1-8
    int m=1;                          //用来控制每一次填表时i行j列的起始填充位置
    for(s=1;s<=k;s++)                 //s指对称赋值的总循环次数，即分成几大步进行制作日程表
    {
        n=n/2;
        for(t=1;t<=n;t++)              //t指明内部对称赋值的循环次数
            for(i=m+1;i<=2*m;i++)
                for(j=m+1;j<=2*m;j++)
                {
                    array[i][j+(t-1)*m*2]=array[i-m][j+(t-1)*m*2-m];       //右上角等于左上角的值
                    array[i][j+(t-1)*m*2-m]=array[i-m][j+(t-1)*m*2];       //左下角等于右上角的值
                }
        m*=2;
    }
    
}
void print(int k,int array[][N])
{
    int i,j;
    int num=pow(2,k);
    printf("%d人的循环赛日程表如下：\n",num);
    for(i=1;i<=num;i++)                           //输出二维数组 
    {
        for(j=1;j<=num;j++)
        {
            printf("%d\t",array[i][j]);
        }
         printf("\n");
    }
}

（三）排序问题

（1）直接插入排序

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

void InsertSort(int a[], int n)
{
	for(int i= 1; i<n; i++){
		if(a[i] < a[i-1]){//若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入
			int j= i-1;	
			int x = a[i];		 //复制为哨兵，即存储待排序元素
			a[i] = a[i-1];           //先后移一个元素
			while(x < a[j]){	 //查找在有序表的插入位置
				a[j+1] = a[j];
				j--;		 //元素后移
			}
			a[j+1] = x;		 //插入到正确位置
		}
		print(a,n,i);			//打印每趟排序的结果 
	}
}

（2）希尔排序

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

void ShellInsertSort(int a[], int n, int dk)
{
	for(int i= dk; i<n; ++i){
		if(a[i] < a[i-dk]){			//若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入
			int j = i-dk;	
			int x = a[i];			//复制为哨兵，即存储待排序元素
			a[i] = a[i-dk];			//首先后移一个元素
			while(x < a[j]){		//查找在有序表的插入位置
				a[j+dk] = a[j];
				j -= dk;			 //元素后移
			}
			a[j+dk] = x;			//插入到正确位置
		}
		print(a, n,i );
	}
	
}
 
/**
 * 先按增量d（n/2,n为要排序数的个数进行希尔排序
 *
 */
void shellSort(int a[], int n){
 
	int dk = n/2;
	while( dk >= 1  ){
		ShellInsertSort(a, n, dk);
		dk = dk/2;
	}
}

（3）简单选择排序

int SelectMinKey(int a[], int n, int i)
{
	int k = i;
	for(int j=i+1 ;j< n; ++j) {
		if(a[k] > a[j]) k = j;
	}
	return k;
}
 
/**
 * 选择排序
 *
 */
void selectSort(int a[], int n){
	int key, tmp;
	for(int i = 0; i< n; ++i) {
		key = SelectMinKey(a, n,i);           //选择最小的元素
		if(key != i){
			tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换
		}
		print(a,  n , i);
	}
}

（4）冒泡排序

两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

void BubbleSort(int *p, int length)
{
    for (int i = 0; i < length-1; i++)
    {
        for (int j =length-1; j>=i;j--)
        {
            if (p[j-1] > p[j])
            {
                swap(p[j-1], p[j]);
            }
        }
    }
}

（5）堆排序

堆排序的基本思想（利用堆，如大顶堆进行排序）：将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将它与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余n-1个序列重新构造成一个堆，这样就会得到n个元素的次小值。如此反复执行，便能得到一个有序序列。

//构造最大堆void MaxHeapFixDown(int *p, int i, int length) {
    int j = 2 * i + 1;
    int temp = p[i];
    while (j<length) {
        if (j + 1<length && p[j]<p[j + 1])
            ++j;
        if (temp>p[j])
            break;
        else {
            p[i] = p[j];
            i = j;
            j = 2 * i + 1;
        }
    }
    p[i] = temp;
}
//堆排序void HeapSort(int *p, int length) {
    for (int i = length / 2 - 1; i >= 0; i--)
    {
        MaxHeapFixDown(p, i, length);
    }
    for (int i = length - 1; i >= 1; i--)
    {
        swap(p[i], p[0]);
        MaxHeapFixDown(p, 0, i);
        cout << "i的值：" << i << " 排序：";
        ergodic(p, 9);
    }
}

（6）归并排序

归并排序就是利用归并思想实现的排序方法。原理：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列长度为1，然后再两两归并，得到[n/2]个长度为2或1的有序子序列；再两两归并….，如此重复，直到的一个长度为n的有序序列为止，称为2路归并排序。

//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]
void Merge(ElemType *r,ElemType *rf, int i, int m, int n)
{
	int j,k;
	for(j=m+1,k=i; i<=m && j <=n ; ++k){
		if(r[j] < r[i]) rf[k] = r[j++];
		else rf[k] = r[i++];
	}
	while(i <= m)  rf[k++] = r[i++];
	while(j <= n)  rf[k++] = r[j++];
}

void MergeSort(ElemType *r, ElemType *rf, int lenght)
{ 
	int len = 1;
	ElemType *q = r ;
	ElemType *tmp ;
	while(len < lenght) {
		int s = len;
		len = 2 * s ;
		int i = 0;
		while(i+ len <lenght){
			Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的两个子表合并
			i = i+ len;
		}
		if(i + s < lenght){
			Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的两个子表合并
		}
		tmp = q; q = rf; rf = tmp; //交换q,rf，以保证下一趟归并时，仍从q 归并到rf
	}
}

（7）快速排序

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序

void swap(int *a, int *b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
int partition(int a[], int low, int high)
{
	int privotKey = a[low];								//基准元素
	while(low < high){								    //从表的两端交替地向中间扫描
		while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端
		swap(&a[low], &a[high]);
		while(low < high  && a[low] <= privotKey ) ++low;
		swap(&a[low], &a[high]);
	}
	print(a,10);
	return low;
}
void quickSort(int a[], int low, int high){
	if(low < high){
		int privotLoc = partition(a,  low,  high);  //将表一分为二
		quickSort(a,  low,  privotLoc -1);			//递归对低子表递归排序
		quickSort(a,   privotLoc + 1, high);		//递归对高子表递归排序
	}
}

（四）棋盘覆盖问题

1、基本算法原理
当k>0时，将2k×2k棋盘分割为4个2k-1×2k-1 子棋盘(a)所示。特殊方格必位于4个较小子棋盘之一中，其余3个子棋盘中无特殊方格。为了将这3个无特殊方格的子棋盘转化为特殊棋盘，可以用一个L型骨牌覆盖这3个较小棋盘的会合处，从而将原问题转化为4个较小规模的棋盘覆盖问题。递归地使用这种分割，直至棋盘简化为棋盘1×1
2、源代码

//棋盘覆盖问题
/*
(tr，tc)是棋盘左上角的方格坐标
(dr,dc)是特殊方格所在的坐标
size是棋盘的行数和列数
*/
#include<iostream>
using namespace std;
int board[1025][1025];
static int tile = 1;
void ChessBoard(int tr,int tc,int dr,int dc,int size)
{
	if(size==1) 
		return ;//递归边界
	int t=tile++;//L型骨牌号
	int s=size/2;//分割棋盘
	//覆盖左上角子棋盘
	if(dr<tr+s && dc<tc+s)
		ChessBoard(tr,tc,dr,dc,s);//特殊方格在此棋盘中
	else //此棋盘中无特殊方格，用t号L型骨牌覆盖右下角
	{
		board[tr+s-1][tc+s-1]=t;
		//覆盖其余方格
		ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
	}
	//覆盖右上角子棋盘
	if(dr<tr+s && dc>=tc+s)
		ChessBoard(tr,tc+s,dr,dc,s);//特殊方格在此棋盘中
	else //此棋盘中无特殊方格，用t号L型骨牌覆盖左下角
	{
		board[tr+s-1][tc+s]=t;
		//覆盖其余方格
		ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
	}
	//覆盖左下角子棋盘
	if(dr>=tr+s && dc<tc+s)//特殊方格在此棋盘中
		ChessBoard(tr+s,tc,dr,dc,s);
	else //此棋盘中无特殊方格，用t号L型骨牌覆盖右上角
	{
		board[tr+s][tc+s-1]=t;
		//覆盖其余方格
		ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
	}
	//覆盖右下角子棋盘
	if(dr>=tr+s && dc>=tc+s)//特殊方格在此棋盘中
		ChessBoard(tr+s,tc+s,dr,dc,s);
	else //此棋盘中无特殊方格，用t号L型骨牌覆盖左上角
	{
		board[tr+s][tc+s]=t;
		//覆盖其余方格
		ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
	}
}
int main()
{
	int i,j;
	int k;//棋盘大小为2^k
	cout<<"棋盘大小为2^k,请输入k的值：";
	while(cin>>k)
	{
		int size = 1<<k;
		int x,y;//x,y为特殊方格的坐标
		cout<<"请输入特殊方格的坐标：";
		cin>>x>>y;
		board[x][y]=0;
		ChessBoard(0, 0, x, y, size);
		for(i=0; i<size; i++)
		{
			for(j = 0; j < size; j++)
				cout<< board[i][j]<<"\t";
				cout<<"\n";
		}
	}
return 0;
}

五、实验结果及算法复杂度分析
（一）最近对问题
1、实验结果

img

2、时间复杂度
蛮力法：O(n^2)
分治法:O(nlog2n)
（二）循环赛日程安排问题
1、实验结果

img

2、时间复杂度
时间复杂度：O(2^k * 2^k)

（三）排序问题
1、实验结果

1、直接插入排序

img

2、 希尔排序

img

3、简单选择排序

img

4、冒泡排序

img

5、 堆排序

img

7、快速排

img

2、时间复杂度
1、直接插入排序时间复杂度：O（n^2);
2、 希尔排序时间复杂度：O(n^2);
3、简单选择排序时间复杂度：O（n^2);
4、冒泡排序时间复杂度：O(n^2);
5、 堆排序时间复杂度：O(nlog2n);
6、 归并排序时间复杂度：O（nlog n);
7、快速排序时间复杂度：0（n^2）。

（四）棋盘覆盖问题
1、实验结果

img

2、时间复杂度
最坏时间复杂度：O(4^k)

实验小结（包括问题和解决方法、心得体会等）

本次实验的中心思想就是分治法，在课堂教学中老师就对分治法进行了比较深刻的讲解，再加上在网上百度就对分治法有了比较清楚的认识，字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。在通过实验的四道题目的实践，相信自己对分治法已经足够掌握了。

温柔说给风
关注
专栏目录
循环赛日程表问题（分治算法）
lhn的博客
12-07 3819
循环赛日程表问题（分治算法） 设有n=2kn=2^kn=2k个运动员要进行网球循环赛。现要设计一个满足以下要求的比赛日程表： (1)每个选手必须与其他n−1n-1n−1个选手各赛一次； (2)每个选手一天只能参赛一次； (3)循环赛在n−1n-1n−1天内结束 按此要求将比赛日程表设计成有nnn行和n−1n-1n−1列的一个表。在表中的第iii行，第jjj列处填入第iii个选手在第jjj天所遇到的选手。 题图来自：https://blog.csdn.net/weixin_44469806/article/
算法设计与分析 —— 排列问题
starter_____的博客
10-14 5798
排列问题 设计一个递归算法生成n个元素r1,r2,...,rn{r_1,r_2,...,r_n}r1​,r2​,...,rn​的全排列 设R=r1,r2,...,rnR={r_1,r_2,...,r_n}R=r1​,r2​,...,rn​是要进行排列的n个元素，Ri=R−riR_i=R-{r_i}Ri​=R−ri​。 集合XXX中元素的全排列记为perm(X)perm(X)perm(X) (ri...
算法设计与分析_课程报告.pdf
04-23
求以下两个基因序列的最长公共子序列，论述过程并完成论文。
算法设计与分析报告
awang50683的博客
11-02 589
算法分析与设计论文 以大学生程序设计竞赛为例 姓名：于港添 学 号：2015338 专 业：信息与计算科学 学 校：山东农业大学 授课老师：费玉奎 前言： 这门课程主要讲了贪心、递归、回溯、分支定界、动态规划等几种算法。 在进行学习之前有做过相关题目，所以在听课的时候感觉好理解了许多。没学这门...
最近点对问题 分治法 C++实现
最新发布
SnowLightning的博客
10-08 486
最近点对问题的分治法实现（C++）
算法设计与分析 实验报告
sunjiangangok的博客
04-10 8233
算法设计与分析实验报告题目一：矩阵相乘题目二：最长公共子序列题目一：矩阵相乘一．问题描述给定n个矩阵｛A1，A2，... ，An｝，其中这n个矩阵是可相乘的，i＝1，2，...，n-1。算出这n个矩阵的相乘积A1A2 。。。An。补充：如果两个矩阵A和B是可相乘的，那么A的列数要和B的行数是相同的，否则，这两个矩阵是不可相乘的。它们的相乘结果矩阵C的行数是A的行数，而列数是B的列数。二．问题分析由
算法设计与分析实验报告c++实现(矩阵链相乘问题、投资问题、背包问题、TSP问题、数字三角形)
Obliviate的博客
04-12 867
1.矩阵链相乘问题、 2.投资问题、 3.背包问题、4、TSP问题 旅行家要旅行n个城市，要求经历各个城市且仅经历一次，然后回到出发城市，并要求所走的路程最短。 5、数字三角形 问题描述：在上面的数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。
算法设计与分析（一）
Maple_Lai的博客
09-09 804
890.Question You have a list of words and a pattern, and you want to know which words in words matches the pattern. A word matches the pattern if there exists a permutation of letters p so that afte...
C++实现算法设计与分析课后习题详解
以上章节中涉及的知识点是算法设计与分析课程的核心内容，通过C++代码的编写实践，学生能够更直观地理解各种算法的设计思想和解决问题的方法，对于培养逻辑思维和编程能力具有重要作用。掌握这些知识点对于计算机...
算法设计技巧与分析
04-26
《算法设计技巧与分析》涵盖了绝大多数算法设计中的一般技术，在表达每一种技术时，阐述它的应用背景，注意用与其他技术比较的方法说明它的特征，并提供大量实际问题的例子。《算法设计技巧与分析》同时也强调了对每...
算法分析：求最近点对问题（c++）
热门推荐
blowfire123的博客
11-18 1万+
算法分析：求最近点对问题（c++）1、 准备部分： 对于最近点问题，需要将问题代码化，所以要先创建一个点类，来使得计算使用时候更加方面，class Points //点类 { public: float x; float y; };因为会多次计算距离，需要一个计算两点之间距离的函数。float Distance(Points p1,Points p2)//求
算法设计与分析实验报告
11-30
算法设计与分析实验报告，全文由本人使用c++撰写，内容涵盖重要的基本算法，贪心、动态规划、分治、回溯等，结合实际问题分析来讲解算法的实现机理
手眼标定算法(AX=XB)测试报告1
08-08
手眼标定算法(AX=XB)测试报告1
算法对比分析报告.docx
08-18
光流法相关，算法对比分析报告。详细分析算法流程，结果差异
C++版本的BSO算法测试报告
03-06
我们将已有的matlab原创代码作为基准，详细地对没有优化的C++代码做了静态检测。选取了两个多峰与单峰代表性的Benchmark Functions来评估原创与变种两个BSO版本的代码。希望在学术界起到抛砖引玉的作用，同时在工业界也鼓励方便同仁们使用。
求最近点对算法——C++
狒狒不会编程
11-29 8367
题目: 给定的二维平面上有n个点，找其中的一对点，使得在n个点的所有点对中，该点对的距离最小； 算法设计： （1）蛮力法：计算出所有点对的距离，由此找到距离最小的点对。本题暂不考虑。 （2）分治法：将平面上的点集S按x坐标排序后，若只有1个点，则返回；若有两个点，则直接计算两点距离为最近距离；若有三个点，则两两计算出距离，得到最近距离。 若大于三个点，则将其线性分割成大小大致相等的2个子...
算法实验报告
weixin_46210259的博客
12-28 3363
算法实验报告 贪心算法 贪心算法概述 算法原理 贪心算法总是做出当前最好的选择，它期望通过局部最优选择从而得到全局最优的解决 方案。贪心算法的基本思路如下： 1：建立数学模型来描述问题。 2：把求解的问题分成若干个子问题。 3：对每一子问题求解，得到子问题的局部最优解。 4：把子问题的解局部最优解合成原来解问题的一个解。 基本思想 贪心法是一种解决最优问题的策略。它是从问题的初始解出发，按照当前最佳的选择， 把问题归纳为更小的相似的子问题，并使子问题最优，再由子问题来推导出全局最优解。使 用贪
算法程序设计实验报告
weixin_42418315的博客
07-17 2129
题目1：设A是n个非0实数构成的数组，设计一个算法重新排列数组中的数，使得负数都排在正数前面，要求用多种算法实现，并保证至少算法中有一种算法使用O(n)的时间和O(1)的空间。 题目2：给定n个不同数的数组S和正整数i，i≤n1/2，求S中最大的i个数，并且按照从大到小的次序输出。用至少3种算法来实现，并分析其时间复杂度。 题目3：求两个序列的最长公共子序列。 题目4：最大子段和问题，用至少三种方法求解，并比较它们的复杂度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

温柔说给风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值