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 taskif l < r: todo_list.append((l, r, 1)) # merge tasktodo_list.append((l, l + (r - l) / 2, 0)) # sort tasktodo_list.append((l + (r - l) / 2 + 1, r, 0)) # sort taskelse: # merge task: simple taski, j, k = l, l + (r - l) / 2 + 1, lwhile i <= l + (r - 1) / 2 and j <= r:if A[i] < A[j]: aux[k] = A[i]i += 1else:aux[k] = A[j]j += 1k += 1while i <= l:aux[k] = A[i]k, i = k + 1, i + 1while j <= r:aux[k] = A[j]k, j = k + 1, j + 1for 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的例子中，终端任务不能先做，所以先压到箱底。