Question

你正在计划一个开放式书籍测试的团体座位安排，给出来自不同学校的学生名单V参与。假设直接或间接相互了解的学生与坐在一起的未知人相比可能会更多地欺骗。假设你还有一个查找表T，其中T [u]为你？ V是你知道的学生名单。如果你知道v，那么v知道你。您需要安排座位，以便桌上的任何学生都不会直接或通过坐在同一张桌子上的其他学生知道坐在同一张桌子上的任何其他学生。例如，如果x知道y，并且y知道z，则x，y，z可以位于同一个表中。描述一种有效的算法，给定V和T，返回达到此要求所需的最小表数。分析算法的运行时间。

Answer 1

将学生关系带到两个边缘，得到一个图表：

a - e - j
      \ q

b - d
  \ t

r - w - x - y - z

同一子图中的所有学生必须分开，因此最大组中每个学生的最小表数为1 - 在此示例中，最大子图为r-w-x-y-z，因此有5个表。

未经测试的Python伪代码：

# Given a student list
# a b c d e f j q r t w x y z

# start a chain at a
# a b c d e f j q r t w x y z
# .

# visit friends of a
# a b c d e f j q r t w x y z
# .       .

# visit friends of a's friends
# a b c d e f j q r t w x y z
# .       .   . .

# if e and j are friends, don't double-count

# Get a count of 4 starting at person a
# Repeat for all students
# Report the longest chain.

friendCounts = {}

def countFriendsOf(T, student, friendTracker, moreSteps=2):
    friendTracker[student] = True #quicker to set it regardless,
                                  #than to check if it's set
    if not moreSteps:
        return

    for friend in T[student]:
        countFriendsOf(T, friend, friendTracker, moreSteps - 1)

    return friendTracker


for u in V:
    friends = countFriendsOf(T, u, friendTracker={})
    friendCounts[u] = (len(friends), friends)

results = sorted(friendCounts.items(), key=lambda x: x[1][0], reverse=True)
(student, (friendCount, friends)) = results[0]

print "The smallest number of tables is:", friendCount
print "Mandated by the friend group of:", student
print

from pprint import pprint
pprint(friends)

分析算法的运行时间。

分析：任何比snowglobe更强大的计算机都可以。

不确定。最佳案例：学生没有朋友 - 就学生人数而言是线性的。上）。最坏的情况：每个学生都是与其他学生的朋友，然后它会为每个学生查找每个学生，所以O（n ^ 3）。 EW。

它更像O（n ^ 2），直到我意识到版本肯定是错误的。

这个版本只是不是绝对错误的，它并非绝对正确。

我甚至没有将其作为递归解决方案启动，它最终就是这样。 friendTracker的使用是一个讨厌的副作用，递归调用不是尾递归可优化的。不是说Python做到了，

用于查找打开的书籍测试的组座位安排的算法

1 个答案: