STL(5)—set和map的使用与AVL树的插入(四种旋转情况)

已于 2022-05-21 10:52:10 修改
阅读量232 收藏
点赞数
分类专栏： C/C++学习 高级数据结构 文章标签： C++ 数据结构与算法 AVL树 STL
于 2022-05-16 16:48:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CS_COPy/article/details/124802936
版权

- 本人的LeetCode账号：Router，欢迎关注获取每日一题题解，快来一起刷题呀~

一、关联式容器

  STL容器中，底层为线性序列的数据结构的容器vector list deque forward_list，这些容器被称为序列式容器；

  关联式容器也是来存储数据的，插入元素时，数据是必须往固定的位置插入的，数据之间有着强烈的关联关系，因此数据的检索效率会更高。

二、key模型有序序列set

  原型：

  第二个参数是仿函数，用来给内部进行比较。

1 简单使用

  所有的容器都可以用范围for或迭代器来遍历，其中范围for的底层的原理就是迭代器。

int main()
{
	set<int> myset;
	myset.insert(1);
	myset.insert(3);
	myset.insert(-5);
	myset.insert(9);
	myset.insert(-10);
	auto it = myset.begin();
	while (it != myset.end())
	{
		cout << *it << ' ';
		++it;
	}
	return 0;
}

2 迭代器

  显然支持正向和反向迭代器的set的迭代器是一个双向迭代器。

3 修改容器

  它的删除支持给一个迭代器位置删除、给一个值删除、或者给一个迭代器区间删除：

  删除一个迭代器位置和删除一个值的区别：如果按迭代器位置删除，给的是一个无效迭代器，很可能会报错。

int main()
{
	set<int> myset;
	myset.insert(1);
	myset.insert(3);
	myset.insert(-5);
	myset.insert(9);
	myset.insert(-10);
	auto it = myset.begin();
	while (it != myset.end())
	{
		cout << *it << ' ';
		++it;
	}
	cout << endl;
	it = myset.find(10);
	myset.erase(it);
	for (auto e : myset)
	{
		cout << e << ' ';
	}
	return 0;
}

  而用值删除，如果目标元素不存在，我们直接删，它不会给我报错，会通过返回值告诉我被删除的数据的个数：

  对于set来说，返回1表示这个元素存在且被删除，返回0表示这个元素不存在。

  交换：

4 lower_bound和upper_bound

  set维护的是一个有序集合，其lower_bound(val)返回的是第一个不在val之前的元素的迭代器。（即如果set中有val，它可以是指向val的迭代器）。

  upper_bound(val)返回的是第一个在val之后的元素的迭代器，如果set中有val，它会指向它之后的一个元素。

二、multiset

  为了解决排序而不去重的需求，multiset容器应运而生。

  它的接口和set的接口都类似，区别在哪呢？

  它可以直接排序，并且元素重复时依然允许我们插入。

1 multiset的find

  既然multiset中可能有重复元素，那么我们find(重复元素)返回的迭代器到底是指向谁的?

  可见它找的是中序的第一个结点，返回的是中序的第一个值所在的结点的迭代器。

2 multiset的erase

  按迭代器删除只删除迭代器指向的节点，按值删除可以在multiset中删除所有值为val的结点。

  这里如果一个一个删除，那么也可能出现迭代器失效的问题，而C++98中没有用返回值来防止迭代器失效，C++11给了我们用返回值来防止这种迭代器失效的场景：

  如果不能用C++11，你可以提前储存下一个位置的迭代器来规避迭代器失效。

  不过一次性删除multiset中所有值为val的元素，我们可以按值删除。

  set没有像其他容器一样给我们提供专门的修改接口，就算通过迭代器也不能修改，*it在set中是常引用，无法修改。

  因为擅自修改一个值，很可能直接破坏了搜索树的结构，有的结构破坏了以后，没法通过旋转等操作弄回来。

三、key-value模型有序序列map

  每个结点除了存一个Key，还存了一个T,它是使用pair<const Key, T>键值对实现的。

1 map的简单使用

  map的大部分操作和set都相同，除了这个operator[]：

  它的insert：

  它的value_type是pair去typedef出来的。

  它的遍历不能直接把pair输出出来，因为pair没有去重载operator<<，

void test_map1()
{
	map<string, string> dict;
	// 第一种插入方式
	pair<string, string> p1("sort", "排序");
	dict.insert(p1);
	// 第二种插入方式 匿名对象
	dict.insert(pair<string, string>("unique", "不同的"));
	// 还可使用make_pair 优势在于自动推导类型
	dict.insert(make_pair("value", "值"));
	// 还可以用{}
	dict.insert({ "type", "类型" });
	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		cout << '(' << (*it).first << ' ' << (*it).second << ')';
        // 还是operator->看起来正常
		cout << '(' << it->first << ' ' << it->second << ')';
		++it;
	}
	cout << endl;
    // 范围for
	for (auto& p : dict)
	{
		cout << '(' << p.first << ',' << p.second << ')' << endl;
	}
}

  这里排序是按key进行排序的。

  erase和find和set的类似，但是是只针对key做查找和删除。

2 map的operator[]

  map的key不支持修改，但是其value支持修改。

  如果我们朴素的去统计一个字典中单词出现的次数：

void test_map2()
{
	string arr[] = { "苹果", "香蕉", "菠萝", "香蕉", "苹果", "梨", "苹果" };
	map<string, int> cnt;
	for (auto& s : arr)
	{
		auto it = cnt.find(s);
		if (it == cnt.end()) cnt.insert(make_pair(s, 1));
		else
		{
			++(*it).second;
		}
	}
}

  这里还可以优化一下，cnt.find查找一次，cnt.insert再查找一次。

  我们先看这个insert的返回值：

  如果key已经存在了，返回值的第二个成员为true，第一个成员就是新位置的迭代器，如果已经存在了，那么第二个成员为false，第一个成员为就是已经存在的位置的迭代器。

  所以不用find了，直接用insert的返回值来搞就行了

void test_map2()
{
	string arr[] = { "苹果", "香蕉", "菠萝", "香蕉", "苹果", "梨", "苹果" };
	map<string, int> cnt;
	for (auto& s : arr)
	{
		// 如果是key第一次出现 直接就插入进去了 pb.second == true
		auto pb = cnt.insert(make_pair(s, 1));
		// 如果插入失败 说明key不是第一次出现 这时
		// 返回了一个迭代器指向已经出现的节点
		// 然后利用这个迭代器++其second(次数)
		if (pb.second == false)
		{
			pb.first->second++;
		}
	}
    for (auto& kv : cnt)
	{
		cout << kv.first << ':' << kv.second << endl;
	}
}

  但是其实更常用的做法是使用operator[]

void test_map2()
{
	string arr[] = { "苹果", "香蕉", "菠萝", "香蕉", "苹果", "梨", "苹果" };
	map<string, int> cnt;
	for (auto& s : arr)
	{
		++cnt[s];
	}
	for (auto& kv : cnt)
	{
		cout << kv.first << ':' << kv.second << endl;
	}
}

  以前的operator[]是数组行为，但这里operator[]是以关键字来返回value的引用，如果不存在则插入：

// 这是operator[]的简略等价版本
(*((this->insert(make_pair(k,mapped_type()))).first)).second

  含义就是this调用insert函数，插入make_pair(k,mapped_type())，然后得到其返回值pair<iteraot, bool>的first，即那个key位置的迭代器，然后解引用这个迭代器去访问其second，访问到value.

  所以这个operator[]同时做到了插入、查找、修改value的功能，如果[key]第一次出现，那么它会做到插入并且返回刚初始化的value的引用，如果[key]不是第一次出现，通过查找返回value的引用，然后可以通过其他运算修改这个值。

  operator的三种作用：

dict["string"];// 单纯插入
dict["sort"] = "排序"; // 插入加排序
dict["sort"] = "不想玩了"; // 修改

四、multimap

  它的用法和map的用法几乎一致，和multiset一样，如果key存在它仍然会继续插入。

  因此它就没有operator[]，因为key相同的可能有很多节点，我到底要返回哪一个呢？

void test_map3()
{
	multimap<string, string> mdict;
	mdict.insert(make_pair("排序", "sort"));
	mdict.insert(make_pair("排序", "mysort"));
	for (auto& e : mdict)
	{
		cout << e.first << ' ' << e.second << endl;
	}
}

  它支持count，会返回关键字等于key的节点的个数。

  erase和multiset也是一样，传迭代器就删除一个结点，传键值就删除所有键值为key的结点。

  对于topk问题，数据量不大时，我们可以用map<string, int>计数，然后vector<map<string, int>::iterator>加函数对象排序；

  也可以用multimap<int, string>把<次数, 关键字>存进来并排序，降序的话搞个greater<int>进去就行。

五、平衡二叉树—AVL树

  前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是： 其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接 近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构 是对二叉树进行了平衡处理，即采用平衡树来实现。

  AVL树又称高度平衡二叉搜索树，以高度来控制二叉搜索树的平衡。

  二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

  AVL树有很多实现方法，其中一种比较经典的实现方式就是去使用平衡因子（右子树高度减左子树高度），这种情况下，AVL树要求：

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

  如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 ，搜索时间复杂度O(logN)，效率就非常高，如果往AVL树中插入10亿个结点，它最多查找30次。

1 基础结构

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;// 三叉链
	pair<K, V> _kv;

	int _bf;// 平衡因子
	// 不加平衡因子需要用递归实现 不好理解
	// 新增结点平衡因子为0
	AVLTreeNode(const pair<K, V>& kv = pair<K, V>()) 
		: _kv(kv), _left(nullptr), _right(nullptr), _parent(nullptr), _bf(0)
	{}
};
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree() : _root(nullptr) {}
private:
	Node* _root;
};

2 插入

  插入时，要更新祖先的平衡因子（更新到根也会结束），更新逻辑：

  1. cur == parent->left，parent->bf--。
  2. cur == parent->right，parent->bf++。
  3. 如果更新后parent->bf == 0，说明更新前parent的bf是1或-1，现在变成0，说明填上了矮的那边，parent所在的子树高度不变，自然更新结束。
  4. 更新以后，parent->bf == 1 / -1，当前parent所在子树是平衡的，但是要继续往上更新新插入结点的影响，说明更新前parent的bf是0，新插入的节点使得高度变高了，需要继续往上更新。
  5. 更新以后，parent->bf == 2 / -2，则说明parent所在的子树已经不平衡了，需要旋转处理

  我们提供一下插入的总框架：

// 插入
bool Insert(const pair<K, V> &kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        return true;
    }
    Node *parent = nullptr;
    Node *cur = _root;
    while (cur)
    {
        if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else
            return false;
    }
    // 插入一个结点 只会影响它的祖先的平衡因子
    cur = new Node(kv);
    cur->_parent = parent;
    if (parent->_kv.first > cur->_kv.first)
    {
        parent->_left = cur;
    }
    else
    {
        parent->_right = cur;
    }
    // 控制平衡
    // 1、更新平衡因子
    // 2、出现异常的平衡因子(2, -2)，那么需要“旋转平衡树"
    while (parent)
    {
        if (parent->_left == cur)
        {
            --parent->_bf;
        }
        else
        {
            ++parent->_bf;
        }

        if (parent->_bf == 0)
        {
            break; // 平衡因子变成0的情况 直接停止更新
        }
        else if (abs(parent->_bf) == 1)
        {
            // 平衡因子没有破坏平衡
            // 继续往上更新
            cur = parent;
            parent = parent->_parent;
        }
        else if (abs(parent->_bf) == 2)
        {
            // 旋转处理
            if (parent->_bf == -2 && cur->_bf == -1)
            {
                // 这种情况就是右单旋转
                RotateR(parent);
            }
            // 左单选
            else if (parent->_bf == 2 && cur->_bf == 1)
            {
                RotateL(parent);
            }
            // 左右双旋
            else if (parent->_bf == -2 && cur->_bf == 1)
            {
                RotateLR(parent);
            }
            // 右左双旋
            else if (parent->_bf == 2 && cur->_bf == -1)
            {
                RotateRL(parent);
            }
            break;
        }
        else
        {
            // 说明插入平衡因子之前这个位置就出问题了
            // assert断掉
            assert(false);
        }
    }
    return true;
}

3 旋转的情况

I 右单旋(左边高)

  注意这个过程要控制三叉链，结合下面的图，我们写出代码：

// 右单旋
void RotateR(Node* parent)
{
    Node* subL = parent->_left;
	Node* subLR = subL->_right;
    Node* parentParent = parent->_parent;
	subL->_right = parent;
    parent->_parent = subL;
	parent->_left = subLR;
    if (subLR)
		subLR->_parent = parent;
    if (parent == —_root)
	{
        _root = subL;
		subL->_parent = nullptr;
	}
    else
	{
        if (parentParent->_left == parent) parentParent->_left = subL;
		else parentParent->_right = subL;
		subL->_parent = parentParent;
    }
	subL->_bf = parent->_bf = 0;
}

II 左单旋(右边高)

  同理，这里就是反过来了，parent的平衡因子是2，cur的平衡因子是1，只要画出图来，注意维护三叉链，很快就能写出来：

// 左单旋 平衡因子为parent == 2 cur == 1
// 转后平衡因子为0,0
void RotateL(Node* parent)
{
    Node* subR = parent->_right;
	Node* subRL = subR->_left;
    Node* parentParent = parent->_parent;
	parent->_parent = subR;
    subR->_left = parent;
	parent->_right = subRL;
    if (subRL) subRL->_parent = parent;
	if (parent == _root)
    {
		_root = subR;
        subR->_parent = nullptr;
	}
	else
    {
		if (parentParent->_left == parent)
        {
			parentParent->_left = subR;
		}
        else parentParent->_right = subR;
		subR->_parent = parentParent;
	}
    subR->_bf = parent->_bf = 0;
}

III 左右双旋和右左双旋

// 左右双旋
void RotateLR(Node *parent)
{
    // 先选parent的左孩子 进行左旋
    RotateL(parent->_left);
    // 再把parent进行右旋
    RotateR(parent);
    // 平衡因子更新：
}
// 右左双旋
void RotateRL(Node *parent)
{
    // 先旋parent的右孩子 进行右旋
    RotateR(parent->_right);
    // 再把parent进行左旋
    RotateL(parent);
    // 平衡因子更新
}

  如何在左右双旋的情况下更新平衡因子我们稍后讨论。

4 验证平衡

  手动验证未免过于麻烦，我们遍历每个点，如果每个点的左右子树的高度差小于一即说明平衡，否则说明不平衡。

bool _isBalance(Node *root)
{
    if (root == nullptr)
        return true;
    int leftheight = _height(root->_left);
    int rightheight = _height(root->_right);

    // 检查平衡因子是否异常
    if (rightheight - leftheight != root->_bf)
    {
        cout << root->_kv.first << "现在是" << root->_bf << endl;
        cout << root->_kv.first << "应该是" << rightheight - leftheight << endl;
        return false;
    }

    return abs(leftheight - rightheight) < 2 && _isBalance(root->_left) && _isBalance(root->_right);
}

int _height(Node *root)
{
    if (root == nullptr)
        return 0;
    int leftheight = _height(root->_left);
    int rightheight = _height(root->_right);
    return 1 + max(leftheight, rightheight);
}

  发现这组测试用例:{4, 2, 6, 1, 3, 5, 15, 7, 16, 14}通过不了验证：

void TestAVLTree1()
{
	AVLTree<int, int> t;
	//int a[] = { 5, 4, 3, 2, 1 };
	// int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	// int a[] = { 1, 2, 3, 4, 5 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto& e : a)
	{
		t.Insert(make_pair(e, e));
		if (!t.isBalance())
		{
			cout << "插入" << e << "出问题了" << endl;
		} 
	}
	t.Inorder();
	if (!t.isBalance()) cout << "该树异常" << endl;
}

  它的问题在于我们右左双旋时，平衡因子都是按照单旋时的平衡因子更新，没有做对应的平衡因子更新

5 右左双旋平衡因子更新

  触发右左双旋的三个场景如下，并且它们引发的不同平衡因子更新变化结果如下：

  方法是去识别60的平衡因子，插入结点后，旋转前，第一种情况“60”的平衡因子是1，第二种情况“60”的平衡因子是-1，第三种情况60的平衡因子是0.

// 左右双旋
void RotateLR(Node *parent)
{
    Node *subL = parent->_left;
    Node *subLR = subL->_right;
    int checkbf = subLR->_bf;
    // 先选parent的左孩子 进行左旋
    RotateL(parent->_left);
    // 再把parent进行右旋
    RotateR(parent);
    // 平衡因子更新：
    if (checkbf == -1)
    {
        // 图1
        parent->_bf = 1;
        subLR->_bf = subL->_bf = 0;
    }
    else if (checkbf == 1)
    {
        // 图2
        subL->_bf = -1;
        subLR->_bf = parent->_bf = 0;
    }
    else
    {
        // 图3
        subL->_bf = subLR->_bf = parent->_bf = 0;
    }
}

6 左右双旋平衡因子更新

  仿照右左双旋平衡因子更新的方法，画出图来：

// 左右双旋
void RotateLR(Node *parent)
{
    Node *subL = parent->_left;
    Node *subLR = subL->_right;
    int checkbf = subLR->_bf;
    // 先选parent的左孩子 进行左旋
    RotateL(parent->_left);
    // 再把parent进行右旋
    RotateR(parent);
    // 平衡因子更新：
    if (checkbf == -1)
    {
        // 图1
        parent->_bf = 1;
        subLR->_bf = subL->_bf = 0;
    }
    else if (checkbf == 1)
    {
        // 图2
        subL->_bf = -1;
        subLR->_bf = parent->_bf = 0;
    }
    else
    {
        // 图3
        subL->_bf = subLR->_bf = parent->_bf = 0;
    }
}

7 通过验证

8 AVL树的删除

  因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不 同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

  因为比较复杂，这里不做讲解，详细可以参考《算法导论》或者《数据结构-用面向对象方法与C++描述》殷人昆版。

9 AVL树的性能

  AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即logN 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如： 插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。 因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树， 但一个结构经常修改，就不太适合。

  我们来测试一下AVL树插入1e9个结点的速度和它的高度。

  可以看到AVL树的插入的效率还是很不错的。

魔术师的徒弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL_Tree实现STL中的map, set, multimap和multiset
01-10
用AVL-tree数据结构作为底层机制，以STL底层空间配置器和iterator_traits编程技法实作出一个独立的关联式容器(map, set, multimap, multiset)，并对外提供接口实现和STL完全兼容的容器。
【C++】使用AVL平衡树实现一个类似STL的Map
icykitty的博客
11-09 765
我才学完AVL，感觉AVL好像能实现类似map这样的功能，于是做了这样一个模板类。（后来知道stl的map也是用平衡树实现的，但是是用内建的红黑树，更高级一点） #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;string&gt; using namespace std; /* Map使用起来就像一个强大的数组，但...
STL之AVL树
HN_gsf的博客
08-16 1730
关联式容器 之所以说是关联式容器，每笔数据都有一个键值和一个实值，当元素插入关联式容器时，容器会按照键值大小， 依据特定规则（set，multiset，map，multimap是红黑书，hash是hash表）将元素放在特定位置； 所以关联式容器就不会有push_back( )  pop_back( ) push_front( ) pop_front( )等操作； 首先了解一下树的深
STL AVL map/set library-开源
04-26
这是使用AVL树而不是Red-Black树（当前libstdc ++中存在）的g ++完全兼容STL的C ++映射/集合/多图/多集实现。
数据结构之红黑树详解
12-31
在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行...
红黑树: 理论与实现
04-19
红黑树是一种很有意思的平衡检索树。...在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。
STL源码剖析.pdg
01-12
第1章 stl 概论与版本简介001 1.1 stl 概论 001 1.1.1 stl的历史 003 1.1.2 stl与c++ 标准程序库 003 . 1.2 stl 六大组件 - 功能与运用 004 1.3 gnu源码开放精神 007 1.4 hp stl实现版本 009 1.5 p.j. ...
背包问题—动态规划
weixin_50470247的博客
06-10 146
与找521 零钱兑换的方式的区别，这个是排列，顺序不同，也统计次数。01背包问题：没有物品（元素）只能选择1次。完全背包，物品(元素)个数有无限个。
论文阅读笔记：DepGraph: Towards Any Structural Pruning
最新发布
HollowKnightz的博客
06-15 1245
论文阅读笔记：DepGraph: Towards Any Structural Pruning
LeetCode452用最少数量的箭引爆气球
JELEE
06-14 101
有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被 引爆。可以射出的弓箭的数量 没有限制。弓箭一旦被射出之后，可以无限地前进。
Python | Leetcode Python题解之第149题直线上最多的点数
Mopes__的博客
06-14 467
Python | Leetcode Python题解之第149题直线上最多的点数
FreeRTOS简单内核实现2 双向链表
lc_guo的博客
06-14 754
FreeRTOS 的 list.c / list.h 文件中有 3 个数据结构、2 个初始化函数、2 个插入函数、1 个移除函数和一些宏函数，链表是 FreeRTOS 中的重要数据结构
算法训练题day57
stmfresher的博客
06-12 154
不太一样，如果是连续的那代码就一样了，这里的区别就在于如果两个字符不相等，应该取max(dp[i - 1][j], dp[i][j - 1])这道题其实可以转换成寻找两个数组中不连续的子序列的最大长度，就和上题一样了。其实动态规划和贪心的本质上都是一样的。这道题的子序列是不连续的，所以很。
【代码随想录训练营】【Day 50】【动态规划-9】| Leetcode 198, 213, 337
qq_44574200的博客
06-10 432
【代码随想录训练营】【Day 50】【动态规划-9】| Leetcode 198, 213, 337。
集成算法实验(Bagging策略)
weixin_50917576的博客
06-12 1022
Bagging：训练多个分类器取平均fx1/M∑m1M​fm​x全称： bootstrap aggregation（说白了就是训练一堆分类器）最典型的代表就是随机森林，现在Bagging模型基本上也是随机森林。随机：数据采样随机，；数据有多个特征(属性)组成，。随机是为了使得每个分类器拥有明显差异性。森林：很多个决策树并行放在一起如何对所有树选择最终结果？分类的话可以采取少数服从多数，回归的话可以采用取平均值。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 343
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
【Android面试八股文】请讲一讲AQS的原理
字节卷动
06-11 212
AQS即,是一个用于构建锁和同步器的框架。它能降低构建锁和同步器的工作量，还可以避免处理多个位置上发生的竞争问题。在基于AQS构建的同步器中，只可能在一个时刻发生阻塞，从而降低上下文切换的开销，并提高吞吐量。AQS使用内部的FIFO（先进先出）等待队列来管理线程的争用和调度，其中一个常见的算法实现就是CLH队列锁。CLH（Craig, Landin, and Hagersten）锁是一种基于链表的自旋锁，最早是由Craig、Landin和Hagersten提出的。
FreeRTOS 简单内核实现1 前言
lc_guo的博客
06-14 682
深入理解 RTOS 内核工作机制，自己动手从 0 到 1 编程一个简单的 RTOS 内核，实现任务并行工作的效果
算法题day43（补5.29日卡：动态规划03）
TIANBIU的博客
06-13 247
③初始化：dp[i][0]=0 for i in range(len(weight)（容量为0，装不了东西）①状态转移方程：dp[j] = max(dp[j],dp[j - weight[i]] + value[i])第i件物品的重量是weight[i],得到的价值是value[i]。①dp[i][j]的含义：从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。放物品：此时dp[i-1][j-weight[i]+value[i]不放物品：此时dp[i][j]=dp[i-1][j]
map和set的底层为什么使用红黑树，而不使用AVL树
03-25
map和set使用红黑树的主要原因是红黑树的平衡性能相对较好且实现比较简单，而AVL树的平衡性能更好但实现相对较为复杂。在实际使用中，红黑树的优越性能已经足够满足大部分的需求，因此STL中的map和set选择了红黑树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值