如何计算这些回溯算法的时间复杂度,它们是否具有相同的时间复杂度?如果不同怎么样?请详细解释并感谢您的帮助。
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(2 n )但是对于哈密尔顿循环它的不同,因此打印相同字符串的不同排列和然后再次解决n皇后问题。
答案 0 :(得分:19)
O(N!)
O(2^N)
O(N!)
注意:对于WordBreak,有一个O(N ^ 2)动态编程解决方案。
在哈密顿循环中,在每次递归调用中,在最坏的情况下选择剩余顶点之一。在每次递归调用中,分支因子减少1.在这种情况下的递归可以被认为是n个嵌套循环,其中在每个循环中迭代次数减少1。因此,时间复杂度由下式给出:
T(N) = N*(T(N-1) + O(1))
T(N) = N*(N-1)*(N-2).. = O(N!)
同样在NQueens中,每次分支因子减少1或更多,但不多,因此O(N!)
的上限
对于WordBreak它更复杂,但我可以给你一个近似的想法。在WordBreak中,字符串的每个字符在最坏的情况下有两个选择,要么是前一个单词中的最后一个字母,要么是新单词的第一个字母,因此分支因子是2.因此对于WordBreak和&amp; SegmentString T(N) = O(2^N)
答案 1 :(得分:2)
回溯算法:
n-queen问题: O(n!)
图形着色问题: O(nm ^ n) //其中n = no。顶点,m =否。使用的颜色
汉密尔顿周期: O(N!)
WordBreak和StringSegment: O(2 ^ N)
子集求和问题: O(nW)