【剪枝】【广度优先】【深度优先】488祖玛游戏

news2024/11/17 17:40:28

作者推荐

【动态规划】458:可怜的小猪

涉及知识点

剪枝 广度优先 深度优先

488祖玛游戏

在这个祖玛游戏变体中，桌面上有 一排 彩球，每个球的颜色可能是：红色 ‘R’、黄色 ‘Y’、蓝色 ‘B’、绿色 ‘G’ 或白色 ‘W’ 。你的手中也有一些彩球。
你的目标是 清空 桌面上所有的球。每一回合：
从你手上的彩球中选出 任意一颗 ，然后将其插入桌面上那一排球中：两球之间或这一排球的任一端。
接着，如果有出现 三个或者三个以上 且 颜色相同 的球相连的话，就把它们移除掉。
如果这种移除操作同样导致出现三个或者三个以上且颜色相同的球相连，则可以继续移除这些球，直到不再满足移除条件。
如果桌面上所有球都被移除，则认为你赢得本场游戏。
重复这个过程，直到你赢了游戏或者手中没有更多的球。
给你一个字符串 board ，表示桌面上最开始的那排球。另给你一个字符串 hand ，表示手里的彩球。请你按上述操作步骤移除掉桌上所有球，计算并返回所需的 最少 球数。如果不能移除桌上所有的球，返回 -1 。
示例 1：
输入：board = “WRRBBW”, hand = “RB”
输出：-1
解释：无法移除桌面上的所有球。可以得到的最好局面是：

  • 插入一个 ‘R’ ，使桌面变为 WRRRBBW 。WRRRBBW -> WBBW
  • 插入一个 ‘B’ ，使桌面变为 WBBBW 。WBBBW -> WW
    桌面上还剩着球，没有其他球可以插入。
    示例 2：
    输入：board = “WWRRBBWW”, hand = “WRBRW”
    输出：2
    解释：要想清空桌面上的球，可以按下述步骤：
  • 插入一个 ‘R’ ，使桌面变为 WWRRRBBWW 。WWRRRBBWW -> WWBBWW
  • 插入一个 ‘B’ ，使桌面变为 WWBBBWW 。WWBBBWW -> WWWW -> empty
    只需从手中出 2 个球就可以清空桌面。
    示例 3：
    输入：board = “G”, hand = “GGGGG”
    输出：2
    解释：要想清空桌面上的球，可以按下述步骤：
  • 插入一个 ‘G’ ，使桌面变为 GG 。
  • 插入一个 ‘G’ ，使桌面变为 GGG 。GGG -> empty
    只需从手中出 2 个球就可以清空桌面。
    示例 4：
    输入：board = “RBYYBBRRB”, hand = “YRBGB”
    输出：3
    解释：要想清空桌面上的球，可以按下述步骤：
  • 插入一个 ‘Y’ ，使桌面变为 RBYYYBBRRB 。RBYYYBBRRB -> RBBBRRB -> RRRB -> B
  • 插入一个 ‘B’ ，使桌面变为 BB 。
  • 插入一个 ‘B’ ，使桌面变为 BBB 。BBB -> empty
    只需从手中出 3 个球就可以清空桌面。

提示：
1 <= board.length <= 16
1 <= hand.length <= 5
board 和 hand 由字符 ‘R’、‘Y’、‘B’、‘G’ 和 ‘W’ 组成
桌面上一开始的球中，不会有三个及三个以上颜色相同且连着的球

剪枝

剪枝一：如果手中有多个相同颜色的球，只需要尝试一个，其它不需要尝试。
剪枝二：如果收中的球和桌面颜色相同的球，只需要考虑插入到最前面。在一个红球的前面或后面插入红球，结果一样两个连续的红球。在两个红球的前面或后面或中间插入红球的效果一样，连续的3个红球消除。
假定插入的颜色是ch，插入的位置是i，只需要考虑以下两种情况：
一，board[i]等于ch。
二，board[i-1]等于board[i]。
忽略剪枝后，再考虑这两种情况。这两种情况都是必须，缺少情况一，无法消除任何球。缺少情况二，无法消除以下用例：
RRWWRRBBRR WB，第一步消除W或B的连锁反应都会消除4个R，造成余下的2个R，无法消除。
RRWWRRBBRWR − − − > 消除 B _{--->}^{消除B} −−−>消除B​ RRWWRRRWR − − − − − − − − > 连锁消除 3 个 R _{-------->}^{连锁消除3个R} −−−−−−−−>连锁消除3个R​ RRWWWR − − − − − − − − > 连锁消除 3 个 W _{-------->}^{连锁消除3个W} −−−−−−−−>连锁消除3个W​ RRR − − − − − − − − > 连锁消除 3 个 W _{-------->}^{连锁消除3个W} −−−−−−−−>连锁消除3个W​ 结束。

下面来证明为什么只需要考虑两种情况：

0==i两种相等情况一
两种不等假定ch能被消除，假定和ch同时消除，从左向右第一个小标为i1，board[0]和board[i1]一起被消除，说明board(0,i1)能被消除且不依赖不影响board[i1]，那将ch不插入到0，插入到i1，操作顺序完全一样。被淘汰。简称证明一。
board.length-1 == i两者相等就是剪枝二。
两者不等类似证明一。
i是中间的下标三者相等剪枝二淘汰。
ch==board[i]就是情况一。
ch==board[i-1]就是剪枝二，淘汰。
board[i-1]==board[i]就是情况二。
三者不等。假定ch能被消除，否则则组合没有任何意义。一个ch无法消除，所以它的左边或边有必定有一个ch被一起消除。不失一般性，假定在它的左边，下标为i1，borad[i1]和ch一起被消除，说明(i1,i)的字符都消除。那将ch插入到i1和i的效果一样。由于board[i-1]不等于board[i]和ch，所以无论是否插入ch，都不会影响右边的字符。 两中方案(i1,i)的左边都是ch，所以新方案不会有影响左边。

第一版代码

class Solution {
public:
int findMinStep(string board, string hand) {
sort(hand.begin(), hand.end());
queue<pair<string, string>> que;
unordered_set setHasDo;
auto Add = [&](const string& s, const string& h)
{
bool bEmpty = s.empty();
const string cur = s + “-” + h;
if (setHasDo.count(cur))
{
return;
}
setHasDo.emplace(cur);
que.emplace(s, h);
};
Add(board, hand);
while (que.size())
{
auto [s, h] = que.front();
que.pop();
if (s.empty())
{
return hand.length() - h.length();
}
unordered_map<char, int> mCharCount;
for (const auto& ch : h)
{
mCharCount[ch]++;
}
for (int j = 0; j < s.length(); j++)
{
if ((j + 1 < s.length()) && (s[j] == s[j + 1]))
{
if (mCharCount.count(s[j]) && (mCharCount[s[j]] >= 1))
{
mCharCount[s[j]]–;
Add(Do(s.substr(0,j+1)+s[j] + s.substr(j+1)),ToString(mCharCount));
mCharCount[s[j]]++;
}
for ( auto& [ch, iCnt] : mCharCount)
{
if (ch != s[j])
{
iCnt–;
Add(Do(s.substr(0, j+1) + ch + s.substr(j + 1)), ToString(mCharCount));
iCnt++;
}
}
}
else
{
if (mCharCount.count(s[j]) && (mCharCount[s[j]] >= 2))
{
mCharCount[s[j]] -= 2;
Add(Do(s.substr(0, j) + s[j] + s[j] + s.substr(j)), ToString(mCharCount));
mCharCount[s[j]] += 2;
}
}
}
}
return -1;
}
string Do(const string& s)
{
stack<pair<char, int>> sta;
for (const char& ch : s )
{
while (sta.size() && (sta.top().first != ch) && (sta.top().second >= 3))
{
sta.pop();
}
if (sta.size() && (sta.top().first == ch))
{
sta.top().second++;
}
else
{
sta.emplace(ch, 1);
}
}
string sRet;
while (sta.size())
{
const auto [ch, iCnt] = sta.top();
sta.pop();
if (iCnt < 3)
{//最后一个元素需要判断
sRet += string(iCnt, ch);
}
}
return sRet; //正序和反序是一样的
}
string ToString(const unordered_map<char, int>& mCharCount)
{
string strRet;
for (const auto& [ch, iCnt] : mCharCount)
{
strRet += string(iCnt, ch);
}
return strRet;
}
}; ，

测试用例

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()
{
	string board,  hand;	
	{
		Solution sln;
		board = "RRWWRRBBRR", hand = "WB";
		auto res = sln.findMinStep(board, hand);
		Assert(2, res);
	}
	{
		Solution sln;
		board = "WWRRBBWW", hand = "WRBRW";
		auto res = sln.findMinStep(board, hand);
		Assert(2, res);
	}

	
	{
		Solution sln;
		board = "G", hand = "GGGGG";
		auto res = sln.findMinStep(board, hand);
		Assert(2, res);
	}
	{
		Solution sln;
		board = "WRRBBW", hand = "RB";
		auto res = sln.findMinStep(board, hand);
		Assert(-1, res);
	}
	{
		Solution sln;
		board = "WRRBBW", hand = "RB";
		auto res = sln.findMinStep(board, hand);
		Assert(-1, res);
	}

	
	{
		Solution sln;
		board = "RBYYBBRRB", hand = "YRBGB";
		auto res = sln.findMinStep(board, hand);
		Assert(3, res);
	}
	{
		Solution sln;
		board = "RRGGBBYYWWRRGGBB", hand = "RGBYW";
		auto res = sln.findMinStep(board, hand);
		Assert(-1, res);
	}

	
}

小的优化

class Solution {
public:
	int findMinStep(string board, string hand) {
		sort(hand.begin(), hand.end());
		queue<pair<string,string>> que;
		unordered_set<string> setHasDo;
		auto Add = [&](const string& s, const string& h)
		{
			const string cur = s + "-" + h;
			if (setHasDo.count(cur))
			{
				return;
			}
			setHasDo.emplace(cur);
			que.emplace(s,h);
		};
		Add(board, hand);
		while (que.size())
		{
			auto[s,h] = que.front();
			que.pop();	
			if (s.empty())
			{
				return hand.length() - h.length();
			}
			for (int i = 0 ; i < h.length();i++)
			{
				if (i && (h[i] == h[i - 1]))
				{//剪枝一
					continue;
				}
				string h2 = h.substr(0,i) + h.substr(i+1);
				for (int j = 0; j < s.length(); j++)
				{
					if (j&& (h[i] == s[j-1]))
					{
						continue;//剪枝二
					}
					if ((h[i] == s[j])||(j && (s[j - 1] == s[j])))
					{
						Add(Do(s, j, h[i]), h2);
					}
				}
			}
		}
		return -1;
	}
	string Do(const string& s, int l1,  const char& ch)
	{		
		stack<pair<char,int>> sta;
		auto Add = [&sta](const char& ch)
		{
			while (sta.size() && (sta.top().first != ch ) && (sta.top().second >= 3))
			{
				sta.pop();
			}
			if (sta.size()&& (sta.top().first == ch))
			{
				sta.top().second++;
			}
			else
			{
				sta.emplace(ch,1);
			}			
		};
		for (int i = 0; i < l1; i++)
		{
			Add( s[i]);
		}
		Add(ch);
		for (int i = l1; i < s.length() ; i++)
		{
			Add(s[i]);
		}
		string sRet;
		while (sta.size())
		{
			const auto [ch,iCnt] = sta.top();
			sta.pop();
			if (iCnt < 3)
			{//最后一个元素需要判断
				sRet += string(iCnt, ch);
			}
		}
		return sRet; //正序和反序是一样的
	}
};

实际上只需要考虑三种情况

  • 弹出一个球，三消。
  • 弹出两个同颜色的球三消。
  • 两个同颜色的球直接插入不同颜色的球。
class Solution {
public:
	int findMinStep(string board, string hand) {
		sort(hand.begin(), hand.end());
		queue<pair<string, string>> que;
		unordered_set<string> setHasDo;
		auto Add = [&](const string& s, const string& h)
		{
			bool bEmpty = s.empty();
			const string cur = s + "-" + h;
			if (setHasDo.count(cur))
			{
				return;
			}
			setHasDo.emplace(cur);
			que.emplace(s, h);
		};
		Add(board, hand);
		while (que.size())
		{
			auto [s, h] = que.front();
			que.pop();
			if (s.empty())
			{
				return hand.length() - h.length();
			}
			unordered_map<char, int> mCharCount;
			for (const auto& ch : h)
			{
				mCharCount[ch]++;
			}			
			for (int j = 0; j < s.length(); j++)
			{
				if ((j + 1 < s.length()) && (s[j] == s[j + 1]))
				{
					if (mCharCount.count(s[j]) && (mCharCount[s[j]] >= 1))
					{
						mCharCount[s[j]]--;
						Add(Do(s.substr(0,j+1)+s[j] + s.substr(j+1)),ToString(mCharCount));
						mCharCount[s[j]]++;
					}
					for ( auto& [ch, iCnt] : mCharCount)
					{
						if (ch != s[j])
						{
							iCnt--;
							Add(Do(s.substr(0, j+1) + ch + s.substr(j + 1)), ToString(mCharCount));
							iCnt++;
						}
					}
				}
				else
				{
					if (mCharCount.count(s[j]) && (mCharCount[s[j]] >= 2))
					{
						mCharCount[s[j]] -= 2;
						Add(Do(s.substr(0, j) + s[j] + s[j] + s.substr(j)), ToString(mCharCount));
						mCharCount[s[j]] += 2;
					}
				}				
			}
		}
		return -1;
	}
	string Do(const string& s)
	{
		stack<pair<char, int>> sta;
		for (const char& ch : s )
		{
			while (sta.size() && (sta.top().first != ch) && (sta.top().second >= 3))
			{
				sta.pop();
			}
			if (sta.size() && (sta.top().first == ch))
			{
				sta.top().second++;
			}
			else
			{
				sta.emplace(ch, 1);
			}
		}
		string sRet;
		while (sta.size())
		{
			const auto [ch, iCnt] = sta.top();
			sta.pop();
			if (iCnt < 3)
			{//最后一个元素需要判断
				sRet += string(iCnt, ch);
			}
		}
		return sRet; //正序和反序是一样的
	}
	string ToString(const unordered_map<char, int>& mCharCount)
	{
		string strRet;
		for (const auto& [ch, iCnt] : mCharCount)
		{
			strRet += string(iCnt, ch);
		}
		return strRet;
	}
};

进一步改进

hand的状态可以用位运算来表示，这可以提速，本题已经够复杂了。就不继续了。
可以用 深度优先，但要处理重复搜索。
已有状态： board用字符串，字典树提速。 hand用int 提速。

2023年1月版

class Solution {
public:
int findMinStep(string board, string hand) {
std::sort(hand.begin(), hand.end());
m_iMaxStep = hand.size();
std::unordered_set pre;
pre.emplace(hand + board);
for (int iStep = m_iMaxStep; iStep > 0; iStep–)
{
std::unordered_set dp;
for (const auto str : pre)
{
const string sHand = str.substr(0, iStep);
const string sBoard = str.substr(iStep);
if (“” == sBoard)
{
return m_iMaxStep - iStep;
}
Do(dp, sBoard, sHand);
}
pre.swap(dp);
}
if (pre.count(“”))
{
return m_iMaxStep;
}
return -1;
}
void Do(std::unordered_set& dp, const string& strBoard, const string& strHand)
{
for (int i = 0; i < strHand.size(); i++)
{
if ((i>0) && (strHand[i] == strHand[i - 1]))
{
continue;
}
string tmp = strHand;
tmp.erase(i, 1);
const char& ch = strHand[i];
for (int j = 0; j <= strBoard.size(); j++)
{
bool bNeedDo = false;
if (j < strBoard.length() && (strBoard[j] == ch))
{
bNeedDo = true;
}
if (j>0)
{
if ((j < strBoard.length()) && (strBoard[j-1] == strBoard[j])&&(ch != strBoard[j]))
{
bNeedDo = true;
}
}
if (!bNeedDo)
{
continue;
}
dp.emplace(tmp + Do(strBoard, j, ch));
}
}
}
string Do(string strBoard, int index, const char& ch)
{
strBoard.insert(index, std::string(“”) + ch);
Erase(strBoard, index);
return strBoard;
}
void Erase(string& strBoard, int index)
{
string res;
vector<pair<char, int>> st;
for (auto c : strBoard) {
while (!st.empty() && c != st.back().first && st.back().second >= 3) {
st.pop_back();
}
if (st.empty() || c != st.back().first) {
st.push_back({ c, 1 });
}
else {
st.back().second++;
}
}
if (!st.empty() && st.back().second >= 3) {
st.pop_back();
}
for (int i = 0; i < st.size(); ++i) {
for (int j = 0; j < st[i].second; ++j) {
res.push_back(st[i].first);
}
}
strBoard = res;
}
int m_iMaxStep;
};

扩展阅读

视频课程

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

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

相关文章

flutter使用getx进行数据状态管理，实现页面响应式

flutter使用getx进行数据状态管理，实现页面响应式

无论是什么样的应用&#xff0c;都还是需要最基础的数据来支撑的&#xff0c;而且不同的页面之间可能需要共享数据状态&#xff0c;这就显得数据状态管理非常有必要了。因为我这里使用了get依赖库&#xff0c;所以就可以直接在项目中使用getx来管理状态&#xff0c;不想再使用别…
阅读更多...
PDF-XChange Editor v10.2.0.384

PDF-XChange Editor v10.2.0.384

软件介绍 PDF-XChange Editor&#xff0c;号称打开速度最快最强大的PDF编辑器/PDF阅读器&#xff0c;PDF-XChange专注于PDF文档的编辑&#xff0c;打开PDF文件速度快&#xff0c;软件小功能强大&#xff0c;可以自定义制作PDF电子文档&#xff0c;具有创建&#xff0c;查看&am…
阅读更多...
2024年实时获取地图边界数据方法，省市区县街道多级联动【附实时geoJson数据下载】

2024年实时获取地图边界数据方法，省市区县街道多级联动【附实时geoJson数据下载】

首先&#xff0c;来看下效果图 在线体验地址&#xff1a;https://geojson.hxkj.vip&#xff0c;并提供实时geoJson数据文件下载 可下载的数据包含省级geojson行政边界数据、市级geojson行政边界数据、区/县级geojson行政边界数据、省市区县街道行政编码四级联动数据&#xff0…
阅读更多...
基于Linux的Flappy bird游戏开发

基于Linux的Flappy bird游戏开发

项目介绍 主要是使用C语言实现&#xff0c;开启C项目之旅。 复习巩固C语言、培养做项目的思维。 功能&#xff1a; 按下空格键小鸟上升&#xff0c;不按下落&#xff1b; 显示小鸟需要穿过的管道&#xff1b; 小鸟自动向右飞行&#xff1b;&#xff08;管道自动左移和创建&a…
阅读更多...
1-Docker-基础

1-Docker-基础

本文内容多处参考黑马程序员的公开资料&#xff0c;仅用来个人梳理&#xff0c;原资料地址&#xff1a;https://b11et3un53m.feishu.cn/wiki/MWQIw4Zvhil0I5ktPHwcoqZdnec Docker介绍 为什么要用Docker&#xff1f; 以Mysql安装为例&#xff0c;想要在Linux系统上安装Mysql&…
阅读更多...
brpc: a little source code

brpc: a little source code

之前在https://www.yuque.com/treblez/qksu6c/nqe8ip59cwegl6rk?singleDoc# 《olap/clickhouse-编译器优化与向量化》中我谈过brpc的汇编控制bthread。本文就来看一下brpc作为一个高性能的rpc实现&#xff0c;除了自定义线程栈之外&#xff0c;代码还有什么优秀之处。 因为时间…
阅读更多...
Windows11 安装MySQL8.0操作

Windows11 安装MySQL8.0操作

一、从MySQL官网下载MySQL安装包 官网地址&#xff1a; www.mysql.com &#xff08;1&#xff09;首先 选择 DOWNLOADS 下载界面 &#xff08;2&#xff09;其次选择 MySQL 客户端 下载 &#xff08;3&#xff09;选择windows安装MySQL &#xff08;4&#xff09;选择MySQL类型…
阅读更多...
【目标检测】YOLOv5算法实现(八)：模型验证

【目标检测】YOLOv5算法实现(八)：模型验证

本系列文章记录本人硕士阶段YOLO系列目标检测算法自学及其代码实现的过程。其中算法具体实现借鉴于ultralytics YOLO源码Github&#xff0c;删减了源码中部分内容&#xff0c;满足个人科研需求。   本系列文章主要以YOLOv5为例完成算法的实现&#xff0c;后续修改、增加相关模…
阅读更多...
【DevOps-08-3】Jenkins容器内部使用Docker

【DevOps-08-3】Jenkins容器内部使用Docker

一、简要描述 构建镜像和发布镜像到harbor都需要使用到docker命令。而在Jenkins容器内部安装Docker官方推荐直接采用宿主机带的Docker即可。 设置Jenkins容器使用宿主机Docker。 二、配置和操作步骤 1、修改宿主机docker.sock权限 # 修改docker.sock 用户和用户组都为root $ …
阅读更多...
如何配置Kafka账号密码

如何配置Kafka账号密码

背景 我们需要与第三方系统进行数据同步&#xff0c;需要搭建公网Kafka&#xff0c;Kafka默认是没有用户密码校验的&#xff0c;所以我们需要配置用户名密码校验。 配置 新增JAAS配置文件 在conf目录下新增kafka_server_jaas.conf文件&#xff0c;文件内容如下&#xff1a;…
阅读更多...
高压消防泵：科技与安全性的完美结合

高压消防泵：科技与安全性的完美结合

在现代社会&#xff0c;随着科技的不断发展&#xff0c;各种高科技设备层出不穷&#xff0c;为我们的生活带来了极大的便利。在森林火灾扑救领域&#xff0c;恒峰智慧科技研发的高压消防泵作为一种高效、节能、绿色、环保的优质设备&#xff0c;将科技与安全性完美地结合在一起…
阅读更多...
最强联网Chat GPT 火爆全网高速 永久免费

最强联网Chat GPT 火爆全网高速 永久免费

&#x1f534;高速联网 秒响应支持语音通话&#x1f388; 首先介绍一下她的功能吧&#x1f601; 女友消息代回机&#x1f44c;&#x1f3fb; 朋友圈文案&#x1f44c;&#x1f3fb; 聊天话术&#x1f44c;&#x1f3fb; 高情商回复&#x1f44c;&#x1f3fb; 脱单助…
阅读更多...
Windows使用（版本8.11）ElasticSearch、elasticsearch-head、kibana

Windows使用（版本8.11）ElasticSearch、elasticsearch-head、kibana

下载安装引用这篇文章 目录 1、ES基本知识核心术语核心概念倒排索引ES字典树ES怎么保证读写一致 2、Window启动ES步骤elasticsearch-8.11.3elasticsearch-head-masterkibana-8.11.3 3、Kibana 调用ES API示例 1、ES基本知识 核心术语 ● 索引&#xff1a;index &#xff08;相…
阅读更多...
持续构建行业影响力|HarmonyOS SDK荣膺年度“技术卓越”奖项

持续构建行业影响力|HarmonyOS SDK荣膺年度“技术卓越”奖项

自2023年9月华为宣布鸿蒙原生应用全面启动以来&#xff0c;HarmonyOS SDK通过将HarmonyOS系统级能力对外开放&#xff0c;支撑开发者高效打造更纯净、更智能、更精致、更易用的鸿蒙原生应用&#xff0c;和开发者共同成长。 通过在开发者社区和HarmonyOS开发者持续的内容共创与技…
阅读更多...
uniapp小程序超出一行显示...并展示更多按钮

uniapp小程序超出一行显示...并展示更多按钮

注意:全部标签需要浮动在父盒子右边哦 循环获取所有需要展示数据标签的高度 this.goods this.goods.map(item > ({...item,showBtn: false}));this.$nextTick(() > {uni.createSelectorQuery().in(this).selectAll(".cart-info").boundingClientRect((data)…
阅读更多...
RocketMQ源码阅读-Producer发消息

RocketMQ源码阅读-Producer发消息

RocketMQ源码阅读-Producer发消息 1. 从单元测试入手2. 启动过程3. 同步消息发送过程4. 异步消息发送过程5. 小结 Producer是消息的生产者。 Producer和Consummer对Rocket来说都是Client&#xff0c;Server是NameServer。 客户端在源码中是一个单独的Model&#xff0c;目录为ro…
阅读更多...
LeetCode - 1371 每个元音包含偶数次的最长子字符串（Java JS Python C）

LeetCode - 1371 每个元音包含偶数次的最长子字符串（Java JS Python C）

题目来源 1371. 每个元音包含偶数次的最长子字符串 - 力扣&#xff08;LeetCode&#xff09; 题目描述 给你一个字符串 s &#xff0c;请你返回满足以下条件的最长子字符串的长度&#xff1a;每个元音字母&#xff0c;即 a&#xff0c;e&#xff0c;i&#xff0c;o&#xff0…
阅读更多...
【Git】的工作流程简介

【Git】的工作流程简介

目录 Git的工作区域Git的基本流程 1.将工作区的代码添加到暂存区2.将暂存区的文件提交到本地仓库3.将暂存区的文件提交到远程仓库 Git的工作区域 Git的基本流程 图形化方式操作 命令行模式&#xff08;Linux系统常用&#xff09;操作 1.将工作区的代码添加到暂存区 查看文件状…
阅读更多...
架构03 - 理解构架的视角

架构03 - 理解构架的视角

学习架构时&#xff0c;首要任务是弄清楚不同视角对于架构的理解&#xff0c;因为每个人对于架构的理解可能存在差异。不同职位对于架构的关注点也不同。开发人员更多关注开发架构&#xff0c;售前人员更多关注业务架构&#xff0c;运维人员更多关注运维架构&#xff0c;技术支…
阅读更多...
基于SSM的电脑测评系统（有报告）。Javaee项目。ssm项目。

基于SSM的电脑测评系统（有报告）。Javaee项目。ssm项目。

演示视频&#xff1a; 基于SSM的电脑测评系统&#xff08;有报告&#xff09;。Javaee项目。ssm项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&#xff0c;通过Spring Spri…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023