アルゴリズム分析の魔法の背後にあるシステムはありますか？

アルゴリズムの実行時間を分析する方法については、多くの質問があります（たとえば、ランタイム分析およびアルゴリズム分析を参照）。多くは似ています。たとえば、ネストされたループのコスト分析や、分割統治アルゴリズムを求めるものですが、ほとんどの答えはオーダーメイドのようです。

一方、別の一般的な質問への回答では、いくつかの例を使用してより大きな全体像（特に漸近解析に関する）を説明していますが、手を汚す方法はありません。

アルゴリズムのコストを分析するための構造化された一般的な方法はありますか？コストは、実行時間（時間の複雑さ）、または実行された比較の数、スペースの複雑さなどのコストのその他の尺度である場合があります。

^{これは、初心者を指すのに使用できる参照質問になるはずです。したがって、通常よりも広い範囲です。少なくとも1つの例で説明されているが、多くの状況をカバーする、一般的で教訓的に提示された答えを与えるように注意してください。ありがとう！}

コードを数学に変換する

（多かれ少なかれ）正式な操作上のセマンティクスがあれば、アルゴリズムの（擬似）コードを、文字通り、結果を提供する数式に変換できます。これは、比較、スワップ、ステートメント、メモリアクセス、いくつかの抽象的なマシンニーズのサイクル数などの追加コスト測定に適しています。

例：Bubblesortでの比較

与えられた配列をソートするこのアルゴリズムを考えてみましょうA：

 bubblesort(A) do                   1
  n = A.length;                     2
  for ( i = 0 to n-2 ) do           3
    for ( j = 0 to n-i-2 ) do       4
      if ( A[j] > A[j+1] ) then     5
        tmp    = A[j];              6
        A[j]   = A[j+1];            7
        A[j+1] = tmp;               8
      end                           9
    end                             10
  end                               11
end                                 12

通常のソートアルゴリズム分析を実行するとします。つまり、要素比較の数をカウントします（5行目）。この量は配列の内容に依存せずA、長さのみ依存することにすぐに注意してください。したがって、（ネストされた）ループを文字通り（ネストされた）合計に変換できます。ループ変数が合計変数になり、範囲が引き継がれます。我々が得る：$n$for

$\qquad\displaystyle C_{\text{cmp}}(n) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \dots = \frac{n(n-1)}{2} = \binom{n}{2}$、

ここで、は5行目の実行ごとのコストです（カウント）。$1$

例：Bubblesortのスワップ

Iは、によって表すう行で構成サブプログラムへとによってこのサブプログラムを実行するためのコスト（1回）。 C i 、$P_{i,j}$ij$C_{i,j}$

スワップをカウントしたいとしましょう。これは、が実行される頻度です。これは「基本ブロック」、つまり常にアトミックに実行され、一定のコスト（ここでは）を持つサブプログラムです。そのようなブロックを縮小することは、考えたり話したりせずに適用することが多い便利な単純化です。$P_{6,8}$$1$

上記と同様の翻訳で、次の式が得られます。

$\qquad\displaystyle C_{\text{swaps}}(A) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$。

$A^{(i,j)}$は、の番目の反復の前の配列の状態を示します。$(i,j)$$P_{5,9}$

パラメーターとしてではなくを使用していることに注意してください。その理由はすぐにわかります。コストはここで（つまり、均一コストモデル）に依存しないため、パラメーターとしてとを追加しません。一般に、彼らはただそうするかもしれません。$A$$n$$i$$j$$C_{5,9}$

明らかに、コストはの内容（値および、特に）に依存するため、それを考慮する必要があります。今、私たちは課題に直面しています：をどのように「アンラップ」しますか？さて、のコンテンツへの依存関係を明示的にすることができます。$P_{5,9}$$A$A[j]A[j+1]$C_{5,9}$$A$

$\qquad\displaystyle C_{5,9}(A^{(i,j)}) = C_5(A^{(i,j)}) + \begin{cases} 1 &, \mathtt{A^{(i,j)}[j] > A^{(i,j)}[j+1]} \\ 0 &, \text{else} \end{cases}$。

どの入力配列でも、これらのコストは明確に定義されていますが、より一般的なステートメントが必要です。より強い仮定をする必要があります。3つの典型的なケースを調べてみましょう。

1. 最悪の場合

   合計を見て、に注目するだけで、コストの自明な上限を見つけることができます。$C_{5,9}(A^{(i,j)}) \in \{0,1\}$

   $\qquad\displaystyle C_{\text{swaps}}(A) \leq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \frac{n(n-1)}{2} = \binom{n}{2}$。

   しかし、これは起こる可能性があります。つまり、この上限のが達成されるのでしょうか。結局のところ、はい：ペアごとに異なる要素の逆ソートされた配列を入力した場合、すべての反復でスワップを実行する必要があります¹。したがって、Bubblesortのスワップの正確な最悪ケース数を導き出しました。$A$

2. 最高のケース

   逆に、簡単な下限があります。

   $\qquad\displaystyle C_{\text{swaps}}(A) \geq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 0 = 0$。

   これは、すでにソートされている配列でも発生する可能性があります。Bubblesortは単一のスワップを実行しません。

3. 平均的なケース

   最悪で最良の場合は、かなりのギャップが生じます。しかし、スワップの典型的な数は何ですか？この質問に答えるためには、「典型的な」が意味するものを定義する必要があります。理論的には、ある入力を別の入力よりも優先する理由はないので、通常、すべての可能な入力にわたって均一な分布を仮定します。つまり、すべての入力が等しく発生する可能性があります。ペアごとに異なる要素を持つ配列に制限しているため、ランダム置換モデルを想定しています。

   次に、この²のようにコストを書き換えることができます。

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

   ここで、単純な合計の操作を超えなければなりません。アルゴリズムを見ると、すべてのスワップが 1つの反転のみを削除することに注意してください（私たちは隣人だけをスワップします³）。すなわち、上で行わスワップの数であり、正確に反転数であるの。したがって、内側の2つの合計を置き換えて、$A$$A$$\operatorname{inv}(A)$$A$

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \operatorname{inv}(A)$。

   幸運なことに、反転の平均数は

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{2} \cdot \binom{n}{2}$

   これが最終結果です。これは最悪の場合のコストのちょうど半分であることに注意してください。

1. アルゴリズムはi = n-1、何も実行しない外部ループの「最後の」反復が実行されないように慎重に定式化されていることに注意してください。
2. 「」は「期待値」の数学表記であり、ここでは単なる平均です。$\mathbb{E}$
3. 我々は、道に沿って学習しないだけ隣接する要素をスワップアルゴリズムは（さえ平均して）漸近的に速いバブルソートよりなることはできません-反転の数は、すべてのそのようなアルゴリズムの下限です。これは、たとえばInsertion SortおよびSelection Sortに適用されます。

一般的な方法

例では、制御構造を数学に変換する必要があることがわかりました。翻訳ルールの典型的なアンサンブルを紹介します。また、任意のサブプログラムのコストが現在の状態、つまり（大まかに）変数の現在の値に依存することもわかりました。アルゴリズムは（通常）状態を変更するため、一般的な方法は表記がやや面倒です。混乱し始めたら、例に戻るか、自分で構成することをお勧めします。

で現在の状態を示します（変数の割り当てのセットとして想像してください）。状態で始まるプログラムを実行すると、状態（終了が提供されます）。$\psi$P$\psi$$\psi / \mathtt{P}$P

• 個別の声明

  ステートメントが1つだけのS;場合、コストを割り当てます。通常、これは定数関数です。$C_S(\psi)$

• 表現

  Eフォームの式E1 ∘ E2（たとえば、∘加算または乗算が可能な算術式）がある場合、コストを再帰的に加算します。

  $\qquad\displaystyle C_E(\psi) = c_{\circ} + C_{E_1}(\psi) + C_{E_2}(\psi)$。

  ご了承ください

  • 操作コスト一定であるが、の値に依存しないことがありとと$c_{\circ}$$E_1$$E_2$
  • 式の評価は多くの言語で状態を変えるかもしれません。

  そのため、このルールに柔軟に対応する必要があります。

• シーケンス

  プログラムをプログラムのPシーケンスとして指定Q;Rすると、コストを

  $\qquad\displaystyle C_P(\psi) = C_Q(\psi) + C_R(\psi / \mathtt{Q})$。

• 条件付き

  次Pの形式のプログラムを考えるif A then Q else R endと、コストは州によって異なります。

  $\qquad\displaystyle C_P(\psi) = C_A(\psi) + \begin{cases} C_Q(\psi/\mathtt{A}) &, \mathtt{A} \text{ evaluates to true under } \psi \\ C_R(\psi/\mathtt{A}) &, \text{else} \end{cases}$

  一般に、評価Aは状態を非常によく変更する可能性があるため、個々のブランチのコストの更新が行われます。

• ループ用

  次Pの形式のプログラムを指定するfor x = [x1, ..., xk] do Q endと、コストを割り当てます

  $\qquad\displaystyle C_P(\psi) = c_{\text{init_for}} + \sum_{i=1}^k c_{\text{step_for}} + C_Q(\psi_i \circ \{\mathtt{x := xi\}})$

  ここで、はvalueの処理前の状態、つまり、...、... に設定された反復後の状態です。$\psi_i$Qxixx1xi-1

  ループメンテナンス用の追加の定数に注意してください。ループ変数を作成し（）、その値を割り当てる必要があります（）。これは関連している$c_{\text{init_for}}$$c_{\text{step_for}}$

  • 次の計算にはxiコストがかかり、
  • for空のボディを持つ-loop（たとえば、特定のコストでベストケース設定で単純化した後）は、反復を実行する場合、ゼロコストになりません。

• While-Loops

  次Pの形式のプログラムを指定するwhile A do Q endと、コストを割り当てます

  $\qquad\displaystyle C_P(\psi) \\\qquad\ = C_A(\psi) + \begin{cases} 0 &, \mathtt{A} \text{ evaluates to false under } \psi \\ C_Q(\psi/\mathtt{A}) + C_P(\psi/\mathtt{A;Q}) &, \text{ else} \end{cases}$

  アルゴリズムを調べることにより、この繰り返しは、forループの場合と同様の合計としてうまく表現できることがよくあります。

  例：この短いアルゴリズムを考えてみましょう：

  while x > 0 do    1
    i += 1          2
    x = x/2         3
  end               4
  

  ルールを適用することにより、

  $\qquad\displaystyle C_{1,4}(\{i := i_0; x := x_0\}) \\\qquad\ = c_< + \begin{cases} 0 &, x_0 \leq 0 \\ c_{+=} + c_/ + C_{1,4}(\{i := i_0 + 1; x := \lfloor x_0/2 \rfloor\}) &, \text{ else} \end{cases}$

  個々のステートメントに一定のコストが伴います。これらは状態（およびの値）に依存しないと暗黙的に仮定します。これは「現実」に当てはまる場合も、そうでない場合もあります。$c_{\dots}$ix

  この再発を解決する必要があります。ループ本体のコストではなく、反復回数もの値に依存しないことに注意してください。この繰り返しが残っています：$C_{1,4}$i

  $\qquad\displaystyle C_{1,4}(x) = \begin{cases} c_> &, x \leq 0 \\ c_> + c_{+=} + c_/ + C_{1,4}(\lfloor x/2 \rfloor) &, \text{ else} \end{cases}$

  これは、と解決基本的な手段に

  $\qquad\displaystyle C_{1,4}(\psi) = \lceil \log_2 \psi(x) \rceil \cdot (c_> + c_{+=} + c_/) + c_>$、

  完全な状態を象徴的に再導入します。もし、その後。$\psi = \{ \dots, x := 5, \dots\}$$\psi(x) = 5$

• 手続き呼び出し

  プログラムを考えるとP、フォームのM(x)いくつかのパラメータ（複数可）のための（名前付き）のパラメータと手順があり、コストを割り当てますxMp

  $\qquad\displaystyle C_P(\psi) = c_{\text{call}} + C_M(\psi_{\text{glob}} \circ \{p := x\})$。

  再度、追加の定数注意してください（実際には依存する可能性があります！）。プロシージャコールは、実際のマシンでの実装方法のために高価であり、ランタイムを支配することさえあります（たとえば、フィボナッチ数の繰り返しを単純に評価する）。$c_{\text{call}}$$\psi$

  ここでは、状態に関するセマンティックの問題について説明します。グローバル状態とそのようなローカルプロシージャコールを区別する必要があります。ここでグローバル状態のみを渡しM、の値を設定することで初期化された新しいローカル状態を取得すると仮定pしxます。さらに、x渡す前に（通常）評価されると想定される式である場合があります。

  例：手順を検討する

  fac(n) do                  
    if ( n <= 1 ) do         1
      return 1               2
    else                     3
      return n * fac(n-1)    4
    end                      5
  end                        
  

  ルールに従って、以下を取得します。

  $\qquad\displaystyle\begin{align*} C_{\text{fac}}(\{n := n_0\}) &= C_{1,5}(\{n := n_0\}) \\ &= c_{\leq} + \begin{cases} C_2(\{n := n_0 \}) &, n_0 \leq 1 \\ C_4(\{n := n_0 \}) &, \text{ else} \end{cases} \\ &= c_{\leq} + \begin{cases} c_{\text{return}} &, n_0 \leq 1 \\ c_{\text{return}} + c_* + c_{\text{call}} + C_{\text{fac}}(\{n := n_0 - 1\}) &, \text{ else} \end{cases} \end{align*}$

  fac明らかにアクセスしないため、グローバル状態を無視することに注意してください。この特定の再発は簡単に解決できます

  $\qquad\displaystyle C_{\text{fac}}(\psi) = \psi(n) \cdot (c_{\leq} + c_{\text{return}}) + (\psi(n) - 1) \cdot (c_* + c_{\text{call}})$

典型的な擬似コードで発生する言語機能について説明しました。高レベルの擬似コードを分析するときは、隠れたコストに注意してください。疑わしい場合は展開します。表記は面倒に思えるかもしれませんが、確かに好みの問題です。ただし、リストされている概念は無視できません。ただし、ある程度の経験があれば、「問題のサイズ」や「頂点の数」など、状態のどの部分がどのコストメジャーに関連しているかをすぐに確認できます。残りはドロップすることができます-これは物事を大幅に簡素化します！

あなたは、これはあまりにも複雑であることを今考えられる場合は、助言すること：それはあります！実際のマシンに非常に近いモデルでアルゴリズムの正確なコストを導き出して、実行時の予測（相対的なものであっても）を可能にするのは困難な試みです。そして、それは実際のマシンでのキャッシュやその他の厄介な効果を考慮していません。

したがって、アルゴリズム分析は、数学的に扱いやすいという点まで単純化されることがよくあります。たとえば、正確なコストを必要としない場合は、任意の時点で（上限または下限の場合）過大または過小評価することができます：定数セットの削減、条件の削除、合計の単純化など。

漸近コストに関する注意

通常、文献やWebで見つかるのは「Big-Oh分析」です。適切な用語は漸近解析です。これは、例で行ったように正確なコストを導出するのではなく、一定の係数と制限内のコストのみを与えることを意味します（大まかに言うと、「」）。$n$

マシン、オペレーティングシステム、およびその他の要因に応じて、抽象的なステートメントには実際にはいくつかの（一般に不明な）コストがあるため、これは（多くの場合）公平です。短いランタイムは、最初にプロセスをセットアップするオペレーティングシステムによって支配される場合があります。とにかく、あなたはいくらかの動揺を得る。

漸近解析がこのアプローチにどのように関係するかを以下に示します。

1. 支配的な操作（コストを引き起こす）、つまり最も頻繁に発生する操作（一定の要因まで）を特定します。Bubblesortの例で考えられる選択肢の1つは、5行目の比較です。

   または、基本操作のすべての定数を最大値（上から）でバインドします。それらの最小値（下から）と通常の分析を実行します。

2. この操作の実行回数をコストとして使用して分析を実行します。
3. 簡素化する場合、推定を許可します。目標が上限（）である場合にのみ、上からの推定を許可するように注意してください。下限（）が必要な場合は、下から。$O$$\Omega$

Landauシンボルの意味を理解してください。このような境界は3つのケースすべてに存在することを忘れないでください。を使用しても、最悪の場合の分析を意味するわけではありません。$O$

参考文献

アルゴリズム分析にはさらに多くの課題とコツがあります。ここにいくつかの推奨読書があります。

• アルゴリズムのランタイムをどのように考え出すのですか？
  アルゴリズムを記述し、それらを証明し、分析する方法は？
• 2つのアルゴリズムの比較にランタイムではなく比較を使用する理由
  数値の基本的な操作に一定の時間がかかると仮定するにはどうすればよいですか？
  ランタイム分析で1つの時間単位を構成するものは何ですか？
• 数列の再帰関係の解決または近似
• 償却分析の基礎

これに類似した手法を使用するアルゴリズム分析にタグ付けされた質問が数多くあります。

ステートメントの実行カウント

ドナルドE.クヌースが彼のThe Art of Computer Programmingシリーズで支持している別の方法があります。アルゴリズム全体を1つの式に変換するのとは対照的に、「物事をまとめる」側のコードのセマンティクスとは独立して機能し、「イーグルズアイ」ビューから開始して、必要な場合にのみ下位レベルに移動できます。すべてのステートメントは、他のステートメントとは無関係に分析でき、より明確な計算につながります。ただし、この手法は、より高度な擬似コードではなく、かなり詳細なコードに適しています。

方法

原理的には非常に簡単です：

1. すべてのステートメントに名前/番号を割り当てます。
2. すべてのステートメントコストます。$S_i$$C_i$
3. すべてのステートメントの実行回数決定します。$S_i$$e_i$

4. 総コストを計算する

   $\qquad\displaystyle C = \sum_{i} e_i \cdot C_i$。

推定値および/またはシンボリック量を任意のポイントに挿入できるため、それぞれを弱めます。それに応じて結果を一般化します。

手順3は任意に複雑になる可能性があることに注意してください。通常は、結果を取得するために「」などの（漸近的な）推定値を使用する必要があります。$e_{77} \in O(n \log n)$

例：深さ優先検索

次のグラフ走査アルゴリズムを検討してください。

dfs(G, s) do
  // assert G.nodes contains s
  visited = new Array[G.nodes.size]     1
  dfs_h(G, s, visited)                  2
end 

dfs_h(G, s, visited) do
  foo(s)                                3
  visited[s] = true                     4

  v = G.neighbours(s)                   5
  while ( v != nil ) do                 6
    if ( !visited[v] ) then             7
      dfs_h(G, v, visited)              8
    end
    v = v.next                          9
  end
end

（無向）グラフは、ノード隣接リストによって与えられると仮定します。してみましょう辺の数です。$\{0,\dots,n-1\}$$m$

アルゴリズムを見るだけで、一部のステートメントが他のステートメントと同じ頻度で実行されることがわかります。実行カウントいくつかのプレースホルダー、、およびを導入します。$A$$B$$C$$e_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & A & A & B & B & B & B+C & C & B-1 & C \end{array}$

特に、は、8行目のすべての再帰呼び出しが3行目の呼び出しを引き起こします（1つはからの元の呼び出しが原因です）。さらに、。条件は反復ごとに1回チェックする必要がありますが、それを終了するにはもう一度チェックする必要があります。$e_8 = e_3-1$foodfs$e_6 = e_5 + e_7$while

あることは明らかです。さて、正当性の証明中に、ノードごとに1回だけ実行されることを示します。つまり、です。しかし、その後、すべての隣接リストを正確に1回反復し、すべてのエッジが合計2つのエントリ（インシデントノードごとに1つ）を意味します。合計反復を取得します。これを使用して、次の表を導き出します。$A=1$foo$B = n$$C = 2m$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & 1 & 1 & n & n & n & 2m + n & 2m & n-1 & 2m \end{array}$

これにより、正確に合計コストが発生します

$\qquad\begin{align*} C(n,m) = (C_1 + C_2 - C_8) &+\ n \cdot (C_3 + C_4 + C_5 + C_6 + C_8) \\ &+\ 2m \cdot (C_6 + C_7 + C_9) \;. \end{align*}$

適切な値をインスタンス化することにより、より具体的なコストを導き出すことができます。たとえば、メモリアクセスを（ワードごとに）カウントする場合は、次を使用します。$C_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline C_i & n & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 \end{array}$

そして得る

$\qquad\displaystyle C_{\text{mem}}(n,m) = 3n + 4m$。

参考文献

私の他の答えの一番下を参照してください。

定理証明のようなアルゴリズム分析は、大部分が芸術です（たとえば、分析方法がわからない単純なプログラム（Collat​​z問題など）があります）。Raphaelが包括的に回答したように、アルゴリズムの複雑さの問題を数学的な問題に変換できますが、既知の関数に関してアルゴリズムのコストの限界を表現するために、次のことを行います。

1. 既存の分析でわかっている手法を使用します。たとえば、理解している繰り返しに基づいて境界を見つけたり、計算できる合計/積分を使用したりします。
2. アルゴリズムを分析方法がわかっているものに変更します。
3. まったく新しいアプローチを考え出します。