离散数学笔记-算法部分

N久N久没有更新这个东西了。一半是在忙其他事情,一半是确是有点畏惧离散数学部分。今天总结的东西都已经是一个月前的东西了。主要包括下面几个部分

1、算法的定义(无聊的东西……)
2、算法分类(普及一下知识)
3、算法的设计基本方法(非常重要的东西,但是这里只简单提一下)
4、算法复杂度与函数的增长(复杂而又麻烦的东西,用简单的语言随便说一说)
5、几个算法展示

1、算法的定义

算法(Algorithm)是一系列解决问题的清晰指令
算法可以使用自然语言、伪代码、流程图等多种不同的方法来描述。
关于Algorithm有五个特性,也不知道是什么人总结的,总之看看就好,没有深究的必要。

1、有穷性(Finiteness)
算法的有穷性是指算法必须能在执行有限个步骤之后终止
2、确切性(Difiniteness)
算法的每一步骤必须有确切的定义;
3、输入项(Input)
一个算法有0个或多个输入,以刻画运算对象的初始情况,所谓0个输入是指算法本身定出了初始条件;
4、输出项(Output)
一个算法有一个或多个输出,以反映对输入数据加工后的结果。没有输出的算法是毫无意义的;
5、可行性(Effectiveness)
算法中执行的任何计算步都是可以被分解为基本的可执行的操作步,即每个计算步都可以在有限时间内完成。(也称之为有效性)

PS.《数据结构+算法=程序》的作者叫做尼克劳斯-沃思

2、算法分类

算法可大致分为

基本算法
数论与代数算法
加密算法
排序算法
随机化算法
数据结构的算法--关于链表,队列,堆栈,树等等的算法
图论的算法--和图相关的各种算法
计算几何的算法--包括向量,各种平面立体几何相关的算法
动态规划以及数值分析--将原问题分解为相似的子问题,在求解的过程中通过子问题的解求出原问题的解
检索算法--与搜索类似,但是因为信息的特别性,有非常特别的检索方式
并行算法--区别于串行算法,同时执行独立的计算

 

3、算法的设计基本方法

1.递推法
它把问题分成若干步,找出相邻几步的关系,从而达到目的。比如过F(N)与F(N-1)有关。利用计算F(1)得出F(2)再得出F(3)……直到得出F(N)。这种就是一个递推的过程一个一个推上去。
2.递归
一个函数不断引用自身,直到引用的对象已知。可以理解是递推发的逆向,但是变得复杂很多。比如同上F(N)与F(N-1)有关,而且知道一个终止条件如F(1)已知。用递归思想计算F(N),那么就必须先算F(N-1),计算F(N-1)要先算F(N-1-1)即F(N-2)……直到计算F(2),利用到F(1)。|||通过F(1)算出了F(2),算出了F(2)就能算出F(3)……最终得到F(N)。这里我用|||把递归过程分隔成两个部分,递|||归。关于递归的更多部分,还会在做专门的总结。
3.穷举搜索法
对可能的解按某种顺序进行逐一枚举和检验。极度暴力的方法,不过往往很好用……
4.贪婪法
简单的说就是每一步都选择最大的利益,但是这样往往导致最终的结果不是最优解。不过我们还是可以得到一个还不错的解。贪婪法一般可以快速得到满意的解,因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪法常以当前情况为基础作最优选择,而不考虑各种可能的整体情况。
5.分治法
分治法是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并。
6.动态规划法
这个东西非常牛逼,要顺便记一下他的简写DP。其基本思想是,将原问题分解为相似的子问题,在求解的过程中通过子问题的解求出原问题的解。DP给我的感觉就是死咬住最优解,求得到最优解的前一步是什么,然后一路递归到出发点。(不知道有没有计算可以再好好玩一玩)

4、算法复杂度与函数的增长

看一个算法好不好,有很多方面,最简单直观的方法就是分析一个算法的时间复杂度和空间复杂度。
空间复杂度就是估计一下一个算法需要使用到的内存,分析方法与分析时间复杂度类似,而且我们不常需要分析空间复杂度(不是说它不重要!)。

严格的说,我们是没办法算出一个消耗的时间的(除非我们拿到机器上跑)。
不过我们可以算出一个算法遇到一个n规模的问题(或者说输入的数据量为N)时,使用某个算法需要执行多少条语句,这里用个一个函数T(N)表示。
值得一提的是,其实不同的语句执行的速度也是有很大差距的。但是一会我们要分析N趋于无穷大的情况,所有很多小东西都会被忽略掉。

现在我们就来讨论一下T(N)的事,如果有两个功能相同算法,遇到N个数据量时需要执行的语句数分别是T1(N)和T2(N)。现在我们要比较这两个算法的在时间是的好坏,如果N是一个具体的数,那带到函数里计算一下就好了。但是这个不能反映出两个算法的真正实力。所以呢,我们使用的方法是计算当n趋于无穷大时T1(N)/T2(N)。(这里有没有一点点高数上计算无穷小的感觉,其实就是反过来),如果T1(N)/T2(N)在N趋于无穷时,是一个无穷大量,说明T2比T1牛逼。如果是0(即无穷小量)就反过来。如果出来是一个常数,说明T1和T2同阶级,如果常数刚好是1,那么这两个算法就在时间复杂度上就一样了。比较时间复杂度本质上就是比较几个T(N)之间函数的相对增长率。

到这里,我们就可以比较两个算法的时间复杂度了,然而如果有四五种算法要比较好坏,两两相比的方法似乎比较麻烦。于是我们想说能不能定义一些等级,看一看每个算法属于什么登记就可以估计他的复杂度。具体的做法是构造一个函数F(N),通常是弄成下面几种
F(N) = 1
F(N) = logN
F(N) = N
F(N) = N logN
F(N) = N2
F(N) = N3
F(N) = 2N
F(N) = N!
这些级别之间的差异,很多书上都有列表和函数图来让你体会,我就偷懒一下不贴图了。
接下来呢,比较T(N)和F(N)中的一个确定T(N)所在的等级。

这里要先介绍几个定义和符号。
当N很大时(趋于无限),T(N) <= cF(N),c为一个常数,我们记为T(N) = O(F(N)); 读 大O……
当N很大时(趋于无限),T(N) >= cF(N),c为一个常数,我们记为T(N) = Ω(F(N)); 读 omega
当T(N) = O(G(N)) 且 T(N) = Ω(G(N)) 记为T(N) = Θ(G(N));读 theta
当T(N) = O(G(N)) 且 T(N) != Ω(G(N)) 记为T(N) = o(G(N));读 小o……

这里解释一下常数c,这个只是为了消除同阶级之间的差别,也就是上面有写到的T1(N)/T2(N)=一个常数,不论这个常数是什么,1也好,0.00000001,或者1000000我们都把他们看作在同一个等级。因为相比于无穷大和无穷小,常数级别的差异都可以忽略。定义一说明T(N)增长率大于等于F(N),第二个反过来。第三个说明两个函数增长率同阶(相等,忽略常数)。第四个说明T(N)增长率严格小于G(N)。
理论上有这么多东西,但是我们往往只求O(F(N)),保证得到一个上界,也就是所谓的大O标记法

下面我们来看几个例子,看一看算法的时间复杂度在代码上的体现。

常数复杂度O(1)

   1:  int sum = 0, n = 100; /*执行一次*/
   2:  sum = (1+n)*n/2;   /*执行第1次*/
   3:  sum = (1+n)*n/2;   /*执行第2次*/
   4:  sum = (1+n)*n/2;   /*执行第3次*/
   5:  sum = (1+n)*n/2;   /*执行第4次*/
   6:  sum = (1+n)*n/2;   /*执行第5次*/
   7:  sum = (1+n)*n/2;   /*执行第6次*/
   8:  sum = (1+n)*n/2;   /*执行第7次*/
   9:  sum = (1+n)*n/2;   /*执行第8次*/
  10:  sum = (1+n)*n/2;   /*执行第9次*/
  11:  sum = (1+n)*n/2;   /*执行第10次*/
  12:  printf("%d",sum);  /*执行一次*/ 

这段程序T(N)= 12,这是一个常数,用大O标记法就是F(N)= 1;也就是常数阶级,我们简单的说这个算法的复杂度是O(1)的。
这里就体现了一个把常数忽略掉的思想,就算T(N)= 99999999,我们一样认为他的复杂度是O(1)。

对数复杂度O(log n)

   1:  int count = 1;
   2:  while (count < n)
   3:  {
   4:     count = count * 2;
   5:     /*时间复杂度为O(1)的程序步骤序列*/
   6:  }

这个相比其他的稍微难理解一点,不过好在它有一个最经常出现的规律法则
算法把问题的大小削减成一部分(通常是1/2),他的复杂度就是O(log n)。

比如一开始问题规模是n,一条或几条语句(严格的说是一个O(1)的算法)之后,问题的规模只剩下n/2(或者是削减到其他大小的规模),我们可以认定他的复杂度为O(log n)

线性复杂度O(n)

   1:  for(int i = 0; i < n; i++)
   2:  {
   3:     /*时间复杂度为O(1)的程序步骤序列*/
   4:  }

这个不难理解他的复杂度就是O(n).

这里在做一个补充,如果算法如下

   1:  for(int i = 0; i < 10; i++)
   2:  {
   3:      //DoSomething;
   4:  }
   5:   
   6:  for(int j = 0; j < m; j++)
   7:  {
   8:      //DoSomething;
   9:  }

这边第一个循环我们可以看成是一个O(1)的复杂度,第二个循环是O(n)的复杂度,那么整体的复杂度我们认为是O(n)。也就是取比较大的复杂度
法则是这样的如果T1(N) = O(F(N)),T2 = O(G(N)),则T1(N)+ T2(N)= max(O(F(N)),O(G(N)))

O(n log n)--这个应该叫什么呢?

基本思想是 n log n = log nn然后就可以参考对数阶级的方面,这个复杂度往往会在递归算法中出现,自己水平不行,遇到这个复杂度的算法往往分析不清楚。

平方阶级的复杂度O(n2)

   1:  int i,j;
   2:  for(i = 0; i < n; i++)
   3:  {
   4:     for (j = 0; j < n;j++)                       
   5:     {                                      
   6:         /*时间复杂度为O(1)的程序步骤序列*/
   7:     }                                      
   8:  }
很清楚这个复杂度就是O(n2)
 
看两段有一点不一样的算法
   1:  int i,j;
   2:  for(i = 0; i < m; i++)
   3:  {
   4:     for (j = 0; j < n; j++)                
   5:     {                                      
   6:         /*时间复杂度为O(1)的程序步骤序列*/
   7:     }                                      
   8:  }

这个的T(N)= m * n ,由于m,n之间的差别是常数级别的所以我们认为他的复杂度为O(n2)

   1:  int i,j;
   2:  for(i = 0; i < n; i++)
   3:  {
   4:      for (j = i; j < n; j++)  /*注意int j = i而不是0*/
   5:      {                                      
   6:            /*时间复杂度为O(1)的程序步骤序列*/
   7:      }                                      
   8:  }
 
这边呢?需要一点点数学的东西,他的T(n)=2-9-1

出现线性复杂度和平方复杂度,我们取复杂度大的,然后无视掉1/2常数,所以最终复杂度为O(n2)

关于立方级别的复杂度O(n3)和平方分析相同,就是多嵌套一层循环罢了,再高的常数次方都一样。

指数级O(2n)的和阶乘级O(n!)别的,太少见了,而且这个复杂度是在大的可怕。

复杂度分析中,最最麻烦的就是遇到递归算法,那些能把递归算法玩弄于鼓掌之间的人我们一律称为神。

5、几个算法展示
//冒泡排序

void bubbleSort(int n, int* number)

{

    int i;

    int j;

    for(i = 0; i < n; i++)

    {

        for(j = 1; j < n - i; j++)

        {

            if(number[j] < number[j - 1])

            {

                int tmp = number[j];

                number[j] = number[j - 1];

                number[j - 1] = tmp;

            }

        }

    }

}
 
//选择排序

void selectionSort(int n, int* number)

{

    int i;

    int j;

    

    for(i = 0; i < n; i++)

    {

        int min = number[i];

        int minIndex = i;

        for(j = i; j < n; j++)

        {

            if(number[j] < min)

            {

                min = number[j];

                minIndex = j;

            }

        }

        int tmp;

        tmp = number[i];

        number[i] = min;

        number[minIndex] = tmp;

    }

}

//二分查找

bool binarySearch(int* number, int left, int right ,int key)

{

    int mid;

    while (left <= right)

    {

        mid = (left + right) / 2;

        if(number[mid] == key)

        {

            return true;

        }

        else

        {

            if(key > number[mid])

            {

                left = mid + 1;

            }

            else

            {

                right = mid -1;

            }

        }

    }

    return false;

}

//贪心算法实例

/*

这货不是背包问题。

有N个货物,每个货物重量为1,第i个货位的价值为P[i]。你有一个包,容量为V。

求能得最大价值

*/

//贪心思想,那价值最高的前V个。

int main()

{

    int N = 5;

    int V = 2;

    int P[5] = {31,65,2,5,65};

    int sum = 0;

    int i;

    int j;

    for(i = 0; i < N; i++)

    {

        for(j = 1; j < N - i; j++)

        {

            if(P[j] > P[j - 1])

            {

                int tmp = P[j];

                P[j] = P[j - 1];

                P[j - 1] = tmp;

            }

        }

    }

    for(i = 0; i < V; i++)

    {

        sum += P[i];

    }

    

    printf("%d ", sum);

    system("pause");

    return 0;

}

//动态规划简单例子.基本背包问题

/*

有N件物品和一个容量为V的背包。

第i件物品的费用是c[i],价值是w[i]。

求解将哪些物品装入背包可使价值总和最大。

*/



/*

定义状态:f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值

“将前i件物品放入容量为v的背包中”这个子问题,

若只考虑第i件物品的策略(放或不放),那么就可以转化为一个只牵扯前i-1件物品的问题。

如果不放第 i件物品,那么问题就转化为“前i-1件物品放入容量为v的背包中”,价值为f[i-1][v];

如果放第i件物品,那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”,

此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。

状态转移方程:f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}

*/



int main()

{

    int N = 5;

    int V = 30;

    //为边界设置方便第0件物品都设置成0

    int c[6] = {0,9,12,16,5,15};

    int w[6] = {0,19,15,18,8,22};

    int f[6][31];

    int i;

    int j;

    

    //初始化

    for(i = 0; i <= N; i++)

    {

        for(j = 0; j <= V; j++)

        {

            f[i][i] = 0;

        }

    }

    //递推

    for(i = 1; i <= N; i++)

    {

        for(j = c[i]; j <= V; j++)

        {

            if(f[i-1][j] > f[i-1][j-c[i]]+w[i])

            {

                f[i][j] = f[i-1][j];

            }

            else

            {

                f[i][j] = f[i-1][j-c[i]]+w[i];

            }

        }

    }

    

    printf("%d ",f[N][V]);



    system("pause");

    return 0;

}

你可能感兴趣的:(算法)