蓝桥杯：C++贪心算法、字符串函数、朴素模式匹配算法、KMP算法

最新推荐文章于 2024-05-02 20:41:48 发布

DaveVV

最新推荐文章于 2024-05-02 20:41:48 发布

阅读量1.6k

点赞数 43

分类专栏：蓝桥杯c++ 文章标签：蓝桥杯 c++ 贪心算法算法开发语言数据结构 c语言

本文链接：https://blog.csdn.net/m0_74098386/article/details/136156844

版权

蓝桥杯c++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

贪心算法

贪心(Greedy)算法的原理很容易理解：把整个问题分解成多个步骤，在每个步骤都选取当前步骤的最优方案，直到所有步骤结束；每个步骤都不考虑对后续步骤的影响，在后续步骤中也不再回头改变前面的选择。

贪心算法虽然简单，但它有广泛的应用。例如图论中的最小生成树(Minimal Spanning Tree，MST)算法、单源最短路径算法(Dijkstra)都是贪心算法的典型应用。

贪心算法的主要问题是不一定能得到最优解，因为局部最优并不总是能导致全局最优，而竞赛题基本都是求全局最优解的。

一个问题是否能用贪心算法求解，有时很容易判断，有时不那么容易判断。例如常见的最少硬币支付问题，能否用贪心算法求解取决于硬币的面值。

最少硬币支付问题：

假设有3种面值的硬币，分别是1元、2元、5元，数量不限；需要支付M元，问怎么支付，才能使硬币数量最少？

用贪心算法求解，第一步先用面值最大的5元硬币，第二步用面值第二大的2元硬币，最后用面值最小的1元硬币。在这个解决方案中，硬币数量总数是最少的，使用贪心算法得到的结果是全局最优的。但是如果是其他面值的硬币，则使用贪心算法就不一定能得到全局最优解。

例如，假设硬币面值有5种，分别是1元、2元、4元、5元、6元。要支付M = 9元，如果用贪心算法，则答案是6 + 2 + 1，需要3个硬币，而全局最优解是5 + 4，只需要两个硬币。

DP不是本文的讲解范围，这里只是拓展一下解题技巧。

贪心算法没有固定的算法框架，关键是如何选择贪心策略。贪心策略必须具备无后效性，即某个状态以后的过程不会影响以前的状态，只与当前状态有关。贪心题是蓝桥杯大赛的常见题型。有的贪心题考验参赛人员的思维能力，有的贪心题结合了其他算法，贪心题可能很难。下面通过一些例题介绍一下贪心算法的应用。

例题1.翻硬币

先分析翻动的具体操作。

(1)只有一个硬币不同。例如位置a的硬币不同，那么翻动它时，会改变与它相邻的硬币b，现在变成了硬币b不同，回到了“只有一个硬币不同”的情况。也就是说，如果只有一个硬币不同，无法求解。

(2)有两个硬币不同。这两个硬币位于任意两个位置，从左边的不同硬币开始翻动，一直翻动到右边的不同硬币，结束。

(3)有3个硬币不同。左边两个不同硬币，可以用操作(2)完成翻动；但是最后一个硬币需要使用操作(1)，无法完成。

总结这些操作，得到以下结论。

(1)有解的条件。初始字符串s和目标字符串t必定有偶数个字符不同。

(2)贪心操作。从头开始遍历字符串，遇到不同的字符就翻动，直到最后一个字符。下面证明这个贪心操作是局部最优也是全局最优。

代码：

#include<bits/stdc++.h>
using namespace std;
int main() {
	string s,t;
	cin >> s >> t;
	int ans=0;
	for(int i=0; i<s.length(); i++)
		if(s[i] != t[i]) {
			// s[i]   = (s[i]  =='*'? 'o': '*');      //多余，我们求的是最小操作步数
			s[i+1] = (s[i+1]== '*'? 'o': '*');      //翻下一个就行了
			ans++;
		}
	cout << ans;
}

字符串函数

求解字符串的题目，最好使用系统提供的库函数。本节将介绍C++常用的字符串函数：

代码（讲解在注释中）：

#include<bits/stdc++.h>
using namespace std;
int main() {
	string str ="123456789abcdefghiaklmn";
	for(int i=0; i<10; i++)   cout<<str[i]<< " ";       //把str看成一个字符串数组
	cout << endl;
	//find()函数
	cout<<"123的位置:"<<str.find("123")<<endl;     //输出：123的位置:   0
	cout<<"34在str[2]到str[n-1]中的位置:"<<str.find("34",2)<<endl;	//输出：34在str[2]到str[n-1]中的位置:   2
	cout<<"ab在str[0]到str[12]中的位置:"<<str.rfind("ab",12)<<endl;
	//输出：ab在str[0]到str[12]中的位置:    9
	//substr()函数
	cout<<"str[3]及以后的子串:"<<str.substr(3)<<endl;
	//输出：str[3]及以后的子串:456789abcdefghiaklmn
	cout<<"从str[2]开始的4个字符:"<<str.substr(2,4)<<endl;      //若小于限制长度，则报错
	//输出：从str[2]开始的4个字符:3456
	//find()函数
	str.replace(str.find("a"), 5, "@#"); //用str替换指定字符串从起始位置pos开始长度为len的字符 string& replace (size_t pos, size_t len, const string& str); 
	cout<<str<<endl;           //输出：123456789@#fghiaklmn
	//insert()函数
	str.insert(2, "***");
	cout<<"从2号位置插入: "<<str<<endl;    //输出：从2号位置插入：12***3456789@#fghiaklmn
	//添加字符串：append()函数
	str.append("$$$");
	cout<<"在字符串str后面添加字符串: "<<str<<endl;     //输出：在字符串str后面添加字符串：12***3456789@#fghiaklmn$$$
	//求字符串长度
	cout<<str.size()<<endl;//26
	cout<<str.length()<<endl;//26
	//交换字符串：swap()函数
	string str1="aaa",str2="bbb";
	swap(str1, str2);
	cout<<str1<< " " <<str2<<endl;//bbb aaa
	//字符串比较：compare()函数，若相等，则输出0；若不等，则输出1
	cout<<str1.compare(str2)<<endl;  //1
	if(str1==str2) cout <<"==";      //直接比较也行
	if(str1!=str2) cout <<"!=";      //!=
	return 0;
}

例题1.标题统计

分析：用string定义变量，一个一个地读入字符串，字符串之间是用空格分开的。

代码：

#include<bits/stdc++.h>
using namespace std;
int main() {
	string s;
	int ans=0;
	while(cin >> s)   ans += s.size();   
	cout << ans;
	return 0;
}

朴素模式匹配算法

模式匹配(Pattern Matching)问题：在一篇长度为n的文本S中，查找某个长度为m的关键词P，称S为母串，P为模式串。

P可能出现多次，都需要找到。例如在S = abcxyz123bqrst12dg123gdsa中查找P=123，P出现了两次。

最优的模式匹配算法复杂度是什么？由于至少需要检索文本S的n个字符和关键词P的m个字符，所以复杂度至少是O(m + n)。

最简单的是朴素模式匹配算法，这是一种暴力法，从S的第1个字符开始，逐个匹配P的每个字符，如果发现不同，就从S的下一个字符重新开始匹配。

例如S =abcxyz123，P = 123。第1轮匹配：比较S[0]～S[2]= abc和P[0]～P[2]= 123。发现第1个字符就不同，即P[0]≠S[0]，这种情况称为“失配”，后面的P[1]、P[2]就不用比较了，如图9.1所示。

第2轮匹配：S往后移一个字符，比较S[1]～S[3]= bcx和P[0]～P[2]=123。发现P的第1个字符与S的第2个字符不同，即P[0]≠S[1]，后面的P[1]、P[2]就不用比较了，如图9.2所示。

继续匹配，直到第7轮匹配，终于在S中完全匹配了一个P，如图9.3所示。

一共比较了6 + 3 = 9次：前6轮每次只比较了P的第1个字符，第7轮比较了P的3个字符。

这个例子比较特殊，因为P和S的字符基本都不一样。在每轮匹配时，往往第1个字符就不同，用不着继续匹配P后面的字符。计算复杂度差不多是O(n)，这已经是字符串匹配能达到的最优复杂度了。所以，如果字符串S、P符合这样的特征，暴力法是很好的选择。

但是如果情况很“恶劣”，例如P的前m−1个都容易找到匹配，只有最后一个不匹配，那么复杂度就退化成O(nm)。例如S =aaaaaaaab，P =aab。

第1轮匹配：比较S[0]～S[2]=aaa和P[0]～P[2]=aab，前两个字符相同，第3个字符不同，即S[2]≠P[2]，共比较了3次。i是指向S的指针，j是指向P的指针，在i=2、j=2处失配，如图9.4所示。

第2轮匹配：让i回溯到1，j回溯到0，重新开始比较S[1]～S[3]= aaa和P[0]～P[2]=aab，如图9.5所示。发现S[3]≠P[2]，共比较了3次，在i=3、j=2处失配。

……

第7轮匹配：在S中完全匹配了一个P，如图9.6所示。

这7轮匹配共比较7×3 = 21次，远远超过上面例子中的9次。有没有更好的方法？后面介绍的KMP算法是在任何情况下都稳定、高效的算法。

这里先把朴素模式匹配算法的代码放在这参考：

int ViolentMatch(string text, string pattern)		//text是文本串,pattern是关键字
{
	int tLen = text.size();      //获取长度 
	int pLen = pattern.size();
 
	int i = 0;
	int j = 0;
	while (i < tLen && j < pLen)    //开始匹配 
	{
		if (text[i] == pattern[j])
		{
			//如果当前字符匹配成功（即text[i] == pattern[j]）,匹配下一个字符
			i++;
			j++;
		}
		else					//如果当前字符匹配失败,pattern从头开始匹配
		{
			i = i - j + 1;
			j = 0;
		}
	}
	
	if (j == pLen)				//当pattern全部匹配成功,返回匹配位置
		return i - j;         
	else
		return -1;
}

KMP算法

对于模式匹配，目前所学的最简单的是BF算法，即偏向于“暴力”匹配的方法。另外一种就是较为复杂KMP算法了。而俩者的区别在于：BF算法是时间复杂度相对高的，KMP则可以理解为用空间换时间。

KMP算法： KMP只需要将j值模式串中j的位置回溯到next[j]位，而免除了前面不需要的匹配，以此来换取时间。
相比一个一个比较，而KMP则在此基础上更加的简便了。

现在一步一步模拟一下KMP匹配的过程：

现在要在text中找temp：

string text = "ABAABAABBABAAABAABBABAAB";
string temp = "ABAABBABAAB";

next[] = {0,0,1,1,2,0,1,2,3,4,5} //next数组已经给出

再给你一个公式：
移动位数 = 已匹配值 - 部分匹配值

（说人话：移动位数 = 已匹配值 - 最大公共元素长度） ---在匹配的过程中就会明白该怎么移动

1.第一步匹配与暴力没有区别，找到第一个都是A的点开始匹配：

可以看到，我们匹配到第6位的时候，匹配失败了，我们直接中断本次匹配
然后移动已匹配值 - 最大公共元素长度
我们匹配了5位，对应的next[5]=2,那么我们就应该移动 5 - 2 =3位。

很好，我们现在又可以进行匹配了，匹配到第11位时，又匹配失败了，我们同样中断本次匹配并进行移动操作。如图：

继续套公式，我们需要移动已匹配值 - 最大公共元素长度
我们匹配了10位，对应的next[10] = 4，那么我们移动10-4=6位。

如法炮制，我们继续进行匹配，匹配到第5位的时候又出错了，继续进行处理，移动已匹配值 - 最大公共元素长度
我们匹配了4位，对应next[4] = 1，我们需要移动4 - 1 = 3 位。如图：

这次只匹配到了1位，移动已匹配值 - 最大公共元素长度，这次匹配了1位，对应next[1] = 0，我们要移动 1 - 0 = 1 位。

总结：在kmp算法中最重要的部分就是next[] 数组。它存放的是我们当前位置下的最大公共元素长度。

以待匹配文本"ABCDABD"来举例：

前缀后缀就是：把字符串的子串分解出来，从前到后（前缀），从后到前（后缀）的一个排列
！注意：（前缀得不到最后一位，后缀得不到最前一位）。

然后我们找出前缀和后缀中相同的子排列，将它们的长度保存到字符串子串的长度下的下标中去。

下面是实现代码：

#include <bits/stdc++.h>
using namespace std;

//在关键字中记录与前缀匹配的组合,记录在next数组
void make_next(string pattern, int *next)
{
    int q, k;               //q是匹配的位置         k是记录前缀开始的地方
    int m = pattern.size(); //关键字的长度

    next[0] = 0;
    for (q = 1, k = 0; q < m; q++)
    { 
        while (k > 0 && pattern[q] != pattern[k])
        { 
            k = next[k - 1];
        }

        if (pattern[q] == pattern[k])
        {
            k++;
        }
        next[q] = k; //用于记录关键字中与前缀匹配的组合的位置
    }
}

//kmp算法
int kmp(string text, string pattern, int *next)
{
    int n = text.size();    //文本串的长度
    int m = pattern.size(); //关键字的长度

    make_next(pattern, next); //在关键字中记录与前缀匹配的组合,记录在next数组

    int i, q;
    for (i = 0, q = 0; i < n; i++)
    { //i --> text, q --> pattern
        while (q > 0 && pattern[q] != text[i])
        {                    
            q = next[q - 1]; 
        }                    

        if (pattern[q] == text[i])
        { 
            q++;
        }

        if (q == m)
        {                     
            return i - q + 1; 
        }
    }
    return -1; //整个文本串找完都没有找到字符串,返回-1
}

int main()
{
    string text = "ABAABAABBABAAABAABBABAAB";
    string temp = "ABAABBABAAB";
    int len = temp.size();
    int arr[len+1];
    make_next(temp, arr);
    
    cout << kmp(text, temp, arr);//13

    return 0;
}

DaveVV

关注

43
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
蓝桥杯：C++贪心算法、字符串函数、朴素模式匹配算法、KMP算法

发现第1个字符就不同，即P[0]≠S[0]，这种情况称为“失配”，后面的P[1]、P[2]就不用比较了，如图9.1所示。第1轮匹配：比较S[0]～S[2]=aaa和P[0]～P[2]=aab，前两个字符相同，第3个字符不同，即S[2]≠P[2]，共比较了3次。发现P的第1个字符与S的第2个字符不同，即P[0]≠S[1]，后面的P[1]、P[2]就不用比较了，如图9.2所示。最简单的是朴素模式匹配算法，这是一种暴力法，从S的第1个字符开始，逐个匹配P的每个字符，如果发现不同，就从S的下一个字符重新开始匹配。
复制链接

扫一扫