字符串的包含

题目描述

给定一长字符串 a 和一短字符串 b ，请问如何最快地判断出短字符串 b 的所有字符是否都在长字符串 a 中？

分析与解法

解法一：蛮力轮询

判断短字符串 b 中的字符是否都在长字符串 a 中，最直观最简单的思路就是：轮询短字符串 b 中的每个字符，依次与长字符串 a 中的每个字符进行比较。

代码

#include <iostream>
#include <string>

using namespace std;

bool StringContain(string &a, string &b)
{   
    for (int i = 0; i < b.length(); i++)
    {
        int j;
        for (j = 0; (j < a.length()) && (a[j] != b[i]); j++);
        if (j >= a.length())
        {
            return false;
        }
    } 
    return true;
}

int main()
{
    string a = "ABb19";
    string b = "Ab19";
    if (StringContain(a,b))
        cout << a << "包含" << b; 
    else 
        cout << a << "不包含" << b; 
    return 0;
} 

分析

如果 n 是长字符串 a 的长度，m 是短字符串 b 的长度，那么算法需要 O(mn) 次比较。因此如果 m 和 n 很大时，时间开销太大。

解法二：排序后轮询

可先对两个字符串进行排序，然后在对两个字符串依次轮询。

代码

#include <iostream>
#include <string>

using namespace std;

bool StringContainSort(string &a, string &b)
{
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    for (int pa = 0, pb = 0; pb < b.length();)
    {
        while ((pa < a.length()) && (a[pa] < b[pb]))
        {
            pa++; 
        }
        if ((pa >= a.length()) || (a[pa] > b[pb]))
        {
            return false;
        } 
        pb++;
    }
    return true;
}

int main()
{
    string a = "ABb19";
    string b = "Ab19";
    if (StringContainSort(a,b))
        cout << a << "包含" << b; 
    else 
        cout << a << "不包含" << b; 
    return 0;
} 

分析

常规情况下，两个字符串的快速排序需要 O(mlogm)+O(nlogn) 此操作，之后的线性扫描需要 O(m+n) 此操作。

解法三：素数相乘

1. 按照从小到大的顺序，用 26 个素数分别代替长字符串 a 中的所有字母。
2. 遍历长字符串 a ，求得 a 中所有字母对应的素数的乘积。
3. 遍历短字符串 b ，判断第二步得到的乘积是否能被 b 中字母对应的素数整除。

代码

#include <iostream>
#include <string>

using namespace std;

bool StringContainPrime(string &a, string &b)
{
    const int table[26] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
                            47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101 };
    int sum = 1;
    for (int i = 0; i < a.length(); ++i) 
    { 
        int temp = table[a[i] - 'A'];
        if (sum % temp)
        {
            sum *= temp;
        }
    }
    for (int i = 0; i < b.length(); ++i)
    {
        int temp = table[b[i] - 'A'];
        if (sum % temp)
        {
            return false;
        }
    }
    return true;
}

int main()
{
    string a = "AB";
    string b = "A";
    if (StringContainPrime(a,b))
        cout << a << "包含" << b; 
    else 
        cout << a << "不包含" << b; 
    return 0;
} 

注：仅供拓展思路，且仅适用于全部为大写字母。素数相乘结果会逐渐增大导致整数溢出（前 16 个字母对应的素数相乘就会超出 long long 类型所能表示的最大整数范围）。

分析

一般情况下，算法的时间复杂度为 O(m+n)，最好情况下的时间复杂度为 O(n)，即再遍历短字符串 b 的第一个字母时，与素数乘积相除就出现余数。

解法四：位运算法

事实上，可以先把长字符串 a 中的所有字符放入一个散列表（hash table）中，然后轮询短字符串 b ，查看 b 中的每个字符是否都在散列表中。

根据这种方法可以使用过一个整数替代散列表。

1. 用位运算为长字符串a计算出一个签名。
2. 依次将短字符串b中的字符放到a中进行查找。

代码

#include <iostream>
#include <string>

using namespace std;

bool StringContainBit(string &a, string &b)
{
    long long hash = 0;
    long long move = 1;
    for (int i = 0; i < a.length(); ++i)
    {
        hash |= (move << (a[i] - 'A'));
    }
    for (int i = 0; i < b.length(); ++i)
    {
        if ((hash & (move << (b[i] - 'A'))) == 0)
        {
            return false;
        }
    }
    return true;
}

int main()
{
    string a = "ABb19";
    string b = "Ab19";
    if (StringContainBit(a,b))
        cout << a << "包含" << b; 
    else 
        cout << a << "不包含" << b; 
    return 0;
}

注：hash 和 move 变量使用 long long 类型。移位操作是根据 move 变量的类型进行判断，若用 int 类型，’a’-‘A’=32，左移 32 位超出 int 范围会出错，hash 变量同理。

拓展知识——位运算

1. 按位与——&：清零特定位，或取某数中指定位 。
2. 按位或——|：常用来将源操作数某些位置1，其它位不变。

分析

算法的空间复杂度为 O(1) ，时间复杂度为 O(n+m) ，这样算是比较完美的解决了这个字符串包含的问题，但溢出问题仍需考虑，如需支持全字符可能还要考虑牺牲一些空间，使用散列表法。

声明：本文为July的《编程之法》的学习笔记。

参考博客

字符串包含：http://blog.csdn.net/beggar200/article/details/50215035

位运算：http://blog.csdn.net/y990041769/article/details/12977271