1. We should go over "Counting Inversion" which is section 5.3 of the 
book. Given a sequence (of unique numbers) $a_1, a_2, \ldots, a_n$ we 
want to find the number of pairs $i < j$ such that $a_i > a_j$.
To solve the problem we simultaneously merge-sort $a_1, a_2, \ldots, 
a_n$, and count the number of inversions. This is easily done when 
merging. You should just add the number of numbers left in the first half 
when you are merging two halves when the number in the front of the second 
half is being added. The following code does this.

(int, list) MergeCount(int from, int to) {
	if(to == from + 1) return (0, A[from..to]);
	int mid = (from+to)/2;
	int res = 0, sub_solution = 0;
	(sub_solution, A[from..mid]) = MergeCount(from, mid);
	res += sub_solution;
	(sub_solution, A[mid..to]) = MergeCount(from, mid);
	res += sub_solution;
	int Sol[];
	for(int x=from, y=mid;(x<mid)&&(y<to);)
		if(A[x] < A[y]) Sol.put_back(A[x++]);
		else {
			Sol.put_back(A[y++]);
			res += (mid - x);
		}
	for(;x<mid;x++) Sol.put_back(A[x]);
	for(;y<to;y++) Sol.put_back(A[y]);
	return (res, Sol);
}

The analysis is the same as that of merge-sort. 

2. Problem 6 in chapter 5 of the book:

In this problem we want to find a local minima in a huge complete 
binary tree of height $d$. Each node $v$ of the tree is labeled with a 
real number $x_v$. We want to find a node in the tree whose label is less 
than the labels of all its neighbors. We can query the label of any node 
in the tree but we want to keep the number of queries O(d).
The solution is to start at the root, and in each step if the current 
node has a child with smaller label we go to that child. This way the 
label of the current node is always less than the label of its parent, so 
as soon as we find a node with label less than that of its children we 
are done. As the tree has height $d$, we query a maximum of $2d+1$ nodes.

Another way to see it using the Master Theorem is that we always call one 
copy of the computation with the new n being (n-1)/2, and the amount of
work performed at every stackframe is O(1). Thus
T(n)=T(n/2)+O(1) => T(n)=O(log n).