TODO List based 算法、任务分解、任务顺序、分治法

TODO List based 算法、任务分解、分治法

就是围绕一个TODO list，不断取出并处理其中的work item。处理work item的时候，一般先做一些工作，然后可能会产生新的子work item追加到todo list，类似一个大任务分解成若干小任务。

class ToList {
public:
    void append(WorkItem wi);
    WorkItem fetch();
}

注意这个todo list最自然的就是一个队列，实际上只要是支持添加(push)和取出(pop)的容器都可以，queue, stack, priority_queue, random_queue都行，取决于这些子任务之间是否独立，是否有顺序上的要求。
经典例子：
1快排
todo list中的work item定义为对数组的一段[a, b]进行快排

一开始todo list只有一个任务: 快排整个数组[0, A.size() - 1]，每个快排任务的处理是：

1）以第一个元素为轴进行partition

2）添加两个子快排任务到工作列表

int partition(vector<int> &A, int l, int r) {
	int i = l;
	for (int j = l + 1; j <= r; ++j)
		if (A[j] < A[l]) swap(A[++i], A[j]);
	swap(A[l], A[i]);
	return i;
}
void quick_sort(vector<int> &A) {
	if (A.empty()) return;
	queue<pair<int, int>> q;
	for (q.push(make_pair(0, A.size() - 1)); !q.empty(); q.pop()) {
		int l = q.front().first, r = q.front().second;	
		int p = partition(A, l, r);
		if (p - 1 > l) q.push(make_pair(l, p - 1));
		if (p + 1 < r) q.push(make_pair(p + 1, r));
	}
}

2bfs
任务定义：以s为起点进行遍历

任务处理：先打印s的数据。 然后针对s的每个邻居，（如果没被访问过），产生一个新bfs任务追加到todo list。

3进一步，todo list里的任务可以是多种任务，而且之间可以满足一定顺序，通过选用不同的容器。

经典的后序遍历问题，可以用todo list 任务列表算法很自然的表达：

def postorderTraversal(self, root):
    result, todo_list = [], [(root, 1)]
    if root is None: return result
    while len(todo_list) > 0:
        node, taskType  = todo_list.pop()
        if taskType == 1: # 1 for traverse job
            todo_list.append((node, 0)) # 0 for basic print job
            if node.right is not None: todo_list.append((node.right, 1))
            if node.left is not None: todo_list.append((node.left, 1))
        else: result.append(node.val)
    return result

定义2种类型的task, 

1) print task：打印该节点值

2) traverse task：遍历以该节点为根的树

对于第一种task的处理就是直接打印，对于第二种task，产生生成三个子task, 1个print task, 2个 traverse task，并注意task加入顺序，根, 右， 左

一开始工作列表里只有一个任务：后序遍历以root为跟的树，然后不断衍生子任务。。。

4 merge Sort

def mergeSort(A):
	todo_list, aux = [(0, len(A) - 1, 0)], [0] * len(A)
	while len(todo_list) > 0:
		l, r, type = todo_list.pop()
		if type == 0: # mergeSort task: compound task
			if l < r: 
				todo_list.append((l, r, 1)) # merge task
				todo_list.append((l, l + (r - l) / 2, 0)) # sort task
				todo_list.append((l + (r - l) / 2 + 1, r, 0)) # sort task
		else: # merge task: simple task
			i, j, k = l, l + (r - l) / 2 + 1, l
			while i <= l + (r - 1) / 2 and j <= r:
				if A[i] < A[j]: 
					aux[k] = A[i]
					i += 1
				else:
					aux[k] = A[j]
					j += 1
				k += 1
			while i <= l:
				aux[k] = A[i]
				k, i = k + 1, i + 1
			while j <= r:
				aux[k] = A[j]
				k, j = k + 1, j + 1
			for k in xrange(l, r + 1):
				A[k] = aux[k]

5全排列:

两种task：1）全排任务。2）swap 任务

def permute(A):
    todoList = [(0, 0, len(A) - 1)]
    while len(todoList) > 0:
        taskType, l, r = todoList.pop()
        if taskType == 0 and l == r: print A
        elif taskType == 0:
            for i in xrange(r, l - 1, -1):
                todoList.append((1, l, i))
                todoList.append((0, l + 1, r))
                todoList.append((1, l, i))
        else: 
            A[l], A[r] = A[r], A[l]

总结：

2种任务，终端任务和复合任务，终端任务是可以直接做的任务，复合任务是由一系列其他任务序列组成。在快排和BFS的例子中，并没有定义终端任务，因为终端任务处在任务序列前面（或者顺序无关）可以先做，不用放到todo list。而后序遍历和merge sort的例子中，终端任务不能先做，所以先压到箱底。