我一直在尝试寻找答案，但我发现的所有讨论要么是我不懂的语言，要么依赖于一个集合，其中每个元素都有自己的权重。

我想基本上只是得到一个介于 0 和 10 之间的随机数，这是“中等权重”，因为 5 比 0 和 10 更常见。基本上我一直在试图找出一种算法，我可以给出任何数字我定义的最小值和最大值之间的“加权数字”以及生成的所有数字都将被适当加权。我知道这听起来可能像是“我不想考虑这个，我就坐等别人去做”，但我已经思考和搜索了一个小时，我真的迷路了:|

所以最后，我希望我可以调用（通过扩展方法）

（我将 Solr 和 SQL 作为标签附加，因为我不知道在这种情况下使用什么。甚至可能是其他东西）

例子：

必须根据时间和价格对任务进行排序的Web应用程序。用户有一个滑块来决定什么更重要（时间或价格）。

它必须进行加权排序，其中结果的分数取决于价格和时间，但是当用户滑向时间或价格时，必须可以更改系数。

示例 2：

用户正在尝试找到合适的袜子。想知道它们应该有多绿和多长时间。这两个属性之间再次有一个滑块。如果在滑块的 50% 处，用户关心它们的绿色程度与它们的长度一样多。如果滑块更接近绿色端，则用户对袜子的绿色程度更感兴趣，但也希望袜子长一些。

我不知道要使用什么软件或如何实现这一点。

我正在尝试完成一些真/假问题。当我用 true 回答其中许多时，我开始担心... 请假设所有图表都是无向的并且没有不同的权重。负重应该没问题。

Qa) 如果 G 有一个具有唯一最重边 e 的循环，则 e 不能是任何 MST 的一部分。

我的回答是真的。例如，我们有一个包含节点 A、B、C、D、E 的图。

如您所见，BCD 是一个循环。我的论点是，既然它是一个循环，我们总是可以通过采取其他路线来避免独特的最重边缘 CD。因此这是真的。我的论点是否合理（足够）？

Qb) Dijkstra 算法计算的最短路径树必然是 MST。

我的回答是对的，但我的直觉告诉我出了点问题。嗯... Disjkstra 和 Prim 都是贪心算法。他们每次都选择最轻的加权边缘。是否存在最短路径树不是最小生成树的情况？我实际上很难理解这两个家伙之间的区别。

Qc) Prim 的算法适用于负加权边缘。

我的回答是真的。因为这就是 wiki 所说的...... :p 该算法是关于在所有边中找到成本最低的边。所以负加权边缘应该没关系，是吗？但是负加权循环呢？

Qd) 如果 G 有一个具有唯一最轻边 e 的循环，则 e 必须是每个 MST 的一部分。

我的回答是真的。我们必须访问 MST 中的所有节点。例如，在长度为 3 的循环中，我们总是可以用 2 步遍历该循环中的所有节点。如果有独特的最轻边缘，我们肯定会在 MST 中选择它。

我的主张合理吗？也许他们还不够？那么有什么建议吗？

我有一个来自数据库的记录数组（尽管数据库与这个问题无关——它最终变成了一个“行”数组，每一行都是一个数组，其中字符串键对应于字段名）。例如：

我想要做的是打乱这个数组，但以某种方式给具有更新“创建”时间戳的项目更多“权重”。随机性不一定是完美的，确切的重量对我来说并不重要。换句话说，如果有一些快速简单的技术对人类来说有点随机，但在数学上不是随机的，我可以接受。此外，如果这对于时间戳的“无限连续体”来说不容易做到，那么我可以将每条记录分配给一天或一周，并根据它们所在的日期或星期进行加权.

一种相对快速/高效的技术更可取，因为这种随机化将发生在我网站中某个页面的每个页面加载时（但如果无法有效地做到这一点，我可以定期运行它并缓存结果）。

我们正在使用 Solr 1.4 为用户查询生成结果。结果是从包含大约 500k 个文档的索引中获取的。索引不断更新新文档，旧文档过期。

结果页面是按相关性（分数）排序的文档列表，由 solr 根据用户的查询自动计算。每个文档都属于一个类别（例如工程、金融、管理、数学等），类别 ID 由 Solr 存储和索引。

我们想要实现的是根据相关性对文档进行排序，但也要以某种方式加权，以便至少结果的第一页（10,20 或 50）包含来自尽可能多类别的文档和尽可能少的文档同一类别是连续的。

我们进行了很多搜索，但没有设法提出任何可行的方案。

非常感谢您的任何想法。GK

我对类似的主题进行了搜索，但是对于我的理解和理解水平而言，答案太模糊了，而且我认为它们对我的问题不够具体。

类似的线程：
树（有向无环图）实现
表示一个DAG（有向无环图）

问题：

我已经格式化了一个文本文件，其中包含以下格式的数据...
示例数据集：
GO:0000109#is_a: GO:0000110#is_a: GO:0000111#is_a: GO:0000112#is_a: GO:0000113#is_a: GO :0070312#is_a: GO:0070522#is_a: GO:0070912#is_a: GO:0070913#is_a: GO:0071942#part_of: GO:0008622
GO:0000112#part_of: GO:0000442
GO:00000168#is_a: GO: #is_a: GO:0034967#is_a: GO:0070210#is_a: GO:0070211#is_a: GO:0070822#is_a: GO:0070823#is_a: GO:0070824
GO:0000120#is_a: GO:0000500#is_a: GO: 0005668#is_a: GO:0070860
GO:0000123#is_a: GO:0005671#is_a: GO:0043189#is_a: GO:0070461#is_a: GO:0070775#is_a: GO:0072487
GO:0000126#is_a: GO#0 is_a: GO:0034733
GO:0000127#part_of: GO:0034734#part_of: GO:0034735
GO:0000133#is_a: GO:0031560#is_a: GO:0031561#is_a: GO:0031562#is_a: GO:0031563#part_of: GO:0031500
GO:0000137#part_of: GO:0000136

我希望从这些数据中构建一个加权的有向 DAG（上面只是一个片段）。106kb的整个数据集在这里：Source

--------------------------------------------------

逐行考虑，每行数据说明如下... 以
第一行为例：
GO:0000109#is_a: GO:0000110#is_a: GO:0000111#is_a: GO:0000112#is_a : GO:0000113#is_a: GO:0070312#is_a: GO:0070522#is_a: GO:0070912#is_a: GO:0070913#is_a: GO:0071942#part_of: GO:0008622

'#' 是行数据的分隔符/标记器。
第一项，GO:0000109 是节点名称。
is_a: GO:xxxxxxx OR part_of: GO:xxxxxxx 后面的项是连接到 GO:0000109 的节点。
如数据集中所述，随后的一些术语也有联系。
当为is_a时，边的权重为0.8。
为part_of时，边的权重为0.6。

--------------------------------------------------

我有关于 DAG 的 Google-d，我理解这个概念。但是，我仍然不知道如何将其放入代码中。我正在使用 Java。
据我了解，图通常由节点和弧组成。这个图是否需要邻接表来确定连接的方向？如果是这样，我不确定如何结合图形和邻接表来相互通信。构建完图后，我的次要目标是从根节点中找出每个节点的度数。数据集中有一个根节点。

为了说明，我画了下面第一行数据的连接示例：
图片链接

我希望你们能理解我在这里想要达到的目标。感谢您浏览我的问题。:)

我有 SQL 表，其中有 column 和 Probability 。我想从中随机选择一行，但我想给更多的机会来获得更多的加权概率。我可以这样做

但是概率之间的差异太大了，所以它给最高概率提供了更多的机会。就像在选择 74 次该值之后，它再次选择另一个值大约 74 次。我想减少这个。就像我想要 3-4 次对它，而不是其他和所有。我正在考虑将 Range 赋予 Probabilies.It Like

我该怎么做。我需要创建函数吗？还有其他方法可以实现吗？我是 neewby。任何帮助都会得到帮助。谢谢

编辑： 我有我的问题的解决方案。我有一个问题 。如果我有如下表格。

我能得到吗？

每次我想用现有的增加价值。有什么办法吗？

更新： 终于在 3 小时后得到解决方案，我只是取我的概率的平方根，这样我就可以缩小它们的差异。就像我添加列

我有一个程序，我正在使用跟踪各种事情的成功collections.Counter-每件事的成功都会增加相应的计数器：

然后，对于未来的测试，我想偏向那些产生最大成功的东西。Counter.elements()对此似乎很理想，因为它返回重复次数等于计数的元素（以任意顺序）。所以我想我可以这样做：

但是不，这会引发TypeError: object of type 'itertools.chain' has no len()。好的，所以random.choice不能使用 iterators。但是，在这种情况下，长度是已知的（或可知的）——它是sum(scoreboard.values()).

我知道遍历未知长度列表并随机选择一个元素的基本算法，但我怀疑还有更优雅的东西。我应该在这里做什么？

让我们假设：

List<element>哪个元素是：

我想要实现的是，通过权重随机选择一个元素。例如：

所以

• 被选中的几率Element_1是 100/(100+50+200)=28.57%
• 被选中的几率Element_2是 50/(100+50+200)=14.29%
• 被选中的几率Element_3是 200/(100+50+200)=57.14%

我知道我可以创建一个循环，计算总数等...

我想学习的是，Linq 在一行（或尽可能短）中执行此操作的最佳方法是什么，谢谢。

更新

我在下面找到了答案。我学到的第一件事是：Linq 不是魔法，它比精心设计的循环慢。

所以我的问题变成了按重量找到一个随机元素，（没有尽可能短的东西:)

我正在尝试为应用程序提出加权算法。在应用程序中，不同元素的可用空间有限。一旦所有空间都被占用，算法应该选择要删除的最佳元素，以便为新元素腾出空间。

有不同的属性会影响这个决定。例如：

• T：自上次访问以来的时间。（最好更换一段时间未访问的东西。）
• N：访问次数。（最好更换没有多次访问的东西。）
• R：为新元素腾出空间而需要移除的元素数量。（最好替换最少数量的元素。理想情况下，这还应该考虑到每个被替换元素的 T 和 N 属性。）

我有两个问题：

1. 计算出给这些属性中的每一个赋予多少权重。
2. 弄清楚如何计算元素的权重。

（1）我意识到为这样的事情提出权重是非常主观的，但我希望有一种标准方法或其他东西可以帮助我决定赋予每个属性多少权重。例如，我在想一种方法可能是提出一组两个样本元素，然后手动比较两者并决定最终应该选择哪一个。这是一个例子：

元素 A：N = 5，T = 2 小时前。
元素 B：N = 4，T = 10 分钟前。

在这个例子中，我可能希望 A 成为被选择替换的元素，因为虽然它被访问了一次，但与 B 相比，它已经很长时间没有被访问了。这种方法似乎需要很多时间，并且会涉及做出很多艰难的、主观的决定。此外，最后得出最终的权重可能并非易事。

我想出的另一种方法是任意选择不同属性的权重，然后使用该应用程序一段时间。如果我发现算法有任何明显错误，我可以进入并稍微修改权重。这基本上是一种“猜测和检查”的方法。

这两种方法似乎都不是很好，我希望有更好的解决方案。

(2) 一旦我计算出重量，我不确定哪种方法最适合计算重量。我应该添加所有内容吗？（在这些示例中，我假设具有最高元素的元素replacementWeight应该是要被替换的元素。）

或乘以一切？

不使用常量作为权重怎么办？例如，确定“时间”(T) 可能很重要，但是一旦经过了特定的时间量，它就不会产生太大的影响。本质上，我会将所有内容归为“已经过去了很多时间”的垃圾箱。（例如，即使 8 小时和 7 小时两者之间有一个小时的差异，这种差异可能不如 1 分钟和 5 分钟之间的差异那么显着，因为这两个时间要近得多。）（或另一个示例：替换 (R ) 1 或 2 个元素很好，但是当我开始需要替换 5 或 6 个时，这应该被严重加权......因此它不应该是线性的。）

显然（1）和（2）是密切相关的，这就是为什么我希望有更好的方法来提出这种算法。