算法题常考的几种算法
1.回溯
n皇后问题
什么是N-皇后问题?
说到这个N-皇后问题，就不得不先提一下这个历史上著名的8皇后问题啦。
八皇后问题，是一个古老而著名的问题.该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法?
那么，我们将8皇后问题推广一下，就可以得到我们的N皇后问题了。N皇后问题是一个经典的问题，在一个NxN的棋盘上放置N个皇后，使其不能互相攻击 (同一行、同一列、同一斜线上的皇后都会自动攻击) 那么问，有多少种摆法？
回溯算法(backtracking algorithm)
N皇后问题其实就是回溯算法中的一个典型应用。为此，在这里先介绍一下回溯算法。
定义(参考至百度百科)
回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。
基本思想
回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。
- 若用回溯法求问题的所有解时，要回溯到根，且根结点的所有可行的子树都要已被搜索遍才结束。
- 而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。
什么是深度优先搜索？
- 深度优先搜索(DFS即Depth First Search)其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。
解决问题的一般步骤
- 针对所给问题，定义问题的解空间，它至少包含问题的一个（最优）解。
- 确定易于搜索的解空间结构,使得能用回溯法方便地搜索整个解空间 。
- 以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。
确定了解空间的组织结构后，回溯法就从开始结点（根结点）出发，以深度优先的方式搜索整个解空间。这个开始结点就成为一个活结点，同时也成为当前的扩展结点。在当前的扩展结点处，搜索向纵深方向移至一个新结点。这个新结点就成为一个新的活结点，并成为当前扩展结点。如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的一个活结点处，并使这个活结点成为当前的扩展结点。回溯法即以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已没有活结点时为止。
解空间和解空间树
- 解空间
一个复杂问题的解决往往由多部分构成，那么，一个大的解决方案就可以看成是由若干个小的决策组成。很多时候它们构成一个决策序列。解决一个问题的所有可能的决策序列构成该问题的解空间。解空间中满足约束条件的决策序列称为可行解。一般说来，解任何问题都有一个目标，在约束条件下使目标值达到最大（或最小）的可行解称为该问题的最优解。在解空间中，前k项决策已经取定的所有决策序列之集，称为k定子解空间。0定子解空间即是该问题的解空间。这个空间必须至少包含一个解（可能是最优的）。 - 解空间树
因为回溯方法的基本思想是通过搜索解空间来找到问题所要求的解，所以如何组织解空间的结构会直接影响对问题的求解效率。一般地，我们可以用一棵树来描述解空间，并称之为解空间树。
算法框架
- 针对N叉树的递归回溯方法
//针对N叉树的递归回溯方法
void backtrack (int t)
{
if (t>n)
{
output(x); //叶子节点，输出结果，x是可行解
}
else
{
for i = 1 to k//当前节点的所有子节点
{
x[t]=value(i); //每个子节点的值赋值给x
//满足约束条件和限界条件
if (constraint(t)&&bound(t))
backtrack(t+1); //递归下一层
}
}
}
- 针对N叉树的迭代回溯方法
//针对N叉树的迭代回溯方法
void iterativeBacktrack ()
{
int t=1;
while (t>0)
{
if(ExistSubNode(t)) //当前节点的存在子节点
{
for i = 1 to k //遍历当前节点的所有子节点
{
x[t]=value(i);//每个子节点的值赋值给x
if (constraint(t)&&bound(t))//满足约束条件和限界条件
{
//solution表示在节点t处得到了一个解
if (solution(t))
output(x);//得到问题的一个可行解，输出
else
t++;//没有得到解，继续向下搜索
}
}
}
else //不存在子节点，返回上一层
t--;
}
}
N皇后问题的solve
算法伪代码描述
下面是算法的高级伪码描述，这里用一个N*N的矩阵来存储棋盘：
-
算法开始, 清空棋盘，当前行设为第一行，当前列设为第一列
-
在当前行，当前列的位置上判断是否满足条件(即保证经过这一点的行,列与斜线上都没有两个皇后)，若不满足，跳到第4步
-
在当前位置上满足条件的情形：
- 在当前位置放一个皇后，若当前行是最后一行，记录一个解；
- 若当前行不是最后一行，当前行设为下一行, 当前列设为当前行的第一个待测位置；
- 若当前行是最后一行，当前列不是最后一列，当前列设为下一列；
- 若当前行是最后一行，当前列是最后一列，回溯，即清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置。
- 以上返回到第2步
-
在当前位置上不满足条件的情形：
- 若当前列不是最后一列，当前列设为下一列，返回到第2步;
- 若当前列是最后一列了，回溯，即，若当前行已经是第一行了，算法退出，否则，清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置，返回到第2步;
图解问题过程
为了让大家更好理解，这里画了一张图。
coding time
我们之前说过N皇后问题是回溯算法的经典应用。因此我们可以使用回溯法来解决该问题，具体实现也有两个途径，递归和非递归。
- 递归法
其实递归法算是比较简单的了。我们使用一个一维数组来存储棋盘。具体细节如下：把棋盘存储为一个一维数组a[N]，数组中第i个元素的值代表第i行的皇后位置。在判断是否冲突时也很简单：- 首先每行只有一个皇后，且在数组中只占据一个元素的位置，行冲突就不存在了。
- 其次是列冲突，判断一下是否有a[i]与当前要放置皇后的列j相等即可。
- 至于斜线冲突，通过观察可以发现所有在斜线上冲突的皇后的位置都有规律。即它们所在的行列互减的绝对值相等，即| row – i | = | col – a[i] | 。
#include <stdio.h>
#include <stdlib.h>
const int N=20; //最多放皇后的个数
int q[N]; //i表示皇后所在的行号，
//q[i]表示皇后所在的列号
int cont = 0; //统计解的个数
//输出一个解
void print(int n)
{
int i,j;
cont++;
printf("第%d个解：",cont);
for(i=1;i<=n;i++)
printf("(%d,%d) ",i,q[i]);
printf("\n");
for(i=1;i<=n;i++) //行
{
for(j=1;j<=n;j++) //列
{
if(q[i]!=j)
printf("x ");
else
printf("Q ");
}
printf("\n");
}
}
//检验第i行的k列上是否可以摆放皇后
int find(int i,int k)
{
int j=1;
while(j<i) //j=1~i-1是已经放置了皇后的行
{
//第j行的皇后是否在k列或(j,q[j])与(i,k)是否在斜线上
if(q[j]==k || abs(j-i)==abs(q[j]-k))
return 0;
j++;
}
return 1;
}
//放置皇后到棋盘上
void place(int k,int n)
{
int j;
if(k>n)
print(n); //递归出口
else
{
for(j=1;j<=n;j++) //试探第k行的每一个列
{
if(find(k,j))
{
q[k] = j; //保存位置
place(k+1,n); //接着下一行
}
}
}
}
int main1111(void)
{
int n;
printf("请输入皇后的个数(n<=20),n=:");
scanf("%d",&n);
if(n>20)
printf("n值太大，不能求解!\n");
else
{
printf("%d皇后问题求解如下(每列的皇后所在的行数):\n",n);
place(1,n); //问题从最初状态解起
printf("\n");
}
system("pause");
return 0;
}
- 迭代法
为什么还要迭代呢？因为递归效率有时候并不是那么的高。具体思路：首先对N行中的每一行进行探测，查找该行中可以放皇后的位置。具体怎么做呢？- 首先对该行的逐列进行探测，看是否可以放置皇后，如果可以，则在该列放置一个皇后，然后继续探测下一行的皇后位置。
- 如果已经探测完所有的列都没有找到可以放置皇后的列，这时候就应该回溯了，把上一行皇后的位置往后移一列。
- 如果上一行皇后移动后也找不到位置，则继续回溯直至某一行找到皇后的位置或回溯到第一行，如果第一行皇后也无法找到可以放置皇后的位置，则说明已经找到所有的解，程序终止。
- 如果该行已经是最后一行，则探测完该行后，如果找到放置皇后的位置，则说明找到一个结果，打印出来。
- 但是此时并不能在此处结束程序，因为我们要找的是所有N皇后问题所有的解，此时应该清除该行的皇后，从当前放置皇后列数的下一列继续探测。
由此可见，非递归方法的一个重要问题时何时回溯及如何回溯的问题。
具体代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define QUEEN 8 //皇后的数目
#define INITIAL -10000 //棋盘的初始值
int a[QUEEN]; //一维数组表示棋盘
void init() //对棋盘进行初始化
{
int *p;
for (p = a; p < a + QUEEN; ++p)
{
*p = INITIAL;
}
}
int valid(int row, int col) //判断第row行第col列是否可以放置皇后
{
int i;
for (i = 0; i < QUEEN; ++i) //对棋盘进行扫描
{ //判断列冲突与斜线上的冲突
if (a[i] == col || abs(i - row) == abs(a[i] - col))
return 0;
}
return 1;
}
void print() //打印输出N皇后的一组解
{
int i, j;
for (i = 0; i < QUEEN; ++i)
{
for (j = 0; j < QUEEN; ++j)
{
if (a[i] != j) //a[i]为初始值
printf("%c ", '.');
else //a[i]表示在第i行的第a[i]列可以放置皇后
printf("%c ", '#');
}
printf("\n");
}
for (i = 0; i < QUEEN; ++i)
printf("%d ", a[i]);
printf("\n");
printf("--------------------------------\n");
}
void queen() //N皇后程序
{
int n = 0;
int i = 0, j = 0;
while (i < QUEEN)
{
while (j < QUEEN) //对i行的每一列进行探测，看是否可以放置皇后
{
if(valid(i, j)) //该位置可以放置皇后
{
a[i] = j; //第i行放置皇后
j = 0; //第i行放置皇后以后，需要继续探测下一行的皇后位置，
//所以此处将j清零，从下一行的第0列开始逐列探测
break;
}
else
{
++j; //继续探测下一列
}
}
if(a[i] == INITIAL) //第i行没有找到可以放置皇后的位置
{
if (i == 0) //回溯到第一行，仍然无法找到可以放置皇后的位置，
//则说明已经找到所有的解，程序终止
break;
else //没有找到可以放置皇后的列，此时就应该回溯
{
--i;
j = a[i] + 1; //把上一行皇后的位置往后移一列
a[i] = INITIAL; //把上一行皇后的位置清除，重新探测
continue;
}
}
if (i == QUEEN - 1) //最后一行找到了一个皇后位置，
//说明找到一个结果，打印出来
{
printf("answer %d : \n", ++n);
print();
//不能在此处结束程序，因为我们要找的是N皇后问题的所有解，
//此时应该清除该行的皇后，从当前放置皇后列数的下一列继续探测。
j = a[i] + 1; //从最后一行放置皇后列数的下一列继续探测
a[i] = INITIAL; //清除最后一行的皇后位置
continue;
}
++i; //继续探测下一行的皇后位置
}
}
int main(void)
{
init();
queen();
system("pause");
return 0;
}
内容来自简书 链接：https://www.jianshu.com/p/bb123944d3e5
2.动态规划
爬楼梯问题
在介绍动态规划算法之前，我们不妨先看一下小例子。相信学计算机的在读大学期间都遇到过这么一道题：青蛙一次只能蹦上1个或2个台阶，现在有10个台阶，请问青蛙上这10个台阶有多少种蹦法？当然不一定是青蛙，题目大致就是这个意思。
我们来分析一下，假设青蛙现在还差一次就能到达第10个台阶，那么青蛙现在只能在第8个台阶上，或者第9个台阶上，也就是说，青蛙在第8个台阶上蹦2个台阶，或者在第9个台阶上蹦1个台阶。至于在第8个台阶上蹦1个台阶之后再蹦1个台阶，是考虑在后一种情况中。那么青蛙蹦上第10个台阶的蹦法即为：F(10) = F(8) + F(9)。依次类推，F(9) = F(7) + F(8), F(8) = F(6)+F(7)。那么我们可以得到一个通用公式:
F(N) = F(N-2) + F(N-1); (N>2)
F(1) = 1;
F(2) = 2;
这是一个完全符合递归思想的问题，那么，接下来我们就可以编码了。递归解决爬楼梯问题的代码如下：
public class UpStairsDemo1 {
public static int numsOfUpStairs(int n){
if(n == 1){
return 1;
}else if(n ==2){
return 2;
}else if(n > 2){
//F(N) = F(N-1) + F(N-2)
return numsOfUpStairs(n - 1) + numsOfUpStairs(n - 2);
}else return 0;
}
public static void main(String[] args) {
System.out.println("nums of up the stairs: " + numsOfUpStairs(1));
System.out.println("nums of up the stairs: " + numsOfUpStairs(2));
System.out.println("nums of up the stairs: " + numsOfUpStairs(3));
System.out.println("nums of up the stairs: " + numsOfUpStairs(10));
}
}
结果如下：
nums of up the stairs: 1
nums of up the stairs: 2
nums of up the stairs: 3
nums of up the stairs: 89
结果分析
通过上述代码，表面上看起来我们的问题是解决了，但是不够完美。为什么呢？如果此时楼梯数，从10变成了100，那么以上代码就很难hold住了。
为什么呢？本质上是由递归的缺点决定的：递归太深容易造成堆栈的溢出。递归写起来虽然很方便，代码结构层次清晰，而且可读性高，但是这些都不能遮盖住递归最大的缺点：太占资源。因为递归需要保护现场，由于递归需要系统堆栈，所以空间消耗要比非递归代码要大很多。而且，如果递归深度太大，系统很有可能是撑不住的。
我们来分析以上上述递归的执行过程：
F(10) = F(8) + F(9);
F(10) = F(6) + F(7) + F(7) + F(8);
F(10) = F(6) + F(7) + F(7) + F(6) + F(7);
F(10) = F(4) + F(5) + F(5) + F(6) + F(5) + F(6) + F(4) + F(5) + F(5) + F(6);
........
最终的结果是：为了计算F(10), 需要计算1次F(9), 2次F(8), 3次F(7), 4次F(6), 5次F(5), 6次F(4).....快写不下去了。通过分析我们知道，这种递归求解的时间复杂度达到了O(2^N)。F(N)的计算中存在大量重叠的子问题，可想而知，当N为100时，各个F(n)得计算多少次了。有没有办法让每个状态都只计算一次，然后将结果保存，用于下一次计算呢？这样既可以降低CPU的使用率，可以降低系统栈的开销，因为无需堆栈来保存递归的现场。答案是肯定的，动态规范算法就能很好地解决这种问题。
动态规划算法（Dynamic Programming）
定义（以下内容来自百度百科）
动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推或者分治的方式去解决。
动态规划算法的基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。
由于动态规划解决的问题多数有重叠子问题这个特点，为减少重复计算，对每一个子问题只解一次，将其不同阶段的不同状态保存在一个二维数组中。
求解的基本步骤
以上述的“爬楼梯问题”为例，我们简单解释一下动态规划算法的过程。根据动态规划的思想，首先，将问题分段，过程如下：
F(1) = 1;
F(2) = 2;
F(N) = F(N-2) + F(N-1);
我们从头开始按顺序求解子阶段。
F(1) = 1;
F(2) = 2;
F(3) = F(1) + F(2) = 1 + 2 = 3;
F(4) = F(2) + F(3) = 2 + 3 = 5;
F(5) = F(3) + F(4) = 3 + 5 = 8;
F(6) = F(4) + F(5) = 5 + 8 = 13;
F(7) = F(5) + F(6) = 8 + 13 = 21;
F(8) = F(6) + F(7) = 13 + 21 = 34;
F(9) = F(7) + F(8) = 21 + 34 = 55;
F(10) = F(8) + F(9) = 34 + 55 = 89;
好了，以上就是求解爬楼梯问题的详细过程。通过分析我们知道，通过递推，我们只需知道当前状态的前两个状态的结果即可推出当前状态的结果。即我们只需要的变量有：
F(N) = F(N-2) + F(N-1);
//这里F(N-2)，F(N-1)是我们求解过程中的需要存储的中间变量。
代码实现
通过以上分析，我们给出针对“爬楼梯问题”的动态规划求解过程的代码，具体代码如下：
public class DynamicUpstairs {
public static int numsOfUpStairs(int n){
int temp1 = 1, temp2 = 2;
if(n<1){
return 0;
}else if(n<3){
return n;
}else{
int sum = 0;
for(int i=3;i<=n;i++){
sum = temp1 + temp2;
temp1 = temp2;
temp2 = sum;
}
return sum;
}
}
public static void main(String[] args) {
System.out.println("nums of up stairs : " + numsOfUpStairs(1));
System.out.println("nums of up stairs : " + numsOfUpStairs(2));
System.out.println("nums of up stairs : " + numsOfUpStairs(3));
System.out.println("nums of up stairs : " + numsOfUpStairs(10));
}
}
结果如下：
nums of up stairs : 1
nums of up stairs : 2
nums of up stairs : 3
nums of up stairs : 89
算法分析
这里我们通过保存前两次的结果，采用迭代递推的方式求解最终问题。很明显，时间复杂度为O(N), 空间复杂度为O(1)。相比较递归方法，既能避免递归堆栈过深可能导致的内存溢出，同时能大大降低求解问题所需的时间。
“爬楼梯问题”只是动态规划法最简单的用例之一。动态规划法还有很多的应用场景，任何思想方法都有一定的局限性，超出了特定条件，它就失去了作用。同样，动态规划也并不是万能的。适用动态规划的问题必须满足最优化原理和无后效性。接下来说一下动态规划算法的适用条件：
- 最优化原理（最优子结构性质） 最优化原理可这样阐述：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。
- 无后效性将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。
- 子问题的重叠性 动态规划将原来具有指数级时间复杂度的搜索算法改进成了具有多项式时间复杂度的算法。其中的关键在于解决冗余，这是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术，它在实现的过程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其它的算法。
最佳实践（参照百度百科--动态规划）
算法实现是比较好考虑的。但有时也会遇到一些问题，而使算法难以实现。动态规划思想设计的算法从整体上来看基本都是按照得出的递推关系式进行递推，这种递推相对于计算机来说，只要设计得当，效率往往是比较高的，这样在时间上溢出的可能性不大，而相反地，动态规划需要很大的空间以存储中间产生的结果，这样可以使包含同一个子问题的所有问题共用一个子问题解，从而体现动态规划的优越性，但这是以牺牲空间为代价的，为了有效地访问已有结果，数据也不易压缩存储，因而空间矛盾是比较突出的。另一方面，动态规划的高时效性往往要通过大的测试数据体现出来（以与搜索作比较），因而，对于大规模的问题如何在基本不影响运行速度的条件下，解决空间溢出的问题，是动态规划解决问题时一个普遍会遇到的问题。
一般地说，这种方法可以通过两种思路来实现：一种是递推结果仅使用Data1和Data2这样两个数组，每次将Data1作为上一阶段，推得Data2数组，然后，将Data2通过复制覆盖到Data1之上，如此反复，即可推得最终结果。这种做法有一个局限性，就是对于递推与前面若干阶段相关的问题，这种做法就比较麻烦；而且，每递推一级，就需要复制很多的内容，与前面多个阶段相关的问题影响更大。另外一种实现方法是，对于一个可能与前N个阶段相关的问题，建立数组Data[0..N]，其中各项为前面N个阶段的保存数据。这样不采用这种内存节约方式时对于阶段k的访问只要对应成对数组Data中下标为k mod (N+1)的单元的访问就可以了。这种处理方法对于程序修改的代码很少，速度几乎不受影响，而且需要保留不同的阶段数也都能很容易实现。
来源简书链接：https://www.jianshu.com/p/3babdd1aedca
3.分治
最典型的二分法
4.贪心
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
求最小生成树的Prim算法和Kruskal算法都是漂亮的贪心算法。
5.分支限定
分支限界法是以广度优先或以最小耗费优先的方式搜索解空间树，在每一个活结点处，计算一个函数值，并根据函数值，从当前活结点表中选择一个最有利的结点作为扩展结点，使搜索朝着解空间上有最优解的分支推进，以便尽快地找出一个最优解，这种方法称为分支限界法。
基本思想
用分支限界法解问题时，同样也应明确定义问题的解空间。之后还应将解空间很好的组织起来。分支限界法也有两种组织解空间的方法，即队列式分支限界法和优先队列式分支限界法。两者的区别在于：队列式分支限界法按照队列先进先出的原则选取下一个节点为扩展节点，而优先队列式分支限界法按照优先队列中规定的优先级选取优先级最高的节点成为当前扩展节点。分支限界法常以广度优先或以最小耗费优先的方式搜索问题的解空间树。在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。
