前言
先说一些题外的东西吧。受到春跃大神的影响和启发，推荐了这个算法公开课给我，晚上睡觉前点开一看发现课还有两天要开始，本着要好好系统地学习一下算法，于是就爬起来拉上两个小伙伴组团报名了。今天听了第一节课，说真的很实用，特别是对于我这种算法不扎实，并且又想找工作，提高自己的情况。 那就不多说废话了，以后每周都写个总结吧，就趁着这一个月好好把算法提高一下。具体就从：课堂笔记、leetcode和lintcode相关习题、hdu和poj相关习题三个方面来写吧。希望自己能够坚持下来，给大家分享一些好的东西。
outline：
- 第一境界：会写程序
- Find First Position of Target
- Find Last Position of Target
- 第二境界：找到第一个/最后一个满足某个条件的位置/值
- Search a 2D Matrix
- Find Minimum in Rotated Sorted Array
- 第三境界：保留有解的那一半
- Find Peak Element
课堂笔记
二分查找这类题以前接触的也算是比较多的了，所以还算相对熟悉，但今天听老师讲过以后，还是觉得有了很多新的认识，最有印象的就是令狐老师讲的三个境界：
1. 第一境界：会写程序
这个境界我自认为在刷了那么多leetcode之后算是没有问题的了，套了不少模版，虽然还有一些边界问题考虑不周全，但是经过调试，应该没有什么问题，经过几次面试，也面到过Binary Seach。想必大家也有很好的基础。 正如老师说的，这个境界还是存在一些问题，比如解决二分程序的三大痛点、权衡递归与非递归。 对于第一个问题，其实就是start和end的位置选取，比如容易进入死循环，或者容易分不清楚到底应该是start = mid还是start = mid+ 1等。以下给出一个代码模版，这个也是我之前写二分问题经常会写的样子：
int start = 0, end = nums.size() - 1;
while (start < end){
int mid = (start + end)/2;
if (...) {...}
else if (...) {...}
else {...}
}
想必大家都会把循环条件写成start < end或者start <= end这样的，这样在一些情况下也确实没有问题（这里直接上一个题）：
Find First Position of Target
http://www.lintcode.com/zh-cn/problem/first-position-of-target/
给定一个排序的整数数组（升序）和一个要查找的整数
target，用O(logn)的时间查找到target第一次出现的下标（从0开始），如果target不存在于数组中，返回-1。样例
在数组
[1, 2, 3, 3, 4, 5, 10]中二分查找3，返回2。
这个题应该是Binary Search最基础的题，直接套用模版就可以，以下是这个题的代码（Bug Free）：
int binarySearch(vector<int> &array, int target) {
if (!array.size()) return -1;
int start = 0, end = array.size() - 1;
while (start < end) {
int mid = (start + end) >> 1;
if (array[mid] < target) {
start = mid + 1;
} else if (array[mid] > target) {
end = mid -1;
} else {
end = mid;
}
}
if (array[start] == target) return start;
return -1;
}
因为比较简单，就不再多说了，这里需要注意的几个点是，int mid = (start + end) >>1;其实就是int mid = (start + end)/1;因为在面试中如果会位运算的话，还是能够给面试官留下很好的印象。有的人说直接加起来除以2会溢出，其实start和end不会大到超过int的最大值的，因为一个vector也不会去开辟那么大的空间，但是写成`int mid = (end - start)/2 + start;`也能显得你比较不错。综上，两种方法都可以。 在这个题中因为是找第一个与target相等的值，所以用这种方法不会出问题，但是在考虑下面的题，就会出现问题：
Find Last Position of Target
http://www.lintcode.com/zh-cn/problem/last-position-of-target/
给一个升序数组，找到target最后一次出现的位置，如果没出现过返回
-1样例
给出 [1, 2, 2, 4, 5, 5].
target =
2, 返回2.target =
5, 返回5.target =
6, 返回-1.
错误代码如下：
while (start < end) {
int mid = ( start + end ) >>1;
if (A[mid] < target) { start = mid + 1; } else if ( A[mid] > target) { end = mid -1; } else { start = mid; }
}
这里如果这样写的话，代码就会进入死循环，因为在求mid的时候是向左边取整的。考虑这样的一个情况[...,5,5]，假设target为5，那么start就会一直向右靠近，最后到n-2的位置，而end此时为n-1，再次进入循环mid等于n-2，所以就进入了死循环。 根据课上老师所说的，建议大家写成start + 1 < end，最后再判断start和end（按照所需先后判断）即可，这种写法适用于所有的情况，不容易出现问题。 ps. 这里把条件写成如下也可行：
while (start + 1 < end) {
int mid = (start + end)>>1;
if (A[mid] > target) { end = mid;
} else { start = mid; }
}
因为start和end不管是否包括mid值都不影响最后的结果。 这个境界需要理解一个重点： 二分法实际上就是把区间变小的问题，把一个长度为n的区间变为n/2，然后再变小，即：
T(n) = T(n/2) + O(1) = O(logn)
通过O(1)的时间，把规模为n的问题变为n/2 当面试的时候，有O(n)的解，如果面试官需要你进一步优化，那么很大可能就是需要用二分O(logn)的方法来做。 实际上的步骤：
**区间缩小-> 剩下两个下标->判断两个下表**
**注：不要把缩小区间和得到答案放在一个循环里面，容易出问题，增加难度**
2. 第二境界：找到第一个/最后一个满足某个条件的位置/值
这个境界就是第一个境界的进阶版本，就是能够把一些实际的应用问题转换为二分的核心问题：把具体的问题转变为找到数组中的额第一个/最后一个满足某个条件的位置/值。
就不多说了，直接上题吧：
Seach a 2D Matrix
http://www.lintcode.com/zh-cn/problem/search-a-2d-matrix/
写出一个高效的算法来搜索 m × n矩阵中的值。
这个矩阵具有以下特性：
- 每行中的整数从左到右是排序的。
- 每行的第一个数大于上一行的最后一个整数。
样例
考虑下列矩阵：
[ [1, 3, 5, 7], [10, 11, 16, 20], [23, 30, 34, 50] ]给出
target = 3，返回true
这道题最简单的方式就是对每一行进行一次二分查找，第一行没有找到就找第二行，以此类推，那么时间复杂度为0(nlogn)。 如果需要再进行优化，那么可以这样考虑：因为条件中有每行的第一个数大于上一行的最后一个整数。所以我们可以先对每行的第一个数来进行一个二分查找，找到最后一个不大于target的数（注意这里是二分查找的核心思想）然后再对这一行进行二分查找即可，这样首先对每行的第一个数查找复杂度为0(logn)，再对某一行进行查找，复杂度为O(logn)，所以为O(logn)。代码如下(Bug Free)：
bool searchMatrix(vector<vector<int> > &matrix, int target) {
if (!matrix.size()||!matrix[0].size()) return false;
int start = 0, end = matrix.size() - 1;
while (start + 1 < end) {
int mid = (end - start)/2 + start;
if (matrix[mid][0] < target) start = mid;
else end = mid;
}
int new_start = 0,new_end = matrix[0].size()-1;
int index = matrix[end][0] <= target ?end:start;
while (new_start + 1 < new_end) {
int mid = (new_end - new_start)/2 + new_start;
if (matrix[index][mid] > target) new_end = mid;
else if (matrix[index][mid] < target)
new_start = mid;
else return true;
}
if (matrix[index][new_end] == target) return true;
if (matrix[index][new_start] == target) return true;
return false;
}
这个题关键在于要对两个端点的把握，还是二分查找的基本流程：先缩小区间，然后对两个剩余的端点进行判断。
当然这个题也有不需要进行两次计算的方法，因为当前行的所有元素严格大于第一行，所以可以把矩阵考虑为一维的数组，只需要在切换的时候进行一个行和列的转换即可，具体代码如下(Bug Free)：
bool searchMatrix(vector<vector<int> > &matrix, int target) {
if (!matrix.size()||!matrix[0].size()) return false;
int m = matrix.size();
int n = matrix[0].size();
int start = 0, end = n * m - 1;
while (start + 1 < end) {
int mid = (end - start)/2 + start;
int x = mid / n;
int y = mid % n;
if (matrix[x][y] > target) {
end = mid;
} else {
start = mid;
}
}
int x = start / n;
int y = start % n;
if (matrix[x][y] == target) {
return true;
}
x = end / n;
y = end % n;
if (matrix[x][y] == target) {
return true;
}
return false;
}
再来一个题吧：
Find Minimum in Rotated Sorted Array
http://www.lintcode.com/zh-cn/problem/find-minimum-in-rotated-sorted-array/
假设一个旋转排序的数组其起始位置是未知的（比如0 1 2 4 5 6 7 可能变成是4 5 6 7 0 1 2）。
你需要找到其中最小的元素。
你可以假设数组中不存在重复的元素。
样例
给出[4,5,6,7,0,1,2] 返回 0
这个题如果按照我以前的想法，就是最直观的办法：直接从头遍历，发现某一个值小于前一个值，并且小于后一个值，那么这个值就是最小的。这样的复杂度就是O(n)，我记得有一次面试的时候就是这么回答了，然后遭到了面试官无情的鄙视。 这里使用二分的话，是非常有技巧的，这个技巧也是对于之后难一些的题来说需要掌握的，我们要时刻不能忘记二分的宗旨：把具体的问题转变为找到数组中的额第一个/最后一个满足某个条件的位置/值。这题其实可以这么考虑：由最小值为中心把两边分开，两边都是递增的，而后一部分的最大值也严格小于前一部分的所有值，显然，最后一部分的最大值就是num[n-1]那么我们只需要找到比这个值小的第一个值即可。这里是不是又回到了最原始的问题。代码如下(Bug Free)：
int findMin(vector<int> &num) {
if (!num.size()) return 0;
int start = 0, end = num.size() - 1;
int target = num[end];
while (start + 1 < end) {
int mid = (end - start)/2 + start;
if (num[mid] <= target) {
end = mid;
}
else {
start = mid;
}
}
if (num[start] <= target) {
return num[start];
}
else {
return num[end];
}
}
这题稍微有一些和之前不一样的地方，就是在两个部分之间进行了一个权衡，在start和end的变换的地方，需要大家注意。
3. 第三境界：保留有解的那一半
有了前面两个阶段的铺垫，达到一定的训练以后，应该也差不多能够熟练掌握中等和简单的题了，其实足够深刻地理解了二分的精髓以后，可以把几个习题都做一遍，尽量还是达到Bug Free的级别吧（这里所说的Bug Free是指能够不用编译器的情况下，直接空手写代码，用眼睛和笔来调试，最后提交后Accepted）。
第三个阶段呢，其实就是回到了二分本身的定义，我的理解就是：二分法其实就是把问题不断缩小为原来的n/2，然后再找到相应的位置进行处理。那么二分法的最高境界就是学会去保留有答案的那一半，也许你心里会想：这个我本来就知道啊，但是真正到了实际操作的时候，还是会有搞不清楚的时候。贴出一道题：
Find Peak Element
http://www.lintcode.com/zh-cn/problem/find-peak-element/
给出一个整数数组(size为n)，其具有以下特点：
- 相邻位置的数字是不同的
- A[0] < A[1] 并且 A[n - 2] > A[n - 1]
假定P是峰值的位置则满足
A[P] > A[P-1]且A[P] > A[P+1]，返回数组中任意一个峰值的位置。样例
给出数组
[1, 2, 1, 3, 4, 5, 7, 6]返回1, 即数值 2 所在位置, 或者6, 即数值 7 所在位置.
这个题算是比较简单的题，但是重要的是理解其中的思想，还是回到二分法第三个阶段的核心：保留有答案的那一半。这道题只是要求找到其中一个峰值即可。峰值满足的条件就是左边的部分是单调递增的，而右边的部分是单调递减的（如果该点可导，并且导数为0，那么这个点就是峰值），我们很容易在纸上画出来某个点的四种情况（如下图所示）:
第一种情况：当前点就是峰值，直接返回当前值。
第二种情况：当前点是谷点，不论往那边走都可以找到峰值。
第三种情况：当前点处于下降的中间，往左边走可以到达峰值。
第四种情况：当前点处于上升的中间，往右边走可以达到峰值。
分析了四种情况，那么就容易把有答案的一半保留下来了，接下来就判断是否能够找到峰值即可。代码如下（Bug Free）:
int findPeak(vector<int> A) {
if (!A.size()) return 0;
int start = 0;
int end = A.size() -1;
while (start + 1 < end) {
int mid = (end - start)/2 + start;
if (A[mid] > A[mid - 1] && A[mid] > A[mid + 1]) {
return mid;
} else if (A[mid] <= A[mid+1] && A[mid] >= A[mid -1]) {
start = mid;
} else if (A[mid] >= A[mid+1] && A[mid] <= A[mid -1]) {
end = mid;
} else {
start = mid;
}
}
if (start >= 1 && A[start] > A[start - 1] && A[start] > A[start + 1]) return start; if (end <= A.size()-2 && A[end] > A[end-1] && A[end] > A[end+1]) return end;
}
这道题的难点其实就是把各种情况考虑一下，然后把有答案的部分保留下来，基本上就没有问题了。
总结
本文只是挑选了一些比较好的课上的题进行了讲解，还有部分题没有写出来，也会在后续的博客中。
对于我个人而言，二分法算是比较熟悉的一个方法，之前在做微软校招第一题的时候用的就是二分的方法。在面试中也是比较常用到的一种方法，因为总有那么一种说法嘛：比0(n)还要快的算法复杂度，那必须就是0(logn)了（这里说的是在一般的面试情况下）那么O(logn)就必然要考虑二分的方法来做了。一般都会与一些排序的序列、在一段有规则的序列等情况中找到符合某个条件的位置/值。这个模块还是需要多练习，然后就能够很好上手了，如果想要能够在算法面试中有更好的突破，还是需要去解决一些难一点的题，诸如poj或者hdu这样的应用场景的题。
这也是本人第一次认真写一个技术长文，虽然也没有什么特别深奥的东西，读到这里说明你也是很给我面子的了，之后还会继续更新一些自己的想法和一些好的题目，希望大家多多支持！