【题目总结】查询区间内相同元素的信息

已于 2022-06-26 17:46:45 修改
阅读量220 收藏
点赞数
分类专栏： 算法学习 做题笔记 文章标签： 算法 数据结构 acm竞赛 c++
于 2022-06-26 11:00:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhyu61/article/details/125464119
版权

LuoguP1972 - [SDOI2009] HH的项链

题目链接

给定若干区间，询问区间内物品的种数。

考虑离线，将每一个区间按照右端点从小到大进行排序。右端点不断向右移动的时候，将移动时遇到的序列中的数获取过来，更新我们已有的信息，然后进行统计。我们要掌握的就是每一种物品离右端点最近的位置在哪，统计最近的位置，就是为了在固定右端点的情况下，区间再小，也能掌握到这一种物品的存在。

以题目样例为例， [ 1 , 2 , 3 , 4 , 3 , 5 ] [1,2,3,4,3,5] [1,2,3,4,3,5]，我们设一个答案序列 [ 0 , 0 , 0 , 0 , 0 , 0 ] [0,0,0,0,0,0] [0,0,0,0,0,0]，用来方便我们对于每一个询问的统计。设右端点为 r r r，样例中的物品序列为 a a a。

当 r = 1 r=1 r=1时， a 1 = 1 a_1=1 a1​=1， 1 1 1是之前没有遇到过的数，将这个位置标上 1 1 1。答案序列变为 [ 1 , 0 , 0 , 0 , 0 , 0 ] [1,0,0,0,0,0] [1,0,0,0,0,0]。

当 r = 2 r=2 r=2时， a 2 = 2 a_2=2 a2​=2， 2 2 2是之前没有遇到过的数，将这个位置标上 1 1 1。答案序列变为 [ 1 , 1 , 0 , 0 , 0 , 0 ] [1,1,0,0,0,0] [1,1,0,0,0,0]。

此时有一个询问是 [ 1 , 2 ] [1,2] [1,2]，那么就求答案序列 [ 1 , 2 ] [1,2] [1,2]的和，也就是 2 2 2。

继续移动右端点。

当 r = 3 r=3 r=3时， a 3 = 3 a_3=3 a3​=3， 3 3 3是之前没有遇到过的数，将这个位置标上 1 1 1。答案序列变为 [ 1 , 1 , 1 , 0 , 0 , 0 ] [1,1,1,0,0,0] [1,1,1,0,0,0]。

当 r = 4 r=4 r=4时， a 4 = 4 a_4=4 a4​=4， 4 4 4是之前没有遇到过的数，将这个位置标上 1 1 1。答案序列变为 [ 1 , 1 , 1 , 1 , 0 , 0 ] [1,1,1,1,0,0] [1,1,1,1,0,0]。

当 r = 5 r=5 r=5时， a 5 = 3 a_5=3 a5​=3，与 a 3 a_3 a3​相同，将原先值为 3 3 3上的 1 1 1抹除，将这个位置标上 1 1 1。答案序列变为 [ 1 , 1 , 0 , 1 , 1 , 0 ] [1,1,0,1,1,0] [1,1,0,1,1,0]。

此时有一个询问是 [ 3 , 5 ] [3,5] [3,5]，那么就求答案序列 [ 3 , 5 ] [3,5] [3,5]的和，也就是 2 2 2。

继续移动右端点。

当 r = 6 r=6 r=6时， a 6 = 5 a_6=5 a6​=5， 5 5 5是之前没有遇到过的数，将这个位置标上 1 1 1。答案序列变为 [ 1 , 1 , 0 , 1 , 1 , 1 ] [1,1,0,1,1,1] [1,1,0,1,1,1]。

此时有一个询问是 [ 2 , 6 ] [2,6] [2,6]，那么就求答案序列 [ 2 , 6 ] [2,6] [2,6]的和，也就是 4 4 4。

总结起来，就是将一种物品的代表设置得离右端点越近越好，这样可以保证，左端点以左的标记在询问区间内一定没有对应的相同物品。

求答案序列的和，用线段树/树状数组都可以。更新答案序列用普通数组记录一下这个数组上一次出现的位置即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1000005;

int n, m;
int a[N], b[N], c[N];

int lowbit(int x) {
	return x & (-x);
}

void add(int x, int k) {
	while (x <= n) {
		c[x] += k; x += lowbit(x);
	}
}

int presum(int x) {
	int ans = 0;
	while (x >= 1) {
		ans += c[x]; x -= lowbit(x);
	}
	return ans;
}

struct QUERY {
	int l, r, ans, id;
}q[N];

int mp[N];

void main2() {
	cin >> n;
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
	}
	cin >> m;
	for (int i = 1; i <= m; ++i) {
		cin >> q[i].l >> q[i].r;
		q[i].ans = 0; q[i].id = i;
	}
	sort(q + 1, q + m + 1, [](const QUERY &A, const QUERY &B) {
		return A.r < B.r;
	});
	int lst = 0;
	for (int i = 1; i <= m; ++i) {
		if (q[i].r > lst) {
			for (int j = lst + 1; j <= q[i].r; ++j) {
				if (!mp[a[j]]) {
					mp[a[j]] = j;
					add(j, 1); 
				}
				else {
					int x = mp[a[j]];
					add(x, -1);
					add(j, 1);
					mp[a[j]] = j;
				}
			}
			lst = q[i].r;
		}
		q[i].ans = presum(q[i].r) - presum(q[i].l - 1);
	}
	sort(q + 1, q + m + 1, [](const QUERY &A, const QUERY &B) {
		return A.id < B.id;
	});
	for (int i = 1; i <= m; ++i) {
		cout << q[i].ans << '\n';
	}
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _;
//	cin >> _;
	_ = 1;
	while (_--) main2();
	return 0;
}

LuoguP4113 - [HEOI2012]采花

题目链接

给定若干区间，询问区间内出现过两次及以上的物品的种数。

和上面那道题大同小异，只有几行代码的差别。这一道题要同时记录这种花上一次出现的位置和上上一次出现的位置。右端点向右移动时，每遇到一种花，就要在这种话上一次出现的位置上打一个标记，如果这是他三次及以上出现，就要把上上一次出现的位置取消掉。

以样例中的数据为例，设序列 a a a为题目花的种类数据 [ 1 , 2 , 2 , 3 , 1 ] [1,2,2,3,1] [1,2,2,3,1]。同样设答案序列 [ 0 , 0 , 0 , 0 , 0 ] [0,0,0,0,0] [0,0,0,0,0]。

r = 1 r=1 r=1， a 1 = 1 a_1=1 a1​=1，这是第一次遇到 1 1 1，所以只记录出现的位置，不在答案序列进行标记。
此时答案序列 [ 0 , 0 , 0 , 0 , 0 ] [0,0,0,0,0] [0,0,0,0,0]。

r = 2 r=2 r=2， a 2 = 2 a_2=2 a2​=2，这是第一次遇到 2 2 2，所以只记录出现的位置，不在答案序列进行标记。
此时答案序列 [ 0 , 0 , 0 , 0 , 0 ] [0,0,0,0,0] [0,0,0,0,0]。

此时有以 2 2 2为右端点的询问，分别是 [ 1 , 2 ] [1,2] [1,2]和 [ 2 , 2 ] [2,2] [2,2]。分别求得答案序列中 [ 1 , 2 ] [1,2] [1,2]和 [ 2 , 2 ] [2,2] [2,2]的区间和，答案都是 0 0 0。

r = 3 r=3 r=3， a 3 = 2 a_3=2 a3​=2，这是第二次遇到 2 2 2，所以在答案序列对 2 2 2上一次出现的位置进行标记，并记录先在出现的位置。
此时答案序列 [ 0 , 1 , 0 , 0 , 0 ] [0,1,0,0,0] [0,1,0,0,0]。

此时有以 3 3 3为右端点的询问，是 [ 2 , 3 ] [2,3] [2,3]。分别求得答案序列中 [ 2 , 3 [2,3 [2,3的区间和，答案是 1 1 1。

r = 4 r=4 r=4， a 4 = 3 a_4=3 a4​=3，这是第一次遇到 3 3 3，所以只记录出现的位置，不在答案序列进行标记。
此时答案序列 [ 0 , 1 , 0 , 0 , 0 ] [0,1,0,0,0] [0,1,0,0,0]。

r = 5 r=5 r=5， a 5 = 1 a_5=1 a5​=1，这是第二次遇到 1 1 1，所以在答案序列对 1 1 1上一次出现的位置进行标记，并记录先在出现的位置。
此时答案序列 [ 1 , 1 , 0 , 0 , 0 ] [1,1,0,0,0] [1,1,0,0,0]。

此时有以 5 5 5为右端点的询问，分别是 [ 1 , 5 ] [1,5] [1,5]和 [ 3 , 5 ] [3,5] [3,5]。分别求得答案序列中 [ 1 , 5 ] [1,5] [1,5]和 [ 3 , 5 ] [3,5] [3,5]的区间和，答案分别是 2 2 2和 0 0 0。

这个题数据范围很大，线段树常数比较大，线段树不太容易过，但是树状数组是可以过的。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 2000005;

int n, co, m;
int a[N], b[N], c[N];

int lowbit(int x) {
	return x & (-x);
}

void add(int x, int k) {
	while (x <= n) {
		c[x] += k; x += lowbit(x);
	}
}

int presum(int x) {
	int ans = 0;
	while (x >= 1) {
		ans += c[x]; x -= lowbit(x);
	}
	return ans;
}

struct QUERY {
	int l, r, ans, id;
}q[N];

int mp[N], del[N];

void main2() {
	cin >> n >> co >> m;
	for (int i = 1; i <= co; ++i) {
		mp[i] = del[i] = 0;
	}
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
	}
	for (int i = 1; i <= m; ++i) {
		cin >> q[i].l >> q[i].r;
		q[i].ans = 0; q[i].id = i;
	}
	sort(q + 1, q + m + 1, [](const QUERY &A, const QUERY &B) {
		return A.r < B.r;
	});
	int lst = 0;
	for (int i = 1; i <= m; ++i) {
		if (q[i].r > lst) {
			for (int j = lst + 1; j <= q[i].r; ++j) {
				if (!mp[a[j]]) {
					mp[a[j]] = j;
				}
				else {
					int x = 0;
					if (del[a[j]]) x = del[a[j]];
					if (x) {
						add(x, -1);
					}
					x = mp[a[j]];
					add(x, 1);
					del[a[j]] = x;
					mp[a[j]] = j;
				}
			}
			lst = q[i].r;
		}
		q[i].ans = presum(q[i].r) - presum(q[i].l - 1);
	}
	sort(q + 1, q + m + 1, [](const QUERY &A, const QUERY &B) {
		return A.id < B.id;
	});
	for (int i = 1; i <= m; ++i) {
		cout << q[i].ans << '\n';
	}
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _;
//	cin >> _;
	_ = 1;
	while (_--) main2();
	return 0;
}

（最后一个点1.86s，也超级悬！）

代码源469 - Closest Equals

题目链接

考虑离线来做这道题。将所有的询问按照 r r r排序。我们考察 r r r不断向右的时候，每向右遇到一个数，如何维护答案。

以样例 1 1 1为例， [ 1 , 1 , 2 , 3 , 2 ] [1,1,2,3,2] [1,1,2,3,2]。我们最初设答案是 [ i n f , i n f , i n f , i n f , i n f ] [inf,inf,inf,inf,inf] [inf,inf,inf,inf,inf]。

r = 1 r=1 r=1时， a i = 1 a_i=1 ai​=1，前面没有与其相等的数，所以不会更新答案。

r = 2 r=2 r=2时， a i = 1 a_i=1 ai​=1，最近一个与其相等的数是 a 1 a_1 a1​。那么让答案序列变为 [ 2 − 1 , i n f , i n f , i n f , i n f ] = [ 1 , i n f , i n f , i n f , i n f ] [2-1,inf,inf,inf,inf]=[1,inf,inf,inf,inf] [2−1,inf,inf,inf,inf]=[1,inf,inf,inf,inf]。这样的话，在以 2 2 2为右端点的查询区间中，只要区间包含 1 1 1，那么选取答案最小值就可以选到最优答案 1 1 1。

r = 3 r=3 r=3时， a i = 2 a_i=2 ai​=2，前面没有与其相等的数，所以不会更新答案。

r = 4 r=4 r=4时， a i = 3 a_i=3 ai​=3，前面没有与其相等的数，所以不会更新答案。

r = 5 r=5 r=5时， a i = 2 a_i=2 ai​=2，最近一个与其相等的数是 a 3 a_3 a3​。那么让答案序列变为 [ 1 , 2 , 2 , 2 , i n f ] [1,2,2,2,inf] [1,2,2,2,inf]。对每一个位置， 2 = 5 − 3 2=5-3 2=5−3，是 a 3 a_3 a3​与 a 5 a_5 a5​的距离。我们对答案序列的每一个位置都是更新最小值，如果当前位置的答案已经小于要更新上去的答案，那就不动。

总体上来说，维护这样一个答案序列，当 r r r移到序列第 i i i个数时，每遇到一个前面遇到的一个数，假设这个数与相同的数的最近距离是 x x x，那么更新 [ 1 , i − 1 ] [1,i-1] [1,i−1]，将这些位置的答案与 x x x比较，选取更小的值。查询答案时，就选取答案序列中 [ l , r ] [l,r] [l,r]中的最小值作为答案。

维护这样的序列相当于区间赋值，维护最小值，用线段树可以轻松解决。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

struct QUERY {
	int l, r, ans, id;
}q[500005];

int a[500005];
int n, m;

struct Tree {
	int l, r, tag, mn;
}t[2000005];

void pd(int ni) {
	t[ni << 1].tag = min(t[ni << 1].tag, t[ni].tag);
	t[ni << 1 | 1].tag = min(t[ni << 1 | 1].tag, t[ni].tag);
	t[ni << 1].mn = min(t[ni << 1].mn, t[ni].tag);
	t[ni << 1 | 1].mn = min(t[ni << 1 | 1].mn, t[ni].tag);
	t[ni].tag = 1e9; 
}

void pu(int ni) {
	t[ni].mn = min(t[ni << 1].mn, t[ni << 1 | 1].mn);
}

void build_tree(int ni, int l, int r) {
	t[ni].l = l; t[ni].r = r; t[ni].tag = 1e9;
	if (l == r) {
		t[ni].mn = 1e9; 
		return;
	}
	int mid = (l + r) >> 1;
	build_tree(ni << 1, l, mid);
	build_tree(ni << 1 | 1, mid + 1, r);
	pu(ni);
}

void fix(int ni, int l, int r, int x) {
	if (l <= t[ni].l and t[ni].r <= r) {
		t[ni].tag = min(t[ni].tag, x);
		t[ni].mn = min(t[ni].mn, t[ni].tag);
		return;
	}
	int mid = (t[ni].l + t[ni].r) >> 1;
	pd(ni);
	if (l <= mid) fix(ni << 1, l, r, x);
	if (mid < r) fix(ni << 1 | 1, l, r, x);
	pu(ni);
}

int query(int ni, int l, int r) {
	if (l <= t[ni].l and t[ni].r <= r) {
		return t[ni].mn;
	}
	int mid = (t[ni].l + t[ni].r) >> 1;
	pd(ni);
	int ans = 1e9;
	if (l <= mid) ans = min(ans, query(ni << 1, l, r));
	if (mid < r) ans = min(ans, query(ni << 1 | 1, l, r));
	return ans; 
}

map<int, int> mp;

void main2() {
	cin >> n >> m;
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
	}
	for (int i = 1; i <= m; ++i) {
		cin >> q[i].l >> q[i].r;
		q[i].ans = 0; q[i].id = i;
	}
	sort(q + 1, q + m + 1, [](const QUERY &A, const QUERY &B) {
		return A.r < B.r;
	});
	int lst = 0;
	build_tree(1, 1, n);
	for (int i = 1; i <= m; ++i) {
		if (q[i].r > lst) {
			for (int j = lst + 1; j <= q[i].r; ++j) {
				if (!mp[a[j]]) mp[a[j]] = j;
				else {
					int x = mp[a[j]];
					fix(1, 1, x, j - x);
					mp[a[j]] = j;
				}
			}
			lst = q[i].r;
		}
		int res = query(1, q[i].l, q[i].r);
		if (res == 1e9) q[i].ans = -1;
		else q[i].ans = res;
	}
	sort(q + 1, q + m + 1, [](const QUERY &A, const QUERY &B) {
		return A.id < B.id;
	});
	for (int i = 1; i <= m; ++i) {
		cout << q[i].ans << '\n';
	}
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	LL _;
//	cin >> _;
	_ = 1;
	while (_--) main2();
	return 0;
}
xhyu61
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
E.买礼物（线段树查询区间是否有重复的值）
稚始稚终的博客
02-08 244
买礼物 题目传送门： 买礼物 思路： pre[i]表示第i个礼物的上一个相同礼物的位置 nex[i]示第i个礼物的下一个相同礼物的位置 我们要维护的就是区间 l ~ r 间nex[i]的最小值或者pre[i]的最大值。 我这里维护的是pre[i]的最大值，当删除位置i的物品时，把pre[i]置成0，但需要注意的是因为删除了当前位置的礼物，所以我们还需要修改下一个位置的相同礼物的上一个位置,及 pre[ nex [i] ] = pre[i]。查询时看区间最大值是否大于等于r即可。 AC Code #incl
高频算法题目总结1
08-04
本文将围绕给定的标题和描述，对其中涉及的高频算法题目进行详细的总结和解析。 1. **删除链表的倒数第n个节点**： 这个问题要求我们找到链表的倒数第n个节点并将其删除。可以通过双指针技术解决，一个快指针先...
哈希表查找一段区间内相同的元素
m0_51367574的博客
07-27 351
题目描述 给你一个长为N的序列A，有Q次询问。每次询问给出一个区间[L,R]，询问AL与AR之间是否存在两个相等的数。 输入 共Q+2行。 第一行，两个整数N,Q。 第二行，N个整数A1,A2……An。 接下来Q行，每行两个整数L,R。 输出 对每个询问输出一行，Yes或No. 还是超限 主要是记录一下这个方法。 #include<bits/stdc++.h> using namespace std; int main() { int n,q; int a[1000...
Modulo Query ZOJ - 3940 （区间取模）
七九河开的博客
04-10 252
题目 https://cn.vjudge.net/problem/ZOJ-3940 题意 给你n个模数，和一个0-m范围，Q次询问，每次问范围内有多少数结果是给定的数 思路 区间取模，对x个区间取模，最多会产生x+1个区间，即x个0-（x-1）的区间合并为一个，和0-（<x）的区间 所有最后最多会有2*n个区间， 对于所有的查询x，查找有多少区间又端点大于等于x，即答案 代码...
2021牛客寒假算法基础集训营3 E 线段树 查询区间中是否有相同的数 处理链表结构 预处理
从你的全世界路过
11-23 366
题目 题解思路 预处理出每个相同数之前的点和后继节点。 类似链表的结构。 如果我们将首节点的前节点设置为0后继节点设置为n+1 来保证数据合法性。 将每个节点的后继节点导入线段树，再让线段树处理区间最小值。 这样我们就可以完成查询操作了。 根据查询出来的值是否合法即可。 删除操作就类似链表删除某个节点。 将合法的前节点直接指向后继节点。 并且在线段树上修改即可。 这里用链表处理属实巧妙 AC代码 #include <bits/stdc++.h> #define PII pair<int,
GTY's gay friends 线段树判断区间是否有相同数字
weixin_30319153的博客
07-28 353
http://acm.hdu.edu.cn/showproblem.php?pid=5172 判断一个区间是否为全排列是： 1、区间总和 = (1 + R - L + 1) * (R - L + 1) / 2; 2、区间没有重复数字 记录数组a[i]表示第i个数上一次在那个位置出现。 那么最需要在[L, R]中a[i]的最大值 >= L的，就是有重复数字了。 #inclu...
全网最最最最最详细的区间dp题目总结！！
y_immortal的博客 QwQ(qdez_ymh)
04-26 9924
QWQ最近在做一些区间dp的题，有感而发 嗯如果在阅读本文时遇到什么问题或者解法本身有什么漏洞，可以随时联系我 +q  752742355区间dp，顾名思义，就是解决一些区间内最优值的问题，通常的时间复杂度为n^2 或者 n^3而区间dp的大致思路就是首先确定状态初始化长度为1（or 2,3....具体因题而异）的dp数组的值然后枚举区间长度，枚举区间的起始点，（有的题目还需要枚举断点） 由小区间...
zoj题目简单归类zoj题目简单归类
08-02
题目要求判断一个序列中是否存在相邻的相同元素。解决策略是遍历序列，检查每个元素与其后继元素是否相等。 #### #2857 Average Value 题目要求计算一个矩阵中每个格子的三个数的平均值。解决策略是设计一个算法，...
百度之星程序设计大赛题目
06-20
3. **实现细节**：为了防止重复输出相同的序列，需要确保窗口内的数是从最小值开始递增的。此外，还需要考虑边界情况，比如当目标数本身就是一个连续序列（只包含自身）的情况。 **示例代码片段**（Python）： ```...
汇总区间（双指针）1
08-03
给定一个无重复元素的有序整数数组`nums`，任务是返回一个最小有序区间范围列表，使得数组中的每个元素都恰好被某个区间覆盖，并且没有区间覆盖到不在数组内的数字。 解题思路： 本题的解决方案主要使用了双指针的...
历年机试题目汇总1
08-04
这需要理解因子的概念，设计一个算法来求解一个区间内的所有孪生数对。 以上这些知识点涵盖了基础数学、算法、数据结构、文件操作、数值计算等多个IT领域的基础内容，是编程竞赛和面试中常见的问题类型。熟悉并掌握...
找出数组中重复的元素
往事撩人醉的博客
05-08 2117
注意：找出数组中重复的元素，数组中也有可能不存在重复的数，也有可能存在多个 方法一：使用位图法，再申请一个数组b，用b[a[i]]存储a[i]的重复次数： 方法二：使用map映射表。map是一个容器。第一个元素为关键字KEY，第二个元素为关键字的值。 #include &amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;lt;map&amp;am
校验区间范围是否重复
Hard_F的博客
07-30 1366
校验两组数据或多组数据的区间是否重复 例如： 第一组区间：1-10 包含 1、2、3、4……10等 第二组区间：8-15 包含 8、9、10、11……15等 第三组区间：16-20 包含 16、17、18、19、20 那么我们需要怎么做才能校验它们中间包含的重复数字呢？ 一般遇到这种情况有的同学可能想都不用想直接上手： List<Integer> integers = new ArrayList<>(); List<String> strs = new A.
算法-KMP字符串匹配
xx_xb的博客
07-23 163
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 385
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 642
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 733
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 303
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 529
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值