翻译

给定一个模式,和一个字符串str。返回str是否符合同样的模式。

这里的符合意味着全然的匹配,所以这是一个一对多的映射,在pattern中是一个字母。在str中是一个为空的单词。

比如:

pattern = “abba”。 str = “dog cat cat dog” 应该返回真。

pattern = “abba”, str = “dog cat cat fish” 应该返回假。

pattern = “aaaa”, str = “dog cat cat dog” 应该返回假。

pattern = “abba”, str = “dog dog dog dog” 应该返回假。

批注:

你可以假定pattern中仅仅包括小写字母,在str中仅仅包括被单个空格隔开的小写字母。

原文

Given a pattern and a string str, find if str follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in str.

Examples:

pattern = “abba”, str = “dog cat cat dog” should return true.

pattern = “abba”, str = “dog cat cat fish” should return false.

pattern = “aaaa”, str = “dog cat cat dog” should return false.

pattern = “abba”, str = “dog dog dog dog” should return false.

Notes:

You may assume pattern contains only lowercase letters, and str contains lowercase letters separated by a single space.

分析

我发现我真是越来越爱LeetCode了 ……

今天刚做了一道相似的题目:

LeetCode 205 Isomorphic Strings(同构的字符串)(string、vector、map)(*)

仅仅只是本题是升级版的,之前是字母匹配字母。如今是字母匹配单词了。

之前的题目示比例如以下:

For example,
Given "egg", "add", return true. Given "foo", "bar", return false. Given "paper", "title", return true.

当时我们实现了这么一个函数:

vector<int> getVecOrder(string str) {
map<char, int> strM;
int index = 0;
vector<int> strVec;
for (int i = 0; i < str.size(); ++i) {
auto iter = strM.find(str[i]);
if (iter == strM.end()) {
strM.insert(pair<char, int>(str[i], index));
strVec.push_back(index);
index += 1;
}
else {
strVec.push_back(strM[str[i]]);
}
}
return strVec;
}

它可以依据字符串生成序列:

For example,

Given "paper", return "01023".

Given "foo", return "011".

Given "isomorphic", return "0123245607".

如今的需求也是相似的,仅仅只是更加升级了一点而已:

For example,

Given "dog cat cat dog", return "0110".
Given "dog cat cat fish", return "0112".
Given "Word Pattern", return "01".

所以就封装了例如以下函数:

vector<int> getVecOrderPro(string str) {
istringstream sstream(str);
string tempStr;
vector<string> strVec;
while (!sstream.eof()) {
getline(sstream, tempStr, ' ');
strVec.push_back(tempStr);
} map<string, int> strNumMap;
int strNumIndex = 0;
vector<int> orderNumVec;
for (int i = 0; i < strVec.size(); ++i) {
auto iter = strNumMap.find(strVec[i]);
if (iter == strNumMap.end()) {
strNumMap.insert(pair<string, int>(strVec[i], strNumIndex));
orderNumVec.push_back(strNumIndex);
strNumIndex += 1;
}
else {
orderNumVec.push_back(strNumMap[strVec[i]]);
}
}
return orderNumVec;
}

首先须要对整个长长的字符串进行依据空格进行分割,分割成的单个的字符串并加入到vector数组中。使用了流的相关函数。

后面的部分就和之前的一样了,由于是个封装好的函数了,对变量名也进行了一定的改动,前面的那个函数由此改动例如以下:

vector<int> getVecOrder(string str) {
map<char, int> charNumMap;
int charNumIndex = 0;
vector<int> orderNumVec;
for (int i = 0; i < str.size(); ++i) {
auto iter = charNumMap.find(str[i]);
if (iter == charNumMap.end()) {
charNumMap.insert(pair<char, int>(str[i], charNumIndex));
orderNumVec.push_back(charNumIndex);
charNumIndex += 1;
}
else {
orderNumVec.push_back(charNumMap[str[i]]);
}
}
return orderNumVec;
}

最后的比較例如以下,由于题目没有说pattern和str的长度一致,也就是说假设最后的索引长度不匹配了那肯定就是false了。

所以多加一行:

bool wordPattern(string pattern, string str) {
vector<int> pattern_v = getVecOrder(pattern), str_v = getVecOrderPro(str);
if (pattern_v.size() != str_v.size()) return false;
for (int i = 0; i < pattern_v.size(); ++i) {
if (pattern_v[i] != str_v[i]) return false;
}
return true;
}
updated at 2016/09/17

一点半了,大半夜的不睡觉~

没看之前写的这篇博客。只是思想应该是几乎相同的~ pattern方面还是一样,str的话就先构造出一个String数组。然后在HashMap中存储和推断String。而不是Char了。

    public boolean wordPattern(String pattern, String str) {
ArrayList s0 = getArrayOrder(pattern);
ArrayList s1 = getArrayOrder2(getArrayFromString(str));
if (s0.size() != s1.size())
return false;
for (int i = 0; i < s0.size(); i++) {
if (s0.get(i) != s1.get(i)) {
return false;
}
}
return true;
} private ArrayList getArrayOrder(String str) {
HashMap<Character, Integer> strM = new HashMap<>();
int index = 0;
ArrayList order = new ArrayList(str.length());
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (strM.containsKey(c)) {
order.add(strM.get(c));
} else {
strM.put(c, index);
order.add(index);
index += 1;
}
}
return order;
} private ArrayList<String> getArrayFromString(String str) {
ArrayList<String> arrayList = new ArrayList<>();
StringBuilder builder = new StringBuilder();
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == ' ' && !builder.toString().equals("")) {
arrayList.add(builder.toString());
builder = new StringBuilder();
} else if (i == str.length() -1) {
builder.append(str.charAt(i));
arrayList.add(builder.toString());
builder = null;
} else {
builder.append(str.charAt(i));
}
}
return arrayList;
} private ArrayList getArrayOrder2(ArrayList<String> arrayList) {
HashMap<String, Integer> strM = new HashMap<>();
int index = 0;
ArrayList order = new ArrayList(arrayList.size());
for (int i = 0; i < arrayList.size(); i++) {
String s = arrayList.get(i);
if (strM.containsKey(s)) {
order.add(strM.get(s));
} else {
strM.put(s, index);
order.add(index);
index += 1;
}
}
return order;
}

代码

class Solution {
public:
vector<int> getVecOrder(string str) {
map<char, int> charNumMap;
int charNumIndex = 0;
vector<int> orderNumVec;
for (int i = 0; i < str.size(); ++i) {
auto iter = charNumMap.find(str[i]);
if (iter == charNumMap.end()) {
charNumMap.insert(pair<char, int>(str[i], charNumIndex));
orderNumVec.push_back(charNumIndex);
charNumIndex += 1;
}
else {
orderNumVec.push_back(charNumMap[str[i]]);
}
}
return orderNumVec;
} vector<int> getVecOrderPro(string str) {
istringstream sstream(str);
string tempStr;
vector<string> strVec;
while (!sstream.eof()) {
getline(sstream, tempStr, ' ');
strVec.push_back(tempStr);
} map<string, int> strNumMap;
int strNumIndex = 0;
vector<int> orderNumVec;
for (int i = 0; i < strVec.size(); ++i) {
auto iter = strNumMap.find(strVec[i]);
if (iter == strNumMap.end()) {
strNumMap.insert(pair<string, int>(strVec[i], strNumIndex));
orderNumVec.push_back(strNumIndex);
strNumIndex += 1;
}
else {
orderNumVec.push_back(strNumMap[strVec[i]]);
}
}
return orderNumVec;
} bool wordPattern(string pattern, string str) {
vector<int> pattern_v = getVecOrder(pattern), str_v = getVecOrderPro(str);
if (pattern_v.size() != str_v.size()) return false;
for (int i = 0; i < pattern_v.size(); ++i) {
if (pattern_v[i] != str_v[i]) return false;
}
return true;
}
};

LeetCode 290 Word Pattern(单词模式)(istringstream、vector、map)(*)的更多相关文章

  1. [LeetCode] 290. Word Pattern 单词模式

    Given a pattern and a string str, find if str follows the same pattern. Here follow means a full mat ...

  2. [LeetCode] 290. Word Pattern 词语模式

    Given a pattern and a string str, find if str follows the same pattern. Here follow means a full mat ...

  3. 290 Word Pattern 单词模式

    给定一种 pattern(模式) 和一个字符串 str ,判断 str 是否遵循这种模式.这里的 遵循 指完全匹配,例如在pattern里的每个字母和字符串 str 中的每个非空单词存在双向单映射关系 ...

  4. leetcode 290. Word Pattern 、lintcode 829. Word Pattern II

    290. Word Pattern istringstream 是将字符串变成字符串迭代器一样,将字符串流在依次拿出,比较好的是,它不会将空格作为流,这样就实现了字符串的空格切割. C++引入了ost ...

  5. 290. Word Pattern 单词匹配模式

    [抄题]: Given a pattern and a string str, find if str follows the same pattern. Here follow means a fu ...

  6. LeetCode 290. Word Pattern (词语模式)

    Given a pattern and a string str, find if str follows the same pattern. Here follow means a full mat ...

  7. LeetCode 290 Word Pattern

    Problem: Given a pattern and a string str, find if str follows the same pattern. Here follow means a ...

  8. Leetcode 290 Word Pattern STL

    Leetcode 205 Isomorphic Strings的进阶版 这次是词组字符串和匹配字符串相比较是否一致 请使用map来完成模式统计 class Solution { public: boo ...

  9. [leetcode] 290. Word Pattern (easy)

    原题 思路: 建立两个哈希表,分别保存: 1 模式 :单词 2 单词 :是否出现过 水题 /** * @param {string} pattern * @param {string} str * @ ...

随机推荐

  1. Python基础-week07 Socket网络编程

    一 客户端/服务器架构 1.定义 又称为C/S架构,S 指的是Server(服务端软件),C指的是Client(客户端软件) 本章的中点就是教大写写一个c/s架构的软件,实现服务端软件和客户端软件基于 ...

  2. [oldboy-django][1初识django]创建虚拟(干净)的Python环境

    如果应用A需要jinja 2.7,而应用B需要jinja 2.6怎么办?此时可以针对不同应用创建不同的虚拟环境. 这种情况下,每个应用可能需要各自拥有一套“独立”的Python运行环境.virtual ...

  3. SEO相关

    前端需要注意哪些SEO 合理的title.description.keywords: -- 搜索对着三项的权重逐个减小,title值强调重点即可,重要关键词出现不要超过2次,而且要靠前,不同页面tit ...

  4. 多IP指定出口IP地址 如何指定云服务器源IP?

    如果一个主机绑定有多个IP地址,那么在被动响应和主动发起连接两种方式中,源IP地址的选择机制肯定是有所差异的.主机在接收外部数据包,并发送响应数据包时,响应源地址显然就是客户端请求的地址,这是非常容易 ...

  5. BZOJ 1452:[JSOI2009]Count(二维树状数组)

    [JSOI2009]Count 描述 输入 输出 1 2 分析: 裸二维bit,对每个颜色建一颗bit. program count; var bit:..,..,..]of longint; a:. ...

  6. ZOJ 2112 Dynamic Rankings(带修改的区间第K大,分块+二分搜索+二分答案)

    Dynamic Rankings Time Limit: 10 Seconds      Memory Limit: 32768 KB The Company Dynamic Rankings has ...

  7. [SDOI2011][bzoj2245] 工作分配 [费用流]

    题面 传送门 思路 数据范围n,m<=250 分配任务问题 这是典型的"看到数据范围就知道算法"类型 而且我们发现我们要保证一定产出的情况下最小化花费 这句话等价于保证一定流 ...

  8. Bajtman i Okrągły Robin

    Bajtman i Okrągły Robin 题目描述 你是一个保安,你发现有n个强盗,其中第i个强盗会在[a[i],a[i]+1],[a[i]+1,a[i]+2],...,[b[i]-1,b[i] ...

  9. spring项目启动报错BeanFactory not initialized or already closed

    spring项目启动的时候报如下错误: java.lang.IllegalStateException: BeanFactory not initialized or already closed - ...

  10. 笔记:CS231n+assignment2(作业二)(一)

    第二个作业难度很高,但做(抄)完之后收获还是很大的.... 一.Fully-Connected Neural Nets 首先是对之前的神经网络的程序进行重构,目的是可以构建任意大小的全连接的neura ...