算法

序列化排列

馨荣家园 — Fri, 25 Mar 2005 15:11:00 GMT

基础知识

假设有M个对象构成的集合，从中取出N个，按照一定顺序排成一列，称为一个该集合的一个(M,N)排列。

乘法原理

如果一个事件可以分成几个互不相关的阶段进行，那么完成这个事件的方法数等于各个阶段方法的乘积。

例如：从A地到D地的旅行可以分成A 到B，B到C和C到D三个阶段进行。从A到B的路径有3条，从B到C有4条，从C到D有5条，那么从A到D的路径总共有3x4x5=60条。

根据乘法原理，计算含有M个元素的集合的(M,N)排列的个数的过程可以这样进行：

第1步：从集合中随机取出一个元素，方法有M种，此时集合中还有M-1个元素。
第2步：从集合中随机取出一个元素，方法有M-1种，此时集合中还有M-2个元素。
......
第k步：从集合中随机取出一个元素，方法有M-k+1种，此时集合中还有M-k个元素。
......
第N步：从集合中随机取出一个元素，方法有M-N+1种，此时集合中还有M-N个元素。

这样，排列的个数共计有Mx(M-1)x...x(M-k)x...x(M-N+1) = M!/(M-N)!

排列计算和序列化原理

在计算机程序设计中，有时有两种排列的需求：

随机给出某个集合的一个(M,N)排列
给出一个集合的所有(M,N)排列

我们知道一个含有M个元素的集合的(M,N)排列的个数为M!/(M-N)!，如果我们能够把这些排列按照某种规则进行排序，这样我们根据一个序号就可以获得一个排列，上面两个问题就可以迎刃而解了。

假设包含M个元素的集合为S，按照某种规则进行排序后，第k个排列记做P(S,M,N,k)，那么上面两个需求的答案分别是：

Print P(S,M,N,random())

   for( i = 0 ; i <= M!/(M-N)! ; i++)
   {
          Print P(S,M,N,i)
   }

问题的关键在于建立这样的规则，使得任意一个位于0和M!/(M-N)!之间的整数都唯一对应一个排列

规则和算法实现

我们回到乘法原理，给出一个(M,N)排列的过程可以分解成N步，其中第k步的可选方法为M-k+1。

考虑这样的一个映射关系{i(1),i(2),...,i(N)} -> I

其中：

        1≤i(k)≤ M-k +1
        1≤  I ≤ M!/(M-N)!
令：
       p(k) = k! / (M-N)!
       I = p(M-N) x i(N)+ p(M-N+1) x i(N-1) + ... + p(M-N+1) x i(1)

可以看出，当{i(k)}取遍所有值的时候，I恰好取遍它所有可能的值，两者是一一对应的关系。

这样，如果给出一个序号I，我们就能计算出第k步应该取第几个元素。由于p(k+1) = (k+1) * p(k),我们可以看出：

i(N) = I % p(M-N+1)
i(N-1) = (I - i(N)*p(M-N)) % P(M-N+2)
i(N-2) = (I - i(N)*p(M-N) - i(N-1) * p(M-N+1) ) % p(M-2)
...

因此，计算{i(k)}的算法可以为：

k = N,p = M-N+1
如果k = 0 结束，否则，跳到下一步
i[k] = I % p
k = k-1, p = p * (M - k +1)
转到第2步

当{i(k)}计算出来以后，我们就可以根据这个数组和乘法原理进行计算，算法如下：

      输入：原始数组in[M]
      输出：一个排列out[N]

计算{i(k)}数组
k = 1，拷贝in[M]到bak[M]做备份
如果k > N ，转8
从in中选择第i[k]个元素，放到out[k]中
把in中第i[k]个元素后面所有元素朝前移动一位
k = k+1
转第3步
把bak[M]中的元素拷贝回in[M]

一个分数类CFraction

阿荣陋室 — Tue, 18 May 2004 14:18:00 GMT

头文件

// Fraction.h: interface for the CFraction class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_FRACTION_H__5E2C2908_42A9_4372_9903_08BC892255CC__INCLUDED_)
#define AFX_FRACTION_H__5E2C2908_42A9_4372_9903_08BC892255CC__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
unsigned int GCD(int a,int b);
class CFraction  
{
 int  m_nNumerator;
 int  m_nDenominator;
 bool m_bInfinity;
 //constructor and desctructor
public:
 CFraction( const CFraction & fraction);
 CFraction(int nNumerator=0,int nDenominator=1,bool bInfinity=false);
 virtual ~CFraction();
 CFraction & operator= (const CFraction & fraction);
 //operators
public:
 CFraction operator+( const CFraction & fraction)const;
 CFraction operator-( const CFraction & fraction)const;
 CFraction operator*( const CFraction & fraction)const;
 CFraction operator/( const CFraction & fraction)const;
 CFraction operator-()const;
 CFraction& operator+=( const CFraction & fraction);
 CFraction& operator-=( const CFraction & fraction);
 CFraction& operator*=( const CFraction & fraction);
 CFraction& operator/=( const CFraction & fraction);
public:
 bool operator >(const CFraction & fraction)const;
 bool operator <(const CFraction & fraction)const;
 bool operator >=(const CFraction & fraction)const;
 bool operator <=(const CFraction & fraction)const;
 bool operator ==(const CFraction & fraction)const;
 bool operator !=(const CFraction & fraction)const;
};
bool operator >(int nNumber ,const CFraction & fraction);
bool operator <(int nNumber ,const CFraction & fraction);
bool operator >=(int nNumber ,const CFraction & fraction);
bool operator <=(int nNumber ,const CFraction & fraction);
bool operator ==(int nNumber ,const CFraction & fraction);
bool operator !=(int nNumber ,const CFraction & fraction);
CFraction operator +(int nNumber ,const CFraction & fraction);
CFraction operator -(int nNumber ,const CFraction & fraction);
CFraction operator *(int nNumber ,const CFraction & fraction);
CFraction operator /(int nNumber ,const CFraction & fraction);
#endif // !defined(AFX_FRACTION_H__5E2C2908_42A9_4372_9903_08BC892255CC__INCLUDED_)

cpp文件

// Fraction.cpp: implementation of the CFraction class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Calc24.h"
#include "Fraction.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
unsigned int GCD(int a,int b)
{
 unsigned int ua,ub,uc;
 ua = abs(a);
 ub = abs(b);
 if(ub > ua)
 {
  uc = ua;
  ua = ub;
  ub = uc;
 }
 if(ub == 0)
 {
  return ua;
 }
 for(uc = ua % ub ; uc != 0 ; uc = ua % ub)
 {
  ua = ub;
  ub = uc;
 }
 return ub;
}
CFraction::CFraction(int nNumerator,int nDenominator,bool bInfinity)
{
 m_nNumerator = nNumerator;
 m_nDenominator = nDenominator;
 if(m_nDenominator <0)
 {
  m_nDenominator = -m_nDenominator;
  m_nNumerator   = -m_nNumerator;
 }
 m_bInfinity     = bInfinity;
}
CFraction::~CFraction()
{
}
CFraction::CFraction(const CFraction &fraction)
{
 m_nNumerator = fraction.m_nNumerator;
 m_nDenominator = fraction.m_nDenominator;
 m_bInfinity     = fraction.m_bInfinity; 
}
CFraction & CFraction::operator = (const CFraction & fraction)
{
 if(&fraction != this)
 {
  m_nNumerator = fraction.m_nNumerator;
  m_nDenominator = fraction.m_nDenominator;
  m_bInfinity     = fraction.m_bInfinity; 
 }
 return *this;
}
CFraction CFraction::operator +(const CFraction &fraction)const
{
 if(m_bInfinity)return *this;
 if(fraction.m_bInfinity )return fraction;
 int Denominator = m_nDenominator * fraction.m_nDenominator ;
 int Numerator   = m_nNumerator * fraction.m_nDenominator 
  + m_nDenominator * fraction.m_nNumerator;
 unsigned int gcd = GCD(Denominator,Numerator);
 return CFraction(Numerator / gcd, Denominator / gcd);
}
CFraction CFraction::operator -(const CFraction &fraction)const
{
 if(m_bInfinity)return *this;
 if(fraction.m_bInfinity )return -fraction;
 int Denominator = m_nDenominator * fraction.m_nDenominator ;
 int Numerator   = m_nNumerator * fraction.m_nDenominator 
  - m_nDenominator * fraction.m_nNumerator;
 unsigned int gcd = GCD(Denominator,Numerator);
 return CFraction(Numerator / gcd, Denominator / gcd);
}
CFraction CFraction::operator *(const CFraction &fraction)const
{
 if(m_bInfinity)
 {
  if(fraction.m_nNumerator < 0)
  {
   return - *this;
  }else{
   return *this;
  }
 }
 if(fraction.m_bInfinity )
 {
  if(m_nNumerator < 0)
  {
   return -fraction;
  }else{
   return fraction;
  }
 }
 int Denominator = m_nDenominator * fraction.m_nDenominator ;
 int Numerator   = m_nNumerator * fraction.m_nNumerator;
 unsigned int gcd = GCD(Denominator,Numerator);
 return CFraction(Numerator / gcd, Denominator / gcd);
}
CFraction CFraction::operator /(const CFraction &fraction)const
{
 if(m_bInfinity)
 {
  if(fraction.m_nNumerator < 0)
  {
   return - *this;
  }else{
   return *this;
  }
 }
 if(fraction.m_bInfinity )
 {
  return 0;
 }
 if(fraction.m_nNumerator ==0)
 {
  if(m_nNumerator >= 0)
  {
   return CFraction(1,1,true);
  }else{
   return CFraction(-1,1,true);
  }
 }
 int nNumerator = m_nNumerator * fraction.m_nDenominator;
 int nDenominator = m_nDenominator * fraction.m_nNumerator;
 if(nDenominator < 0 )
 {
  nNumerator  = -nNumerator;
  nDenominator = -nDenominator ;
 }
 unsigned int gcd = GCD(nNumerator,nDenominator);
 return CFraction(nNumerator /gcd,nDenominator /gcd);
}
CFraction CFraction::operator -()const
{
 return CFraction(-m_nNumerator,m_nDenominator,m_bInfinity);
}
CFraction& CFraction::operator +=(const CFraction & fraction)
{
 return *this = *this + fraction;
}
CFraction& CFraction::operator -=(const CFraction & fraction)
{
 return *this = *this - fraction;
}
CFraction& CFraction::operator *=(const CFraction & fraction)
{
 return *this = *this * fraction;
}
CFraction& CFraction::operator /=(const CFraction & fraction)
{
 return *this = *this / fraction;
}
CFraction operator +(int nNumber,const CFraction & fraction)
{
 return CFraction(nNumber,1) + fraction;
}
CFraction operator -(int nNumber,const CFraction & fraction)
{
 return CFraction(nNumber,1) - fraction;
}
CFraction operator *(int nNumber,const CFraction & fraction)
{
 return CFraction(nNumber,1) * fraction;
}
CFraction operator /(int nNumber,const CFraction & fraction)
{
 return CFraction(nNumber,1) / fraction;
}
bool CFraction::operator != (const CFraction & fraction)const
{
 if(m_nNumerator != fraction.m_nNumerator )return false;
 if(m_nDenominator != fraction.m_nDenominator)return false;
 if(m_bInfinity != fraction.m_bInfinity )return false;
 return true;
}
bool CFraction::operator ==(const CFraction & fraction)const
{
 return !(*this != fraction);
}

bool CFraction::operator >(const CFraction & fraction)const
{
 if(m_bInfinity)return m_nNumerator >0;
 if(fraction.m_bInfinity )return fraction.m_nNumerator < 0 ;
 return m_nNumerator * fraction.m_nDenominator > 
  m_nDenominator * fraction.m_nNumerator;
}
bool CFraction::operator >=(const CFraction & fraction)const
{
 if(m_bInfinity)return m_nNumerator >0;
 if(fraction.m_bInfinity )return fraction.m_nNumerator < 0 ;
 return m_nNumerator * fraction.m_nDenominator >= 
  m_nDenominator * fraction.m_nNumerator;
}
bool CFraction::operator <(const CFraction & fraction)const
{
 return !(*this >= fraction);
}
bool CFraction::operator <=(const CFraction & fraction)const
{
 return !(*this > fraction);
}
bool operator >(int nNumber ,const CFraction & fraction)
{
 return CFraction(nNumber,1) > fraction;
}
bool operator <(int nNumber ,const CFraction & fraction)
{
 return CFraction(nNumber,1) < fraction;
}
bool operator >=(int nNumber ,const CFraction & fraction)
{
 return CFraction(nNumber,1) >= fraction;
}
bool operator <=(int nNumber ,const CFraction & fraction)
{
 return CFraction(nNumber,1) <= fraction;
}
bool operator ==(int nNumber ,const CFraction & fraction)
{
 return CFraction(nNumber,1) == fraction;
}
bool operator !=(int nNumber ,const CFraction & fraction)
{
 return CFraction(nNumber,1) != fraction;
}

洗牌问题：随机获得一个(m,n)排列的算法

Blog Author — Mon, 17 May 2004 21:49:00 GMT

(m,n)排列问题：在m个对象中，随机取出n个(n≤m)对象，按照一个随机的顺序排成一列，称为一个排列。(m,n)排列问题包含两个方面含义，一是这种排列的个数有多少(记做P(m,n))，二是每个排列究竟是怎样构成的。其中第一个问题非常简单，有现成的公式：P(m,n) = m! /(m-n)! / n!。至于第二个问题在程序设计中遇到的比较多，一般以两种形式出现：随机排列和罗列排列。随机排列就是在所有可能的排列中选择一种，罗列排列则是要求列出所有的排列。

本文详细描述了随机排列问题，至于罗列排列问题将在随后的排列线性化文章中说明。

最早遇到随机排列问题是在编写扑克牌游戏遇到的。在扑克牌游戏中，每次游戏开始都要求把54张牌重新排列一下，称为洗牌。其实洗牌的过程就是在(54,54)排列中随机抽取一个排列的过程，因此我把这个随机排列算法称为洗牌算法。

考虑一个(m,n)问题，从m个对象中取出n个对象并排成一列可以通过如下n步实现：

第一步：从m个对象中取出一个对象，作为排列的第一个对象
第k步：从剩下的m-k+1个对象中取出一个对象，作为第k个对象
从m-n+1个对象中取出一个对象作为第n个对象

这样每步取出一个对象作为排列的一个对象，就可以构建一个排列。如果每步都采用一种随机的算法取出对象，就可以实现随机排列的目的。

根据上面原理，可以构建算法如下：

算法输入：in(包含m个对象的对象数组)，out(含n个元素的输出数组），m,n

k = 1,初始化随机数发生器
divisor = m - k+1,index = rand() % divisor+1
从in中取出第index个元素，放入数组out的第k项中
把in中index后的元素向前移动一位
k = k +1
如果k ≤ n，转2步
算法结束

按照上述方法，就可以计算一个随机排列。需要注意的是，这种计算方法中，数组下标从一开始。in数组中的对象顺序是无关的。

数的进制及进制转换

Blog Author — Wed, 28 Apr 2004 05:23:00 GMT

考虑一个10进制数123，数字1、2、3在这个数中的重要性是不一样的，3代表的是10⁰的3倍，2代表10¹的2倍，而1代表的则是10²的1倍。数学上把10⁰，10¹和10²称为对应数位上的权重(简称权），分别表示了对应位上的数字对整个数值的“贡献”。对于10进制数来说，各位权从小到大分别是10⁰、10¹、10²……，都是10的各次幂。对于各位上的数字，我们称为某权的系数，简称系数。

其他进制数也存在同样的问题，例如2进制数各位权重分别是2的各次幂，8进制数是8的各次幂等等。

需要说明的是，各种进制数都是人们为了理解数而进行的一种表述，在计算机计算过程中，是不存在进制这种概念的，对于C语言表示数的三种形式：0x12（16进制）、18（10进制）和022(8进制），在内存中都是一样的。

如果已经知道一个数k，在某种进制w条件下，计算各位的系数一般采用除余法，基本算法如下：

首先估计这个数的最大位数N
n = N,divisor = w^n-1
b(n) = k / divisor, k = k % divisor,divisor = divisor /w,n --
如果n ==0算法结束，否则转3

例如对于C语言中的unsigned char 类型，最大可能为3位8进制数，如果已经知道一个数n=252，计算8进制的过程如下：

N =3
n = N,divisor = 8^n-1= 64
b(3) = 252 / 64 = 3, k = k % 64 =60,divisor = divisor /8 = 8,n -- = 2
b(2) = 60/8 = 7,k = k %8 =4,divisor = 8/8 =1,n = 1
b(1) = k / 1= 4 ,k=k %1 =0,divisor = 1/8,n = 0
n == 0算法结束

计算结果252就是8进制数0374

如果不按照上面的幂次方式规定各位数的权，也可以定义一些特殊的进制数。例如，我们按照从小到大顺序分别规定各位的权重分别为w(n)，n=1,2,3....，（注意，必须满足w(n) | w(m),n<= m，也就是低位权必须能整除高位权）已知一个数计算各位系数也一样可以采用修正后的除余法。修正后的除余法为：

首先估计这个数的最大位数N
n = N,divisor = w(n)
b(n) = k / divisor, k = k % divisor,n--,divisor = w(n)
如果n ==0算法结束，否则转3

可见，当w(n) = bⁿ时，这个修正的除余法就和开始的除余法等价了

如果需要在不同进制间转换，最简单的方法是先把一种不容易进行四则运算的进制转换成容易进行四则运算的10进制，然后利用除余法转换成给定的进制。例如对于022，很容易利用权的定义计算出他的10进制形式为2 * 8¹ + 2 * 8⁰ = 18，转换成16进制利用除余法可以得到为0x12。