1.算法分析的两个主要任务：正确性（不变性 + 单调性） + 复杂度。

2.复杂度分析的主要方法：

• 迭代：级数求和；
• 递归：递归跟踪 + 递推方程
• 猜测 + 验证

3.级数：

（1）算术级数：与末项平方同阶
$$T(n)=1+2+\cdots +n=\frac{n(n+1)}{2}=O(n^2)$$
（2）幂方级数：比幂次高出一阶
$$\sum _{k=0}^n{k}^d\approx {\int }_0^n{x}^{d+1}\text{d}x=\frac{1}{d+1}{x}^{d+1}{|}_0^n=\frac{1}{d+1}{n}^{d+1}=O(n^{d+1})$$
例如：
$$\begin{array}{rl}& T_2(n)=1^2+2^2+\cdots +n^2=\frac{n(n+1)(2n+1)}{6}=O(n^3)\\ & T_3(n)=1^3+2^3+\cdots +n^3=\frac{n^2(n+1{)}^2}{4}=O(n^4)\\ & T_4(n)=1^4+2^4+\cdots +n^4=\frac{n(n+1)(2n+1)(3n^2+3n-1)}{30}=O(n^5)\end{array}$$
（3）几何级数：与末项同阶
$$T_a(n)=a^0+a^1+\cdots +a^n=\frac{a^{n+1}-1}{a-1}=O(a^n)$$
例如：
$$1+2+4+\cdots +2^n=2^{n+1}-1=O(2^{n+1})=O(2^n)$$
（4）收敛级数：
$$\begin{array}{rl}& \frac{1}{1\times 2}+\frac{1}{2\times 3}+\frac{1}{3\times 4}+\cdots +\frac{1}{(n-1)\times n}=1-\frac{1}{n}=O(1)\\ & 1+\frac{1}{2^2}+\cdots +\frac{1}{n^2}<1+\frac{1}{2^2}+\cdots +=\frac{{\pi }^2}{6}=O(1)\\ & \frac{1}{3}+\frac{1}{7}+\frac{1}{8}+\frac{1}{15}+\frac{1}{24}+\frac{1}{26}+\frac{1}{31}+\frac{1}{35}+\cdots =1=O(1)\end{array}$$
（5）两个重要级数：

• 调和级数：

$$\begin{array}{rl}& h(n)=1+\frac{1}{2}+\frac{1}{3}+\cdots +\frac{1}{n}=\Theta (\log n)\end{array}$$

• 对数级数：

$$\log 1+\log 2+\log 3+\cdots +\log n=\log (n!)=\Theta (n\log n)$$

4.一些循环的复杂度估计：

（1）循环体如下：

for (int i = 1; i < n; i <<= 1)for (int j = 0; j < i; j++)O1_Operation(i, j);

其时间复杂度的计算如下：
$$\begin{array}{rl}\text{几何级数：}& \\ & 1+2+4+\cdots +2^{\lfloor {\log }_2(n-1)\rfloor }\\ =& \sum _{k=0}^{\lfloor {\log }_2(n-1)\rfloor }{2}^k(\text{let}k={\log }_{2}i)\\ =& 2^{\lceil {\log }_{2}n\rceil }-1\\ =& O(n)\end{array}$$
（2）前置知识：数列 { n ⋅ 2 n } \{n\cdot 2^n\} {n⋅2n} 的前 $n$ 项和：$S_n=(n-1)\cdot 2^{n+1}+2$

循环体如下：

for (int i = 0; i <= n; i++)for (int j = 1; j < i; j += j)O1_Operation(i, j);

时间复杂度的计算如下：
$$\begin{array}{rl}\text{几何级数：}& \sum _{k=0}^n\lceil {\log }_{2}i\rceil =O(n\log n)\\ & (i=0,1,2,3\sim 4,5\sim 8,9\sim 16,\cdots )\\ =& 0+0+1+2\times 2+3\times 2^2+4\times 2^4+\cdots \\ =& \sum _{k=0\cdots \log n}(k\times 2^{k-1})\\ =& O(\log n\times 2^{\log n})\end{array}$$
5.算法正确性的证明：（以起泡排序为例）

• 不变性：经 $k$ 轮扫描交换后，最大的 $k$ 个元素必然就位；
• 单调性：经 $k$ 轮扫描交换后，问题规模缩减至 $n-k$；
• 正确性：经至多 $n$ 趟扫描后，算法必然终止，且能给出正确解答。

6.封底估算（Back-Of-The-Envelope Calculation）：

（1）1 day = 24h x 60min x 60sec $\approx$ 25 x 4000 = 10^5 sec
（2）10^9 sec $\approx$ 30 year

7.最长公共子序列：

（1）递归版：

unsigned int lcs(const char* A, int n, const char* B, int m)
{if (n < 1 || m < 1) return 0; // recursion baseelse if (A[n - 1] == B[m - 1]) // decrease-and-conquerreturn 1 + lcs(A, n - 1, B, m - 1);else // divide-and-conquerreturn max(lcs(A, n, B, m - 1), lcs(A, n - 1, B, m));
}

（2）迭代版：

unsigned int lcs(const char* A, int n, const char* B, int m)
{if (n < m){swap(A, B);swap(n, m); // make sure m <= n}unsigned int* lcs1 = new unsigned int[m + 1];unsigned int* lcs2 = new unsigned int[m + 1];memset(lcs1, 0x00, sizeof(unsigned int) * (m + 1));lcs2[0] = 0;for (int i = 0; i < n; swap(lcs1, lcs2), i++)for (int j = 0; j < m; j++)lcs2[j + 1] = (A[i] == B[j]) ? 1 + lcs1[j] : max(lcs2[j], lcs1[j + 1]);unsigned int res = lcs1[m];delete [] lcs1; delete [] lcs2;return res;
}

8.总和最大区段：

（1）$O(n^3)$ 蛮力算法：

int gs_BF(int A[], int n)
{int gs = A[0]; // current maxfor (int i = 0; i < n; i++)for (int j = i; j < n; j++) // enumerate every segment{int s = 0;for (int k = i; k <= j; k++) s += A[k];if (gs < s) gs = s;}return gs;
}

（2）$O(n^2)$ 递增策略：

// 考查所有起点相同的区间，它们的总和之间具有相关性
int gs_IC(int A[], int n)
{int gs = A[0]; // current maxfor (int i = 0; i < n; i++){int s = 0;for (int j = i; j < n; j++){s += A[j];if (gs < s) gs = s;}}return gs;
}

（3）$O(n\log n)$ 分治策略：

// 将整个区间递归地分为三部分：前缀、后缀、跨越切分线的中间部分
int gs_DC(int A[], int lo, int hi) // 注意区间是左闭右开的：[lo, hi)
{if (hi - lo < 2) return A[lo]; // recursion baseint mi = (lo + hi) >> 1;// 寻找跨越切分线左半边的gsLint gsL = A[mi - 1], sL = 0, i = mi;while (lo < i--){sL += A[i];if (gsL < sL) gsL = sL;}// 寻找跨越切分线右半边的gsRint gsR = A[mi], sR = 0, j = mi - 1;while (++j < hi){sR += A[j];if (gsR < sR) gsR = sR;}return max(gsL + gsR, max(gs_DC(A, lo, mi), gs_DC(A, mi, hi)));
}

（4）$O(n)$ 减治策略：

// 该策略基于这样一个结论：
// 记suffix(k) = A[k, hi), 其中k = max{lo<=i<hi | sum[i, hi)<=0}，
// 则GS(lo, hi) = A[i, j)要么是其真后缀(k <= i < j = hi)，要么与之无交(j <= k)
int gs_LS(int A[], int n) // Linear Scan: O(n)
{int gs = A[0], s = 0, i = n;while (0 < i--){s += A[i];if (gs < s) gs = s;if (s <= 0) s = 0; // 剪除负和后缀}return gs;
}