Độ phức tạp thời gian của Độ sâu Tìm kiếm Đầu tiên [đã đóng]

Xin vui lòng tha thứ cho tôi vì đã hỏi một câu hỏi mới làm quen, nhưng tôi là người mới bắt đầu với các thuật toán và độ phức tạp, và đôi khi thật khó để hiểu được sự phức tạp của một thuật toán cụ thể đã xảy ra như thế nào.

Tôi đã đọc thuật toán DFS từ Giới thiệu về thuật toán của Cormen và đây là thuật toán:

G        -> graph
G.V      -> set of vertices in G
u.π      -> parent vertex of vertex u
G.Adj[u] -> adjacency list of vertex u


DFS(G)
1   for each vertex u ∈ G.V
2       u.color = WHITE
3       u.π = NIL
4   time = 0
5   for each vertex u ∈ G.V
6       if u.color == WHITE
7         DFS-VISIT(G,u)

DFS-VISIT(G,u)
1   time = time + 1            // white vertex u has just been discovered
2   u.d = time
3   u.color = GRAY
4   for each v ∈ G.Adj[u]      // explore edge u
5       if v.color == WHITE
6           v.π = u
7           DFS-VISIT(G,v)
8   u.color = BLACK            // blacken u; it is finished
9   time = time + 1
10  u.f = time

Sau đó nó nói dòng 1-3và 5-7là O(V), không bao gồm thời gian để thực hiện các cuộc gọi đến DFS-VISIT(). Trong DFS-VISIT(), các dòng 4-7là O(E), bởi vì tổng các danh sách kề của tất cả các đỉnh là số cạnh. Và sau đó nó kết luận rằng tổng số phức tạp DFS()là O(V + E).

Tôi không hiểu điều đó xảy ra như thế nào. DFS-VISIT()được gọi là bên trong DFS() . Vì vậy, nếu dòng 5-7của DFS()là O(V)và DFS-VISIT()là O(E), sau đó không nên tổng độ phức tạp thời điểm DFS()được O(VE)?

Cuốn sách đang đếm số lần mỗi dòng được thực thi trong toàn bộ quá trình thực hiện lệnh gọi của DFS, thay vì số lần nó được thực hiện trong mỗi cuộc gọi của chương trình con DFS-VISIT. Có lẽ ví dụ đơn giản sau đây sẽ làm rõ điều này:

PROCEDURE A(n)
1  global = 0
2  for i from 1 to n:
3      B(i)
4  return global

PROCEDURE B(i)
1  global = global + 1

Trong mỗi lần thực hiện của A, dòng 1 của B được thực hiện lần và bản thân B được thực hiện lần. Tuy nhiên, thời gian chạy là chứ không phải .$n$$n$$O(n)$$O(n^2)$

Đây là một ví dụ khác, trong đó một mảng có liên quan.$T[1\ldots n]$

PROCEDURE COUNT(n, T[1...n]):
1  count = 0
2  index = 1
3  while index <= n:
4    ADVANCE()
5    count = count + 1
6    index = index + 1
7  return count - 1

PROCEDURE ADVANCE():
1  while index <= n and T[index] == 0:
2    index = index + 1

Quy trình COUNT đếm số lượng 1 giây trong mảng đầu vào T. Mặc dù ADVANCE có thể được gọi tới lần bởi COUNT và thời gian chạy trường hợp xấu nhất của ADVANCE là , các dòng 1 Cách2 của ADVANCE chạy nhiều nhất lần và do đó tổng thời gian chạy là thay vì .$n$$O(n)$$n$$O(n)$$O(n^2)$