解决这个问题的第一想法是一位一位的观察，判断是否为1，是则计数器加一，否则跳到下一位，于是很容易有这样的程序。

或者和其等价的位运算版本：

这样的方法复杂度为二进制的位数，即，于是可是想一下，有没有只与二进制中1的位数相关的算法呢。

可以考虑每次找到从最低位开始遇到的第一个1，计数，再把它清零，清零的位运算操作是与一个零，但是在有1的这一位与零的操作要同时不影响未统计过的位数和已经统计过的位数，于是可以有这样一个操作 n&(n-1) ，这个操作对比当前操作位高的位没有影响，对低位则完全清零。拿6（110）来做例子，第一次 110&101=100，这次操作成功的把从低位起第一个1消掉了，同时计数器加1，第二次100&011=000，同理又统计了高位的一个1，此时n已变为0，不需要再继续了，于是110中有2个1。

代码如下：

这几个方法虽然也用到了位运算，但是并没有体现其神奇之处，下面这个版本则彰显位运算的强大能力，若不告诉这个函数的功能，一般一眼看上去是想不到这是做什么的，这也是wikipedia上给出的计算hamming_weight方法。

没有循环，5个位运算语句，一次搞定。

比如这个例子，143的二进制表示是10001111，这里只有8位，高位的0怎么进行与的位运算也是0，所以只考虑低位的运算，按照这个算法走一次

+---+---+---+---+---+---+---+---+
| 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |   <---143
+---+---+---+---+---+---+---+---+
|  0 1  |  0 0  |  1 0  |  1 0  |   <---第一次运算后
+-------+-------+-------+-------+
|    0 0 0 1    |    0 1 0 0    |   <---第二次运算后
+---------------+---------------+
|        0 0 0 0 0 1 0 1        |   <---第三次运算后，得数为5
+-------------------------------+

这里运用了分治的思想，先计算每对相邻的2位中有几个1，再计算每相邻的4位中有几个1，下来8位，16位，32位，因为2^5＝32，所以对于32位的机器，5条位运算语句就够了。

分析：

把该正整数表示为十进制的字符串：an-1an-2…a0，其中an-1为最高位，a0为最低位(个位)，按最高位、最低位、中间位来分别分析其中1出现的次数：

• 最高位(a_n-1)出现数字1的次数：

如果a_n-1 == 1，则为1b_n-2…b₀，且 0 <= 整数(b_n-2…b₀) <= 整数(a_n-2…a₀)，累计 (a_n-2…a₀)+1个；

否则，a_n-1 > 1，则为1x_n-2…x₀，其中(x_n-2…x₀)为任意(n-1)位整数，累计10^n-1个；

• 最低位(a₀)出现数字1的次数：

如果a₀ == 0，则为b_n-1…b₁1，且 0 <= 整数(b_n-1…b₁) < 整数(a_n-1…a₁)，累计 (a_n-1…a₁)个；

否则a₀ >= 1，则为b_n-1…b₁1，且 0 <= 整数(b_n-2…b₀) <= 整数(a_n-1…a₁)，累计 (a_n-1…a₁)+1个；

• 中间位(a_i)：a_i出现数字1的次数，0 < i < (n-1)：

如果a_i == 0，则为b_n-1…b_i+11x_i-1…x₀，且 0 <= 整数(b_n-1…b_i+1) < 整数(a_n-1…a_i+1)，(x_i-1…x₀)为任意i位数，累计 (a_n-1…a_i+1)*10ⁱ个；

如果a_i == 1，则除了a_i == 0的情形外，还有一种情形：a_n-1…a_i+11c_i-1…c₀，且0 <= (c_i-1…c₀) <= a_i-1…a₀，有(a_i-1…a₀)+1个，累计：(a_n-1…a_i+1)*10ⁱ+(a_i-1…a₀)+1，即(a_n-1…a_i+1a_i-1…a₀)+1个；

当前数组a和数组b的和之差为
    A = sum(a) - sum(b)

a的第i个元素和b的第j个元素交换后，a和b的和之差为
    A' = sum(a) - a[i] + b[j] - （sum(b) - b[j] + a[i])
           = sum(a) - sum(b) - 2 (a[i] - b[j])
           = A - 2 (a[i] - b[j])
    设x = a[i] - b[j]

|A| - |A'| = |A| - |A-2x|

|A'|= |A-2x|

假设A > 0,

当x 在 (0,A)之间时，做这样的交换才能使得交换后的a和b的和之差变小，x越接近A/2效果越好,

如果找不到在(0,A)之间的x，则当前的a和b就是答案。

所以算法大概如下：

分析：先求解一维数组最大和，再求解二维。

假设最大子矩阵的结果为从第r行到k行、从第i列到j列的子矩阵，
如下所示(ari表示a[r][i],假设数组下标从1开始)：

| a11 …… a1i ……a1j ……a1n |
  | a21 …… a2i ……a2j ……a2n |
  .....

| ar1 …… ari ……arj ……arn |     第r行 . . .
  ..........                            | 
                                  V
  | ak1 …… aki ……akj ……akn |   第k行 . . .

.....
  | an1 …… ani ……anj ……ann |

那么我们将从第r行到第k行的每一行中相同列的加起来，可以得到一个一维数组如下：
 (ar1+……+ak1, ar2+……+ak2, ……,arn+……+akn)
 由此我们可以看出最后所求的就是此一维数组的最大子断和问题。

#include <iostream>
using namespace std;
struct Point
{
 short int x;
 short int y;
};

//求一维数组的最大和
int getMaxSumInArray(int data[], int nSize, int& start, int& end)
{
 int sum = data[0];
 int maxSum = data[0];
 for( int i=1; i<nSize; i++)
 {
  if(sum>0)
   sum+=data[i];
  else
  {
   sum = data[i];
   start = i;
   end = i;
  }
  if(sum>maxSum)
  {
   maxSum = sum;
   end = i;
  }
 }
 return maxSum;
}

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。写一个程序求一棵二叉树中相距最远的两个节点之间的距离。

书中对这个问题的分析是很清楚的，我尝试用自己的方式简短覆述。

计算一个二叉树的最大距离有两个情况:

• 情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。
• 情况B: 路径不穿过根节点，而是左子树或右子树的最大距离路径，取其大者。

只需要计算这两个情况的路径距离，并取其大者，就是该二叉树的最大距离。

我也想不到更好的分析方法。

但接着，原文的实现就不如上面的清楚 (源码可从下载):

// 数据结构定义
struct NODE
{NODE* pLeft;            // 左子树NODE* pRight;           // 右子树int nMaxLeft;           // 左子树中的最长距离int nMaxRight;          // 右子树中的最长距离char chValue;           // 该节点的值
};int nMaxLen = 0;// 寻找树中最长的两段距离
void FindMaxLen(NODE* pRoot)
{// 遍历到叶子节点，返回if(pRoot == NULL){return;}// 如果左子树为空，那么该节点的左边最长距离为0if(pRoot -> pLeft == NULL){pRoot -> nMaxLeft = 0; }// 如果右子树为空，那么该节点的右边最长距离为0if(pRoot -> pRight == NULL){pRoot -> nMaxRight = 0;}// 如果左子树不为空，递归寻找左子树最长距离if(pRoot -> pLeft != NULL){FindMaxLen(pRoot -> pLeft);}// 如果右子树不为空，递归寻找右子树最长距离if(pRoot -> pRight != NULL){FindMaxLen(pRoot -> pRight);}// 计算左子树最长节点距离if(pRoot -> pLeft != NULL){int nTempMax = 0;if(pRoot -> pLeft -> nMaxLeft > pRoot -> pLeft -> nMaxRight){nTempMax = pRoot -> pLeft -> nMaxLeft;}else{nTempMax = pRoot -> pLeft -> nMaxRight;}pRoot -> nMaxLeft = nTempMax + 1;}// 计算右子树最长节点距离if(pRoot -> pRight != NULL){int nTempMax = 0;if(pRoot -> pRight -> nMaxLeft > pRoot -> pRight -> nMaxRight){nTempMax = pRoot -> pRight -> nMaxLeft;}else{nTempMax = pRoot -> pRight -> nMaxRight;}pRoot -> nMaxRight = nTempMax + 1;}// 更新最长距离if(pRoot -> nMaxLeft + pRoot -> nMaxRight > nMaxLen){nMaxLen = pRoot -> nMaxLeft + pRoot -> nMaxRight;}
}

这段代码有几个缺点:

1. 算法加入了侵入式(intrusive)的资料nMaxLeft, nMaxRight
2. 使用了全局变量 nMaxLen。每次使用要额外初始化。而且就算是不同的独立资料，也不能在多个线程使用这个函数
3. 逻辑比较复杂，也有许多 NULL 相关的条件测试。

我认为这个问题的核心是，情况A 及 B 需要不同的信息: A 需要子树的最大深度，B 需要子树的最大距离。只要函数能在一个节点同时计算及传回这两个信息，代码就可以很简单:

#include <iostream>using namespace std;struct NODE
{NODE *pLeft;NODE *pRight;
};struct RESULT
{int nMaxDistance;int nMaxDepth;
};RESULT GetMaximumDistance(NODE* root)
{if (!root){RESULT empty = { 0, -1 };       // trick: nMaxDepth is -1 and then caller will plus 1 to balance it as zero.return empty;}RESULT lhs = GetMaximumDistance(root->pLeft);RESULT rhs = GetMaximumDistance(root->pRight);RESULT result;result.nMaxDepth = max(lhs.nMaxDepth + 1, rhs.nMaxDepth + 1);result.nMaxDistance = max(max(lhs.nMaxDistance, rhs.nMaxDistance), lhs.nMaxDepth + rhs.nMaxDepth + 2);return result;
}

45.雅虎：
1.对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）

这题明显用动态规划来解。假设在目标数组array[ ]的前i个元素中，以array[i]元素为最大元素的递增子序列的长度是LIS[i]。那么

递归求解表达式为：

LIS[i+1] = max{1, LIS[k] + 1}, array[i+1] > array[k],   k<=i, k>=0

时间复杂度为O(NlgN)的代码：

int min(int *array,int len)

{

int m = array[0];

for (int i = 1; i < len; i++) {

if (m > array[i])

m = array[i];

}

return m;

}

int findFirstMin(int*array, int len, int key)

{//找出有序数组array中，第一个小于key的元素，并返回该元素的索引

int low = 0;

int high = len - 1;

int mid;

while (low <= high) {

mid = low + (high - low )/2;

if ( array[mid] >= key) {

high = mid - 1;

} else {

low = mid + 1;

}

}

return high;

}

int LIS(int *array,int len)

{

int *lis = new int[len];

int *maxValue = new int[len + 1];

maxValue[1] = array[0];

maxValue[0] = min(array, len) - 1;

int nmax = 1;

for (int i = 0; i < len; i++)

lis[i] = 1;

int j;

for (int i = 1; i < len; i++) {

j = findFirstMin(maxValue,nmax + 1, array[i]);

lis[i] = j + 1;

if (lis[i] > nmax) {

nmax = lis[i];

maxValue[nmax] =array[i];

} else if (array[i] >maxValue[j] && array[i] < maxValue[j + 1]) {

maxValue[j + 1] =array[i];

}

}

delete lis;

delete maxValue;

return nmax;

经常会遇到复杂问题不能简单地分解成几个子问题，而会分解出一系列的子问题。简单地采用把大问题分解成子问题，并综合子问题的解导出大问题的解的方法，问题求解耗时会按问题规模呈幂级数增加。

为了节约重复求相同子问题的时间，引入一个数组，不管它们是否对最终解有用，把所有子问题的解存于该数组中，这就是动态规划法所采用的基本方法。

问题描述：字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。令给定的字符序列X=“x0，x1，…，xm-1”，序列Y=“y0，y1，…，yk-1”是X的子序列，存在X的一个严格递增下标序列<i0，i1，…，ik-1>，使得对所有的j=0，1，…，k-1，有xij=yj。例如，X=“ABCBDAB”，Y=“BCDB”是X的一个子序列。

考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，并Z=“z0，z1，…，zk-1”为它们的最长公共子序列。不难证明有以下性质：

（1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列；

（2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列；

（3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。

求解：

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

问题的递归式写成：

回溯输出最长公共子序列过程：

算法分析：
由于每次调用至少向上或向左（或向上向左同时）移动一步，故最多调用(m + n)次就会遇到i = 0或j = 0的情况，此时开始返回。返回时与递归调用时方向相反，步数相同，故算法时间复杂度为Θ(m + n)。

代码：

#include <stdio.h>
#include < string.h>
#define MAXLEN 100

void LCSLength( char *x,  char *y,  int m,  int n,  int c[][MAXLEN],  int b[][MAXLEN])
{
     int i, j;
    
     for(i = 0; i <= m; i++)
        c[i][0] = 0;
     for(j = 1; j <= n; j++)
        c[0][j] = 0;
     for(i = 1; i<= m; i++)
    {
         for(j = 1; j <= n; j++)
        {
             if(x[i-1] == y[j-1])
            {
                c[i][j] = c[i-1][j-1] + 1;
                b[i][j] = 0;
            }
             else  if(c[i-1][j] >= c[i][j-1])
            {
                c[i][j] = c[i-1][j];
                b[i][j] = 1;
            }
             else
            {
                c[i][j] = c[i][j-1];
                b[i][j] = -1;
            }
        }
    }
}

void PrintLCS( int b[][MAXLEN],  char *x,  int i,  int j)
{
     if(i == 0 || j == 0)
         return;
     if(b[i][j] == 0)
    {
        PrintLCS(b, x, i-1, j-1);
        printf("%c ", x[i-1]);
    }
     else  if(b[i][j] == 1)
        PrintLCS(b, x, i-1, j);
     else
        PrintLCS(b, x, i, j-1);
}

int main( int argc,  char **argv)
{
     char x[MAXLEN] = {"ABCBDAB"};
     char y[MAXLEN] = {"BDCABA"};
     int b[MAXLEN][MAXLEN];
     int c[MAXLEN][MAXLEN];
     int m, n;
    
    m = strlen(x);
    n = strlen(y);
    
    LCSLength(x, y, m, n, c, b);
    PrintLCS(b, x, m, n);
    
     return 0;
}

例如ABAB，BABA，ABBA，最长公共子串为AB。

我们可以把该问题定义如下：

给出两个字符串S和T，S的长度为m，T的长度为n，找出S与T的最长公共子串。

假设S = “ABAB”，T=“BABA”，我们可以构造一个如下的矩阵：

对于数组array[m][n]，扩展为array[m+1][n+1]，这样是为了方便初始化，减少循环中对边界的判断。

• if( S[i] == T[j] ) array[i+1][j+1] = array[i][j] + 1
• if( S[i] != T[j] ) array[i+1][j+1] = 0

 1 #include <string.h>
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4
 5 const char * LongestCommonSubstring(const char * strA, const char * strB)
 6 {
 7     char * LCS = NULL;
 8     const size_t LengthA = strlen(strA);
 9     const size_t LengthB = strlen(strB);
10     size_t LCSLength = 0;
11     unsigned int PositionX = 0;
12     unsigned int PositionY = 0;
13
14     int i, j;
15     int Matrix[LengthA + 1][LengthB + 1];;
16
17     for(i = 0; i < LengthA ; ++i)
18     {
19         for(j = 0; j < LengthB ; ++j)
20         {
21             Matrix[i][j] = 0;
22         }
23     }
24
25     for(i = 0; i < LengthA; ++i)
26     {
27         for(j = 0; j < LengthB; ++j)
28         {
29             if(strA[i] == strB[j])
30             {
31                 if((i == 0)||(j == 0))
32                     Matrix[i][j] = 1;
33                 else
34                     Matrix[i][j] = Matrix[i - 1][j - 1] + 1;
35             }
36             if(Matrix[i][j] > LCSLength)
37             {
38                 LCSLength = Matrix[i][j];
39                 PositionX = i;
40                 PositionY = j;
41             }
42         }
43     }
44
45
46     LCS = (char *)malloc(LCSLength + 1);
47     int index = LCSLength - 1;
48     while(index >= 0)
49     {
50         LCS[index] = strA[PositionX];
51         --index;
52         --PositionX;
53     }
54     LCS[LCSLength] = '\0';
55
56     return LCS;
57 }
58 int main(int argc, char **argv)
59 {
60     const char * strA = "abab";
61     const char * strB = "baba";
62     const char * LCS = LongestCommonSubstring(strA, strB);
63     printf("Longest Common Substring is %s\n", LCS);
64     return 0;
65 }