408数据结构算法题目

408数据结构算法题目

一、2020-41

1.1 题目描述

2020-41 41.(13分）

定义三元组（a,b,c)(a,b,c均为正数）的距离D=|a-b|+|b-c|+|c-a|。 给定3个非空整数集合S1、S2和S3,按升序分别存储在3个数组中。请设计一个尽可能高效的算法 计算并输出所有可能的三元组（a,b,c)(a )中的最小距离。 例如S1={1,0,9},S2={-25,-10,10,11},S3={2,9,17,30,41},则最小距离为2,相应的三元组为（9,10,9)。

要求：

(1)给出算法的基本设计思想。

(2)根据设计思想，采用C或C+语言描述算法，关键之处给出注释。

(3)说明你所设计算法的时间复杂度和空间复杂度。

1.2 分析

简要分析一下：

三元组的最小距离即三个元素最大值和最小值差值的两倍，三路归并求最小值。

所以说，三元组中的距离只跟相距最大的两点有关。

所以说，我们想要获取到距离最短，那么改动b的位置是没有用的，甚至会让它距离更远（当b移动到[ a , c ] [a,c][a,c]外面以后）

所以我们只能移动a和c

但是由题目可以知道，三个数组中的数据都是按升序排序的，那么这就成为我们优化时间复杂度的一个突破口

都是升序排序——对应到上面那张图就是：所有点只能从左向右移动！

那么在这一限制条件下，我们向右移动c肯定不是一个明智的想法，因为这只会让距离越来越大

那么b不能移动，c也不能移动，那我们只能移动a了，其实想一想，移动a确实可能能让距离更短

其实这道题我们可以想象一下，我们现在有一根橡皮筋，那么距离其实就是固定了橡皮筋a，c以后橡皮筋的长度，而我们要做的就是找出什么时候橡皮筋最松

我们只能向右移动a，但是也有可能a移动太过了，比如超过了b，或者甚至超过了c，那么我们可以给它重新标个号，从左到右重新标为a,b,c

所以说到最后，其实这就变成了一道贪心题，我们不断尝试向右移动最小的那个点，看看能否让距离变短，不能就继续

那我们对比一下暴力求解的算法？

暴力求解时，我们会先固定i,j,然后一个个尝试k（i , j , k 是数组A，B，C的下标,A [ i ] , B [ j ] , C [ k ] 是上面所说的变换的a,b,c），但是我们会发现，无论怎么尝试，都只有当A [ i ] ≤ C [ k ] ≤ B [ j ] 时，才是当前状态（指当前固定好的i，j）的最小值，我们假设A [ i ] ≤ C [ m . . . n ] ≤ B [ j ] ，那么m，n里面的比较是毫无意义的，因为我们知道它一定会是最小距离，而我们说了，我们是从左向右遍历序列的，所以我们很清楚，当k遍历到m时，再往后已经没有意义的，所以我们其实已经可以跳出循环了，当然，在固定i,k或者j,k时也是如此，所以我们不如使用三指针，让他们选一个最小的值，让其指针往右走，这才会造成真正我们需要的不同的状态，而不是那些越往后距离越大或者往后也没有变化的状态（这些状态是冗余的，没必要）

简而言之，只让最小的那个值往右走，这才会出现我们需要的尽可能小的状态！！！在这些状态中找最小值才是有效的。

1.3 代码

1.3.1 暴力美学

//
// Created by cai4 on 2023/9/15.
//
/**
 * 2020-41 41.(13分）定义三元组（a,b,c)(a,b,c均为正数）的距离D=|a-b|+|b-c|+|c-a|。
 * 给定3个非空整数集合S1、S2和S3,按升序分别存储在3个数组中。请设计一个尽可能高效的算法
 * 计算并输出所有可能的三元组（a,b,c)(a)中的最小距离。
 * 例如S1={1,0,9},S2={-25,-10,10,11},S3={2,9,17,30,41},则最小距离为2,相应的三元组为（9,10,9)。
 * 要求：(1)给出算法的基本设计思想。
 * (2)根据设计思想，采用C或C+语言描述算法，关键之处给出注释。
 * (3)说明你所设计算法的时间复杂度和空间复杂度。
 */

#include
#include
#define	INT_MAX 0x7fffffff

int abs(int a) //求绝对值
{
	if(a<0)
		return -a;
	return a;
}

int GetMinDistance(int a[],int aa,int b[],int bb,int c[],int cc) { //计算距离
    int min= abs(a[0] - b[0]) + abs(b[0] - c[0]) + abs(c[0] - a[0]);;
    for(int i=0;i<aa;i++) {
        for(int j=0;j<bb;j++) {
            for(int k=0;k<cc;k++) {
                int d=0,add=0; //d用于记录距离，add记录每次要加的数值
                d = abs(a[i]-b[j])+abs(b[j]-c[k])+ abs(c[k]-a[i]);
                printf("%d %d %d =%d\n",a[i],b[j],c[k],d); //输出三元组以及距离
                if(min>d){ //如果出现更小的距离，进行替换
                    min=d;
                }
        }
    }
    }
    return min;
}


int main()
{
	int a[3]={-1,0,9};
	int b[4]={-25,-10,10,11};
	int c[5]={2,9,17,30,41};
    printf("最小距离为:%d\n",GetMinDistance(a,3,b,4,c,5));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

• 空间复杂度为 O(1)
• 时间复杂度为O(n^3)

1.3.2 贪心

//
// Created by cai4 on 2023/9/15.
//
/**
 * 2020-41 41.(13分）定义三元组（a,b,c)(a,b,c均为正数）的距离D=|a-b|+|b-c|+|c-a|。
 * 给定3个非空整数集合S1、S2和S3,按升序分别存储在3个数组中。请设计一个尽可能高效的算法
 * 计算并输出所有可能的三元组（a,b,c)(a)中的最小距离。
 * 例如S1={1,0,9},S2={-25,-10,10,11},S3={2,9,17,30,41},则最小距离为2,相应的三元组为（9,10,9)。
 * 要求：(1)给出算法的基本设计思想。
 * (2)根据设计思想，采用C或C+语言描述算法，关键之处给出注释。
 * (3)说明你所设计算法的时间复杂度和空间复杂度。
 */
#include                                                                             
#include                                                                           
#define	INT_MAX 0x7fffffff                                                                   
int abs(int a) //求绝对值                                                                    
{                                                                                             
	if(a<0)                                                                                 
		return -a;                                                                           
	return a;                                                                               
}                                                                                             
bool compare(int a,int b,int c) // a是否为最小值                                               
{                                                                                             
	if(a<=b&&a<=c)                                                                           
		return true;                                                                         
	else                                                                                     
		return false;                                                                       
}                                                                                             
int minDistance(int a[],int n,int b[],int m,int c[],int p) // 计算目标函数的最小值             
{                                                                                             
	int Dmin = INT_MAX;                                                                     
	int D,i=0,j=0,k=0;                                                                       
	while(i<n&&j<m&&k<p&&Dmin>0)                                                             
	{                                                                                       
		D=abs(a[i]-b[j])+abs(b[j]-c[k])+abs(c[k]-a[i]);                                     
		if(D<Dmin) Dmin=D;                                                                   
		if(compare(a[i],b[j],c[k]))++i;                                                     
		else if(compare(b[j],a[i],c[k]))++j;                                                 
		else                                                                                 
			++k;
	}                                                                                       
	return Dmin;                                                                             
}                                                                                                  
int main()                                                                                   
{                                                                                             
	int a[3]={-1,0,9};                                                                       
	int b[4]={-25,-10,10,11};                                                               
	int c[5]={2,9,17,30,41};                                                                 
	printf("最小距离为:%d\n",minDistance(a,3,b,4,c,5));                                       
}                                                                                            
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

• 时间复杂度：O(n)
• 空间复杂度：O(1)