五大常用算法思想

最近有空学习了一下算法，参考网上文章，将五中常用的算法思想汇总一下，方便以后工作使用

1 分治算法

一、基本思想及策略

分治法的设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

二、分治法适用的情况
1. 该问题的规模缩小到一定的程度就可以容易地解决
2. 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3. 利用该问题分解出的子问题的解可以合并为该问题的解；
4. 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。

第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；
第二条特征是应用分治法的前提它也是大多数问题可以满足的，此特征反映了递归思想的应用；、
第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。
第四条特征涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。

三、可使用分治法求解的一些经典问题
1. 二分搜索
2. 大整数乘法
3. Strassen矩阵乘法
4. 棋盘覆盖
5. 归并排序
6. 快速排序
7. 线性时间选择
8. 最接近点对问题
9. 循环赛日程表
10. 汉诺塔

附：归并排序Java实现

public　class　MergeSort　{
   //　private　static　long　sum　=　0;
   /**
   　*　<pre>
   　*　二路归并
   　*　原理：将两个有序表合并和一个有序表
   　*　</pre>
   　*　
   　*　@param　a
   　*　@param　s
   　*　第一个有序表的起始下标
   　*　@param　m
   　*　第二个有序表的起始下标
   　*　@param　t
   　*　第二个有序表的结束小标
   　*　
   　*/
   private　static　void　merge(int[]　a,　int　s,　int　m,　int　t)　{
        int[]　tmp　=　new　int[t　-　s　+　1];
        int　i　=　s,　j　=　m,　k　=　0;
        while　(i　<　m　&&　j　<=　t)　{
            if　(a[i]　<=　a[j])　{
                tmp[k]　=　a[i];
                k++;
                i++;
            }　else　{
                tmp[k]　=　a[j];
                j++;
                k++;
            }
        }
        while　(i　<　m)　{
            tmp[k]　=　a[i];
            i++;
            k++;
        }
        while　(j　<=　t)　{
            tmp[k]　=　a[j];
            j++;
            k++;
        }
        System.arraycopy(tmp,　0,　a,　s,　tmp.length);
   }
   /**
   　*　
   　*　@param　a
   　*　@param　s
   　*　@param　len
   　*　每次归并的有序集合的长度
   　*/
   public　static　void　mergeSort(int[]　a,　int　s,　int　len)　{
        int　size　=　a.length;
        int　mid　=　size　/　(len　<<　1);
        int　c　=　size　&　((len　<<　1)　-　1);
        //　-------归并到只剩一个有序集合的时候结束算法-------//
        if　(mid　==　0)
            return;
        //　------进行一趟归并排序-------//
        for　(int　i　=　0;　i　<　mid;　++i)　{
            s　=　i　*　2　*　len;
            merge(a,　s,　s　+　len,　(len　<<　1)　+　s　-　1);
        }
        //　-------将剩下的数和倒数一个有序集合归并-------//
        if　(c　!=　0)
            merge(a,　size　-　c　-　2　*　len,　size　-　c,　size　-　1);
        //　-------递归执行下一趟归并排序------//
        mergeSort(a,　0,　2　*　len);
   }
   public　static　void　main(String[]　args)　{
        int[]　a　=　new　int[]　{　4,　3,　6,　1,　2,　5　};
        mergeSort(a,　0,　1);
        for　(int　i　=　0;　i　<　a.length;　++i)　{
            System.out.print(a[i]　+　"　");
        }
   }
}

2 动态规划算法

一、基本概念

动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。

二、基本思想与策略

1. 基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。
2. 由于动态规划解决的问题多数有重叠子问题这个特点，为减少重复计算，对每一个子问题只解一次，将其不同阶段的不同状态保存在一个二维数组中。
3. 与分治法最大的差别是：适合于用动态规划法求解的问题，经分解后得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）。

三、适用的情况
能采用动态规划求解的问题的一般要具有3个性质：

（1）最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。
（2） 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。
（3）有重叠子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到。（该性质并不是动态规划适用的必要条件，但是如果没有这条性质，动态规划算法同其他算法相比就不具备优势）

四、动态规划算法基本框架

for(j=1; j<=m; j=j+1) // 第一个阶段
  xn[j] = 初始值;

for(i=n-1; i>=1; i=i-1)// 其他n-1个阶段
      for(j=1; j>=f(i); j=j+1)//f(i)与i有关的表达式
 xi[j]=j=max（或min）{g(xi-1[j1:j2]), ......, g(xi-1[jk:jk+1])};

 t = g(x1[j1:j2]); // 由子问题的最优解求解整个问题的最优解的方案

 print(x1[j1]);

 for(i=2; i<=n-1; i=i+1）
 {
     t = t-xi-1[ji];

     for(j=1; j>=f(i); j=j+1)
     if(t=xi[ji])
     break;
 }

3 贪心算法

一、定义

什么是贪心算法呢？所谓贪心算法是指，在对问题求解时，总是做出在当前看来最好的选择。也就是说，不从整体最优解出发来考虑，它所做出的仅是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题都能产生整体最优解或整体最优解的近似解。

贪心算法的基本思路如下：
1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每个子问题求解，得到每个子问题的局部最优解。
4.把每个子问题的局部最优解合成为原来问题的一个解。
实现该算法的过程：
从问题的某一初始状态出发；
while 能朝给定总目标前进一步 do
求出可行解的一个解元素；
由所有解元素组合成问题的一个可行解；
二、例题分析
[背包问题]有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。
要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。
物品 A B C D E F G
重量 35 30 60 50 40 10 25
价值 10 40 30 50 35 40 30
记得当时学算法的时候，就是这个例子，可以说很经典。
分析：
目标函数： ∑pi最大
约束条件是装入的物品总重量不超过背包容量，即∑wi<=M( M=150)
（1）根据贪心的策略，每次挑选价值最大的物品装入背包，得到的结果是否最优？
（2）每次挑选所占重量最小的物品装入是否能得到最优解？
（3）每次选取单位重量价值最大的物品，成为解本题的策略?
贪心算法是很常见的算法之一，这是由于它简单易行，构造贪心策略简单。但是，它需要证明后才能真正运用到题目的算法中。一般来说，贪心算法的证明围绕着整个问题的最优解一定由在贪心策略中存在的子问题的最优解得来的。
对于本例题中的3种贪心策略，都无法成立，即无法被证明，解释如下：
（1）贪心策略：选取价值最大者。反例：
W=30
物品：A B C
重量：28 12 12
价值：30 20 20
根据策略，首先选取物品A，接下来就无法再选取了，可是，选取B、C则更好。
（2）贪心策略：选取重量最小。它的反例与第一种策略的反例差不多。
（3）贪心策略：选取单位重量价值最大的物品。反例：
W=30
物品：A B C
重量：28 20 10
价值：28 20 10
根据策略，三种物品单位重量价值一样，程序无法依据现有策略作出判断，如果选择A，则答案错误。
值得注意的是，贪心算法并不是完全不可以使用，贪心策略一旦经过证明成立后，它就是一种高效的算法。比如，求最小生成树的Prim算法和Kruskal算法都是漂亮的贪心算法。

4 回溯算法

1、概念

回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。

回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。

2、基本思想

在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。（其实回溯法就是对隐式图的深度优先搜索算法）。
若用回溯法求问题的所有解时，要回溯到根，且根结点的所有可行的子树都要已被搜索遍才结束。
而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。

3、用回溯法解题的一般步骤：
（1）针对所给问题，确定问题的解空间：
首先应明确定义问题的解空间，问题的解空间应至少包含问题的一个（最优）解。
（2）确定结点的扩展搜索规则
（3）以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。
4、算法框架
（1）问题框架
设问题的解是一个n维向量(a1,a2,………,an),约束条件是ai(i=1,2,3,…..,n)之间满足某种条件，记为f(ai)。
（2）非递归回溯框架

  int a[n],i;
  初始化数组a[];
  i = 1;
  while (i>0(有路可走)   and  (未达到目标))  // 还未回溯到头
  {
      if(i > n)                                              // 搜索到叶结点
       {  
            搜索到一个解，输出；
       }
     else                                                  // 处理第i个元素
      {
           a[i]第一个可能的值；
            while(a[i]在不满足约束条件且在搜索空间内)
            {
                a[i]下一个可能的值；
            }
            if(a[i]在搜索空间内)
          {
               标识占用的资源；
                i = i+1;                              // 扩展下一个结点
           }
           else
          {
                清理所占的状态空间；            // 回溯
                i = i –1;
          }
 }

（3）递归的算法框架
回溯法是对解空间的深度优先搜索，在一般情况下使用递归函数来实现回溯法比较简单，其中i为搜索的深度，框架如下：

  int a[n];
   try(int i)
  {
       if(i>n)
          输出结果;
        else
       {
          for(j = 下界; j <= 上界; j=j+1)  // 枚举i所有可能的路径
          {
             if(fun(j))                 // 满足限界函数和约束条件
               {
                  a[i] = j;
                ...                         // 其他操作
                  try(i+1);
                回溯前的清理工作（如a[i]置空值等）;
                }
           }
       }
  }

5 分支限界法

一、基本描述

类似于回溯法，也是一种在问题的解空间树T上搜索问题解的算法。但在一般情况下，分支限界法与回溯法的求解目标不同。回溯法的求解目标是找出T中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。

（1）分支搜索算法
所谓“分支”就是采用广度优先的策略，依次搜索E-结点的所有分支，也就是所有相邻结点，抛弃不满足约束条件的结点，其余结点加入活结点表。然后从表中选择一个结点作为下一个E-结点，继续搜索。
选择下一个E-结点的方式不同，则会有几种不同的分支搜索方式。
1）FIFO搜索
2）LIFO搜索
3）优先队列式搜索

二．分支限界法和回溯算法的区别

回溯法以深度优先的方式搜索解空间树T，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树T。