根据下面的答案，您可能会注意到这个问题，有很多不同的解决方案。我只选择了Evan，因为它是我在自己的代码中实现的最简单的方法。但是，根据我的尝试，其他每个答案也都有效。 @SalvadorDali链接了Kaggle page这个非常有趣的内容，如果您有兴趣，我建议您阅读。 Prolog也被提出作为一种可能的解决方案，我不熟悉它，但如果你已经知道它 - 它可能值得考虑。此外，如果您只想获取要使用的代码，请参阅下面的Javascript和Python示例。但是，每个人都有不同的解决方案，我不确定哪个是最有效的（可以自己测试）。
有关进一步的方法/阅读：
http://en.wikipedia.org/wiki/Breadth-first_search
Prolog and ancestor relationship
https://www.kaggle.com/c/word2vec-nlp-tutorial/details/part-2-word-vectors
对于令人困惑的标题感到抱歉，我无法找到正确说出问题的方法 - 欢迎任何更好的想法。
因为我很难描述我的问题，所以我会尽量解释我的目标和代码：
注意：我的代码是Go，但我也很满意其他语言的答案，如果您有任何问题，我会尽快回答
基本上，我有一个＆＃34; Word＆＃34;看起来像这样的对象：
type Word struct{
text string
synonyms []string
}
这是数组中4个单词的示例：
[]Word{
{text: "cat" synonyms: ["feline", "kitten", "mouser"]}
{text: "kitten" synonyms: ["kitty", "kit"]}
{text: "kit" synonyms: ["pack", "bag", "gear"]}
{text: "computer" synonyms: ["electronics", "PC", "abacus"]}
}
我的挑战是编写一种方法来测试两个单词之间的关系。当然，使用上面的示例，在＆＃34; cat＆＃34; 和＆＃34; kitten＆＃34; 等2个单词之间进行测试会很容易。我可以检查一下Cat＆＃34的同义词列表并测试它是否包含＆＃34;小猫。＆＃34;使用这样的代码：
areWordsRelated(word1 Word, word2 Word) bool{
for _, elem := range word1.synonyms{
if elem == word2.text{
return true
}
}
return false
}
但是，我无法弄清楚如何测试更远的关系。
例如：
areWordsRelated("cat","pack") //should return true
//because "cat" is related to "kitten" which is related to "pack"
areWordsRelated("cat", "computer") //should return false
我尝试递归地做，但我的所有尝试似乎都不起作用。任何示例代码（我的代码在Go中，但Python，Java或Javascript也很好），伪代码或只是解释会非常好。
答案 0 :(得分：3)
Python解决方案：
class Word:
# Dictionary of Words, keyed by name.
word_dict = {}
def __init__(self, name, synonyms):
self.name = name
self.synonyms = synonyms
# Update the dictionary.
Word.word_dict[name] = self
for s in synonyms:
if not s in Word.word_dict:
Word.word_dict[s] = Word(s, [])
def isAncestor(self, other):
if other in self.synonyms:
return True
for s in self.synonyms:
if Word.word_dict[s].isAncestor(other):
return True
return False
def areWordsRelated(word1, word2):
if not word1 in Word.word_dict or not word2 in Word.word_dict:
return False
return Word.word_dict[word1].isAncestor(word2) or Word.word_dict[word2].isAncestor(word1)
words = []
words.append(Word("cat", ["feline", "kitten", "mouser"]))
words.append(Word("kitten", ["kitty", "kit"]))
words.append(Word("kit", ["patck", "bag", "gear"]))
words.append(Word("computer", ["electronics", "PC", "abacus"]))
print(areWordsRelated("cat", "kit"))
print(areWordsRelated("kit", "cat"))
print(areWordsRelated("cat", "computer"))
print(areWordsRelated("dog", "computer"))
输出：
True
True
False
False
答案 1 :(得分：3)
如果你给我一些反馈意见，我可以编辑它，因为它并没有完全按照你的要求进行编辑，但这是一个问题。我将使用技术说明进行编辑，以了解必须更改的内容以满足您的确切示例。
package main
import "fmt"
func main() {
words := []Word{
{text: "cat", synonyms: []string{"feline", "kitten", "mouser"}},
{text: "kitten", synonyms: []string{"kitty", "kit"}} ,
{text: "kit", synonyms: []string{"pack", "bag", "gear"}},
{text: "computer", synonyms: []string{"electronics", "PC", "abacus"}},
}
fmt.Println(areWordsRelated(words, words[0], words[2]))
fmt.Println(areWordsRelated(words, words[0], words[3]))
}
type Word struct{
text string
synonyms []string
}
func areWordsRelated(words []Word, word1, word2 Word) bool {
for _, elem := range word1.synonyms{
if elem == word2.text{
return true
} else {
for _, word := range words {
if word.text == elem {
if (areWordsRelated(words, word, word2)) {
return true
}
}
}
}
}
return false
}
编辑：这并不是你提出的要求，因为它没有在＆＃34; pack＆＃34;之间建立连接。和＆＃34; cat＆＃34;因为pack不是由实际的单词对象表示的，所以我定义了接收word2作为对象的方法（只是处理你的例子）。我可以把它变成一个字符串，这样就可以检查＆＃34; pack＆＃34;在＆＃34; kit＆＃34;的同义词数组中在返回之前，但这个想法是相同的......这里是对算法的高级解释。
迭代同义词，如果它不匹配，则在原始集合中找回Word对象，并将其作为第一个参数调用自己。这将以递归方式耗尽每条路径，直到找到匹配为止，或者没有留下任何路径，在这种情况下，您将在循环外返回false。上面的代码在go playground中运行并正确返回true\nfalse。请注意，递归调用是在if中进行的，以防止过早返回false（也是性能增强，因为一旦找到true就返回，而不是继续递归路径）。
答案 2 :(得分：3)
首先，目前尚不清楚如何定义这里的关系。如果你的 ＆＃34;猫＆＃34;有同义词：[＆＃34;猫科动物＆＃34;，＆＃34;小猫＆＃34;，＆＃34; mouser＆＃34;]，这是否意味着＆＃34; mouser＆＃34;有一个同义词＆＃34; cat＆＃34;。
根据我的理解，答案是否定的。所以这是python中的一个解决方案：
G = {
"cat": ["feline", "kitten", "mouser"],
"kitten": ["kitty", "kit"],
"kit": ["pack", "bag", "gear"],
"computer": ["electronics", "PC", "abacus"]
}
def areWordsRelated(G, w1, w2):
if w1 == w2:
return True
frontier = [w1]
checked = set()
while len(frontier):
el = frontier.pop()
if el in G:
neighbors = G[el]
for i in neighbors:
if i == w2:
return True
if i not in checked:
frontier.append(i)
checked.add(i)
return False
areWordsRelated(G, "cat", "pack") #true
areWordsRelated(G, "cat", "computer") #false
那我们在这做什么？首先你有你的图表，它只是字典（go in map），显示你的关系（我基本上把你的切片）。
我们的算法像模具一样增长，维护一组已检查元素和当前边界。如果边界是空的（没有什么可以探索，那么元素没有连接）。我们从边界一次提取一个元素并检查所有邻居。如果它们中的任何一个是我们正在寻找的元素 - 则存在连接。否则，检查我们是否已经看过这样的元素（如果不是将它添加到边界和已检查的集合中）。
请注意，如果您的关系以稍微不同的方式运作，您只需要修改图表。
最后一句话，如果您正在寻找寻找同义词的常规方法，请查看word to vector algorithm和一个不错的implementation in python。这样即使没有指定这种关系，即使在发现California和Golden Gate相关的单词之间也能找到真正复杂的关系。
答案 3 :(得分：2)
这是一个用JavaScript编写的递归算法示例，其中引入了一些jQuery以便更容易地搜索数组。它可能会被优化，但应该给你一些东西。
$(function() {
var words = [{
text: "cat",
synonyms: ["feline", "kitten", "mouser"]
}, {
text: "kitten",
synonyms: ["kitty", "kit"]
}, {
text: "kit",
synonyms: ["pack", "bag", "gear"]
}, {
text: "computer",
synonyms: ["electronics", "PC", "abacus"]
}];
console.log(areWordsRelated('cat', 'pack', words));
console.log(areWordsRelated('cat', 'rack', words));
});
function areWordsRelated(parentWord, childWord, list) {
var parentWordItems = $.grep(list, function(element) {
return element.text === parentWord;
});
if (parentWordItems.length === 0) {
return false
} else {
var parentWordItem = parentWordItems[0];
var remainingItems = $.grep(list, function(element) {
return element.text !== parentWord;
});
if (parentWordItem.synonyms.indexOf(childWord) >= 0) {
return true;
} else {
for (var i = 0; i < parentWordItem.synonyms.length; i++) {
var synonym = parentWordItem.synonyms[i];
if (areWordsRelated(synonym, childWord, remainingItems)) {
return true;
}
}
return false;
}
}
}<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
答案 4 :(得分：2)
你正在寻找二级关系（而不是你已经知道如何找到的'简单'第一名的例子），这意味着你必须做两件事之一：
（1）存储量大的解决方案需要维护一个单独的二度关系列表，然后只需在该（更长）列表中进行搜索 - 这需要维护（可能更多）关于字关系的更多数据。例如，如果您有10000个单词，并且每个单词大约有10个同义词，则存储100,000个一级关系。但那时候你会有十亿次二度关系。所以当然很快就会变得笨拙。
在这种情况下，每个条目如下所示： {text：“cat”的同义词：[“feline”，“kitten”，“mouser”]秒：[“pack”，...]} ......你只需编写一个单独的函数来检查EITHER'的同义词'或'秒'中的关系。
（2）程序化解决方案仍然只是存储一级关系，然后进行嵌入式循环。
在这种情况下：
//// This checks for 1st degree relationship
areWordsRelated1(word1 Word, word2 Word) bool{
for _, elem := range word1.synonyms{
if elem == word2.text{
return true
}
}
return false
}
//// This checks for 2nd degree by checking 1st and then, if not,
//// then trying the 1st degree function on the children of word2
//// before giving up and returning false
areWordsRelated2(word1 Word, word2 Word) bool{
for _, elem1 := range word1.synonyms{
if elem1 == word2.text{
return true
} else {
for _, elem2 := range elem1.synonyms{
if areWordsRelated1(word1, elem2) {
return true
}
}
}
return false
}
注意：我注意到在您的样本数据中，“cat”与“小猫”有关，但“小猫”与“猫”没有相关。