Question

我觉得我可能对这些要求不够清楚，所以让我试着让事情变得更清楚。

您将获得一个字典，其中包含单个字母或多个字母的键。每个键都有一个关联值。给定输入，您必须找到包含输入字母的键。返回满足此要求的最低键值。

以下是一些例子：

输入字典

键 - ＆gt;值

a - ＆gt; 4

b - ＆gt; 6

e - ＆gt; 5

abc - ＆gt; 8

输入：＆＃39; a＆＃39; 输出：4

输入：＆＃39; c＆＃39; 输出：8

输入：＆＃39; ab＆＃39; 输出：8

输入：＆＃39; ac＆＃39; 输出：8

输入：＆＃39; ce＆＃39; 输出：13

输入：＆＃39; d＆＃39; 输出：null

注意第三个例子，输入是ab。所以在这里，我们可以得到这封信＆＃39; a＆＃39;从关键＆＃39; a＆＃39;或关键的＆＃39; abc＆＃39;。我们可以收到这封信＆＃39; b＆＃39;从关键＆＃39; b＆＃39;或关键的＆＃39; abc＆＃39;。为了获得总价值最低的两个键，＆＃39; abc＆＃39;值为8是正确的输出。

注意第五个例子，输入是ce。这封信＆＃39; c＆＃39;仅适用于密钥＆＃39; abc＆＃39;。这封信＆＃39; e＆＃39;仅适用于密钥＆＃39;。在这种情况下，正确的输出是13。

更新：我能够通过从输入序列中的第一个字母开始，查找包含该字母的所有键，以及为每个键构建所有可能组合的列表来递归地解决此问题。我能够通过递归移动输入序列的一个字母来跟踪最低总和。

Answer 1

你可以而且可能应该做递归。始终抓住您要搜索的字符串的下一个字母，并继续构建所有可能性。对于每个分支，只保留最小值和与之关联的字符串。

从字母a开始，您有2个选项 - [4，a]或[8，abc]。现在你继续下一个字母，因为你现在有[6，b]或[8，abc]。由于这是列表的末尾，并且b小于abc，因此最终得到[10，ab]。现在另一个，abc分支，可以跳过b - 它已经拥有它。所以，你比较[8，abc] vs [10，ab]和abc更小，所以它会被返回。并且已经是最终的解决方案了。

Answer 2

我在这里建议的方法有点长，但这是我能想到的现在帮助你的方法取最大计数变量现在，如果输入是多个字母，请检查具有所需字母表的所有字符串。还要寻找＆＃34;字母和＃34;分开。

继续相应地更新max_count变量。

Answer 3

  #!/usr/bin/python3                                                                                                       
  import operator

    def smallest_sum(dic):
        a_dic = {}
        b_dic = {}
        # get a list of all keys containing a and b
        for key in dic:
            if "a" in key:
                a_dic[key] = dic[key]
            elif "b" in key:
                b_dic[key] = dic[key]

        a_dic = sorted(a_dic.items(), key=operator.itemgetter(1))
        b_dic = sorted(b_dic.items(), key=operator.itemgetter(1))

        if "ab" in a_dic[0]:
            return a_dic[0][1]
        else:
            a_sum_b = a_dic[0][1] + b_dic[0][1]
            return a_sum_b

    if __name__ == "__main__":
        dic = {"a":2, "b":3, "abc":10, "ab": 15, "bcd": 2}
        sum = smallest_sum(dic)
        print(sum)

Answer 4

我不知道我是否做对了

private static Dictionary<string, int>  dic=new Dictionary<string, int>()  ;
public static void MinSum()
{

    // here create statements where the key is a single letter
    dic.Add("a", 4);
    dic.Add("b", 6);
    dic.Add("c", 3);
    dic.Add("d", 4);
    dic.Add("e", 5);
    // here add the combination
    dic.Add("abcde", 8);
    dic.Add("abce", 10);
    dic.Add("ae", 2);

    var minSum= GetMinSum( "ae".ToCharArray());
    var minSum2 = GetMinSum("abc".ToCharArray());
    var minSum4 = GetMinSum("a".ToCharArray());

}

public static int GetMinSum(char[] letters)
{
    //If the input is a single letter, then I simply return the value associated with that key
    if (letters.Count() == 1)
        return dic[letters[0].ToString()];

    // sumUp all the single Key elements
    var sumOfSingleKeyElements = dic.Where(x => x.Key.Length == 1 && letters.Contains(x.Key[0])).Sum(v => v.Value);
    // get the min value Key elements that combine the letters above
    //  the " !letters.Except(x.Key.ToCharArray()).Any()" defines if the set letters is a subset of the key
    var minOfCompositeKeyElements = dic.Where(x => x.Key.Length > 1 
                        && !letters.Except(x.Key.ToCharArray()).Any()
                        ).Min(v => v.Value);

    return sumOfSingleKeyElements < minOfCompositeKeyElements ? sumOfSingleKeyElements : minOfCompositeKeyElements;
}

字母组合的最小金额＆＃34; a＆＃34;，＆＃34; e＆＃34;是2
字母组合的最小金额＆＃34; a＆＃34;，＆＃34; b＆＃34;，＆＃34; c＆＃34;是8
该字母的最低金额＆＃34; a＆＃34;是4

最小和算法

4 个答案: