小小小草儿的博客哟

#include <iostream>using namespace std;struct Node { int left, right; int father;}node[1000];bool Judge(int a, int b) { if(node[b].left >= node[a].right || node[b].right &lt...

在直角坐标系，假设i，j，k分别是x轴，y轴，z轴上的单位向量。叉乘积的方向垂直于这两个向量构成的平面，大小表示这两个向量构成的平行四边形的面积。假设OP1=（x1,y1,z1），OP2=（x2,y2,z2），OP1 X OP2 = （y1z2-y2z1）i + (x2z1-x1z2)j + (x1y2-x2y1)k因此叉乘的模为 |OP1 X OP2| = （y1z2-y2z1）+(x2z1-x

n是大于一的任意正整数。（称为标准分解式）其中pi为素数，质数ai为正整数（如果ai=0，相当于乘一，没有意义的）。标准分解式是唯一且一定存在的。（素因子的乘积顺序不考虑）下面给出几个简单的判别式：整数a能被2整除的充要条件是a的末尾数字为偶数。整数a能被3整除的充要条件是a的各位数字之和能被3整除。整数a能被5整除的充要条件是a的末尾数字为0或5 。整数a能被11整除的充要条件是a的奇位数

队列的实现可以基于数组实现，也可以基于单链表实现。 下面给出数组实现，为防止队列多次进行插入和删除操作导致的前面的数组空间被浪费，采用循环队列的方式。声明一个队列类，这里要注意maxn的大小，因为是循环队列，所以不用太大。如果太大，类又是在main函数中定义的，就有可能导致栈溢出。class Queue{public: Queue(); int PUSH(in

一：线性素数筛 一般的素数筛思路就是选择出小素数，然后划去小素数得到整数倍，这就是”埃拉托斯特尼筛法”，这种方法会同一个元素进行多次筛选。因此有了另一种优化的线性素数筛法。主要思想是：每一个合数都可以进行质因数分解，所有任何一个合数都可以由最小素因子进行唯一标记。代码如下：void quick_prime(int n){ memset(prime,0,sizeof(prime));

思想： 快速排序（quick sort）是对冒泡排序的一种改进，通过一趟排序把即将排序的数据分割为独立的两部分，其中一部分的数据都比另外一部分的所有数据都要小。然后再按照这种方法对这两部分数据分别进行快速排序，递归完成整个排序过程。它采用的是一种分治策略，也就是分治法。 分析： 快速排序的时间复杂度为O（nlogn），而且排序效率在同为O（nlogn）的几种排序算法（如归并排序，堆排序）中效

算法简介： Kruskal算法又叫做加边法，采用的并查集的思想。克鲁斯卡尔算法只需要对边进行访问，所以算法的时间复杂度只和边的数量有关系，时间复杂度为O(eloge)，其中e是边的数量。 算法过程： 1.将图中所有的边按照权值进行排序。 2.将图中的每一条边进行遍历，找出权值最小的边（注意：不能与已经加入到最小生成树集合的边构成环），如果符合要求，则把该边加入到最小生成树的集合中。 3.重

给出一组数字，数字个数为N，找到其中第K大的数字。（N>= K）int a[maxn]中maxn=32768*1024/4；解法一：读入所有数据，用快速排序 时间复杂度O(N+N*logN)#include <cstdio>#include <algorithm>#define maxn 1000000+5using namespace std;int T[maxn];bool cmp(in

并查集是一种树形的数据结构，用于处理一些不相交的集合的合并及查询问题。 集就是让每一个元素构成一个单元素的集合，也就是按照一定的顺序将属于同一组的元素的集合进行合并。模板代码如下：int pre[1000]; //并查集数组int Find(int x){ int r = x; //假设根节点是自身，然后通过循环进行查找x的根节点 while(pre[r] != r)

const double eps = 1e-8;//epsilonconst double PI = acos(-1.0);struct Point{ double x,y; Point(){} // 析构函数 Point(double _x,double _y) { x = _x; y = _y; } Point

字典树，Trie树，是一种树形结构，是一种哈希树的变种，典型功能是用于统计，排序和保存大量的字符串。优点是：利用字符串的公共前缀来节约存储空间，最大限度的减少无谓的字符串的比较。代码模板：#define MAX 26//定义结点typedef struct Trie { Trie *next[MAX]; int v;};Trie *root; //定义一个字典树//构建字典树voi

堆排序的时间复杂度为O(N*logN).二叉堆定义 二叉堆是完全二叉树或者是近似完全二叉树。 二叉堆满足两个特性： 1.父结点的键值总是大于或者等于（小于或者等于）任何一个子结点的键值。 2.每个结点的左子树和右子树都是一个二叉堆（最大堆或者最小堆）。当父结点的键值总是大于或者等于任何一个子结点的键值时为最大堆，反之为最小堆。堆的存储 一般都使用数组来表示堆，（若根节点从0开始，因为数组的

问题描述只有一堆n个物品，两个人轮流从中取物，规定每次至少取一个，至多取m个，最后取光者获胜。过程推导显然，若是n=m+1，那么因为一次最多只能取m个，所以，无论先取者拿走几许个，后取者都可以或许一次拿走残剩的物品，后者取胜。是以我们发了然如何取胜的法例：若是 n=（m+1）r+s，（r为随便率性天然数，s≤m），那么先取者要拿走s个物品，若是后取者拿走k（≤m）个，那么先取者再拿走m+1-k个，

1. Beautiful Soup 简介Beautiful Soup是将数据从HTML和XML文件中解析出来的一个python库，它能够提供一种符合习惯的方法去遍历搜索和修改解析树，这将大大减少爬虫程序的运行时间。 Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，Beautiful Soup

一:算法描述 求单源最短路的SPFA算法，是一种可以处理负权边的算法。对于存在负权边，迪杰斯特拉算法不能使用，但是bellman-ford时间复杂度较高。 简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路。二：算法基本步骤 几乎所有的最短路径算法都是以下两个步骤： ①初始化 ②松弛操作初始化： dis数组

基本性质：若p|(a-b)，则a≡b(%p)(a%p) = (b%p),则a≡b(%p)a≡b(%p) 等价于 b≡a(%p)(传递性) 若a≡b(%p)且b≡c(%p),则a≡c(%p)运算性质：(a+b) % p = (a%p + b%p) % p(a-b) % p = (a%p - b%p) % p(a*b) % p = (a%p * b%p) % p(a^b) %p = (

问题描述： 给定一个n*n的棋盘，放置n个彼此无法攻击的皇后，在国际象棋中，皇后可以攻击与其在同一列或者同一行或者同一斜线上的旗子。也就是说，在n个皇后中，任意两个都不能放在同一列或者同一行或者同一斜线上。解题思路： x[t]表示第t行中皇后所在列，因此x数组[t1,t2…tn]是一个1-n的全排列。所以从第一行开始，一行一行的向下进行，在每一行中遍历每一列，然后监测是否满足，如果满足，则进入下

从头到尾彻底理解KMP 作者：July时间：最初写于2011年12月，2014年7月21日晚10点 全部删除重写成此文，随后的半个多月不断反复改进。1. 引言    本KMP原文最初写于2年多前的2011年12月，因当时初次接触KMP，思路混乱导致写也写得混乱，如此，留言也是“骂声”一片。所以一直想找机会重新写下KMP，但苦于一直以来对KMP的理解始终不够，故才迟迟没有修改本文。

算法简述 Floyd算法用于求每一对顶点之间的最短路径，3个for循环就可以。时间复杂度O(n^3) 。Floyd算法的基本思想如下：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查Dis(AX) + Dis(XB) 算法代码这里写代码片总之：无论

最短路径的第一类问题 求从单个源点到其余各顶点的最短路径。算法简介 给定带权有向图G和源点v0，求从源点v0到G中其余各顶点的最短路径。迪杰斯特拉算法是对有权图进行搜索，但是如果引用于无权图或者是权值相等的图，就是广度优先搜索。（注意是有向图）算法描述 对于网N=（V,E），将N中的顶点分成两组： 第一组S：已求出的最短路径的终点集合（初始时只含有v0） 第二组V-S：尚未求出最短路径的终

算法分析： prim算法适合稠密图，时间复杂度为O(n^2),时间复杂度与边的条数无关。 概念： 边带有权值的图称为带权图或者网，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。 1.最小生成树（MST）：权值最小的生成树。 2.构造最小生成树应该满足一下两个性质： 尽可能的选取权值小的边，但是不能构成回路。 选取n-1条恰当的边连通n个顶点。MST性

中国剩余定理是求解一次线性同余方程组的方法。中国剩余定理： 假设整数m1,m2, … ,mn两两互素，则同余方程组 有整数解。 设 是m1,m2,m3…mn的乘积，并设 是除了mi以外的n-1个整数的乘积。 设是Mi模mi的逆元（数论中的倒数）。那么在模M下的解是唯一的。 模板代码如下：void Extend_Euclid(int a,int b,int& x,int& y){

Waiting:正在评测程序。 Compiling:正在编译程序。 Accepted:程序正确。 Wrong Answer:程序运行结果与正确结果不一样。 Time Limit Exceeded:运行时间超出了要求。 Memory Limit Exceeded:程序运行占用内存超出了标准。 Runtime Error:程序在运行的时候异常退出。 Compile Error:编译错误。（

0-1背包问题中的0.1一般表示物品取或者不取的2种状态。这是其他背包问题的基础。

INT_MIN在标准头文件limits.h中定义。#define INT_MAX 2147483647#define INT_MIN (-INT_MAX - 1)在C/C++语言中，不能够直接使用-2147483648来代替最小负数，因为这不是一个数字，而是一个表达式。表达式的意思是对整数21473648取负，但是2147483648已经溢出了int的上限，所以定义为（-INT_MAX -1）。C

最大连续子段和定义 给定n个整数（可能为负数）组成的序列a[1…n],求该序列中形如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的数字均为0的时候，最大子段和定义为0。 方法一： 在不考虑时间的情况下，使用循环暴力的方法，求出序列的所有子段和。该方法会有3层循环嵌套。时间复杂度为O（n^3）。#include &amp;lt;cstdio&amp;gt;#include &amp;lt...

问题描述有两堆若干个物品，两个人轮流从两堆物品中取物，规定每次至少取一个，多者不限，取法分为两种：取走一堆中任意个物品，或从两堆中取走相同数目的物品，先取完所有物品的一方获胜。过程推导1.最佳策略游戏过程中的任何状态都可以用一对正整数(n,m)来表示，其中另n≤m，分别表示两堆物品的个数。所有的状态分为两种：先手必胜或者后手必胜。在双方均采取最佳策略的情况下，前者表示下一个行动的玩家将取胜，后者表示

Bubble Sort原理：相邻的2个数进行比较。 每次经过一趟比较，最大数或者最小数就会被交换到最后一位。for(int i=0;i&amp;lt;len-1;i++) for(int j=i;j&amp;lt;len;j++) if(大小比较) 交换；如果是按照从小到大的顺序进行排序，只需要把前n-1个大的数归为到后面的n-1位即可，所以外层循环只需要到l...

一：文件测试数据代码如下：#include &amp;lt;cstdio&amp;gt;#include &amp;lt;algorithm&amp;gt;#include &amp;lt;iostream&amp;gt;using namespace std;int main(){ freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);

一：stringstring 是c++ 提供的字符串类型，不限长度。头文件#include &amp;lt; string&amp;gt; 声明： string s； string s=”china”; 和char数组不同的是string对象中不含\0，也就是说如果是一个三个字符的字符串，在string s[]中仅仅到s[2]就会结束。操作 string对象声明 ...

石子合并是经典的动态规划，有以下3种题型。 1.有N堆石子，现在要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费是新合成的一堆石子的数量。现在求将这N堆石子合并为一堆的总花费最小（或最大）。分析：贪心算法，每次选择最小（或最大）的两堆合并，实际上是哈夫曼的变形。2.有N堆石子，现在要将石子有序的合并成一堆，规定如下：每次只能合并相邻的2堆石子，合并花费是新合成的一堆石子

1.map简介 map的特性是，所有的元素都会根据元素的键值自动被排序，map的所有元素都是pair类型，同时拥有键值和实值。pair的第一元素被看做键值（也就是说是按照第一元素进行排序的），第二元素被看做实值。map不允许两个元素具有相同的键值。在map中是不可以通过map的迭代器改变map的键值，因为map元素的键值关系到map元素的排列规则，任意的改变map元素的键值会严重破坏map组...

首先我们要知道少加载一点头文件是减少运行时间的主要途径之一。 C++中的pair模板包含在头文件 utility 中。一个pair保存两个数据成员。类似容器，pair是一个用来生成特定类型的模板。当创建一个pair的时候，必须提供两个类型名，此时pair的数据成员将具有对应的类型。pair&amp;amp;lt;string, string&amp;amp;gt; p1;pair&amp;amp;lt;string, size_...

如果是求一个数字的欧拉函数，可以在时间复杂度为O(sqrt(n))求出。但是如果要求前n个数的欧拉函数，按照上述的思路，时间复杂度就是O(n*sqrt(n))。 因此采用一种线性时间的方法筛选欧拉函数值，完成打表。本方法需要一下的几个性质： （p为质数） 1.phi[p]=p-1，因为1-p中只有p与本身不互质。 2.如果i mod p = 0，则 phi[i*p] = p *ph

欧拉函数是小于等于n的数字中与n互质的数字的数目。 欧拉函数的公式如下： 其中x不为0，p1…pr表示x的所有质因数。 特殊的，φ(1)=1（唯一和1互质的数(小于等于1)就是1本身）。 注意：每种质因数只一个。（对任意整数都可以进行素数分解，任意素数幂之积） 性质如下： 欧拉函数是积性函数，若m，n互质，φ(mn)=φ(m)φ(n) 。 若n是质数p的k次幂，φ(n)

欧几里德算法又称辗转相除法，用于计算两个正整数a，b的最大公约数。定理:两个整数的最大公约数等于其中较小的那个数和两个数相除余数的最大公约数。gcd(a,b) = gcd(b,a mod b)上述表达式中a>b。限制gcd(a,b) = gcd(|a| , |b|),也就是对非负整数进行了讨论。证明方法： （百度百科：a可以表示成a = kb + r（a，b，k，r皆为正整数），则r = a mo

1.说明首先这里需要引入两个名词就是左值引用和右值引用。i++返回原来的值，但是++i返回加一后的值。++i可以作为左值，但是i++不可以。下面给出几个例子：int i=0；int *p2 = &(++i)；//正确int *p1 = &(i++)； //错误++i = 1；//正确i++ = 1；//错误下面给出++i和i++的实现机制：（以下代码来自底层实现）// 前缀形式（++i）：i

存储区一般分为以下五种： 栈区： 由编译器在需要的时候进行分配，不需要的时候会自动清空，栈区一般比较小，对于较大的数组不应该放入栈区。 堆区： 由new分配的空间，他们的释放由程序中的语句进行操作。由delete释放，如果没有释放，就会在程序结束时自动回收。 代码区： 存放代码的二进制代码。 全局（静态）存储区： 全局变量和静态变量被分配到同一块内存中。 常量存储区： 存放的数据

二分查找是一种效率非常高的算法。 在头文件< algorithm>中已经有二分查找的实现。 而且binary_search()的使用一般是和STL配套使用。（后面有关于STL无序容器的排序函数书写讲解）一：STL二分查找1.binary_search()函数该函数的功能是查看某一值在已经排好的序列中是否存在，当存在的时候返回true，否则返回false。返回值是一个bool类型，也说明了bina

一：矩阵快速幂算法 矩阵快速幂的思想和数的快速幂的思想是一样的，但是需要自己实现矩阵的乘法，然后套用数的快速幂模板即可。 核心： 难点在于构造矩阵，一般用于可以推出递推公式的题目，发现时间复杂度为O（n），因此可以构造一个矩阵，利用矩阵快速幂算法把时间复杂度降低到O（logn）。 矩阵的快速幂算法是用于高效的计算矩阵的高次方的。比如矩阵A*A*A*A*A*A可以变为（A*A）（A*A）（A*...