算法复杂度

学习目标 sklearn中的Pipeline 偏差与方差 模型正则化之L1正则、L2正则 一、sklearn中的Pipeline 研究一个因变量与一个或多个自变量间多项式的回归分析方法，称为多项式回归（Polynomial Regression）。多项式回归是线性回归模型的一种，其回归函数关于回归系数是线性的。其中自变量x和因变量y之间的关系被建模为n次多项式。 如果自变量只有一个时，称为一元多项式回归；如果自变量有多个时，称为多元多项式回归。在一元回归分析中，如果变量y与自变量x的关系为非线性的，但是又找不到适当的函数曲线来拟合，则可以采用一元多项式回归。 由于任一函数都可以用多项式逼近，因此多项式回归有着广泛应用。 多项式回归的思路是：添加一个特征，即对于X中的每个数据进行平方。 import numpy as np import matplotlib.pyplot as plt x = np.random.uniform(-3, 3, size=100) X = x.reshape(-1, 1) y = 0.5 + x**2 + x + 2 + np.random.normal(0, 1, size=100) plt.scatter(x, y) plt.show() from sklearn.linear_model import LinearRegression lin

定义 什么是好的算法 利用递归运算，此时占用的空间较大，系统会崩掉 当n较大的时候，下面的方法运算更快 复杂度的渐进表达法 第一个表示f(n)是T(n)的一个上限 第二个表示f(n)是T(n)的一个下限 第三个表示f(n)既是T(n)的一个上限又是它的下限 注意：上限下限是无限个的（因为倍数，所以无限） 复杂度分析小窍门 来源： CSDN 作者： 海底捞肥牛 链接： https://blog.csdn.net/qq_45696288/article/details/104582135

这道题的算法是一个动态规划加单调队列优化时间复杂度，未优化的时间复杂度是O(nnm)，优化后是O(nm)。 构造一个单减队列，队头是起始点，新入队的元素是要跳跃到的树。 代码如下 # include <cstdio> # include <algorithm> # include <iostream> # include <cstring> # include <string> using namespace std ; int val [ 5002 ] , s [ 5002 ] , q [ 5002 ] ; //q里存放的是树的数 int dp [ 5002 ] [ 5002 ] ; //第一维保存猴子跳跃的次数，第二维保存第几棵树 int main ( ) { int n , m , d ; scanf ( "%d%d%d" , & n , & d , & m ) ; for ( int i = 1 ; i <= n ; i ++ ) { scanf ( "%d%d" , & val [ i ] , & s [ i ] ) ; } dp [ 0 ] [ 1 ] = val [ 1 ] ; int head , tail ; int ans = - 1000 ; for ( int i = 1 ; i <= m ; i ++ ) //两层循环都是枚举树！！！！但要维护m次跳跃次数

题目： 给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。 示例 1: 输入: 2 输出: [0,1,1] 示例 2: 输入: 5 输出: [0,1,1,2,1,2] 进阶: 给出时间复杂度为O(n*sizeof(integer))的解答非常容易。但你可以在线性时间O(n)内用一趟扫描做到吗？ 要求算法的空间复杂度为O(n)。 你能进一步完善解法吗？要求在C++或任何其他语言中不使用任何内置函数（如 C++ 中的 __builtin_popcount）来执行此操作。 代码： class Solution { public: vector<int> countBits(int num) { vector<int>ans; ans.insert(ans.end(), 0); for (int i = 1; i <= num; i++) { ans.insert(ans.end(), i % 2 + ans[i / 2]); } return ans; } }; 来源： CSDN 作者： csuzhucong 链接： https://blog.csdn.net/nameofcsdn/article/details/104220855

过程： 每次从未排序区间中找到最小的元素，将其放到已排序区间的末尾。 空间复杂度为O(1) ，是一种 原地排序算法 。选择排序的最好情况时间复杂度、最坏情况和平均情况 时间复杂度都为O(n 2 )。 选择排序是一种不稳定的排序算法。 示意图： import java . util . Arrays ; public class Main { public static void selectSort ( int [ ] arr ) { //i 代表无序区间的首元素下标 for ( int i = 0 ; i < arr . length - 1 ; i ++ ) { //下面有 j=i+1，所以 i 到 n-1 //查找最小值 int minIndex = i ; for ( int j = i + 1 ; j < arr . length ; j ++ ) { if ( arr [ j ] < arr [ minIndex ] ) { minIndex = j ; } } // 交换 arr[i] 与 arr[minIndex] int tmp = arr [ i ] ; arr [ i ] = arr [ minIndex ] ; arr [ minIndex ] = tmp ; } } public static void main ( String [ ] args ) {

一般方法   快速排序每趟都可以确定一个元素的最终位置，使得其左侧元素均小于temp，右侧元素均大于temp。   快速排序的算法复杂度为 O ( n l o g n ) O(nlogn) O ( n l o g n ) ，当需要排序的序列接近有序时，算法复杂度退化为 O ( n 2 ) O(n^2) O ( n 2 ) 。 代码如下： //对区间[left, right]进行划分 int Partition ( int A [ ] , int left , int right ) { int temp = A [ left ] ; //将A[left]存放至临时变量temp while ( left < right ) { while ( left < right && A [ right ] > temp ) right -- ; //反复左移right A [ left ] = A [ right ] ; while ( left < right && A [ left ] <= temp ) left ++ ; //反复右移left A [ right ] = A [ left ] ; } A [ left ] = temp ; //放置temp至left与right相遇的地方 return left ; //返回相遇的下标 } //快速排序

摘自： http://www.cnblogs.com/luluping/archive/2010/03/03/1677552.html 浅析求素数算法 注意: 如果没有特殊说明, 以下讨论的都是针对n为素数时的时间复杂度 1. 根据概念判断: 如果一个正整数只有两个因子, 1和p，则称p为素数. 代码: bool isPrime(int n) { if(n < 2) return false; for(int i = 2; i < n; ++i) if(n%i == 0) return false; return true; } 时间复杂度O(n). 2. 改进, 去掉偶数的判断 代码: bool isPrime(int n) { if(n < 2) return false; if(n == 2) return true; if(n%2==0) return false; for(int i = 3; i < n; i += 2) if(n%i == 0) return false; return true; } 时间复杂度O(n/2), 速度提高一倍. 3. 进一步减少判断的范围 定理: 如果n不是素数, 则n有满足1<d<=sqrt(n)的一个因子d. 证明: 如果n不是素数, 则由定义n有一个因子d满足1<d<n. 如果d大于sqrt(n), 则n/d是满足1<n/d<

浅析求素数算法 转载： http://www.linuxsir.org/bbs/showthread.php?t=278294 注意: 如果没有特殊说明, 以下讨论的都是针对n为素数时的时间复杂度 1. 根据概念判断: 如果一个正整数只有两个因子, 1和p，则称p为素数. 代码: 1 bool isPrime(int n)2 {3 if(n < 2) return false;4 for(int i = 2; i < n; ++i)5 if(n%i == 0) return false;6 return true;7 } 时间复杂度O(n). 2. 改进, 去掉偶数的判断 代码: bool isPrime(int n) { if(n < 2) return false; if(n == 2) return true; for(int i = 3; i < n; i += 2) if(n%i == 0) return false; return true;} 时间复杂度O(n/2), 速度提高一倍. 3. 进一步减少判断的范围 定理: 如果n不是素数, 则n有满足1<d<=sqrt(n)的一个因子d. 证明: 如果n不是素数, 则由定义n有一个因子d满足1<d<n. 如果d大于sqrt(n), 则n/d是满足1<n/d<=sqrt(n)的一个因子. 代码: bool isPrime

算法其他篇 目录： 1.1 设计一个O(n)复杂度的算法 1.2 在大量数中找到前10个最大的数 1.3 其他 1.1 设计一个O(n)复杂度的算法 返回顶部 　　1、问题：计数排序 　　　　　　现在有一个列表，列表中的数范围都在0到100之间，列表长度大约为100万，设计算法在O(n)时间复杂度内将列表进行排序 　　2、原理 　　　　　　1、 必须知道这些数中最大的数是多少 　　　　　　2、 然后生成一个长度等于最大数的列表 　　　　　　3、 循环li列表中所有的数，li中每出现一次这个数就在生成的count列表中加一 　　　　　　4、 这样就可以在count列表中的对应位置记录出列表li中所有数出现的次数 　　　　　　5、 然后在循环count，这个数出现几次就依次写几个到li列表中，就出现下面效果 def count_sort(li, max_num): count = [0 for i in range(max_num + 1)] for num in li: count[num] += 1 i = 0 print('count',count) for num,m in enumerate(count): #循环列表count，按顺序得到li中数出现次数 for j in range(m): #这个数出现多少次就在li中依次追加多少个 li[i] = num i += 1

思路： 怎么用时间复杂度最低的方式解决问题 官方题解： 我的题解： 1.解题中 ，我们用到了将寻找需要处理下标位置 现在数组中循环找出 再对其进行处理，这样会使怎个程序运行效率最高，时间复杂度最低 O（n） 。 2.在整个题解中 数组倒换 的方法最为巧妙，利用了 两个变量分别接受需要交换的首坐标和尾坐标，再循环分别递增 首 递减尾 判断 尾坐标是始终大于首坐标 ，直接遍历得到我们需要的结果。 来源： CSDN 作者： 与一人同游_ 链接： https://blog.csdn.net/Eye_Me/article/details/104051290