哈希表与字符串--02-单词规律[简单]

力扣

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"

输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"

输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"

输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"

输出: false

说明:你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。    

 

#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <stack>
#include <set>
#include <algorithm> //标准算法的头文件
using namespace std;

class Solution {
public:
	bool wordPattern(string pattern, string s) {
		map<string, char> m;
		char used[128] = {0};  //用于标记pattern的字母使用情况
		string temp;
		int index = 0;  //用于记录当前pattern的下标 
		s.push_back(' '); //补充一个空格用于拆分
		for (int i = 0; i < s.size(); i++) {
			if (s[i] != ' ')   //合并单词
				temp += s[i];
			else { //单词生成完成
				if (index == pattern.size())
					return false;  //表示已没用对应的字符
				if (m.find(temp) == m.end()) { //表示未添加哈希
					if (used[pattern[index]])  //如果当前字符已使用
						return false;
					m[temp] = pattern[index];  //否则加入哈希表
					used[pattern[index]] = 1;  //标记字符
				}
				else {  //如果哈希表中找到
					if (m[temp] != pattern[index])
						return false; //如果对应失败
				}
				temp.clear();//当前单词处理完成
				index = index + 1;
			}
		}

		if (index != pattern.size())
			return false; //表示多余的pattern字符

		return true;
	}
};

void test02() 
{
	string pattern = "abba";
	string str1 = "cat dog dog cat";
	Solution s;
	cout << s.wordPattern(pattern,str1) << endl;
}

int main()
{
	test02();

	system("pause");
	return 0;
}

class Solution {
private:
    string gernerate(string s,int &i) { //引用传递 记录位置
        string item;
        for(;i<s.size();i++) {
            if(s[i]==' ') {
                i=i+1; //如果碰到空格 结束单词构造 并跳到下一个
                break;
            }
            item+=s[i]; //构造单词
        }
        return item;
    }
public:
    bool wordPattern(string pattern, string s) {
        unordered_map<char,string> umap; //索引 单词
        unordered_map<string,bool> umap2; //记录单词是否使用过
        int index=0; //记录字符串搜索到的位置
        int i=0; //记录pattern搜索到的位置
        for(;i<pattern.size();i++) {
            char ch=pattern[i];
            string item=gernerate(s,index); //构造单词
            if(item.empty()) //如果单词不够匹配
                return false;
            if(umap.find(ch)==umap.end()) { //关联未添加 
                if(umap2.find(item)==umap2.end()) { //单词未使用
                    umap.insert(make_pair(ch,item));
                    umap2.insert(make_pair(item,true));
                } else
                    return false;
            } else {  //已添加
                if(umap[ch].compare(item)==0) 
                    continue; //相同
                else
                    return false;
            }
        } 
        if(index!=s.size())
            return false;
        return true;
    }
};

class Solution {
public:
    bool wordPattern(string pattern, string s) {
        unordered_map<char,string> umap; //记录对应情况
        unordered_map<string,char> m;  //反向记录对应情况
        vector<bool> used(128,false);  //记录字母使用情况
        int i=0;  //记录s使用到的位置
        int j=0;  //记录pattern使用到的位置
        for(;j<pattern.size();j++) {
            char ch=pattern[j];
            if(i==s.size())   //如果没单词用来对应了
                return false;
            if(used[ch-'0']==false) {
                used[ch-'0']=true;
                string item;
                for(;i<s.size();i++) {  //构建单词
                    if(s[i]==' ') {
                        i++;
                        break;
                    }
                    item+=s[i];
                }
                if(m.find(item)==m.end()) {  //无对应
                    umap.insert(make_pair(ch,item));  //记录对应
                    m.insert(make_pair(item,ch));
                } else //如果单词已经被占用
                    return false;
            } else {
                string item;
                for(;i<s.size();i++) {  //构建单词
                    if(s[i]==' ') {
                        i++;
                        break;
                    }
                    item+=s[i];
                }
                if(umap[ch].compare(item)==0)
                    continue;
                else
                    return false;
            }
        }
        if(i==s.size() && j==pattern.size())
            return true;
        else
            return false;
    }
};