字符串的包含

题目描述

 给定一个字符串a和一短字符串b，只包含小写字母，判断b中元素是否都在a中？

• a是”abcd”，b是”bad”，答案是true
• a是”abcd”，b是”bce”，答案是false
• a是”abcd”，b是”aa”，答案是true

解法一：蛮力轮询

 轮询字符串b中每个字符，逐一与a中字符比较。

时间复杂度：O(nm)； 空间复杂度：O(1)

C++代码：

bool stringContain_1(string &a, string &b)
{
    // b string is not empty by default
    for (int i = 0; i < b.length(); ++i) {
        int j;
        for (j = 0; j < a.length(); ++j) {
            if (b[i] == a[j]) {     // if exist, check next character in b string
                break;
            }
        }
        if (j == a.length()) {      // current character doesn't exist in string a
            return false;
        }
    }
    return true;
}

解法二：排序后轮询

 分别对字符串a、b进行排序，排序后全部轮询b结束后只需要遍历字符串a一次。

时间复杂度：排序分别为O(nlog(n)), O(Nlog(n)), 所有比较过程O(m+n)

C++代码：

bool stringContain_2(string &a, string &b)
{
    // sort string a and string b alphabetically
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    int i = 0, j = 0;
    while (j < b.length()) {                        // for every character in string b
        while (i < a.length() && a[i] != b[j]) {    // find the identical character in string a
            ++i;
        }
        if (i == a.length()) {          // not find
            return false;
        }
        ++j;
    }
    return true;
}

解法三：素数相乘

 将字符串a中所有不同的字母用不同的素数标记，计算a中所有不同字符对应素数的乘积prod；
 遍历b中每个字符，字符对应素数能整除prod则表示该字符存在于a中；

时间复杂度：O(m+n)

C++代码：

bool stringContain_3(string &a, string &b)
{
    // the first 26 prime number
    const vector<int> prime{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};
    long long prod = 1;
    for (int i = 0; i < a.length(); ++i) {
        if (prod % prime[a[i] - 'a'] != 0) {        // filter the same character
            prod *= prime[a[i] - 'a'];
        }
    }
    for (int i = 0; i < b.length(); ++i) {
        if (prod % prime[b[i] - 'a'] != 0) {
            return false;
        }
    }
    return true;
}

局限性：16个字母对应的素数相乘就超过long long类型的最大范围，只能处理小字符串

解法四：散列表

建立一个标记字符是否存在于a中的散列表，轮询b字符串，在O(1)时间内判断字符是否存在

时间复杂度：O(m+n)； 空间复杂度O(1)

C++代码：

bool stringContain_4(string &a, string &b)
{
    vector<bool> exist(26, false);
    for (int i = 0; i < a.length(); ++i) {  // bookkeep the information of if a character in the string a
        exist[a[i] - 'a'] = 1;
    }
    for (int i = 0; i < b.length(); ++i) {  // check every character in string b
        if (!exist[b[i] - 'a']) {
            return false;
        }
    }
    return true;
}

完整测试代码

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
bool stringContain_1(string &a, string &b)
{
    // b string is not empty by default
    for (int i = 0; i < b.length(); ++i) {
        int j;
        for (j = 0; j < a.length(); ++j) {
            if (b[i] == a[j]) {     // if exist, check next character in b string
                break;
            }
        }
        if (j == a.length()) {      // current character doesn't exist in string a
            return false;
        }
    }
    return true;
}
bool stringContain_2(string &a, string &b)
{
    // sort string a and string b alphabetically
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    int i = 0, j = 0;
    while (j < b.length()) {                        // for every character in string b
        while (i < a.length() && a[i] != b[j]) {    // find the identical character in string a
            ++i;
        }
        if (i == a.length()) {          // not find
            return false;
        }
        ++j;
    }
    return true;
}
bool stringContain_3(string &a, string &b)
{
    // the first 26 prime number
    const vector<int> prime{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};
    long long prod = 1;
    for (int i = 0; i < a.length(); ++i) {
        if (prod % prime[a[i] - 'a'] != 0) {        // filter the same character
            prod *= prime[a[i] - 'a'];
        }
    }
    for (int i = 0; i < b.length(); ++i) {
        if (prod % prime[b[i] - 'a'] != 0) {
            return false;
        }
    }
    return true;
}
bool stringContain_4(string &a, string &b)
{
    vector<bool> exist(26, false);
    for (int i = 0; i < a.length(); ++i) {  // bookkeep the information of if a character in the string a
        exist[a[i] - 'a'] = 1;
    }
    for (int i = 0; i < b.length(); ++i) {  // check every character in string b
        if (!exist[b[i] - 'a']) {
            return false;
        }
    }
    return true;
}
int main()
{
    string a("ababacaba"), b("adac");
    cout << stringContain_1(a, b) << endl;
    cout << stringContain_2(a, b) << endl;
    cout << stringContain_3(a, b) << endl;
    cout << stringContain_4(a, b) << endl;

    return 0;
}

举一反三：变位词

 提供一个字符串str，在一个字典中找到它的兄弟字符串。兄弟字符串是指两个字符串包含的字符完全相同，但是顺序不一样。比如”bad”和”adb”为兄弟字符串。

C++代码：

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
vector<string> siblingString(vector<string> &dict, string str)
{
    // a map, whose key is the sorted word and value is a vector contains the sibling strings
    map<string, vector<string> > mp;
    for (int i = 0; i < dict.size(); ++i) {
        string tmp = dict[i];
        sort(tmp.begin(), tmp.end());
        mp[tmp].push_back(dict[i]);
    }
    sort(str.begin(), str.end());       // sort the string
    return mp[str];         // return the sibling strings
}
int main()
{
    vector<string> dict{ "abc", "acb", "cba", "aaa", "bad" };
    string str = "cab";
    vector<string> siblings = siblingString(dict, str);
    for (int i = 0; i < siblings.size(); ++i) {
        cout << siblings[i] << endl;
    }

    return 0;
}