【无标题】

@Algorithm

Incremental Algorithms

Insertion Sort algorithm

1. 头递归

Require: 1 =< N <=A.length
procedure: Sort(A,N)
	if N == 1 then
		return
	end if
	Sort(A,N-1)
	INSERT(A,N)      //INSERT A[N] into the sorted array
end procedure
best case: Θ(N)
worst case: Θ(N^2)   //N-1此递归，一共比较1+2+3+。。。+N-1 = N(N-1)/2
sigma(N) and O(N^2)

T(N) = Θ（1） if N = 1
T(N) = T(N-1) +(N-1)c + d if N > 1

T(N-1) = T(N-2) +(N-2)c + d if N> 2
T(N) = T(N-2) +(N-1+N-2)c + 2d if N > 1
T(N) = T(N-i) + (N-i)c + … +(N-1)c + id if N > 1
T(N) = T(1) + (1 + 2 +…+ N-1)c + (N-1)d if N > 1
T(N) = Θ(N^2)

2. 尾递归

procedure Sort(A,N)
	if N == 1 then
		return
	end if
	SelectMax(A,N)  //选出除了最后一个元素外最大的数，和最后一位交换
	Sort(A,N-1)
end procedure

procedure SelectMax(A,N)
	for j<-1 to N-1 do
		if A[j] > A[N]
			Swap(A,j,N)
		end if
	end for
end procedure

3. PARTITION

procedure PARTITION(A,k)
	N <- A.length
	p <- 1
	for i<-1 to N do
		if A[i] < k then
			SWAP(A,i,p)
			p = p + 1
		end if
	end for
	return p
end procedure

Divide and Conquer

Require: 1 =< L < R <= A.length + 1
procedure MERGESORT(A,L,R)
	if R - L = 1
		return
	end if
	M <- (L + R) / 2
	MERGESORT(A,L,M)
	MERGESORT(A,M,R)
	MERGE(A,L,M,R)
end procedure

Require: 1 ≤ 𝐿 < 𝑀 < 𝑅 ≤ 𝐴.length + 1
1: procedure Merge(𝐴, 𝐿, 𝑀, 𝑅)
2: left ← Copy(𝐴, 𝐿, 𝑀)
3: right ← Copy(𝐴, 𝑀, 𝑅)
4: 𝑖 ← 1 // index in left
5: 𝑗 ← 1 // index in right
6: for 𝑘 ← 𝐿 to 𝑅 − 1 do
7: if 𝑖 > left.length or (𝑗 ≤ right.length and right[𝑗] < left[𝑖]) then
8: 𝐴[𝑘] ← right[𝑗]
9: 𝑗 ← 𝑗 + 1
10: else
11: 𝐴[𝑘] ← left[𝑖]
12: 𝑖 ← 𝑖 + 1
13: end if
14: end for
15: end procedure

master method

1. If 𝑓 (𝑁) = 𝑂(𝑁𝑐), where 𝑐 < log𝑏𝑎, then 𝑇(𝑁) = Θ(𝑁log𝑏𝑎).
2. If 𝑓 (𝑁) = Θ(𝑁log𝑏𝑎 × (log2𝑁)𝑘), then 𝑇(𝑁) = Θ(𝑁log𝑏𝑎 × (log2𝑁)𝑘+1).
3. If 𝑓 (𝑁) = Ω(𝑁𝑐), where 𝑐 > log𝑏𝑎, then 𝑇(𝑁) = Θ(𝑓 (𝑁)).
   比较Nlog𝑏𝑎和f(N)
   T(N) = 2T(N/2) + Nc
   a = 2, b = 2, f(N) = N
   logba = 1
   Nlogba x log2 k = N
   k = 0
   T(N) = Θ(Nlogba x log2N k+1) = Θ(Nlogn)

quicksort

procedure QUICKSORT(A,L,R)
	if R - L <= 1 then
		return
	end if
	P = PARTITION(A,L,R)
	QUICKSORT(A,L,P)
	QUICKSORT(A,P+1,L)
end procedure

复杂度
worst case: O(N^2)
best case: sigma(NlogN)

Dynamic Programming

𝑟(𝑖) = 𝑃[𝑖] + 𝑅(𝑁 − 𝑖)
𝑅(𝑁) = 𝑁max𝑖=1 𝑟(𝑖)
𝑅(𝑁)表示长度为N的最大收入
r(i)表示切下长度为i的最大收益

procedure RODCUTRECURSIVE(P,N)
	if N = 0 then
		return 0
	end if
	opt<-0
	for i<-1 to N do
		r <- P[i] + RODCUTRECURISIVE(P,N-i)
		opt <- Max(opt,r)
	end for
	return opt
end procedure

improvement

procedure RODCUTTOPDOWN(P,N)
	for i<- 0 to N do
		R[i] <- 0
	end for
	return RODCUTAUX(P,R,N)
	
procedure RODCUTAUX(P,R,N)
	if N = 0 then
		return 0
	end if
	if R[N] > 0 then
		return R[N]
	end if
	opt<-0
	for i<-1 to N do
		r <- P[i] + RODCUTRECURISIVE(P,R,N-i)
		opt <- Max(opt,r)
	end for
	R[N] <- opt
	return opt
end procedure

bottom-up dynamic programming algorithm for the rod cutting problem

procedure RodCutBottomUp(𝑃, 𝑁)
	R[0] <- 0 
	for i<- 1 to N do
		opt <- 0
		for j <- 1 to i do
			r <- p[j] + R[i - j]
			opt <- Max(r,opt)
		end for
		R[i] <- opt
	end for
return R[N]
end procedure