常見字符串算法題

1. 拓撲結構相同的子樹

對於兩棵彼此獨立的二叉樹A和B，請編寫一個高效算法，檢查A中是否存在一棵子樹與B樹的拓撲結構完全相同，節點取值也要相同。

給定兩棵二叉樹的頭結點A和B，請返回一個bool值，代表A中是否存在一棵同構於B的子樹。

思路1：遍歷樹A，若遍歷到的節點C取值與B的根節點取值一樣，則判斷以B為根和以C為根的樹結構是否相同。時間復雜度：O(N*M)。 N：A的節點數，M：B的節點數。

思路2：將樹A和樹B序列化為字符串，然后用KMP算法在字符串A中尋找子串B。時間復雜度：O(N+M)

知識點：樹的遍歷；樹結構匹配；樹的序列化；KMP算法

// 思路1
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class IdenticalTree {
public:
    bool chkIdentical(TreeNode* A, TreeNode* B) {
        if (B==NULL) return true;
        return pre_order(A, B);
    }
    bool pre_order(TreeNode* A, TreeNode* B){
        if(A==NULL) return false;
        bool flag=false;
        if(A->val == B->val)
            flag = judge(A, B);
        if(flag) 
            return true;
        else
            return pre_order(A->left, B) || pre_order(A->right, B);
    }
    
    bool judge(TreeNode* root1, TreeNode* root2){
        if(root1 == NULL && root2 == NULL) return true;
        if(root1 == NULL && root2 != NULL) return false;
        if(root1 != NULL && root2 == NULL) return false;
        if(root1->val != root2->val) return false;
        return judge(root1->left, root2->left) && judge(root1->right, root2->right);
    }
};

// 思路2
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class IdenticalTree {
public:
    bool chkIdentical(TreeNode* A, TreeNode* B) {
        string strA = pre_serial(A);
        string strB = pre_serial(B);
        int idx = kmp_search(strA, strB);
        return idx != -1;
    }
    
    string pre_serial(TreeNode* root){
        if(root==NULL) return "#!";
        string res = std::to_string(root->val)+"!";
        res += pre_serial(root->left);
        res += pre_serial(root->right);
        return res;
    }
    
    int kmp_search(string s, string p){
        int len_s=s.length(), len_p=p.length();
        int* next = getNext(p);
        int i=0, j=0;
        while(i<len_s && j<len_p){
            if(s[i] == p[j] || j==-1){
                ++i;
                ++j;
            }else{
                j = next[j];
            }
        }
        return j==len_p ? i-j : -1;
    }
    
    int* getNext(string p){
        int len = p.length();
        int* next = new int[len];
        next[0] = -1;
        
        int k=-1, j=0;
        while(j<len-1){
            if(k==-1 || p[j]==p[k]){
                if(p[j+1] == p[k+1])
                    next[++j] = next[++k];
                else
                    next[++j] = ++k;
            }else
                k = next[k];
        }
        return next;
    }
};

2. 詞語變形題

對於兩個字符串A和B，如果A和B中出現的字符種類相同且每種字符出現的次數相同，則A和B互為變形詞，請設計一個高效算法，檢查兩給定串是否互為變形詞。

給定兩個字符串A和B及他們的長度，請返回一個bool值，代表他們是否互為變形詞。

思路：C++字符的取值范圍為0-255，Java為0-65535。可以設置一個大小為256的數組，存儲A中出現的每個字符的計數。B同理。然后比較兩個計數數組是否相等。

知識點：字符取值范圍；給定取值范圍時，可用數組模擬哈希表，效率更高。

class Transform {
public:
    bool chkTransform(string A, int lena, string B, int lenb) {
        int* cntA=new int[256]();
        int* cntB=new int[256]();
        for(int i=0; i<lena; ++i)
            ++cntA[A[i]];
        for(int i=0; i<lenb; ++i)
            ++cntB[B[i]];
        for(int i=0; i<256; ++i)
            if(cntA[i] != cntB[i])
                return false;
        return true;
    }
};

3. 判斷串的旋轉

如果對於一個字符串A，將A的前面任意一部分挪到后邊去形成的字符串稱為A的旋轉詞。比如A="12345",A的旋轉詞有"12345","23451","34512","45123"和"51234"。對於兩個字符串A和B，請判斷A和B是否互為旋轉詞。

給定兩個字符串A和B及他們的長度lena，lenb，請返回一個bool值，代表他們是否互為旋轉詞。

思路：令C=A+A, 然后在C中用KMP算法查找子串B。

4. 句子的逆序

給定一個原字符串A和他的長度，請返回逆序后的字符串。如輸入："dog loves pig",13，返回："pig loves dog"。

思路：實現一個逆序函數，然后對整個句子逆序，然后對單詞逆序。

 

 5. 最大回文子串 LeetCode 5

class Solution {
public:
    string longestPalindrome(string s) {
        int len = 0;
        string str;
        // 遍歷每一個位置，作為中心點
        for(int i=0; i<s.size(); ++i)
        {
            // 查找aba模式回文串
            for(int j=0; i-j>=0 && i+j<s.size(); ++j)
                if(s[i-j] == s[i+j])
                {
                    if(2*j+1 > len)
                    {
                        str = s.substr(i-j, 2*j+1);
                        len = 2*j+1;
                    }
                }
                else break;
            // 查找abba模式回文串
            for(int l=i,r=i+1; l>=0&&r<s.size(); --l,++r)
                if(s[l] == s[r])
                {
                    if(r-l+1 > len)
                    {
                        str = s.substr(l, r-l+1);
                        len = r-l+1;
                    }
                }
                else break;
        }
        return str;
    }
};