【动态规划】【图论】【C++算法】1575统计所有可行路径

news2024/11/18 9:27:32

作者推荐

【动态规划】【字符串】【行程码】1531. 压缩字符串

本文涉及知识点

动态规划汇总
图论

LeetCode1575统计所有可行路径

给你一个 互不相同 的整数数组，其中 locations[i] 表示第 i 个城市的位置。同时给你 start，finish 和 fuel 分别表示出发城市、目的地城市和你初始拥有的汽油总量每一步中，如果你在城市 i ，你可以选择任意一个城市 j ，满足 j != i 且 0 <= j < locations.length ，并移动到城市 j 。从城市 i 移动到 j 消耗的汽油量为 |locations[i] - locations[j]|，|x| 表示 x 的绝对值。
请注意， fuel 任何时刻都 不能 为负，且你 可以 经过任意城市超过一次（包括 start 和 finish ）。
请你返回从 start 到 finish 所有可能路径的数目。
由于答案可能很大， 请将它对 10^9 + 7 取余后返回。
示例 1：
输入：locations = [2,3,6,8,4], start = 1, finish = 3, fuel = 5
输出：4
解释：以下为所有可能路径，每一条都用了 5 单位的汽油：
1 -> 3
1 -> 2 -> 3
1 -> 4 -> 3
1 -> 4 -> 2 -> 3
示例 2：
输入：locations = [4,3,1], start = 1, finish = 0, fuel = 6
输出：5
解释：以下为所有可能的路径：
1 -> 0，使用汽油量为 fuel = 1
1 -> 2 -> 0，使用汽油量为 fuel = 5
1 -> 2 -> 1 -> 0，使用汽油量为 fuel = 5
1 -> 0 -> 1 -> 0，使用汽油量为 fuel = 3
1 -> 0 -> 1 -> 0 -> 1 -> 0，使用汽油量为 fuel = 5
示例 3：
输入：locations = [5,2,1], start = 0, finish = 2, fuel = 3
输出：0
解释：没有办法只用 3 单位的汽油从 0 到达 2 。因为最短路径需要 4 单位的汽油。
提示：
2 <= locations.length <= 100
1 <= locations[i] <= 109
所有 locations 中的整数 互不相同 。
0 <= start, finish < locations.length
1 <= fuel <= 200

动态规划

令n = locations.length

动态规划的状态表示

dp[l][f] 表示 使用f单位的汽油，终点是l的可行路径数。状态数共：nm，故空间复杂度:O(nm)。

动态规划的转移方程

通过前置条件转移后置条件。
枚举符合以下条件的l1：
l1!=l
f1 = |loc[l1]-[l]| + f <= fuel。
dp[l1][[f1] += dp[l][f]
时间复杂度: O(nnm)

动态规划的填表顺序

f从小到大，确保动态规划的无后效性。

动态规划的初始状态

dp[start][0] =1 ，其它全部为0。

动态规划的返回值

dp[finish]之和

代码

核心代码

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

class Solution {
public:
	int countRoutes(vector<int>& locations, int start, int finish, int fuel) {
		const int n = locations.size();
		vector<vector<C1097Int<> >> dp(n, vector<C1097Int<>>(fuel + 1));
		dp[start][0] = 1;
		for (int f = 0; f < fuel; f++)
		{
			for (int l = 0; l < n; l++)
			{
				for (int l1 = 0; l1 < n; l1++)
				{
					if (l1 == l)
					{
						continue;
					}
					int f1 = f + abs(locations[l1] - locations[l]);
					if (f1 <= fuel)
					{
						dp[l1][f1] += dp[l][f];
					}
				}
			}
		}
		return std::accumulate(dp[finish].begin(), dp[finish].end(), C1097Int()).ToInt();
	}
};

测试用例

template<class T>
void Assert(const T& t1, const T& 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<int> locations;
	int start,  finish,  fuel;
	{
		Solution sln;
		locations = { 2, 3, 6, 8, 4 }, start = 1, finish = 3, fuel = 5;
		auto res = sln.countRoutes(locations, start, finish, fuel);
		Assert(4, res);
	}

	{
		Solution sln;
		locations = { 4, 3, 1 }, start = 1, finish = 0, fuel = 6;
		auto res = sln.countRoutes(locations, start, finish, fuel);
		Assert(5, res);
	}

	{
		Solution sln;
		locations = { 5, 2, 1 }, start = 0, finish = 2, fuel = 3;
		auto res = sln.countRoutes(locations, start, finish, fuel);
		Assert(0, res);
	}
}

小幅优化

排序后，向右（左）第一个油量不够的城市就停止。

class Solution {
public:
	int countRoutes(vector<int>& locations, int start, int finish, int fuel) {
		const int n = locations.size();
		const int startLoc = locations[start];
		const int finishLoc = locations[finish];
		sort(locations.begin(), locations.end());
		start = std::find(locations.begin(), locations.end(), startLoc)- locations.begin();
		finish = std::find(locations.begin(), locations.end(), finishLoc) - locations.begin();
		vector<vector<C1097Int<> >> dp(n, vector<C1097Int<>>(fuel + 1));
		dp[start][0] = 1;
		for (int f = 0; f < fuel; f++)
		{
			for (int l = 0; l < n; l++)
			{
				int use = 0;
				for (int l1 = l+1 ;(l1 < n )&&( f + (use = locations[l1] - locations[l]) <= fuel); l1++)
				{
					dp[l1][f+use] += dp[l][f];					
				}
				for (int l1 = l - 1; (l1 >= 0 ) && (f + (use = locations[l] - locations[l1]) <= fuel); l1--)
				{
					dp[l1][f + use] += dp[l][f];
				}
			}
		}
		return std::accumulate(dp[finish].begin(), dp[finish].end(), C1097Int()).ToInt();
	}
};

再次优化

填表顺序，还是从使用汽油少的到使用汽油多的。
前一个位置可能在当前位置的左边，也可能是右边。不失一般性，只讨论从左边过来。
假定当前使用汽油是f，位置是l。前一站使用的汽油是f1,位置是l1。则
行驶的路径等于消耗的汽油 → \rightarrow → f-f1= l - l1 → \rightarrow → f-l = f1-l1 性质一
符合性质一的状态分以下三类：
一，使用汽油比当前使用的汽油少。此状态就是本状态的前置状态。
二，使用汽油和当前状态使用的汽油一样，就是本状态。
三，使用汽油比当前汽油多，还没有更新。
结论： 符合性质一的状态路径和，就是本状态的路径和。
从右边来，类似：
f-f1=l1-l → \rightarrow → f+l==f1+l1 性质二
m1，记录性质一；m2 记录性质二。
时间复杂度：将为O(nfuel)。

class Solution {
public:
	int countRoutes(vector<int>& locations, int start, int finish, int fuel) {
		const int n = locations.size();
		vector<vector<C1097Int<> >> dp(n, vector<C1097Int<>>(fuel + 1));
		unordered_map<int, C1097Int<>> m1,m2;
		dp[start][0] = 1;
		m1[0 - locations[start]] +=1 ;
		m2[0 + locations[start]] += 1;
		for (int f = 1; f <= fuel; f++)
		{
			for (int l = 0; l < n; l++)
			{
				dp[l][f] = m1[f- locations[l]]+ m2[f + locations[l]];
				m1[f - locations[l]] += dp[l][f];
				m2[f + locations[l]] += dp[l][f];
			}
		}
		return std::accumulate(dp[finish].begin(), dp[finish].end(), C1097Int()).ToInt();
	}
};

2023年2月第一版

class C1097Int
{
public:
C1097Int(int iData = 0) :m_iData(iData)
{
}
C1097Int operator+(const C1097Int& o)const
{
return C1097Int((m_iData + o.m_iData) % s_iMod);
}
C1097Int& operator+=(const C1097Int& o)
{
m_iData = (m_iData + o.m_iData) % s_iMod;
return this;
}
C1097Int operator(const C1097Int& o)const
{
return((long long)m_iData o.m_iData) % s_iMod;
}
C1097Int& operator=(const C1097Int& o)
{
m_iData =((long long)m_iData *o.m_iData) % s_iMod;
return *this;
}
int ToInt()const
{
return m_iData;
}
private:
int m_iData = 0;;
static const int s_iMod = 1000000007;
};

int operator+(int iData, const C1097Int& int1097)
{
int iRet = int1097.operator+(C1097Int(iData)).ToInt();
return iRet;
}

int& operator+=(int& iData, const C1097Int& int1097)
{
iData = int1097.operator+(C1097Int(iData)).ToInt();
return iData;
}

class Solution {
public:
int countRoutes(vector& locations, int start, int finish, int fuel) {
m_c = locations.size();
vector<vector> vFuelPos(fuel + 1, vector(m_c));
vFuelPos[fuel][start] = 1;
for (int iCurFuel = fuel-1; iCurFuel >= 0; iCurFuel–)
{
for (int iPos = 0; iPos < m_c; iPos++)
{
for (int iPrePos = 0; iPrePos < m_c; iPrePos++)
{
if (iPrePos == iPos)
{
continue;
}
const int iNeedFuel = iCurFuel + abs(locations[iPos] - locations[iPrePos]);
if (iNeedFuel <= fuel)
{
vFuelPos[iCurFuel][iPos] += vFuelPos[iNeedFuel][iPrePos];
}
}
}
}
C1097Int iNum = 0;
for (int iCurFuel = fuel ; iCurFuel >= 0; iCurFuel–)
{
iNum += vFuelPos[iCurFuel][finish];
}
return iNum.ToInt();
}
int m_c;
};

2023年9月版

class Solution {
public:
int countRoutes(vector& locations, int start, int finish, int fuel) {
m_c = locations.size();
int startValue = locations[start], finishValue = locations[finish];
std::sort(locations.begin(), locations.end());
start = std::lower_bound(locations.begin(), locations.end(), startValue) - locations.begin();
finish = std::lower_bound(locations.begin(), locations.end(), finishValue) - locations.begin();
m_vLeft.assign(m_c, vector<C1097Int<>>(fuel + 1));
m_vRight = m_vLeft;
int iRemain;
if ((start+1 < m_c)&&(( iRemain = fuel - locations[start+1]+ locations[start ]) >=0 ))
{
m_vRight[start+1][iRemain] = 1;
}
if ((start > 0) && ((iRemain = fuel - locations[start] + locations[start - 1]) >= 0))
{
m_vLeft[start-1][iRemain] = 1;
}
for (int iFuel = fuel-1; iFuel > 0; iFuel–)
{
for (int city = 0; city < m_c; city++)
{
RightMoveRight(iFuel, city, locations);
RightMoveLeft(iFuel, city, locations);
LeftMoveRight(iFuel, city, locations);
LeftMoveLeft(iFuel, city, locations);
}
}
C1097Int<> biRet = 0;
for (int iFuel = fuel; iFuel >= 0; iFuel–)
{
biRet += m_vLeft[finish][iFuel];
biRet += m_vRight[finish][iFuel];
}
if (start == finish)
{
biRet += 1;
}
return biRet.ToInt();
}
void RightMoveRight(int iFuel, int city, const vector& loc)
{
if (city + 1 >= m_c)
{
return;
}
const int iNeedFuel = loc[city + 1] - loc[city];
if (iNeedFuel > iFuel)
{
return;
}
m_vRight[city + 1][iFuel - iNeedFuel] += m_vRight[city][iFuel] * 2;
}
void RightMoveLeft(int iFuel, int city, const vector& loc)
{
if (0 == city)
{
return;
}
const int iNeedFuel = loc[city] - loc[city - 1];
if (iNeedFuel > iFuel)
{
return;
}
m_vLeft[city - 1][iFuel - iNeedFuel] += m_vRight[city][iFuel];
}
void LeftMoveRight(int iFuel, int city, const vector& loc)
{
if (city + 1 >= m_c)
{
return;
}
const int iNeedFuel = loc[city + 1] - loc[city];
if (iNeedFuel > iFuel)
{
return;
}
m_vRight[city + 1][iFuel - iNeedFuel] += m_vLeft[city][iFuel];
}
void LeftMoveLeft(int iFuel, int city, const vector& loc)
{
if (0 == city)
{
return;
}
const int iNeedFuel = loc[city] - loc[city - 1];
if (iNeedFuel > iFuel)
{
return;
}
m_vLeft[city - 1][iFuel - iNeedFuel] += m_vLeft[city][iFuel] * 2;
}
vector<vector<C1097Int<>>> m_vLeft, m_vRight;
int m_c;
};

扩展阅读

视频课程

有效学习：明确的目
标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步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/1419414.html

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

相关文章

github添加 SSH 密钥

github添加 SSH 密钥

1 打开终端 输入 ssh-keygen -t rsa -b 4096 -C "github邮箱地址"如果不需要密码可以一路回车 出现这个页面就是生存成功了 open ~/.ssh // 打开.ssh 找到id_rsa.pub复制出内容新建ssh密钥输入内容,保存即可
阅读更多...
JavaWeb中的Filter（过滤器）和 Listener（监听器）

JavaWeb中的Filter（过滤器）和 Listener（监听器）

提示&#xff1a;这两个东西听起来似乎很难&#xff0c;实际上是非常简单的&#xff0c;按照要求写就行了&#xff0c;一定不要被新名词给吓到了。 JavaWeb中的Filter&#xff08;过滤器&#xff09; 一、Filter&#xff08;过滤器&#xff09;1.如何编写 Filter2.Filter 中的细…
阅读更多...
webassembly003 TTS BARK.CPP

webassembly003 TTS BARK.CPP

TTS task TTS&#xff08;Text-to-Speech&#xff09;任务是一种自然语言处理&#xff08;NLP&#xff09;任务&#xff0c;其中模型的目标是将输入的文本转换为声音&#xff0c;实现自动语音合成。具体来说&#xff0c;模型需要理解输入的文本并生成对应的语音输出&#xff0…
阅读更多...
Day01-变量和数据类型课后练习-参考答案

Day01-变量和数据类型课后练习-参考答案

文章目录 1、输出你最想说的一句话&#xff01;2、定义所有基本数据类型的变量和字符串变量3、用合适类型的变量存储个人信息并输出4、定义圆周率PI5、简答题 1、输出你最想说的一句话&#xff01; 编写步骤&#xff1a; 定义类 Homework1&#xff0c;例如&#xff1a;Homewo…
阅读更多...
85 C++对象模型探索。数据语义学 - 继承多个类，且是虚基类的数据内存模型分析。虚基类表，虚基类表指针

85 C++对象模型探索。数据语义学 - 继承多个类，且是虚基类的数据内存模型分析。虚基类表，虚基类表指针

前面我们分析了 继承多个类的情况。上一次分析的这样的情况&#xff1a; 今天看虚基类。先复习一下虚基类&#xff1a;类似下面这样的图 复习虚基类可以解决的问题&#xff1a; 在这之前先要复习一下多继承同一个爷爷类时带来的问题 空间问题 效率问题 二义性问题 //虚基类问…
阅读更多...
数据库管理-第141期 DG PDB - Oracle DB 23c（20240129）

数据库管理-第141期 DG PDB - Oracle DB 23c（20240129）

数据库管理141期 2024-01-29 第141期 DG PDB - Oracle DB 23c&#xff08;20240129&#xff09;1 概念2 环境说明3 操作3.1 数据库配置3.2 配置tnsname3.3 配置强制日志3.4 DG配置3.5 DG配置建立联系3.6 启用所有DG配置3.7 启用DG PDB3.8 创建源PDB的DG配置3.9 拷贝pdbprod1文件…
阅读更多...
TCP/IP网络模型

TCP/IP网络模型

大家好我是苏麟 , 今天聊聊TCP/IP四层网络模型 . 资料来源 : 小林coding 小林官方网站 : 小林coding (xiaolincoding.com) 应用层 最上层的&#xff0c;也是我们能直接接触到的就是应用层&#xff08;Application Layer&#xff09;&#xff0c;我们电脑或手机使用的应用软件都…
阅读更多...
测试ASP.NET Core项目调用EasyCaching的基本用法（InMemory）

测试ASP.NET Core项目调用EasyCaching的基本用法（InMemory）

EasyCaching属于开源缓存库&#xff0c;支持基本缓存方式及高级缓存用法&#xff0c;提高用户操作缓存的效率。EasyCaching支持的缓存方式包括以下类型&#xff0c;本文学习最基础的InMemory方式的基本用法。   EasyCaching.InMemory包属于基于内存的缓存库&#xff0c;使用的…
阅读更多...
C语言——指针进阶（四）

C语言——指针进阶（四）

目录 一.前言 二.指针和数组笔试题解析 2.1 二维数组 2.2 指针笔试题 三.全部代码 四.结语 一.前言 本文我们将迎来指针的结尾&#xff0c;包含了二维数组与指针的试题解析。码字不易&#xff0c;希望大家多多支持我呀&#xff01;&#xff08;三连&#xff0b;关注&…
阅读更多...
JavaWeb后端登录校验功能（JWT令牌技术,Cookie技术,Session，拦截技术，过滤器）

JavaWeb后端登录校验功能（JWT令牌技术,Cookie技术,Session，拦截技术，过滤器）

目录 一.登录校验功能&#xff08;解决直接通过路径访问&#xff09; 1.实现思路 二.会话技术 ​编辑 1.Cookie技术 2.Session 3.令牌技术 1.简介 2.如何生成和解析 3.令牌的使用 三.Filter过滤器 1.什么是过滤器 2.实现步骤&#xff1a; 3.过滤器执行流程 4.拦截路径 5.过…
阅读更多...
349. 两个数组的交集（力扣LeetCode）

349. 两个数组的交集（力扣LeetCode）

文章目录 349. 两个数组的交集题目描述数组解题set容器解题该思路数组版解题 349. 两个数组的交集 题目描述 给定两个数组 nums1 和 nums2 &#xff0c;返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。 示例 1&#xff1a; 输入&a…
阅读更多...
【Linux】Linux下多线程

【Linux】Linux下多线程

需要云服务器等云产品来学习Linux的同学可以移步/–>腾讯云<–/官网&#xff0c;轻量型云服务器低至112元/年&#xff0c;优惠多多。&#xff08;联系我有折扣哦&#xff09; 文章目录 1. 前置&#xff1a;进程地址空间和页表1.1 如何看待进程地址空间和页表1.2 虚拟地址…
阅读更多...
练习12.6_横向射击_Python编程：从入门到实践（第3版）

练习12.6_横向射击_Python编程：从入门到实践（第3版）

编写一个游戏&#xff0c;将一艘飞船放在屏幕左侧&#xff0c;并允许玩家上下移动飞船。在玩家按空格键时&#xff0c; 让飞船发射一颗在屏幕中向右飞行的子弹&#xff0c;并在子弹从屏幕中消失后将其删除。 ship_shooting.py import pygame import sys from leftship impor…
阅读更多...
​ArcGIS Pro 如何批量删除字段

​ArcGIS Pro 如何批量删除字段

在某些时候&#xff0c;我们得到的图层属性表内可能会有很多不需要的字段&#xff0c;如果挨个去删除会十分的麻烦&#xff0c;对于这种情况&#xff0c;我们可以使用工具箱内的字段删除工具批量删除&#xff0c;这里为大家介绍一下使用方法&#xff0c;希望能对你有所帮助。 …
阅读更多...
[C++历练之路]C++中的继承小学问

[C++历练之路]C++中的继承小学问

W...Y的主页 &#x1f60a; 代码仓库分享&#x1f495; &#x1f354;前言&#xff1a; C中&#xff0c;继承是一种面向对象编程的重要概念&#xff0c;它允许一个类&#xff08;子类/派生类&#xff09;从另一个类&#xff08;父类/基类&#xff09;继承属性和方法。继承是…
阅读更多...
C语言系列-整数在内存中的存储大小端字节序

C语言系列-整数在内存中的存储大小端字节序

&#x1f308;个人主页: 会编程的果子君 ​&#x1f4ab;个人格言:“成为自己未来的主人~” 目录 整数在内存中的存储 大小端字节序和字节序判断 什么是大小端 为什么会有大小端 练习 整数在内存中的存储 在讲解操作符的时候&#xff0c;我们就讲过了下面的内容 整数的2…
阅读更多...
HashMap基本使用

HashMap基本使用

特点&#xff1a; ①HashMap是Map里面的一个实现类。②没有额外需要学习的特有方法&#xff0c;直接使用Map里面的方法就可以了。③特点都是由键决定的&#xff1a;无序、不重复、无索引④HashMap跟HashSet底层原理是一模一样的&#xff0c;从名字可以看出来&#xff0c;都是哈…
阅读更多...
MySQL原理（一）架构组成（2）逻辑模块组成

MySQL原理（一）架构组成（2）逻辑模块组成

总的来说&#xff0c;MySQL可以看成是二层架构&#xff0c;第一层我们通常叫做SQL Layer&#xff0c;在MySQL数据库系统处理底层数据之前的所有工作都是在这一层完成的&#xff0c;包括权限判断&#xff0c;sql解析&#xff0c;执行计划优化&#xff0c;query cache的处理等等&…
阅读更多...
麒麟系统—— openKylin 安装 Nacos

麒麟系统—— openKylin 安装 Nacos

麒麟系统—— openKylin 安装 Nacos 一、准备工作1. 确保麒麟系统 openKylin 已经安装完毕。2. 确保 java 已经安装完毕3. 确保 Maven 已经安装完毕 二、下载 nacos三、解压与运行解压 关于 nacos 配置 本文将分享如何在麒麟系统 openKylin 上安装 Nacos。 一、准备工作 1. …
阅读更多...
深度学习之卷积神经网络

深度学习之卷积神经网络

卷积神经网络简称为CNN 首先我们来回顾一下&#xff0c;我们之前学到的全连接的神经网络&#xff1a; 上面我们通过线性层串行连接起来的神经网络&#xff0c;我们叫做全链接的网络&#xff0c;在线性层里面&#xff0c;我们的输入值和任意的输出值之间都存在权重&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023