python封装aes加密函数

1. 蛮力法

蛮力法的思路是枚举所有点对的距离，找到其中最小的距离。具体实现步骤如下：

1. 定义结构体表示点的坐标，包括x和y。同时定义一个函数用于计算两点之间的距离。
2. 生成100个随机点的坐标，并保存到一个数组中。
3. 用双重循环遍历所有点对，计算它们之间的距离，并记录下最小距离和对应的点对。
4. 输出最小距离和对应的点对。

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX 100

// 定义点的坐标结构体
typedef struct {
double x;
double y;
} Point;

// 计算两点之间的距离
double distance(Point p1, Point p2) {
double dx = p1.x - p2.x;
double dy = p1.y - p2.y;
return sqrt(dx * dx + dy * dy);
}

int main() {
Point points[MAX]; // 存储100个随机点的坐标
double min_distance = INFINITY; // 最小距离
int min_i, min_j; // 最小距离对应的点的下标

// 生成随机点的坐标
for (int i = 0; i < MAX; i++) {
points[i].x = (double) rand() / RAND_MAX;
points[i].y = (double) rand() / RAND_MAX;
}

// 枚举所有点对，找到最小距离
for (int i = 0; i < MAX; i++) {
for (int j = i + 1; j < MAX; j++) {
double d = distance(points[i], points[j]);
if (d < min_distance) {
min_distance = d;
min_i = i;
min_j = j;
}
}
}

// 输出最小距离和对应的点
printf("最小距离为：%lf\n", min_distance);
printf("对应的点为：(%lf, %lf) 和 (%lf, %lf)\n",
points[min_i].x, points[min_i].y,
points[min_j].x, points[min_j].y);

return 0;
}

2. 分治法

分治法的思路是将点集按照x坐标排序，然后将点集分成两个子集，对每个子集递归地求解最近点对，并找到跨越两个子集的最近点对。具体实现步骤如下：

1. 定义结构体表示点的坐标，包括x和y。同时定义一个函数用于计算两点之间的距离。另外还需定义一个函数用于按照x坐标排序。
2. 生成100个随机点的坐标，并保存到一个数组中。按照x坐标排序。
3. 分别对左右两个子集递归地求解最近点对。
4. 找到跨越两个子集的最近点对。
5. 输出最小距离和对应的点对。

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX 100

// 定义点的坐标结构体
typedef struct {
double x;
double y;
} Point;

// 计算两点之间的距离
double distance(Point p1, Point p2) {
double dx = p1.x - p2.x;
double dy = p1.y - p2.y;
return sqrt(dx * dx + dy * dy);
}

// 按照x坐标排序
int cmp(const void *a, const void *b) {
Point *p1 = (Point *) a;
Point *p2 = (Point *) b;
if (p1->x < p2->x) return -1;
else if (p1->x > p2->x) return 1;
else return 0;
}

// 求解跨越两个子集的最近点对
double closest_split_pair(Point *points, int left, int right, double d) {
double mid_x = (points[left].x + points[right].x) / 2; // 中间点的x坐标
double min_distance = d;
int i, j;
// 在[left, right]区间内找到所有横坐标距离中间点不超过d的点
for (i = left; i <= right; i++) {
if (points[i].x >= mid_x - d && points[i].x <= mid_x + d) {
for (j = i + 1; j <= right; j++) {
if (points[j].x >= mid_x - d && points[j].x <= mid_x + d) {
double distance_ij = distance(points[i], points[j]);
if (distance_ij < min_distance) {
min_distance = distance_ij;
}
}
}
}
}
return min_distance;
}

// 求解最近点对
double closest_pair(Point *points, int left, int right) {
if (left == right) return INFINITY; // 只有一个点，距离为无穷大
if (left + 1 == right) return distance(points[left], points[right]); // 只有两个点，直接计算距离

int mid = (left + right) / 2; // 计算中间点
double d1 = closest_pair(points, left, mid); // 递归求解左子集的最近点对
double d2 = closest_pair(points, mid + 1, right); // 递归求解右子集的最近点对
double d = d1 < d2 ? d1 : d2;

// 求解跨越两个子集的最近点对
double d3 = closest_split_pair(points, left, right, d);

return d < d3 ? d : d3;
}

int main() {
Point points[MAX]; // 存储100个随机点的坐标
double min_distance; // 最小距离

// 生成随机点的坐标
for (int i = 0; i < MAX; i++) {
points[i].x = (double) rand() / RAND_MAX;
points[i].y = (double) rand() / RAND_MAX;
}

// 按照x坐标排序
qsort(points, MAX, sizeof(Point), cmp);

// 求解最近点对
min_distance = closest_pair(points, 0, MAX - 1);

// 输出最小距离
printf("最小距离为：%lf\n", min_distance);

return 0;
}