思路：每处理一个数，都可以将这个数插入到已经找到的某个递增子序列（假设包含无限个长度为0的空序列）后，使其长度增加1，处理完毕后，这些长度最大值即为所求。

具有相同长度i+1的递增子序列，若这些序列的最后一个数最小值为min_v[i]，其所在的序列为A，则若某个数能插入到序列A后面，必然能插入到其它相同长度的递增子序列后面，而能否插入到序列A后面，仅由min_v[i]值决定，因而只要维护min_v[i]值就够了。

当前数必然可以插入到某个长度为j（0<=j<=len， len为已找到的最长递增子序列长度）的序列后，使得旧的min_v[j+1]（假设该数组每个值初始化为无穷大）大等于该数，必须更新min_v[j+1]等于该数。如果序列是严格递增的，则只能找到一个这样的j值；如果序列是非严格递增的，可能找到不止一个j，取所有j值最大的即可，因为插入到其它的，min_v[j+1]值不会发生改变。

具体过程：

用min_v[i]保存当前已找到的所有长度为i的递增子序列的最后一个数的最小值。

用len保存当前已找到的最长递增子序列的长度。

对输入src[n]， 显然 min_v[0]=src[0]，这时len=1

从输入数组的第二个数开始，(假设要求所求子序列严格递增)

比较当前值value和长度为len的子序列最后一个值(min_v[len-1])

1若value > min_v[len-1]，则可以将value加在已找到的最长递增子序列后面,得到长度为len+1的更长的递增子序列，即有min_v[len]=value，且len值加1。

2若value <= min_v[len-1]，则可以找到0<=j<=len-1满足： value <= min_v[j]，

   如果j=0，则value可组成长度为1的子序列，

如果j>0，则可以将value加在由min_v[j-1]决定的长度为j的子序列后，得到新的长度为j+1的子序列。

均有min_v[j]=value

如果要输出一个最长递增子序列，可以用一个数组info[i]记录第i+1个src[n]数能得到最长递增子序列的长度（info[i]等于前面要写入value的位置在min_v的下标加1）。再同时扫描一遍这两个数组，从后往前扫描，先找到第一个对应长度为len的数A，然后找到第一个对应长度为len-1且比A小的数，以此类推找出所有的数。

size_t lis(const int src[], size_t sz)
{
  if (src==NULL || sz<1) return 0; 
  //min_v[i]为当前已找到的长度为i+1的所有递增子序列的最后一个值的最小值。
  vector<int> min_v(sz);
  min_v[0]=src[0];
  //len为当前已找到的最长递增子序列的长度
  size_t i,len=1;
  int value;
  for (i=1; i<sz; ++i) {
    value=src[i];
    //假设递增子序列是严格递增    
    if (value>min_v[len-1]) min_v[len++]=value;
    else *lower_bound(&min_v[0],&min_v[len], value)=value;
  }
  return len;
}

看到Milo写的这篇文章，又翻了下书，发现书的代码（P253）有个瑕疵，每个节点值后面都会显示一个空格，如果将间隔字符改为“-”，输出的每行最后都有一个“-”，不能达到要求。不过，只要将 cout << vec[cur] -> data << " ";

这行改为：

if (cur==last-1) cout << vec[cur] -> data << "\n";

else cout << vec[cur] -> data << " ";

即可修正这个问题。

书上的代码用了两个while循环，可以精简为一个。

思路：保存每层的最后一个节点位置（取节点的地址或在容器内的位置），当遍历到该位置时，获取下一层最后一个节点的位置，如果这两个位置相同，说明已经遍历完全部节点，否则开始下一层的遍历。

由于不知道树的节点数，很多情况下，容器采用deque比采用vector性能更佳，因为避免了申请内存后对原数据的拷贝。另外，再考虑到deque的数组下标访问要比采用迭代器访问慢很多，最好采用迭代器来访问内部数据。

代码一
 1
 2struct Node {
 3  Node *left;
 4  Node *right;
 5  int data;
 6};
 7void print_tree_bfs_d(Node* root) {
 8  if (root==NULL) return;
 9  deque<Node*> tree;
10  tree.push_back(root);
11  deque<Node*>::iterator low=tree.begin(),last=tree.begin();
12  Node *node=root;
13  while (1){
14      if (node->left)  tree.push_back(node->left);
15      if (node->right) tree.push_back(node->right);
16    if (low!=last){
17      cout << node->data << " ";
18    }else{
19      cout<< node->data << "\n";
20      if (last==tree.end()-1) break;
21      last=tree.end()-1;
22    }
23    node=*++low;
24  }
25  cout<< "\n";
26}
27
28

上面的代码，保留了树的所有全部节点，稍做修改（比如用一个数组记录每层的最后一个节点的位置），可以查询某层的所有节点。如果不需要保存中间结果，可以修改为：

代码二
 1
 2void print_tree_bfs_dq(Node* root) {
 3  if (root==NULL) return;
 4  deque<Node*> tree;
 5  tree.push_back(root);
 6  Node *node=root, *last=root;
 7  while (1){
 8    node=tree.front();
 9    tree.pop_front();
10      if (node->left)  tree.push_back(node->left);
11      if (node->right) tree.push_back(node->right);
12    if (node!=last){
13      cout << node->data << "-";
14    }else{
15      cout<< node->data << "\n";
16      if (tree.empty()) break;
17      last=tree.back();
18    }
19  }
20  cout<< "\n";
21}
22
23

当然也可以用queue（queue只是对deque的封装）。

对问题2，上面的代码只要做稍微修改，只在遍历到所要求的层才输出，输出后直接返回就可以了。

对一个已经是最优解的排列，记第i个文件的长度为B_i，被访问概率为A_i。如果交换第i个和第i+1个文件，则平均长度一定不会变小，交换后，访问原第i个文件时，要多访问一个原第i+1文件，长度增加了A_i*B_i+1，而访问原第i+1个文件时，要少访问一个原第i个文件，长度减少了A_i+1*B_i，而访问这两个文件之前和之后的文件，长度没有改变，故有：

A_i*B_i+1 - A_i+1*B_i >=0 即A_i/B_i >= A_i+1/B_i+1，

由于i可以任意取，因而A₀/B₀ >= A₁/B₁ >= A₂/B₂ >= … >= A_n-1/B_n-1。也就是说，最优解一定满足P[i]/L[i] 按降序排列，而根据P[i]/L[i]值通过降序排列只能得到唯一确定的排列（只考虑P[i]/L[i]值大小，如果两个文件的P[i]/L[i]值相同，它们位置可以互换而不影响），这个排列必然是最优解。因而，原问题等同于“将P[i]/L[i] 降序排列”。

类似题：

“将一个给定的自然数数组，连接起来得到一个数，求这个数的最大值或最小值”。

问题：

    现在有一班飞机将要起飞，乘客们正准备按机票号码（1, 2, 3, …N）依次排队登机。突然来了一只大猩猩（对，他叫金刚）。他也有飞机票，但是他插队第一个登上了飞机，然后随意地选了一个座位坐下了1。根据社会的和谐程度，其他的乘客有两种反应：

1. 乘客们都义愤填膺，“既然金刚同志不遵守规定，为什么我要遵守？”他们也随意地找位置坐下，并且坚决不让座给其他乘客。

2. 乘客们虽然感到愤怒，但还是以“和谐”为重，如果自己的位置没有被占领，就赶紧坐下，如果自己的位置已经被别人（或者金刚同志）占了，就随机地选择另一个位置坐下，并开始闭目养神，不再挪动位置。

那么，在这两种情况下，第 i 个乘客（除去金刚同志之外）坐到自己原机票位置的概率分别是多少？

对问题一，每个人都是随机选择座位，任意一个人坐在指定座位的概率相同，因而第i个乘客坐在其座位的概率是 1/n。

对问题二，答案和金刚的原来座位编号有关。不妨先去除金刚的座位，将乘客（根据机票号）和剩下的座位，按原大小顺序从1开始重新编号。用F(i，n)表示在新排列中（共有n-1个乘客座位和金刚原来的座位），新的第i个乘客坐在其原来座位的概率，则在n个座位中：

① 金刚若挑自己的座位或选的座位在第i个座位后（共有n-i个座位满足这个条件），则第i个乘客肯定能坐到原来的座位；

② 金刚若挑选的座位在第i个座位前，不妨假设为j，则第j个乘客除非坐到金刚的座位，不然就会抢其他人的座位，因为他的行为和金刚相似，可以将他当做金刚处理。去除前j个座位，剩下的座位和乘客再按原大小排序重新从1开始编号，则先前的第i个乘客，其座位号变为i-j，新的总座位数变为n-j。因而可得公式：

用 G(i, n)表示原排列中，第i个乘客坐到自己座位的概率，假设金刚的座位编号为j。

若 i<j 则   G(i,n)=F(i,n)= (n-i)/(n+1-i)。

若 i>j 则   G(i,n)=F(i-1,n)= (n+1-i)/(n+2-i) 。

类似题：

“约瑟芬环：n个人，编号为0到n-1，围成一圈，从编号为0的开始，从1开始报数，所有报到m的出列，下一个人从1开始继续报数。求最后一个人的编号。”

对根节点a以及先序遍历次序P和中序遍历次序I，查找a在I中的位置，将I分为两部分，左边部分的元素都在a的左子树上，右边的元素都在a的右子树上，因而可以确定a的左子树节点数和a的右子树节点数，再结合P，可以确定a的左孩子和右孩子，以及各个孩子的先序和中序遍历次序。

由于已经知道节点数，可以事先分配好内存，可以按先序遍历次序连续存放节点。

rebuild_tree_1

struct Node {
  Node* left;
  Node* right;
  char data;
};

void rebuild(char preorder[], char inorder[], Node result[], size_t size)
{
  result->data = *preorder;
  result->left=NULL;
  result->right=NULL;
  char *p = inorder;
  size_t left_size=0;
  while (left_size<size && *p++!=*preorder) ++left_size;
  assert (left_size<size);
  size_t right_size = size-1-left_size;
  if (left_size) {
    result->left=result+1;
    rebuild(preorder+1, inorder, result+1, left_size);
  }
  if (right_size) {
    result->right=result+left_size+1;
    rebuild(preorder+left_size+1, inorder+left_size+1,
            result+left_size+1, right_size);
  }
}

上面的代码，栈深度是O(n)，有可能出现栈溢出，可以修改代码，减少一次递归调用，实现栈深度为O(lg n)。

rebuild_tree_2

void rebuild2(char preorder[], char inorder[], Node result[], size_t size)
{
  while (1){
    result->data = *preorder;
    result->left=NULL;
    result->right=NULL;
    char *p = inorder;
    size_t left_size=0;
    while (left_size<size && *p++!=*preorder) ++left_size;
    assert (left_size<size);
    size_t right_size = size-1-left_size;
    if (left_size==0 && right_size==0) break;
    if (left_size<right_size) {
      if (left_size) {
        result->left=result+1;
        rebuild2(preorder+1, inorder, result+1, left_size);
      }
      result->right=result+left_size+1;
      preorder += left_size+1;
      inorder += left_size+1;
      result += left_size+1;
      size = right_size;
    } else {
      if (right_size) {
        result->right=result+left_size+1;
        rebuild2(preorder+left_size+1, inorder+left_size+1,
                 result+left_size+1, right_size);
      }
      if (left_size) {
        result->left=result+1;
        ++preorder;
        ++result;
        size = left_size;
      }
    }
  }
}

书上的代码（P246）：

  NODE* pTemp = new NODE;
  pTemp -> chValue = *pPreOrder;
  pTemp -> pLeft = NULL;
  pTemp -> pRight = NULL;
  
  // 如果节点为空，把当前节点复制到根节点
  if(*pRoot == NULL)
  {
       *pRoot = pTemp;
  }

可能引起内存泄漏（当*pRoot!=NULL，新申请的内存没释放），注释也不对（不是复制节点，而是更改指针指向新建的节点）。另外，频繁的new，极有可能会产生内存碎片。当节点很小时，内存浪费很严重（每new一次都要额外分配空间储存相关信息）。

问题：

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

实际上就是求树的直径。若采用“动态规划方法”思想，会将该问题分解成“具有最大距离两点间的路径是否经过根节点”两个子问题，然后再对这两个子问题求解判断。实际上，不必这么麻烦。距离最远的两点必然在以某个节点A为根的子树上，它们间的路径必然经过该子树的根节点A。因而，以任意一个节点B为根的子树，计算出经过该子树根节点B的最大距离，则所有最大距离的最大值就是所要求的二叉树的最大距离，即“树的直径”。而经过树的根节点的最大距离为：左子树的高度+右子树的高度+2（假设空节点的高度为-1），因而，原问题等同于“计算每个节点的左子树和右子树的高度和，取最大值”。

struct Node {
  Node *left;
  Node *right;
  int data;
};

static int tree_height(Node* root, int& max_distance)
{
  //每碰到一个子节点，高度自增1，可以设空节点高度为-1，
  //避免计算高度时对空节点的判断。
  if (root == NULL) return -1;
  int left_height = tree_height(root->left, max_distance) + 1;
  int right_height = tree_height(root->right, max_distance) + 1;
  int distance = left_height + right_height;
  if (max_distance < distance) max_distance = distance;
  return  left_height > right_height ? left_height : right_height;
}

int tree_diameter(Node* root)
{
  int max_distance = 0;
  tree_height(root, max_distance);
  return max_distance;
}

很经典的可使用动态规划方法解决的题目，和计算两字符串的最长公共子序列相似。

设A_i为字符串A(a₁a₂a₃ … a_m)的前i个字符（即为a₁,a₂,a₃ … a_i）

设B_j为字符串B(b₁b₂b₃ … b_n)的前j个字符（即为b₁,b₂,b₃ … b_j）

设 L(i , j)为使两个字符串和A_i和B_j相等的最小操作次数。

当a_i等于b_j时 显然L(i, j)=L(i-1, j-1)

当a_i不等于b_j时

  若将它们修改为相等，则对两个字符串至少还要操作L(i-1, j-1)次

  若删除a_i或在B_j后添加a_i，则对两个字符串至少还要操作L(i-1, j)次

  若删除b_j或在A_i后添加b_j，则对两个字符串至少还要操作L(i, j-1)次

  此时L(i, j)=min( L(i-1, j-1), L(i-1, j), L(i, j-1) )  + 1

显然，L(i, 0)=i，L(0, j)=j, 再利用上述的递推公式，可以直接计算出L(i, j)值。

为了保持与书中代码一致，下面的函数参数类型是string,而不是char*。

distance_1
 1int string_distance(const string& sa, const string& sb)
 2{
 3  const int sz_a=sa.size()+1;
 4  const int sz_b=sb.size()+1;
 5  int i,j,k,tmp;
 6  vector< vector<int> > arr(sz_a, vector<int>(sz_b) );
 7  for (i=0; i<sz_a; ++i) arr[i][0]=i;
 8  for (j=0; j<sz_b; ++j) arr[0][j]=j;
 9
10  for (i=1; i<sz_a; ++i){
11    for (j=1; j<sz_b; ++j){
12      if( sa[i-1] == sb[j-1]) arr[i][j]=arr[i-1][j-1];
13      else{
14        tmp= arr[i-1][j] > arr[i][j-1] ? arr[i][j-1] : arr[i-1][j];
15        if (tmp>arr[i-1][j-1]) tmp=arr[i-1][j-1];
16        arr[i][j]=tmp+1;
17      }
18    }
19  }
20  return arr[sz_a-1][sz_b-1];
21}
22
23

由于只要求计算两字串的距离，计算时，只用到两列数据，因而可以对代码进一步优化，节省空间。

distance_2
 1int string_distance2(const string& sa, const string& sb)
 2{
 3  const int sz_a=sa.size()+1;
 4  const int sz_b=sb.size()+1;
 5  int sz_max=sz_a;
 6  int sz_min=sz_b;
 7  const char *longer=sa.data();
 8  const char *shorter=sb.data();
 9  if (sz_a < sz_b){
10    sz_max=sz_b;
11    sz_min=sz_a;
12    longer=sb.data();
13    shorter=sa.data();
14  }
15  int i,j,k,tmp;
16  vector<int>  arr(sz_min+1);
17  for (j=0; j<sz_min; ++j) arr[j+1]=j;
18
19  for (i=1; i<sz_max; ++i){
20    arr[0]=i;
21    for (j=1; j<sz_min; ++j){
22      if( longer[i-1] != shorter[j-1]) {
23        tmp= arr[j+1] > arr[j] ? arr[j] : arr[j+1];
24        if (tmp>arr[j-1]) tmp=arr[j-1];
25        arr[j]=tmp+1;  //tmp= min(arr[j-1],arr[j],arr[j+1])
26      }
27    }
28    for(j=sz_min-1; j>=0; --j) arr[j+1]=arr[j];
29  }
30  return arr[sz_min];
31}
32
33

 

上面的代码还可进一步优化，比如通过指针而不是数组名来访问内存。如果内存足够大，可以多申请空间，每次循环，通过修改保存的数据起始位置，避免内存复制。

 

补充：字符串的相似度，就是求编辑距离（edit distance）。

如果直接遍历，则至少要遍历 Cr(n-1,2*n)次（Cr(m,n)为从n个数中取m个数的组合数），为了减少遍历次数，可以先对数组排序。再将所有可能的组合大致分成几组，每个组的数组和也是升序的，通过不断的分组、查找，确定上下边界条件，最终找到所求子数组。

如果数组各个元素均不相同，可以采用下面的算法：

先将数组{a_i}排序，并计算出各元素的总和的一半S(=Sum/2.0)，（对数组的划分时，可以先选中a₀，再取n-1个数）。

假设T_i=sum(a₀+a_i+a_n+2+a_n+3…+a_2n-1) (0<i<=n+1) 则数组{T_i}也是升序。如果T_n+1<=S则T_n+1即为所求，如果存在T_i=S，则T_i即为所求。否则，可以通过二分法找到唯一的i、j使得T_i<S<T_j，（选中a₀和a_j），记录T_i，假设R_i=sum(a₀+a_j+a_i+a_n+3+a_n+4…+a_2n-1) (j<i<=n+2)，则T_j=R_n+2，比较T_i、R_j+1、R_n+2，再对R_i进行类似T_i的分析，找出下一个数。通过不断的分组和查找和判断，最终可以找到所求的n个数。

例如：长度为8的数组：共有35种组合，对每种组合的子数组和，可以划分到几个区间：(下面的0123表示取a₀+a₁+a₂+a₃)

较小值   较大值

0123 —— 0167 （共15个）

0234 —— 0267 （共10个）

0345 —— 0367 （共6个）

0456 —— 0467 （共3个）

0567 —— 0567 （共1个）

(各个较大值不必计算，它们间必然只有一个数不同（并且这个不同的数在升序数列中的位置是连续的），查找S在哪两个较大值之间，可以用S减去相同的数的和，得到的差去指定的范围（不同的那个数的位置范围）进行二分查找。)

由于数组是升序，数组元素各不相同，右边的“较大值”都是升序排列且不会重复。利用数组和的一半S进行查找，如果S在0267和0367之间。只要记录0267，并在适当时候判断该记录是否是所求的，展开0345——0367的6个数，

0345 —— 0347（共3个）

0356 —— 0357（共2个）

0367 —— 0367（共1个）

再重复上述操作。

扩展问题一：

实际上就是求区间的最大重叠次数。书上P57的算法，比较巧妙，但要注意的是：排序时要用到双关键字比较，当两个值相等时，属于时间段开始的一定要排在属于时间段结束的后面，只有这样才能保证结果的正确性。（假设[3, 4）和[4, 5)能在同一个地方举行。书上区间段都是用闭区间，本文采用前闭后开。）

考虑到面试安排的时间一般安排在某个整点、半点或者某刻，可以采用计数的方法，如果都安排在整点，每处理一个区间[a, b)，就对[a, b)间的所有整数计数一次。最后从计数结果中找出最大值即可。时间复杂度为O(n)（准确的讲，应该是O(k*n)，k为区间的最大间隔，k<=24）。如果面试安排时间在某个半点、刻，可以对原来的时间乘以一个整数（比如2或4，这实际上就是桶排序设置桶间隔为0.5或0.25）。

//arr[][0]为面试开始时间，arr[][1]为面试结束时间
int max_places (int arr[][2], size_t sz)
{
  if (arr==NULL || sz<1) return 0; 
  const size_t MAX_HOURS=24;
  int count[MAX_HOURS]={0}; 
  int max=0, j=0; 
  size_t i=0;
  for (i=0; i<sz; ++i)
    for (j=arr[i][0]; j<arr[i][1]; ++j) ++count[j];
  for (i=0; i<MAX_HOURS; ++i)
    if (count[i]>max) max=count[i];
  return max;
}

假设电梯有n层，上楼要消耗能量k₁，下楼要消耗能量k₂，用a[i]表示要在第i层下的人数，S_i为到i层时已经下（包括i层）的总人数，则总人数S=S_n。若用F(i)表示电梯在i层停时要消耗的总能量，则电梯在i+1层停时，有S_i人要多下一层，（S-S_i）人少上一层。则：  

F(i+1) = F(i) + k₂*S_i - k₁*(S-S_i) = F(i) + (k₂+k₁)*S_i – k₁*S ＝ F(i) + G(i)

（定义G(i) = (k₂+k₁)*S_i – k₁*S）

由于S_i是递增的，G(i)也是递增的，当G(i) <= 0，F(i+1) <= F(i)，“求使F(i)最小的i”问题等同于 “求使G(i)＝(k₂+k₁)*S_i – k₁*S  <= 0的最大i值”（所得i值+1即为原问题的解），或 “求使G(i)＝(k₂+k₁)*S_i – k₁*S  >= 0的最小i值”（所得i值即为原问题的解）。注意：等号可取可不取。

对书上原题：k₁=k₂=1，G(i)=2*S_i – S >= 0，可以扫描数组两遍，第一遍算出S，第二遍算出使 2*S_i – S < 0 的最大i值。也可以只扫找一遍，用两个指针分别指向数组的开头和结尾，一个向前移动，一个向后移动，并同时开始计算最前几个数的和S_{2, i}和最后几个数的和S_{j, n}，通过调整两个指针位置，使S_{2, i}<= S_{j, n}总成立并使i尽可能的大，这样扫描完毕，

2*S_{2, i} <= S_{2, i} + S_{i+1, n} = S，且 2*S_{2, i+1} >= S。

（书中解法二的分析与给出的代码不对应，只有证明“使N1 + N2 >= N3成立的第一个i值就是全局最优解”，才能保证给出的代码的正确性。）

程序代码
 1//arr[i] 为在第i层要下的人数，因而i>=2;
 2int lift(int *arr, unsigned sz, int& total)
 3{
 4  assert(sz>=3);
 5  int i, sum=0, count=0;
 6  total=0;
 7  for (i=2; i<sz; i++){
 8    sum += arr[i];
 9    total += arr[i]*i;
10  }
11  total = total - sum * 2;
12  for ( i=2; ; i++){
13    count += arr[i] * 2;
14    if ( count >= sum ) break;
15    total += count - sum;
16  }
17  return i;
18}
19
20
21
22//arr[i] 为在第i层要下的人数，因而i>=2;
23
24int lift2(int *arr, unsigned sz, int& total)
25{
26  assert(sz>=3);
27  int *low=arr+2, *high=arr+sz-1;
28  int sum_a=0, sum_b=0, sum_ta=0, sum_tb=0;
29  while (low <= high){
30    if (sum_a <= sum_b){
31      sum_a += *low++;
32      sum_ta += sum_a;
33    } else{
34      sum_b += *high--;
35      sum_tb += sum_b;
36    }
37  }
38  --low;
39//电梯所停的那层始终被计算了,要扣除
40  if (sum_a >= sum_b){
41    sum_ta -= sum_a;
42  } else{
43    ++low;
44sum_tb -= sum_b;
45  }
46
47  total = sum_ta + sum_tb;
48  return low - arr;
49}
50

当初，刚看到题时，首先想到的是除法计算除数的商和余数（eax和edx）。后来才想到需要动态多维数组时，new一维数组，用它模拟多维数组时，多维数组的下标和实际偏移量的转换，我想很多人学习C或C++时都做过这种事吧。

本来以为题目要求输出将帅在棋盘上的具体位置，如d10、f1，书中的解法给的是相对位置，解决起来更简单。解法一用了一堆令人讨厌的宏，代码实在不美，解法三和解法一本质是一样的，虽然解法三只定义了一个结构体，但结构体内有两个变量，总共有三个变量，不合题意才对。

要将一个变量i拆成两个，可以按其的二进制表示，取出连续几位，比如第0-3位和第4-7位，读变量时，取出变量i相应的几位，存变量时，再更新变量i的对应几位。另外，利用位置的对称性，可以一次输出两个，减少循环次数。

下面的代码和解法一类似，但是一次输出两个，减少了循环次数，并且没有用到除法，如果不考虑C++ IO效率的影响，会比解法二和解法三都高效。

  unsigned i;
  //外层循环变量a使用i的第4-7位，初始值为1，最大值为8。
  //内层循环变量b使用i的第0-3位，初始值为a+1，最大值为9。
  for (i=0x10; i<0x90; i+=0x10)
    for (i= (i&0xF0)|(i>>4); (++i&0xF)<10; )
      if ( ((i&0xF)-(i>>4))!=3 && ((i&0xF)-(i>>4))!=6)
        cout<< "A="<< (i>>4)<< ", B="<< (i&0xF)<< "\n"
            << "A="<< (i&0xF)<< ", B="<< (i>>4)<< "\n";