字符串与哈希表 leetcode c++实现

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <stack>
#include <bitset>
#include <string>


using namespace std;

int g_hasp_map[1<<20]={0};

struct LinkNode
{
    int val;
    LinkNode* next;
    LinkNode(int x):val(x),next(NULL){}
};

class Solution
{
public:
    void insert_hash(LinkNode* root[],LinkNode* target,int length)
    {
        int keys=func(target->val,length);
        target->next=root[keys];
        root[keys]=target;
    }
    bool search_hash(LinkNode* node[],int target,int length)
    {
        int keys=func(target,length);
        LinkNode* head=node[keys];
        while(head)
        {
            if(head->val==target)
            {
                return true;
            }
            head=head->next;
        }
        return false;
    }
    /***************************************************
    *  函数功能：最长回文串
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(n)
    *  题目来源  ： https://leetcode.com/problems/longest-palindrome/description/
    *  日期：2018-07-04-18.58
    ***************************************************/
    int longestPalindrome(string s)
    {
        if(s.length()<1) return 0;
        map<char,int> hash_MAP;
        for(int i=0;i<s.length();i++)
        {
            hash_MAP[s[i]]++;
        }
        map<char,int>::iterator it;
        int len=0;
        int flag=0;
        for(it=hash_MAP.begin();it!=hash_MAP.end();it++)
        {
            if(it->second % 2)
            {
                flag++;
            }
            len+=it->second;
        }
        if(flag)
        {
            len=len-flag+1;
        }
        return len;

    }
    /***************************************************
    *  函数功能：单词匹配
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/word-pattern/description/
    *  日期：2018-07-04-19.55
    ***************************************************/
    bool wordPattern(string pattern,string str)
    {
        map<string,char> wordP;
        int used[128]={0};
        int pos=0;
        string word="";
        str+=' ';
        for(int i=0;i<str.length();i++)
        {
            if(str[i]==' ')
            {
                if(pos==pattern.length())
                {
                    return false;
                }
                if(wordP.find(word)!=wordP.end())
                {
                    if(wordP[word]!=pattern[pos])
                    {
                        return false;
                    }
                }else
                {
                    if(used[pattern[pos]])
                    {
                        return false;
                    }
                    used[pattern[pos]]=1;
                    wordP[word]=pattern[pos];
                }
                word="";
                pos++;
            }else
            {
                word+=str[i];

            }
        }
        if(pos!=pattern.length())
        {
            return false;
        }
        return true;
    }

    /***************************************************
    *  函数功能：同字符词语分组
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/group-anagrams/description/
    *  日期：2018-07-04-19.55
    ***************************************************/
    vector<vector<string> > groupAnagrams(vector<string>& strs)
    {
        map<string,vector<string> > str;
        vector<vector<string> > result;
        if(strs.size()<1) return result;

        for(int i=0;i<strs.size();i++)
        {
            string T=strs[i];
            sort(T.begin(),T.end());
            if(str.find(T)==str.end())
            {
                vector<string> item;
                str[T]=item;
            }
            str[T].push_back(strs[i]);
        }
        for(auto it=str.begin();it!=str.end();it++)
        {
            result.push_back(it->second);
        }

        return result;
    }
    /***************************************************
    *  函数功能：无重复字符的最长子串
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/longest-substring-without-repeating-characters/description/
    *  日期：2018-07-04-21.27
    ***************************************************/
    int lengthOfLengestSubstring(string s)
    {
        int result=0;
        if(s.length()<1) return result;
        int number[128]={0};
        string word="";
        int begins=0;
        stack<string>  TT;
        for(int i=0;i<s.length();i++)
        {
            number[s[i]]++;
            if(number[s[i]]==1)
            {
                word+=s[i];
                if(result<word.length())
                {
                    result=word.length();
                    TT.push(word);
                }
            }else
            {
                while(i>begins && number[s[i]]>1)
                {
                    number[s[begins]]--;
                    begins++;
                }
                word="";
                for(int j=begins;j<=i;j++)
                {
                    word+=s[j];
                }
            }
        }
        cout<<"longest :"<<TT.top()<<endl;
        return result;
    }
    /***************************************************
    *  函数功能：重复DNA序列
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/repeated-dna-sequences/description/
    *  日期：2018-07-05-19.23
    ***************************************************/
    vector<string> findRepeatedDnaSequences(string s)
    {
        vector<string> result;
        if(s.length()<=10) return result;
        map<string,int> Temp;
        for(int i=0;i<s.length();i++)
        {
            string word=s.substr(i,10);
            Temp[word]++;
        }
        for(auto it=Temp.begin();it!=Temp.end();it++)
        {
            if(it->second > 1)
            {
                result.push_back(it->first);
            }
        }
        return result;
    }

    vector<string> findRepeatedDnaSequences1(string s)
    {
        vector<string> result;
        if(s.length()<=10) return result;
        int char_map[128]={0};
        char_map['A']=0;
        char_map['G']=1;
        char_map['C']=2;
        char_map['T']=3;
        int key=0;
        for(int i=9;i>=0;i--)
        {
            key+=char_map[s[i]]<<(2*i);
        }
        g_hasp_map[key]=1;
        for(int j=10;j<s.length();j++)
        {
            key=key>>2;
            key=key | (char_map[s[j]]<<18);
            g_hasp_map[key]++;
        }
        for(int j=0;j<(1<<20);j++)
        {
            if(g_hasp_map[j]>1)
            {
                result.push_back(number_to_DNA(j));
            }
        }
        return result;

    }

    vector<string> findRepeatedDnaSequences2(string s)
    {
        vector<string> result;
        if(s.length()<11) return result;
        bitset<1<<20> S1;   //已经存在，但是未保存值；
        bitset<1<<20> S2;  //已经存在，并且保存了值
        int key=0;
        for(int i=0;i<10;i++)
        {
            key=(key<<2) | char_to_int(s[i]);
        }
        S1.set(key);
        int mask=(1<<20)-1;
        for(int j=10;j<s.length();j++)
        {
            key=(key<<2 & mask) | char_to_int(s[j]);
            if(S2[key])
            {
                continue;
            }
            if(S1[key])
            {
                result.push_back(s.substr(j-9,10));
                S2.set(key);
            }else
            {
                S1.set(key);
            }
        }
        return result;
    }

private:
    int char_to_int(char c)
    {
        int number=0;
        switch(c)
        {
            case 'A':number=0;break;
            case 'C':number=1;break;
            case 'G':number=2;break;
            case 'T':number=3;break;
        }
        return number;
    }
    string number_to_DNA(int number)
    {
        const char DNA[]={'A','G','C','T'};
        string word="";
        for(int i=0;i<10;i++)
        {
            word+=DNA[number & 3];
            number=number>>2;
        }
        return word;
    }
    int func(int target,int length)
    {
        return target%length;
    }
};


int main()
{
    Solution ss;
    string s="AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT";
    vector<string> result;
    result=ss.findRepeatedDnaSequences(s);
    for(int i=0;i<result.size();i++)
    {
        cout<<result[i]<<endl;
    }

    vector<string> result1;
    result1=ss.findRepeatedDnaSequences2(s);
    for(int i=0;i<result1.size();i++)
    {
        cout<<result1[i]<<endl;
    }

    return 0;
}

/*
int main()
{
    Solution ss;
    string s="pwwkew";
    cout<<ss.lengthOfLengestSubstring(s)<<endl;
    return 0;
}
*/


/*
int main()
{
    Solution ss;
    vector<string> strs;
    strs.push_back("eat");
    strs.push_back("tea");
    strs.push_back("tan");
    strs.push_back("ate");
    strs.push_back("nat");
    strs.push_back("bat");

    vector<vector<string> > result;
    result=ss.groupAnagrams(strs);
    for(int i=0;i<result.size();i++)
    {
        for(int j=0;j<result[i].size();j++)
        {
            cout<<result[i][j]<<"  ";
        }
        cout<<endl;
    }
    return 0;
}
*/


/*
int main()
{
    Solution ss;
    string pattern="abba";
    string str="dog cat cat dog";
    cout<<ss.wordPattern(pattern,str)<<endl;
    return 0;
}
*/

/*
int main()
{
    Solution ss;
    string s="abcccccddaa";
    int a;
    cout<<ss.longestPalindrome(s)<<endl;

    return 0;
}
*/

/*
int main()
{
    Solution ss;
    const int TABLE_LEN=11;
    LinkNode* hash_table[TABLE_LEN]={0};
    vector<LinkNode*> hash_node_vec;
    int test[]={1,1,4,9,20,30,150,500};
    for(int i=0;i<sizeof(test)/sizeof(*test);i++)
    {
        hash_node_vec.push_back(new LinkNode(test[i]));
    }
    for(int i=0;i<hash_node_vec.size();i++)
    {
        ss.insert_hash(hash_table,hash_node_vec[i],TABLE_LEN);
    }

    cout<<"hash table:"<<endl;
    for(int i=0;i<TABLE_LEN;i++)
    {
        cout<<"["<<i<<"]:";
        LinkNode* head=hash_table[i];
        while(head)
        {
            cout<<"-->"<<head->val;
            head=head->next;
        }
        cout<<endl;
    }

    for(int i=0;i<20;i++)
    {
        if(ss.search_hash(hash_table,i,TABLE_LEN))
        {
            cout<<i<<" is in the hash table"<<endl;
        }else
        {
            cout<<i<<" is not in the hash table"<<endl;
        }
    }
    cout<<"----------------------------------"<<endl;

    map<string,int> hash_mapp;
    string str1="aaa";
    string str2="abc";
    string str3="xxxxx";
    hash_mapp[str1]=12;
    hash_mapp[str2]=4;
    hash_mapp[str3]=32;
    if(hash_mapp.find(str1)!=hash_mapp.end())
    {
        cout<<hash_mapp[str1];
    }
    cout<<endl<<"------------------"<<endl;
    map<string,int>::iterator it;
    for(it=hash_mapp.begin();it!=hash_mapp.end();it++)
    {
        cout<<it->first<<"-->"<<it->second<<endl;
    }

    return 0;
}
*/

/*
vector<int> hasp_sort(vector<int>& nums)
{
    int maxN=nums[0];
    for(int i=1;i<nums.size();i++)
    {
        if(maxN<nums[i])
        {
            maxN=nums[i];
        }
    }
    vector<int> hasp_map(maxN,0);
    for(int i=0;i<nums.size();i++)
    {
        hasp_map[nums[i]]++;
    }
    vector<int> result;
    for(int i=0;i<=maxN;i++)
    {
        for(int j=0;j<hasp_map[i];j++)
        {
            result.push_back(i);
        }
    }
    return result;
}
int main()
{
    int random[]={999,1,444,7,20,9,1,3,7,7};
    int len=sizeof(random)/sizeof(*random);
    vector<int> nums;
    vector<int> result;
    for(int i=0;i<len;i++)
    {
        nums.push_back(random[i]);
        cout<<random[i]<<" ";
    }
    cout<<endl;
    result=hasp_sort(nums);
    for(int i=0;i<result.size();i++)
    {
        cout<<result[i]<<" ";
    }
    cout<<endl;
    cout<<"--------------"<<endl;


    int char_map[128]={0};
    string str="abcdefgaaxxy";
    for(int i=0;i<str.length();i++)
    {
        char_map[str[i]]++;
    }
    for(int i=0;i<128;i++)
    {
       if(char_map[i]>0)
       {
           cout<<i<<" --> "<<char_map[i]<<endl;

       }
    }
    cout<<endl;
    cout << "Hello world!" << endl;
    return 0;
}
*/