在信息领域，两个长度相等的字符串的海明距离是在相同位置上不同的字符的个数，也就是将一个字符串替换成另一个字符串需要的替换的次数。

例如：

• "toned" and "roses" is 3.
• 1011101 and 1001001 is 2.
• 2173896 and 2233796 is 3.

对于二进制来说，海明距离的结果相当于 a XOR b 结果中1的个数。

python代码如下

def hamming_distance(s1, s2):

    assert len(s1) == len(s2)

    return sum(ch1 != ch2 for ch1, ch2 in zip(s1, s2))

print (hamming_distance("gdad","glas"))

结果是2

C语言代码如下

unsigned hamdist(unsigned x, unsigned y)

{

  unsigned dist = 0, val = x ^ y;

  // Count the number of set bits

  while(val)

  {

    ++dist;

    val &= val - 1;

  }

  return dist;

}

int main()

{

         unsigned x="abcdcc";

         unsigned y="abccdd";

         unsigned z=hamdist(x,y);

         printf("%d",z);

}

本文转自：http://www.cppblog.com/humanchao/archive/2012/12/26/196680.html

By unanao

<sunjianjiao@gmail.com>

一、什么是大小端问题

(From《Computer Systems,A Programer's Perspective》)在几乎所有的机器上，多字节对象被存储为连续的字节序列，对象的地址为所使用字节序列中最低字节地址。

小端：某些机器选择在存储器中按照从最低有效字节到最高有效字节的顺序存储对象，这种最低有效字节在最前面的表示方式被称为小端法(little endian) 。这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；

       大端：某些机器则按照从最高有效字节到最低有效字节的顺序储存，这种最高有效字节在最前面的方式被称为大端法(big endian) 。这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。

 举个例子来说名大小端:  比如一个int x, 地址为0x100, 它的值为0x1234567. 则它所占据的0x100, 0x101, 0x102, 0x103地址组织如下图:

二、为什么会有大小端模式之分呢？

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于 8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于 大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

三、如何区分大小端问题：

方法1：

       C中的数据类型都是从内存的低地址向高地址扩展，取址运算"&"都是取低地址。小端方式中（i占至少两个字节的长度）则i所分配的内存最小地址那个字节中就存着1，其他字节是0。大端的话则1在i的最高地址字节处存放，char是一个字节，所以强制将char型量p指向i，则p指向的一定是i的最低地址，那么就可以判断p中的值是不是1来确定是不是小端。

方法2：

       利用联合体的特点，数据成员共享内存空间，union中元素的起始地址都是相同的——位于联合的开始。 用char来截取感兴趣的字节。

四、需要考虑大小端（字节顺序）的情况

1、所写的程序需要向不同的硬件平台迁移，说不定哪一个平台是大端还是小端，为了保证可移植性，一定提前考虑好。

2. 在不同类型的机器之间通过网络传送二进制数据时。 一个常见的问题是当小端法机器产生的数据被发送到大端法机器或者反之时，接受程序会发现，字(word)里的字节(byte)成了反序的。为了避免这类问 题，网络应用程序的代码编写必须遵守已建立的关于字节顺序的规则，以确保发送方机器将它的内部表示转换成网络标准，而接受方机器则将网络标准转换为它的内部标准。

3. 当阅读表示整数的字节序列时。这通常发生在检查机器级程序时，e.g.：反汇编得到的一条指令：
80483bd: 01 05 64 94 04 08        add %eax, 0x8049464

3. 当编写强转的类型系统的程序时。如写入的数据为u32型，但是读取的时候却是char型的。如：0x1234, 大端读取为12时，小端独到的是34。

六、提高程序的可移植性

使用宏编译

#ifdef LITTLE_ENDIAN

//小端的代码

#else

//大端的代码

#endif

七、大、小端之间的转换

1、小端转换为大端

本文转自：http://www.cppblog.com/humanchao/archive/2012/12/26/196684.html

     一个循环有序数组（如：3,4,5,6,7,8,9,0,1,2），不知道其最小值的位置，要查找任一数值的位置。要求算法时间复杂度为log2(n)。

问题分析：

    我们可以把循环有序数组分为左右两部分（以mid = （low+high）/ 2为界），由循环有序数组的特点知，左右两部分必有一部分是有序的，我们可以找出有序的这部分，然后看所查找元素是否在有序部分，若在，则直接对有序部分二分查找，若不在，对无序部分递归调用查找函数。

代码如下：

    #include <iostream>

    using namespace std;

    int binarySearch(int a[],int low,int high,int value)  //二分查找
    {
        if(low>high)
            return -1;

        int mid=(low+high)/2;

        if(value==a[mid])
            return mid;
        else if(value>a[mid])
            return binarySearch(a,mid+1,high,value);
        else
            return binarySearch(a,low,mid-1,value);
    }

    int Search(int a[],int low,int high,int value)     //循环有序查找函数
    {
        int mid=(low+high)/2;

        if(a[mid]>a[low])       //左有序
        {
            if(a[low]<=value && value<=a[mid] )        //说明value在左边，直接二分查找
            {
                return binarySearch(a,low,mid,value);
            }

            else                                       //value在右边
            {
                return Search(a,mid+1,high,value);
            }
        }
        else                    //右有序
        {
            if(a[mid]<=value && value<=a[high])
            {
                return binarySearch(a,mid,high,value);
            }
            else
            {
                return Search(a,low,mid-1,value);
            }
        }
    }

    int main()
    {
        int a[]={3,4,5,6,7,8,9,0,1,2};

        cout<<Search(a,0,9,0)<<endl;

        return 0;
    }

哈希表算法-哈希表的构造方法

１、直接定址法

例如：有一个从1到100岁的人口数字统计表，其中，年龄作为关键字，哈希函数取关键字自身。

           但这种方法效率不高,时间复杂度是O(1),空间复杂度是O(n),n是关键字的个数

哈希表算法

２、数字分析法

有学生的生日数据如下：

年.月.日

75.10.03
75.11.23
76.03.02
76.07.12
75.04.21
76.02.15
...

经分析,第一位，第二位，第三位重复的可能性大，取这三位造成冲突的机会增加，所以尽量不取前三位，取后三位比较好。

３、平方取中法

取关键字平方后的中间几位为哈希地址。

４、折叠法

将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分的叠加和（舍去进位）作为哈希地址，这方法称为折叠法。

例如：每一种西文图书都有一个国际标准图书编号，它是一个10位的十进制数字，若要以它作关键字建立一个哈希表，当馆藏书种类不到10,000时，可采用此法构造一个四位数的哈希函数。如果一本书的编号为0-442-20586-4,则：

哈希表算法

５、除留余数法

取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。

H(key)=key MOD p (p<=m)

６、随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即

H(key)=random(key) ,其中random为随机函数。通常用于关键字长度不等时采用此法。

５、除留余数法

取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。

H(key)=key MOD p (p<=m)

６、随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即

H(key)=random(key) ,其中random为随机函数。通常用于关键字长度不等时采用此法。

５、除留余数法

取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。

H(key)=key MOD p (p<=m)

６、随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即

H(key)=random(key) ,其中random为随机函数。通常用于关键字长度不等时采用此法。

它是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

基数排序时对每一维进行调用子排序算法时要求这个子排序算法必须是稳定的。
基数排序与直觉相反：它是按照从底位到高位的顺序排序的。

伪代码：

RADIX-SORT(A,d)

1    for i <-- 1 to d

2        do use a stable sort to sort array A on digit i

引理8.3： 给定n个d位数，每一个数位可以取k种可能的值，如果所用稳定排序需要Θ(n+k)时间，基数排序能以Θ(d(n+k))的时间完成。

证明：如果采用计数排序这种稳定排序，那么每一遍处理需要时间Θ(n+k)，一共需处理d遍，于是基数排序的运行时间为Θ(d(n+k))。当d为常数，k=O(n)时，有线性运行时间。

注：将关键字分成若干位方面，可以有一定的灵活性。

引理8.4：给定n个b位数和任何正整数r<=b，如果采用的稳定排序需要Θ(d(n+k))时间，则RADIX-SORT能在Θ((b/r)(n+2r))时间内正确地对这些数进行排序。

证明：对于一个r<=b,将每个关键字看成由d=b/r位组成的数，每一个数字都是(0~ -1)之间的一个整数，这样就可以采取计数排序。K= ，d=b/r，总的运行时间为Θ((b/r)(n+ ))。

对于给定的n值和b值，如何选择r值使得最小化表达式(b/r)(n+2r)。如果b< lgn，对于任何r<=b的值，都有(n+2r)=Θ(n)，于是选择r=b，使计数排序的时间为Θ((b/b)(n+2b)) = Θ(n)。 如果b>lgn，则选择r=lgn，可以给出在某一常数因子内的最佳时间：当r=lgn时，算法复杂度为Θ(bn/lgn)，当r增大到lgn以上时，分子 增大比分母r快，于是运行时间复杂度为Ω(bn/lgn)；反之当r减小到lgn以下的时候，b/r增大，而n+ 仍然是Θ(n)。

以下引自麻省理工学院算法导论——笔记：












以下代码实例转自：http://www.docin.com/p-449224125.html

      当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。

由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。计数排序之所以能够突破前面所述的Ω(nlgn)极限，是因为它不是基于元素比较的。计数排序适合所需排序的数组元素取值范围不大的情况(范围太大的话辅助空间很大)。

定理：任意一个比较排序算法在最坏情况下，都需要做Ω(nlgn)次比较。

算法的步骤如下：

• 找出待排序的数组中最大和最小的元素
• 统计数组中每个值为i的元素出现的次数，存入数组C的第i项
• 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
• 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

以下引自麻省理工学院算法导论——笔记：

Counting sort: No comparisons between elements.
• Input: A[1 . . n], where A[ j]􀂏{1, 2, …, k} .
• Output: B[1 . . n], sorted.
• Auxiliary storage: C[1 . . k] .

Counting sort
for i  ← 1 to k
do C[i]  ← 0
for j  ←1 to n
do C[A[ j]]  ← C[A[ j]] + 1   —> C[i] = |{key = i}|
for i  ← 2 to k
do C[i]  ← C[i] + C[i–1]        —>C[i] = |{key  ← i}|
for j  ← n downto 1
do B[C[A[ j]]]  ← A[ j]
C[A[ j]]  ← C[A[ j]] – 1

实例：

对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）

反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

注：基于比较的排序算法的最佳平均时间复杂度为 O(nlogn)
     稳定性：算法是稳定的。

如果k小于nlogn可以用计数排序，如果k大于nlogn可以用归并排序。

代码实例：

使用条件&范围
通常可以在任何图中使用，包括有向图、带负权边的图。

Floyd-Warshall 算法用来找出每对点之间的最短距离。它需要用邻接矩阵来储存边，这个算法通过考虑最佳子路径来得到最佳路径。

1.注意单独一条边的路径也不一定是最佳路径。
2.从任意一条单边路径开始。所有两点之间的距离是边的权，或者无穷大，如果两点之间没有边相连。
对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是更新它。
3.不可思议的是，只要按排适当，就能得到结果。
伪代码:

我们平时所见的Floyd算法的一般形式如下：

注意下第6行这个地方，如果dist[i][k]或者dist[k][j]不存在，程序中用一个很大的数代替。最好写成if(dist[i] [k]!=INF && dist[k][j]!=INF && dist[i][k]+dist[k][j]

Floyd算法的实现以及输出最短路径和最短路径长度，具体过程请看【动画演示Floyd算法】。

代码说明几点：

1、A[][]数组初始化为各顶点间的原本距离，最后存储各顶点间的最短距离。

2、path[][]数组保存最短路径，与当前迭代的次数有关。初始化都为-1，表示没有中间顶点。在求A[i][j]过程中，path[i][j]存放从顶点vi到顶点vj的中间顶点编号不大于k的最短路径上前一个结点的编号。在算法结束时，由二维数组path的值回溯，可以得到从顶点vi到顶点vj的最短路径。

初始化A[][]数组为如下，即有向图的邻接矩阵。

完整的实现代码如下：

测试结果如下：

本文转自：http://www.wutianqi.com/?p=1903

Dijkstra算法是很有代表性的最短路算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。

其基本思想是，设置顶点集合S并不断地作贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。

初始时，S中仅含有源。设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短特殊路径长度。Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist作必要的修改。一旦S包含了所有V中顶点，dist就记录了从源到所有其它顶点之间的最短路径长度。

例如，对下图中的有向图，应用Dijkstra算法计算从源顶点1到其它顶点间最短路径的过程列在下表中。

Dijkstra算法的迭代过程：

主题好好理解上图！

以下是具体的实现(C/C++):

输入数据:
5
7
1 2 10
1 4 30
1 5 100
2 3 50
3 5 10
4 3 20
4 5 60
输出数据:
999999 10 999999 30 100
10 999999 50 999999 999999
999999 50 999999 20 10
30 999999 20 999999 60
100 999999 10 60 999999
源点到最后一个顶点的最短路径长度: 60
源点到最后一个顶点的路径为: 1 -> 4 -> 3 -> 5

 本文转自：http://www.wutianqi.com/?p=1890
其他连接：http://2728green-rock.blog.163.com/blog/static/43636790200901211848284/

当一个问题具有最优子结构性质时，我们会想到用动态规划法去解它。但有时会有更简单有效的算法。我们来看一个找硬币的例子。假设有四种硬币，它们的面值分别为二角五分、一角、五分和一分。现在要找给某顾客六角三分钱。这时，我们会不假思索地拿出2个二角五分的硬币，1个一角的硬币和3个一分的硬币交给顾客。这种找硬币方法与其他的找法相比，所拿出的硬币个数是最少的。这里，我们下意识地使用了这样的找硬币算法：首先选出一个面值不超过六角三分的最大硬币，即二角五分；然后从六角三分中减去二角五分，剩下三角八分；再选出一个面值不超过三角八分的最大硬币，即又一个二角五分，如此一直做下去。这个找硬币的方法实际上就是贪心算法。顾名思义，贪心算法总是作出在当前看来是最好的选择。也就是说贪心算法并不从整体最优上加以考虑，它所作出的选择只是在某种意义上的局部最优选择。当然，我们希望贪心算法得到的最终结果也是整体最优的。上面所说的找硬币算法得到的结果就是一个整体最优解。找硬币问题本身具有最优子结构性质，它可以用动态规划算法来解。但我们看到，用贪心算法更简单，更直接且解题效率更高。这利用了问题本身的一些特性。例如，上述找硬币的算法利用了硬币面值的特殊性。如果硬币的面值改为一分、五分和一角一分3种，而要找给顾客的是一角五分钱。还用贪心算法，我们将找给顾客1个一角一分的硬币和4个一分的硬币。然而3个五分的硬币显然是最好的找法。虽然贪心算法不是对所有问题都能得到整体最优解，但对范围相当广的许多问题它能产生整体最优解。如图的单源最短路径问题，最小生成树问题等。在一些情况下，即使贪心算法不能得到整体最优解，但其最终结果却是最优解的很好的近似解。

二．求解活动安排问题算法

活动安排问题是可以用贪心算法有效求解的一个很好的例子。该问题要求高效地安排一系列争用某一公共资源的活动。贪心算法提供了一个简单、漂亮的方法使得尽可能多的活动能兼容地使用公共资源。

设有n个活动的集合e={1，2，…，n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。每个活动i都有一个要求使用该资源的起始时间si和一个结束时间f_i,且s_i<f_i。如果选择了活动i，则它在半开时间区间[s_i，f_i]内占用资源。若区间[s_i，f_i]与区间[s_j，f_j]不相交，则称活动i与活动j是相容的。也就是说，当s_i≥fi或s_j≥f_j时，活动i与活动j相容。活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

在下面所给出的解活动安排问题的贪心算法gpeedyselector中，各活动的起始时间和结束时间存储于数组s和f{中且按结束时间的非减序：．f1≤f2≤…≤fn排列。如果所给出的活动未按此序排列，我们可以用o(nlogn)的时间将它重排。

算法greedyselector中用集合a来存储所选择的活动。活动i在集合a中，当且仅当a[i]的值为true。变量j用以记录最近一次加入到a中的活动。由于输入的活动是按其结束时间的非减序排列的，f_j总是当前集合a中所有活动的最大结束时间，即：

贪心算法greedyselector一开始选择活动1，并将j初始化为1。然后依次检查活动i是否与当前已选择的所有活动相容。若相容则将活动i加人到已选择活动的集合a中，否则不选择活动i，而继续检查下一活动与集合a中活动的相容性。由于f_i

总是当前集合a中所有活动的最大结束时间，故活动i与当前集合a中所有活动相容的充分且必要的条件是其开始时间s 不早于最近加入集合a中的活动j的结束时间f_j，s_i≥f_j。若活动i与之相容，则i成为最近加人集合a中的活动，因而取代活动j的位置。由于输人的活动是以其完成时间的非减序排列的，所以算法greedyselector每次总是选择具有最早完成时间的相容活动加入集合a中。直观上按这种方法选择相容活动就为未安排活动留下尽可能多的时间。也就是说，该算法的贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。算法greedyselector的效率极高。当输人的活动已按结束时间的非减序排列，算法只需g(n)的时间来安排n个活动，使最多的活动能相容地使用公共资源。

例：设待安排的11个活动的开始时间和结束时间按结束时间的非减序排列如下：

算法greedyselector的计算过程如图所示。

图中每行相应于算法的一次迭代。阴影长条表示的活动是已选人集合a中的活动，而空白长条表示的活动是当前正在检查其相容性的活动。

若被检查的活动i的开始时间s_i小于最近选择的活动了的结束时间f_j，则不选择活动i，否则选择活动i加入集合a中。

三．算法分析

贪心算法并不总能求得问题的整体最优解。但对于活动安排问题，贪心算法greedyse—1ector却总能求得的整体最优解，即它最终所确定的相容活动集合a的规模最大。我们可以用数学归纳法来证明这个结论。

事实上，设e={1，2，…，n}为所给的活动集合。由于正中活动按结束时间的非减序排列，故活动1具有最早的完成时间。首先我们要证明活动安排问题有一个最优解以贪心选择开始，即该最优解中包含活动1。设 是所给的活动安排问题的一个最优解，且a中活动也按结束时间非减序排列，a中的第一个活动是活动k。若k=1，则a就是一个以贪心选择开始的最优解。若k>1，则我们设 。由于f1≤f_k，且a中活动是互为相容的，故b中的活动也是互为相容的。又由于b中活动个数与a中活动个数相同，且a是最优的，故b也是最优的。也就是说b是一个以贪心选择活动1开始的最优活动安排。因此，我们证明了总存在一个以贪心选择开始的最优活动安排方案。

进一步，在作了贪心选择，即选择了活动1后，原问题就简化为对e中所有与活动1相容的活动进行活动安排的子问题。即若a是原问题的一个最优解，则a’=a—{i}是活动安排问题 的一个最优解。事实上，如果我们能找到e’的一个解b’，它包含比a’更多的活动，则将活动1加入到b’中将产生e的一个解b，它包含比a更多的活动。这与a的最优性矛盾。因此，每一步所作的贪心选择都将问题简化为一个更小的与原问题具有相同形式的子问题。对贪心选择次数用数学归纳法即知，贪心算法greedyselector最终产生原问题的一个最优解。

四．贪心算法的基本要素

贪心算法通过一系列的选择来得到一个问题的解。它所作的每一个选择都是当前状态下某种意义的最好选择，即贪心选择。希望通过每次所作的贪心选择导致最终结果是问题的一个最优解。这种启发式的策略并不总能奏效，然而在许多情况下确能达到预期的目的。解活动安排问题的贪心算法就是一个例子。下面我们着重讨论可以用贪心算法求解的问题的一般特征。

对于一个具体的问题，我们怎么知道是否可用贪心算法来解此问题，以及能否得到问题的一个最优解呢?这个问题很难给予肯定的回答。但是，从许多可以用贪心算法求解的问题中

我们看到它们一般具有两个重要的性质：贪心选择性质和最优子结构性质。

1．贪心选择性质

所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。在动态规划算法中，每步所作的选择往往依赖于相关子问题的解。因而只有在解出相关子问题后，才能作出选择。而在贪心算法中，仅在当前状态下作出最好选择，即局部最优选择。然后再去解作出这个选择后产生的相应的子问题。贪心算法所作的贪心选择可以依赖于以往所作过的选择，但决不依赖于将来所作的选择，也不依赖于子问题的解。正是由于这种差别，动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行,以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为一个规模更小的子问题。

对于一个具体问题，要确定它是否具有贪心选择性质，我们必须证明每一步所作的贪心选择最终导致问题的一个整体最优解。通常可以用我们在证明活动安排问题的贪心选择性质时所采用的方法来证明。首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始。而且作了贪心选择后，原问题简化为一个规模更小的类似子问题。然后，用数学归纳法证明，通过每一步作贪心选择，最终可得到问题的一个整体最优解。其中，证明贪心选择后的问题简化为规模更小的类似子问题的关键在于利用该问题的最优子结构性质。

2．最优子结构性质

当一个问题的最优解包含着它的子问题的最优解时，称此问题具有最优子结构性质。问题所具有的这个性质是该问题可用动态规划算法或贪心算法求解的一个关键特征。在活动安排问题中，其最优子结构性质表现为：若a是对于正的活动安排问题包含活动1的一个最优解,则相容活动集合a’=a—{1}是对于e’={i∈e:s_i≥f₁}的活动安排问题的一个最优解。

3．贪心算法与动态规划算法的差异

贪心算法和动态规划算法都要求问题具有最优子结构性质，这是两类算法的一个共同点。但是，对于一个具有最优子结构的问题应该选用贪心算法还是动态规划算法来求解?是不是能用动态规划算法求解的问题也能用贪心算法来求解?下面我们来研究两个经典的组合优化问题，并以此来说明贪心算法与动态规划算法的主要差别。

五． ０－背包问题

给定n种物品和一个背包。物品i的重量是w ，其价值为v ，背包的容量为c.问应如何选择装入背包中的物品，使得装入背包中物品的总价值最大? 在选择装入背包的物品时，对每种物品i只有两种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。

此问题的形式化描述是，给定c>0，w_i>0，v_i>0，1≤i≤n，要求找出一个n元0—1向

量(xl，x2，…，x_n)， ，使得 ≤c，而且 达到最大。

背包问题：与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包。

此问题的形式化描述是，给定c>0，w_i>0，v_i>0，1≤i≤n，要求找出一个n元向量

(x1,x2,...x_n)，0≤x_i≤1，1≤i≤n 使得 ≤c，而且 达到最大。

这两类问题都具有最优子结构性质。对于0—1背包问题，设a是能够装入容量为c的背包的具有最大价值的物品集合，则a_j=a-{j}是n-1个物品1，2，…，j—1，j+1，…，n可装入容量为c-w_i叫的背包的具有最大价值的物品集合。对于背包问题，类似地，若它的一个最优解包含物品j，则从该最优解中拿出所含的物品j的那部分重量w_i，剩余的将是n-1个原重物品1，2，…，j-1，j+1，…，n以及重为w_j-w_i的物品j中可装入容量为c-w的背包且具有最大价值的物品。

虽然这两个问题极为相似，但背包问题可以用贪心算法求解，而0·1背包问题却不能用贪心算法求解。用贪心算法解背包问题的基本步骤是，首先计算每种物品单位重量的价值

v_j／w_i然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包。若将这种物品全部装入背包后，背包内的物品总重量未超过c，则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直进行下去直到背包装满为止。具体算法可描述如下：

void knapsack(int n, float m, float v[ ], float w[ ], float x[ ] )

sort(n,v,w);

int i;

for(i= 1;i<= n;i++) x[i] = o;

float c = m;

for (i = 1;i < = n;i ++) {

if (w[i] > c) break;

x[i] = 1;

c-= w[i];

}

if (i < = n) x[i] = c/w[i];

}

算法knapsack的主要计算时间在于将各种物品依其单位重量的价值从大到小排序。因此，算法的计算时间上界为o(nlogn)。当然，为了证明算法的正确性，我们还必须证明背包问题具有贪心选择性质。

这种贪心选择策略对0—1背包问题就不适用了。看图2(a)中的例子，背包的容量为50千克；物品1重10千克；价值60元；物品2重20千克，价值100元；物品3重30千克；价值120元。因此，物品1每千克价值6元，物品2每千克价值5元，物品3每千克价值4元。若依贪心选择策略，应首选物品1装入背包，然而从图4—2(b)的各种情况可以看出，最优的选择方案是选择物品2和物品3装入背包。首选物品1的两种方案都不是最优的。对于背包问题，贪心选择最终可得到最优解，其选择方案如图2(c)所示。

对于0—1背包问题，贪心选择之所以不能得到最优解是因为它无法保证最终能将背包装满，部分背包空间的闲置使每千克背包空间所具有的价值降低了。事实上，在考虑0—1背包问题的物品选择时，应比较选择该物品和不选择该物品所导致的最终结果，然后再作出最好选择。由此就导出许多互相重叠的于问题。这正是该问题可用动态规划算法求解的另一重要特征。动态规划算法的确可以有效地解0—1背包问题。

本文转自：http://www.cppblog.com/3522021224/archive/2007/06/16/26429.aspx
其他链接：http://www.cnblogs.com/chinazhangjie/archive/2010/11/23/1885330.html

哈希表和哈希函数是大学数据结构中的课程，实际开发中我们经常用到Hashtable这种结构，当遇到键-值对存储，采用Hashtable比ArrayList查找的性能高。为什么呢？我们在享受高性能的同时，需要付出什么代价(这几天看红顶商人胡雪岩，经典台词：在你享受这之前，必须受别人吃不了的苦，忍受别人受不了的屈辱)，那么使用Hashtable是否就是一桩无本万利的买卖呢？就此疑问，做以下分析，希望能抛砖引玉。
1)hash它为什么对于键-值查找性能高
学过数据结构的，都应该晓得，线性表和树中，记录在结构中的相对位置是随机的，记录和关键字之间不存在明确的关系，因此在查找记录的时候，需要进行一系列的关键字比较，这种查找方式建立在比较的基础之上，在.net中(Array,ArrayList,List)这些集合结构采用了上面的存储方式。
比如，现在我们有一个班同学的数据，包括姓名，性别，年龄，学号等。假如数据有

假如，我们按照姓名来查找，假设查找函数FindByName(string name);
1)查找“张三”
只需在第一行匹配一次。
2)查找"王五"
   在第一行匹配，失败，
   在第二行匹配，失败，
   在第三行匹配，成功
上面两种情况，分别分析了最好的情况，和最坏的情况，那么平均查找次数应该为 (1+3)/2=2次，即平均查找次数为(记录总数+1)的1/2。
尽管有一些优化的算法，可以使查找排序效率增高，但是复杂度会保持在log2n的范围之内。
如何更更快的进行查找呢？我们所期望的效果是一下子就定位到要找记录的位置之上，这时候时间复杂度为1，查找最快。如果我们事先为每条记录编一个序号，然后让他们按号入位，我们又知道按照什么规则对这些记录进行编号的话，如果我们再次查找某个记录的时候，只需要先通过规则计算出该记录的编号，然后根据编号，在记录的线性队列中，就可以轻易的找到记录了 。
注意，上述的描述包含了两个概念，一个是用于对学生进行编号的规则，在数据结构中，称之为哈希函数，另外一个是按照规则为学生排列的顺序结构，称之为哈希表。
仍以上面的学生为例，假设学号就是规则，老师手上有一个规则表，在排座位的时候也按照这个规则来排序，查找李四，首先该教师会根据规则判断出，李四的编号为2，就是在座位中的2号位置，直接走过去，“李四，哈哈，你小子，就是在这！”
看看大体流程:
 
从上面的图中，可以看出哈希表可以描述为两个筒子，一个筒子用来装记录的位置编号，另外一个筒子用来装记录，另外存在一套规则，用来表述记录与编号之间的联系。这个规则通常是如何制定的呢？
a)直接定址法:
   我在前一篇文章对GetHashCode()性能比较的问题中谈到，对于整形的数据GetHashCode()函数返回的就是整形　　　本身，其实就是基于直接定址的方法，比如有一组0-100的数据，用来表示人的年龄
那么，采用直接定址的方法构成的哈希表为:

总之，哈希函数的规则是：通过某种转换关系，使关键字适度的分散到指定大小的的顺序结构中。越分散，则以后查找的时间复杂度越小，空间复杂度越高。
２)使用hash，我们付出了什么？
hash是一种典型以空间换时间的算法，比如原来一个长度为100的数组，对其查找，只需要遍历且匹配相应记录即可，从空间复杂度上来看，假如数组存储的是byte类型数据，那么该数组占用100byte空间。现在我们采用hash算法，我们前面说的hash必须有一个规则，约束键与存储位置的关系，那么就需要一个固定长度的hash表，此时，仍然是100byte的数组，假设我们需要的100byte用来记录键与位置的关系，那么总的空间为200byte,而且用于记录规则的表大小会根据规则，大小可能是不定的，比如在lzw算法中，如果一个很长的用于记录像素的byte数组，用来记录位置与键关系的表空间，算法推荐为一个1２bit能表述的整数大小，那么足够长的像素数组，如何分散到这样定长的表中呢，lzw算法采用的是可变长编码，具体会在深入介绍lzw算法的时候介绍。
注:hash表最突出的问题在于冲突，就是两个键值经过哈希函数计算出来的索引位置很可能相同，这个问题，下篇文章会令作阐述。
注:之所以会简单得介绍了hash，是为了更好的学习lzw算法，学习lzw算法是为了更好的研究gif文件结构，最后，我将详细的阐述一下gif文件是如何构成的，如何高效操作此种类型文件。

HASH如何处理冲突：

1)冲突是如何产生的？
上文中谈到，哈希函数是指如何对关键字进行编址的规则，这里的关键字的范围很广，可视为无限集，如何保证无限集的原数据在编址的时候不会出现重复呢？规则本身无法实现这个目的。举一个例子，仍然用班级同学做比喻，现有如下同学数据
张三，李四，王五，赵刚，吴露.....
假如我们编址规则为取姓氏中姓的开头字母在字母表的相对位置作为地址，则会产生如下的哈希表

位置	字母	姓名
0	a
1	b
2	c

...

10

L

李四

...

22

W

王五，吴露

..

25

Z

张三，赵刚

我们注意到，灰色背景标示的两行里面，关键字王五，吴露被编到了同一个位置，关键字张三，赵刚也被编到了同一个位置。老师再拿号来找张三，座位上有两个人，"你们俩谁是张三？"
2)如何解决冲突问题
既然不能避免冲突，那么如何解决冲突呢，显然需要附加的步骤。通过这些步骤，以制定更多的规则来管理关键字集合，通常的办法有:
a)开放地址法
开放地执法有一个公式:Hi=(H(key)+di) MOD m i=1,2,...,k(k<=m-1)
其中，m为哈希表的表长。di 是产生冲突的时候的增量序列。如果di值可能为1,2,3,...m-1，称线性探测再散列。
如果di取1，则每次冲突之后，向后移动1个位置.如果di取值可能为1,-1,2,-2,4,-4,9,-9,16,-16,...k*k,-k*k(k<=m/2) 
称二次探测再散列。如果di取值可能为伪随机数列。称伪随机探测再散列。仍然以学生排号作为例子，
现有两名同学，李四，吴用。李四与吴用事先已排好序，现新来一名同学，名字叫王五，对它进行编制

10..	....	22	..	..	25
李四..	....	吴用	..	..	25

   赵刚未来之前

10..	..	22	23	25
李四..		吴用	王五

   (a)线性探测再散列对赵刚进行编址，且di=1

10...	20	22	..	25
李四..	王五	吴用

   (b)二次探测再散列，且di=-2

1...	10...	22	..	25
王五..	李四..	吴用

   (c)伪随机探测再散列,伪随机序列为:5,3,2

b)再哈希法 
当发生冲突时，使用第二个、第三个、哈希函数计算地址，直到无冲突时。缺点：计算时间增加。
比如上面第一次按照姓首字母进行哈希，如果产生冲突可以按照姓字母首字母第二位进行哈希，再冲突，第三位，直到不冲突为止
c)链地址法
将所有关键字为同义词的记录存储在同一线性链表中。如下：

因此这种方法，可以近似的认为是筒子里面套筒子
d.建立一个公共溢出区
假设哈希函数的值域为[0,m-1],则设向量HashTable[0..m-1]为基本表，另外设立存储空间向量OverTable[0..v]用以存储发生冲突的记录。
经过以上方法，基本可以解决掉hash算法冲突的问题。

递归算法学习系列二（归并排序）