C++博客-hex108-随笔分类-Algorithm

[找工作]算法小结

hex108 — Wed, 24 Aug 2011 13:39:00 GMT

为一个问题寻找算法的过程，有点像一个穷举过程：搜索已有知识，并进行重组的过程。所以把常用的算法记住，然后一个一个试用，看是否可行，不失为一个好方法。

如果这个方法不行呢？不妨写出最直观的解答（即用“蛮力法”），然后从中看出可以优化的地方在哪里，进而进行优化。

如何确定该问题可以用哪类方法来解答呢？首先，需要对这些常用的算法的基本思想非常熟悉。
常用的算法可以分为以下几类：

1. Divide & conquer
   分治算法：将问题分为两个1／2规模大小的子问题，然后解决。如merge sort

2. Decrease & conquer
   减治法 : 将问题规模从 n 变为 n - 1，然后在规模n-1的基础上解决此问题。如insertion sort
   这不是递归么？

3. Transform & conquer
   变治法：变换结构。如heap sort

4. Brute force
   蛮力算法，可以说是必杀技吧，大部分问题都可以用此方法解决。如selection sort
   使用蛮力法的优点是简单不容易出错，缺点是复杂度有时很高，所以我们可以在穷举法的基础上进行改进，这样能达到一举双得的效果。
   Backtracking(回溯法) 是 Brute fore搜索算法的一种，它通常用最简单的递归方法来实现，在最坏的情况下，回溯法会导致一次复杂度为指数时间的计算。其比较经典的运用是：N皇后问题。

其次，数据结构有时候会决定算法，例 Transform & conquer。

另外在TopLanguage上看到的一些有用的观点：
1. 算法里面极大一部分内容是如何有效地进行搜索，这里的"有效"可以分为：避免不必要的计算（如A*寻路以及所有的启发式剪枝），缓存重复计算（如所有的动态规划）。
2.本质上，练习并不产生新能力。然而练习最重要的一个作用就是将外显记忆转化为内隐记忆。用大白话来说就是将平时需要用脑子去想（参与）的东西转化为内在的习惯。譬如我们一开始学骑自行车的时候需要不断提醒自己注意平衡，但随着不断的联系，这种技能就内化成了所谓的程序式记忆
这就是熟能生巧吧。

hex108 2011-08-24 21:39 发表评论

[找工作]动态规划与贪心算法

hex108 — Wed, 24 Aug 2011 12:51:00 GMT

1. 动态规划

Dynamic programming, like the divideand-conquer method, solves problems by combinging the solutions to subproblems.

1) 动态规划适用于优化问题：从很多个解中找到最优解。(Dynamic progrmming is typicall applied to optimization problems.)

   2) 适合用动态规划解决的问题有两个特征：
      a. optimal substructure(http://en.wikipedia.org/wiki/Optimal_substructure)
         用一个公式化的式子把它的solution表示出来会更清晰。
      b. overlapping subproblems
         如果不是overlapping subproblems，用分治法就可以解决了。动态规划正是利用了重复子问题这个特性，将子问题的解存起来以便重复利用。

   3) 如何划分子问题
      以问题 "An activity-selection problem"为例，CLRS划分的方法和我的就不同。
      注意：如果划分的子问题之间存在依赖，那么该问题就不适合用动态规划解决。（见CLRS 15.3 subtlties小节）

    4) reconsturcting an optimal solution
      用动态规划有个问题就是在最后得到最优解时不能知道选择的过程，有如下两种方法可以解决：

      a. 可以根据我们存下来的信息推导出前一步的选择是什么，如：diff.java
      b. 记下选择。
   如果选择较少可以采用方法a，否则选择方法2比较好。这是一个时空权衡问题。

    5）运用动态规划有几个需要注意的地方：
       a. We must ensure that when we search for the correct place to spilt the product, we have considered all possible places so that we are sure of
            having examined the optimal one.
     b. The subproblems are independent.

c. 不要形成困定思维: 一想到动态规划，马上联想到LCS，然后觉得动态规划的表结构就是一个二维数组

6)思考
子问题有最优解，那么该问题得到的一定是最优解吗？如果不是，那么什么情况下是全局最优解，什么情况是局部最优解?

以＜编程之美＞上的一个例子举例说明如下 :(有时间再补上)

2. 贪心算法

A greedy algorithm always makes the choice that looks best at the moment. That is , it makes a locally optimal choce in the hope that chis choce will lead to a globally optimal solution.

贪心法能解决的问题，动态规划基本都能解决。（CLRS 16.2 Nevertheless, beneath every greedy algorithm, ther is almost always a more cumbersome dynamic-progrmming solution）。

   但是：For many optimization problems, using dynamic programming to determine the best choices is overkill; Simpler, more effiiect algorithms will do. (eg: greedy algorithm)

     1）适合用贪心法解决的问题
         必须要有Greedy-choice property : a globally optiaml solution can be arrivedat by making a locally optimal (greedy) choice.
         如：Huffman编码，最小生成树

2）贪心法的一般步骤
a. 将原问题划分为子2个子问题（非overlap的），此时就能用动态规划求解了

b. 找到一个划分点，让其中一个子问题变为空，则只剩下一个子问题了，这就是贪心算法

3）使用贪心法时必须保证：

We must prove that a greedy choice at each step yields a golbally optimal solution, and this is where cleverness may be required.
这点也是最难的。所以有个问题“什么情况下，局部最优最终会产生全局最优的结果？”

       4）适用贪心算法的问题有 greedy-choice propertty，需要找到一个贪心策略。

       5）对于找不到全局最优解的问题（如NP问题），可以考虑贪心算法。

3. 动态规划与分治法的比较

    分治法适合于那些能被分解为独立子问题的问题；动态规划更适用于子问题之间不是独立的，而是会share subproblems。动态规划的这个特点得益于它把子问题的结果都保存在一个表中了（动态规划的英文名字是Dynamic Programming，这里的Programming可理解为a tabular method(表格方法)），这样就能少去重复子问题的计算。所以动态规划可以算作是分治法在overlapping 子问题里的一个优化（这个优化在程序中是常见的优化方法Memoization（http://en.wikipedia.org/wiki/Memoization））

4. 动态规划与贪心法的比较
   1) 相同点
     a. 问题要有optimal substructure

        A problem exhibits optimalsubstructure if an optimal solution to the problem contains within it optimal solutions to subproblems.
        这是能用贪心法与动态规划解答的问题的关键因素。
     b. 都需要划分子问题，但是划分子问题的方式有些区别，见下面的不同点。

   2）不同点
     a. 划分子问题

如果你把划分的子问题有交集(overloapping subproblem)，这就很显然地将你引入了动态规划的思维，以"An activity-selection problem"举例说明：

对于问题 "An activity-selection problem"，很容易就能想到动态规划的解法

int select_activity(int *a, int n, int i)

{

if(i >=n )

return 0;

for(j= i + 1; j < n; j ++){

if(a[j].start >= a[i].end)

break;

}

int sum1 = select_activity(a, n, j) + 1; //select the ith activity

int sum2 = select_activity(a, n, i + 1); //not select the ith activity

if(sum1 > sum2)

return sum1;

else

return sum2;

}

但是如何将它转化为贪心算法呢？
答案是：由这种方法是不易转化为贪心法的。上面这种划分子问题的方式表明了它更适合于动态规划，就像在CLRS 383页里说到的0-1背包问题：The problem formulated in this way gives rise to many over-lapping subproblems － a hallmark of dynamic programming.

b. 贪心法： make whaterver choice seems best a the moment and then solve the subproblem arising after the choice is made.

动态规划：make a choice at each step, but the choice usually depends on the solutions to subproblems.

c. 贪心法：top-down fashinon
动态规划：bottom-up manner

hex108 2011-08-24 20:51 发表评论

[找工作]数据结构小结

hex108 — Wed, 24 Aug 2011 12:15:00 GMT

要找工作了，终于觉得是时候总结一下数据结构了（ps: 对于数组，链表这样简单常用的结构就不总结了，此文会持续更新），总结有助于更好地思考。

1. 位图
位图的威力可以在＜编程珠玑＞的开头就体会到。另外在Find an integer not among four billion given ones中的运用也很精彩。

2. 堆

   在＜编程珠玑＞里重点运用了该结构，直接导致我以后经常想到并使用该结构。
   不得不说，它真的很有用，如：找N个数中最大／最小的k个数。
   实现优先级队列时也有用。

3. 树

     二叉搜索树：是一个很容易就能想到的结构，只要让一棵二叉树满足以下一个特性就可以了：对于任一结点N，其左子树结点left满足key(x) <= key(N)，其右子树结点right满足key(y) >= key(N)，其优点是操作简单，缺点是插入，删除结点的复杂度高，为O(N)
     二叉搜索树复杂度高的原因为：树的高度不确定/不稳定，有可能为n，所以问题的关键是：如何控制树的高度
     很多人灵机一动:产生了一系列平衡二叉树，如：AVL树，Red-Black树，Treap
     也产生了很多平衡二叉树的变种，如：Weight balanced tree，k-neighbor tree等
     Skip List 也是平衡二叉树之外的另一种选择
     Trie树用来存储一个字典，然后用来查找某个字符串还是很方便的（A trie can be seen as a deterministic finite automaton.）另外可以看看Suffix_tree后缀树。

4. hash
    hash的两个关键点在于：a. hash桶大小的设定（一般为一个素数） b. 冲突处理机制，如可以用一个链表处理hash值相同的元素。
    我很少考虑hash，觉得复杂度不好把握。以后倒是可以考虑用用，如：在问题“判断两个链表是否相交”有可以使用hash；“判断链表有没有环”用hash也很给力。

hex108 2011-08-24 20:15 发表评论

关于算法的一些资料

hex108 — Fri, 01 Jul 2011 12:27:00 GMT

算法的过程很详细，美中不足的是最基本最常用的那些算法其实是比较少的，花点时间多想想为什么，知其然还要知其所以然(1，2)，这样才能活学活用。

1. 书
1.1 编程珠玑
言简意赅，回味无穷。本书的网络版在 http://netlib.bell-labs.com/cm/cs/pearls/ 上，附有源代码。这里有我的读书总结。受到此书的影响，我对代码产生了很强的洁癖，坚信代码还可以写得更优美，更艺术。此外面对一个问题时分析的角度更多了。

1.2 编程之美
书上的每个题都会仔细地做，并完成代码。思考的乐趣是无穷的，时常会有乐趣。

1.3 算法导论
经典但是比较厚，适合系统地学习算法，而后每次遇到不懂的可以再查阅，

算法的过程很详细，美中不足的是没有知其所以然的感觉。看此书第一遍时，是按照书的顺序看的，对这些算法大致都有熟悉了。后来会偶尔查阅。现在为了准备算法，会时常查阅此书。

2. 文章
2.1 Do We Teach the Right Algorithm Design Techniques ?
把算法按其通用程度提出了4个最基本的算法思想：Brute force ， Divide & conquer ， Decrease & conquer， Transform & conquer。
读完后可以对算法的整体有更好的掌握。

3. 网络教程
3.1 Top Coder的algorithm tutorial

hex108 2011-07-01 20:27 发表评论

二分查找 -- 来自编程珠玑

hex108 — Sat, 18 Jun 2011 07:02:00 GMT

     二分查找法（Binary search algorithm）是一个很常见的算法，从＜编程珠玑＞里再次看到时又有新的收获。
   直接看代码吧，下面是常见的实现代码：

int binary_search(int *a, int num, int t)
{
    int start = 0, end = num - 1;

    while(end >= start){
        int middle = (start + end) / 2;
        int tmp = a[middle];
        if(tmp < t){
            start = middle + 1;
        }else if(tmp > t){
            end = middle - 1;
        }else{
            return middle;
        }
    }

    return -1;
}

优化后的代码为（这个优化的思想也挺好的，不知道有没有一套系统的方法来思考出这个优化思路）：

int binary_search(int *a, int num, int t)
{
    int low = -1, high = num - 1;

    while(low + 1 != high){
        int middle = (low + high) / 2;
        if(a[middle] < t){
            low = middle;
        }else{
            high = middle;
        }
    }

    if(a[high] != t)
        return -1;
    else
        return high;
}

如果直接看这段代码，有可能不知道是怎么回事。但是运用书中提到的“程序验证”的方法后，原理就显而易见了，修改后的代码为：

1 int binary_search(int *a, int num, int t)
2 {
3     int low = -1, high = num - 1;
4
5     //invariant: low < high && a[low] < t && a[high] >= t
6     while(low + 1 != high){
7         int middle = (low + high) / 2; ＝＝＞ int middle = low + (high - low) / 2;   //防止溢出
8         if(a[middle] < t){
9             low = middle;
10         }else{
11             high = middle;
12         }
13     }

14 //assert：　low +1 = high && a[low] < t && a[high] >= t

15
16     if(a[high] != t)
17         return -1;
18     else
19         return high;
20 }
21

“程序验证” 的思想可以简述为：不管是验证一个函数，还是一条语句，一个控制结构（循环，if分支等），都可以采用两个断言（前置条件和后置条件）来达到这个目的。前置条件是在执行该处代码之前就应该成立的条件，后置条件的正确性在执行完该处代码后必须得到保证。（ps: 断言也算是一种验证的手段）

　　上面这段代码的原理是给定一段区间 (low, high] ，如果満足 a[low] < t && a[high] >=t && high = low + 1，那么有两种情况存在：1. a[high] = t ; 2.与t相等的元素不存在。由于数组a 肯定满足条件a[low] < t && a[high] >=t，所以该算法要做的就是把区间 (-1, num -1] 缩小到(low, low+1]。　
1. 在执行代码6~17行时，始终保证low < high && a[low] < t && a[high] >= t 成立。
　　2. 在执行完6~17行后，肯定滿足条件a[low] < t && a[high] >=t && high = low + 1，因为循环退出的条件是 high = low + 1，而该循环始终保证上面第１条。
　　经过这样的分析后，我们能对程序的正确性有更好的掌握，同时程序也更易理解。

参考：
　　１. 基本上摘自＜编程珠玑＞，很不错的一本书，让我对算法有了新的思考，以前只是看看算法导论如何实现的，没有思考该算法是如何想出来的，有没有更简单的算法（思考的过程类似刘未鹏的＜知其所以然（续）＞），要坚持这个思考过程需要很多功夫与时间，但效果也很明显，能对算法有更好的掌握。

hex108 2011-06-18 15:02 发表评论