算法入门经典第八章学习笔记（上）

第8章  高效算法设计

【教学内容相关章节】 

8.1算法分析初步     8.2再谈排序与搜索         8.3递归与分治  8.4贪心法     

【教学目标】 （加粗表示基本掌握）

（1）理解“基本操作”、渐近时间复杂度的概念和大O记号的含义； 

（2）掌握“最大连续和”问题的各种算法及其时间复杂度分析； 

（3）正确认识算法分析的优点和局限性，能正确使用分析结果； 

（4）掌握归并排序和逆序对统计的分治算法； 

（5）掌握归并排序和快速选择算法； 

（6）熟练掌握二分查找算法，包括找上下界的算法； 

（7）能用递归的方式思考和求解问题； 

（8）熟练掌握用二分法求解非线性方程的方法； 

（9）熟练掌握用二分法把优化问题转化为判定问题的方法； 

（10）熟悉能用贪心法求解的各类经典的问题。

8.1算法分析初步 

例8-1：最大连续和（注：数组下标从1开始）

（1）枚举的思想。计算次数用数学计算为n*(n+1)*(n+2)/6，时间复杂度O（n^n^n)。

	best = A[1];
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= n; j++)
		{
			int sum = 0;
			for (k = i; k <=j; k++)
				sum += A[k];
			if (sum > best) best = sum;
		}
	}

（2）优化，设Si=A1+A2+„+Ai，则Ai+Ai+1+„+Aj=Sj-Si-1，它的含义是连续子序列之和等于两个前缀和之差。同样可计算出计算次数为 n*(n+1)/2，时间复杂度为O(n^n)。

	S[0] = 0;
	for (i = 1; i <= n; i++)
		s[i] = s[i-1] + A[i];
	for (i = 1; i <= n; i++)
		for (j = i; j <= n; j++)
			if (s[j] - s[i-1] > best)	best = s[j] - s[i-1];

（3）分治法：

分治法一般分为3个步骤：

1、划分问题，把问题的实例划分成若干子问题；

2、递归问题，递归解决子问题；

3、合并问题，合并子问题的解得到原问题的解。

本例中，“划分”就是把序列分成元素个数尽量相等的两半；“递归求解”就是分别求出完全位于左半或完全位于右半的最佳序列；“合并”就是求出起点位于左半、终点位于右半的最大连续和序列，并和子问题的最优解比较。

贴上一个完整能跑的程序。注意区间为左闭右开[x,y)。递归方程T(n)=2T(n/2)+n，T(1)=1的解为T(n)=Θ(nlogn)

#include <iostream>  
#include <iomanip>  
#include <string>  
#include <cstring>  
#include <cstdio>  
#include <queue>  
#include <stack>  
#include <algorithm>  
#include <cmath>  

using namespace std;

int maxsum(int *A, int x, int y)
{
	int m = 0, max = 0, v = 0, L = 0, R = 0, i = 0;
	if (y - x == 1) return A[x];
	m = x + (y-x)/2;
	max = maxsum(A, x, m) > maxsum(A, m, y)? maxsum(A, x, m) : maxsum(A, m, y);
	v = 0; L = A[m-1];
	for (i = m-1; i >= x; i--)
	{
		v += A[i];
		if (v > L) L = v;
	}
	v = 0; R = A[m];
	for (i = m; i < y; i++)
	{
		v += A[i];
		if (v > R) R = v;
	}
	if (L+R > max) max = L+R;
}

int main() 
{
#ifdef Local    
	freopen("a.in", "r", stdin);    
#endif
	int A[10], sum = 0, i = 0;
	for (i = 0; i < 10; i++)
		cin >> A[i];
	sum = maxsum(A, 0, 10);
	cout << sum << endl;
}

（4）（没怎么想）再优，把O(n2)算法稍作修改，便可以得到一个O(n)算法：当j确定时，“S[j]-S[i-1]最大”相当于“S[i-1]最小”，因此只需要扫描一次数组，维护“目前遇到过的最小S”即可。

8.2再谈排序与搜索

8.2.1  归并排序

归并排序也是按照分治法的三步，划分、递归和合并。关键在于第三步，每次只需要把两个序列的最小元素加以比较，删除其中的较小元素并加入合并后的新表即可。由于需要一个新表来存放结果，所以附加空间n。

#include <iostream>  
#include <iomanip>  
#include <string>  
#include <cstring>  
#include <cstdio>  
#include <queue>  
#include <stack>  
#include <algorithm>  
#include <cmath>  

using namespace std;

void merge_sort(int *A, int x, int y, int *T)
{
	if (y-x > 1)
	{
		int m = x + (y-x)/2;
		int p = x, q = m, i = x;
		merge_sort(A, x, m, T);
		merge_sort(A, m, y, T);
		while (p < m || q < y)
		{
			if (q >= y || (p < m && A[p] <= A[q]))
				T[i++] = A[p++];
			else
				T[i++] = A[q++];
		}
		for (int i = x; i < y; i++)
			A[i] = T[i];
	}
}

int main() 
{
#ifdef Local    
	freopen("a.in", "r", stdin);    
	freopen("a.out", "w", stdout);    
#endif
	int A[10], T[10], i = 0;
	for (i = 0; i < 10; i++)
		cin >> A[i];
	merge_sort(A, 0, 10, T);
	for (i = 0; i < 10; i++)
		cout << T[i] << ' ';
}

函数判断中用的'||"挺实用，因为满足第一个就不会去判断第二个。

例8-2 逆序对数。

给一列a1,a2,„,an，求它的逆序对数，即有多少个有序对(i,j)，使得i<j但ai>aj。n可以高达10^6。

和归并排序一样，例如 4 3 2 1，刚开始分为 4 3 | 2 1 ，两边都有一个逆序对，然后变为 3 4| 1 2，此时如果左边的比右边的大就加上 m-p个。所以2+（2+2) = 6.

			else
			{
				T[i++] = A[q++];
				*cnt += m-p;
			}

仅是这里不同和函数参数不同。

8.2.2  快速排序

按照分治三步法，将快速排序算法作如下介绍。 
（1）划分问题：数组的各个元素重排后分成左右两部分，使得左边的任意元素都小于或等于右边的任意元素。 
（2）递归问题：把左右两部分分别排序； 
（3）合并问题：例8-3 第k小的数。不用合并，因为此时数组已经完全有序。

例8-3 第k小的数。

输入n个整数和一个正整数（1≤k≤n），输入这些整数从小到大排序后的第k个（例如，k=1就是最小值）。n≤107。

这里的快排和数据结构上学的基本一样，原理就是把第一个元素作为数轴，交换后边的的，最后使数轴左右两边是比他大和小的。但是这个题目有些地方没懂。

例如 int pos = q - low + 1; 和 return Select_k(a, q+1, high, k-pos);中的k-pos。这里先放下，希望大牛路过指点。

#include <iostream>  
#include <iomanip>  
#include <string>  
#include <cstring>  
#include <cstdio>  
#include <queue>  
#include <stack>  
#include <algorithm>  
#include <cmath>  

using namespace std;
const int N = 100;

int Partition(int a[N], int low, int high)
{
	int i = low, j = high+1, x = a[low];
	while (true)
	{
		while (a[++i] < x);
		while (a[--j] > x);
		if (i >= j) break;
		swap(a[i], a[j]);
	}
	a[low] = a[j];
	a[j] = x;
	return j;
}

int Select_k(int a[N], int low, int high, int k)
{
	int q = Partition(a, low, high);
	int pos = q - low + 1;
	if (low == high) return a[low];
	if (k == pos) return a[q];
	else if (k < pos)
		return Select_k(a, low, q-1, k);
	else
		return Select_k(a, q+1, high, k-pos);
	return 0;
}

int main() 
{
#ifdef Local    
	freopen("a.in", "r", stdin);    
	freopen("a.out", "w", stdout);    
#endif
	int n = 0, k = 0, a[N];
	while (cin >> n >> k)
	{
		for (int i = 0; i < n; i++)
			cin >> a[i];
		cout << "第" << k << "小数：" << Select_k(a,0,n-1,k) <<endl;
		return 0;
	}
}

8.2.3  二分查找

基本思想： 
（1）先将升序（或降序）输入n个元素到一个数组中； 
（2）设low指向数组的低端，high指向数组的高端，mid=(low+high)/2； 

（3）测试mid所指的位置，是否是查找的元素； 
（4）若mid所指的元素大于要查找值，表示被查找的元素在low和mid之间，否则，表示被查找的元素在mid和high之间。 
（5）修改low或high的值，重新计算mid，继续查找。

和学过的没什么不一样，稍微不同是刘大大的这些方法都是让区间为左闭右开的！注意！

#include <iostream>  
#include <iomanip>  
#include <string>  
#include <cstring>  
#include <cstdio>  
#include <queue>  
#include <stack>  
#include <algorithm>  
#include <cmath>  

using namespace std;

int BinSearch(int *a, int x, int y, int v)
{
	int m;
	while (x < y)
	{
		m = x + (y-x)/2;
		if (v == a[m])
			return m;
		else if (a[m] > v)
			y = m;
		else
			x = m+1;
	}
	return -1;
}

int main() 
{
#ifdef Local    
	freopen("a.in", "r", stdin);    
	freopen("a.out", "w", stdout);    
#endif
	int A[] = {1,2,3,4,5,6,7,8,9,0};
	cout << BinSearch(A, 0, 10, 5) << endl;
}

二分查找的一个缺陷是如果和查找值相等的值有若干个，则可能返回的位置不是我们想要的位置——例如返回第一个的位置，并且如果不存在的时候，也返回一个位置，是的要查找的值插在这个位置上后仍然有序。

（二分查找求下界）

int BinSearch(int *a, int x, int y, int v)
{
	int m;
	while (x < y)
	{
		m = x + (y-x)/2;
		if (a[m] >= v)
			y = m;
		else
			x = m+1;
	}
	return x;
}

类似可以写出二分查找求上界。

例8-4 范围统计。

给出n个整数xi和m个询问，对于每个询问(a,b)，输出闭区间[a,b]内的整数xi的个数。

不是很明白这个题目的意思，但是去百度了lower_bound的作用：

lower_bound()返回一个 iterator 它指向在[first,last)标记的有序序列中可以插入value，而不会破坏容器顺序的第一个位置，而这个位置标记了一个大于等于value 的值。

也就是和上边二分发的作用一样，但是具体用法感觉像是STL相关的，苦逼我们居然没怎么学STL。暂且放一下。

章半小结：写出来比单纯看要好的多。。速度还行，晚上或者明天继续写剩下的。