qq_44879626的博客

操作一共分为4个基本操作1.pushup(u) 操作是传入节点编号u，用u节点的子节点信息计算父节点的信息2.build操作，将一段区间初始化为线段树3.modify操作，修改某个点或者某个某个区间某个点某个区间：使用懒标记，延迟更新4.查询操作，query()操作线段树的原理：除了最后一行是满二叉树存储类似堆的方式，用一维数组保存线段树下面来看存储下一颗线段树需要多少内存因为除了最后一层是满的二叉树，假设倒数第二层有n个点，那么除去最后一层和倒数第二层，有2*n - 1个点；

来源：www.acwing.com在这个问题中，您必须分析特定的排序算法----超快速排序。该算法通过交换两个相邻的序列元素来处理 n 个不同整数的序列，直到序列按升序排序。对于输入序列 9 1 0 5 4，超快速排序生成输出 0 1 4 5 9。您的任务是确定超快速排序需要执行多少交换操作才能对给定的输入序列进行排序。输入格式输入包括一些测试用例。每个测试用例的第一行输入整数 n，代表该用例中输入序列的长度。接下来 n 行每行输入一个整数 ai,代表用例中输入序列的具体数据，第 i 行的数

题目来源：www.acwing.com七夕节因牛郎织女的传说而被扣上了「情人节」的帽子。于是 TYVJ 今年举办了一次线下七夕祭。Vani 同学今年成功邀请到了 cl 同学陪他来共度七夕，于是他们决定去 TYVJ 七夕祭游玩。TYVJ 七夕祭和 11 区的夏祭的形式很像。矩形的祭典会场由 N 排 M 列共计 N×M 个摊点组成。虽然摊点种类繁多，不过 cl 只对其中的一部分摊点感兴趣，比如章鱼烧、苹果糖、棉花糖、射的屋……什么的。Vani 预先联系了七夕祭的负责人 zhq，希望能够通过恰当地布

树状数组基本原理它可以解决的问题1.快速求前缀和 O(logn)2.修改某一个数 O(logn )使用普通数组（前缀和数组）的话求前缀和的时间复杂度是O(n)，修改某个数时间复杂度是O(1)树状数组其实就是想办法，将两个极端的复杂度折中一下思路：基于二进制数据将长度为n的数组分成log(n)个的不同长度的区间可以看到，对于每个区间来说，比如对于第一个区间(x - 2^i1，x]，其实是x二进制表示的最后一位1推广开就是对于(L, R]区间来说，区间长度一定是R的二进制表示的最

来源：www.acwing.com给定一个长度为 n 的数列 a1,a2,…,an，每次可以选择一个区间 [l,r]，使下标在这个区间内的数都加一或者都减一。求至少需要多少次操作才能使数列中的所有数都一样，并求出在保证最少次数的前提下，最终得到的数列可能有多少种。输入格式第一行输入正整数 n。接下来 n 行，每行输入一个整数，第 i+1 行的整数代表 ai。输出格式第一行输出最少操作次数。第二行输出最终能得到多少种结果。数据范围0<n≤10^5,0≤ai<214748364

题目来源：www.acwing.com地图上有 N 个目标，用整数 Xi,Yi 表示目标在地图上的位置，每个目标都有一个价值 Wi。注意：不同目标可能在同一位置。现在有一种新型的激光炸弹，可以摧毁一个包含 R×R 个位置的正方形内的所有目标。激光炸弹的投放是通过卫星定位的，但其有一个缺点，就是其爆炸范围，即那个正方形的边必须和 x，y 轴平行。求一颗炸弹最多能炸掉地图上总价值为多少的目标。输入格式第一行输入正整数 N 和 R，分别代表地图上的目标数目和正方形的边长，数据用空格隔开。接下来 N

int lowbit(int n){ return n & (-n);}函数返回的是为1的最低位的幂次方。比如2， 它返回的是2， -2和2的的位的区别如下：0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

假设最小的矩形想要插入头结点后面，假设当前的节点的编号是2，已有的那个节点的编号是1.如上面的代码所示，首先把要保存的值放入，将上一个节点的值保存为当前节点的next，注意这个时候的head保存的是上一个节点的地址。这个时候使用head再指向当前。...

题目描述：和单调栈和单调队列一样，先想出暴力的做法，之后再优化char s[N], p[M]; //s的长度大于pfor(int i = 1; i <= n; i++){ bool flag = true; for(int j = 1; j <= m; j++) { if(s[i + j - 1] != p[j]){ flag = flase; break; } }}如图所示，蓝色的线表示的是长的字符串， 红的是表示的模板字符串。可以看到，在遍历到

数组中如果使用有序的数组，查找的时候可以使用二分查找，时间复杂度为O(log2n)， 当你插入或者删除的时候，需要前移或者后移，时间复杂度为O(n)。基于上述信息，提出了BST，这个结构的查找（在平衡的时候）和二分一样，时间复杂度是O(log2n)下去整 + 1， 但是插入和删除的时候不用移动大量的数据。由于BST不平衡，比如全部插入到右子树，查找的效率相当于链表。为了提高效率，就要让bst尽可能的接近平衡，于是AVL应运而生。AVL树在插入和删除的时候，实时的进行调整以保持结构的平衡，但是由于频繁进

class Solution {public: int longestValidParentheses(string s) { if(s.empty()) return 0; stack<int> stk; int res = 0; for(int i = 0, last = -1; i < s.size(); i++){ if(s[i] == '(') stk.push(i); .

二叉树中最大路径和树的枚举中，一般枚举树的最高点， 即最低公共祖先（LCA）.给定一个树，要求最大路径和，可以分成节点的值 + 左子树的最大值 + 右子树的最大值。这个最大值是局部的最大值。/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), lef

第一类：对于n个区间，在区间内标记几个点，使得所有区间上都有标记的点，最少可用多少点完成标记？思路：贪心策略，使用区间的右端点进行排序，将标记的点尽可能的延后，这样可以保证点最少。第二类：对于n个区间， 给出一段区间，怎么选区间才能保证用最少的区间覆盖掉给定的区间？思路：贪心策略，对于给定的[l, r]， 将区间按左端点排序，对于l，找到一个左端点小于l同时右端点最靠后的一个区间，然后用此区间的右端点来更新掉l。如此往复。第三类：对于n个区间，要想将这些区间分成多个组，在每个组中每个区间没有交集，最

区间分组给定N个闭区间[ai,bi]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。输出最小组数。输入格式第一行包含整数N，表示区间数。接下来N行，每行包含两个整数ai,bi，表示一个区间的两个端点。输出格式输出一个整数，表示最小组数。数据范围1≤N≤10^5,−109≤ai≤bi≤109输入样例：3-1 12 43 5输出样例：2思路：贪心，先将区间按左端点排序，因为要组数尽量小，所以枚举时，和每一个组的最后一个区间比较，

给定N个闭区间[ai,bi]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。输出选择的点的最小数量。位于区间端点上的点也算作区间内。输入格式第一行包含整数N，表示区间数。接下来N行，每行包含两个整数ai,bi，表示一个区间的两个端点。输出格式输出一个整数，表示所需的点的最小数量。数据范围1≤N≤105,−109≤ai≤bi≤109输入样例：3-1 12 43 5输出样例：2思路：对n个区间以右端点排序，只要然后枚举，只要左端点超过backbone就意味着

K倍区间给定一个长度为 N 的数列，A1,A2,…AN，如果其中一段连续的子序列 Ai,Ai+1,…Aj 之和是 K 的倍数，我们就称这个区间 [i,j] 是 K 倍区间。你能求出数列中总共有多少个 K 倍区间吗？输入格式第一行包含两个整数 N 和 K。以下 N 行每行包含一个整数 Ai。输出格式输出一个整数，代表 K 倍区间的数目。数据范围1≤N,K≤100000,1≤Ai≤100000输入样例：5 212345输出样例：6思路：可以用前缀和思想。对于每一个Ai，

耍杂技的牛农民约翰的N头奶牛（编号为1…N）计划逃跑并加入马戏团，为此它们决定练习表演杂技。奶牛们不是非常有创意，只提出了一个杂技表演：叠罗汉，表演时，奶牛们站在彼此的身上，形成一个高高的垂直堆叠。奶牛们正在试图找到自己在这个堆叠中应该所处的位置顺序。这N头奶牛中的每一头都有着自己的重量Wi以及自己的强壮程度Si。一头牛支撑不住的可能性取决于它头上所有牛的总重量（不包括它自己）减去它的身体强壮程度的值，现在称该数值为风险值，风险值越大，这只牛撑不住的可能性越高。您的任务是确定奶牛的排序，使得所

最短编辑距离给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。你可以对一个单词进行如下三种操作：插入一个字符删除一个字符替换一个字符示例 1：输入：word1 = “horse”, word2 = “ros”输出：3解释：horse -> rorse (将 ‘h’ 替换为 ‘r’)rorse -> rose (删除 ‘r’)rose -> ros (删除 ‘e’)示例 2：输入：word1 = “int

星空之夜夜空深处，闪亮的星星以星群的形式出现在人们眼中，形态万千。一个星群是指一组非空的在水平，垂直或对角线方向相邻的星星的集合。一个星群不能是一个更大星群的一部分。星群可能是相似的。如果两个星群的形状、包含星星的数目相同，那么无论它们的朝向如何，都认为它们是相似的。通常星群可能有 8 种朝向，如下图所示：现在，我们用一个二维 01 矩阵来表示夜空，如果一个位置上的数字是 1，那么说明这个位置上有一个星星，否则这个位置上的数字应该是 0。给定一个夜空二维矩阵，请你将其中的所有星群用小写字母

通读题目，找出一些性质：1.正确区间一定在0~100之间，证明过程如下反证法：假设存在正确区间端点不在范围内，由于区间点变换前所有点都在[0, 100], 那么我可以将范围外的点移动到端点0处，由于先前的点都在范围内，因此移动的步数肯定更少，那么这个区间就不是代价最少的，和题设矛盾。2.确定了区间，我们就可以直接枚举长度为17的区间。#include<algorithm>#include<iostream>using namespace std;const int

题目思路：先求出最大值，查找出最大路径上的路径，由下图可知，最大值加上的最后一个数，其位置就是左上角为最大值的位置。查找到，将此数置为0；代码实现：#include<iostream>#include<cstring>using namespace std;const int N = 12;int f[N][N];int w[N][N];int n;typedef pair<int, int> pii;pii p1, p2;int get

题目来自www.acwing.com题目分析过程代码实现#include<iostream>#include<cstring>using namespace std;const int N = 110;int f[N][N], w[N][N];int n;int main(){ cin >> n; for(int i = 1; i <= n; i++) for(int j = 1; j <

题目来源 www.acwing.com分析过程代码：#include<iostream>using namespace std;int n, m;int T;int w[110][110];int f[110][110];int main(){ cin >> T; while(T -- ){ cin >> n >> m; for(int i = 1; i <= n; i+

文章资料题目均来自于www.acwing.com

题目和材料均来自于www.acwing.com采药明显是一个01背包的应用，写出代码#include<iostream>#include<algorithm>using namespace std;int n, m;int v, w;int f[1010];int main(){ cin >> m >> n; for(int i = 0; i < n; i ++) { cin >&gt

所有题目，材料均来自于www.acwing.com

原题目：最长上升子序列，所有题目，材料均来自于：www.acwing.com代码：#include<iostream>#include<algorithm>using namespace std;const int N = 1010;int f[N];int a[N];int n;int main(){ cin >> n; for(int i = 0; i < n; i++) cin >> a[i];

大家都知道MySQL的底层索引的数据结构是B+树。为什么不用hash结构呢？hash结构是无序的，不能够提供范围性查找，比如我要查 >= 某个数的或者小于某个数的结果就不能实现，但是进行单个查找hash表是非常快的；并且你如果想要进行排序操作的话也是不可以的，因为下标和该下标对应的值是1 1对应的，排序后就失去了意义。如果当你的hash值是相等的时候会比较慢为什么不用AVL结构呢？树的高度越高，查找的速度越慢，最慢时为logn， 当数据量大于一定量级的时候就会出现问题。除此之外，当你的查找大于

题目：求小于当前数的左边最近的数#include<iostream>#include<algorithm>using namespace std;const int N = 100010;int n;int stk[N], tt; //tt == 0时栈为空int main(){ int n; cin >> n; while(n --){ int x; cin >> x;

来源题目：数字三角形由数字三角形可以引申到题目：摘花生结合划分的原则是1.不重复 2.不漏； 但是并不是要求每一个题目都要满足的，根据你要求的属性，可以发生变化。比如你要求的是一些集合的最大值，部分的重复元素并不影响最大值或者最小值；比如你要求的是元素的个数，那么这个时候就要求既不能重复也不能漏掉一些 。不漏的原则一直都必须满足。先求出途中的最大值，再计算最后所要的#include<iostream>#include<algorithm>using namespa

由维恩图引入对于多个圆拼成的一个图形，如果要求他的面积，该过程如下从前几个可以看出规律： 三个圆覆盖的面积 = 一个圆做组合面积 - 2个圆做组合面积 + 3个圆做组合 - 4个圆做组合 + … + （-1）^ (n - 1) 个圆做组合。可以看到正负号相间。表示成集合即为：S1∪S2∪S3 = S1 + S2 + S3 - S1 ∩ S2 - S2 ∩ S3 - S1 ∩ S3 + S1 ∩ S2 ∩ S3三个集合并集的元素个数 = 3个单个个集合的元素个数 - 2个结合交集的元素个数 + 3个

题目描述和Nim问题类似假设有三级台阶。如果先手把2上的石子往1台阶上拿，那么后手就在台阶1上拿同样数量的石子到地上；如果先手把台阶3的石子往台阶2上拿，那么后手就把同样多的石子从台阶1往平地上拿。第1阶上的石子数量和第3阶的相同。那么也总是先手会面对第一阶石子为0的局面。一般情况：如果先手面对的状态是全0，他在奇数台阶上往下拿石子个数为n， 后手只要将先手拿下来的石子顺次往下拿，就能使状态2又变为状态1，即全为0的状态；只需要处理奇数台阶就可以了。#include<iostream&g

假设开始有两堆石子， 一堆石子是3， 另一个是2.那么先手必胜。原因：1号先从第一堆石子里面拿一个石子。两堆石子就都是2颗了。之后，只要先手根据后手的操作进行镜像的操作，就能保证自己的胜利。如果后手取一颗，先手也在另一堆里面取一颗；后手取两颗，先手在另一堆里面取两颗。总能保证先手取完最后一颗石子。先手必胜状态：可以走到某一个必败状态先手必败状态：走不到一个必败状态结论：第一个状态表示终点的异或值一定是0，表示必败态，因为无法走到任意一个必败态第二个状态表示必胜态，因为，可以想办法将当前状态走

锁相环PLLCR， 在sci中设置的PLLCR是10，LCD中设置的是2.相当于两个设备的时钟频率差了5倍，LCD还来不及处理sci传输过来的数据我们将延时函数改成原来的6.4倍，即i < 800;可以进行转换。

电容最主要作用是滤波，只要是某条线路和电源直接相连的时候，就必须加上电容。

法1：将此问题变为容量为n的完全背包问题，有质量分别为1,2,3，，，n的物品，每个物品有无穷多件，问能装满这个背包的方法有多少种？任何一种等式都可以看做是背包问题。f[i][j] 表示的是从1 - i个物品中选物品，体积恰好是j的选择种数按照这个思路写出状态转移方程是这里进行了优化，将s次计算变为了一次这里为了节约内存空间，将二维转换为1维，这里把第一维选择了几个物品省略掉了。题目要求的是选择任意多个物品，达到指定体积就可以。因此用一维数组时只需从小到大枚举即可。#include&l.

代码：#include<iostream>using namespace std;const int N = 1010;char a[N], b[N];int f[N][N];int main(){ int n, m; cin >> n >> a + 1 >> m >> b + 1; for(int i = 0; i <= n ;i++) f[i][0] = i; //...

题目：f[i - 1, j]表示的是A[1~i -1]和B[1~j - 1]的公共子序列的集合，但是【0,1】状态表示的是包含b[i]但是不包含a[i]的集合，所以其实f[i-1,j-1]包含了[0, 1]状态。但是由上图的分析看到，所要求的属性是最大值，集合重复覆盖也不影响，但是如果要求的是和就必须考虑不重不漏。#include<iostream>#include<algorithm>using namespace std;const int N = 1010;

转载自：https://blog.youkuaiyun.com/huhuandk/article/details/92771038?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159791855919724848361335%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=159791855919724848361335&biz_id=0&

在上一种解法的基础上可以有更快的做法。如果先前的f[j] 和 后来的f[i]大小是一样的，那么 由于子序列的长度长度是一样，并且 后一个的最后一个元素a[i - 1]是小于前一个的最后一个元素a[i]的,如果不满足条件的话，那么f[i] = f[i -1] + 1 了，因为a[i] > a[i - 1]对每一个子串的长度的大小是递增的并且随着上升子序列的长度变化，其末尾的元素是递增的。上图表示的是不同上升子序列的最小值的大小，可以看到是递增的。对于每一个数，我们要要找出小于这个数a[i]的最大的.