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]))

  

import randomimport 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] = 0def judge(inp):    n = 0for 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 = 0sign2 = 0x[n][0] = dot[i][0]            x[n][1] = dot[j][0]            y[n][0] = dot[i][1]            y[n][1] = dot[j][1]            n += 1for k in range(inp):                if k == j or k == i:                    continue                if a*dot[k][0]+b*dot[k][1] == c:                    sign1 += 1sign2 += 1if a*dot[k][0]+b*dot[k][1] > c:                    sign1 += 1if a*dot[k][0]+b*dot[k][1] < c:                    sign2 += 1if (sign1 == (inp - 2)) or (sign2 == (inp - 2)):                    dot[i][2] = 1dot[j][2] = 1cn.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]))

原文地址:https://www.cnblogs.com/whitehawk/p/10850368.html

时间: 2024-11-09 00:52:04

python动态演示蛮力法解决凸包问题的相关文章

(算法初步学习)蛮力法解决生成子集问题

关于蛮力法求生成子集问题 对于算法分析中的问题我已经不想对自己说什么了,到了大三了,竟然还是小白.对生成子集问题我研究了一下午,最后终于想通了.思路:   1.利用<math.h> 头文件中的pow(x,y)函数来求得2的n次方,作为外循环.2.然后写一个将10进制数转换为2进制数的函数(当然,C中有专门的转换进制的函数在<stdlib.h>中,但是,他转换下来  5不是0101而是101,这就导致需要分开判断,所以不用itoa函数).如下:conversation(int n,i

python动态演示动态规划解决矩阵连乘

矩阵连乘:给定n个矩阵:A1,A2,...,An,其中Ai与Ai+1是可乘的,i=1,2...,n-1.确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少.输入数据为矩阵个数和每个矩阵规模,输出结果为计算矩阵连乘积的计算次序和最少数乘次数. 若A是一个p*q的矩阵,B是一个q*r的矩阵,则其乘积C=AB是一个p*r的矩阵.数乘次数是p*q*r. 动态规划算法与分治法类似,其基本思想也就是将待求解的问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解,简

蛮力法-最近对和凸包问题

3.3.1 最近对问题 问题描述:要求找出一个包含n个点的集合中距离最近的两个点.原本思想是我们应该去比较两点之间的欧几里得距离,而实际上,我们可以去比较它们的平方,这样,我们就可以避免对平方根的近似求解. 代码实现: /** * 蛮力法解决最近对问题 * @author xiaofeig * @since 2015.9.16 * @param points 对象点集 * @return 返回包含最小对的下标 * */ public static int[] bruteForceClosestP

算法——蛮力法之最近对问题和凸包问题

上次的博客写到一半宿舍停电了....然而今天想起来补充完的时候发现博客园并没有自动保存哦,微笑. 首先来看最近对问题,最近对问题描述的就是在包含n个端的集合中找到距离最近的两个点,当然问题也可以定义在多维空间中,但是这里只是跟随书上的思路实现了二维情况下的最近对问题.假设所有讨论的点是以标准的笛卡尔坐标形式(x,y)给出的,那么在两个点Pi=(Xi,Yi)和Pj=(Xj,Yj)之间的距离是标准的欧几里得距离: d(Pi,Pj)=sqrt( (X1-X2)2+(Y1-Y2)2 ) 蛮力法的思路就是

关于算法--蛮力法篇--选择排序

近日开始学习算法,所看课本为清华大学出版社的<算法设计与分析基础>,对简单的数据结构进行了复习,已经学习了算法效率分析基础. 本篇开始对所学算法的思想进行实际JS编码,看学习的进度,每日写一篇学到的算法,以上为背景. 蛮力法是一种直接解决问题的方法,常常基于问题的描述和所涉及的概念定义:所谓的“力”,指的是计算机的计算能力. 优点是①可解决广阔的领域各种问题:②可以产生一些合理的算法:③实例不多时,可用一种能接受的速度求解:④可解决一些小规模问题实例:⑤可作为研究或教学目的,作为其他算法的准绳

Python 动态创建函数【转】

知乎上也有相似的问题 偶然碰到一个问题,初想是通过动态创建Python函数的方式来解决,于是调研了动态创建Python函数的方法. 定义lambda函数 在Python中定义lambda函数的写法很简单, func = lambda: "foobar" 可以认为lambda函数是最常用的一种方式. 定义局部函数 Python中函数可以在代码块中进行定义,比如decorator就是通过这种方式实现的, def decorator(func): def _(*args, **kwargs)

python 进程内存增长问题, 解决方法和工具

python 进程内存增长问题, 解决方法和工具 表现 解决方法 定位问题过程 gdb-python: 搞清楚python程序在做什么 准备gdb 接入gdb 查看线程 查看调用栈 coredump 其他命令 pyrasite: 连接进入python程序 psutil 查看python进程状态 guppy 取得内存使用的各种对象占用情况 无法回收的对象 不可回收对象的例子 ?? objgraph 查找循环引用 表现 运行环境: # uname -a Linux ** 3.10.0-327.el7

Python 动态类型

Python 动态类型 1.Python中,类型是在运行过程中自动决定的,并不需要提前在代码中声明. 2.所有变量必须在使用前明确的赋值,否则将会产生错误.#例:NameError: name 'a' is not defined 3.赋值语句 a=3 代表了:创建一个对象代表3:创建一个变量a:将变量与新的对象3相连.实际上是到对象内存空间的一个指针! 4.上面的第3条可翻译为:变量是一个系统表的元素,拥有指向对象的链接的空间:对象是分配的一块内存,有足够空间来表示他们所代表的值:引用是自动形

Python动态加载模块

需求:实现一个简单的pyton程序,接收两个参数:plugin_name, data,根据不同的plugin_name定位到不同的逻辑处理模块并进行输出. 实现方案: 使用python的库函数:load_source,将插件模块加载到一个dict中key为模块名称,value为类的实例,核心代码: def load_plugins(): global plugin_dict # 遍历插件目录加载所有py结尾的模块 for root, dirs, files in os.walk(module_p