描述：一群孩子做游戏，现在请你根据游戏得分来发糖果，要求如下：
给定一个数组 arrarr 代表得分数组，请返回最少需要多少糖果
描述：有 n 个活动即将举办，每个活动都有开始时间与活动的结束时间，第 i 个活动的开始时间是 starti ,第 i 个活动的结束时间是 endi ,举办某个活动就需要为该活动准备一个活动主持人。
一位活动主持人在同一时间只能参与一个活动。并且活动主持人需要全程参与活动，换句话说，一个主持人参与了第 i 个活动，那么拿薯该主持人在 (starti,endi) 这个时间段不能参与其他任何活动。求为了成功举办这 n 个活动，最少需要多少名主持人。
输入：
2,[[1,2],[2,3]]
返回值：
1
说明：
只需要一个主持人就能成功举办这两个活动
输入：
2,[[1,3],[2,4]]
返回值：
2
说明：
需要两个主持人才能成功举办这两个活动
描述：假设你有一个数组prices，长度为n，其中prices[i]是股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益
1.你可以买入一次股票和卖出一次股票，并非每天都可以蠢敏轮买入或卖出一次，总共只能买入带信和卖出一次，且买入必须在卖出的前面的某一天
2.如果不能获取到任何利润，请返回0
3.假设买入卖出均无手续费
数据范围： 0 <= n <= 10^5 , 0 <= val <= 10^4
要求：空间复杂度 O(1)，时间复杂度 O(n)
描述：假设你有一个数组prices，长度为n，其中prices[i]是某只股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益
描述：描述
假设你有一个数组prices，长度为n，其中prices[i]是某只股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益
这里的buy2以及profit2如何更新？
1.只有一个数出现奇数次，其它数出现偶数次
2.共有两个数出现奇数次，其它数目出现偶数次
#一个数&与自己的取反加1就是得到该数最右位置的1
eor&(~eor+1)
⑵ python中有哪些简单的算法
你好：
跟你详细说一下python的常用8大算法：
1、插入排序
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外(让数组多一个空间才有插入的位置)，而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
2、希尔排序
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
3、冒泡排序
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
4、快速排序
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
5、直接选择排序
基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
6、堆排序
堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
7、归并排序
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
8、基数排序
基数排序(radix sort)属于“分配式排序”(distribution sort)，又称“桶子法”(bucket sort)或bin sort，顾名思义，它是透过键值的部分资讯，将要排序的元素分配至某些“桶”中，借以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。
⑶ python求解线性规划问题，百度后发现了scipy模块，optimize，新手希望大神能写个实例，例子如下：
scipy做线性规划不是很方便，推荐用pulp来做，这个模块不属于python的内置模块，需要先安装，pip install pulp
from pulp import *
# 设置对象
prob = LpProblem('myProblem', LpMinimize)
# 设置三个变量，并设置变量最小取值
x1 = LpVariable('x1', 0)
x2 = LpVariable('x2', 0)
x3 = LpVariable('x3', 0)
x4 = LpVariable('x4')
# 载入目标函数，默认是求最小值，因此这次对原目标函数乘以-1
prob += 3*x1 - 4*x2 + 2*x3 -5*x4
# 载入约束变量
prob += 4*x1 - x2 + 2*x3 -x4 == -2
prob += x1 + x2 -x3 + 2*x4 <= 14
prob += -2*x1 + 3*x2 + x3 -x4 >= 2
# 求解
status = prob.solve()
# 显示结果
for i in prob.variables():
print(i.name + "=" + str(i.varValue))
计算结果为：
x1=0.0
x2=2.0
x3=4.0
x4=8.0
⑷ python非线性规划用什么模块
python非线性规划用什么模块本文使用SciPy的optimize模块来求解非线性规划问题，结合实际例子，引入非线性规划问题的求解算法及相应函数的调用。
本文提纲一维搜索／单变量优化问题
无约束多元优化问题
非线性最小二乘问题
约束优化问题
非线性规划问题的目标函数或约束条件是非线性的。本文使用SciPy的optimize模块来求解非线性规划问题。
目标函镇滚数和约束搏清条件是否连续光滑是非常重要的性质，这是因为如果光滑，则所有决策变量可微，多变量函数的偏导数组成的向量为梯度，梯度是指向目标函数增长最快的方向。将目标函数梯度作为搜索方向，对非线性规划问题的求解具有重要的意义。这些函数或其导数\梯度的不基旅前连续性给许多现有的非线性优化问题的求解带来了困难。在下文中，我们假设这些函数是连续且光滑的。
# Importing Moles
from scipy import optimize
import matplotlib.pyplot as plt
import numpy as np
import sympy
1、一维搜索／单变量优化问题(Univariate Optimization)
无约束非线性规划最简单的形式是一维搜索。一维搜索通常作为多维优化问题中的一部分出现，比如梯度下降法中每次最优迭代步长的估计。求解一维搜索常用的两类方法是函数逼近法和区间收缩法。其中函数逼近法是指用较简单的函数近似代替原来的函数，用近似函数的极小点来估计原函数的极小点，比如牛顿法；区间收缩法对于一个单谷函数通过迭代以不断缩小该区间的长度，当区间长度足够小时，可将该区间中的一点作为函数的极小点，比如黄金分割法。
e.g. 最小化一个单位体积的圆柱体的表面积。
r, h = sympy.symbols("r, h")
Area = 2 * sympy.pi * r**2 + 2 * sympy.pi * r * h
Volume = sympy.pi * r**2 * h
⑸ python中有哪些简单的算法
算法都是第三方库才有的
如果要自带的，只有排序了，是timsort
⑹ python解决jacob迭代法求解线性方程组
题主好. 经典的 Jacobi 迭代算法如下:
设 A = D - E, 则 x = D^{-1}*b + D^{-1}*E*x = C + T*x
可以参考如下代码(复制代码后请注意缩进):
import numpy as np
def linalg_solve_jacobi(A, b, x0, max_it, tol=1.0e-7):
# 判断 A, b 的维数是否正确
if A.shape[0]!=A.shape[1] or A.shape[0]!= b.shape[0]:
raise Exception('A must be square or A and b must be compatible!')
D = np.diag(A)
# 判断对角元素是否含零
if np.amin(np.absolute(D)) < 1e-14:
raise Exception('Diagonal elements of A must not be zeros!')
# 设置初始迭代步数为0
n = 0
#
# Jacobi 算法:
# 设 A = D - E, 则 x = D^{-1}*b + D^{-1}*E*x = C + T*x
#
invD = np.diag(1.0/D) # invD is inv(D)
C = np.dot(invD,b) # C is inv(D)*b
T = np.dot(invD, np.diag(D)-A) # T is inv(D)*E
while n < max_it:
x = C + np.dot(T, x0)
if np.linalg.norm(x-x0)<tol:
break
x0[:] = x
n+=1
# 如果超过最大迭代步数, 迭代失败
if n>max_it:
raise Exception('Failed to converge within {} steps!'.format(max_it))
# 成功, 返回
return x, n
if __name__ == "__main__":
A = np.array([[10, -1, 2, 0],[-1, 11, -1, 3],
[2, -1, 10, -1], [0, 3, -1, 8]], dtype=np.float64)
b = np.array([6, 25, -11, 15], dtype=np.float64)
x0 = np.array([0,0,0,0], dtype=np.float64)
max_it = 100
tol = 1.0e-7
x,n=linalg_solve_jacobi(A, b, x0, max_it, tol)
print(x,n)
⑺ python求解多解问题怎么让方程数量多于未知数值
目录
一、多元多次方程
1.1 定义
我们常见的方程组有一元一次方程组，比如x+3=5这种，很简单很好解。
二元一次方程组，即方程组中有两个未知数，未知数的最高次数为1.
二元二次方程组：方程组中有两个未知数，未知数的最高次数为2.。此类方程组均有公式解法或者成形的解法。
但是面临多元多次方程组，解法错综复杂，是数学家们研究的内容。为了更好的解决此类问题，我们可以用python来实现。
1.2 例子
多元多次方程组例如下面这种，三元二次方程组：
下面这种，二元二次方程组。
第二个方程组实在比较复杂，因此需要借助python。
二、python求解工具包
python求解方程组的工具包较多。例如：
numpy：numpy.linalg.solve 可以直接求解线性方程组，numpy是python非常常用的包，解的方程也较为初级。
scipy：from scipy.optimize import fsolve，可以求解非线性方程组，使用较为方便，但是解集并不完备，可能漏掉一下解(后文会给个例子)scipy可以用于数学、科学、工程领域的常用软件包,可以处理插值、积分、优化，相对较初级易用
sympy：此厅嫌工具包功能相对强大，支持符号计算、高精度计算、解方程、微积分、组合数学、离散数学、几何学、概率与统计、物理学等方面的功能。github地址：
https://github.com/sympy/sympy
sage，不支持位运算，z3约束求解器，等其他工具包，本文不详述，感兴趣的可以查找相应的内容。
本文详细讲述scipy以及sympy求解多次方程的方法。
三、scipy方法
3.1 使用scipy的铅春fsolve求解
我们只将求解方程的部分。
用fsolve相对初级，也相对简单易操作，代码较为简单，只用将方程的表达式写出运行即可。fsolve近似看作用最小二乘法求解。不够很强大，很多情况下解集不完备或者无法解出。
例如对于
，首先要定义相应的函数：
def solve_function(unsolved_value):
x,y,z=unsolved_value[0],unsolved_value[1],unsolved_value[2]
return [
x**2+y**2-10,
y**2+z**2-34,
x**2+z**2-26,
]
求解函数三个公式都为0时候的解，中括号内为初值[0, 0, 0]
solved=fsolve(solve_function,[0, 0, 0])
全部代码：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
"""
python解方程
"""
from scipy.optimize import fsolve
def solve_function(unsolved_value):
x,y,z=unsolved_value[0],unsolved_value[1],unsolved_value[2]
return [
x**2+y**2-10,
y**2+z**2-34,
x**2+z**2-26,
]
solved=fsolve(solve_function,[0, 0, 0])
print(solved)
print("Program done!")
"""
运行结果：
[-1. 3. 5.]
Program done!
"""
看出运行结果来看，此结果并非完备解集。因为x，y，z都是可正可负。例如1或者-1，3或者-3，5或者-5，但是此工具包只能解出一个解。
3.2 非完备解
显而易见，x**2-9=0的解为3或者-3
def solve_function(unsolved_value):
x=unsolved_value[0]
return [
x**2-9,
]
solved=fsolve(solve_function,[0])
但是程序只能得出一扮激手个结果3，但是得不到-3
3.3 非线性方程的解
最简单的sin(x)=0.5,则x可能为π/6或者 5π/6
#!/usr/bin/python
# -*- coding: UTF-8 -*-
"""
python解方程
"""
from scipy.optimize import fsolve
from math import sin,cos
def solve_function(unsolved_value):
x=unsolved_value[0]
return [
sin(x)-0.5
]
solved=fsolve(solve_function,[3.14])
print(solved)
solved=fsolve(solve_function,[0])
print(solved)
print("Program done!")
运行结果为：
[2.61799388]
[0.52359878]
Program done!
可以解出π/6或者 5π/6，中括号内为初始迭代的值。
3.4 无法求解
部分较难情况无法求解
#!/usr/bin/python
# -*- coding: UTF-8 -*-
"""
python解方程
"""
from scipy.optimize import fsolve
def solve_function(unsolved_value):
x,y=unsolved_value[0],unsolved_value[1]
return [
x*x+2*x*y,
2*x*y-2*y*y
]
solved=fsolve(solve_function,[6, -3])
print(solved)
print("Program done!")
无法求解会给出报错，和用最小二乘法迭代得到明显错误的解。
[1.64526700e-115 1.33665018e-115]
A:\python\python\lib\site-packages\scipy\optimize\minpack.py:162: RuntimeWarning: The number of calls to function has reached maxfev = 600.
Program done!
warnings.warn(msg, RuntimeWarning)
四、sympy工具包求解
没安装可以在teiminal中pip install sympy，此工具包涉及支持符号计算、高精度计算、模式匹配、绘图、解方程、微积分、组合数学、离散 数学、几何学、概率与统计、物理学等方面的功能。功能较为强大，解方程组时性能也较好。
4.1 二元一次方程组
较为简单，
from sympy import *
# 二元一次方程
x = Symbol('x')
y = Symbol('y')
solved_value=solve([2*x+y-1, x-2*y], [x, y])
print(solved_value)
此方法较为简单，但是相应的自变量应当写成符号的形式，x=Symbol('x')
求解后有分数解：
{x: 2/5, y: 1/5}
Program done!
4.2 多解
多解情况与复数解
例如，多个解的情况，sympy可以很好的进行求解
x = Symbol('x')
solved_value=solve([x**2-9], [x])
print(solved_value)
输出结果：
[(-3,), (3,)]
4.3 复数解
复数解也可以很好解出：
# 复数解
solved_value = solve([x ** 2 + 9], [x])
print(solved_value)
solved_value = solve([x ** 4 - 9], [x])
print(solved_value)
"""
运行结果：
[(-3*I,), (3*I,)]
[(-sqrt(3),), (sqrt(3),), (-sqrt(3)*I,), (sqrt(3)*I,)]
"""
复数解也能较好解出
4.4 非线性求解
比如三角函数：
程序均能较好解出
# 非线性解
solved_value = solve([sin(x) - 0.5], [x])
print(solved_value)
solved_value = solve([sin(x) - 1], [x])
print(solved_value)
"""
[(0.523598775598299,), (2.61799387799149,)]
[(pi/2,)]
"""
4.5 较为复杂的二元二次方程
此题较难，无论人来算，很难算出，用scipy工具包也迭代不出解。但是sympy强大的功能可以很好的解出此方程。
# 二元二次方程组
x = Symbol('x')
y= Symbol('y')
solved_value=solve([x**2+2*x*y-6,2*x*y-2*y**2+3], [x,y])
print(solved_value)
有四组实数解：
[(-(-3 + sqrt(13))*sqrt(sqrt(13)/2 + 2), -sqrt(sqrt(13)/2 + 2)),
((-3 + sqrt(13))*sqrt(sqrt(13)/2 + 2), sqrt(sqrt(13)/2 + 2)),
(-sqrt(2 - sqrt(13)/2)*(-sqrt(13) - 3), -sqrt(2 - sqrt(13)/2)),
(sqrt(2 - sqrt(13)/2)*(-sqrt(13) - 3), sqrt(2 - sqrt(13)/2))]
复杂的问题终于解出，有四组实数解！
五、全部代码
#!/usr/bin/python
# -*- coding: UTF-8 -*-
"""
python解方程
created by xingxinagrui on 2020.2.24
"""
from scipy.optimize import fsolve
from math import sin,cos
from sympy import *
# 1-4 scipy
# 5-7 sympy
part=7
if part==1:
# 求解非线性方程组
def solve_function(unsolved_value):
x=unsolved_value[0]
return [
sin(x)-0.5
]
solved=fsolve(solve_function,[3.14])
print(solved)
solved=fsolve(solve_function,[0])
print(solved)
if part==2:
# 求解三元二次方程组
def solve_function(unsolved_value):
x, y, z = unsolved_value[0], unsolved_value[1], unsolved_value[2]
return [
x ** 2 + y ** 2 - 10,
y ** 2 + z ** 2 - 34,
x ** 2 + z ** 2 - 26,
]
solved = fsolve(solve_function, [0, 0, 0])
print(solved)
if part==3:
#解的非完备性
def solve_function(unsolved_value):
x = unsolved_value[0]
return [
x ** 2 - 9,
]
solved = fsolve(solve_function, [0])
print(solved)
if part == 4:
# 较难无法求解
def solve_function(unsolved_value):
x, y = unsolved_value[0], unsolved_value[1]
return [
x * x + 2 * x * y,
2 * x * y - 2 * y * y
]
solved = fsolve(solve_function, [6, -3])
print(solved)
if part == 5:
# 二元一次方程
x = Symbol('x')
y = Symbol('y')
solved_value=solve([2*x+y-1, x-2*y], [x, y])
print(solved_value)
if part == 6:
# 多解情况
x = Symbol('x')
solved_value=solve([x**2-9], [x])
print(solved_value)
# 复数解
solved_value = solve([x ** 2 + 9], [x])
print(solved_value)
solved_value = solve([x ** 4 - 9], [x])
print(solved_value)
# 非线性解
solved_value = solve([sin(x) - 0.5], [x])
print(solved_value)
solved_value = solve([sin(x) - 1], [x])
print(solved_value)
if part == 7:
# 二元二次方程组
x = Symbol('x')
y= Symbol('y')
solved_value=solve([x**2+2*x*y-6,2*x*y-2*y**2+3], [x,y])
print(solved_value)
print("Program done!")
⑻ python的pulp库解决线性规划问题
战术决策问题，某战略轰炸机队指挥官得到了摧毁敌方坦克生产能力的命令. 根据情报, 敌方有四个生产坦克部件的工厂, 位于不同的地方. 只要破坏其中任一工厂的生产设施就可以有效地停止敌方坦克的生产. 根据分析, 执行该任务的最大因素是汽油短缺, 为此项任务只能提供48000加仑汽油.而对于任何一种轰炸机来说, 不论去轰炸哪一个工厂都必须有足够往返的燃料和100加仑备余燃料.该轰炸机队现有重型和中型两种轰炸机, 其燃油消耗量及数量见下表
编号 飞机类型 每千米耗油量 飞机驾数
1 重型 1/2 48
2 中型 1/3 32
各工厂距离空军基地的距离和摧毁目标的概率见下表
工厂 距离/千米 摧毁目标概率(重型/中型)
1 450 0.10 0.08
2 480 0.20 0.16
3 540 0.15 0.12
4 600 0.25 0.20
所以应该去2号工厂1驾重型和1驾中型机，去4号工厂45驾重型机和31驾中型机。
⑼ Python 算法
什么是算法
“算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。”
“在谈到算法时，我们不得不去了解一下什么是时间复杂度和空间复杂度这两个概念”
计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间,时间复杂度常用大O符号（大O符号（Big O notation）是用于描述函数渐进行为的数学符号。
空间复杂度：它是用来评估算法内存占用大小的一个式子。
Python 算法的几大重要特征
Python算法除了具有以上特征，还和时间和空间有关系，不同的算法可能用不同的时间、空间或效率来完成同样的任务，因此， 一个Python算法的优劣可以用空间复杂度与时间复杂度来衡量。
通过实例加深对算法的理解
如题所示：
要求x,y,z的1000以内取值满足x x+y y=z*z，同时x+y+z=1000,求解出所以x,y,z的组合情况？
求解过程如下
这里使用了一个waste_time方法作为装饰器来计算装饰过的方法的执行时间，这里有两种算法来求解这个问题
代码如下：
总结：
通过这个示例，对于同一个问题给出两种不同的算法，两种算法在执行过程中我增加了对程序执行时间的统计，通过时间上的对比发现两个算法的执行时间相差非常的大，如响应结果所示。
由此我们可以得出一个结论，就是实现不同的算法程序执行的时间可以反应出算法的效率，即算法有优劣之分，好的算法可以节约时间，提高效率，反之则不然。