基础算法,贪心算法,贪心策略,OJ练习

文章目录

    • 一、概念
    • 二、OJ练习
      • 2.1 区间选点
      • 2.2 区间合并
      • 2.3 区间
      • 2.4 合并果子
      • 2.5 排队接水
      • 2.6 货仓选址
      • 2.7 防晒
      • 2.8 畜栏预定
      • 2.9 雷达设备
      • 2.10 国王游戏
      • 2.11 耍杂技的牛
      • 2.12 给树染色
      • 2.13 任务
      • 2.14 能量石
    • 三、总结


一、概念

贪心是一种在每次决策时采取当前意义下最优策略的算法,因此,使用贪心法要求问题的整体最优性可以由局部最优性导出。贪心算法的正确性需要证明,常见的证明手段有:

  1. 微扰(邻项交换)
    1. 证明在任意局面下,任何对局部最优策略的微小改变都会造成整体结果变差。经常用于以“排序”为贪心策略的证明。
  2. 范围缩放
    1. 证明任何对局部最优策略作用范围的扩展都不会造成整体结果变差
  3. 决策包容性
    1. 证明在任意局面下,作出局部最优决策以后,在问题状态空间中的可达集合包含了作出其他任何决策后的可达集合。换言之,这个局部最优策略提供的可能性包含其他所有策略提供的可能性。
  4. 反证法
  5. 数学归纳法

贪心算法在算法体系中较为特殊,这里通过几道例题来体会贪心算法的应用。

二、OJ练习

2.1 区间选点

区间选点 - 45D - Codeforces

题目保证了有解,我们该如何选出可行解呢?

我们考虑把区间按照右端点升序排序,然后遍历所有区间,对于每个区间选取区间内没有被选取的最左端点

如何证明正确性?——反证法

假设按照上述策略出现某个区间无点可选,该区间为[l, r],说明有r - l + 1个右端点不小于l,不超过r的区间选择了[l, r]内的r - l + 1个点

它们选择[l, r]内的点说明它们在[0, l - 1]的部分都被选完了,否则按照靠左原则应该选取[0, l - 1]的点,那么[l, r]内就存在r - l + 2个区间的右端点,此时原问题无解,与题目条件矛盾,故策略正确。

对于区间问题通用操作是按照某端点排序,在处理区间问题没有头绪的时候可以试着排序来寻找突破口。

n = int(input())lines = []for _ in range(n):a, b = map(int, input().split())lines.append((a, b, _))
lines.sort(key=lambda x: x[1])st = set()
ans = [0] * n
for l, r, idx in lines:for i in range(l, r + 1):if not (i in st):st.add(i)ans[idx] = ibreakfor x in ans:print(x, end=' ')

2.2 区间合并

P2082 区间覆盖(加强版) - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

即求区间合并后的长度

那么我们将区间按照左端点升序排序,然后顺序遍历区间

记录当前合并区间的左端点L,右端点R,对于遍历到的区间[l, r]

如果l > R,那么说明和前面的区间不相交,我们累加前面区间的长度后更新当前合并区间为[l, r]

否则,更新R = max(R, r)

证明很简单,就是假设存在两个可以合并的区间没有合并,然后反证推出矛盾即可,不再赘述。

n = int(input())
lines = [tuple(map(int, input().split())) for _ in range(n)]
lines.sort(key=lambda x: x[0])res = 0
L, R = 0, -1
for x, y in lines:if x <= R:R = max(R, y)else:res += R - L + 1L, R = x, y
print(res + (R - L + 1))

2.3 区间

[P2434 SDOI2005] 区间 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

和上一道题做法一样,是在上一道题目的基础上加上了输出具体方案

我们只需开一个数组表示当前的不合并区间数组,如果当前区间和最后一个不相交就加入数组,否则就维护最后一个区间的最右端点

n = int(input())
lines = [tuple(map(int, input().split())) for _ in range(n)]
lines.sort(key=lambda x: x[0])res = 0
ans = [lines[0]]
for x, y in lines:if x <= ans[-1][1]:ans[-1] = (ans[-1][0], max(ans[-1][1], y))else:ans.append((x, y))
for x, y in ans:print(x, y)

2.4 合并果子

148. 合并果子 - AcWing题库

很明显的贪心思路,每次区所有堆中最小的两堆合并即可

为什么是正确的呢?

我们合并的过程其实可以构造出一棵树,这棵树和Huffman树其实是等价的。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

上图中蓝色代表初始的果子堆,每个结点都是由两个孩子合并而来

初始蓝色结点的贡献为深度 乘 结点权值

我们只需证明按照贪心策略得到的树中:蓝色结点的权值 * 深度之和最小即可

引理:权值最小的两个点的深度一定最深,且互为兄弟

证明:如果不是,两个点中至少有一个可以和最后一层的某个权值不小于自身的结点交换,那么两个结点可以交换到最后一层并且成为兄弟,那么 蓝色结点的权值 * 深度之和至少不会变大,甚至变小,故得证

那么最优解的值等价于 权值最小的两个点的值相加 加上 两个点合并后与剩余的n - 2个点构造出的最优树的值

同样的,我们如此迭代下去,可以构造出一棵最优解树,故得证。

import heapq
n = int(input())
a = list(map(int, input().split()))
heapq.heapify(a)
res = 0
while len(a) > 1:x = heapq.heappop(a)y = heapq.heappop(a)res += x + yheapq.heappush(a, x + y)
print(res)

2.5 排队接水

P1223 排队接水 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

每个人接的越早,它的时间就会越多人忍受

所以我们让接的少的人优先接水即可

证明也很简单,同样反证,然后总可以按照贪心策略构造出不比最优解差甚至更优的解

n = int(input())
a = [(int(x), _ + 1) for _, x in enumerate(input().split())]
a.sort()
s = 0
for i, (x, idx) in enumerate(a):s += x * (n - i - 1)print(idx, end=' ')
print('')
print('%.2f' % (s / n))

2.6 货仓选址

104. 货仓选址 - AcWing题库

很经典的中位数问题,就是数轴上找到一个点y使得,Σ|x - y|最小

img

上图其实已经很明白了,当y选在两个数里面的差绝对值和总小于等于在两个数外面的差绝对值

那么我们剥洋葱似的一层一层往里钻,就会落到中位数处

n = int(input())
a = list(map(int, input().split()))
a.sort()mid = a[len(a) // 2]print(sum(abs(x - mid) for x in a))

2.7 防晒

110. 防晒 - AcWing题库

又是区间问题,不过这道题按照左右端点哪个排都能做,其实有点让每个资源发挥其最大作用的意思

怎么思考呢?我们把牛牛的区间按照右端点排序,然后顺序遍历牛牛每次选取在自己区间内最小的那个防晒霜

如何证明我们这样得到的一定是最优解?

我们可以证明对任意最优解按照贪心策略调整不会使得解变差从而得到一个最优解,我们也可以用范围缩放来证明,即我们的局部最优贪心策略对整体影响最小。

我们已经按照右端点排序,那么对于当前枚举奶牛的可用防晒霜x,y,SPF[x] < SPF[y]只有如下三种情况:

  • 后面奶牛x,y都能用
  • 后面奶牛只能用y
  • 后面奶牛x,y都不能用

我们发现我们选择x对后面奶牛影响最小,所以贪心策略正确。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
#define x first
#define y second
typedef pair<int, int> PII;
const int N = 2510;int n, m;
PII w[N];
map<int, int> mp;int main(){cin >> n >> m;for(int i = 0; i < n; i ++) cin >> w[i].x >> w[i].y;for(int i = 0, a, b; i < m; i ++) cin >> a >> b, mp[a] += b;sort(w, w + n, [](const PII& a, const PII& b){return a.y < b.y;});int res = 0;for(int i = 0; i < n; i ++){ //cout << w[i].x << ' ' << w[i].y << endl;auto it = mp.lower_bound(w[i].x);if (it != mp.end() && it -> first <= w[i].y) {it -> second --, res ++;if(! it -> second) mp.erase(it);}}cout << res;return 0;
}

2.8 畜栏预定

111. 畜栏预定 - AcWing题库

我们将牛按开始时间升序排序,然后枚举牛

如果对于当前牛有可以安排的畜栏(畜栏内最后一头牛结束时间不晚于当前牛的开始时间),那么我们就安排进去

如果没有,就新开一个畜栏

上述做法的正确性:

反证法:我们存在不同于上述策略的方案为更优解,只需m个畜栏,那么我们上述策略建立第m + 1个畜栏时,必然有m个畜栏的结束时间都大于当前牛的开始时间,而由于我们按照开始时间升序,故m个畜栏的最后一头牛都和当前牛区间有交集,等价于m + 1头牛两两有交集,所以我们至少需要m + 1个畜栏,矛盾,故得证。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
#define x first
#define y second
const int N = 5e4 + 10;
typedef pair<int, int> PII;
typedef pair<PII, int> PIII;
PIII lines[N];
int n, id[N];
priority_queue<PII, vector<PII>, greater<PII>> pq;
int main(){cin >> n;for(int i = 0, a, b; i < n; i ++) cin >> a >> b, lines[i] = { {a, b}, i };sort(lines, lines + n);for(int i = 0; i < n; i ++){if(pq.empty() || pq.top().x >= lines[i].x.x)pq.emplace(lines[i].x.y, id[lines[i].y] = pq.size() + 1);else{PII t = pq.top();pq.pop();t.x = lines[i].x.y;pq.emplace(t);id[lines[i].y] = t.y;}}cout << pq.size() << endl;for(int i = 0; i < n; i ++) cout << id[i] << endl;return 0;
}

2.9 雷达设备

112. 雷达设备 - AcWing题库

对于每个小岛而言,可以覆盖它的点对应x轴上一个区间,那么每个小岛就能够有一个可监测区间

我们只需选择尽可能少的点使得每个区间都被覆盖到即可,这就转化为了区间选点问题

我们将区间按照右端点排序,然后如果当前区间左端点小于覆盖区间的右端点,说明该区间可以被前面覆盖区间的点

否则我们就开一个新区间,所选的点为当前区间的右端点

from math import sqrt
n, d = map(int, input().split())
eps = 1e-6
lines = []
for _ in range(n):x, y = map(int, input().split())if y - d > eps:print(-1)exit(0)dx = sqrt(d * d - y * y)lines.append((x - dx, x + dx))lines.sort(key=lambda x: x[1])
ed = -2000
res = 0
for l, r in lines:if l - ed > eps:res += 1ed = r
print(res)

2.10 国王游戏

114. 国王游戏 - AcWing题库

本题贪心策略为:将大臣按照左手乘右手升序排序,此时的最大值最小

证明策略:临项交换(微扰)

我们假设最优解不是按照上述策略得到,那么一定存在a[i] * b[i] >= a[i + 1] * b[i + 1]

交换二者不影响其他大臣的收益

我们对比交换前后二者的收益:

交换前:i人:premul(i - 1) / bi i + 1人:premul(i - 1) * ai / bi+1

交换后:i人:premul(i - 1) / bi+1 i + 1人:premul(i - 1) * ai+1 / bi

四个数同乘 bi*bi+1/premul(i - 1):

交换前:i人:bi+1 i + 1人:ai bi

交换后:i人:bi i + 1人:ai+1 bi+1

由于ai * bi >= ai+1*bi+1,ai bi >= bi,则交换后整体的最大值没有变大,甚至变小

那么我们交换所有逆序对可以得到不比最优解差的解,故我们的贪心策略正确。

cpp要手写高精度

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<int, int> PII;
const int N = 1005;vector<int> mul(vector<int>& a, int x){int n = a.size(), t = 0;vector<int> ret;for(int i = 0; i < n; i ++){t += a[i] * x;ret.push_back(t % 10);t /= 10;}while(t) ret.push_back(t % 10), t /= 10;return ret;
}vector<int> div(vector<int>& a, int x){int n = a.size(), t = 0;vector<int> ret;for(int i = n - 1; ~i; i --){t = t * 10 + a[i];ret.push_back(t / x);t %= x;}reverse(ret.begin(), ret.end());while(ret.size() && !ret.back()) ret.pop_back();return ret;
}
vector<int> ma(const vector<int>& a, const vector<int>& b){if(a.size() > b.size()) return a;if(a.size() < b.size()) return b;if(vector<int>(a.rbegin(), a.rend()) > vector<int>(b.rbegin(), b.rend())) return a;return b;
}
int n;
PII w[N];int main(){cin >> n, n ++;for(int i = 0, a, b; i < n; i ++) cin >> a >> b, w[i] = { a, b };sort(w + 1, w + n, [](const PII& a, const PII& b){return a.first * a.second < b.first * b.second;});vector<int> cur(1, 1), res(1, 0);for(int i = 0; i < n; i ++){ if(i)res = ma(res, div(cur, w[i].second));cur = mul(cur, w[i].first);/*for(int x : vector<int>(cur.rbegin(), cur.rend()))cout << x;puts("");*/} for(int x : vector<int>(res.rbegin(), res.rend()))cout << x;return 0;
}

不想写高精度就用python3

n = int(input())
n += 1
w = [tuple(map(int, input().split())) for _ in range(n)]
cur ,res = w[0][0], 0
for a, b in sorted(w[1::], key=lambda x:x[0]*x[1]):res = max(res, cur // b)cur *= a
print(res)

2.11 耍杂技的牛

125. 耍杂技的牛 - AcWing题库

和上一题很像,这题按照w + s升序排序

和上一题同样的证明思路,不再赘述

n = int(input())
ws = [tuple(map(int, input().split())) for _ in range(n)]
pre = 0
ans = -1e18
for w, s in sorted(ws, key=lambda x:x[0]+x[1]):ans = max(ans, pre - s)pre += w
print(ans)

2.12 给树染色

115. 给树染色 - AcWing题库

错误的贪心:从根结点开始扩展,每次取当前最小权值的结点

很容易举出反例,可以自己试一下。

我们可以确定的事情是,当前除去根节点的最大权值结点会在其父节点被染色后立即被染色。

那么我们考虑当前最大结点x,父节点y,和任意结点z,染色顺序无非:

x,y,z,代价为x + 2y + 3z

z,x,y,代价为:z + 2x + 3y

二者做差有:2z - (x + y),可见当z大于x+y的平均值时才会先染x+y

那么我们在考虑当前树中剩余结点时,不妨将x,y当成一个结点,其权值为平均权值,然后就有了做法:

选择当前树中的最大权值,进行染色,由于它和父亲染色顺序为一前一后,所以染色后合并到父亲结点后面

我们合并n - 1次就只剩下一个结点,此时整棵树的染色顺序也就知道了

具体实现时,由于我们并不关心具体染色方案,所以为了简便,我们可以在合并时维护答案

考虑x合并到y上,由于要先染色y,所以x的权值要被加上y的sz次(sz为y结点的大小)

可以用并查集+堆优化到O(nlogn),不过这个数据量没必要,重要的还是这道题的思想

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;const int N = 1005;
const double eps = 1e-6;
struct node{int fa, sz, v;double avg;
}nodes[N];
int n, root, res;int nxt()
{double avg = 0;int res = -1;for (int i = 1; i <= n; i ++ )if (i != root && nodes[i].avg > avg){avg = nodes[i].avg;res = i;}return res;
}int main(){cin >> n >> root;for(int i = 1, v; i <= n; i ++){cin >> v, res += v;nodes[i] = { -1, 1, v, v };}for(int i = 1, a, b; i < n; i ++){cin >> a >> b;nodes[b].fa = a;}for(int i = 1; i < n; i ++){int t = nxt(), fa = nodes[t].fa;res += nodes[fa].sz * nodes[t].v;nodes[t].avg = -1;for(int j = 1; j <= n; j ++)if(nodes[j].fa == t) nodes[j].fa = fa;nodes[fa].sz += nodes[t].sz, nodes[fa].v += nodes[t].v, nodes[fa].avg = (double)nodes[fa].v / nodes[fa].sz;}cout << res;return 0;
}

2.13 任务

127. 任务 - AcWing题库

我们发现式子中x对于利润占主导,所以按x从大到小来进行考虑每个任务。对于每个任务从时间满足的机器中选择等级足够且最小的那个。

具体流程如下:

  • 按照x对任务和机器排序
  • 按x从大到小遍历任务,把时间充足的机器放入集合
  • 如果集合中存在等级足够的机器,那么选择等级最小的那个
  • 再处理下一个任务时,集合中的机器的时间都是足够的,我们只需考虑等级

时间复杂度:O(nlogn + mlogn)

#include <bits/stdc++.h>
using i64 = long long;
using PII = std::pair<int, int>;
const int N = 1e5 + 10, M = 1e5 + 10;
int n, m;
PII a[N], b[M];
int main(){std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);while (std::cin >> n >> m){for(int i = 0; i < n; i ++) std::cin >> a[i].first >> a[i].second;for(int i = 0; i < m; i ++) std::cin >> b[i].first >> b[i].second;std::sort(a, a + n), std::sort(b, b + m);std::multiset<int> st;i64 cnt = 0, res = 0;for(int i = m - 1, j = n - 1; ~i; i --){while(~j && a[j].first >= b[i].first)st.insert(a[j --].second);auto it = st.lower_bound(b[i].second);if(it != st.end()){cnt ++;res += 500 * b[i].first + 2 * b[i].second;st.erase(it);}}std::cout << cnt << ' ' << res << '\n';}return 0;
}

2.14 能量石

734. 能量石 - AcWing题库

01背包 + 临项交换

先暴力考虑所有情况,即全排列中依次求01背包

那么最优解是否存在某种特性呢?或者说,我们需要考虑的情况的范围能否缩小?

我们考虑最优解,相邻两个能量石s[i], s[i + 1]

二者的收益为:e’[i] + e’[i + 1] - s[i] * l[i + 1]

交换次序:e’[i] + e’[i + 1] - s[i + 1] * l[i]

由于是最优解,所以交换前的收益不小于交换后的收益:s[i] * l[i + 1] <= s[i + 1] * l[i]

那么说明最优解满足两两之间s[i] * l[i + 1] <= s[i + 1] * l[i]

所以我们将能量石按照s[i] / l[i]升序排序,然后跑01背包即可

#include <bits/stdc++.h>
#define sc scanf
using i64 = long long;
const int N = 105, M = 1e4 + 10;
struct node{int s, e, l;bool operator<(const node& x) const{return s * x.l < x.s * l;}
}nodes[N];int main(){int _ = 1;std::cin >> _;for(int t = 1, n, m; t <= _; t ++){std::cin >> n;m = 0;for(int i = 0, a, b, c; i < n; i ++) std::cin >> a >> b >> c, nodes[i] = { a, b, c }, m += a;std::sort(nodes, nodes + n);std::vector<i64> f(m + 1, -1e8);f[0] = 0;for(int i = 0; i < n; i ++){auto [s, e, l] = nodes[i];for(int j = m; j >= s; j --){f[j] = std::max(f[j], f[j - s] + e - (j - s) * l);}}printf("Case #%d: %lld\n", t, *std::max_element(f.begin(), f.end()));}return 0;
}

三、总结

很想从上面的问题中提取出某些东西,但是发现没有套路可言,只是遇到贪心问题时有了几个贪心的方向,区间类试着按端点排序,贪心构造,临项交换等等,但具体还得多做题。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/bicheng/10363.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Selenium获取网页参数信息(标题、网址、网页资源)

天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物。 每个人都有惰性&#xff0c;但不断学习是好好生活的根本&#xff0c;共勉&#xff01; 文章均为学习整理笔记&#xff0c;分享记录为主&#xff0c;如有错误请指正&#xff0c;共同学习进步。…

Python正则表达式入门指南

Python中的正则表达式是处理文本数据的强大工具&#xff0c;它可以用来搜索、匹配和替换文本中的特定模式。本指南将带你入门Python正则表达式的基础知识&#xff0c;并介绍一些常用的用法。 什么是正则表达式&#xff1f; 正则表达式&#xff08;Regular Expression&#xf…

Held-Karp算法解决旅行商问题(TSP)

Held-Karp算法是一种用于解决旅行商问题&#xff08;TSP&#xff09;的动态规划算法。它由Richard M. Karp在1972年提出&#xff0c;并且是第一个证明TSP问题具有多项式时间算法的算法。Held-Karp算法利用了TSP问题的对称性和结构&#xff0c;将问题分解为更小的子问题&#xf…

Vue详细介绍

Vue.js&#xff08;通常简称为Vue&#xff09;是一个用于构建用户界面的渐进式JavaScript框架。它由尤雨溪&#xff08;Evan You&#xff09;创建&#xff0c;并于2014年首次发布。Vue的设计目的是易于上手&#xff0c;同时也能够强大到驱动复杂的单页应用&#xff08;SPA&…

linux上使用mariadb安装mysql环境

之前都是手动安装mysql数据库&#xff0c;现在尝试下在线安装&#xff0c;为后面的项目部署做准备&#xff0c;突然发现使用mariadb安装mysql环境真的超级简单。 1.使用mariadb安装mysql 安装服务端&#xff1a; yum install mariadb-server -y 安装客户端&#xff1a; yum i…

数字孪生引擎国产信创环境适配靠谱么?

近期我们组织了一次国产化环境适配以及产品国产化产品替换的交流&#xff0c;虽然从属于不同的业务条线&#xff0c;但是在过去一段时间多多少少都承受不同程度的信创压力&#xff0c;尤其是自然资源业务方面&#xff0c;由于自然资源大多数的业务是属于强GIS的范畴&#xff0c…

docker容器技术篇:rancher管理平台部署kubernetes集群

rancher管理平台部署kubernetes集群 Rancher 是一个 Kubernetes 管理工具&#xff0c;让你能在任何地方和任何提供商上部署和运行集群。 Rancher 可以创建来自 Kubernetes 托管服务提供商的集群&#xff0c;创建节点并安装 Kubernetes&#xff0c;或者导入在任何地方运行的现…

【微服务】springcloud整合dubbo3使用nacos作为注册中心

目录 一、前言 二、springboot版本升级带来的问题 2.1 springboot为什么需要升级版本

GEE数据下载——1984-2022年指定区域的逐月地表水数据批量下载(JRC Monthly Water History, v1.4)

简介 JRC Monthly Water History, v1.4 JRC Monthly Water Recurrence, v1.4 以前的数据是JRC/GSW1_3/MonthlyHistory版本为1.3,现在的数据是JRC/GSW1_4/MonthlyHistory 1.4版本,GEE在数据中进行了更新。所以我们使用新的数据进行下载。JRC Monthly Water Recurrence, v1.…

[优选算法]------滑动窗⼝——209. 长度最小的子数组

目录 1.题目 1.解法⼀&#xff08;暴⼒求解&#xff09;&#xff08;会超时&#xff09;&#xff1a; 2.解法⼆&#xff08;滑动窗⼝&#xff09;&#xff1a; 1.算法思路&#xff1a; 2.手撕图解 3.代码实现 1.C 2.C语言 1.题目 209. 长度最小的子数组 给定一个含有 n…

AI绘画已如此厉害,为何我们仍需学习绘画?

在这个AI技术日新月异的时代&#xff0c;AI绘画能力的大幅提升已经不是什么新鲜事。它们以惊人的速度和惊人的精细度完成作品&#xff0c;让不少人感叹&#xff1a;“这是不是意味着&#xff0c;未来绘画将完全由AI接管&#xff0c;人类的创作将变得无足轻重&#xff1f;”在这…

C++笔试强训day18

目录 1.压缩字符串 2.chika和蜜柑 3.01背包 1.压缩字符串 链接 注意细节&#xff1a; 1.数量为一个时不用输出个数 2.当数量超过 9 时&#xff0c;需要逐个拿出 n 的位数&#xff0c;如153次&#xff0c;需要拿出1、5、3三个数 详细代码&#xff1a; class Solution { publ…

二叉树进阶 --- 中

目录 1. find 的递归实现 2. insert 的递归实现 3. erase 的递归实现 3.1. 被删除的节点右孩子为空 3.2. 被删除的节点左孩子为空 3.3. 被删除的节点左右孩子都不为空 4. 析构函数的实现 5. copy constructor的实现 6. 赋值运算符重载 7. 搜索二叉树的完整实现 1. fi…

【嵌入式开发 Linux 常用命令系列 7.5 -- awk 过滤指定列的字符串】

文章目录 背景 背景 问题&#xff1a; 以逗号为分隔符从test_data.h的第27409行开始找出第2列不为0x00000000的行。 为了寻找从test_data.h文件的第27409行开始&#xff0c;第2列不为0x00000000的行&#xff08;假设字段是以逗号分隔的&#xff09;&#xff0c;我们可以使用a…

树的基本介绍

引入 定义 表示 相关概念 结点&#xff1a;数据元素与指向分支的指针两部分组成 树的深度&#xff1a;树中结点的最大层次 将树A结点(根结点)去掉&#xff0c;树A就变成了森林 区别 实现

再谈毕业论文设计投机取巧之IVR自动语音服务系统设计(信息与通信工程A+其实不难)

目录 举个IVR例子格局打开&#xff0c;万物皆能IVR IVR系统其实可盐可甜。还能可圈可点。 戎马一生&#xff0c;归来依然IVR。 举个IVR例子 以下是IVR系统的一个例子。 当您拨打电话进入IVR系统。 首先检验是否为工作时间。 如是&#xff0c;您将被送入ivr-lang阶段&#xff0…

管道液位传感器可以应用在哪些领域

管道液位传感器是一种利用光学原理来检测水管液位的传感器&#xff0c;其工作原理基于光线在水和空气中折射率不同的特性。通过光电管道传感器&#xff0c;可以有效解决传统机械式传感器存在的低精度、卡死失效等问题&#xff0c;同时也避免了电容式传感器因感度衰减而导致的不…

【Linux笔记】 基础指令(二)

风住尘香花已尽 日晚倦梳头 重命名、剪切指令 -- mv 简介&#xff1a; mv 命令是 move 的缩写&#xff0c;可以用来移动文件或者将文件改名&#xff0c;是 Linux 系统下常用的命令&#xff0c;经常用来备份文件或者目录 语法&#xff1a; mv [选项] 源文件或目录 目标文件或目录…

泵站远程启停

随着物联网技术的迅猛发展&#xff0c;传统泵站的管理方式正面临前所未有的变革。在这一变革的浪潮中&#xff0c;HiWoo Cloud平台凭借其卓越的技术实力和创新理念&#xff0c;为泵站远程启停控制带来了全新的解决方案。本文将详细介绍HiWoo Cloud平台在泵站远程启停方面的应用…

红魔6/6pro9008救砖刷机详细教程

1. 安装驱动和打开工具&#xff1a; - 首先安装高通Qualcomm驱动。 - 安装完成后&#xff0c;以管理员权限打开Qualcomm_tool高通工具。 2. 选择引导文件&#xff1a; - 选择引导刷机包内的ELF引导文件&#xff0c;并点击打开。 3. 配置rawprogram XML文件&#xff1a; - 点击r…