【深度优先搜索】【树】【图论】2973. 树中每个节点放置的金币数目

作者推荐

视频算法专题

本博文涉及知识点

深度优先搜索 树 图论 分类讨论

LeetCode2973. 树中每个节点放置的金币数目

给你一棵 n 个节点的 无向 树，节点编号为 0 到 n - 1 ，树的根节点在节点 0 处。同时给你一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间有一条边。
给你一个长度为 n 下标从 0 开始的整数数组 cost ，其中 cost[i] 是第 i 个节点的 开销 。
你需要在树中每个节点都放置金币，在节点 i 处的金币数目计算方法如下：
如果节点 i 对应的子树中的节点数目小于 3 ，那么放 1 个金币。
否则，计算节点 i 对应的子树内 3 个不同节点的开销乘积的 最大值 ，并在节点 i 处放置对应数目的金币。如果最大乘积是 负数 ，那么放置 0 个金币。
请你返回一个长度为 n 的数组 coin ，coin[i]是节点 i 处的金币数目。
示例 1：
在这里插入图片描述

输入：edges = [[0,1],[0,2],[0,3],[0,4],[0,5]], cost = [1,2,3,4,5,6]
输出：[120,1,1,1,1,1]
解释：在节点 0 处放置 6 * 5 * 4 = 120 个金币。所有其他节点都是叶子节点，子树中只有 1 个节点，所以其他每个节点都放 1 个金币。
示例 2：
在这里插入图片描述

输入：edges = [[0,1],[0,2],[1,3],[1,4],[1,5],[2,6],[2,7],[2,8]], cost = [1,4,2,3,5,7,8,-4,2]
输出：[280,140,32,1,1,1,1,1,1]
解释：每个节点放置的金币数分别为：

  • 节点 0 处放置 8 * 7 * 5 = 280 个金币。
  • 节点 1 处放置 7 * 5 * 4 = 140 个金币。
  • 节点 2 处放置 8 * 2 * 2 = 32 个金币。
  • 其他节点都是叶子节点，子树内节点数目为 1 ，所以其他每个节点都放 1 个金币。
    示例 3：
    在这里插入图片描述

输入：edges = [[0,1],[0,2]], cost = [1,2,-2]
输出：[0,1,1]
解释：节点 1 和 2 都是叶子节点，子树内节点数目为 1 ，各放置 1 个金币。节点 0 处唯一的开销乘积是 2 * 1 * -2 = -4 。所以在节点 0 处放置 0 个金币。

提示：
2 <= n <= 2 * 104
edges.length == n - 1
edges[i].length == 2
0 <= ai, bi < n
cost.length == n
1 <= |cost[i]| <= 104
edges 一定是一棵合法的树。

分类讨论

情况表面上很多，时间上只有4情况：
{ 1 不足 3 个节点 最大的三个正数的乘积 至少 3 个正数节点 1 个正数和 2 个负数的乘积 至少一个正数节点， 2 个负数节点 0 o t h e r \begin{cases} 1 &不足3个节点 \\ 最大的三个正数的乘积 & 至少3个正数节点\\ 1个正数和2个负数的乘积 & 至少一个正数节点，2个负数节点\\ 0 & other \\ \end{cases} ⎩ ⎨ ⎧​1最大的三个正数的乘积1个正数和2个负数的乘积0​不足3个节点至少3个正数节点至少一个正数节点，2个负数节点other​
正数节点都只需要记录3个节点，2个不够。

3个负数节点，0个正数节点。值是0。
2个负数节点，0个正数节点。值是1。
注意：cost[i]不会为0。

代码

核心代码

class CNeiBo2
{
public:
	CNeiBo2(int n, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase)
	{
		m_vNeiB.resize(n);
	}
	CNeiBo2(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase)
	{
		m_vNeiB.resize(n);
		for (const auto& v : edges)
		{
			m_vNeiB[v[0] - iBase].emplace_back(v[1] - iBase);
			if (!bDirect)
			{
				m_vNeiB[v[1] - iBase].emplace_back(v[0] - iBase);
			}
		}
	}
	inline void Add(int iNode1, int iNode2)
	{
		iNode1 -= m_iBase;
		iNode2 -= m_iBase;
		m_vNeiB[iNode1].emplace_back(iNode2);
		if (!m_bDirect)
		{
			m_vNeiB[iNode2].emplace_back(iNode1);
		}
	}
	const int m_iN;
	const bool m_bDirect;
	const int m_iBase;
	vector<vector<int>> m_vNeiB;
};

class Solution {
public:
	vector<long long> placedCoins(vector<vector<int>>& edges, vector<int>& cost) {
		m_vAns.resize(cost.size());
		m_cost = cost;
		CNeiBo2 neiBo(cost.size(), edges, false);
		std::priority_queue<int> maxHeap;
		std::priority_queue<int, vector<int>, greater<int> > minHeap;
		DFS(maxHeap, minHeap, neiBo.m_vNeiB, 0, -1);
		return m_vAns;
	}
	void DFS(std::priority_queue<int>& maxHeap, std::priority_queue<int, vector<int>, greater<int> >& minHeap,const vector<vector<int>>& neiBo, int cur, int par)
	{
		if (m_cost[cur] >= 0)
		{
			minHeap.emplace(m_cost[cur]);
		}
		else
		{
			maxHeap.emplace(m_cost[cur]);
		}
		for (const auto& next : neiBo[cur])
		{
			if (next == par)
			{
				continue;
			}
			std::priority_queue<int> maxHeap1;
			std::priority_queue<int, vector<int>, greater<int> > minHeap1;
			DFS(maxHeap1,minHeap1,neiBo, next, cur);
			Union(maxHeap, maxHeap1);
			Union(minHeap, minHeap1);
		}
		auto Cal = [&]()
		{
			if (maxHeap.size() + minHeap.size() <3 )
			{
				return 1LL;
			} 
			long long llRet = 0;
			auto v1 = ToVector(minHeap);
			auto v2 = ToVector(maxHeap);			
			if (3 == minHeap.size())
			{		
				llRet =max(llRet, (long long)v1[0] * v1[1] * v1[2]);
			}
			if (minHeap.size()&& (maxHeap.size() >= 2))
			{				
				if (v2.size() > 2)
				{
					v2.erase(v2.begin());
				}				
				llRet = max(llRet, (long long)v1.back() * v2[0] * v2[1]);
			}
			return llRet;
		};
		m_vAns[cur] = Cal();
	}

protected:
	template<class T>
	vector<int> ToVector(T heap)
	{
		vector<int> v;
		while (heap.size())
		{
			v.emplace_back(heap.top());
			heap.pop();
		}
		T heap2(v.begin(), v.end());
		heap2.swap(heap);
		return v;
	}
	template<class T>
	void Union(T& heap1, T& heap2)
	{
		while (heap2.size())
		{
			heap1.emplace(heap2.top());
			heap2.pop();
		}
		while (heap1.size() > 3)
		{
			heap1.pop();
		}
	}
	vector<long long> m_vAns;
	vector<int> m_cost;
};

测试用例

template<class T,class T2>
void Assert(const T& t1, const T2& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}

}

int main()
{
	vector<vector<int>> edges;
	vector<int> cost;
	{
		Solution sln;
		edges = { {0,1},{0,2},{2,3} }, cost = { 10000, -10000, 10000, -10000 };
		auto res = sln.placedCoins(edges, cost);
		Assert({ 1000000000000,1,1,1 }, res);
	}
	{
		Solution sln;
		edges = { {0,1},{0,2},{0,3},{0,4},{0,5} }, cost = { 1,2,3,4,5,6 };
		auto res = sln.placedCoins(edges, cost);
		Assert({ 120,1,1,1,1,1 }, res);
	}
	{
		Solution sln;
		edges = { {0,1},{0,2},{1,3},{1,4},{1,5},{2,6},{2,7},{2,8} }, cost = { 1,4,2,3,5,7,8,-4,2 };
		auto res = sln.placedCoins(edges, cost);
		Assert({ 280,140,32,1,1,1,1,1,1 }, res);
	}
	{
		Solution sln;
		edges = { {0,1},{0,2} }, cost = { 1,2,-2 };
		auto res = sln.placedCoins(edges, cost);
		Assert({ 0,1,1 }, res);
	}
	{
		Solution sln;
		edges = { {0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},{0,12},{0,13},{0,14},{0,15},{0,16},{0,17},{0,18},{0,19},{0,20},{0,21},{0,22},{0,23},{0,24},{0,25},{0,26},{0,27},{0,28},{0,29},{0,30},{0,31},{0,32},{0,33},{0,34},{0,35},{0,36},{0,37},{0,38},{0,39},{0,40},{0,41},{0,42},{0,43},{0,44},{0,45},{0,46},{0,47},{0,48},{0,49},{0,50},{0,51},{0,52},{0,53},{0,54},{0,55},{0,56},{0,57},{0,58},{0,59},{0,60},{0,61},{0,62},{0,63},{0,64},{0,65},{0,66},{0,67},{0,68},{0,69},{0,70},{0,71},{0,72},{0,73},{0,74},{0,75},{0,76},{0,77},{0,78},{0,79},{0,80},{0,81},{0,82},{0,83},{0,84},{0,85},{0,86},{0,87},{0,88},{0,89},{0,90},{0,91},{0,92},{0,93},{0,94},{0,95},{0,96},{0,97},{0,98},{0,99} };
		cost={-5959, 602, -6457, 7055, -1462, 6347, 7226, -8422, -6088, 2997, -7909, 6433, 5217, 3294, -3792, 7463, 8538, -3811, 5009, 151, 5659, 4458, -1702, -1877, 2799, 9861, -9668, -1765, 2181, -8128, 7046, 9529, 6202, -8026, 6464, 1345, 121, 1922, 7274, -1227, -9914, 3025, 1046, -9368, -7368, 6205, -6342, 8091, -6732, -7620, 3276, 5136, 6871, 4823, -1885, -4005, -3974, -2725, -3845, -8508, 7201, -9566, -7236, -3386, 4021, 6793, -8759, 5066, 5879, -5171, 1011, 1242, 8536, -8405, -9646, -214, 2251, -9934, -8820, 6206, 1006, 1318, -9712, 7230, 5608, -4601, 9185, 346, 3056, 8913, -2454, -3445, -4295, 4802, -8852, -6121, -4538, -5580, -9246, -6462};
		auto res = sln.placedCoins(edges, cost);
		sort(cost.begin(), cost.end());
		Assert({ 971167251036, 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, 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, 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, 1, 1, 1, 1, 1, 1 }, res);
	}
}

第二版

class CNeiBo2
{
public:
CNeiBo2(int n, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase)
{
m_vNeiB.resize(n);
}
CNeiBo2(int n, vector<vector>& edges, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase)
{
m_vNeiB.resize(n);
for (const auto& v : edges)
{
m_vNeiB[v[0] - iBase].emplace_back(v[1] - iBase);
if (!bDirect)
{
m_vNeiB[v[1] - iBase].emplace_back(v[0] - iBase);
}
}
}
inline void Add(int iNode1, int iNode2)
{
iNode1 -= m_iBase;
iNode2 -= m_iBase;
m_vNeiB[iNode1].emplace_back(iNode2);
if (!m_bDirect)
{
m_vNeiB[iNode2].emplace_back(iNode1);
}
}
const int m_iN;
const bool m_bDirect;
const int m_iBase;
vector<vector> m_vNeiB;
};

class Solution {
public:
vector placedCoins(vector<vector>& edges, vector& cost) {
m_cost = cost;
m_vAns.resize(cost.size());
CNeiBo2 neiBo(cost.size(), edges, false);
multiset<int, greater> more0;
multiset less0;
DFS(more0, less0, neiBo.m_vNeiB, 0, -1);
return m_vAns;
}
void DFS(multiset<int, greater>& more0, multiset& less0, vector<vector>& neiBo, int cur, int par)
{
if (m_cost[cur] > 0)
{
more0.emplace(m_cost[cur]);
}
else
{
less0.emplace(m_cost[cur]);
}
for (const auto& next : neiBo[cur])
{
if (next == par)
{
continue;
}
multiset<int, greater> more01;
multiset less01;
DFS(more01, less01, neiBo, next, cur);
Union(more0, more01);
Union(less0, less01);
}
long long& llRet = m_vAns[cur];
if (more0.size() + less0.size() < 3)
{
llRet = 1;
return;
}
if (more0.size() >= 3)
{
auto it = more0.begin();
llRet = max(llRet, (long long)*(it++) * *(it++) * (it++));
}
if (more0.size() && (less0.size() >= 2))
{
llRet = max(llRet, (long long)(more0.begin()) * *(less0.begin()) * *(std::next(less0.begin())));
}
};
template
void Union(T& set1, const T& set2)
{
for (const auto& n : set2)
{
set1.emplace(n);
}
while (set1.size() > 3)
{
set1.erase(prev(set1.end()));
}
}
vector m_cost;
vector m_vAns;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关

下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Linux技术宝典】Linux入门：揭开Linux的神秘面纱

【Linux技术宝典】Linux入门：揭开Linux的神秘面纱

文章目录 官网Linux 环境的搭建方式一、什么是Linux&#xff1f;二、Linux的起源与发展三、Linux的核心组件四、Linux企业应用现状五、Linux的发行版本六、为什么选择Linux&#xff1f;七、总结 Linux&#xff0c;一个在全球范围内广泛应用的开源操作系统&#xff0c;近年来越来…
阅读更多...
深入学习《大学计算机》系列之第1章 1.7节——图灵机的一个例子

深入学习《大学计算机》系列之第1章 1.7节——图灵机的一个例子

一.欢迎来到我的酒馆 第1章 1.7节&#xff0c;图灵机的一个例子。 目录 一.欢迎来到我的酒馆二.图灵机2.1 艾伦-图灵简介2.2 图灵机简介 三.图灵机工作原理3.1 使用图灵机打印二进制数3.2 图灵机工作原理总结 四.总结 二.图灵机 本节内容主要介绍计算机科学之父——艾伦-图灵、…
阅读更多...
【CC++】内存管理2：new + delete

【CC++】内存管理2：new + delete

前言 今天继续来学new和delete operator new 与operator delete函数 new和delete是用户进行动态内存申请和释放的操作符&#xff0c;operator new 和operator delete是系统提供的全局函数&#xff0c;new在底层调用operator new全局函数来申请空间&#xff0c;delete在底层通…
阅读更多...
OpenCV入门：图像处理的基石

OpenCV入门：图像处理的基石

在数字图像处理领域&#xff0c;OpenCV&#xff08;开源计算机视觉库&#xff09;是一个不可或缺的工具。它包含了一系列强大的算法和函数&#xff0c;使得开发者可以轻松地处理图像和视频数据。本文将带你走进OpenCV的世界&#xff0c;了解其基本概念和常见应用。 1. OpenCV简…
阅读更多...
【开源】基于JAVA+Vue+SpringBoot的公司货物订单管理系统

【开源】基于JAVA+Vue+SpringBoot的公司货物订单管理系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 客户管理模块2.2 商品维护模块2.3 供应商管理模块2.4 订单管理模块 三、系统展示四、核心代码4.1 查询供应商信息4.2 新增商品信息4.3 查询客户信息4.4 新增订单信息4.5 添加跟进子订单 五、免责说明 一、摘要 1.1 项目…
阅读更多...
锐捷（十九）锐捷设备的接入安全

锐捷（十九）锐捷设备的接入安全

1、PC1的IP地址和mac地址做全局静态ARP绑定; 全局下&#xff1a;address-bind 192.168.1.1 mac&#xff08;pc1&#xff09; G0/2:ip verify source port-securityarp-check 2、PC2的IP地址和MAC地址做全局IPMAC绑定&#xff1a; Address-bind 192.168.1.2 0050.7966.6807Ad…
阅读更多...
Hugging Face 刚刚推出了一款开源的 AI 助手制造工具，直接向 OpenAI 的定制 GPT 挑战

Hugging Face 刚刚推出了一款开源的 AI 助手制造工具，直接向 OpenAI 的定制 GPT 挑战

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
MMKV：轻巧高效的跨平台键值存储解决方案

MMKV：轻巧高效的跨平台键值存储解决方案

MMKV&#xff1a;轻巧高效的跨平台键值存储解决方案 引言 在移动应用的开发中&#xff0c;数据存储是一个至关重要的环节。随着移动应用的普及和功能的增多&#xff0c;应用需要存储和管理各种类型的数据&#xff0c;包括用户配置信息、缓存数据、临时状态等。传统的数据存储…
阅读更多...
Ubuntu Desktop 删除文件

Ubuntu Desktop 删除文件

Ubuntu Desktop 删除文件 1. right mouse click on the file -> Move to Trash2. right mouse click on the file -> DeleteReferences 1. right mouse click on the file -> Move to Trash ​ 2. right mouse click on the file -> Delete ​​​ References …
阅读更多...
Unity Meta Quest MR 开发（四）：使用 Scene API 和 Depth API 实现深度识别和环境遮挡

Unity Meta Quest MR 开发（四）：使用 Scene API 和 Depth API 实现深度识别和环境遮挡

文章目录 &#x1f4d5;教程说明&#x1f4d5;Scene API 实现遮挡&#x1f4d5;Scene API 实现遮挡的缺点&#x1f4d5;Depth API 实现遮挡⭐导入 Depth API⭐修改环境配置⭐添加 EnvironmentDepthOcclusion 预制体⭐给物体替换遮挡 Shader⭐取消现实手部的遮挡效果 此教程相关…
阅读更多...
C++ //练习 5.6 改写上一题的程序，使用条件运算符（参见4.7节，第134页）代替if else语句。

C++ //练习 5.6 改写上一题的程序，使用条件运算符（参见4.7节，第134页）代替if else语句。

C Primer&#xff08;第5版&#xff09; 练习 5.6 练习 5.6 改写上一题的程序&#xff0c;使用条件运算符&#xff08;参见4.7节&#xff0c;第134页&#xff09;代替if else语句。 环境&#xff1a;Linux Ubuntu&#xff08;云服务器&#xff09; 工具&#xff1a;vim 代码…
阅读更多...
blender怎么保存窗口布局，怎么设置默认输出文件夹

blender怎么保存窗口布局，怎么设置默认输出文件夹

进行窗口布局大家都会&#xff0c;按照自己喜好来就行了&#xff0c;设置输出文件夹如图 这些其实都简单。关键问题在于&#xff0c;自己调好了窗口布局&#xff0c;或者设置好了输出文件夹之后&#xff0c;怎么能让blender下次启动的时候呈现出自己设置好的窗口布局&#xff…
阅读更多...
《CSS 简易速速上手小册》第10章：未来的 CSS（2024 最新版）

《CSS 简易速速上手小册》第10章：未来的 CSS（2024 最新版）

文章目录 10.1 CSS 的新特性和趋势10.1.1 基础知识10.1.2 重点案例&#xff1a;使用 CSS Grid 创建响应式图库10.1.3 拓展案例 1&#xff1a;利用 CSS 变量实现主题切换10.1.4 拓展案例 2&#xff1a;使用 lab() 颜色和 layer 规则优化样式 10.2 CSS Houdini&#xff1a;魔法般…
阅读更多...
Day46 300最长递增子序列 674最长连续递增子序列 718最长重复子数组 1143最长公共子序列

Day46 300最长递增子序列 674最长连续递增子序列 718最长重复子数组 1143最长公共子序列

300 最长递增子序列 给你一个整数数组 nums &#xff0c;找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列&#xff0c;删除&#xff08;或不删除&#xff09;数组中的元素而不改变其余元素的顺序。例如&#xff0c;[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序…
阅读更多...
Kafka 入门笔记

Kafka 入门笔记

课程地址 概述 定义 Kafka 是一个分布式的基于发布/订阅模式的消息队列&#xff08;MQ&#xff09; 发布/订阅&#xff1a;消息的发布者不会将消息直接发送给特定的订阅者&#xff0c;而是将发布的消息分为不同的类别&#xff0c;订阅者只接受感兴趣的消息 消息队列 消息队…
阅读更多...
【北邮鲁鹏老师计算机视觉课程笔记】04 fitting 拟合

【北邮鲁鹏老师计算机视觉课程笔记】04 fitting 拟合

【北邮鲁鹏老师计算机视觉课程笔记】04 fitting 拟合 1 拟合的任务 如何从边缘找出真正的线&#xff1f; 存在问题 ①噪声 ②外点、离群点 ③缺失数据 2 最小二乘 存在的问题 3 全最小二乘 度量的是点到直线的距离而不是点在y方向到直线的距离 提示&#xff1a;点到直线的…
阅读更多...
【北邮鲁鹏老师计算机视觉课程笔记】05 Hough 霍夫变换

【北邮鲁鹏老师计算机视觉课程笔记】05 Hough 霍夫变换

【北邮鲁鹏老师计算机视觉课程笔记】05 Hough 霍夫变换 1 投票策略 考虑到外点率太高 ①让直线上的每一点投票 ②希望噪声点不要给具体的任何模型投票&#xff0c;即噪声点不会有一致性的答案 ③即使被遮挡了&#xff0c;也能把直线找出来 参数空间离散化 直线相当于就是m,b两…
阅读更多...
vue核心技术（二）

vue核心技术（二）

◆ 指令补充 指令修饰符 通过 "." 指明一些指令 后缀&#xff0c;不同 后缀 封装了不同的处理操作 → 简化代码 v-bind 对于样式控制的增强 为了方便开发者进行样式控制&#xff0c; Vue 扩展了 v-bind 的语法&#xff0c;可以针对 class 类名 和 style 行内样式…
阅读更多...
网络安全检查表

网络安全检查表

《网络攻击检查表》 1.应用安全漏洞 2.弱口令&#xff0c;默认口令 3.服务器互联网暴露 4.操作系统&#xff0c;中间件安全漏洞 5.研发服务器&#xff0c;邮件服务器等安全检查
阅读更多...
PySpark（四）PySpark SQL、Catalyst优化器、Spark SQL的执行流程、Spark新特性

PySpark（四）PySpark SQL、Catalyst优化器、Spark SQL的执行流程、Spark新特性

目录 PySpark SQL 基础 SparkSession对象 DataFrame入门 DataFrame构建 DataFrame代码风格 DSL SQL SparkSQL Shuffle 分区数目 DataFrame数据写出 Spark UDF Catalyst优化器 Spark SQL的执行流程 Spark新特性 自适应查询(SparkSQL) 动态合并 动态调整Join策略 …
阅读更多...
最新文章

Copyright @ 2022~2023