これはシーケンスA054261です

$n$素数封じ込め番号番目は、第含ま最小数である$n$のサブストリングとして素数を。たとえば、番号$235$は、サブストリングとして最初の3つの素数を含む最小の番号であり、3番目の素数格納番号になります。

最初の4つの素数封じ込め番号があることを把握することは簡単です$2$、$23$、$235$および$2357$、しかし、それはより面白いです。次の素数は11であるため、次の素数包含番号は$235711$でが、プロパティで最小の数として定義されているため、$112357$です。

ただし、11を超えると実際の課題が発生します。次の主な包含番号は$113257$です。この番号では、部分文字列11と 13が重複していることに注意してください。番号3も番号と重複しています13。

次の番号は、その前にある番号のすべての基準を満たし、さらに1つのサブストリングを持つ必要があるため、このシーケンスが増加していることを証明するのは簡単です。ただし、n=10との結果が示すように、シーケンスは厳密には増加していませんn=11。

チャレンジ

あなたの目標は、できるだけ多くの素数の収容番号を見つけることです。プログラムは、2から始まり上に向かって、順序付けられた形式で出力する必要があります。

ルール

1. あなたは許可されていますハードコード素数に。
2. 素数包含番号をハードコーディングすることはできません（2唯一の例外）、またはチャレンジを簡単にするマジック番号。どうぞよろしくお願いします。
3. 任意の言語を使用できます。コードを実行する環境を準備するためのコマンドのリストを含めてください。
4. CPUとGPUの両方を自由に使用でき、マルチスレッドを使用できます。

得点

公式の採点は私のラップトップ（dell XPS 9560）から行われます。あなたの目標は、5分以内にできるだけ多くの素数の包含番号を生成することです。

スペック

• 2.8GHz Intel Core i7-7700HQ（3.8GHzブースト）4コア、8スレッド。
• 16GB 2400MHz DDR4 RAM
• NVIDIA GTX 1050
• Linux Mint 18.3 64-ビット

これまでに見つかった数字と、最後に追加された素数：

 1 =>                                                       2 (  2)
 2 =>                                                      23 (  3)
 3 =>                                                     235 (  5)
 4 =>                                                    2357 (  7)
 5 =>                                                  112357 ( 11)
 6 =>                                                  113257 ( 13)
 7 =>                                                 1131725 ( 17)
 8 =>                                               113171925 ( 19)
 9 =>                                              1131719235 ( 23)
10 =>                                            113171923295 ( 29)
11 =>                                            113171923295 ( 31)
12 =>                                           1131719237295 ( 37)
13 =>                                          11317237294195 ( 41)
14 =>                                        1131723294194375 ( 43)
15 =>                                      113172329419437475 ( 47)
16 =>                                     1131723294194347537 ( 53)
17 =>                                   113172329419434753759 ( 59)
18 =>                                  2311329417434753759619 ( 61)
19 =>                                231132941743475375961967 ( 67)
20 =>                               2311294134347175375961967 ( 71)
21 =>                              23112941343471735375961967 ( 73)
22 =>                             231129413434717353759619679 ( 79)
23 =>                           23112941343471735359619678379 ( 83)
24 =>                         2311294134347173535961967837989 ( 89)
25 =>                        23112941343471735359619678378979 ( 97)
26 =>                      2310112941343471735359619678378979 (101)
27 =>                    231010329411343471735359619678378979 (103)
28 =>                 101031071132329417343475359619678378979 (107)
29 =>              101031071091132329417343475359619678378979 (109)
30 =>              101031071091132329417343475359619678378979 (113)
31 =>           101031071091131272329417343475359619678378979 (127)
32 =>           101031071091131272329417343475359619678378979 (131)
33 =>         10103107109113127137232941734347535961967838979 (137)
34 =>      10103107109113127137139232941734347535961967838979 (139)
35 =>   10103107109113127137139149232941734347535961967838979 (149)
36 => 1010310710911312713713914923294151734347535961967838979 (151)

このリストを拡張してくれたArdnauld、Ourous、およびjaphに感謝します。

そのノートn = 10とn = 11するので、同じ数である$113171923295$すべての数値が含まれている最小数である$[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$、それも含まれている$31$。

参考までに、上記のリストを生成するために書いた元のPythonスクリプトが約6分で最初の12の用語を計算するという事実を使用できます。

追加のルール

最初の結果が出てから、最高の結果が同じスコアになる可能性が高いことに気付きました。同点の場合、勝者は結果を生成する時間が最も短いものになります。2つ以上の回答が同じ速さで結果を出す場合、それは単に勝利につながります。

最後のメモ

5分間の実行時間は、公正なスコアリングを確保するためにのみ配置されます。OEISシーケンスをさらにプッシュできるかどうかを確認したいと思います（現在は17個の数字が含まれています）。Ourous 'コードを使用して、すべての数値を生成しました。n = 26が、コードをより長い期間実行する予定です。

スコアボード

1. Python 3 + Google ORツール：169
2. Scala：137（非公式）
3. Concorde TSPソルバー：84（非公式）
4. C ++（GCC）+ x86アセンブリ：62
5. クリーン：25
6. JavaScript（Node.js）：24

Python 3 + Google ORツール、295秒で169スコア（公式スコア）

使い方

他の素数に含まれる冗長な素数を破棄した後、各素数からそのサフィックスまでのエッジが距離ゼロで、各プレフィクスから各素数までのエッジが追加された桁数で定義される有向グラフを描画します。空のプレフィックスで始まり、各素数を通過し（必ずしも各プレフィックスまたはサフィックスを通過する必要はありません）、空のサフィックスで終わる、グラフの辞書編集上最初の最短パスを探します。

たとえば、最適なパスのエッジε→11→1→13→3→31→1→17→ε→19→ε→23→ε→29→ε→5→ε = n = 11出力文字列113171923295へ。

巡回セールスマン問題の単純な削減と比較して互いに直接ではなく、これらの追加の接尾辞/接頭辞ノードを介して素数を間接的に接続することにより、考慮する必要があるエッジの数が劇的に削減されているに注意してください。ただし、余分なノードを1回だけトラバースする必要がないため、これはTSPのインスタンスではなくなりました。

Google OR-ToolsのインクリメンタルCP-SAT制約ソルバーを使用して、最初にパスの全長を最小化し、次に追加された数字の各グループを順番に最小化します。ローカル制約のみでモデルを初期化します。各素数は1つの接尾辞の前に1つの接頭辞が続き、各接尾辞/接頭辞は同じ数の素数の前後にあります。結果のモデルには、切断されたサイクルが含まれる可能性があります。その場合、追加の接続制約を動的に追加し、ソルバーを再実行します。

コード

import multiprocessing
from ortools.sat.python import cp_model


def superstring(strings):
    def gen_prefixes(s):
        for i in range(len(s)):
            a = s[:i]
            if a in affixes:
                yield a

    def gen_suffixes(s):
        for i in range(1, len(s) + 1):
            a = s[i:]
            if a in affixes:
                yield a

    def solve():
        def find_string(s):
            found_strings.add(s)
            for i in range(1, len(s) + 1):
                a = s[i:]
                if (
                    a in affixes
                    and a not in found_affixes
                    and solver.Value(suffix[s, a])
                ):
                    found_affixes.add(a)
                    q.append(a)
                    break

        def cut(skip):
            model.AddBoolOr(
                skip
                + [
                    suffix[s, a]
                    for s in found_strings
                    for a in gen_suffixes(s)
                    if a not in found_affixes
                ]
                + [
                    prefix[a, s]
                    for s in unused_strings
                    if s not in found_strings
                    for a in gen_prefixes(s)
                    if a in found_affixes
                ]
            )
            model.AddBoolOr(
                skip
                + [
                    suffix[s, a]
                    for s in unused_strings
                    if s not in found_strings
                    for a in gen_suffixes(s)
                    if a in found_affixes
                ]
                + [
                    prefix[a, s]
                    for s in found_strings
                    for a in gen_prefixes(s)
                    if a not in found_affixes
                ]
            )

        def search():
            while q:
                a = q.pop()
                for s in prefixed[a]:
                    if (
                        s in unused_strings
                        and s not in found_strings
                        and solver.Value(prefix[a, s])
                    ):
                        find_string(s)
            return not (unused_strings - found_strings)

        while True:
            if solver.Solve(model) != cp_model.OPTIMAL:
                raise RuntimeError("Solve failed")

            found_strings = set()
            found_affixes = set()
            if part is None:
                found_affixes.add("")
                q = [""]
            else:
                part_ix = solver.Value(part)
                p, next_affix, next_string = parts[part_ix]
                q = []
                find_string(next_string)
            if search():
                break

            if part is not None:
                if part_ix not in partb:
                    partb[part_ix] = model.NewBoolVar("partb%s_%s" % (step, part_ix))
                    model.Add(part == part_ix).OnlyEnforceIf(partb[part_ix])
                    model.Add(part != part_ix).OnlyEnforceIf(partb[part_ix].Not())
                cut([partb[part_ix].Not()])
                if last_string is None:
                    found_affixes.add(next_affix)
                else:
                    find_string(last_string)
                q.append(next_affix)
                if search():
                    continue

            cut([])

    solver = cp_model.CpSolver()
    solver.parameters.num_search_workers = 4
    affixes = {s[:i] for s in strings for i in range(len(s))} & {
        s[i:] for s in strings for i in range(1, len(s) + 1)
    }
    prefixed = {}
    for s in strings:
        for a in gen_prefixes(s):
            prefixed.setdefault(a, []).append(s)
    suffixed = {}
    for s in strings:
        for a in gen_suffixes(s):
            suffixed.setdefault(a, []).append(s)
    unused_strings = set(strings)
    last_string = None
    part = None

    model = cp_model.CpModel()
    prefix = {
        (a, s): model.NewBoolVar("prefix_%s_%s" % (a, s))
        for a in affixes
        for s in prefixed[a]
    }
    suffix = {
        (s, a): model.NewBoolVar("suffix_%s_%s" % (s, a))
        for a in affixes
        for s in suffixed[a]
    }
    for s in strings:
        model.Add(sum(prefix[a, s] for a in gen_prefixes(s)) == 1)
        model.Add(sum(suffix[s, a] for a in gen_suffixes(s)) == 1)
    for a in affixes:
        model.Add(
            sum(suffix[s, a] for s in suffixed[a])
            == sum(prefix[a, s] for s in prefixed[a])
        )

    length = sum(prefix[a, s] * (len(s) - len(a)) for a in affixes for s in prefixed[a])
    model.Minimize(length)
    solve()
    model.Add(length == solver.Value(length))

    out = ""
    for step in range(len(strings)):
        in_parts = set()
        parts = []
        for a in [""] if last_string is None else gen_suffixes(last_string):
            for s in prefixed[a]:
                if s in unused_strings and s not in in_parts:
                    in_parts.add(s)
                    parts.append((s[len(a) :], a, s))
        parts.sort()
        part = model.NewIntVar(0, len(parts) - 1, "part%s" % step)
        partb = {}
        for part_ix, (p, a, s) in enumerate(parts):
            if last_string is not None:
                model.Add(part != part_ix).OnlyEnforceIf(suffix[last_string, a].Not())
            model.Add(part != part_ix).OnlyEnforceIf(prefix[a, s].Not())
        model.Minimize(part)
        solve()
        part_ix = solver.Value(part)
        model.Add(part == part_ix)
        p, a, last_string = parts[part_ix]
        unused_strings.remove(last_string)
        out += p
    return out


def gen_primes():
    yield 2
    n = 3
    d = {}
    for p in gen_primes():
        p2 = p * p
        d[p2] = 2 * p
        while n <= p2:
            if n in d:
                q = d.pop(n)
                m = n + q
                while m in d:
                    m += q
                d[m] = q
            else:
                yield n
            n += 2


def gen_inputs():
    num_primes = 0
    strings = []

    for new_prime in gen_primes():
        num_primes += 1
        new_string = str(new_prime)
        strings = [s for s in strings if s not in new_string] + [new_string]
        yield strings


with multiprocessing.Pool() as pool:
    for i, out in enumerate(pool.imap(superstring, gen_inputs())):
        print(i + 1, out, flush=True)

結果

以下は、8コア/ 16スレッドシステムで1.5日で計算された最初の1000個の素数の包含番号です。

C ++（GCC） + x86アセンブリ、259秒で_{32 36} 62を獲得（公式）

これまでに計算された結果。の後にコンピュータのメモリが不足し65ます。

1 2
2 23
3 235
4 2357
5 112357
6 113257
7 1131725
8 113171925
9 1131719235
10 113171923295
11 113171923295
12 1131719237295
13 11317237294195
14 1131723294194375
15 113172329419437475
16 1131723294194347537
17 113172329419434753759
18 2311329417434753759619
19 231132941743475375961967
20 2311294134347175375961967
21 23112941343471735375961967
22 231129413434717353759619679
23 23112941343471735359619678379
24 2311294134347173535961967837989
25 23112941343471735359619678378979
26 2310112941343471735359619678378979
27 231010329411343471735359619678378979
28 101031071132329417343475359619678378979
29 101031071091132329417343475359619678378979
30 101031071091132329417343475359619678378979
31 101031071091131272329417343475359619678378979
32 101031071091131272329417343475359619678378979
33 10103107109113127137232941734347535961967838979
34 10103107109113127137139232941734347535961967838979
35 10103107109113127137139149232941734347535961967838979
36 1010310710911312713713914923294151734347535961967838979
37 1010310710911312713713914915157232941734347535961967838979
38 1010310710911312713713914915157163232941734347535961967838979
39 10103107109113127137139149151571631672329417343475359619798389
40 10103107109113127137139149151571631672329417343475359619798389
41 1010310710911312713713914915157163167173232941794347535961978389
42 101031071091131271371391491515716316717323294179434753596181978389
43 101031071091131271371391491515716316723294173434753596181917978389
44 101031071091131271371391491515716316717323294179434753596181919383897
45 10103107109113127137139149151571631671731792329418191934347535961978389
46 10103107109113127137139149151571631671731791819193232941974347535961998389
47 101031071091271313714915157163167173179181919321139232941974347535961998389
48 1010310710912713137149151571631671731791819193211392232941974347535961998389
49 1010310710912713137149151571631671731791819193211392232272941974347535961998389
50 10103107109127131371491515716316717317918191932113922322722941974347535961998389
51 101031071091271313714915157163167173179181919321139223322722941974347535961998389
52 101031071091271313714915157163167173179181919321139223322722923941974347535961998389
53 1010310710912713137149151571631671731791819193211392233227229239241974347535961998389
54 101031071091271313714915157163167173179211392233227229239241819193251974347535961998389
55 101031071091271313714915157163167173179211392233227229239241819193251972574347535961998389
56 101031071091271313714915157163167173179211392233227229239241819193251972572634347535961998389
57 101031071091271313714915157163167173179211392233227229239241819193251972572632694347535961998389
58 101031071091271313714915157163167173179211392233227229239241819193251972572632694347535961998389
59 1010310710912713137149151571631671731792113922332277229239241819193251972572632694347535961998389
60 101031071091271313714915157163167173211392233227722923924179251819193257263269281974347535961998389
61 1010310710912713137149151571631671732113922332277229239241792518191932572632692819728343475359619989
62 10103107109127131371491515716316717321139223322772293239241792518191932572632692819728343475359619989
63 1010307107109127131371491515716316717321139223322772293239241792518191932572632692819728343475359619989
64 10103071071091271311371391491515716316721173223322772293239241792518191932572632692819728343475359619989
65 10103071071091271311371491515716313916721173223322772293239241792518191932572632692819728343475359619989

これらはすべて、コンコルドベースのソルバーの出力と一致します。ため、正しい可能性が高くなります。

変更ログ：

• 必要なコンテキスト長の誤った計算。以前のバージョンは大きすぎて1で、バグもありました。スコア：32 34

• 等コンテキストグループ最適化を追加しました。スコア：34 36

• コンテキストを含まない文字列を適切に使用するようにアルゴリズムを見直し、さらにいくつかの最適化を行いました。スコア：36 62

• 適切な評価を追加しました。

• 素数バリアントを追加しました。

使い方

警告：これはブレインダンプです。コードだけが必要な場合は、最後までスクロールします。

略語：

• PCN：原子炉格納容器番号の問題、つまりこの課題
• SCS：最短共通スーパーストリング
• TSP：巡回セールスマンの問題

このプログラムは基本的に、TSPに教科書の動的プログラミングアルゴリズムを使用します。

1. さらに、実際に解決している問題であるPCN / SCSからTSPへの削減。
2. さらに、各アイテムのすべての数字の代わりにアイテムコンテキストを使用します。
3. さらに、他の素数の端と重複できない素数に基づいて問題を細分化します。
4. さらに、同じ開始/終了桁を持つ素数の計算をマージします。
5. さらに、事前に計算されたルックアップテーブルとカスタムハッシュテーブル。
6. さらに、いくつかの低レベルのプリフェッチとビットパッキング。

それは多くの潜在的なバグです。anselmのエントリで遊んで、そこから間違った結果を導き出せなかった後、少なくとも全体的なアプローチが正しいことを証明する必要があります。

Concordeベースのソリューションは（はるかに）より高速ですが、同じ削減に基づいているため、この説明は両方に当てはまります。さらに、このソリューションは、プライムを含むプライム配列であるOEIS A054260に適合させることができます。TSPフレームワークでそれを効率的に解決する方法がわかりません。そのため、まだある程度関連性があります。

TSPの削減

TSPへの還元が正しいことを実際に証明することから始めましょう。一連の文字列があります

A = 13, 31, 37, 113, 137, 211

そして、これらのアイテムを含む最小のスーパーストリングを見つけたいです。

長さを知ることで十分です

PCNの場合、最短の文字列が複数ある場合、辞書編集上最小の文字列を返す必要があります。しかし、別の（そしてもっと簡単な）問題を見ていきましょう。

• SCS：最初のプレフィックスとアイテムのセットを指定すると、すべてのアイテムをサブストリングとして含み、そのプレフィックスで始まる最短の文字列が見つかります。
• SCS-Length：SCSの長さを見つけるだけです。

SCS-Lengthを解くことができれば、最小の解を再構築してPCNを取得できます。最小の解決策が接頭辞で始まることがわかっている場合、各項目を辞書式順序で追加し、長さを再度解決することにより、それを拡張しようとします。ソリューションの長さが同じである最小のアイテムを見つけると、これが最小のソリューションの次のアイテムでなければならないことがわかっているので（理由）、それを追加して残りのアイテムを再帰します。解決策に到達するこの方法は、自己還元と呼ばれますます。

最大オーバーラップグラフのツアー

上記の例のSCSを手動で解き始めたとします。おそらく：

• 取り除く13と37、彼らはすでに他の項目の部分文字列だから、。137たとえば、を含むソリューションには、13およびも含める必要があります37。
• 組み合わせを考えるとスタート113,137 → 1137、211,113 → 2113など

これは実際には正しいことですが、完全を期すために証明しましょう。SCSソリューションを使用します。たとえば、の最短スーパーストリングAは

2113137

そして、以下のすべてのアイテムの連結に分解できますA。

211
 113
   31
    137

（冗長なアイテムは無視します13, 37。）以下に注意してください。

1. 各アイテムの開始位置と終了位置は、少なくとも1増加します。
2. 各アイテムは、可能な限り前のアイテムと重複しています。

すべての最短スーパーストリングをこの方法で分解できることを示します。

1. 隣接するアイテムのすべてのペアについてx,y、yよりも後の位置で開始および終了しxます。これが当てはまらない場合xは、そのサブストリングであるyか、その逆です。ただし、部分文字列であるすべてのアイテムは既に削除されているため、それは起こりません。

2. シーケンス内の隣接するアイテムが、例えばの21113代わりに、最大以下のオーバーラップを持つと仮定します2113。しかし、それは余分な1冗長性をもたらします。それよりも前に発生し、後に表示されるすべてのアイテムが前の数字で始まることはできないため（ポイント1を参照）、それ以降のアイテムは1（2 1 113のように）イニシャルを必要としません。同様の引数は、前の項目で使用される最後の追加（211 1 3のように）を防ぎます。しかし、定義上、最短のスーパーストリングには冗長な数字がないため、このような非最大オーバーラップは発生しません。1131131131211

これらのプロパティを使用して、SCSの問題をTSPに変換できます。

1. 他のアイテムのサブストリングであるすべてのアイテムを削除します。
2. 各項目に1つの頂点を持つ有向グラフを作成します。
3. アイテムの各ペアについてx、yからエッジを追加xするy、その重量を付加することによって追加の余分なシンボルの数であるyとx最大のオーバーラップしています。たとえば、私たちは、からエッジを追加する211に113ので、重量1と21131以上の数字の上に追加されます211。エッジに対して繰り返しyにx。
4. 初期プレフィックスの頂点を追加し、その頂点から他のすべてのアイテムにエッジを追加します。

このグラフの最初のプレフィックスからのパスは、そのパス上のすべてのアイテムの最大重複連結に対応し、パスの総重量は連結された文字列の長さに等しくなります。したがって、すべてのアイテムを少なくとも1回は訪れる最低重量のツアーはすべて、最短のスーパーストリングに対応します。

そして、それがSCS（およびSCS-Length）からTSPへの削減です。

動的計画法アルゴリズム

これは古典的なアルゴリズムですが、かなり修正しますので、簡単にお知らせします。

（TSPの代わりにSCS-Lengthのアルゴリズムとしてこれを作成しました。これらは本質的に同等ですが、SCS固有の最適化に到達するときにSCSの語彙が役立ちます。）

入力項目のセットAと指定されたプレフィックスを呼び出しますP。すべてのためにk-elementサブセットSでAあり、すべての要素eのS、私達はで始まる最短の文字列の長さを計算しP、すべて含まれていSて、端部を有しますe。これには、値から(S, e)SCS-Lengthsまでのテーブルの保存が含まれます。

私たちはそれぞれのサブセットを取得するとS、テーブルのニーズはすでにの結果含まれるようにS - {e}すべてのためeにあるのS。テーブルは非常に大きくなる可能性があるため、すべてのk要素サブセットの結果を計算しますk+1。その後、などです。このためk、k+1一度に結果を保存するだけで済みます。これにより、メモリ使用量が約1分の1に削減されますsqrt(|A|)。

もう1つの詳細：最小SCS-Lengthを計算する代わりに、実際にアイテム間の最大合計オーバーラップを計算します。（SCS-Lengthを取得するには、アイテムの長さの合計から合計オーバーラップを差し引くだけです。）オーバーラップを使用すると、次の最適化のいくつかが役立ちます。

[2.]アイテムのコンテキスト

コンテキストは、以下の項目と重複することができるアイテムの最長接尾辞です。当社の商品がある場合は113,211,311、その11ためのコンテキストである211と311。（これはのプレフィックスコンテキストでもあり113、パート[4.]で説明します）

上記のDPアルゴリズムでは、各項目で終わるSCSソリューションを追跡しましたが、実際にはSCSがどの項目で終わるかは気にしません。知る必要があるのはコンテキストだけです。したがって、たとえば、同じセットの2つのSCSが23および43で終わる場合、一方から継続するSCSは他方でも機能します。

自明でない素数は数字のみで終わるため、これは重要な最適化1 3 7 9です。4つの1桁のコンテキスト1,3,7,9（および空のコンテキスト）は、実際には最大の素数のPCNを計算するのに十分131です。

[3.]コンテキストフリーアイテム

他のものは既に多くの素数が数字2,4,5,6,8などで始まると指摘しました、など23,29,41,43...。これらのいずれも、（別に前プライムと重複することができない2と5;、素数は、これらの数字で終わることができない2と5、既に冗長として除去されているであろう）。コードでは、これらはコンテキストフリー文字列と呼ばれます。

入力にコンテキストなしの項目がある場合、すべてのSCSソリューションをブロックに分割できます

<prefix>... 23... 29... 41... 43...

また、各ブロックのオーバーラップは他のブロックから独立しています。SCSの長さを変更せずに、ブロックをシャッフルしたり、同じコンテキストを持つブロック間でアイテムを交換したりできます。

したがって、コンテキストの可能なマルチセット（各ブロックに1つ）を追跡するだけです。

完全な例：100未満の素数の場合、11のコンテキストフリーアイテムとそのコンテキストがあります。

23 29 41 43 47 53 59 61 67 83 89
 3  9  1  3  7  3  9  1  7  3  9

最初のマルチセットコンテキスト：

1 1 3 3 3 3 7 7 9 9 9

コードでは、これらを複合コンテキスト、またはccontextと呼びます。次に、残りのアイテムのサブセットのみを考慮する必要があります。

11 13 17 19 31 37 71 73 79 97

[4.]コンテキストのマージ

3桁以上の素数を取得すると、さらに冗長性があります。

 101 151 181 191 ...
 107 127 157 167 197 ...
 109 149 1009 ...

これらのグループは、同じ開始コンテキストと終了コンテキストを共有しているため（通常、入力に含まれる他の素数に依存します）、他のアイテムと重複する場合は区別できません。オーバーラップのみを考慮しているため、これらの等コンテキストグループの素数を区別できないものとして扱うことができます。現在、DPサブセットはマルチサブセットに凝縮されています

4 × 1_1
5 × 1_7
3 × 1_9

（これは、ソルバーがSCSの長さを最小化する代わりにオーバーラップの長さを最大化する理由でもあります。この最適化はオーバーラップの長さを保持します。）

要約：高レベルの最適化

INFOデバッグ出力で実行すると、次のような統計が出力されます

solve: N=43, N_search=26, ccontext_size=18, #contexts=7, #eq_context_groups=16

この特定の行は、最初の62個の素数のSCS-Length 2に対するもの293です。

• 冗長なアイテムを削除すると、互いに部分文字列ではない43個の素数が残ります。
• 7つの一意のコンテキストがあります：1,3,7,11,13,27空の文字列。
• 43個の素数のうち17個はコンテキストフリーです43,47,53,59,61,89,211,223,227,229,241,251,257,263,269,281,283。これらと指定されたプレフィックス（この場合は空の文字列）は、最初の結合コンテキストの基礎を形成します。
• 残りの26項目（N_search）には、16の重要な等コンテキストグループがあります。

これらの構造を活用することで、SCS-Length計算は8498336の(multiset, ccontext)組み合わせのみをチェックする必要があります。簡単な動的プログラミングには43×2^43 > 3×10^14ステップが必要であり、順列を強引に強制するには6×10^52ステップが必要です。プログラムは、PCNソリューションを再構築するために、SCS-Lengthをさらに数回実行する必要がありますが、それほど長くかかりません。

[5.、6]低レベルの最適化

文字列操作を行う代わりに、SCS-Lengthソルバーはアイテムとコンテキストのインデックスを処理します。また、各コンテキストとアイテムのペア間のオーバーラップ量を事前計算します。

コードは当初GCCを使用しましたunordered_map。これは、リンクリストバケットとプライムハッシュサイズ（つまり、高価な部門）を持つハッシュテーブルのようです。そこで、私は線形探査と2のべき乗のサイズで独自のハッシュテーブルを作成しました。これにより、3倍の高速化と3倍のメモリ削減が実現します。

各テーブルの状態は、アイテムのマルチセット、結合されたコンテキスト、およびオーバーラップカウントで構成されます。これらは128ビットエントリにパックされます。オーバーラップカウントは8、マルチセット（ランレングスエンコーディングを使用したビットセットとして）は56、ccontext（1で区切られたRLE）は64です。ccontextのエンコードとデコードは最もトリッキーな部分であり、私は新しいPDEP命令を使用することになりました（これは非常に新しいため、GCCにはまだ組み込み関数がありません）。

最後に、ハッシュテーブルへのアクセスはN、テーブルがキャッシュに収まらないため、大きくなると本当に遅くなります。ただし、ハッシュテーブルに書き込む唯一の理由は、各状態の最もよく知られているオーバーラップカウントを更新することです。プログラムはこのステップをプリフェッチキューに分割し、内側のループは各テーブルのルックアップを数回繰り返してから実際にそのスロットを更新します。コンピューターの2倍の高速化。

ボーナス：さらなる改善

AKA Concordeはどのように高速ですか？

TSPアルゴリズムについてはあまり知らないので、大まかな推測を以下に示します。

Concordeは、TSPを解決するためにブランチアンドカット方式を使用します。

• TSPを整数線形プログラムとしてエンコードします
• 最適なツアー距離の下限と上限を取得するために、初期プログラミングと同様に線形計画法を使用します
• 次に、これらの境界は、最適解を検索する分岐および境界再帰アルゴリズムに送られます。サブツリーの計算された下限が既知の上限を超える場合、検索ツリーの大部分を枝刈りできます
• また、LP緩和を強化し、より良い境界を取得するために切断面を検索します。通常、これらのカットは、決定変数が整数でなければならないという事実の知識をエンコードします

私たちが試すことができる明白なアイデア：

• 特にPCNソリューションを再構築するときのSCS-Lengthソルバーでの枝刈り（その時点で、ソリューションの長さはすでにわかっています）
• SCSの計算しやすい下限を導出し、プルーニングを支援するために使用できます
• 悪用する素数分布のより多くの対称性または冗長性を見つける

ただし、ブランチとカットの組み合わせは非常に強力であるため、Concordeのような最先端のソルバーを、の値が大きい場合に勝るものはありませんN。

ボーナスボーナス：プライムコンテインメントプライム

Concordeベースのソリューションとは異なり、このプログラムは、最小の包含素数（OEIS A054260）を見つけるように変更できます。これには3つの変更が含まれます。

1. $1/\ln(n)$

2. SCS-Lengthソルバーコードを変更して、桁合計が3で割り切れるかどうかに基づいてソリューションを分類します。これには、各DP状態に別のエントリ、桁合計mod 3が追加されます。これにより、メインソルバーが非素数の順列でスタックする確率が大幅に減少します。これは、TSPに翻訳する方法を見つけることができなかった変更です。ILPでエンコードできますが、「サブツアーの不等式」と呼ばれるこのことと、それらを生成する方法について学ぶ必要があります。

3. そのすることができる全ての最短のPCNのが最も小さい素数封じ込めプライムはPCNよりも少なくとも一桁長くする必要があり、その場合には3で割り切れます。SCS-Lengthソルバーがこれを検出した場合、ソリューション再構築コードには、プロセスの任意のポイントで1桁追加するオプションがあります。0..9以前の辞書式順序で、可能な数字と残りの各項目を現在のソリューションプレフィックスに追加しようとします。

これらの変更により、最大でソリューションを取得できN=62ます。を除いて47、再構成コードがスタックし、100万ステップ後にあきらめます（理由はまだわかりません）。プライムコンテインメントプライムは次のとおりです。

1 2
2 23
3 523
4 2357
5 112573
6 511327
7 1135217
8 1113251719
9 11171323519
10 113171952923
11 113171952923
12 11131951723729
13 11317237419529
14 1131723294375419
15 113172329541947437
16 1131723294195343747
17 1113172329419434753759
18 11231329417437475361959
19 231132941743475375967619
20 2311294134347175967619537
21 23112941343471735967619537
22 231129413434717359537679619
23 23112941343471735375961983679
24 11231294134347173535961967983789
25 23112941343471735359679837619789
26 2310112941343471735359619783789679
27 231010329411343471735359619678379897
28 101031071132329417343475359619798376789
29 101031071091132329417343475359619767898379
30 101031071091132329417343475359619767898379
31 1010310710911131272329417343475359619678979837
32 1010310710911131272329417343475359619678979837
33 10103107109113127137232941734347535978961967983
34 10103107109113127137139232941734347535961967838979
35 10103107109113127137139149232941734347535961976798389
36 1010310710911312713713914923294151734347535976198389679
37 1010310710911312713713914915157232941734347535967619798389
38 10103107109111312713713914915157163232941734347535967897961983
39 10103107109113127137139149151571631672329417343475961979838953
40 10103107109113127137139149151571631672329417343475961979838953
41 10103107109111312713713914915157163167173232941794347535976198983
42 1010310710911131271371391491515716316717323294179434761819535989783
43 1010310710911131271371391491515716316723294173434753596181917989783
44 101031071091131271371391491515716316717323294179434753836181919389597
45 10103107109113127137139149151571631671731792329418191934347538961975983
46 101031071091113127137139149151571631671731791819193232941974347535989836199
47 (failed)
48 1010310710912713137149151571631671731791819193211392232941974347895359836199
49 10103107109112713137149151571631671731791819193211392232272941974347619983535989
50 10103107109127131371491515716316717317918191932113922322722941974347595389836199
51 101031071091271313714915157163167173179181919321139223322722941974347595389619983
52 101031071091271313714915157163167173179181919321139223322722923941974347538361995989
53 10103107109112713137149151571631671731791819193211392233227229239241974347619983538959
54 101031071091271313714915157163167173179211392233227229239241819193251974347619953835989
55 1010310710911271313714915157163167173179211392233227229239241819193251974325747596199538983
56 101031071091271313714915157163167173179211392233227229239241819193251972572634347619959895383
57 101031071091271313714915157163167173179211392233227229239241819193251972572632694359538983619947
58 101031071091271313714915157163167173179211392233227229239241819193251972572632694359538983619947
59 1010310710912713137149151571631671731792113922332277229239241819193251972572632694347535983896199
60 1010310710911271313714915157163167173211392233227722923924179251819193257263269281974347535961998389
61 1010310710912713137149151571631671732113922332277229239241792518191932572632692819728343538947619959
62 10103107109127131371491515716316717321139223322772293239241792518191932572632692819728343534759896199

コード

コンパイルする

g++ -std=c++14 -O3 -march=native pcn.cpp -o pcn

素数バージョンの場合は、GMPlibともリンクします。たとえば、

g++ -std=c++14 -O3 -march=native pcn-prime.cpp -o pcn-prime -lgmp -lgmpxx

このプログラムは、最近の（Haswell +）x86プロセッサーでのみ使用可能なPDEP命令を使用します。私のコンピューターとmaxbの両方がサポートしています。そうでない場合、プログラムは遅いソフトウェアバージョンでコンパイルされます。これが発生すると、コンパイル警告が出力されます。

#include <cassert>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
#include <algorithm>
#include <array>

using namespace std;

void debug_dummy(...) {
}

#ifndef INFO
//#  define INFO(...) fprintf(stderr, __VA_ARGS__)
#  define INFO debug_dummy
#endif

#ifndef DEBUG
//#    define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#  define DEBUG debug_dummy
#endif

bool is_prime(size_t n)
{
    for (size_t d = 2; d * d <= n; ++d) {
        if (n % d == 0) {
            return false;
        }
    }
    return true;
}

// bitset, works for up to 64 strings
using bitset_t = uint64_t;
const size_t bitset_bits = 64;

// Find position of n-th set bit of x
uint64_t bit_select(uint64_t x, size_t n) {
#ifdef __BMI2__
    // Bug: GCC doesn't seem to provide the _pdep_u64 intrinsic,
    // despite what its manual claims. Neither does Clang!
    //size_t r = _pdep_u64(ccontext_t(1) << new_context, ccontext1);
    size_t r;
    // NB: actual operand order is %2, %1 despite the intrinsic taking %1, %2
    asm ("pdep %2, %1, %0"
         : "=r" (r)
         : "r" (uint64_t(1) << n), "r" (x)
         );
    return __builtin_ctzll(r);
#else
#  warning "bit_select: no x86 BMI2 instruction set, falling back to slow code"
    size_t k = 0, m = 0;
    for (; m < 64; ++m) {
        if (x & (uint64_t(1) << m)) {
            if (k == n) {
                break;
            }
            ++k;
        }
    }
    return m;
#endif
}

#ifndef likely
#  define likely(x) __builtin_expect(x, 1)
#endif
#ifndef unlikely
#  define unlikely(x) __builtin_expect(x, 0)
#endif

// Return the shortest string that begins with a and ends with b
string join_strings(string a, string b) {
    for (size_t overlap = min(a.size(), b.size()); overlap > 0; --overlap) {
        if (a.substr(a.size() - overlap) == b.substr(0, overlap)) {
            return a + b.substr(overlap);
        }
    }
    return a + b;
}

vector <string> dedup_items(string context0, vector <string> items)
{
    vector <string> items2;
    for (size_t i = 0; i < items.size(); ++i) {
        bool dup = false;
        if (context0.find(items[i]) != string::npos) {
                dup = true;
        } else {
            for (size_t j = 0; j < items.size(); ++j) {
                if (items[i] == items[j]?
                    i > j
                        : items[j].find(items[i]) != string::npos) {
                    dup = true;
                    break;
                }
            }
        }
        if (!dup) {
            items2.push_back(items[i]);
        }
    }
    return items2;
}

// Table entry used in main solver
const size_t solver_max_item_set = bitset_bits - 8;
struct Solver_entry
{
    uint8_t score : 8;
    bitset_t items : solver_max_item_set;
    bitset_t context;

    Solver_entry()
    {
        score = 0xff;
        items = 0;
        context = 0;
    }
    bool is_empty() const {
        return score == 0xff;
    }
};

// Simple hash table to avoid stdlib overhead
struct Solver_table
{
    vector <Solver_entry> t;
    size_t t_bits;
    size_t size_;
    size_t num_probes_;

    Solver_table()
    {
        // 256 slots initially -- this needs to be not too small
        // so that the load factor formula in update_score works
        t_bits = 8;
        size_ = 0;
        num_probes_ = 0;
        resize(t_bits);
    }
    static size_t entry_hash(bitset_t items, bitset_t context)
    {
        uint64_t h = 0x3141592627182818ULL;
        // Add context first, since its bits are generally
        // less well distributed than items
        h += context;
        h ^= h >> 23;
        h *= 0x2127599bf4325c37ULL;
        h ^= h >> 47;
        h += items;
        h ^= h >> 23;
        h *= 0x2127599bf4325c37ULL;
        h ^= h >> 47;
        return h;
    }
    size_t probe_index(size_t hash) const {
        return hash & ((size_t(1) << t_bits) - 1);
    }
    void resize(size_t t2_bits)
    {
        assert (size_ < size_t(1) << t2_bits);
        vector <Solver_entry> t2(size_t(1) << t2_bits);
        for (auto entry: t) {
            if (!entry.is_empty()) {
                size_t h = entry_hash(entry.items, entry.context);
                size_t mask = (size_t(1) << t2_bits) - 1;
                size_t idx = h & mask;
                while (!t2[idx].is_empty()) {
                    idx = (idx + 1) & mask;
                    ++num_probes_;
                }
                t2[idx] = entry;
            }
        }
        t.swap(t2);
        t_bits = t2_bits;
    }
    uint8_t update_score(bitset_t items, bitset_t context, uint8_t score)
    {
        // Ensure we can insert a new item without resizing
        assert (size_ < t.size());

        size_t index = probe_index(entry_hash(items, context));
        size_t mask = (size_t(1) << t_bits) - 1;
        for (size_t p = 0; p < t.size(); ++p, index = (index + 1) & mask) {
            ++num_probes_;
            if (likely(t[index].items == items && t[index].context == context)) {
                t[index].score = max(t[index].score, score);
                return t[index].score;
            }
            if (t[index].is_empty()) {
                // add entry
                t[index].score = score;
                t[index].items = items;
                t[index].context = context;
                ++size_;
                // load factor 4/5 -- ideally 2-3 average probes per lookup
                if (5*size_ > 4*t.size()) {
                    resize(t_bits + 1);
                }
                return score;
            }
        }
        assert (false && "bug: hash table probe loop");
    }
    size_t size() const {
        return size_;
    }
    void swap(Solver_table table)
    {
        t.swap(table.t);
        ::swap(size_, table.size_);
        ::swap(t_bits, table.t_bits);
        ::swap(num_probes_, table.num_probes_);
    }
};

/*
 * Main solver code.
 */
struct Solver
{
    // Inputs
    vector <string> items;
    string context0;
    size_t context0_index;

    // Mapping between strings and indices
    vector <string> context_to_string;
    unordered_map <string, size_t> string_to_context;

    // Items that have context-free prefixes, i.e. prefixes that
    // never overlap with the end of other items nor context0
    vector <bool> contextfree;

    // Precomputed contexts (suffixes) for each item
    vector <size_t> item_context;
    // Precomputed updates: (context, string) to overlap amount
    vector <vector <size_t>> join_overlap;

    Solver(vector <string> items, string context0)
        :items(items), context0(context0)
    {
        items = dedup_items(context0, items);
        init_context_();
    }

    void init_context_()
    {
        /*
         * Generate all relevant item-item contexts.
         *
         * At this point, we know that no item is a substring of
         * another, nor of context0. This means that the only contexts
         * we need to care about, are those generated from maximal join
         * overlaps between any two items.
         *
         * Proof:
         * Suppose that the shortest containing string needs some other
         * kind of context. Maybe it depends on a context spanning
         * three or more items, say X,Y,Z. But if Z ends after Y and
         * interacts with X, then Y must be a substring of Z.
         * This cannot happen, because we removed all substrings.
         *
         * Alternatively, it depends on a non-maximal join overlap
         * between two strings, say X,Y. But if this overlap does not
         * interact with any other string, then we could maximise it
         * and get a shorter solution. If it does, then call this
         * other string Z. We would get the same contradiction as in
         * the previous case with X,Y,Z.
         */
        size_t N = items.size();
        vector <size_t> max_prefix_overlap(N), max_suffix_overlap(N);
        size_t context0_suffix_overlap = 0;
        for (size_t i = 0; i < N; ++i) {
            for (size_t j = 0; j < N; ++j) {
                if (i == j) continue;
                string joined = join_strings(items[j], items[i]);
                size_t overlap = items[j].size() + items[i].size() - joined.size();
                string context = items[i].substr(0, overlap);
                max_prefix_overlap[i] = max(max_prefix_overlap[i], overlap);
                max_suffix_overlap[j] = max(max_suffix_overlap[j], overlap);

                if (string_to_context.find(context) == string_to_context.end()) {
                    string_to_context[context] = context_to_string.size();
                    context_to_string.push_back(context);
                }
            }

            // Context for initial join with context0
            {
                string joined = join_strings(context0, items[i]);
                size_t overlap = context0.size() + items[i].size() - joined.size();
                string context = items[i].substr(0, overlap);
                max_prefix_overlap[i] = max(max_prefix_overlap[i], overlap);
                context0_suffix_overlap = max(context0_suffix_overlap, overlap);

                if (string_to_context.find(context) == string_to_context.end()) {
                    string_to_context[context] = context_to_string.size();
                    context_to_string.push_back(context);
                }
            }
        }
        // Now compute all canonical trailing contexts
        context0_index = string_to_context[
                           context0.substr(context0.size() - context0_suffix_overlap)];
        item_context.resize(N);
        for (size_t i = 0; i < N; ++i) {
            item_context[i] = string_to_context[
                                items[i].substr(items[i].size() - max_suffix_overlap[i])];
        }

        // Now detect context-free items
        contextfree.resize(N);
        for (size_t i = 0; i < N; ++i) {
            contextfree[i] = (max_prefix_overlap[i] == 0);
            if (contextfree[i]) {
                DEBUG("  contextfree: %s\n", items[i].c_str());
            }
        }

        // Now compute all possible overlap amounts
        join_overlap.resize(context_to_string.size(), vector <size_t> (N));
        for (size_t c_index = 0; c_index < context_to_string.size(); ++c_index) {
            const string& context = context_to_string[c_index];
            for (size_t i = 0; i < N; ++i) {
                string joined = join_strings(context, items[i]);
                size_t overlap = context.size() + items[i].size() - joined.size();
                join_overlap[c_index][i] = overlap;
            }
        }
    }

    // Main solver.
    // Returns length of shortest string containing all items starting
    // from context0 (context0's length not included).
    size_t solve() const
    {
        size_t N = items.size();

        // Length, if joined without overlaps. We try to improve this by
        // finding overlaps in the main iteration
        size_t base_length = 0;
        for (auto s: items) {
            base_length += s.size();
        }

        // Now take non-context-free items. We will only need to search
        // over these items.
        vector <size_t> search_items;
        for (size_t i = 0; i < N; ++i) {
            if (!contextfree[i]) {
                search_items.push_back(i);
            }
        }
        size_t N_search = search_items.size();

        /*
         * Some groups of strings have the same context transitions.
         * For example "17", "107", "127", "167" all have an initial
         * context of "1" and a trailing context of "7", no other
         * overlaps are possible with other primes.
         *
         * We group these strings and treat them as indistinguishable
         * during the main algorithm.
         */
        auto eq_context = [&](size_t i, size_t j) {
            if (item_context[i] != item_context[j]) {
                return false;
            }
            for (size_t ci = 0; ci < context_to_string.size(); ++ci) {
                if (join_overlap[ci][i] != join_overlap[ci][j]) {
                    return false;
                }
            }
            return true;
        };
        vector <size_t> eq_context_group(N_search, size_t(-1));
        for (size_t si = 0; si < N_search; ++si) {
            for (size_t sj = si-1; sj+1 > 0; --sj) {
                size_t i = search_items[si], j = search_items[sj];
                if (!contextfree[j] && eq_context(i, j)) {
                    DEBUG("  eq context: %s =c= %s\n", items[i].c_str(), items[j].c_str());
                    eq_context_group[si] = sj;
                    break;
                }
            }
        }

        // Figure out the combined context size. A combined context has
        // one entry for each context-free item plus one for context0.
        size_t ccontext_size = N - N_search + 1;

        // Assert that various parameters all fit into our data types
        using ccontext_t = bitset_t;
        assert (context_to_string.size() + ccontext_size <= bitset_bits);
        assert (N_search <= solver_max_item_set);
        assert (base_length < 0xff);

        // Initial combined context.
        unordered_map <size_t, size_t> cc0_full;
        ++cc0_full[context0_index];
        for (size_t i = 0; i < N; ++i) {
            if (contextfree[i]) {
                ++cc0_full[item_context[i]];
            }
        }
        // Now pack into unary-encoded bitset. The bitset stores the
        // count for each context as <count> number of 0 bits,
        // followed by a 1 bit.
        ccontext_t cc0 = 0;
        for (size_t ci = 0, b = 0; ci < context_to_string.size(); ++ci, ++b) {
            b += cc0_full[ci];
            cc0 |= ccontext_t(1) << b;
        }

        // Map from (item set, context) to maximum achievable overlap
        Solver_table k_solns;
        // Base case: cc0 with empty set
        k_solns.update_score(0, cc0, 0);

        // Now start dynamic programming. k is current subset size
        size_t eq_context_groups = 0;
        for (size_t g: eq_context_group) eq_context_groups += (g != size_t(-1));
        if (context0.empty()) {
            INFO("solve: N=%zu, N_search=%zu, ccontext_size=%zu, #contexts=%zu, #eq_context_groups=%zu\n",
                 N, N_search, ccontext_size, context_to_string.size(), eq_context_groups);
        } else {
            DEBUG("solve: context=%s, N=%zu, N_search=%zu, ccontext_size=%zu, #contexts=%zu, #eq_context_groups=%zu\n",
                  context0.c_str(), N, N_search, ccontext_size, context_to_string.size(), eq_context_groups);
        }
        for (size_t k = 0; k < N_search; ++k) {
            decltype(k_solns) k1_solns;

            // The main bottleneck of this program is updating k1_solns,
            // which (for larger N) becomes a huge table.
            // We use a prefetch queue to reduce memory latency.
            const size_t prefetch = 8;
            array <Solver_entry, prefetch> entry_queue;
            size_t update_i = 0;

            // Iterate every k-subset
            for (Solver_entry entry: k_solns.t) {
                if (entry.is_empty()) continue;

                bitset_t s = entry.items;
                ccontext_t ccontext = entry.context;
                size_t overlap = entry.score;

                // Try adding a new item
                for (size_t si = 0; si < N_search; ++si) {
                    bitset_t s1 = s | bitset_t(1) << si;
                    if (s == s1) {
                        continue;
                    }
                    // Add items in each eq_context_group sequentially
                    if (eq_context_group[si] != size_t(-1) &&
                        !(s & bitset_t(1) << eq_context_group[si])) {
                        continue;
                    }
                    size_t i = search_items[si]; // actual item index

                    size_t new_context = item_context[i];
                    // Increment ccontext's count for new_context.
                    // We need to find its delimiter 1 bit
                    size_t bit_n = bit_select(ccontext, new_context);
                    ccontext_t ccontext_n =
                        ((ccontext & ((ccontext_t(1) << bit_n) - 1))
                         | ((ccontext >> bit_n << (bit_n + 1))));

                    // Select non-empty sub-contexts to substitute for new_context
                    for (size_t ci = 0, bit1 = 0, count;
                         ci < context_to_string.size();
                         ++ci, bit1 += count + 1)
                    {
                        assert (ccontext_n >> bit1);
                        count = __builtin_ctzll(ccontext_n >> bit1);
                        if (!count
                            // We just added new_context; we can only remove an existing
                            // context entry there i.e. there must be at least two now
                            || (ci == new_context && count < 2)) {
                            continue;
                        }

                        // Decrement ci in ccontext_n
                        bitset_t ccontext1 =
                            ((ccontext_n & ((ccontext_t(1) << bit1) - 1))
                             | ((ccontext_n >> (bit1 + 1)) << bit1));

                        size_t overlap1 = overlap + join_overlap[ci][i];

                        // do previous prefetched update
                        if (update_i >= prefetch) {
                            Solver_entry entry = entry_queue[update_i % prefetch];
                            k1_solns.update_score(entry.items, entry.context, entry.score);
                        }

                        // queue the current update and prefetch
                        Solver_entry entry1;
                        size_t probe_index = k1_solns.probe_index(Solver_table::entry_hash(s1, ccontext1));
                        __builtin_prefetch(&k1_solns.t[probe_index]);
                        entry1.items = s1;
                        entry1.context = ccontext1;
                        entry1.score = overlap1;
                        entry_queue[update_i % prefetch] = entry1;

                        ++update_i;
                    }
                }
            }

            // do remaining queued updates
            for (size_t j = 0; j < min(update_i, prefetch); ++j) {
                Solver_entry entry = entry_queue[j];
                k1_solns.update_score(entry.items, entry.context, entry.score);
            }

            if (context0.empty()) {
                INFO("  hash stats: |solns[%zu]| = %zu, %zu lookups, %zu probes\n",
                     k+1, k1_solns.size(), update_i, k1_solns.num_probes_);
            } else {
                DEBUG("  hash stats: |solns[%zu]| = %zu, %zu lookups, %zu probes\n",
                      k+1, k1_solns.size(), update_i, k1_solns.num_probes_);
            }
            k_solns.swap(k1_solns);
        }

        // Overall solution
        size_t max_overlap = 0;
        for (Solver_entry entry: k_solns.t) {
            if (entry.is_empty()) continue;
            max_overlap = max(max_overlap, size_t(entry.score));
        }
        return base_length - max_overlap;
    }
};

// Wrapper for Solver that also finds the smallest solution string
string smallest_containing_string(vector <string> items)
{
    items = dedup_items("", items);

    size_t soln_length;
    {
        Solver solver(items, "");
        soln_length = solver.solve();
    }
    DEBUG("Found solution length: %zu\n", soln_length);

    string soln;
    vector <string> remaining_items = items;
    while (remaining_items.size() > 1) {
        // Add all possible next items, in lexicographic order
        vector <pair <string, size_t>> next_solns;
        for (size_t i = 0; i < remaining_items.size(); ++i) {
            const string& item = remaining_items[i];
            next_solns.push_back(make_pair(join_strings(soln, item), i));
        }
        assert (next_solns.size() == remaining_items.size());
        sort(next_solns.begin(), next_solns.end());

        // Now try every item in order
        bool found_next = false;
        for (auto ns: next_solns) {
            size_t i;
            string next_soln;
            tie(next_soln, i) = ns;
            DEBUG("Trying: %s + %s -> %s\n",
                  soln.c_str(), remaining_items[i].c_str(), next_soln.c_str());
            vector <string> next_remaining;
            for (size_t j = 0; j < remaining_items.size(); ++j) {
                if (next_soln.find(remaining_items[j]) == string::npos) {
                    next_remaining.push_back(remaining_items[j]);
                }
            }

            Solver solver(next_remaining, next_soln);
            size_t next_size = solver.solve();
            DEBUG("  ... next_size: %zu + %zu =?= %zu\n", next_size, next_soln.size(), soln_length);
            if (next_size + next_soln.size() == soln_length) {
                INFO("  found next item: %s\n", remaining_items[i].c_str());
                soln = next_soln;
                remaining_items = next_remaining;
                // found lexicographically smallest solution, break now
                found_next = true;
                break;
            }
        }
        assert (found_next);
    }
    soln = join_strings(soln, remaining_items[0]);

    return soln;
}

int main()
{
    string prev_soln;
    vector <string> items;
    size_t p = 1;
    for (size_t N = 1;; ++N) {
        for (++p; items.size() < N; ++p) {
            if (is_prime(p)) {
                char buf[99];
                snprintf(buf, sizeof buf, "%zu", p);
                items.push_back(buf);
                break;
            }
        }

        // Try to reuse previous solution (this works for N=11,30,32...)
        string soln;
        if (prev_soln.find(items.back()) != string::npos) {
            soln = prev_soln;
        } else {
            soln = smallest_containing_string(items);
        }
        printf("%s\n", soln.c_str());
        prev_soln = soln;
    }
}

オンラインでお試しください！

そして、TIOの一等地に専用バージョン。申し訳ありませんが、私はこれらのプログラムをゴルフしませんでした。投稿の長さの制限があります。

JavaScript（Node.js）、241秒で24点獲得

結果

• $a(1)$$a(21)$
• $a(22)=231129413434717353759619679$
• $a(23)=23112941343471735359619678379$
• $a(1)$$a(24)$

アルゴリズム

これは、数値をマージするすべての可能な方法を試行する再帰的検索であり、最終的にリーフノードに到達すると、辞書式の順序で結果リストをソートします。

$x$$y$$k$$x$$k$$y$$k$$y$$k$$x$

各反復の開始時に、別のエントリで見つかったエントリはリストから削除されます。

訪問したノードを追跡することで大幅な高速化が達成されたため、異なる操作が同じリストにつながったときに早期に中止できます。

匿名ユーザー Neilが提案したように、コピーを生成するのではなく、可能な場合にリストを更新および復元することにより、わずかな高速化が達成されました。

例

$n=7$$[2,3,5,7,11,13,17]$

[]                        // start with an empty list
[ 2 ]                     // append 2
[ 2, 3 ]                  // append 3
[ 2, 3, 5 ]               // append 5
[ 2, 3, 5, 7 ]            // append 7
[ 2, 3, 5, 7, 11 ]        // append 11
[ 2, 3, 5, 7, 11, 13 ]    // append 13
[ 2, 5, 7, 11, 13 ]       // remove 3, which appears in 13
  [ 2, 5, 7, 113, 13 ]    //   try to merge 11 and 13 into 113
  [ 2, 5, 7, 113 ]        //   remove 13, which now appears in 113
  [ 2, 5, 7, 113, 17 ]    //   append 17
  [ 2, 5, 113, 17 ]       //   remove 7, which appears in 17
  --> leaf node: 1131725  //   new best result
[ 2, 5, 7, 11, 13, 17 ]   // append 17
[ 2, 5, 11, 13, 17 ]      // remove 7, which appears in 17
  [ 2, 5, 113, 13, 17 ]   //   try to merge 11 and 13 into 113
  [ 2, 5, 113, 17 ]       //   remove 13, which now appears in 113
                          //   abort because this node was already visited
                          //   (it was a leaf node anyway, so we don't save much here)
  [ 2, 5, 117, 13, 17 ]   //   try to merge 11 and 17 into 117
  [ 2, 5, 117, 13 ]       //   remove 17, which now appears in 117
  --> leaf node: 1171325  //   not better than the previous one
--> leaf node: 11131725   // not better than the previous one

コード

オンラインでお試しください！

let f = n => {
  let visited = {},
      a, d, k, best, search;

  // build the list of primes, as strings
  for(a = [ '2' ], n--, k = 3; n; k++) {
    for(d = k; k % (d -= 2);) {}
    d == 1 && n-- && a.push(k + '');
  }

  best = a.join('');

  // recursive search function
  (search = (a, n = 0, r = []) => {
    let x, y, i, j, k, s;

    // remove all entries in r[] that can be found in another entry
    r = r.filter((p, i) => !r.some((q, j) => i != j && ~q.indexOf(p)));

    // abort early if this node was already visited
    if(visited[r]) {
      return;
    }

    // otherwise, mark it as visited
    visited[r] = 1;

    // walk through all distinct pairs (x, y) in r[]
    for(i = 0; i < r.length; i++) {
      for(j = i + 1; j < r.length; j++) {
        x = r[i];
        y = r[j];

        // try to merge x and y if:
        // 1) the first k digits of x equal the last k digits of y
        for(k = 1; x.slice(0, k) == y.slice(-k); k++) {
          r[i] = y + x.slice(k);
          search(a, n, r);
        }

        // or:
        // 2) the first k digits of y equal the last k digits of x
        for(k = 1; y.slice(0, k) == x.slice(-k); k++) {
          r[i] = x + y.slice(k);
          search(a, n, r);
        }
        r[i] = x;
      }
    }

    if(x = a[n]) {
      // there are other primes to process, so go on with the next one
      search(a, n + 1, [...r, x]);
    }
    else {
      // this is a leaf node: see if we've improved our current score
      s = r.join('');

      if(s.length <= best.length) {
        s = r.sort().join('');

        if(s.length < best.length || s < best) {
          best = s;
        }
      }
    }
  })(a);

  return best;
}

Concorde TSPソルバー、299秒で84点を獲得

ええと…今これを実現するだけで愚かな気分です。

このすべては本質的に巡回セールスマンの問題です。素数pとの各ペアに対してq、q（重なる数字を削除して）追加した桁数を重みとするエッジを追加します。また、p重みがの長さであるすべての素数に初期エッジを追加しpます。最短の巡回セールスマンパスは、最小のプライムコンテインメントナンバーの長さと一致します。

その後、Concordeなどの産業グレードのTSPソルバーがこの問題を簡単に解決します。

このエントリは、おそらく競合しないと見なされる必要があります。

結果

ソルバーはN=350、約20 CPU時間で到達します。完全な結果は1つのSE投稿には長すぎます。OEISは、とにかくそれほど多くの用語を望んでいません。最初の200は次のとおりです。

1 2
2 23
3 235
4 2357
5 112357
6 113257
7 1131725
8 113171925
9 1131719235
10 113171923295
11 113171923295
12 1131719237295
13 11317237294195
14 1131723294194375
15 113172329419437475
16 1131723294194347537
17 113172329419434753759
18 2311329417434753759619
19 231132941743475375961967
20 2311294134347175375961967
21 23112941343471735375961967
22 231129413434717353759619679
23 23112941343471735359619678379
24 2311294134347173535961967837989
25 23112941343471735359619678378979
26 2310112941343471735359619678378979
27 231010329411343471735359619678378979
28 101031071132329417343475359619678378979
29 101031071091132329417343475359619678378979
30 101031071091132329417343475359619678378979
31 101031071091131272329417343475359619678378979
32 101031071091131272329417343475359619678378979
33 10103107109113127137232941734347535961967838979
34 10103107109113127137139232941734347535961967838979
35 10103107109113127137139149232941734347535961967838979
36 1010310710911312713713914923294151734347535961967838979
37 1010310710911312713713914915157232941734347535961967838979
38 1010310710911312713713914915157163232941734347535961967838979
39 10103107109113127137139149151571631672329417343475359619798389
40 10103107109113127137139149151571631672329417343475359619798389
41 1010310710911312713713914915157163167173232941794347535961978389
42 101031071091131271371391491515716316717323294179434753596181978389
43 101031071091131271371391491515716316723294173434753596181917978389
44 101031071091131271371391491515716316717323294179434753596181919383897
45 10103107109113127137139149151571631671731792329418191934347535961978389
46 10103107109113127137139149151571631671731791819193232941974347535961998389
47 101031071091271313714915157163167173179181919321139232941974347535961998389
48 1010310710912713137149151571631671731791819193211392232941974347535961998389
49 1010310710912713137149151571631671731791819193211392232272941974347535961998389
50 10103107109127131371491515716316717317918191932113922322722941974347535961998389
51 101031071091271313714915157163167173179181919321139223322722941974347535961998389
52 101031071091271313714915157163167173179181919321139223322722923941974347535961998389
53 1010310710912713137149151571631671731791819193211392233227229239241974347535961998389
54 101031071091271313714915157163167173179211392233227229239241819193251974347535961998389
55 101031071091271313714915157163167173179211392233227229239241819193251972574347535961998389
56 101031071091271313714915157163167173179211392233227229239241819193251972572634347535961998389
57 101031071091271313714915157163167173179211392233227229239241819193251972572632694347535961998389
58 101031071091271313714915157163167173179211392233227229239241819193251972572632694347535961998389
59 1010310710912713137149151571631671731792113922332277229239241819193251972572632694347535961998389
60 101031071091271313714915157163167173211392233227722923924179251819193257263269281974347535961998389
61 1010310710912713137149151571631671732113922332277229239241792518191932572632692819728343475359619989
62 10103107109127131371491515716316717321139223322772293239241792518191932572632692819728343475359619989
63 1010307107109127131371491515716316717321139223322772293239241792518191932572632692819728343475359619989
64 10103071071091271311371391491515716316721173223322772293239241792518191932572632692819728343475359619989
65 10103071071091271311371491515716313916721173223322772293239241792518191932572632692819728343475359619989
66 10103071071091271311371491515716313921167223317322772293239241792518191932572632692819728343475359619989
67 10103071071091271311371491515716313921167223317322772293239241792518191932572632692819728343475359619989
68 1010307107109127131137149151571631392116722331732277229323924179251819193257263269281972833743475359619989
69 1010307107109127131137149151571631392116722331732277229323924179251819193257263269281972833743475359619989
70 101030710710912713113714915157163139211672233173227722932392417925181919325726326928197283374347534959619989
71 101030710710912713113714915157163139211672233173227722932392417925181919325726337269281972834743534959619989
72 101030710710912713113714915157163139211672233173227722932392417925181919337257263472692819728349435359619989
73 10103071071091271311371491515716313921167223317322772293372392417925181919347257263492692819728353594367619989
74 101030710710912713113714915157163139211672233173227722932392417925181919337347257263492692819728353594367619989
75 1010307107109127131137313914915157163211672233173227722933792392417925181919347257263492692819728353594367619989
76 101030710710912713113731391491515716321167223317322772293379239241792518191934725726349269281972835359438367619989
77 101030710710912713113731391491515716321167223317337922772293472392417925181919349257263535926928197283674383896199
78 1010307107109127131137313914915157163211672233173379227722934723972417925181919349257263535926928197283674383896199
79 101030710710912713113731391491515721163223317337922772293472397241672517925726349269281819193535928367401974383896199
80 101030710710912713113731391491515721163223317337922772293472397241672517925726349269281819193535928367401974094383896199
81 101030710710912713113731391491515721163223317337922772293472397241916725179257263492692818193535928367401974094383896199
82 1010307107109127131137313914915157223317322772293379239724191634725167257263492692817928353594018193674094211974383896199
83 1010307107109127131137313914922331515722772293379239724191634725167257263492692817353592836740181938389409421197431796199
84 101030710710912713113731391492233151572277229323972419163472516725726349269281735359283674018193838940942119743179433796199
85 101030710710912713113731391492233151572277229323924191634725167257263492692817353592836740181938389409421197431794337943976199
86 1010307107109127131137313914922331515722772293239241916347251672572634926928173535928367401819383894094211974317943379443976199
87 1010307107109127131137313914922331515722772293239241916347251672572634926928173535928367401819383894094211974317943379443974496199
88 1010307107109127131137313914922331515722772293239241916347251672572634926928173535928367401819383894094211974317943379443974494576199
89 10103071071091271311373139149223315157227722932392419163472516725726349269281735359283674018193838940942119743179433794439744945746199
90 10103071071091271311373139149223315157227722932392419163251672572634726928173492835359401819367409421197431794337944397449457461994638389
91 10103071071091271311373139149223315157227722932392419163251672572634726928173492835359401819367409421197431794337944397449457461994638389467
92 101030710710912713113731391492233151572277229323924191632516725726347926928173492835359401819367409421197431794337944397449457461994638389467
93 101030710710912713113731391492233151572277229323924191632516725726347926928173492835359401819367409421197431794337944397449457461994638389467487
94 101030710710912713113731392233149151572277229323924191632516725726347926928173492835359401819367409421197431794337944397449457461994638389467487
95 1010307107109127131137313922331491515722772293239241916325167257263479269281734928353594018193674094211974317943379443974499457461994638389467487
96 1010307107109127131137313922331491515722772293239241916325167257263269281734792834940181935359409421197431794337944397449945746199463674674875038389
97 1010307107109127131137313922331491515722772293239241916325167257263269281734792834940181935359409421197431794337944397449945746199463674674875038389509
98 101030710710912713113732233139227722932392419149151572516325726326928167283479401734940942118193535943179433794439744994574619746367467487503838950952199
99 1010307107109127131137322331392277229324191491515725163257263269281672834794017349409421181935359431794337944394499457461974636746748750383895095219952397
100 101030710710922331127131373227722932414915157251632572632692816728347940173494094211394317943379443944994574618191935359463674674875038389509521975239754199
101 101030710710922331127131373227722932414915157251632572632692816728347401734940942113943179433794439449945746181919353594636746748750383895095219752397541995479
102 101030710710922331127131373227722932414915157251632572632692816728347401734940942113943179433794439449945746181919353594636746748750383895095219752397541995479557
103 101030710710922331127131373227722932414915157251632572632692816728340173474094211394317943379443944945746181919349946353594674875036750952197523975419954795575638389
104 101030710710922331127131373227722932414915157251632572632692816728340173474094211394317943379443944945746181919349946353594674875036750952197523975419954795575638389569
105 101030710722331109227127722932413137325149151571632572632692816728340173474094211394317943379443944945746181919349946353594674875036750952197523975419954795575638389569
106 1010307107223311092271277229324131373251491515716325726326928167283401734740942113943179433794439449457461819193499463535946748750367509521975239754199547955775638389569
107 1010307107223311092271277229324131373251491515716325726326928167283401734740942113943179433794439449457461819193499463535946748750367509521975239754199547955775638389569587
108 10103071072233110922712772293241313732514915157163257263269281672834017340942113943179433794439449457461819193474634994674875035359367509521975239754199547955775638389569587
109 10103071072233110922712772293241313732514915157163257263269281672834017340942113943179433794439449457461819193474634994674875035359367509521975239754199547955775638389569587599
110 1010307223311072271092293241277251313732571491515726326928163283401674094211394317343379443944945746179463474674875034995095218191935359367523975419754795577563838956958759960199
111 1010307223311072271092293241277251313732571491515726326928163283401674094211394317343379443944945746179463474674875034995095218191935359367523975419754795577563838956958759960199607
112 1010307223311072271092293241277251491515716325726326928167283401734094211313734317943379443944945746139463474674875034995095218191935359367523975419754795577563838956958759960199607
113 22331101030722710722932410925127725714915157263269281632834016740942113137343173433794439449457461394634746748750349950952181919353593675239754197547955775638389569587599601996076179
114 2233110103072271072293241092512571277263269281491515728340163409421131373431734337944394494574613946347467487503499509521675239754191819353593675479557756383895695875996019760761796199
115 22331010307227107229324109251257126311277269281491515728340163409421131373431734337944394494574613946347467487503499509521675239754191819353593675479557756383895695875996019760761796199
116 22331010307227107229324109251257126311269281277283401491515740942113137343173433794439449457461394634674875034750952163499523975416754795577563535936756958759960181919383896076179619764199
117 223310103072271072293241092512571263112692812772834014915157409421131373431734433794494574613946346748750347509521634995239541675479557756353593675695875996018191938389607617961976419964397
118 223310103072271072293241092512571263112692812772834014915157409421131373431734433794494574613946346748750347509521634995239541675475577563535936756958759960181919383896076179619764199643976479
119 223310103072271072293241092512571263112692812772834014915157409421131373431734433794494574613946346748750347509521634995239541675475577563535695875935996018191936760761796197641996439764796538389
120 2233101030722710722932410925125712631126928127728340149151574094211313734317344337944945746139463467487503475095216349952395416754755775635356958760181919359367607617961976419964397647965383896599
121 22331010307227107229324109251257126311269281277283401491515740942113137343173443379449457461394634674875034750952163499523954167547557756353569587601819193593676076179641976439764796538389659966199
122 223310103072271072293241092512571263112692812772834014915157409421131373431734433794494574613946346734748750349950952163523954167547557756353569587601819193593676076179641976439764796538389659966199
123 2233101030722710722932410925125712631126928127728340149151574094211313734317344337944945746139463467347487503499509521635239541675475577563535695876018191935936776076179641976439764796538389659966199
124 2233101030722710722932410925125712631126928127728340149151574094211313734317344337944945746139463467347487503499509521635239541675475577563535695876018191935936076179641976439764796536776599661996838389
125 22331010307227107229324109251257126311269127728128340149151574094211313734317344337944945746139463467347487503499509521635239541675475577563535695876018191935936076179641976439764796536776599661996838389
126 2233101030701072271092293241251257126311269127728128340149151574094211313734317344337944945746139463467347487503499509521635239541675475577563535695876018191935936076179641976439764796536776599661996838389
127 223310103070107092271092293241251257126311269127728128340149151574094211313734317344337944945746139463467347487503499509521635239541675475577563535695876018191935936076179641976439764796536776599661996838389
128 223310103070107092271092293241251257191263112691277281283401491515740942113137343173443379449457461394634673474875034995095216352395416754755775635356958760181935936076179641976439764796536776599661996838389
129 22331010307010709227109229324125125719126311269127277281283401491515740942113137343173443379449457461394634673474875034995095216352395416754755775635356958760181935936076179641976439764796536776599661996838389
130 223307010103227092293241072510925712631126912719128128340140942113137331491515727743173443379449457461394634673474875034995095216352395416754755775635356958760181935936076179641976439764796536776599661996838389
131 2233070101032270922932410725109257126311269127191281283401409421131373314915157277431734433794494574613946346739487503475095216349952395416754755775635356958760181935936076179641976439764796536776599661996838389
132 2233070101032270922932410725109257126311269127191281283401409421131373314915157277431734433794494574613946346739487503475095216349952395416754755775635356958760181935936076179641976439764796536776599661996838389
133 223307010103227092293241072510925712631126912719128128340140942113137331443173449149457277433794613946346739487503475095215157516349952395416754755775635356958760181935936076179641976439764796536776599661996838389
134 22330701010322709229324107251092571263112691271912812834014094211313733144317344914945727743379461394634673948750347509521515751634995239541675475575635356958757760181935936076179641976439764796536776599661996838389
135 22330701010322709229324107251092571263112691271912812834014094211313733144317344914945727743379461394634673948750347509521515751634995239541675475575635356958757760181935936076179641976439764796536776599661996838389
136 2233070101032270922932410725109257126311269127191281283401409421131373314431734491494572774337946139463467394875034750952151575163499523954167547557563535695875776018193593607617964197643976479653677696599661996838389
137 22330701010322709229324107251092571263112691271912812834014094211313733144317344914945727734613946346739487433795034750952151575163499523954167547557563535695875776018193593607617964197643976479653677696599661996838389
138 2233070101032270922932410725109257126311269127191281283401409421131373314431734491494572773461394634673948743379503475095215157516349952395416754755756353569587577601819359360761796419764397647965367787696599661996838389
139 22330701010322709229324107251092571263112691271912812834014094211313733144317344914945727734613946346739487433795034750952151575163499523954167547557563535695875776018193593607617964197643976479765367787696599661996838389
140 22330701010322709229324107251092571263112691271912812834014094211313733144317344914945727734613946346739487433795034750952151575163499523954167547557563535695875776018193593607617964197643976479765367787696599661996838389809
141 223307010103227092293241072510925712631126912719128112834014094211313733144317344914945727734613946346739487433795034750952151575163499523954167547557563535695875776018193593607617964197643976479765367787696599661996838389809
142 223307010103227092293241072510925712631126912719128112834014094211313733144317344914572773461394634673948743379503475095214952395415157516349954755756353569587577601676076179641935936439764797653677659966197876968383898098218199
143 223070101032270922932410725109257126311269127191281128340140942113137331443173449145727734613946346739487433475034950952149952337954151575163535475575635695875776016760761796419359364396479765367765996619768383898098218199823978769
144 223070101032270922932410725109257126311269127191281128340140942113137331443173449145727433461394634673474875034950952149952337954151575163535475575635695875773960167607617964193593643964797653677659966197683838980982181998239769827787
145 223070101032270922924107251092571263112691271912811283401409421131373314431734491457274334613946346734748750349509521499523379541515751635354755756356958757739601676076179641935936439647976536599661976836776980982181998239782778782938389
146 2230701010322709229241072510925712631126912719128112834014094211313733144317344914572743346139463467347487503495095214995233795415157516353547557563569587577396016760761796419359364396479765367765996619768383976980982181998239827787829389
147 2230701010322709229241072510925712631126912719128112834014094211313733144317344914572743346139463467347487503495095214995233795415157516353547557563569587577396016760761796419359364396479765365996619768367769809821819982397827787829383985389
148 2230701010322709229241072510925712631126912719128112834014094211313733144317344914572743346139463467347487503495095214995233795415157516353547557563569587576016760761796419359364396479765365996619768367739769809821819982398277829383985389857787
149 2230701010322709229241072510925712631126912719128112834014094211313733144317344914572743346139463467347487503495095214995233795415157516353547557563569587576016760761796419359364396479765365966197683677397698098218199823982778293839853898577878599
150 2230701010322709229241072510925712631126912719128112834014094211313733144317344914572743346139463467347487503495095214995233795415157516353547557563569587576016760761796419359364396479765365966197683677397698098218199823982778293839853857787859986389
151 22307010103227092292410725109257126311269127191281128340140942113137331443173449145727433461394634673474875034950952149952337954151575163535475575635695875760167607617964193593643964797653659661976836773976980982181998239827782938398538577877859986389
152 22307010103227092292410725109257126311269127191281128340140942113137331443173449145727433461394634673474875034950952149952337954151547515755756353569587576016359360761796419364396479765365966197683676980982167739782398277829383985385778778599863898818199
153 22307010103227092292410725109257126311269127191281128340140942113137331443173449145727433461394634673474875034950952149952337954151547515755756353569587576016359360761796419364396479765365966197683676980982167739782398277829383853857787785998638988181998839
154 22307010103227092292410725109257126311269127191281128340140942113137331443173449145727433461394634673474875034950952149952337954151547515755756353569587576016359360761796419364396479765365966197683676980982167739782398277829383853857785998638988181998839887787
155 2230701010322709072292410725109257126311269127191281128340140942113137331443173449145727433461394634673474875034950952149952337954151547515755756353569587576016359360761796419364396479765365966197683676980982167739782398277829383853857785998638988181998839887787
156 22307010103227090722924107251092571263112691127191281128340140942113137331443173449145727433461394634673474875034950952149952337954151547515755756353569587576016359360761796419364396479765365966197683676980982167739782398277829383853857785998638988181998839887787
157 22307010103227090722924107251092571263112691127191281128340140942113137331443173449193457274334613946346734748750349509521499523379541515475155756353569587576015760761796419764396479765359365966199683676980982163823978277398293838538577859986389881816778778839887
158 2230701010322709072292410725109257126311269112719128112834014092934211313733144317344919345727433461394634673474875034950952149952337954151547515575635356958757601576076179641976439647976535936596619968367698098216382397827739829853838577859986389881816778778839887
159 22307010103227090722924107251092571263112691127191281128340140929342113137274314433173344919345746139463467347487503495095214995233735354151547515575635695875760157607617964197643964796535937976596619968367698098216382397827739829853838577859986389881816778778839887
160 2230701010322709072292410725109257126311269112719128112834014092934211313727431443317334491934574613941463467347487503495095214995233735354151547515575635695875760157607617964197643964796535937976596619968367698098216382397827739829853838577859986389881816778778839887
161 223070101032270907229241072510925712631126911271912811283401409293421131372743144331733449193457461394146346734748750349475095214995233735354151547515575635695875760157607617964197643964796535937976596619968367698098216382397827739829853838577859986389881816778778839887
162 22307010103227090722924107251092571263112691127191281128340140929342113137274314433173344919345746139414634673474875034947509521499523373535415154751557563569535875760157607617964197643964796535937976596619968367698098216382397827739829853838577859986389881816778778839887
163 2230701010322709072292410725109257126311269112719128112834014092934211313727431443317334491934574613941463467347487503494750952149952337353541515475155756356953587576015760761796419764396479653593797659661996768367698098216382397827739829853838577859986389881816778778839887
164 22307010103227090722924107251092571263112691127128112834014092934211313727431443317334491457461394146346734748750349475095214995233735354151547515575635695358757601576076179641919359379643964797197653659661996768367698098216382397827739829853838577859986389881816778778839887
165 223070101032270907229241072510925712631126911271281128340140929342113137274314433173344914574613941463467347487503494750952149952337353541515475155756356953587576015760761796419193593796439647971976536596619967683676980982163823977398277829853838577859986389881816778778839887
166 22307010103227090722924107251092571263112691127128112834014092934211313727431443317334491457461394146346734748750349475095214995233735354151547515575635695358757601576076179641919359379643964797197653659661996768367698098216382397739827782983838538577859986389881816778778839887
167 223070101032270907229241072510925712631126911271281128340140929342113137274314433173344914574613941463467347487503494750952149915152337353541547515575635695358757601576076179641919359379643964797197653659661996768367698098216382397739827782983838538577859986389881816778778839887
168 2230701010322709072292410725109257126311269112712811283401409293421131372743144331733449145746139414634673474875034947509521499151523373535415475155756356953587576015760761796419193593796439647971976536596619967683676980982163823977398277829838385385778599786389881816778778839887
169 2230701009070922710103229241072510925712631126911272728112834014092934211313733144317344914574334613941463467347487503494750952149915152337515415475575635356953587576015760761796419193593796439647971976536596619967683676980982163823977398277829838385385778599786389881816778778839887
170 22307010090709227101310322924107251092571263112691127272811283401409293421134431373317344914574334613941463467347487503494750952149915152337515415475575635356953587576015760761796419193593796439647971976536596619967683676980982163823977398277829838385385778599786389881816778778839887
171 22307010090709227101310191032292410725109257126311269112727281128340140929342113443137331734491457433461394146346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
172 22307010090709227101310191021032292410725109257126311269112727281128340140929342113443137331734491457433461394146346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
173 223070100907092271013101910210310722924109251257126311269112727281128340140929342113443137331734491457433461394146346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
174 223070100907092271013101910210310331107229241092512571263132691127272811283401409293421137334431734491457433461394146346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
175 223070100907092271013101910210310331103922924107251092571263132691127272811283401409293421137334431734491457433461394146346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
176 223070100907092271013101910210310331103922924104910725109257126313269112727281128340140929342113733443173449414574334613946346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
177 223070100907092271013101910210310331103922924104910510725109257126313269112727281128340140929342113733443173449414574334613946346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
178 223070100907092271013101910210310331103922924104910510610725109257126313269112727281128340140929342113733443173449414574334613946346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
179 223070100907092271013101910210310331103922924104910510610631325107257109263269112727281128340140929342113733443173449414574334613946346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
180 223070100907092271013101910210310331103922924104910510610631325106911072571092632692811272728340140929342113733443173449414574334613946346734748750349475095214991935233751515415475575635356953587576015760761796419643964796535937971976596619967683676980982163823977398277829838385385778599786389881816778778839887
181 223070100907092271013101910210310331103922924104910510610631325106911072571087263269281092834012727409293421137334431734494145743346139463467347487503494750952149919352337515154154755756353569535875760157607617964196439647965359379719765966199676836769809821638239773982778298383853857785997863898811816778778839887
182 2230701009070922710131019102103103311039229241049105106106313251069107257108726326928109112727283401409293421137334431734494145743346139463467347487503494750952149919352337515154154755756353569535875760157607617964196439647965359379719765966199676836769809821638239773982778298383853857785997863898811816778778839887
183 2230701009070922710131019102103103311039229241049105106106313251069107257108726326928109110932834012727409293421137334431734494145743346139463467347487503494750952149919352337515154154755756353569535875760157607617964196439647965359379719765966199676836769809821638239773982778298383853857785997863898811816778778839887
184 2230701009070922710131019102103103311039229241049105106106313251069107257108726326928109110932834010971929340941272742113733443173449457433461394634673474875034947509521499193523375151541547557563535695358757601576076179641976439647965359379765966199676836769809821638239773982778298383853857785997863898811816778778839887
185 2230701009070922710131019102103103311039229241049105106106313251069107257108726326928109110932834010971929340941272742113733443173449457433461394634673474875034947509521499193523375151541547557563535695358757601576076179641976439647965359379765966199676836769809821638239773982778298383853857785997863898811816778778839887
186 2230701009070922710131019102103103311039229241049105106106313251069107257108726326928109110932834010971929340941272742113733443173449457433461394634673474875034947509521499193523375151541547557563535695358757601576076179641976439647965359379765966199676836769809821638239773982778298383853857785997863898811816778778839887
187 223070100907092271013101910210310331103922924104910510610631325106910725710872632692810911093283401097192934094127274211173344317433449457461373463467347487503494750952149919352337515154157547557563535695358757601635937960761796419764396479765365966199676836769809821677397782398277829838385385778599786389881811398839887787
188 223070100907092271013101910210310331103922924104910510610631325106910725710872632692810911093283401097192934094111727421123344317334494574337346137463467347487503494750952127514991935235354151575475575635695358757601635937960761796419764396479765365966199676836769809821677397782398277829838385385778599786389881811398839887787
189 1009070101307092232271019102103103310491051061063110392292410691072510872571091109326326928109719283401117274092934211233443131733449411294574337346137463467347487503494750952127514991935235354151575475575635695358757601635937960761796419764396479765365966199676836769809821677397782398277829838385385778599786389881811398839887787
190 10090701013070922322710191021031033104910510610631103922924106910725108725710911093263269281097192834011172740929342112334431317334494112945743373461374634673474875034947509521139523535412751499193547557563569535875760157607617964197643964796535937976596619967683676980982163823977398277829838385385778599786389881151816778778839887
191 100907010130709101910210310331049105106106311039223227106910722924108725109110932571097192632692811172728340112334092934211294113137334431734494574337461394634673474875034947509521151153523535412751499193547557563569535875760157607617964197643964796535937976596619967683676980982163823977398277829838385385778599786389881816778778839887
192 1009070101307091019102103103310491051061063110392232271069107229241087251091109325710971926326928111727283401123340929342112941131373344317344945743374613946346734748750349475095211511535235354116354751275575635695358757601499193593796076179641976439647976536596619967683676980982157739778239827782983838538578599786389881816778778839887
193 1009070101307092232271019102103103310491051061063110392292410691072510872571091109326326928109711171928340112334092934211294113137274317334433734494574613946346734748750349475095211511535235354127514991935475575635695358757601576076179641976439647965359379765966199676836769809821677397782398277829838385385778599786388181163898839887787
194 10090701013070922322710191021031033104910510610631103922924106910725108725710911093263269281097111719283401123340929342112941131372743173344337344945746139463467347487503494750952115115352353541163547512755756356953587576014991935937960761796419764396479765365966199676836769809821577397782398277829838385385785997863898811816778778839887
195 100907010130709101910210310331049105106106311039223227106910722924108725109110932571097111719263269281123283401129293409411313727421151153443173344945743346139463467347487503494750952116352337353541181187512754755756356953587576014991935937960761796419764396479765365966199676836769809821577397782398277829838385385785997863898816778778839887
196 100907010130709101910210310331049105106106310691072231103922710872292410911093251097111711232571926326928112928340113137274092934211511534431733449411634574334613946346734748750349475095211811875119352337353541275475575635695358757601499196076179641976439647965359379765966199676836769809821577397782398277829838385385785997863898816778778839887
197 100907010130709101910210310331049105106106310691072231103922710872292410911093251097111711232571926326928112928340113137274092934211511534431733449411634574334613946346734748750349475095211811875119352337353541201275475575635695358757601499196076179641976439647965359379765966199676836769809821577397782398277829838385385785997863898816778778839887
198 1009070101307091019102103103310491051061063106910710872231103922710911093229241097111711232511292571926326928113132834011511534092934211634431733449411811872743345746137346346734748750349475095211935233751201213953535412754755756356958757601499196076179641976439647965359379765966199676836769809821577397782398277829838385385785997863898816778778839887
199 10090701013070910191021031033104910510610631069107108710911039223110932271097111711232292411292511313257192632692811511532834011634092934211811872743173344334494119345746137346346734748750349475095212012139523375121754127547557563535695358757601499196076179641976439647965359379765966199676836769809821577397782398277829838385385785997863898816778778839887
200 100907010130709101910210310331049105106106310691071087109109311039110971117112322711292292411313251151153257192632692811632834011811872740929342119344317334494120121373457433461394634673474875034947509521217512233752353541275475575635695358757601499196076179641976439647965359379765966199676836769809821577397782398277829838385385785997863898816778778839887

コード

以下は、ソリューションを構築するまでコンコルドソルバーを何度も呼び出すPython 3スクリプトです。

コンコルドはアカデミックな使用は無料です。独自の線形プログラミングパッケージQSoptでビルドされたConcordeの実行可能バイナリをダウンロードできます。何らかの方法でIBM CPLEXのライセンスを持っている場合は、ソースからConcordeをビルドしてCPLEXを使用できます。

#!/usr/bin/env python3
'''
Find prime containment numbers (OEIS A054261) using the Concorde
TSP solver.

The n-th prime containment number is the smallest natural number
which, when written in decimal, contains the first n primes.
'''

import argparse
import itertools
import os
import sys
import subprocess
import tempfile

def join_strings(a, b):
  '''Shortest string that starts with a and ends with b.'''
  for overlap in range(min(len(a), len(b)), 0, - 1):
    if a[-overlap:] == b[:overlap]:
      return a + b[overlap:]
  return a + b

def is_prime(n):
  if n < 2:
    return False
  d = 2
  while d*d <= n:
    if n % d == 0:
      return False
    d += 1
  return True

def prime_list_reduced(n):
  '''First n primes, with primes that are substrings of other
     primes removed.'''
  primes = []
  p = 2
  while len(primes) < n:
    if is_prime(p):
      primes.append(p)
    p += 1

  reduced = []
  for p in primes:
    if all(p == q or str(p) not in str(q) for q in primes):
      reduced.append(p)
  return reduced

# w_med is an offset for actual weights
# (we use zero as a dummy weight when splitting nodes)
w_med = 10**4
# w_big blocks edges from being taken
w_big = 10**8

def gen_tsplib(prefix, strs, start_candidates):
  '''Generate TSP formulation in TSPLIB format.

     Returns a TSPLIB format string that encodes the length of the
     shortest string starting with 'prefix' and containing all 'strs'.

     start_candidates is the set of strings that solution paths are
     allowed to start with.
     '''
  N = len(strs)

  # Concorde only supports symmetric TSPs. Therefore we encode the
  # asymmetric TSP instances by doubling each node.
  node_in = lambda i: 2*i
  node_out = lambda i: node_in(i) + 1
  # 2*(N+1) nodes because we add an artificial node with index N
  # for the start/end of the tour. This node is also doubled.
  num_nodes = 2*(N+1)

  # Ensure special offsets are big enough
  assert w_med > len(prefix) + sum(map(len, strs))
  assert w_big > w_med * num_nodes

  weight = [[w_big] * num_nodes for _ in range(num_nodes)]
  def edge(src, dest, w):
    weight[node_out(src)][node_in(dest)] = w
    weight[node_in(dest)][node_out(src)] = w

  # link every incoming node with the matching outgoing node
  for i in range(N+1):
    weight[node_in(i)][node_out(i)] = 0
    weight[node_out(i)][node_in(i)] = 0

  for i, p in enumerate(strs):
    if p in start_candidates:
      prefix_w = len(join_strings(prefix, p))
      # Initial length
      edge(N, i, w_med + prefix_w)
    else:
      edge(N, i, w_big)
    # Link every str to the end to allow closed tours
    edge(i, N, w_med)

  for i, p in enumerate(strs):
    for j, q in enumerate(strs):
      if i != j:
        w = len(join_strings(p, q)) - len(p)
        edge(i, j, w_med + w)

  out = '''NAME: prime-containment-number
TYPE: TSP
DIMENSION: %d
EDGE_WEIGHT_TYPE: EXPLICIT
EDGE_WEIGHT_FORMAT: FULL_MATRIX
EDGE_WEIGHT_SECTION
''' % num_nodes

  out += '\n'.join(
    ' '.join(str(w) for w in row)
    for row in weight
  ) + '\n'

  out += 'EOF\n'
  return out

def parse_tour_soln(prefix, strs, text):
  '''This constructs the solution from Concorde's 'tour' output format.
     The format simply consists of a permutation of the graph nodes.'''
  N = len(strs)
  node_in = lambda i: 2*i
  node_out = lambda i: node_in(i) + 1
  nums = list(map(int, text.split()))

  # The file starts with the number of nodes
  assert nums[0] == 2*(N+1)
  nums = nums[1:]

  # Then it should list a permutation of all nodes
  assert len(nums) == 2*(N+1)

  # Find and remove the artificial starting point
  start = nums.index(node_out(N))
  nums = nums[start+1:] + nums[:start]
  # Also find and remove the end point
  if nums[-1] == node_in(N):
    nums = nums[:-1]
  elif nums[0] == node_in(N):
    # Tour printed in reverse order
    nums = reversed(nums[1:])
  else:
    assert False, 'bad TSP tour'
  soln = prefix
  for i in nums:
    # each prime appears in two adjacent nodes, pick one arbitrarily
    if i % 2 == 0:
      soln = join_strings(soln, strs[i // 2])
  return soln

def scs_length(prefix, strs, start_candidates, concorde_path, concorde_verbose):
  '''Find length of shortest containing string using one call to Concorde.'''
  # Concorde's small-input solver CCHeldKarp, tends to fail with the
  # cryptic error message 'edge too long'. Brute force instead
  if len(strs) <= 5:
    best = len(prefix) + sum(map(len, strs))
    for perm in itertools.permutations(range(len(strs))):
      if perm and strs[perm[0]] not in start_candidates:
        continue
      soln = prefix
      for i in perm:
        soln = join_strings(soln, strs[i])
      best = min(best, len(soln))
    return best

  with tempfile.TemporaryDirectory() as tempdir:
    concorde_path = os.path.join(os.getcwd(), concorde_path)
    with open(os.path.join(tempdir, 'prime.tsplib'), 'w') as f:
      f.write(gen_tsplib(prefix, strs, start_candidates))

    if concorde_verbose:
      subprocess.check_call([concorde_path, os.path.join(tempdir, 'prime.tsplib')],
                            cwd=tempdir)
    else:
      try:
        subprocess.check_output([concorde_path, os.path.join(tempdir, 'prime.tsplib')],
                                cwd=tempdir, stderr=subprocess.STDOUT)
      except subprocess.CalledProcessError as e:
        print('Concorde exited with error code %d\nOutput log:\n%s' %
              (e.returncode, e.stdout.decode('utf-8', errors='ignore')),
              file=sys.stderr)
        raise

    with open(os.path.join(tempdir, 'prime.sol'), 'r') as f:
      soln = parse_tour_soln(prefix, strs, f.read())
    return len(soln)

# Cache results from previous N's
pcn_solve_cache = {} # (prefix fragment, strs) -> soln

def pcn(n, concorde_path, concorde_verbose):
  '''Find smallest prime containment number for first n primes.'''
  strs = list(map(str, prime_list_reduced(n)))
  target_length = scs_length('', strs, strs, concorde_path, concorde_verbose)

  def solve(prefix, strs, target_length):
    if not strs:
      return prefix

    # Extract part of prefix that is relevant to cache
    prefix_fragment = ''
    for s in strs:
      next_prefix = join_strings(prefix, s)
      overlap = len(prefix) + len(s) - len(next_prefix)
      fragment = prefix[len(prefix) - overlap:]
      if len(fragment) > len(prefix_fragment):
        prefix_fragment = fragment
    fixed_prefix = prefix[:len(prefix) - len(prefix_fragment)]
    assert fixed_prefix + prefix_fragment == prefix

    cache_key = (prefix_fragment, tuple(strs))
    if cache_key in pcn_solve_cache:
      return fixed_prefix + pcn_solve_cache[cache_key]

    # Not in cache, we need to calculate it.
    soln = None

    # Try strings in ascending order until scs_length reports a
    # solution with equal length. That string will be the
    # lexicographically smallest extension of our solution.
    next_prefixes = sorted((join_strings(prefix, s), s)
                           for s in strs)

    # Try first string -- often works
    next_prefix, _ = next_prefixes[0]
    next_prefixes = next_prefixes[1:]
    next_strs = [s for s in strs if s not in next_prefix]
    next_length = scs_length(next_prefix, next_strs, next_strs,
                             concorde_path, concorde_verbose)
    if next_length == target_length:
      soln = solve(next_prefix, next_strs, next_length)
    else:
      # If not, do a weighted binary search on remaining strings
      while len(next_prefixes) > 1:
        split = (len(next_prefixes) + 2) // 3
        group = next_prefixes[:split]
        group_length = scs_length(prefix, strs, [s for _, s in group],
                                  concorde_path, concorde_verbose)
        if group_length == target_length:
          next_prefixes = group
        else:
          next_prefixes = next_prefixes[split:]
      if next_prefixes:
        next_prefix, _ = next_prefixes[0]
        next_strs = [s for s in strs if s not in next_prefix]
        check = True
        # Uncomment if paranoid
        #next_length = scs_length(next_prefix, next_strs, next_strs,
        #                         concorde_path, concorde_verbose)
        #check = (next_length == target_length)
        if check:
          soln = solve(next_prefix, next_strs, target_length)

    assert soln is not None, (
      'solve failed! prefix=%r, strs=%r, target_length=%d' %
      (prefix, strs, target_length))

    pcn_solve_cache[cache_key] = soln[len(fixed_prefix):]
    return soln

  return solve('', strs, target_length)

parser = argparse.ArgumentParser()
parser.add_argument('--concorde', type=str, default='concorde',
                    help='path to Concorde binary')
parser.add_argument('--verbose', action='store_true',
                    help='dump all Concorde output')
parser.add_argument('--start', type=int, metavar='N', default=1,
                    help='start at this N')
parser.add_argument('--end', type=int, metavar='N', default=1000000,
                    help='stop after this N')
parser.add_argument('--one', type=int, metavar='N',
                    help='solve for a single N and exit')

def main():
  opts = parser.parse_args(sys.argv[1:])

  if opts.one is not None:
    opts.start = opts.one
    opts.end = opts.one

  prev_soln = ''
  for n in range(opts.start, opts.end+1):
    primes = map(str, prime_list_reduced(n))
    if all(p in prev_soln for p in primes):
      soln = prev_soln
    else:
      soln = pcn(n, opts.concorde, opts.verbose)

    print('%d %s' % (n, soln))
    sys.stdout.flush()
    prev_soln = soln

if __name__ == '__main__':
  main()