leetcode每日一题 953.验证外星语词典

953.验证外星语词典

问题描述

	某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。
	给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

示例

	输入：words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
	输出：true
	解释：在该语言的字母表中，'h' 位于 'l' 之前，所以单词序列是按字典序排列的。

---

	输入：words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
	输出：false
	解释：在该语言的字母表中，'d' 位于 'l' 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。

---

	输入：words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
	输出：false
	解释：当前三个字符 "app" 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 "apple" > "app"，因为 'l' > '∅'，其中 '∅' 是空白字符，定义为比任何其他字符都小

提示

	1 <= words.length <= 100
	1 <= words[i].length <= 20
	order.length == 26
	在 words[i] 和 order 中的所有字符都是英文小写字母。

思路

	其实就是一个简化的排序题目。
	不同的是排序需要不断的比较两两元素间的大小关系，而本题仅需验证序列是否为升序，即只需比较前后两个单词的大小即可。
	因此解决问题的思路就很明确了。
	1.将字典序按固定格式存储，方便使用
	2.遍历所有单词
		比较前后两个单词大小
			若后单词>=前单词，则继续比较
			若后单词<前单词，则非升序，返回false
	3.若遍历完毕无误，则返回true
	由上述步骤可见，解决问题只需着重实现两个部分，1)怎么存储字典序；2)怎么比较单词大小
	这里存储字典序主要以“字母序：字母对应字典序”的格式存储
	比较单词大小也很简单，两个单词逐个字符比较该字符的字典序大小即可。
	其余仅需注意一些细节上的问题，详见代码注释。

代码

class Solution {
public:
    bool gt(int dict[], string a, string b){
        // 比较函数，返回a>=b?
        int a_length = a.length();
        int b_length = b.length();
        int max_length = a_length>b_length?a_length:b_length;
        for(int i=0;i<max_length;i++){
            // a,b两个单词，顺序比较逐个字符
            char a_i;
            char b_i;
            if(i<=a_length){
                a_i = a[i];
            }
            if(i<=b_length){
                b_i = b[i];
            }
            // 提取两个字符的字典序，若为空，则字典序为-1(最小)
            int a_v = -1;
            int b_v = -1;
            if(a_i){
                a_v = dict[a_i-'a'];
            }
            if(b_i){
                b_v = dict[b_i-'a'];
            }
            // 比较大小
            if(a_v>b_v){
                return true;
            }
            else if(a_v<b_v){
                return false;
            }
        }
        // 所有循环执行完，则两个单词相同
        return true;
    }

    bool isAlienSorted(vector<string>& words, string order) {
        // 若只有一个单词，无需比较
        if(words.size()==1){
            return true;
        }
        // 初始化字典序, 0存储a的字典序，1存储b的字典序...类推
        int dict[26];
        for(int i=0;i<26;i++){
            int index = order[i]-'a';
            dict[index] = i;
        }

        // 前后单词比较大小
        for(int i=1;i<words.size();i++){
            if(gt(dict, words[i], words[i-1])){
                continue;
            }
            else{
                return false;
            }
        }
        return true;
    }
};

别人的思路

暂无；还没空看:D