blocks|key|819621|text|我认为Round-robin+algorithm会做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|819622|将剩下的学生添加到第二个组中，就完成了。|819623|First+run
1+++2+++3+++4+++5+++6+++7+++8+++9+++10++11++12
23++22++21++20++19++18++17++16++15++14++13

Second+run
1+++23++2+++3+++4+++5+++6+++7+++8+++9+++10++11++
22++21++20++19++18++17++16++15++14++13++12|code-block|syntax|javascript|819624|..。|819625|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Round-robin_tournament#Scheduling_algorithm^0|3|L|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<a href="http://en.wikipedia.org/wiki/Round-robin_tournament#Scheduling_algorithm" rel="noreferrer">Round-robin algorithm</a> will do the trick i think.

Add the remaining student to the second group and you are done.

<pre><code>First run
1 2 3 4 5 6 7 8 9 10 11 12
23 22 21 20 19 18 17 16 15 14 13

Second run
1 23 2 3 4 5 6 7 8 9 10 11 
22 21 20 19 18 17 16 15 14 13 12
</code></pre>

...

blocks|key|5950015|text|另一种可能是graph+matching，需要14个不同的图匹配。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5950016|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Matching_%2528graph_theory%2529^0|6|E|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Another possibility might be <a href="http://en.wikipedia.org/wiki/Matching_%28graph_theory%29" rel="nofollow">graph matching</a>, 14 distinct graph matchings would be needed.

blocks|key|5949823|text|试着用约束来描述这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5949824|然后将约束传递给像ECLiPSe+(而不是Eclipse)这样的工具，请参阅http://eclipseclp.org/。|offset|length|5949825|实际上，您的问题似乎与该站点(http://eclipseclp.org/examples/golf.ecl.txt)上的高尔夫示例类似。|5949826|entityMap|0|LINK|mutability|MUTABLE|url|http://eclipseclp.org/|1|http://eclipseclp.org/examples/golf.ecl.txt^0|0|12|M|0|0|F|17|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

Try to describe the problem in terms of constraints.

Then pass the constraints to a tool like ECLiPSe (not Eclipse), see <a href="http://eclipseclp.org/" rel="nofollow">http://eclipseclp.org/</a>.

In fact, your problem seems similar to that of the Golf example on that site (<a href="http://eclipseclp.org/examples/golf.ecl.txt" rel="nofollow">http://eclipseclp.org/examples/golf.ecl.txt</a>).

blocks|key|2115382|text|首先为所有其他学生都在其中的每个学生设置一个集合(可能是映射到学生的位集，以减少内存消耗)。迭代14次，每次选择11名学生(对于您将形成的11个小组)，您将为其选择合作伙伴。对于每个学生，选择一个他们还没有在一个小组中的伙伴。对于这11个学生中的一个，随机选择第二个伙伴，但确保没有一个学生的剩余伙伴少于剩下的迭代。对于每个拾取，调整集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2115383|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Start off with a set (maybe a bitset mapping to students for less memory consumption) for each student that has all other students in it. Iterate 14 times, each time picking 11 students (for the 11 groups you will form) for whom you will pick partners. For each student, pick a partner they haven't been in a group with yet. For one random student of those 11, pick a second partner, but make sure no student has less remaining partners than there are iterations left. For every pick, adjust the sets.

blocks|key|822647|text|以下是Haskell中的一个示例，它将生成14个非重复的11对组合。值'+pairs‘是从1到23的所有对的组合(例如，1,2，1,3等)。然后，程序构建列表，其中每个列表是11对的14个列表(从值“pairs”中选择)，使得在11对的列表中没有重复的对，也没有重复的单个数字。这取决于你，只要你认为合适，就可以在每周安排缺失的最后一个学生。(在开始输出结果之前，它花了大约三分钟的时间进行计算)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|822648|import+Data.List
import+Control.Monad

pairs+=+nubBy+(\x+y+->+reverse+x+==+y)+
++++++++$+filter+(\x+->+length+(nub+x)+==+length+x)+$+replicateM+2+[1..23]

solve+=+solve'+[]+where
++solve'+results+=
++++if+length+results+==+14
+++++++then+return+results
+++++++else+solveOne+[]+where
+++++++++solveOne+result+=
+++++++++++if+length+result+==+11
++++++++++++++then+solve'+(result:results)
++++++++++++++else+do+next+<-+pairs
++++++++++++++++++++++guard+(notElem+(head+next)+result'+
+++++++++++++++++++++++++++++&&+notElem+(last+next)+result'
+++++++++++++++++++++++++++++&&+notElem+next+results')
++++++++++++++++++++++solveOne+(next:result)
+++++++++++++++++++++++++where+result'+=+concat+result
+++++++++++++++++++++++++++++++results'+=+concat+results|code-block|syntax|javascript|822649|输出中的一个示例：|822650|[[[12,17],[10,19],[9,18],[8,22],[7,21],[6,23],[5,11],[4,14],[3,13],[2,16],[1,15]],
[[12,18],[11,19],[9,17],[8,21],[7,23],[6,22],[5,10],[4,15],[3,16],[2,13],[1,14]],
[[12,19],[11,18],[10,17],[8,23],[7,22],[6,21],[5,9],[4,16],[3,15],[2,14],[1,13]],
[[15,23],[14,22],[13,17],[8,18],[7,19],[6,20],[5,16],[4,9],[3,10],[2,11],[1,12]],
[[16,23],[14,21],[13,18],[8,17],[7,20],[6,19],[5,15],[4,10],[3,9],[2,12],[1,11]],
[[16,21],[15,22],[13,19],[8,20],[7,17],[6,18],[5,14],[4,11],[3,12],[2,9],[1,10]],
[[16,22],[15,21],[14,20],[8,19],[7,18],[6,17],[5,13],[4,12],[3,11],[2,10],[1,9]],
[[20,21],[19,22],[18,23],[12,13],[11,14],[10,15],[9,16],[4,5],[3,6],[2,7],[1,8]],
[[20,22],[19,21],[17,23],[12,14],[11,13],[10,16],[9,15],[4,6],[3,5],[2,8],[1,7]],
[[20,23],[18,21],[17,22],[12,15],[11,16],[10,13],[9,14],[4,7],[3,8],[2,5],[1,6]],
[[19,23],[18,22],[17,21],[12,16],[11,15],[10,14],[9,13],[4,8],[3,7],[2,6],[1,5]],
[[22,23],[18,19],[17,20],[14,15],[13,16],[10,11],[9,12],[6,7],[5,8],[2,3],[1,4]],
[[21,23],[18,20],[17,19],[14,16],[13,15],[10,12],[9,11],[6,8],[5,7],[2,4],[1,3]],
[[21,22],[19,20],[17,18],[15,16],[13,14],[11,12],[9,10],[7,8],[5,6],[3,4],[1,2]]]|822651|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's an example in Haskell that will produce groups of 14 non-repeating 11-pair-combinations. The value 'pairs' is all combinations of pairs from 1 to 23 (e.g., [1,2], [1,3] etc.). Then the program builds lists where each list is 14 lists of 11 pairs (choosing from the value 'pairs') such that no pair is repeated and no single number is repeated in one list of 11 pairs. It's up to you to simply place the missing last student for each week as you see fit. (It took about three minutes to calculate before it started to output results):

<pre><code>import Data.List
import Control.Monad

pairs = nubBy (\x y -&gt; reverse x == y) 
 $ filter (\x -&gt; length (nub x) == length x) $ replicateM 2 [1..23]

solve = solve' [] where
 solve' results =
 if length results == 14
 then return results
 else solveOne [] where
 solveOne result =
 if length result == 11
 then solve' (result:results)
 else do next &lt;- pairs
 guard (notElem (head next) result' 
 &amp;&amp; notElem (last next) result'
 &amp;&amp; notElem next results')
 solveOne (next:result)
 where result' = concat result
 results' = concat results
</code></pre>

One sample from the output:

<pre><code>[[[12,17],[10,19],[9,18],[8,22],[7,21],[6,23],[5,11],[4,14],[3,13],[2,16],[1,15]],
[[12,18],[11,19],[9,17],[8,21],[7,23],[6,22],[5,10],[4,15],[3,16],[2,13],[1,14]],
[[12,19],[11,18],[10,17],[8,23],[7,22],[6,21],[5,9],[4,16],[3,15],[2,14],[1,13]],
[[15,23],[14,22],[13,17],[8,18],[7,19],[6,20],[5,16],[4,9],[3,10],[2,11],[1,12]],
[[16,23],[14,21],[13,18],[8,17],[7,20],[6,19],[5,15],[4,10],[3,9],[2,12],[1,11]],
[[16,21],[15,22],[13,19],[8,20],[7,17],[6,18],[5,14],[4,11],[3,12],[2,9],[1,10]],
[[16,22],[15,21],[14,20],[8,19],[7,18],[6,17],[5,13],[4,12],[3,11],[2,10],[1,9]],
[[20,21],[19,22],[18,23],[12,13],[11,14],[10,15],[9,16],[4,5],[3,6],[2,7],[1,8]],
[[20,22],[19,21],[17,23],[12,14],[11,13],[10,16],[9,15],[4,6],[3,5],[2,8],[1,7]],
[[20,23],[18,21],[17,22],[12,15],[11,16],[10,13],[9,14],[4,7],[3,8],[2,5],[1,6]],
[[19,23],[18,22],[17,21],[12,16],[11,15],[10,14],[9,13],[4,8],[3,7],[2,6],[1,5]],
[[22,23],[18,19],[17,20],[14,15],[13,16],[10,11],[9,12],[6,7],[5,8],[2,3],[1,4]],
[[21,23],[18,20],[17,19],[14,16],[13,15],[10,12],[9,11],[6,8],[5,7],[2,4],[1,3]],
[[21,22],[19,20],[17,18],[15,16],[13,14],[11,12],[9,10],[7,8],[5,6],[3,4],[1,2]]]
</code></pre>

A friend of mine who who is a teacher has 23 students in a class. They want an algorithm that assigns students in groups of 2 and one group of 3 (handle the odd number of students) across 14 weeks such that no two pairs repeat across the 14 weeks (a pair is assigned to one week).

A brute force approach would be too inefficient, so I was thinking of other approaches, matrix representation sounds appealing, and graph theory. Does anyone have any ideas? The problems that I could find deal only with 1 week and <a href="https://stackoverflow.com/questions/12586587/combinatorial-algorithm-for-assigning-people-to-groups">this answer</a> I could quite figure out.

Weekly group assignment algorithm

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我的一个老师朋友，一个班级有23名学生。他们想要一种算法，在14周内将学生分配到2人一组和3人一组(处理奇数数量的学生)，这样在14周内没有两对重复(一对分配到一周)。蛮力方法的效率太低了，所以我在考虑其他方法，矩阵表示听起来很吸引人，还有图论。有谁有什么想法吗？我可以找到的问题只能处理一周和，我可以很好地解决。

问每周分组分配算法
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问每周分组分配算法EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问每周分组分配算法
EN