Recursive : Divide and Conquer(meta-algo II)

• Assume you have an algorithm that works.
• Use it to write an algorithm that works.
• till use brute force to get into the smallest problem(base case).

 meta-recursive algorithm

def recursiveAlgo(a,b,c){
//pre-cond: a,b,c
//post-cond: x,y,z

    if((a,b,c) is sufficently small instance) return (0,0,0)
    else{
        (asub1,bsub1,csub1) =a smaller part of (a,b,c)
        (xsub1,ysub1,zsub1) = recursiveAlgo(asub1,bsub1,csub1)

        (asub2,bsub2,csub2) =a diff smaller part of (a,b,c)
        (xsub2,ysub2,zsub2) = recursiveAlgo(asub2,bsub2,csub2)

        (x,y,z) = combine((xsub1,ysub1,zsub1),(xsub2,ysub2,zsub2))

        return (x,y,z)
    }

}

 

Trust your friends to solve sub-instances.

The sub-instance must be smaller and the same problem.

Combine solution given by friend to construct your own solution for your instance.

Focus on only one step.

Do not trace out the entire computation.

Consider your input instance:

Remember that you know nothing other than what is given to you by the precondition.

Be sure each path in your code returns what is required by the postcondition.

Do not worry about who your boss is OR how your friends solve their instance.

No global variable or effects.

From you instance, construct one or more subinstances.

Prove that the subinstances that you give to your friends are in some way "smaller" than your instance.

And you instance has a finite size.

Assume by magic (strong induction) your friends give you a correct solution for each of these.

If your instance is sufficiently small, sovle it yourself as a base case.

Your solution for the base case meets the postcondition.

T(n) = aT(n/b) + f(n)

evaluating: T(n) = a T(n/b) + f(n)

Level		Instance Size	work in stack frame	#stack frames	work in Level
0	.	n	f(n)	1	1 * f(n)
1	....	n/b	f(n/b)	a	a * f(n/b)
2		n/b2	f(n/b2)	a2	a2 * f(n/b2)
i	................	n/bi	f(n/bi)	ai
h=logn/logb	.................................	n/bh=1	T(1)	ah=alogbn=nlogba	nlogba * T(1)

 Total work: T(n) = Σ_i=0..h aⁱ * f(n/bⁱ)

 

Pros	Cons
Worry about one step at a time	Student resist it.
An abstraction within which to develop, think about,and describe algorithms in such way that their correctness is transparent.	expect too much from their friends.
	expect too much from their boss.

 

T(1)=1

T(2)=2

T(n)=T(n-1)+T(n-2)+3

//TowersOfHanoi
towersOfHanoi(n,source,dest,spare){
//pre-cond: the n smallest disks are on pole source
//post-cond: they are moved to pole dest

if(n==1)
move the single disk from source to dest

else{
towersOfHanoi(n-1,source,spare,dest);
towersOfHanoi(1,source,dest,spare);
towersOfHanoi(n-1,spare,dest,source);
}

//T(n)=2T(n-1)+1

//exponential
}

Four Recursive sorts

	Size of sublists
	n/2,n/2	n-1,1
Minimal effort splitting Lots of effort recombining	merge sort	insertion sort
Lots of effort splitting Minimal effort recombining	Quick sort	selection sort

  

Quick Sort

Best Time: T(n)=T(n/2)+T(n/2)+O(n):O(nlogn)

Worst Time: T(n)=T(0)+T(n-1)+O(n):O(n2)

Expected Time: T(n)=T(n/3)+T(2n/3)+O(n):O(nlogn)

 

K^th element problem

partition set into two using randomly chosen pivot, left OR right?

Best Time: T(n)=T(n/2)+O(n):O(n)

Worse Time:T(n)=T(n-1)+O(n):O(n2)

Expected Time: T(n)=T(2n/3)+O(n):O(n)

 

T(n)=T(n/2)+1:O(logN)

---

Recursion on Trees

a binary tree:

• the empty tree
• a node with a right and a left sub-tree

Most programmers don't use empty tree as a base case, This causes a lot more work.

Empty tree is cool as zero or -∞, to provide a base state.

3+4+8+2+...               | Sum so far is 17 3+4+8+2+... | Sum so far is 0	NewSum=OldSum+nextValue             = 0        +3             =3
3*4*2*3...            |Product so far is 72 3*4*2*3... |Product so far is 1	NewProd=OldProd*newValue              =1 * 3
True and True and False...                | So far is True |So far is True	new = Old and next        =True and True        =True
max(3,4,2...)               | max so far is 4        |max so far is -∞	max(tree)=max(left,right)+1

 

Time: T(n)=2T(n/2)+O(n)=O(nlogn)

                =2T(n/2)+O(n1)=O(nlognn)

 

def isBSTTree(tree,[min,max]):

"""pre-cond: tree is a binary tree. In addition,[min,max] is a range of values.
"""post-cond: the output indicates whether it is a binary search tree with values within this range.

    if(tree=emptyTree):
        return YES;
    elseif(rootkey(tree) in [min,max] and isBSTTree(leftSubTree(tree,[min,rootkey(tree)]) and isBSTTree(rightSubTree(tree),[rootkey(tree),max])):
        return YES;
    else:
        return NO;

 

转载于:https://www.cnblogs.com/grep/archive/2012/02/24/2367240.html