python动态演示蛮力法解决凸包问题

最近开了算法课,但是我的算法着实不咋地,一直搞web和逆向,就没怎么编程。记录一下0.0

算法倒是不难实现,但是这个动态演示很烦,从纯粹的可视化小白,强行写完了,写完发现非常简单,只是自己不知道的函数太多了,哭了。。。。

蛮力法就不用解释了,通俗的说就是把所有可能试一遍。

凸包问题,就是将n个点中某几个点围成一个多边形,除了这n个点,其余的点都在这个多边形内。

核心算法其实就是一个行列式演变而来,后悔没学好线代。。。。。

参考:https://blog.csdn.net/u011001084/article/details/72768075

贴出我的代码:

import random
import matplotlib.pyplot as p

input = int(input('输入生成点的数量:'))
dot = [[0]*3 for i in range(input)]
x = [[0]*2 for a in range(int(input * (input - 1) / 2))]
y = [[0]*2 for b in range(int(input * (input - 1) / 2))]
fg = p.figure()
cn = fg.add_subplot(1, 1, 1)
cn.set_xlim(0, 1000)
cn.set_ylim(0, 1000)
p.ion()
for i in range(input):
    dot[i][0] = random.randrange(1000)
    dot[i][1] = random.randrange(1000)
    dot[i][2] = 0
def judge(inp):
    n = 0
    for i in range(inp):
        for j in range(i+1, inp):
            a = dot[j][1] - dot[i][1]
            b = dot[i][0] - dot[j][0]
            c = (dot[i][0] * dot[j][1]) - (dot[i][1] * dot[j][0])
            sign1 = 0
            sign2 = 0
            x[n][0] = dot[i][0]
            x[n][1] = dot[j][0]
            y[n][0] = dot[i][1]
            y[n][1] = dot[j][1]
            n += 1
            for k in range(inp):
                if k == j or k == i:
                    continue
                if a*dot[k][0]+b*dot[k][1] == c:
                    sign1 += 1
                    sign2 += 1
                if a*dot[k][0]+b*dot[k][1] > c:
                    sign1 += 1
                if a*dot[k][0]+b*dot[k][1] < c:
                    sign2 += 1
                if (sign1 == (inp - 2)) or (sign2 == (inp - 2)):
                    dot[i][2] = 1
                    dot[j][2] = 1
                    cn.scatter(dot[i][0], dot[i][1], color='g', marker='.')
                    cn.scatter(dot[j][0], dot[j][1], color='g', marker='.')
                    cn.plot(x[n-1], y[n-1], color='b')
            cn.scatter(dot[i][0], dot[i][1], color='g', marker='.')
            cn.scatter(dot[j][0], dot[j][1], color='g', marker='.')
            cn.plot(x[n-1], y[n-1], color='r')
            p.pause(0.1)
            cn.lines.pop()
judge(input)
print("凸包极点:")
for i in range(input):
    if dot[i][2] == 1:
        print((dot[i][0], dot[i][1]))
凸包问题可以使用蛮力解决,其基本思想是考虑将所有点都进行组合,找到一个能够包含所有点的凸多边形。 具体步骤如下: 1. 枚举所有点对,找到其中的一条直线分割点集为两个部分,每个部分内部都不包含其他点。 2. 对于两个部分,分别递归地执行第1步,直到只剩下一个点或者没有点。 3. 最后将所有的凸多边形合并成一个凸包。 下面是一个使用蛮力求解凸包的C语言实现代码示例: ```c #include <stdio.h> struct Point { int x; int y; }; int cross_product(struct Point a, struct Point b, struct Point c) { return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); } int is_left_turn(struct Point a, struct Point b, struct Point c) { return cross_product(a, b, c) > 0; } int is_right_turn(struct Point a, struct Point b, struct Point c) { return cross_product(a, b, c) < 0; } void find_upper_hull(struct Point *points, int n, struct Point *hull, int *hull_size) { hull[0] = points[0]; hull[1] = points[1]; *hull_size = 2; for (int i = 2; i < n; i++) { while (*hull_size > 1 && is_right_turn(hull[*hull_size - 2], hull[*hull_size - 1], points[i])) { *hull_size -= 1; } hull[*hull_size] = points[i]; *hull_size += 1; } } void find_lower_hull(struct Point *points, int n, struct Point *hull, int *hull_size) { hull[0] = points[n - 1]; hull[1] = points[n - 2]; *hull_size = 2; for (int i = n - 3; i >= 0; i--) { while (*hull_size > 1 && is_right_turn(hull[*hull_size - 2], hull[*hull_size - 1], points[i])) { *hull_size -= 1; } hull[*hull_size] = points[i]; *hull_size += 1; } } void find_convex_hull(struct Point *points, int n, struct Point *hull, int *hull_size) { struct Point upper_hull[n]; struct Point lower_hull[n]; find_upper_hull(points, n, upper_hull, hull_size); find_lower_hull(points, n, lower_hull, hull_size); for (int i = 0; i < *hull_size; i++) { hull[i] = upper_hull[i]; } for (int i = 1; i < *hull_size - 1; i++) { hull[*hull_size + i - 1] = lower_hull[i]; } *hull_size = 2 * (*hull_size - 1); } int main() { struct Point points[] = {{0, 3}, {1, 1}, {2, 2}, {4, 4}, {0, 0}, {1, 2}, {3, 1}, {3, 3}}; int n = sizeof(points) / sizeof(points[0]); struct Point hull[n]; int hull_size; find_convex_hull(points, n, hull, &hull_size); printf("Convex Hull:\n"); for (int i = 0; i < hull_size; i++) { printf("(%d, %d)\n", hull[i].x, hull[i].y); } return 0; } ``` 该代码实现了一个简单的凸包求解算,可以通过枚举所有点对,找到凸包的上下半部分,然后将它们合并成一个凸包。由于蛮力的时间复杂度为O(n^3),因此对于大规模的数据集,该算可能不太适合使用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值