单词规律

2023-10-19 09:49:14

算法原理

单词规律算法的核心思想是动态规划，它将问题分解为子问题，并逐个解决。算法首先将字符串s和规律pattern划分为多个字符，然后比较每个字符是否满足规律。如果所有字符都满足规律，则字符串s遵循规律；否则，字符串s不遵循规律。

为了比较字符是否满足规律，算法需要记录规律中每个字符的出现次数和位置。当比较字符串s中的字符时，算法会检查该字符在规律中是否出现过，以及出现的次数和位置是否与字符串s中的字符一致。如果一致，则该字符满足规律；否则，该字符不满足规律。

Java实现

import java.util.HashMap;

public class WordPattern {

    public boolean wordPattern(String pattern, String s) {
        if (pattern == null || s == null) {
            return false;
        }

        String[] words = s.split(" ");
        if (words.length != pattern.length()) {
            return false;
        }

        HashMap<Character, String> map = new HashMap<>();
        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            String word = words[i];

            if (map.containsKey(c)) {
                if (!map.get(c).equals(word)) {
                    return false;
                }
            } else {
                if (map.containsValue(word)) {
                    return false;
                }
                map.put(c, word);
            }
        }

        return true;
    }
}

Go实现

package main

import (
	"fmt"
	"strings"
)

func main() {
	pattern := "abba"
	s := "dog cat cat dog"
	result := wordPattern(pattern, s)
	fmt.Println(result) // true
}

func wordPattern(pattern string, s string) bool {
	if pattern == "" || s == "" {
		return false
	}

	words := strings.Split(s, " ")
	if len(words) != len(pattern) {
		return false
	}

	charMap := make(map[rune]string)
	wordMap := make(map[string]rune)
	for i, char := range pattern {
		word := words[i]

		if charMap[char] != "" && charMap[char] != word {
			return false
		}
		if wordMap[word] != 0 && wordMap[word] != char {
			return false
		}

		charMap[char] = word
		wordMap[word] = char
	}

	return true
}