web-dev-qa-db-ja.com

バックトラッキングアルゴリズムの時間の複雑さを計算する方法は？

これらのバックトラッキングアルゴリズムの時間の複雑さを計算する方法と同じ時間の複雑さを持っていますか？どう違う？親切に詳細に説明し、助けてくれてありがとう。

1. Hamiltonian cycle:

        bool hamCycleUtil(bool graph[V][V], int path[], int pos) {
            /* base case: If all vertices are included in Hamiltonian Cycle */
            if (pos == V) {
                // And if there is an Edge from the last included vertex to the
                // first vertex
                if ( graph[ path[pos-1] ][ path[0] ] == 1 )
                    return true;
                else
                    return false;
            }

            // Try different vertices as a next candidate in Hamiltonian Cycle.
            // We don't try for 0 as we included 0 as starting point in in hamCycle()
            for (int v = 1; v < V; v++) {
                /* Check if this vertex can be added to Hamiltonian Cycle */
                if (isSafe(v, graph, path, pos)) {
                    path[pos] = v;

                    /* recur to construct rest of the path */
                    if (hamCycleUtil (graph, path, pos+1) == true)
                        return true;

                    /* If adding vertex v doesn't lead to a solution, then remove it */
                    path[pos] = -1;
                }
            }

            /* If no vertex can be added to Hamiltonian Cycle constructed so far, then return false */
            return false;
        }

2. Word break:

       a. bool wordBreak(string str) {
            int size = str.size();

            // Base case
            if (size == 0)
                return true;

            // Try all prefixes of lengths from 1 to size
            for (int i=1; i<=size; i++) {
                // The parameter for dictionaryContains is str.substr(0, i)
                // str.substr(0, i) which is prefix (of input string) of
                // length 'i'. We first check whether current prefix is in
                // dictionary. Then we recursively check for remaining string
                // str.substr(i, size-i) which is suffix of length size-i
                if (dictionaryContains( str.substr(0, i) ) && wordBreak( str.substr(i, size-i) ))
                    return true;
            }

            // If we have tried all prefixes and none of them worked
            return false;
        }
    b. String SegmentString(String input, Set<String> dict) {
           if (dict.contains(input)) return input;
           int len = input.length();
           for (int i = 1; i < len; i++) {
               String prefix = input.substring(0, i);
               if (dict.contains(prefix)) {
                   String suffix = input.substring(i, len);
                   String segSuffix = SegmentString(suffix, dict);
                   if (segSuffix != null) {
                       return prefix + " " + segSuffix;
                   }
               }
           }
           return null;
      }


3. N Queens:

        bool solveNQUtil(int board[N][N], int col) {
            /* base case: If all queens are placed then return true */
            if (col >= N)
                return true;

            /* Consider this column and try placing this queen in all rows one by one */
            for (int i = 0; i < N; i++) {
                /* Check if queen can be placed on board[i][col] */
                if ( isSafe(board, i, col) ) {
                    /* Place this queen in board[i][col] */
                    board[i][col] = 1;

                    /* recur to place rest of the queens */
                    if ( solveNQUtil(board, col + 1) == true )
                        return true;

                    /* If placing queen in board[i][col] doesn't lead to a solution then remove queen from board[i][col] */
                    board[i][col] = 0; // BACKTRACK
                }
            }
        }

Word Break（b）の複雑さはO（2n）しかし、ハミルトニアンサイクルの場合は異なるため、同じ文字列の異なる順列を出力する場合も、nクイーンの問題を解決する場合も同じです。

algorithmcomplexity-theorytime-complexitybacktracking
21
da3m0n

要するに：

  1. ハミルトニアンサイクル：最悪の場合のO(N!)
  2. WordBreakおよびStringSegment：O(2^N)
  3. NQueens：O(N!)

注：WordBreakには、O（N ^ 2）動的プログラミングソリューションがあります。

詳細：

  1. ハミルトニアンサイクルでは、各再帰呼び出しで、最悪の場合、残りの頂点の1つが選択されます。各再帰呼び出しでは、分岐係数は1ずつ減少します。この場合の再帰は、各ループで反復回数が1ずつ減少するn個のネストされたループと考えることができます。したがって、時間の複雑さは次のようになります。

    T(N) = N*(T(N-1) + O(1))
    T(N) = N*(N-1)*(N-2).. = O(N!)

  2. 同様に、NQueensでは、分岐係数が1以上減少しますが、多くはありません。したがって、O(N!)の上限

  3. WordBreakの場合はより複雑ですが、おおよそのアイデアをお伝えできます。 WordBreakでは、最悪の場合、文字列の各文字に2つの選択肢があります。前のWordの最後の文字か、新しいWordの最初の文字です。したがって、分岐係数は2です。したがって、WordBreakとSegmentString T(N) = O(2^N)

24
Vikram Bhat

バックトラッキングアルゴ：

n-queen問題：O（n！）

グラフの色付けの問題：O（nm ^ n） // where n = no。頂点の、m = no。使用色の

ハミルトンサイクル：O（N！）

WordBreakとStringSegment：O（2 ^ N）

サブセット合計問題：O（nW）

3
Shyam Bhimani