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

news2024/10/6 12:19:29

作者推荐

视频算法专题

本博文涉及知识点

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

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++**实现。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

计网day1

计网day1

RTT&#xff1a;往返传播时延&#xff08;越大&#xff0c;游戏延迟&#xff09; 一.算机网络概念 网络&#xff1a;网样的东西&#xff0c;网状系统 计算机网络&#xff1a;是一个将分散得、具有独立功能的计算机系统&#xff0c;通过通信设备与线路连接起来&#xff0c;由功…
阅读更多...
课堂秩序要求有哪些内容

课堂秩序要求有哪些内容

你是否曾经疑惑&#xff0c;为什么有些课堂总是秩序井然&#xff0c;而有些则混乱不堪&#xff1f;作为一位经验丰富的老师&#xff0c;我想告诉你&#xff0c;课堂秩序不仅仅是学生安静听讲那么简单&#xff0c;它背后涉及到许多关键因素&#xff0c;直接影响着教学质量和学习…
阅读更多...
Unity学习笔记（零基础到就业）｜Chapter04:C#篇补充到Unity篇过渡

Unity学习笔记（零基础到就业）｜Chapter04:C#篇补充到Unity篇过渡

Unity学习笔记&#xff08;零基础到就业&#xff09;&#xff5c;Chapter02:C#篇补充到Unity篇过渡 前言C#总结补充1.值类型和引用类型有什么区别&#xff0c;他们在值的传递上分别有怎样的特性2.string是引用类型&#xff0c;但是他对外表现出值类型的特性&#xff0c;为什么&…
阅读更多...
【BIAI】Lecture 14 - Sleep and Dreaming

【BIAI】Lecture 14 - Sleep and Dreaming

Sleep and Dreaming 专业词汇 pons 延髓 parietal cortex 顶叶皮层 limbic system 边缘系统 temporal cortex 颞叶皮层 dorsolateral prefrontal cortex 背外侧前额叶皮层 pineal gland 松果体 Suprachiasmatic Nucleus 视交叉上核 课程大纲 Sleep stages awake无眼动睡眠&am…
阅读更多...
Java异常处理 throw和throws

Java异常处理 throw和throws

目录 throwthrows实例制造异常 在Java中&#xff0c;throw和throws关键字都与异常处理有关&#xff0c;但它们的使用方式和目的有所不同。 throw throw关键字&#xff1a; * throw用于在代码中显式地抛出一个异常。你可以使用它来触发一个异常&#xff0c;并指定异常的类型。…
阅读更多...
Google刚刚推出了图神经网络Tensorflow-GNN

Google刚刚推出了图神经网络Tensorflow-GNN

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

Hadoop-Yarn-ResourceManagerHA

在这里先给屏幕面前的你送上祝福&#xff0c;祝你在未来一年&#xff1a;技术步步高升、薪资节节攀升&#xff0c;身体健健康康&#xff0c;家庭和和美美。 一、介绍 在Hadoop2.4之前&#xff0c;ResourceManager是YARN集群中的单点故障 ResourceManager HA是通过 Active/St…
阅读更多...
[职场] 公安管理学就业方向及前景 #媒体#笔记#笔记

[职场] 公安管理学就业方向及前景 #媒体#笔记#笔记

公安管理学就业方向及前景 公安管理学是中国普通高等学校本科专业。本专业文理兼收&#xff0c;学制4年&#xff0c;授予法学学士学位。本专业培养掌握马克思主义基本原理&#xff0c;政治坚定&#xff0c;坚持党和国家的路线、方针、政策&#xff0c;具有良好职业素养、科学素…
阅读更多...
Makefile编译原理 make 中的路径搜索_1

Makefile编译原理 make 中的路径搜索_1

一.make中的路径搜索 问题&#xff1a;在实际的工程项目中&#xff0c;所有的源文件和头文件都放在同一个文件夹中吗&#xff1f; 实验1 &#xff1a; VPATH 引子 mhrubuntu:~/work/makefile1/17$ ll total 28 drwxrwxr-x 4 mhr mhr 4096 Apr 22 00:46 ./ drwxrwxr-x 7 mhr m…
阅读更多...
双指针-two pointers的应用

双指针-two pointers的应用

1.枚举输出解法&#xff1a; #include <iostream> using namespace std; int num[1000]; int main(){int result,n;cin>>result>>n;for(int i0;i<n;i)cin>>num[i];for(int i0;i<n;i)for(int ji1;j<n;j)if(num[i]num[j]result)cout<<nu…
阅读更多...
操作系统——内存管理(附带Leetcode算法题LRU)

操作系统——内存管理(附带Leetcode算法题LRU)

1.内存管理主要用来干什么&#xff1f; 操作系统的内存管理主要负责内存的分配与回收、内存扩充(虚拟技术)、地址转换(逻辑-物理)、内存保护(保证各进程在自己的内存空间运行&#xff0c;不会越界访问)..... 2.什么是内存碎片&#xff1f; 内存碎片是内存的申请和释放产生的…
阅读更多...
SpringBoot3整合Knife4j

SpringBoot3整合Knife4j

前置&#xff1a; 官网&#xff1a;快速开始 | Knife4j gitee&#xff1a;swagger-bootstrap-ui-demo: knife4j 以及swagger-bootstrap-ui 集成框架示例项目 - Gitee.com 1.依赖引入&#xff1a; ps&#xff1a;json处理需要引入相关包 <dependency><groupId>c…
阅读更多...
【GAMES101】Lecture 21 动画

【GAMES101】Lecture 21 动画

目录 关键帧&#xff08;Keyframe animation&#xff09; 物理仿真&#xff08;Physical simulation&#xff09; 质点弹簧系统 粒子系统 运动学&#xff08;Kinematics&#xff09; 正运动学&#xff08;Forward Kinematics&#xff09; 逆运动学&#xff08;Inverse K…
阅读更多...
【MySQL】-18 MySQL综合-4（MySQL储存引擎精讲+MySQL数据类型简介+MySQL整数类型+MySQL小数类型）

【MySQL】-18 MySQL综合-4（MySQL储存引擎精讲+MySQL数据类型简介+MySQL整数类型+MySQL小数类型）

MySQL储存引擎精讲MySQL数据类型简介MySQL整数类型MySQL小数类型 十一 MySQL存储引擎精讲11.1 什么是存储引擎11.2 MySQL 5.7 支持的存储引擎11.3 如何选择 MySQL 存储引擎11.4 MySQL 默认存储引擎 十二 MySQL数据类型简介12.1 MySQL 常见数据类型1) 整数类型2) 日期/时间类型3…
阅读更多...
Day30 回溯算法part06

Day30 回溯算法part06

又是眼红别人的一天 重新安排行程 菜鸡思路&#xff1a;把从jfk往下所有的情况都列举出来&#xff0c;result数组包含五个元素的时候返回数组。 我们只需要找到一个行程&#xff0c;就是在树形结构中唯一的一条通向叶子节点的路线 N皇后 这个isValid函数也很不好想啊 首先…
阅读更多...
blender怎么保存窗口布局，怎么设置默认输出文件夹

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

进行窗口布局大家都会&#xff0c;按照自己喜好来就行了&#xff0c;设置输出文件夹如图 这些其实都简单。关键问题在于&#xff0c;自己调好了窗口布局&#xff0c;或者设置好了输出文件夹之后&#xff0c;怎么能让blender下次启动的时候呈现出自己设置好的窗口布局&#xff…
阅读更多...
【leetcode热题100】反转链表 II

【leetcode热题100】反转链表 II

给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1a;[1,4,3,2…
阅读更多...
bugku 1

bugku 1

Flask_FileUpload 文件上传 先随便传个一句话木马 看看回显 果然不符合规定 而且发现改成图片什么的都不行 查看页面源代码&#xff0c;发现提示 那应该就要用python命令才行 试试ls 类型要改成图片 cat /flag 好像需要密码 bp爆破 根据提示&#xff0c;我们先抓包 爆破 …
阅读更多...
Windows安全中心显示页面不可用

Windows安全中心显示页面不可用

2024年2月过年当天重装电脑之后&#xff0c;第二天&#xff08;还是第三天&#xff09;安全中心开始提示如标题所示的问题。 问题环境 Windows 11 家庭中文版23H2安装日期2024/‎2/‎10 我解决之前没有截图&#xff0c;所以此处放一个别人的图做示例。 实际解决方式 搜索了…
阅读更多...
用code去探索理解Llama架构的简单又实用的方法

用code去探索理解Llama架构的简单又实用的方法

除了白月光我们也需要朱砂痣 我最近也在反思&#xff0c;可能有时候算法和论文也不是每个读者都爱看&#xff0c;我也会在今后的文章中加点code或者debug模型的内容&#xff0c;也许还有一些好玩的应用demo&#xff0c;会提升这部分在文章类型中的比例 今天带着大家通过代码角度…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023