1つの制約が不足している制約充足問題

私は大学の研究室の実習チューターで、昨年の学生のコメントに基づいて、私たちの上司と私はそれらに対処したいと思っていました。私の上司はCスクリプトの記述を選択し、問題を解決するためにpython（python-constraint）を選択しました。

お知らせ

6つのセッションがあります
4つの役割があります
6つのプラクティスがあります
生徒は32人です
チームごとに4人の学生がいます

問題点：

4つの異なるセッションの4つの練習で、各生徒を4つの役割に割り当てます。

制約：

学生は一度役割を果たすべきです
学生は6つのうち4つの異なる練習をする必要があります
学生はセッションごとに1つの練習のみを行う必要があります
学生は同じ仲間に一度だけ会うべきです

テンプレート：

これは私が学生に感じるテンプレートです。各チームは4人の学生で構成され、ポジション[0、1、2、または3]はそれらに割り当てられたロールです。使用可能な各位置には、1から128までの番号が付けられています

[# Semester
   [ # Session
     [ # Practice/Team
1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12],
  [13, 14, 15, 16],
  [17, 18, 19, 20],
  [21, 22, 23, 24]],
 [[25, 26, 27, 28],
  [29, 30, 31, 32],
  [33, 34, 35, 36],
  [37, 38, 39, 40],
  [41, 42, 43, 44],
  [45, 46, 47, 48]],
 [[49, 50, 51, 52],
  [53, 54, 55, 56],
  [57, 58, 59, 60],
  [61, 62, 63, 64],
  [65, 66, 67, 68],
  [69, 70, 71, 72]],
 [[73, 74, 75, 76],
  [77, 78, 79, 80],
  [81, 82, 83, 84],
  [85, 86, 87, 88],
  [89, 90, 91, 92],
  [93, 94, 95, 96]],
 [[97, 98, 99, 100],
  [101, 102, 103, 104],
  [105, 106, 107, 108],
  [109, 110, 111, 112]],
 [[113, 114, 115, 116],
  [117, 118, 119, 120],
  [121, 122, 123, 124],
  [125, 126, 127, 128]]]

言い換えると：

これはセッションです：

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

それらのチームは同じことをします：

[
    [1, 2, 3, 4],
    [25, 26, 27, 28],
    [49, 50, 51, 52],
    [73, 74, 75, 76],
    [97, 98, 99, 100],
    [113, 114, 115, 116]
]

それらの立場は同じ役割を果たします：

[
   1,
   5,
   9,
   13,
   17,
   21,
   25,
   ...
]

これまでのところ：

python-constraintを使用して、最初の3つの制約を検証することができました。

Valid solution : False
            - sessions  : [True, True, True, True, True, True]
            - practices : [True, True, True, True, True, True]
            - roles     : [True, True, True, True]
            - teams     : [False, False, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True, False, False, False, False, False]

興味深いかもしれない人のために、私は単にこのようにします：

条件ごとにAllDifferentConstraintを使用します。たとえば、1つのセッションで次のようにします。

problem.addConstraint(AllDifferentConstraint(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])

私はチームを拘束する方法を見つけることができません、全体に対する私の最後の試みsemesterはこれでした：

    def team_constraint(self, *semester):
        students = defaultdict(list)

        # get back each teams based on the format [# Semester [ #Session [# Practice/Team ... 
        teams = [list(semester[i:i+4]) for i in range(0, len(semester), 4)]

        # Update Students dict with all mate they work with
        for team in teams:
            for student in team:
                students[student] += [s for s in team if s != student]

        # Compute for each student if they meet someone more than once 
        dupli = []
        for student, mate in students.items():
            dupli.append(len(mate) - len(set(mate)))

        # Loosly constraint, if a student meet somone 0 or one time it's find
        if max(dupli) >= 2:
            print("Mate encounter more than one time", dupli, min(dupli) ,max(dupli))
            return False
        pprint(students)
        return True

質問：

チームの状況に合わせてやりたいことはできますか？つまり、各生徒に12人の仲間を割り当てることが可能であり、各生徒が同じ仲間と一度だけ会うことができるかどうかはわかりません。
チームの制約について、より高性能なアルゴリズムを見逃しましたか？
私がフォローできる拳はありますか？

python algorithm python-constraint

— フロリアン・バーナード
ソース

なぜ最後の2つのセッションセットが他のセッションセット(4, 4)の(4, 6)ようにではなく、形になるのですか

— r.ook

このコースは1単位のみで多くの仕事を必要とするという事実と一致するため、上司は学生が4つの練習のみを行うべきだと考えています。だから私たちはこれを思い付きました、私たちは32人の学生を持っています、それは4つの練習（128ポジション）をするべきです。

— Florian Bernard

私はランダムで力ずくのアプローチを試みます。セッション1を選択する順列のようにしてください：ロール1生徒1練習1 ... 2から4と同じです。次に、6セッションごとに増分し、すでに会った生徒を破棄します。ランダムでも同じです。なぜ128ポジションで、セッションごとに32の学生を使用しないのですか？多分stackMathにあるかもしれませんが、これが可能な組み合わせ/順列であるかどうかを教えてくれます

— Cristo

現在、ブルートフォース方式の仕事があり、上司はそのスクリプトとその仕事で本当に私に戻ってきました。しかし、私はまだpythonを使いたくありません。

— Florian Bernard

回答:

主な質問は次のようなもので答えられます...

   def person_works_with_different():
        # over all the sessions, each person works with each other person no more than once.
        # 'works with' means in 'same session team'
        for p in all_people:
            buddy_constraint = []
            for s in all_sessions:
                for g in all_teams:
                    p_list = [pv[k] for k in filter(lambda i: i[P] == p and i[S] == s and i[G] == g, pv)]
                    for o in all_people:
                        if o != p:  # other is not person
                            o_list = [self.pv[k] for k in filter(lambda i: i[self.P] == o and i[self.S] == s and i[self.G] == g, self.pv)]
                            tmp = model.NewBoolVar('')
                            buddy_constraint.append(tmp)
                            model.Add(sum(o_list) == sum(p_list)).OnlyEnforceIf(tmp)
                            # tmp is set only if o and p are in the same session/team
            # The number of times a student gets to take part is the number of roles.
            # The size of the group controlled by the number of roles
            model.Add(sum(buddy_constraint) = all_roles * (all_roles - 1))

追加された編集

私は昨日あなたの問題をもう一度見ました-（確かに私は現時点で多くの仕事をしているので長くはありません）、そして...

まず、あなたの「チーム」エンティティは、私が「アクション」エンティティと呼んでいるものであり、振り返ってみると、「チーム」（または「グループ」）の方がいい言葉だと思います。

それでも制約が難しい場合は、それらを解除して、個別に作業することをお勧めします。特に、チーム/個人/セッションの制約の後に、役割/タスクの制約が続きます。

/追加された編集

team: a gathering of 4 persons during a session
person (32): a participant of a team
session (6): time: eg, 8am -10am
role (4): what responsibility a person has in an action
task (6): type of action

A person does:
 0..1 action per session-group
 1 role per action
 1 task per action
 0..1 of each task
 1 of each role in an action
 4 persons in an action

A person meets each other person 0..1 times
An action requires exactly 4 people

私は最近同様の問題を抱えていて、結局ORツールに目を向けました。https://developers.google.com/optimization/cp/cp_solver

特に、ナーススケジューリングの問題を確認してください：https : //developers.google.com/optimization/scheduling/employee_scheduling#nurse_scheduling

とにかく、問題はそれほど複雑ではないので、ソルバーを使用するのはやりすぎかもしれません。

同様に、この種の問題については、ネストされたリストではなく、タプルキーのdictを使用して変数を保持する方が良い場合があります。

{チーム、セッション、人物：BoolVar}

主な理由は、フィルターを使用して制約を適用できるためです。これは、ネストされたリスト操作を実行する必要がある場合よりもはるかに簡単です。たとえば、個人/チームに制約を適用することができます（ここで、個人はインデックス2、チームはインデックスです） 0）：

for p in all_persons:
    for t in all_teams:
        stuff = [b_vars[k] for k in filter(lambda i: i[2] == p and i[0] == t, b_vars)]
        model.Add(sum(stuff) == 4)  # persons per team == 4

— コンチョグ
ソース

ありがとう、forループはどういう意味p for p in all_peopleですか？

— Florian Bernard

うん、ごめんなさい！私は自分の名前をあなたのモデルに「翻訳」しましたが、仕事中だったので少し速かったです。

— Konchog

また、メーリングリストはOR-toolsで本当に協力的です。問題のモデリングについてサポートが必要な場合は、コードの例を示したり、グループ/依存関係の制約を設定する方法についてのすばらしいアイデアを提供したりします

— Konchog

申し訳ありませんが、あなたの頭の解決策をたどることは困難です。そして、P、S、G変数は何ですか？pvとは？ご協力いただきありがとうございます。

— Florian Bernard

順列アルゴリズムのアイデアだけですが、反復ごとに各学生の1つまたは各セッションの1つに焦点を当てることができます。

Session 1:
Roles
1,2,3,4
Students
1,2,3,4

(Note is 1st permutation 1234)

Sess 2 for student 1
Roles 1234
Students 5,1,7,6

ここでは、学生2がセッション1で学生1の代わりになり、次のように続きます

Roles 1234
St 2,5,6,7

学生1 S3 R 1234 St 10,9,1,8に進みます

S4
R 1234
St 11,12,13,1

最後に、学生1の相互作用を削除します。次の反復の順列の場合と同様に、現在を削除します。

ルービックキューブのようなものです。

これをコーディングしたり、このアルゴでいくつかのコードを知っている場合は、私に知らせてください。

多分itertoolsの順列で

セッションが>プラクティスよりも多いことは、その数とは関係ありません。あなたがローテーションのためのより多くの部屋またはより多くの部屋を使い果たすとき、より多くをとるためにちょうどいくつかのプール。たぶん、最初に4セッション=プラクティスを目指して問題を単純化できますか？

— クリスト
ソース