数据结构--LeetCode专题练习 Day13

 290. 单词规律

给定一种规律 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 包含了由单个空格分隔的小写字母。

原始思路：

我的起初思路是先识别单词再去对应类型

思路更正：

与我的初始思路相反，是用类型去对应字符串，再去用每一个字符串去对应字符（双向）

1.哈希表
利用哈希表记录每一个字符对应的字符串，以及每一个字符串对应的字符
枚举每一对字符与字符串的配对过程，不断更新哈希表
如果发生了冲突，则说明给定的输入不满足双射关系。
枚举pattern 中的每一个字符，利用双指针来均摊线性地找到该字符在str 中对应的字符串
每次确定一个字符与字符串的组合，我们就检查是否出现冲突，最后我们再检查两字符串是否比较完毕即可

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<string, char> str2ch;
        unordered_map<char, string> ch2str;
        int m = str.length(); //string的长度
        int i = 0;//指针
		//遍历pattern
        for (auto ch : pattern) { 
            if (i >= m) {  //pattern的长度大于m
                return false;
            }
            int j = i;
            while (j < m && str[j] != ' ') j++;
            const string &tmp = str.substr(i, j - i);//复制子字符串，要求从指定位置开始，并具有指定的长度
            if (str2ch.count(tmp) && str2ch[tmp] != ch) {  //count函数统计某一值在一定范围内出现的次数
                return false;
            }
            if (ch2str.count(ch) && ch2str[ch] != tmp) {
                return false;
            }
            str2ch[tmp] = ch;
            ch2str[ch] = tmp;
            i = j + 1;
        }
        return i >= m;
    }
};

  2.stringstream
（1）定义两个map，为何定义两个呢？ 防止[aaaa]与[cat dog dog cat]、[abba]与[cat cat cat cat]时输出true
（2）用stringstream可以自动输出词组
（3）判断：!(ss >> s)判断pattern长度是否大于str长度，且将ss容器中字符串赋值给s
（4）判断：(map.count(c) == 1 && map[c] != s) || (rmap.count(s) == 1 && rmap[s] != c)) 来判断是否匹配
（5）判断：(ss >> s) ? false : true 判断str长度是否大于pattern长度

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<char, string> map;
        unordered_map<string, char> rmap;
        stringstream ss(str);
		string s;
        for(char c : pattern) {
            if(!(ss >> s) || (map.count(c) == 1 && map[c] != s) || (rmap.count(s) == 1 && rmap[s] != c)) return false;
            map[c] = s;
			rmap[s] = c;
        }
        return (ss >> s) ? false : true;
    }
};

763. 划分字母区间

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。

示例：

输入：S = "ababcbacadefegdehijhklij"
输出：[9,7,8]

解释：
划分结果为 "ababcbaca", "defegde", "hijhklij"。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。
提示：

S的长度在[1, 500]之间。
S只包含小写字母 'a' 到 'z' 。

思路：

//遍历字符串，记录最后一次出现的位置

//将每个字母对应的数组均改为最后一次出现的位置的数字

//遍历位置数组，当寻找到间隔最远的相同数字时，即为分割点

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[27] = {0}; // i为字符，hash[i]为字符出现的最后位置
        for (int i = 0; i < s.size(); i++) { // 统计每一个字符最后出现的位置
            hash[s[i] - 'a'] = i;//下标得是整数，又因为是小写字母，所以char-‘a’变成小写字母对应的整数
        }
        vector<int> result;
        int left = 0;
        int right = 0;
        for (int i = 0; i < S.size(); i++) {
            right = max(right, hash[s[i] - 'a']); // 找到字符出现的最远边界
            if (i == right) {
                result.push_back(right - left + 1);
                left = i + 1;
            }
        }
        return result;
    }
};