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

news2024/11/18 15:44:47

作者推荐

视频算法专题

本文涉及知识点

动态规划汇总

LeetCode 1531. 压缩字符串 II

行程长度编码 是一种常用的字符串压缩方法，它将连续的相同字符（重复 2 次或更多次）替换为字符和表示字符计数的数字（行程长度）。例如，用此方法压缩字符串 “aabccc” ，将 “aa” 替换为 “a2” ，“ccc” 替换为` “c3” 。因此压缩后的字符串变为 “a2bc3” 。
注意，本问题中，压缩时没有在单个字符后附加计数 ‘1’ 。
给你一个字符串 s 和一个整数 k 。你需要从字符串 s 中删除最多 k 个字符，以使 s 的行程长度编码长度最小。
请你返回删除最多 k 个字符后，s 行程长度编码的最小长度 。
示例 1：
输入：s = “aaabcccd”, k = 2
输出：4
解释：在不删除任何内容的情况下，压缩后的字符串是 “a3bc3d” ，长度为 6 。最优的方案是删除 ‘b’ 和 ‘d’，这样一来，压缩后的字符串为 “a3c3” ，长度是 4 。
示例 2：
输入：s = “aabbaa”, k = 2
输出：2
解释：如果删去两个 ‘b’ 字符，那么压缩后的字符串是长度为 2 的 “a4” 。
示例 3：
输入：s = “aaaaaaaaaaa”, k = 0
输出：3
解释：由于 k 等于 0 ，不能删去任何字符。压缩后的字符串是 “a11” ，长度为 3 。
提示：
1 <= s.length <= 100
0 <= k <= s.length
s 仅包含小写英文字母

动态规划

预处理

将s转成arr，每个元素是{字符，长度}。
比如：aabbaa变成{{‘a’,2},{'b",2},{‘a’,2}}
长度0，表示0个字符。长度1，表示1个字符。长度2，表示2到9.长度3，表示10到99，长度4，表示100及以上。

动态规划的状态表示

pre[j] 表示处理完arr[0,i)后， 用去j个字符的最短行程码。
dp[j] 表示处理完arr[0,i]后， 用去j个字符的最短行程码。
pre2[ch][j][m] 表示处理完arr[0,i)后，,以ch+'a’结尾，用去j个字符，最后有m个ch的最短行程码。
dp2表示处理完arr[0,i]…

动态规划的转移方程

arr[i]没有和前面的元素合并：
枚举j，枚举减少长度：0、1、2、3、4
arr[j]和前面的合并：
枚举j,m 再枚举减少长度:0、1、2、3 、4
合并示例：aa d d ‾ \underline{dd} dd​aa 删除dd后，就是4个aa了。

动态规划的初始状态

pre[0]=0,其它100。
pre2全部100。

动态规划的填表顺序

i从小到大。

动态规划的返回值

pre.back().back()

代码

核心代码

class Solution {
public:
	int getLengthOfOptimalCompression(string s, int k) {
		const int lenArr = s.length();
		vector<pair<char, int>> arr;
		for (int left = 0, i = 0; i <= s.length(); i++)
		{
			if ((i >= s.length()) || (s[left] != s[i]))
			{
				arr.emplace_back(s[left], i - left);
				left = i;
			}
		}
		vector<int> vLen = { 0,1,2,10,100 };
		auto GetCodeLen = [&vLen](int len)
		{
			int i = vLen.size() - 1;
			for (; (i >= 0) && (len < vLen[i]); i--);
			return i;
		};
		auto MaxLen = [&vLen](int len)
		{
			return vLen[len + 1] - 1;
		};
		vector<int> pre(lenArr + 1, 100);
		pre[0] = 0;
		vector<vector<vector<int>>> dp3(26, vector<vector<int>>(lenArr+1, vector<int>(lenArr + 1, 100)));
		for (const auto& [ch, cnt] : arr)
		{
			vector<int> dp(lenArr + 1, 100);
			auto& dp2 = dp3[ch - 'a'];
			auto pre2 = dp2;
			auto Update = [&lenArr,&dp,&dp2](int j, int iCodeLen,const char& chEnd,int iEndLen)
			{
				if (j > lenArr)
				{
					return;
				}
				dp[j] = min(dp[j], iCodeLen);
				if (iEndLen <= lenArr)
				{
					dp2[j][iEndLen] = min(dp2[j][iEndLen], iCodeLen);
				}
			};			
			//处理没合并
			for (int j = 0; j <= lenArr; j++)
			{	
				const int curCodeLen = GetCodeLen(cnt);
				Update(j + cnt, pre[j] + curCodeLen,ch,cnt);
				for (int curCodeLen2 = curCodeLen - 1; curCodeLen2 >= 0; curCodeLen2--)
				{//处理 行程妈缩短1,2...
					Update(j + MaxLen(curCodeLen2), pre[j] + curCodeLen2,ch, MaxLen(curCodeLen2));
				}
			}
			
			for (int j = 0; j <= lenArr; j++)
			{
				for (int m = 0; m <= j; m++)
				{
					const int curCodeLen = GetCodeLen(cnt+m );
					Update(j + cnt, pre2[j][m] - GetCodeLen(m) + GetCodeLen(m + cnt), ch, m + cnt);
					for (int curCodeLen2 = curCodeLen - 1; curCodeLen2 >= 0; curCodeLen2--)
					{//处理 行程妈缩短1,2...
						Update(j -m + MaxLen(curCodeLen2), pre2[j][m] - GetCodeLen(m) + curCodeLen2,ch, MaxLen(curCodeLen2));
					}
				}
			}
			pre.swap(dp);	
		}
		return *std::min_element(pre.begin() + pre.size() - k-1, pre.end());
	}
};

测试用例

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 s;
	int k;
	{
		Solution sln;
		s = "aaa", k = 2;
		auto res = sln.getLengthOfOptimalCompression(s, k);
		Assert(1, res);
	}
	{
		Solution sln;
		s = "aaab", k = 2;
		auto res = sln.getLengthOfOptimalCompression(s, k);
		Assert(2, res);
	}
	{
		Solution sln;
		s = "aaabcccd", k = 2;
		auto res = sln.getLengthOfOptimalCompression(s, k);
		Assert(4, res);
	}
	{
		Solution sln;
		s = "aabbaa", k = 2;
		auto res = sln.getLengthOfOptimalCompression(s, k);
		Assert(2, res);
	}
	{
		Solution sln;
		s = "aaaaaaaaaaa", k = 0;
		auto res = sln.getLengthOfOptimalCompression(s, k);
		Assert(3, res);
	}
	{
		Solution sln;
		s = "spnskpulpsiqagreoajsltdrdlnpsdqapmsdlnlirasgfijafeoqjnddpaifsqpghshclqummgootsmkcgneofrkboirkplqijoi", k = 25;
		auto res = sln.getLengthOfOptimalCompression(s, k);
		Assert(3, res);
	}
	
}

动态规划优化

前一个解法的空间复杂度在过与不过的边缘。

动态规划的状态表示

dp[i][j] 表示处理了arr[0,i)，选择了j个字符的最短行程码。

动态规划的转移方程

分两种情况： 和前面的项目合并，和前面的项不合并。细节同上。

动态规划的初始值

dp[0][0]=0，其它100。

动态规划的填表顺序

i从小到大，j从小到大。

动态规划的返回值

dp.back的后k+1个元素的最小值。

优化后的代码

class Solution {
public:
	int getLengthOfOptimalCompression(string s, int k) {
		const int lenArr = s.length();
		vector<pair<char, int>> arr;
		for (int left = 0, i = 0; i <= s.length(); i++)
		{
			if ((i >= s.length()) || (s[left] != s[i]))
			{
				arr.emplace_back(s[left], i - left);
				left = i;
			}
		}
		vector<int> vLen = { 0,1,2,10,100 };
		auto GetCodeLen = [&vLen](int len)
		{
			int i = vLen.size() - 1;
			for (; (i >= 0) && (len < vLen[i]); i--);
			return i;
		};
		auto MaxLen = [&vLen](int len)
		{
			return vLen[len + 1] - 1;
		};
		vector<vector<int>> dp(arr.size() + 1, vector<int>(lenArr + 1, 100));
		dp[0][0] = 0;
		int i = -1;
		for (const auto& [ch, cnt] : arr)
		{
			i++;
			auto& pre = dp[i];
			auto& cur = dp[i + 1];
			auto Update = [&lenArr, &cur](int j, int iCodeLen)
			{
				if (j > lenArr)
				{
					return;
				}
				cur[j] = min(cur[j], iCodeLen);
			};
			//处理没合并
			for (int j = 0; j <= lenArr; j++)
			{
				const int curCodeLen = GetCodeLen(cnt);
				Update(j + cnt, pre[j] + curCodeLen);
				for (int curCodeLen2 = curCodeLen - 1; curCodeLen2 >= 0; curCodeLen2--)
				{//处理 行程妈缩短1,2...
					Update(j + MaxLen(curCodeLen2), pre[j] + curCodeLen2);
				}
			}

			int cnt2 = 0;
			for (int m = i ; m >= 0; m--)
			{
				if (arr[m].first != ch)
				{
					continue;
				}
				cnt2 += arr[m].second;//合并后的字符数		
				const int curCodeLen = GetCodeLen(cnt2);
				for (int j = 0; j <= lenArr; j++)
				{
					Update(j + cnt2, dp[m][j] + curCodeLen);
					for (int curCodeLen2 = curCodeLen - 1; curCodeLen2 >= 0; curCodeLen2--)
					{//处理 行程妈缩短1,2...
						Update(j + MaxLen(curCodeLen2), dp[m][j] + curCodeLen2);
					}
				}
			}			
		}
		return *std::min_element(dp.back().begin() + dp.back().size() - k - 1, dp.back().end());
	}
};

动态规划三

arr数组，少许提升性能，但增加了复杂度，不采用。

动态规划的状态

dp[i][j]表示 从s[0,i)中删除j个字符 最短的行程码。

动态规划的转移方程

令x = dp[i+1][j]
情况一：删除s[i+1]
那x等于dp[i][j-1] 公式一
情况二：不删除，且可能和前面的字符结合后，删除。
不市一般性，令s[i]=‘a’，且它的前面只有三个’a’，小标分别为i1,i2,i3。
情况a：
s[i]没有和其它’a’结合，则x= dp[i][j]+GetCodeLen (1)。 公式二
情况b:
s[i]和s[i3]结合，s(i3,i)之间非’a’的数量为diff，全部删除。
b1: i和i3 都没删除。 x = dp[i3][j-diff] + GetCodeLen(2) → \rightarrow → dp[i-diff-1][j-diff] + GetCodeLen(2) 公式三
b2: i3删除。x = dp[i3][j-diff-1] + GetCodeLen(1) → \rightarrow → dp[i-diff-1][j-diff-1] + GetCodeLen(1) 就是公式二和公式一结合。
情况c:
s[i]和s[i2] s[i3]结合： s(i2,i)之间非’a’的数量为diff2，全部删除。
c1，不删除’a’。 dp[i2][j-diff2] + GetCodeLen(3) ** 公式四**
c2，删除一个’a’ dp[i2][j-diff2-1] + GetCodeLen(2) → \rightarrow → dp[i-diff2-2][j-diff2-1]+GetCodeLen(2) 就是公式三和公式的结合，不需要枚举。
c3 删除两个’a’。dp[i-diff2-2][j-diff2-2] + GetCodeLen(1) 就是公式二和公式一结合，不用枚举。
总结:
无论多少个字符结合，全删除就是公式一。
保留一个就是公式二。
保留三个就是公式三。
…
m个字符结合，只需要枚举m个字符,mm个字符(mm < m )枚举mm个字符结合的时候考虑。

可以这样理解：
m个字符合并后，删除m-mm个，保留mm个。 保留任意mm个都一样，那保留后mm个。所以只需要枚举：保留后mm个。

动态规划的初始值

dp[0][0] = 0，其它100。

动态规划的填表顺序

i从小到大。

动态规划的返回值

dp.back()的最小值。

代码

class Solution {
public:
	int getLengthOfOptimalCompression(string s, int k) {
		const int n = s.length();		
		vector<int> vLen = { 0,1,2,10,100 };
		auto GetCodeLen = [&vLen](int len)
		{
			int i = vLen.size() - 1;
			for (; (i >= 0) && (len < vLen[i]); i--);
			return i;
		};
		vector<vector<int>> dp(n + 1, vector<int>(k + 1, 100));
		dp[0][0] = 0;
		for (int i = 0; i < n; i++)
		{
			//处理删除s[i]
			for (int j1 = 1; j1 <= min(i+1,k); j1++)
			{
				dp[i+1][j1] = dp[i][j1-1];
			}
			//处理不删除s[i]
			for (int same = 0, diff = 0, preLen = i;preLen>=0; preLen--)
			{
				if (s[preLen] == s[i])
				{
					same++;
					for (int j1 = diff; j1 <= min(i + 1, k); j1++)
					{
						dp[i + 1][j1] = min(dp[i + 1][j1], dp[i + 1 - same - diff][j1 - diff] + GetCodeLen(same));
					}					
				}
				else
				{
					diff++;
				}
			}
		}		
		return *std::min_element(dp.back().begin() , dp.back().end());
	}
};

2023年2月 第一版

class Solution {
public:
int getLengthOfOptimalCompression(const string s, const int k) {
int pre[100 + 1][27][101];
memset(pre, 101, sizeof(pre));
pre[0][26][1] = 0;
for (const auto& ch : s)
{
int dp[100 + 1][27][101];
memset(dp, 101, sizeof(dp));
for (int iK = 0; iK <= k; iK++)
{
for (int j = 0; j < 27; j++)
{
for (int iNew = 0; iNew < 101; iNew++)
{
const int& iLen = pre[iK][j][iNew];
if (iLen > 100)
{
continue;
}
if (iK < k)
{//删除
dp[iK + 1][j][iNew] = min(dp[iK + 1][j][iNew], iLen);
}
if (j + ‘a’ != ch)
{
dp[iK][ch - ‘a’][1] = min(dp[iK][ch - ‘a’][1], iLen + 1);
}
else
{
const int iNewNum = min(100, iNew + 1);
dp[iK][ch - ‘a’][iNewNum] = min(dp[iK][ch - ‘a’][iNewNum], iLen + ((1 == iNew) || (9 == iNew) || (99 == iNew)));
}
}
}
}
memcpy(pre,dp, sizeof(pre));
}
int iMin = INT_MAX;
if (100 == s.length())
{
const char chMin = *std::min_element(s.begin(), s.end());
const char chMax = *std::max_element(s.begin(), s.end());
if (chMin == chMax)
{
iMin = 4;
}
}
for (int iK = 0; iK <= k; iK++)
{
for (int j = 0; j < 27; j++)
{
for (int iNew = 0; iNew < 101; iNew++)
{
if (pre[iK][j][iNew] < iMin)
{
iMin = pre[iK][j][iNew];
}
}
}
}
return iMin;
}
};

2023年2月 第二版

class Solution {
public:
int getLengthOfOptimalCompression(const string s, const int k) {
if (100 == s.length())
{
const char chMin = *std::min_element(s.begin(), s.end());
const char chMax = *std::max_element(s.begin(), s.end());
if (chMin == chMax)
{
const int iRemain = s.length() - k;
if (iRemain >= 100)
{
return 4;
}
if (iRemain >= 10)
{
return 3;
}
if (iRemain >= 2 )
{
return 2;
}
return iRemain;
}
}
int pre[100 + 1][27][11];
memset(pre, 101, sizeof(pre));
pre[0][26][1] = 0;
for (const auto& ch : s)
{
int dp[100 + 1][27][11];
memset(dp, 101, sizeof(dp));
for (int iK = 0; iK <= k; iK++)
{
for (int j = 0; j < 27; j++)
{
for (int iNew = 0; iNew < 11; iNew++)
{
const int& iLen = pre[iK][j][iNew];
if (iLen > 100)
{
continue;
}
if (iK < k)
{//删除
dp[iK + 1][j][iNew] = min(dp[iK + 1][j][iNew], iLen);
}
if (j + ‘a’ != ch)
{
dp[iK][ch - ‘a’][1] = min(dp[iK][ch - ‘a’][1], iLen + 1);
}
else
{
const int iNewNum = min(10, iNew + 1);
dp[iK][ch - ‘a’][iNewNum] = min(dp[iK][ch - ‘a’][iNewNum], iLen + ((1 == iNew) || (9 == iNew) || (99 == iNew)));
}
}
}
}
memcpy(pre, dp, sizeof(pre));
}
int iMin = INT_MAX;
for (int iK = 0; iK <= k; iK++)
{
for (int j = 0; j < 27; j++)
{
for (int iNew = 0; iNew < 11; iNew++)
{
if (pre[iK][j][iNew] < iMin)
{
iMin = pre[iK][j][iNew];
}
}
}
}
return iMin;
}
};

2023年2月版

class Solution {
public:
int getLengthOfOptimalCompression(const string s, const int k) {
if (100 == s.length())
{
const char chMin = *std::min_element(s.begin(), s.end());
const char chMax = *std::max_element(s.begin(), s.end());
if (chMin == chMax)
{
const int iRemain = s.length() - k;
if (iRemain >= 100)
{
return 4;
}
if (iRemain >= 10)
{
return 3;
}
if (iRemain >= 2 )
{
return 2;
}
return iRemain;
}
}
int pre[100 + 1][27][11];
memset(pre, 101, sizeof(pre));
pre[0][26][1] = 0;
for (const auto& ch : s)
{
int dp[100 + 1][27][11];
memset(dp, 101, sizeof(dp));
for (int iK = 0; iK <= k; iK++)
{
for (int j = 0; j < 27; j++)
{
for (int iNew = 1; iNew < 11; iNew++)
{
const int& iLen = pre[iK][j][iNew];
if (iLen > 100)
{
continue;
}
if (iK < k)
{//删除
dp[iK + 1][j][iNew] = min(dp[iK + 1][j][iNew], iLen);
}
if (j + ‘a’ != ch)
{
dp[iK][ch - ‘a’][1] = min(dp[iK][ch - ‘a’][1], iLen + 1);
}
else
{
const int iNewNum = min(10, iNew + 1);
dp[iK][ch - ‘a’][iNewNum] = min(dp[iK][ch - ‘a’][iNewNum], iLen + ((1 == iNew) || (9 == iNew) || (99 == iNew)));
}
}
}
}
memcpy(pre, dp, sizeof(pre));
}
int iMin = INT_MAX;
for (int iK = 0; iK <= k; iK++)
{
for (int j = 0; j < 27; j++)
{
for (int iNew = 1; iNew < 11; iNew++)
{
if (pre[iK][j][iNew] < iMin)
{
iMin = pre[iK][j][iNew];
}
}
}
}
return iMin;
}
};

扩展阅读

视频课程

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

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

相关文章

WordPress如何自定义日期和时间格式？附PHP日期和时间格式字符串

WordPress如何自定义日期和时间格式？附PHP日期和时间格式字符串

WordPress网站在很多地方都需要用到日期和时间&#xff0c;那么我们应该在哪里设置日期和时间呢&#xff1f;又如何自定义日期和时间格式呢&#xff1f;下面boke112百科就跟大家一起来学习一下PHP标准化的日期和时间格式字符串。 特别说明&#xff1a;格式字符是标准化的&#…
阅读更多...
Material Components for Android助你打造精美App

Material Components for Android助你打造精美App

Material Components for Android助你打造精美App 简介 Material Components for Android (MDC-Android) 是帮助开发者执行 Material Design 的工具。由谷歌的核心工程师和用户体验设计师团队开发&#xff0c;这些组件使得开发者可以可靠地开发工作流来构建美观且功能齐全的 …
阅读更多...
RT-DETR改进有效系列目录 | 包含卷积、主干、RepC3、注意力机制、Neck上百种创新机制

RT-DETR改进有效系列目录 | 包含卷积、主干、RepC3、注意力机制、Neck上百种创新机制

💡 RT-DETR改进有效系列目录 💡 前言 Hello，各位读者们好 Hello，各位读者，距离第一天发RT-DETR的博客已经过去了接近两个月，这段时间里我深入的研究了一下RT-DETR在ultralytics仓库的使用，旨在为大家解决为什么用v8的仓库训练的时候模型不收敛，精度差的离谱的问题，…
阅读更多...
sqli.labs靶场（8-17关）

sqli.labs靶场（8-17关）

8、第八关&#xff08;布尔盲注&#xff09; id1显示You are in...........&#xff0c;id1单引号不显示&#xff0c;id1 --显示正常 这个应该是单引号闭合&#xff0c;接下来就和第七关差不多上脚本 爆库名长度&#xff1a;id1%27%20and%20length(database()){i}%20-- 爆库…
阅读更多...
如何在 VM 虚拟机中安装 Red Hat Enterprise Linux 9.3 操作系统保姆级教程（附链接）

如何在 VM 虚拟机中安装 Red Hat Enterprise Linux 9.3 操作系统保姆级教程（附链接）

一、VMware Workstation 虚拟机 先得安装 VM 虚拟机&#xff0c;没有的可以参考这篇文章安装 VM 虚拟机 如何在 VM 虚拟机中安装 Win10 操作系统保姆级教程&#xff08;附链接&#xff09;https://eclecticism.blog.csdn.net/article/details/135713915 二、Red Hat Linux 镜…
阅读更多...
软考 系统分析师系列知识点之知识管理（2）

软考 系统分析师系列知识点之知识管理（2）

接前一篇文章&#xff1a;软考 系统分析师系列知识点之知识管理&#xff08;1&#xff09; 所属章节&#xff1a; 第7章. 企业信息化战略与实施 第7节. 企业信息系统 7.7.5 知识管理 相关试题 1. 知识管理是企业信息化过程中的重要环节&#xff0c;知识可以分为显性知识和隐性…
阅读更多...
计算机网络——IP协议

计算机网络——IP协议

前言 网络层的主要负责地址分配和路由选择,ip负责在网络中进行数据包的路由和传输。 IPv4报文组成&#xff08;了解&#xff09; IPv4首部&#xff1a;IPv4首部包含了用于路由和传输数据的控制信息&#xff0c;其长度为20个字节&#xff08;固定长度&#xff09;。 版本&#…
阅读更多...
leetcode26. 删除有序数组中的重复项

leetcode26. 删除有序数组中的重复项

题目 题目 给你一个 非严格递增排列 的数组 nums &#xff0c;请你 原地 删除重复出现的元素&#xff0c;使每个元素 只出现一次 &#xff0c;返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。 考虑 nums 的唯一元素的数量为 k &…
阅读更多...
前端——JavaScript

前端——JavaScript

目录 文章目录 前言 一. JavaScript基础 1.JavaScript基本结构 2. JavaScript 执行过程 3. JavaScript 引入方式 二. JavaScript 语法 1.数据类型 2.变量 2.1 var 关键字定义变量 2.2 let 关键字定义变量 2.3 var 与 let 的区别 3.字符串 3.1定义字符串 3.2 字…
阅读更多...
Python爬虫解析库安装

Python爬虫解析库安装

解析库的安装 抓取网页代码之后&#xff0c;下一步就是从网页中提取信息。提取信息的方式有多种多样&#xff0c;可以使用正则来提取&#xff0c;但是写起来相对比较烦琐。这里还有许多强大的解析库&#xff0c;如 lxml、Beautiful Soup、pyquery 等。此外&#xff0c;还提供了…
阅读更多...
除了Adobe之外，还有什么方法可以将Excel转为PDF？

除了Adobe之外，还有什么方法可以将Excel转为PDF？

前言 Java是一种广泛使用的编程语言&#xff0c;它在企业级应用开发中发挥着重要作用。而在实际的开发过程中&#xff0c;我们常常需要处理各种数据格式转换的需求。今天小编为大家介绍下如何使用葡萄城公司的的Java API 组件GrapeCity Documents for Excel&#xff08;以下简…
阅读更多...
数据结构（一）------顺序表

数据结构（一）------顺序表

文章目录 前言一、什么是顺序表二、实现顺序表1.静态顺序表2.动态顺序表总结 前言 制作不易&#xff01;三连支持一下呗&#xff01;&#xff01;&#xff01; 从今天起我们将会进入数据结构的学习&#xff01; 我们先来了解 什么是数据结构 数据结构是计算机存储、组织数…
阅读更多...
2023年算法OOA-CNN-BiLSTM-ATTENTION回归预测（matlab）

2023年算法OOA-CNN-BiLSTM-ATTENTION回归预测（matlab）

OOA-CNN-BiLSTM-Attention鲸鱼算法优化卷积-长短期记忆神经网络结合注意力机制的数据回归预测 Matlab语言。 鱼鹰优化算法&#xff08;Osprey optimization algorithm&#xff0c;OOA&#xff09;由Mohammad Dehghani 和 Pavel Trojovsk于2023年提出&#xff0c;其模拟鱼鹰的捕…
阅读更多...
go语言函数进阶

go语言函数进阶

1.变量作用域 全局变量 全局变量是定义在函数外部的变量&#xff0c;它在程序整个运行周期内都有效。 在函数中可以访问到全局变量。 package mainimport "fmt"//定义全局变量num var num int64 10func testGlobalVar() {fmt.Printf("num%d\n", num) /…
阅读更多...
汽车网络安全dos, someip

汽车网络安全dos, someip

汽车Cyber Security入门之DoS 攻防 - 知乎 3、SOME/IP-TP 近年来火热地谈论下一代EE架构和SOA的时候&#xff0c;总离不开SOME/IP这个进程间通讯协议。在许多应用场景中&#xff0c;需要通过UDP传输大型的SOME/IP有效载荷。鉴于在以太网上传输数据包的大小限制&#xff0c;SO…
阅读更多...
多维时序 | Matlab实现DBO-BiLSTM蜣螂算法优化双向长短期记忆神经网络多变量时间序列预测

多维时序 | Matlab实现DBO-BiLSTM蜣螂算法优化双向长短期记忆神经网络多变量时间序列预测

多维时序 | Matlab实现DBO-BiLSTM蜣螂算法优化双向长短期记忆神经网络多变量时间序列预测 目录 多维时序 | Matlab实现DBO-BiLSTM蜣螂算法优化双向长短期记忆神经网络多变量时间序列预测效果一览基本介绍程序设计参考资料 效果一览 基本介绍 1.Matlab实现DBO-BiLSTM多变量时间序…
阅读更多...
Matlab|【完全复现】基于价值认同的需求侧电能共享分布式交易策略

Matlab|【完全复现】基于价值认同的需求侧电能共享分布式交易策略

目录 1 主要内容 2 部分程序 3 程序结果 4 下载链接 1 主要内容 该程序完全复现《基于价值认同的需求侧电能共享分布式交易策略》&#xff0c;针对电能共享市场的交易机制进行研究&#xff0c;提出了基于价值认同的需求侧电能共享分布式交易策略&#xff0c;旨在降低电力市…
阅读更多...
面经基础版案例(路由，请求渲染，传参，组件缓存)

面经基础版案例(路由，请求渲染，传参，组件缓存)

文章目录 1.案例效果分析2.配置一级路由&#xff08;首页&#xff0c;详情&#xff09;3.配置二级路由4.导航高亮效果5.首页的请求渲染6.传参&#xff08;查询参数 $ 动态路由&#xff09;7.详情页渲染8.组件缓存kepp-alive9.总结 1.案例效果分析 2.配置一级路由&#xff08;首…
阅读更多...
实战 | OpenCV+OCR实现弧形文字识别实例(详细步骤 + 源码)

实战 | OpenCV+OCR实现弧形文字识别实例(详细步骤 + 源码)

导 读 本文主要介绍基于OpenCV+OCR实现弧形文字识别实例，并给详细步骤和代码。源码在文末。 背景介绍 测试图如下，目标是正确识别图中的字符。图片来源： https://www.51halcon.com/forum.php?mod=viewthread&tid=6712 同样，论坛中已经给出了Halcon实现代码，…
阅读更多...
web应用课——（第二讲：CSS）

web应用课——（第二讲：CSS）

目录 一、实战项目一&#xff1a;Acwing名片 二、实战项目二&#xff1a;Bilibili名片 三、样式定义方式 四、选择器 五、颜色 六、文本 七、字体 八、背景 九、边框 十、元素展示格式 十一、内边距与外边距 十二、盒子模型 十三、位置 十四、浮动 十五、flex布…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023