【C++BFS算法 二分查找】2812. 找出最安全路径

news2024/11/17 4:27:09

本文涉及知识点

C++BFS算法
C++二分查找

LeetCode2812. 找出最安全路径

给你一个下标从 0 开始、大小为 n x n 的二维矩阵 grid ，其中 (r, c) 表示：
如果 grid[r][c] = 1 ，则表示一个存在小偷的单元格
如果 grid[r][c] = 0 ，则表示一个空单元格
你最开始位于单元格 (0, 0) 。在一步移动中，你可以移动到矩阵中的任一相邻单元格，包括存在小偷的单元格。
矩阵中路径的 安全系数 定义为：从路径中任一单元格到矩阵中任一小偷所在单元格的 最小 曼哈顿距离。
返回所有通向单元格 (n - 1, n - 1) 的路径中的 最大安全系数 。
单元格 (r, c) 的某个 相邻 单元格，是指在矩阵中存在的 (r, c + 1)、(r, c - 1)、(r + 1, c) 和 (r - 1, c) 之一。
两个单元格 (a, b) 和 (x, y) 之间的 曼哈顿距离 等于 | a - x | + | b - y | ，其中 |val| 表示 val 的绝对值。
示例 1：
在这里插入图片描述

输入：grid = [[1,0,0],[0,0,0],[0,0,1]]
输出：0
解释：从 (0, 0) 到 (n - 1, n - 1) 的每条路径都经过存在小偷的单元格 (0, 0) 和 (n - 1, n - 1) 。
示例 2：
在这里插入图片描述

输入：grid = [[0,0,1],[0,0,0],[0,0,0]]
输出：2
解释：
上图所示路径的安全系数为 2：

  • 该路径上距离小偷所在单元格（0，2）最近的单元格是（0，0）。它们之间的曼哈顿距离为 | 0 - 0 | + | 0 - 2 | = 2 。
    可以证明，不存在安全系数更高的其他路径。
    示例 3：
    在这里插入图片描述

输入：grid = [[0,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,0]]
输出：2
解释：
上图所示路径的安全系数为 2：

  • 该路径上距离小偷所在单元格（0，3）最近的单元格是（1，2）。它们之间的曼哈顿距离为 | 0 - 1 | + | 3 - 2 | = 2 。
  • 该路径上距离小偷所在单元格（3，0）最近的单元格是（3，2）。它们之间的曼哈顿距离为 | 3 - 3 | + | 0 - 2 | = 2 。
    可以证明，不存在安全系数更高的其他路径。

提示：
1 <= grid.length == n <= 400
grid[i].length == n
grid[i][j] 为 0 或 1
grid 至少存在一个小偷

二分查找

一，BFS出各单格距离小偷的位置（层次）leve。
二，二分查找。Check(mid) 是否存在安全系数为mid或更大的路径。随着mid从0到leve[0][0]，Check的返回值逐步由true，变成false。我们寻找最后一个true。Check函数的大致步骤：
a,连通距离小偷大于等与mid的单格。
b，看右下角的层次是否大于等于0。

代码

第一版（超时）

class CGrid {
public:
	CGrid(int rCount, int cCount) :m_r(rCount), m_c(cCount) {}
	vector<vector<pair<int, int>>> NeiBo(std::function<bool(int, int)> funVilidCur, std::function<bool(int, int)> funVilidNext, int iConnect = 4)
	{
		vector<vector<pair<int, int>>> vNeiBo(m_r * m_c);
		auto Move = [&](int preR, int preC, int r, int c)
		{
			if ((r < 0) || (r >= m_r))
			{
				return;
			}
			if ((c < 0) || (c >= m_c))

			{
				return;
			}
			if (funVilidCur(preR, preC) && funVilidNext(r, c))
			{
				vNeiBo[Mask(preR, preC)].emplace_back(r, c);
			}
		};

		for (int r = 0; r < m_r; r++)
		{
			for (int c = 0; c < m_c; c++)
			{
				for (int k = 0; k < iConnect; k++)
				{
					Move(r, c, r + s_Moves[k][0], c + s_Moves[k][1]);
				}
			}
		}
		return vNeiBo;
	}
	 void EnumGrid(std::function<void(int, int)> call)
	{
		for (int r = 0; r < m_r; r++)
		{
			for (int c = 0; c < m_c; c++)
			{
				call(r, c);
			}
		}
	}	
	 vector<pair<int, int>> GetPos(std::function<bool(int, int)> fun) {
		 vector<pair<int, int>> ret;
		 for (int r = 0; r < m_r; r++)
		 {
			 for (int c = 0; c < m_c; c++)
			 {
				 if (fun(r, c)) {
					 ret.emplace_back(r, c);
				 }
			 }
		 }
		 return ret;
	 }
	inline int Mask(int r, int c) { return  m_c * r + c; }
	const int m_r, m_c;
	const inline static int s_Moves[][2] = { {1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1} };
};

class CBFSLeve {
public :
	static vector<int> Leve(const vector<vector<int>>& neiBo, vector<int> start) {
		vector<int> leves(neiBo.size(), -1);
		for (const auto& s : start) {
			leves[s] = 0;
		}
		for (int i = 0; i < start.size(); i++) {
			for (const auto& next : neiBo[start[i]]) {
				if (-1 != leves[next]) { continue; }
				leves[next] = leves[start[i]]+1;
				start.emplace_back(next);
			}
		}
		return leves;
	}
	static vector<vector<int>> Leve(CGrid& grid, vector<pair<int, int>> start, std::function<bool(int, int)> funVilidCur, std::function<bool(int, int)> funVilidNext, int iConnect = 4 ) {
		auto neiBo = grid.NeiBo(funVilidCur, funVilidCur, iConnect);
		vector<vector<int>> leves(grid.m_r, vector<int>(grid.m_c, -1));
		for (const auto& [r,c] : start) {
			leves[r][c] = 0;
		}
		for (int i = 0; i < start.size(); i++) {
			const int iMask = grid.Mask(start[i].first, start[i].second);
			for (const auto& [r1,c1] : neiBo[iMask]) {
				if (-1 != leves[r1][c1]) { continue; }
				leves[r1][c1] = leves[start[i].first][start[i].second] + 1;
				start.emplace_back(r1,c1);
			}
		}
		return leves;
	}
};

template<class INDEX_TYPE>
class CBinarySearch
{
public:
	CBinarySearch(INDEX_TYPE iMinIndex, INDEX_TYPE iMaxIndex):m_iMin(iMinIndex),m_iMax(iMaxIndex) {}
	template<class _Pr>
	INDEX_TYPE FindFrist( _Pr pr)
	{
		auto left = m_iMin - 1;
		auto rightInclue = m_iMax;
		while (rightInclue - left > 1)
		{
			const auto mid = left + (rightInclue - left) / 2;
			if (pr(mid))
			{
				rightInclue = mid;
			}
			else
			{
				left = mid;
			}
		}
		return rightInclue;
	}
	template<class _Pr>
	INDEX_TYPE FindEnd( _Pr pr)
	{
		int leftInclude = m_iMin;
		int right = m_iMax + 1;
		while (right - leftInclude > 1)
		{
			const auto mid = leftInclude + (right - leftInclude) / 2;
			if (pr(mid))
			{
				leftInclude = mid;
			}
			else
			{
				right = mid;
			}
		}
		return leftInclude;
	}
protected:
	const INDEX_TYPE m_iMin, m_iMax;
};


class Solution {
		public:
			int maximumSafenessFactor(vector<vector<int>>& grid) {
				CGrid ng(grid.size(),grid[0].size());
				auto start = ng.GetPos([&](int r, int c) {return grid[r][c] == 1; });
				auto vilid = [&](int r, int c) {return true; };
				auto leve = CBFSLeve::Leve(ng, start,vilid, vilid);
				auto Check = [&](int mid) {
					auto vilid1 = [&](int r, int c) {return leve[r][c] >= mid; };
					auto leve1 = CBFSLeve::Leve(ng, { {0,0 } }, vilid1, vilid1);
					return leve1.back().back() >= 0;
				};
				CBinarySearch<int> bs(0, leve[0][0]);
				return bs.FindEnd(Check);
			}
		};

第二版

中间过程，求临接表浪费很多时间，省略后，速度提高几倍。就可以过了。许多单格和起点不连通，无需计算。

class CGrid {
public:
	CGrid(int rCount, int cCount) :m_r(rCount), m_c(cCount) {}
	template<class Fun1,class Fun2>
	vector<vector<pair<int, int>>> NeiBo(Fun1 funVilidCur, Fun2 funVilidNext, int iConnect = 4)
	{
		vector<vector<pair<int, int>>> vNeiBo(m_r * m_c);
		for (int r = 0; r < m_r; r++)
		{
			for (int c = 0; c < m_c; c++)
			{
				if (!funVilidCur(r, c))continue;
				auto& v = vNeiBo[Mask(r, c)];
				if ((r > 0)&& funVilidNext(r-1, c)) {
					v.emplace_back(r-1, c);
				}
				if ((c > 0) && funVilidNext(r , c - 1)) {
					v.emplace_back(r, c - 1);
				}
				if ((r+1 < m_r ) && funVilidNext(r + 1, c)) {
					v.emplace_back(r + 1, c);
				}
				if ((c+1 <m_c ) && funVilidNext(r, c + 1)) {
					v.emplace_back(r, c + 1);
				}
			}
		}
		return vNeiBo;
	}
	 void EnumGrid(std::function<void(int, int)> call)
	{
		for (int r = 0; r < m_r; r++)
		{
			for (int c = 0; c < m_c; c++)
			{
				call(r, c);
			}
		}
	}	
	 vector<pair<int, int>> GetPos(std::function<bool(int, int)> fun) {
		 vector<pair<int, int>> ret;
		 for (int r = 0; r < m_r; r++)
		 {
			 for (int c = 0; c < m_c; c++)
			 {
				 if (fun(r, c)) {
					 ret.emplace_back(r, c);
				 }
			 }
		 }
		 return ret;
	 }
	inline int Mask(int r, int c) { return  m_c * r + c; }
	const int m_r, m_c;
	const inline static int s_Moves[][2] = { {1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1} };
};

class CBFSLeve {
public :
	static vector<int> Leve(const vector<vector<int>>& neiBo, vector<int> start) {
		vector<int> leves(neiBo.size(), -1);
		for (const auto& s : start) {
			leves[s] = 0;
		}
		for (int i = 0; i < start.size(); i++) {
			for (const auto& next : neiBo[start[i]]) {
				if (-1 != leves[next]) { continue; }
				leves[next] = leves[start[i]]+1;
				start.emplace_back(next);
			}
		}
		return leves;
	}

	static vector<vector<int>> Dis(CGrid& grid, vector<pair<int, int>> start, std::function<bool(int, int)> funVilidCur, std::function<bool(int, int)> funVilidNext, const int& iConnect = 4 ) {
		static short dir[8][2] = { {0, 1}, {1, 0}, {-1, 0},{ 0, -1},{1,1},{1,-1},{-1,1},{-1,-1} };
		vector<vector<int>> vDis(grid.m_r, vector<int>(grid.m_c, -1));
		for (const auto& [r,c] : start) {
			vDis[r][c] = 0;
		}
		for (int i = 0; i < start.size(); i++) {
			const auto [r,c] = start[i];
			if (!funVilidCur(r, c)) { continue; }
			for (int k = 0; k < iConnect; k++) {
				const int r1 = r + dir[k][0];
				const int c1 = c + dir[k][1];
				if ((r1 < 0) || (r1 >= grid.m_r) || (c1 < 0) || (c1 >= grid.m_c)) { continue; }
				if (funVilidNext(r1, c1)&&(-1 == vDis[r1][c1])) {
					start.emplace_back(r1, c1);
					vDis[r1][c1]= vDis[r][c] + 1;
				}
			}
		}
		return vDis;
	}
};


template<class INDEX_TYPE>
class CBinarySearch
{
public:
	CBinarySearch(INDEX_TYPE iMinIndex, INDEX_TYPE iMaxIndex):m_iMin(iMinIndex),m_iMax(iMaxIndex) {}
	template<class _Pr>
	INDEX_TYPE FindFrist( _Pr pr)
	{
		auto left = m_iMin - 1;
		auto rightInclue = m_iMax;
		while (rightInclue - left > 1)
		{
			const auto mid = left + (rightInclue - left) / 2;
			if (pr(mid))
			{
				rightInclue = mid;
			}
			else
			{
				left = mid;
			}
		}
		return rightInclue;
	}
	template<class _Pr>
	INDEX_TYPE FindEnd( _Pr pr)
	{
		int leftInclude = m_iMin;
		int right = m_iMax + 1;
		while (right - leftInclude > 1)
		{
			const auto mid = leftInclude + (right - leftInclude) / 2;
			if (pr(mid))
			{
				leftInclude = mid;
			}
			else
			{
				right = mid;
			}
		}
		return leftInclude;
	}
protected:
	const INDEX_TYPE m_iMin, m_iMax;
};


		class Solution {
		public:
			int maximumSafenessFactor(vector<vector<int>>& grid) {
				CGrid ng(grid.size(),grid[0].size());		
				auto start = ng.GetPos([&](int r, int c) {return grid[r][c] == 1; });
				auto vilid = [&](int r, int c) {return true; };
				auto dis = CBFSLeve::Dis(ng, start,vilid, vilid);
				auto Check = [&](int mid) {
					auto vilid1 = [&](int r, int c) {return dis[r][c] >= mid; };
					auto dis2 = CBFSLeve::Dis(ng, { {0,0} }, vilid1, vilid1);
					return dis2.back().back() >= 0;
				};
				CBinarySearch<int> bs(0, min(dis[0][0],dis.back().back()));
				return bs.FindEnd(Check);
			}
		};

单元测试

vector<vector<int>> grid;
		TEST_METHOD(TestMethod1)
		{
			grid = { {1} };
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod15)
		{
			grid = { {1,0,0},{0,0,0},{0,0,1} };
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod16)
		{
			grid = { {0,0,1},{0,0,0},{0,0,0} };
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod17)
		{
			grid = { {0,0,0,1},{0,0,0,0},{0,0,0,0},{1,0,0,0} };
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod18)
		{
			grid.assign(400, vector<int>(400));
			grid[0][0] = 1;
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod19)
		{
			grid.assign(400, vector<int>(400));
			grid.back().back() = 1;
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod20)
		{
			grid.assign(400, vector<int>(400));
			grid[0].back() = 1;
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(399, res);
		}
		TEST_METHOD(TestMethod21)
		{
			grid.assign(400, vector<int>(400));
			grid.back()[0] = 1;
			auto res = Solution().maximumSafenessFactor(grid);
			AssertEx(399, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功 成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771
如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

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

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

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

相关文章

【C语言篇】C语言常见概念

【C语言篇】C语言常见概念

文章目录 C语言常见概念C语言是什么C语⾔的历史和辉煌编译器选择编译和连接编译器对比 第一段C语言代码main函数库函数关键字介绍字符和ASCII编码转义字符语句空语句表达式语句函数调⽤语句复合语句控制语句 注释两种形式/* */的形式//形式注释会被替换注释会被替换 C语言常见概…
阅读更多...
关键路径算法（Critical Path）

关键路径算法（Critical Path）

这个算法《算法导论》中并没有提及&#xff0c;很多书和博客说的有点奇怪&#xff0c;所以写本文作为笔记。 关键路径是什么 关键路径的定义非常简单&#xff1a;就是一个图中&#xff0c;权值之和最大的路径就是关键路径。 那么就可以知道关键路径不唯一。 为什么有关键路…
阅读更多...
让大脑处于顶峰的14个保养技巧

让大脑处于顶峰的14个保养技巧

让大脑处于顶峰的14个保养技巧 阅读。 之所以第一个写阅读&#xff0c;是因为阅读需要大脑将已认知的信息与新接触信息结合从而更容易激发人的想象力&#xff0c;而图片与视频虽然更直观&#xff0c;但理解和思考的过程却缩短了&#xff0c;大脑得到的锻炼也十分局限。阅读是让…
阅读更多...
Typesript的type和interface的异同？

Typesript的type和interface的异同？

详解TypeScript中type与interface的区别_javascript技巧_脚本之家 一、相同的地方 1、都可以用来定义对象&#xff0c;描述函数 我们在用typescript开发的时候经常要用到数据类型定义&#xff0c;比如我们写一个接口或者函数的时候定义传参数据类型及字段等。这样子方便知道这…
阅读更多...
opencascade AIS_PointCloud源码学习

opencascade AIS_PointCloud源码学习

AIS_PointCloud 前言 交互对象用于一组点。 表示支持两种显示模式&#xff1a; 点。 用于高亮显示的边界框。 表示通过边界框提供选择。 选择和高亮显示可以通过将默认选择模式设置为 -1 来禁用。 这样在交互视图中将无法选择对象。任何调用 AIS_InteractiveContext::AddOrRem…
阅读更多...
Lua编程

Lua编程

文章目录 概述lua数据类型元表注意 闭包表现 实现 lua/c 接口编程skynet中调用层次虚拟栈C闭包注册表userdatalightuserdata 小结 概述 这次是skynet&#xff0c;需要一些lua/c相关的。写一篇博客&#xff0c;记录下。希望有所收获。 lua数据类型 boolean , number , string…
阅读更多...
【一图学技术】2.API测试9种方法图解

【一图学技术】2.API测试9种方法图解

9种API测试方法 冒烟测试&#xff1a;冒烟测试是一种快速的表面级测试&#xff0c;用于验证软件的基本功能是否正常工作&#xff0c;以确定是否值得进行更详细的测试。功能测试&#xff1a;功能测试是验证软件是否符合预期功能要求的测试类型。它涉及对每个功能进行测试&#…
阅读更多...
[C++进阶]对于多态的底层逻辑

[C++进阶]对于多态的底层逻辑

上回我们了解到了多态的定义,概念以及实现,对于多态如何使用和使用条件进行了了解,本篇我们将了解多态的原理。 一、虚函数表 首先我们看看如下代码&#xff1a; #include<iostream> using namespace std; class Base { public:virtual void Func1(){cout << &qu…
阅读更多...
动手学深度学习V2每日笔记（权重衰退+Dropout）

动手学深度学习V2每日笔记（权重衰退+Dropout）

本文主要参考沐神的视频教程 https://www.bilibili.com/video/BV1UK4y1o7dy/vd_sourcec7bfc6ce0ea0cbe43aa288ba2713e56d 文档教程 https://zh-v2.d2l.ai/ 本文的主要内容对沐神提供的代码中个人不太理解的内容进行笔记记录&#xff0c;内容不会特别严谨仅供参考。 1.函数目录…
阅读更多...
百某应JS逆向

百某应JS逆向

https://ying.baichuan-ai.com/ 目录 一、发起提问 二、观察发现有两个加密参数&#xff1a;X-Bc-Sig和X-Bc-Ts ​三、观察JS调用栈 四、从JS中搜索 X-Bc-Sig和X-Bc-Ts 五、断点并分析参数的生成方式 六、分析入参 七、发现关键的o方法调用了一个i()方法 八、验证结果 …
阅读更多...
sqlilabs解题方法

sqlilabs解题方法

Lass1 查询id为1的用户名和密码 查询id为2的用户名和密码 没有回显&#xff0c;不含id-1的行 判断字段数&#xff0c;字段数为3 查询数据库用户名&#xff0c;和数据库名 查询时id必须超出数据库以外&#xff0c;一般用-1 用户名&#xff1a;user() 数据库名&#xff1a;databa…
阅读更多...
VulnHub：colddbox easy

VulnHub：colddbox easy

靶机下载地址 信息收集 主机发现 攻击机网段192.168.31.0/24&#xff0c;扫描同网段存活主机。 nmap 192.168.31.0/24 -Pn -T4 发现靶机&#xff0c;IP为192.168.31.176。 端口扫描 扫描靶机开放端口。 nmap 192.168.31.176 -A -p- -T4 开放了80,4512端口&#xff0c;注…
阅读更多...
[H并查集] lc100347. 判断矩形的两个角落是否可达(并查集+高质量+周赛408_4)

[H并查集] lc100347. 判断矩形的两个角落是否可达(并查集+高质量+周赛408_4)

文章目录 1. 题目来源2. 题目解析 1. 题目来源 链接&#xff1a;100347. 判断矩形的两个角落是否可达 参考&#xff1a; 灵神视频题解&#xff1a;筛质数 巧妙枚举 并查集【力扣周赛 408】 这一期周赛很不错。 2. 题目解析 十分不错的题目哈&#xff0c;关键是题意的转换…
阅读更多...
哈希 Hash（闭散列、开散列介绍及其实现）

哈希 Hash（闭散列、开散列介绍及其实现）

目录 unordered 系列关联式容器unordered_mapunordered_map 的介绍unordered_map 的接口说明构造函数容量函数迭代器元素访问查询操作修改操作桶操作 unordered_setunordered_set 的介绍unordered_set 的接口说明构造函数容量函数迭代器查询操作修改操作桶操作 底层结构哈希概念…
阅读更多...
Catalyst优化器:让你的Spark SQL查询提速10倍

Catalyst优化器:让你的Spark SQL查询提速10倍

目录 1 逻辑优化阶段 2.1 逻辑计划解析 2.2 逻辑计划优化 2.2.1 Catalys的优化过程 2.2.2 Cache Manager优化 2 物理优化阶段 2.1 优化 Spark Plan 2.1.1 Catalyst 的 Join 策略 2.1.2 如何决定选择哪一种 Join 策略 2.2 Physical Plan 2.2.1 EnsureRequirements 规则 3 相关文…
阅读更多...
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第五十七章 Linux中断实验

【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第五十七章 Linux中断实验

i.MX8MM处理器采用了先进的14LPCFinFET工艺&#xff0c;提供更快的速度和更高的电源效率;四核Cortex-A53&#xff0c;单核Cortex-M4&#xff0c;多达五个内核 &#xff0c;主频高达1.8GHz&#xff0c;2G DDR4内存、8G EMMC存储。千兆工业级以太网、MIPI-DSI、USB HOST、WIFI/BT…
阅读更多...
python 裁剪图片

python 裁剪图片

情况&#xff1a; 有时候看视频&#xff0c;看到一个漂亮的妹子&#xff0c;按下 Alt PrintScreen 进行截图之后&#xff0c;会把整个屏幕都截图。 需要适当剪裁一下。 每次打开 PS &#xff0c; 也太慢了。 所以写个代码&#xff0c; 快速处理。 效果对比&#xff1a; 原始…
阅读更多...
个人定制化形象生成，FaceChain最新模型部署

个人定制化形象生成，FaceChain最新模型部署

FaceChain是阿里巴巴达摩院推出的一个开源的人物写真和个人数字形象的AI生成框架。 FaceChain利用了Stable Diffusion模型的文生图功能&#xff0c;并结合人像风格化LoRA模型训练及人脸相关感知理解模型&#xff0c;将输入的图片进行训练后推理输出生成个人写真图像。 FaceCh…
阅读更多...
【redis】对hash类型和list类型的常用命令,应用场景,内部编码的总结

【redis】对hash类型和list类型的常用命令,应用场景,内部编码的总结

˃͈꒵˂͈꒱ write in front ꒰˃͈꒵˂͈꒱ ʕ̯•͡˔•̯᷅ʔ大家好&#xff0c;我是xiaoxie.希望你看完之后,有不足之处请多多谅解&#xff0c;让我们一起共同进步૮₍❀ᴗ͈ . ᴗ͈ აxiaoxieʕ̯•͡˔•̯᷅ʔ—CSDN博客 本文由xiaoxieʕ̯•͡˔•̯᷅ʔ 原创 CSDN 如…
阅读更多...
初识c++：vector全方面讲解及其代码模拟实现

初识c++：vector全方面讲解及其代码模拟实现

本节大纲&#xff1a; vector全方面讲解及其代码模拟实现 1.学习vector方法 2.vector的使用 2.1 vector的定义 2.2 vector iterator 的使用 2.3 vector 空间增长问题 2.4 vector 增删查改 2.5 vector 迭代器失效问题&#xff08;重点&#xff09; 3.vector 深度刨析 4…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023