【动态规划】C++算法:44 通配符匹配

作者推荐

【动态规划】【字符串】扰乱字符串

本文涉及的基础知识点

动态规划

LeetCode44 通配符匹配

给你一个输入字符串 (s) 和一个字符模式 § ,请你实现一个支持 '?' 和 '' 匹配规则的通配符匹配:
'?' 可以匹配任何单个字符。
'
' 可以匹配任意字符序列(包括空字符序列)。

判定匹配成功的充要条件是:字符模式必须能够 完全匹配 输入字符串(而不是部分匹配)。

示例 1:

输入:s = "aa", p = "a"

输出:false

解释:"a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:s = "aa", p = ""
输出:true
解释:'
' 可以匹配任意字符串。

示例 3:

输入:s = "cb", p = "?a"

输出:false

解释:'?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
参数范围

0 <= s.length, p.length <= 2000

s 仅由小写英文字母组成

p 仅由小写英文字母、'?' 或 '*' 组成

动态规划

共有mn种状态,故空间复杂度是O(nm),每种状态的转移时间复杂度是O(1),故时间复杂度是O(nm)。m和n是p和s的长度。

动态规划的状态表示 dp[i][j]等于p[0,i)和s[0,j)是否匹配
动态规划的转移方程 下文详细列出
动态规划的初始状态 除dp[0][0]=true外,全部false
动态规划的填表顺序 一,如果p[0,j)全部是*,则dp[j][0]=true。二, i,j全部从小到大。由短到长处理子字符串,确保动态规划的无后效性
动态规划的返回值 dp[m][n]

转移方程

p[i-1]为*: a,不匹配任字符。b,匹配1到多个字符。匹配2个字符和匹配1个字符完全相同。

为? : 和dp[i-1][j-1]相同。

其它字符: p[i-1]==s[j-1] 且 dp[i-1][j-1]

代码

核心代码

cpp 复制代码
class Solution {
public:
	bool isMatch(string s, string p) {
		const int m = p.length();
		const int n = s.length();
		vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
		dp[0][0] = true;
		for (int i = 0; (i < m)&&('*'==p[i]); i++)
		{
			dp[i + 1][0] = true;//p前面的*不匹配任何字符
		}
		for (int i = 1; i <= m; i++)
		{
			const char& ch = p[i - 1];
			for (int j = 1; j <= n; j++)
			{
				if ('*' == ch)
				{
					const bool b1 = dp[i - 1][j];//*不匹配任何字符
					const bool b2 = dp[i][j - 1];//*匹配字符1到x个字符
					dp[i][j] = b1 || b2;
				}
				else if ('?' == ch)
				{
					dp[i][j] =  dp[i - 1][j - 1];
				}
				else
				{
					dp[i][j] = dp[i - 1][j - 1]&&(ch == s[j-1]);
				}
			}
		}
		return dp.back().back();
	}
};

测试用例

cpp 复制代码
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,p;	
	{
		Solution sln;
		s = "ab", p = "?*";
		auto res = sln.isMatch(s, p);
		Assert(true, res);
	}
	{
		Solution sln;
		s = "aa", p = "a";
		auto res = sln.isMatch(s, p);
		Assert(false, res);
	}
	
	{
		Solution sln;
		s = "aa", p = "*";
		auto res = sln.isMatch(s, p);
		Assert(true, res);
	}

	{
		Solution sln;
		s = "cb", p = "?a";
		auto res = sln.isMatch(s, p);
		Assert(false, res);
	}

}

2022 年12月

class Solution {

public:

bool isMatch(string s, string p) {

unordered_set preDp;

preDp.insert(0);

for (const auto& ch : p )

{

unordered_set dp;

if ('*' == ch)

{

int iMin = *std::min_element(preDp.begin(), preDp.end());

for (; iMin <= s.length(); iMin++)

{

dp.insert(iMin);

}

}

else

{

for (const auto& pre : preDp)

{

if (pre < s.length())

{

if (('?' == ch) || (ch == s[pre]))

{

dp.insert(pre + 1);

}

}

}

}

preDp.swap(dp);

if (preDp.empty())

{

return false;

}

}

return *std::max_element(preDp.begin(),preDp.end()) >= s.length();

}

};

23年8月

class Solution {

public:

bool isMatch(string s, string p) {

if (p.empty())

{

return s.empty();

}

vector vp;

int left = 0;

for (int i = 0; i < p.length()😉

{

while ((i < p.length()) && ('' != p[i]))
{
i++;
}
//p[i]为'\0'或

vp.emplace_back(p.substr(left, i - left));

while ((i < p.length()) && ('' == p[i]))
{
i++;
}
left = i;
}
if ('
' == p.back())

{

vp.emplace_back("");

}

if (1 == vp.size())

{

return (s.length()p.length())&& (0Cmp(s,p));

}

const int iFirstLen = vp.front().length();

if (s.length() < iFirstLen)

{

return false;

}

if (0 != Cmp( s, vp.front()))

{

return false;

}

s = s.substr(iFirstLen);

vp.erase(vp.begin(), vp.begin()+1);

const int iRemain = s.length() - vp.back().length();

if (iRemain < 0)

{

return false;

}

if (0 != Cmp(s.substr(iRemain), vp.back()))

{

return false;

}

s = s.substr(0, iRemain);

vp.pop_back();

for (const auto& subP : vp)

{

const int ind = Cmp(s, subP);

if (-1 == ind)

{

return false;

}

s = s.substr(ind + subP.length());

}

return true;

}

int Cmp( const string& s , const string& strP)

{

int len = strP.length();

for (int i = 0; i+len <= s.length(); i++)

{

if (CmpInner(s, i, strP))

{

return i;

}

}

return -1;

}

bool CmpInner(const string& s,int si, const string& strP)

{

int len = strP.length();

for (int i = 0; i < len; i++)

{

if ((s[i+si] != strP[i]) && ('?' != strP[i]))

{

return false;

}

}

return true;

}

};

扩展阅读

视频课程

有效学习:明确的目标 及时的反馈 拉伸区(难度合适),可以先学简单的课程,请移步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++**实现。

相关推荐
JingHongB6 分钟前
代码随想录算法训练营Day55 | 图论理论基础、深度优先搜索理论基础、卡玛网 98.所有可达路径、797. 所有可能的路径、广度优先搜索理论基础
算法·深度优先·图论
weixin_432702269 分钟前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
小冉在学习12 分钟前
day52 图论章节刷题Part04(110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长 )
算法·深度优先·图论
Repeat71512 分钟前
图论基础--孤岛系列
算法·深度优先·广度优先·图论基础
小冉在学习15 分钟前
day53 图论章节刷题Part05(并查集理论基础、寻找存在的路径)
java·算法·图论
武子康27 分钟前
大数据-212 数据挖掘 机器学习理论 - 无监督学习算法 KMeans 基本原理 簇内误差平方和
大数据·人工智能·学习·算法·机器学习·数据挖掘
passer__jw7671 小时前
【LeetCode】【算法】283. 移动零
数据结构·算法·leetcode
Ocean☾1 小时前
前端基础-html-注册界面
前端·算法·html
顶呱呱程序1 小时前
2-143 基于matlab-GUI的脉冲响应不变法实现音频滤波功能
算法·matlab·音视频·matlab-gui·音频滤波·脉冲响应不变法
爱吃生蚝的于勒2 小时前
深入学习指针(5)!!!!!!!!!!!!!!!
c语言·开发语言·数据结构·学习·计算机网络·算法