C++博客-天下-随笔分类-算法

判断手指按下

天下 — Tue, 06 Aug 2013 10:47:00 GMT

void BlockVar(const UINT8 *pImg, UINT32 *p_var, UINT32 *p_avr)
{
    UINT8 i;
    UINT8 j;
    UINT8 *p;
    UINT32 AverTemp=0;
    UINT32 VarTemp=0;

    p=(UINT8 *)pImg;
    //block 32*32
    for(i=0;i<32;i++)
    {
        p=(UINT8*)(pImg+256*i);
        for(j=0;j<32;j++)
        {
            AverTemp+=*p;
            p++;
        }
    }
    AverTemp>>=10;
    *p_avr=AverTemp;

    for(i=0;i<32;i++)
    {
        p=(UINT8 *)(pImg+256*i);
        for(j=0;j<32;j++)
        {
            VarTemp+=SQ((*p)-AverTemp);
            p++;
        }
    }
    *p_var=(VarTemp>>10);

}

bool FpIsPressFinger(const UINT8 *pImg)
{
    UINT32  AverTemp=0;
    UINT32  VarTemp=0;
    UINT32  Aver_Var_Val = 0;

    UINT32  VarTemps    =0;
    UINT32  AverTemps = 0;

    //BLOCK 1
    BlockVar(pImg+(85+6)*256+256/3+11,&VarTemp,&AverTemp);
    AverTemps+=AverTemp;
    VarTemps+=VarTemp;

    //BLOCK 2
    BlockVar(pImg+(85+6)*256+256/3+11+32+10,&VarTemp,&AverTemp);
    AverTemps+=AverTemp;
    VarTemps+=VarTemp;

    //BLOCK 3
    BlockVar(pImg+(85+7+32+6)*256+256/3+11,&VarTemp,&AverTemp);
    AverTemps+=AverTemp;
    VarTemps+=VarTemp;

    //BLOCK 4
    BlockVar(pImg+(85+7+32+6)*256+256/3+11+32+10,&VarTemp,&AverTemp);
    AverTemps+=AverTemp;
    VarTemps+=VarTemp;

    AverTemps>>=2;
    VarTemps>>=2;
    pr_debug("VarTemps=%u,AverTemps=%u \r\n",VarTemps,AverTemps);
    return (bool)(( AverTemps<=185 ) && (VarTemps >=70));
}

天下 2013-08-06 18:47 发表评论

计算机视觉、机器学习相关领域论文和源代码大集合(转)

天下 — Fri, 26 Apr 2013 00:42:00 GMT

摘要: 注：下面有project网站的大部分都有paper和相应的code。Code一般是C/C++或者Matlab代码。最近一次更新：2013-3-17 一、特征提取Feature Extraction： · SIFT [1] [Demo ... 阅读全文

天下 2013-04-26 08:42 发表评论

[转]七种排序算法的简单分析与实现

天下 — Wed, 27 Mar 2013 10:23:00 GMT

/*
转自:
http://www.cppblog.com/chenjt3533/archive/2013/03/25/198815.html
*/
#include "stdafx.h"

/*
             --- 冒泡排序 ---
自下而上的两两比较，小泡排在大泡前，一趟冒出一个最小泡。
*/

void BubbleSort(int nArray[], int nLength)
{
    int i = nLength - 1;
    int j = 0;
    int temp = 0;

    for (i = nLength - 1; i > 0; --i)
    {
        for (j = i - 1; j >= 0; --j)
        {
            if (nArray[j] > nArray[j + 1])
            {
                temp = nArray[j + 1];
                nArray[j + 1] = nArray[j];
                nArray[j] = temp;
            }
        }
    }
}

/*
                    --- 选择排序 ---
自下而上的两两比较，记录最小数的下标，将最上面的数与最小数交换。
*/

void SelectSort(int nArray[], int nLength)
{
    int tempIndex = 0;
    int tempValue = 0;

    for (int i = 0; i < nLength; ++i)
    {
        tempIndex = i;
        for (int j = i + 1; j < nLength; ++j)
        {
            if (nArray[tempIndex] > nArray[j])
            {
                tempIndex = j;
            }
        }
        tempValue = nArray[i];
        nArray[i] = nArray[tempIndex];
        nArray[tempIndex] = tempValue;
    }
}

/*
                    --- 插入排序 ---
将数据插入到已排序的序列中，边找合适的位置，边移动数据，找到合适位置插入数据。
*/

void InsertSort(int nArray[], int nLength)
{
    for (int i = 1; i < nLength; ++i)
    {
        int temp = nArray[i];
        int j = i;
        for (; j > 0 && nArray[j - 1] > temp; --j)
        {
            nArray[j] = nArray[j - 1];
        }
        nArray[j] = temp;
    }
}

/*
                    --- 快速排序 ---
是对冒泡排序的改进。
1．先从数列中取出一个数作为基准数;
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边;
3．再对左右区间重复第二步，直到各区间只有一个数.

分区过程可以形象的描述为“挖坑填数”：
1．将基准数nBase挖出形成第一个坑nArray[nLow];
2．nHigh--由后向前找比nBase小的数，找到后挖出此数填前一个坑nArray[nLow]中;
3．nLow++由前向后找比nBase大的数，找到后也挖出此数填到前一个坑nArray[nHigh]中;
4．再重复执行2，3二步，直到nLow==nHigh，将基准数nBase填入nArray[nLow]中.
*/

int AdjustArray(int nArray[], int nLow, int nHigh)
{
    int nBase = nArray[nLow];

    while(nLow < nHigh)
    {
        while(nLow < nHigh && nBase <= nArray[nHigh])
            --nHigh;
        if (nLow < nHigh)
        {
            nArray[nLow++] = nArray[nHigh];
        }

        while(nLow < nHigh && nBase > nArray[nLow])
            ++nLow;
        if (nLow < nHigh)
        {
            nArray[nHigh--] = nArray[nLow];
        }
    }
    nArray[nLow] = nBase;
    return nLow;
}

void QuickSort(int nArray[], int nLow, int nHigh)
{
    if (nLow < nHigh)
    {
        int nMid = AdjustArray(nArray, nLow, nHigh);
        QuickSort(nArray, 0, nMid - 1);
        QuickSort(nArray, nMid + 1, nHigh);
    }
}

/*
                    --- 希尔排序 ---
是对直接插入排序算法的改进，又称缩小增量排序。
1、将数组进行分组，下标相差d的为一组；
2、对每组中全部元素进行排序；
3、然后再用一个较小的增量d, 重复1、2，直到d为1时，排序完成。

一般增量取值为上一次的一半，d = 1/2 d，第一次取值为数组长度的一半。
*/

void ShellSort(int nArray[], int nLength)
{
    for (int nDifference = nLength / 2; nDifference > 0; nDifference = nDifference / 2)
    {
        for (int i = nDifference; i < nLength; ++i)
        {
            int temp = nArray[i];
            int j = i;
            for (; j > 0 && nArray[j - 1] > temp; --j)
            {
                nArray[j] = nArray[j - 1];
            }
            nArray[j] = temp;
        }
    }
}

/*
                    --- 归并排序 ---
是将两个已经排序的序列合并成一个有序序列。
1、待排序序列分为两个子序列;
2、每个子序列重复步骤1，直到每个子序列只有一个元素;
3、按大小顺序合并两个子序列;
4、重复步骤3，直到合并为一个整体有序序列，排序完成。
*/

void Merge(int nArray[], int nLow, int nHigh)
{
    int nFirst = nLow;
    int nMid = (nLow + nHigh) / 2;
    int nSecond = nMid + 1;
    int* p = (int*)malloc(sizeof(int) * (nHigh - nLow + 1));
    int nIndex = 0;

    while(nFirst <= nMid && nSecond <= nHigh)
    {
        if (nArray[nFirst] > nArray[nSecond])
        {
            p[nIndex] = nArray[nSecond++];
        }
        else
        {
            p[nIndex] = nArray[nFirst++];
        }
        ++nIndex;
    }

    while (nFirst <= nMid)
    {
        p[nIndex++] = nArray[nFirst++];
    }

    while (nSecond <= nHigh)
    {
        p[nIndex++] = nArray[nSecond++];
    }

    for (int i = 0; i <= nIndex && nLow <= nHigh;)
    {
        nArray[nLow++] = p[i++];
    }
    free(p);
}

void MergeSort(int nArray[], int nLow, int nHigh)
{
    if (nLow < nHigh)
    {
        int nMid = (nLow + nHigh) / 2;
        MergeSort(nArray, nLow, nMid);
        MergeSort(nArray, nMid+1, nHigh);
        Merge(nArray, nLow, nHigh);
    }
}

/*
                    --- 堆排序 ---
1、先将数组转换为完全二叉树；
2、调整二叉树形如大顶堆；
3、将根结点与最后一个叶子结点互换，即将最大元素放在数组的末尾，数组的长度减一；
4、再重复2、3，直到数组长度为1，排序完成。
*/

void AdjustHeap(int nArray[], int nLength, int nIndex)
{
    int nLeft = nIndex * 2 + 1;
    int nRight = nIndex * 2 + 2;
    int nParent = nIndex;

    while(nLeft < nLength && nRight < nLength)
    {
        int nBigIndex = (nArray[nLeft] > nArray[nRight] ? nLeft : nRight);
        if (nArray[nParent] < nArray[nBigIndex])
        {
            int temp = nArray[nParent];
            nArray[nParent] = nArray[nBigIndex];
            nArray[nBigIndex] = temp;

            nLeft = nBigIndex * 2 + 1;
            nRight = nBigIndex * 2 + 2;
        }
        break;
    }
}

void BuildHeap(int nArray[], int nLength)
{
    for (int i = nLength / 2 - 1; i >= 0; --i)
    {
        AdjustHeap(nArray, nLength, i);
    }
}

void HeapSort(int nArray[], int nLength)
{
    BuildHeap(nArray, nLength);

    while(nLength > 1)
    {
        int temp = nArray[0];
        nArray[0] = nArray[nLength - 1];
        nArray[nLength - 1] = temp;
        AdjustHeap(nArray, --nLength, 0);
    }
}

void Test_Sort()
{
    int nArray[5] = {1,3,2,5,4};
    BubbleSort(nArray, 5);
    //SelectSort(nArray, 5);
    //InsertSort(nArray, 5);
    //QuickSort(nArray, 0, 4);
    //ShellSort(nArray, 5);
    //MergeSort(nArray, 0, 4);
    //HeapSort(nArray, 5);
    for (int n = 0; n < 5; ++n)
    {
        std::cout << nArray[n] << " ";
    }
    std::cout << std::endl;
}
int main()
{
    Test_Sort();
    system("pause");
    return 0;
}

天下 2013-03-27 18:23 发表评论

动态规划算法（5）：背包最大价值问题

天下 — Wed, 27 Mar 2013 01:53:00 GMT

#include "stdafx.h"

int c[20][100];/*对应每种情况的最大价值*/

//int m 背包容量
//int n 背包个数
int knapsack(int m,int n)
{
    int i,j,w[20],p[20];
    for(i=1;i    {
        printf("请输入第(%d)个物品重量,价值:\n",i);
        scanf("%d,%d",&w[i],&p[i]);
    }
    for(i=0;i<10;i++)
        for(j=0;j<100;j++)
            c[i][j]=0;/*初始化数组*/

    for(i=1;i    {
        for(j=1;j        {
            if(w[i]<=j) /*如果当前物品的容量小于背包容量*/
            {
                if(p[i]+c[i-1][j-w[i]]>c[i-1][j])
                {
                    //如果本物品的价值加上背包剩下的空间能放的物品的价值
                    //大于上一次选择的最佳方案,
                    //则更新c[i][j]
                    c[i][j]=p[i]+c[i-1][j-w[i]];
                }
                else
                {
                    c[i][j]=c[i-1][j];
                }
            }
            else c[i][j]=c[i-1][j];
        }
    }
    return(c[n][m]);
}
int main()
{
    //int m 背包容量
    //int n 背包个数
    int m,n;


    printf("请输入背包最大承重,物品个数:\n");
    scanf("%d,%d",&m,&n);

    printf("最大价值:%d \r\n",knapsack(m,n));

    int i,j;

    m += 3;
    n += 3;
    for(j=0;j    {
        printf("%02d  ",j);
    }
    printf("\r\n");
    for(j=0;j    {
        printf("----",j);
    }
    printf("\r\n");
    for(i=0;i    {
        for(j=0;j        {
            printf("%02d  ",c[i][j]);
            if(j==m-1) printf("\n");
        }
    }
    system("pause");

    return 0;

}

天下 2013-03-27 09:53 发表评论

crc32 For Linux 存档

天下 — Mon, 25 Mar 2013 03:49:00 GMT

//编译:/usr/local/arm/4.3.1/bin/arm-linux-g++
#include
#include
#include
#include

typedef unsigned int DWORD;
typedef unsigned char BYTE;

unsigned int GetTickCount(void)
{
    struct timeval tv;
    if (gettimeofday(&tv, NULL)!=0)
        return 0;
    return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}

void PrintCrcTable()
{
    //Poly = 0xedb88320 WinRAR Poly
    DWORD Val;
    for (DWORD i = 0; i < 256; i++)
    {
        Val = i;
        for (DWORD k = 0; k < 8; k++)
        {
            if (Val & 1)
                Val = 0xedb88320L ^ (Val >> 1);
            else
                Val = Val >> 1;
        }
        printf ("0x%08x, ", Val);
        if (0 == ((i+1)%6))
            printf ("\n");
    }
}

const DWORD Crc32Table[] =
{
    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};

DWORD GenerateCrc32(DWORD PartialCrc,BYTE* Buffer,DWORD Length)
{
    DWORD crc;
    DWORD i;

    // Generate the CRC32 checksum.
    crc = PartialCrc ^ 0xffffffffL;

    for (i = 0; i < Length; i++)
    {
        crc = Crc32Table[(crc ^ Buffer[i]) & 0xff] ^ (crc >> 8);
    }

    return (crc ^ 0xffffffffL);
}

//测试程序
int main(int argc,char* argv[])
{
    char* szFileName = NULL;
    if (argc<2)
    {
        printf("Usage:%s  \r\n",argv[0]);
        return -1;
    }
    szFileName = argv[1];
    FILE *fp = fopen(szFileName,"rb");
    if(NULL == fp)
    {
        printf("Open %s error:%d \r\n",szFileName);
        return 0;
    }

    DWORD dwStartTime = GetTickCount();
    printf("dwStartTime:%u \r\n",dwStartTime);
    DWORD crc32 = 0;
    BYTE c = 0;
    while(1 == fread(&c,1,1,fp))
        crc32 = GenerateCrc32(crc32,&c,1);

    fclose(fp);
    DWORD dwEndTime = GetTickCount();
    printf("dwEndTime:%u \r\n",dwEndTime);
    printf("calc_crc32(%s) = 0x%08X ,elapsed %u (ms) \r\n",szFileName,crc32,dwEndTime - dwStartTime);
    return 0;
}

天下 2013-03-25 11:49 发表评论

动态规划算法（4）：lcs递归算法python的实现

天下 — Thu, 21 Mar 2013 11:01:00 GMT

#coding:gbk
import os,sys
def lcs(short, long):
    m = len(short)
    n = len(long)
    if (m <= 0 or n <= 0):
        return "";
    if m>n:
        short,long = long,short

    if short in long:
        return short
    t1 = lcs(short[1:],long)
    t2 = lcs(short[0:-1],long)
    if t1>t2:
        return t1
    else:
        return t2

def main():
    if len(sys.argv)<3:
        print "使用:lcs <字符串1> <字符串2>"
        return
    a = lcs(sys.argv[1],sys.argv[2])
    print "最大公共子串长度:%d"%len(a)
    print "最大公共子串:"+a
if __name__ == '__main__':
    main()

天下 2013-03-21 19:01 发表评论

动态规划算法（3）：菲波那契数列

天下 — Thu, 21 Mar 2013 08:25:00 GMT

原创作品，允许转载，转载时请务必以超链接形式标明文章

#include "stdafx.h"
using namespace std;

/*
algorithm
在数字上递归表示的问题也可以表示成递归算法，在许多情形下对朴素的穷举搜索得到显著的性能改进。
任何数字递推公式都可以直接翻译成递归算法，但是基本现实是编译器常常不能正确地对待递归算法，结果产生低效的程序，当怀疑可能是这种情况时，
必须再给编译器提供一些帮助，将递归算法重新写成非递归算法，让后者把这些子问题的答案系统地记录在一个表（table）内，
利用这种方法的一种技巧称为动态规划（dynamic programming）。

菲波那契数列指的是这样一个数列：
1，1，2，3，5，8，13，21……
这个数列从第二项开始，每一项都等于前两项之和
*/

unsigned int fib1(unsigned int n)
{
    if (n<=1)
    {
        return 1;
    }
    else
    {
        return fib1(n-1) + fib1(n-2);
    }
}

unsigned int fib2(unsigned int n)
{
    if (n<=1)
    {
        return 1;
    }
    unsigned int fib_n        = 1;
    unsigned int fib_n_1    = 1;
    unsigned int fib_n_2    = 1;

    for (int i=2;i<=n;i++)
    {
        fib_n      = fib_n_1 + fib_n_2;
        fib_n_2   = fib_n_1;
        fib_n_1   = fib_n;
    }
    return fib_n;
}

int main()
{
    for (int i=1;i<11;i++)
    {
        printf("fib1(%u)=%u \r\n",i,fib1(i));
        printf("fib2(%u)=%u \r\n",i,fib2(i));
    }
    system("pause");
    return 0;
}

天下 2013-03-21 16:25 发表评论

回溯算法(2):八皇后问题（非递归）

天下 — Wed, 20 Mar 2013 10:09:00 GMT

#include "stdafx.h"
using namespace std;

const  int n = 9;
static int matrix[n];

bool place(int row,int col)
{
    for (int prev = 1; prev < row; prev++)
        if (matrix[prev] == col || labs(col-matrix[prev]) == labs(row-prev)) return false;
    return true;
}

void display()  //打印每个皇后的列的位置
{
    int i;
    cout<<"[";
    for (i = 1; i <=7; i++)
        cout<<matrix[i]<<",";
    cout<<matrix[i]<<"]"<<endl;
}

void queen(int row)
{
    int count = 0;
    bool ret = false;
    int  col = 0;
    memset(matrix,0,sizeof(matrix));
    while (row <= 8)
    {
        ret = false;
        for (col = matrix[row] + 1; col <= 8; col++)
        {
            ret = place(row,col);
            if (ret)     //如果(x,y)位置能否摆放皇后
            {
                matrix[row] = col;  //将第i行的皇后摆放在第j列
                break;      //跳出这一层循环，开始摆放下一行的皇后
            }
        }
        if (!ret)  //如果循环完这一行，每个位置都冲突
        {
            matrix[row] = 0; //将这一行的皇后位置重置为0;
            row--;       //返回到上一行
            if(row==0)break; //如果已经返回到了第0行，说明所有情况都找完了
        }
        else
        {
            if (row == 8)  //如果找到了第8行，说明有满足条件的结果
            {
                display();  //输出结果
                count++;
            }
            else row++;
        }
    }
    cout<<count<<endl;
}
int main()
{
    queen(1);
    system("pause");
    return 0;
}

天下 2013-03-20 18:09 发表评论

回溯算法(1):八皇后问题

天下 — Wed, 20 Mar 2013 07:37:00 GMT

#include "stdafx.h"

/*
算法系列---回溯算法
引言
寻找问题的解的一种可靠的方法是首先列出所有候选解，然后依次检查每一个，在检查完所有或部分候选解后，即可找到所需要的解。理论上，当候选解数量有限并且通过检查所有或部分候选解能够得到所需解时，上述方法是可行的。不过，在实际应用中，很少使用这种方法，因为候选解的数量通常都非常大(比如指数级，甚至是大数阶乘），即便采用最快的计算机也只能解决规模很小的问题。对候选解进行系统检查的方法有多种，其中回溯和分枝定界法是比较常用的两种方法。按照这两种方法对候选解进行系统检查通常会使问题的求解时间大大减少(无论对于最坏情形还是对于一般情形）。事实上，这些方法可以使我们避免对很大的候选解集合进行检查，同时能够保证算法运行结束时可以找到所需要的解。因此，这些方法通常能够用来求解规模很大的问题。
算法思想
回溯(backtracking）是一种系统地搜索问题解答的方法。为了实现回溯，首先需要为问题定义一个解空间(solution space），这个空间必须至少包含问题的一个解(可能是最优的）。
下一步是组织解空间以便它能被容易地搜索。典型的组织方法是图(迷宫问题)或树(N皇后问题)。
一旦定义了解空间的组织方法，这个空间即可按深度优先的方法从开始节点进行搜索。

回溯方法的步骤如下：
1) 定义一个解空间，它包含问题的解。
2) 用适于搜索的方式组织该空间。
3) 用深度优先法搜索该空间，利用限界函数避免移动到不可能产生解的子空间。
回溯算法的一个有趣的特性是在搜索执行的同时产生解空间。在搜索期间的任何时刻，仅保留从开始节点到当前节点的路径。因此，回溯算法的空间需求为O(从开始节点起最长路径的长度）。这个特性非常重要，因为解空间的大小通常是最长路径长度的指数或阶乘。所以如果要存储全部解空间的话，再多的空间也不够用。

算法应用
回溯算法的求解过程实质上是一个先序遍历一棵"状态树"的过程,只是这棵树不是遍历前预先建立的,而是隐含在遍历过程中<<数据结构>>(严蔚敏).

回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。

回溯法是一个既带有系统性又带有跳跃性的搜索算法。它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解的空间树。算法搜索至解的空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。这种以深度优先的方式系统地搜索问题的解的算法称为回溯法，它适用于解一些组合数较大的问题。

算法框架：

1、问题的解空间：应用回溯法解问题时，首先应明确定义问题的解空间。问题的解空间应至少包含一个(最优）解。

2、回溯法的基本思想：确定了解空间的组织结构后，回溯法就从开始结点(根结点）出发，以深度优先的方式搜索整个解空间，这个开始结点就成为一个活结点，同时也成为当前的扩展结点。在当前的扩展结点处，搜索向纵深方向移至一个新结点，这个新结点就成为一个新的活结点，并成为当前扩展结点。如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。换句话说，这个结点不再是一个活结点。此时，应往回移动(回溯）至最近的一个活结点处，并使这个活结点成为当前的扩展结点。回溯法即以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已没有活结点时为止。

运用回溯法解题通常包含以下三个步骤：

(1）针对所给问题，定义问题的解空间；

(2）确定易于搜索的解空间结构；

(3）以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

3、递归回溯：由于回溯法是对解的空间的深度优先搜索，因此在一般情况下可用递归函数来实现回溯法如下：

void backtrace(int i)
{
    for (int j=下界;j<上界;j++)
    {
        matrix[i] = j;

        //可行{满足限界函数和约束条件}
        if ( 可行())
        {
            //置值
            if (i>n)
            {
                //中止搜索并输出结果;
            }
            backtrace(i+1);
        }
    }
}

说明：

i是递归深度；

n是深度控制，即解空间树的高度；

可行性判断有两方面的内容：

①不满约束条件则剪去相应子树；

②若限界函数越界，也剪去相应子树；

③两者均满足则进入下一层；

搜索：全面访问所有可能的情况，分为两种：不考虑给定问题的特有性质，按事先设好的顺序，依次运用规则，即盲目搜索的方法；另一种则考虑问题给定的特有性质，选用合适的规则，提高搜索的效率，即启发式的搜索。

*/

//八皇后问题
//解空间
static int matirx[8] = {0};
static int count = 0;

void display()
{
    int row;
    int col;

    printf("\r\n======%02d=======\n",count);
    for(row = 0; row <8; row ++)
    {
        for(col = 0; col < matirx[row]; col ++)
            printf("* ");

        printf("# ");

        for(col = matirx[row] + 1; col < 8; col ++)
            printf("* ");

        printf("\n");
    }
}

bool place(int row, int col)
{
    int prev;
    int data;

    for(prev = 0; prev < row; prev ++){
        data = matirx[prev];

        //同一列
        if(col == data)
            return false;

        //左斜线
        if ((prev-row) == (col - data) )
            return false;

        //右斜线
        if((row - prev) == (col - data))
            return false;

    }
    return true;
}

void queen(int row)
{
    int col;

    for(col=0;col<8;col++)
    {
        if(place(row,col))
        {
            matirx[row]=col;
            if(row>=7)
            {
                count++,display();
                //matirx[row]=0;
                return;
            }

            queen(row+1);
            //matirx[row]=0;
        }
    }
}

int main(void)
{
    queen(0);
    system("pause");
    return 0;
}

天下 2013-03-20 15:37 发表评论

算法：数学知识（1）

天下 — Tue, 19 Mar 2013 09:48:00 GMT

排列组合
排列的定义及其计算公式：从n个不同元素中，任取m(m≤n,m与n均为自然数,下同)个元素按照一定的顺序排成一列，叫做从n个不同元素中取出m个元素的一个排列；

从n个不同元素中取出m(m≤n)个元素的所有排列的个数，叫做从n个不同元素中取出m个元素的排列数，用符号 A(n,m)表示。A(n,m)=n(n-1)(n-2)……(n-m+1)= n!/(n-m)! 此外规定0!=1

A(n,m) = n!/(n-m)!

从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。

组合的定义及其计算公式：从n个不同元素中，任取m(m≤n)个元素并成一组，叫做从n个不同元素中取出m个元素的一个组合；从n个不同元素中取出m(m≤n)个元素的所有组合的个数，叫做从n个不同元素中取出m个元素的组合数。用符号 C(n,m) 表示。C(n,m)==A(n,m)/m!；C(n,m)=C(n,n-m)。(n>=m)

排列数：
A(n,m) = n!/(n-m)!

组合数：
C(n,m)=A(n,m)/m!
C(n,m)=n!/(n-m)/m!

针对一个集合n，连续子集合
E(n) = n*(1+n)/2

天下 2013-03-19 17:48 发表评论

动态规划算法（2），lcs算法，改进空间复杂度

天下 — Sat, 16 Mar 2013 10:17:00 GMT

const string LCS2(const string& strX,const string& strY)
{
    int xlen=strX.size(); //横向长度
    int ylen=strY.size(); //纵向长度
    vector<int> arr(ylen); //当前行

    int length=0;         //矩阵元素中的最大值
    int pos=0;             //矩阵元素最大值出现在第几列
    arr.assign(ylen,0);
    for(int x=0;x<xlen;x++)
    {
        for(int y=0;y<ylen;y++)
        {
            if (strX.at(x)==strY.at(y))
            {
                if(y==0)
                    arr[y]=1;
                else
                    arr[y]=arr[y-1]+1;
                if(arr[y]>length)
                {
                    length=arr[y];
                    pos=y;
                }
            }
        }
    }
    string res=strY.substr(pos-length+1,length);
    return res;
}

天下 2013-03-16 18:17 发表评论

动态规划算法（1）：lcs算法

天下 — Sat, 16 Mar 2013 05:58:00 GMT

#include "stdafx.h"

/*
求两个字符串的最大公共子串的问题（简要说明，从另外一个地方转的，和下面一篇合成在一起）：
把字符串1（长度m）横排，串2（长度n）竖排，得到一个m×n的矩阵c，矩阵的每个元素的值如下，如果m[i]=n[j]，则c[j][i]=1,否则，c[j][i]=0。然后找出矩阵中连续是1的对角线最长的一个，则对角线的长度就是公共子串的长度.

LCS问题就是求两个字符串最长公共子串的问题。解法就是用一个矩阵来记录两个字符串中所有位置的两个字符之间的匹配情况，若是匹配则为1，否则为0。然后求出对角线最长的1序列，其对应的位置就是最长匹配子串的位置。

下面是字符串babhbxbhhaahbz和字符串hababhbbhzzx的匹配矩阵，前者为X方向的，后者为Y方向的。不难找到，红色部分是最长的匹配子串。通过查找位置我们得到最长的匹配子串为：babhb

0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

但是在0和1的矩阵中找最长的1对角线序列又要花去一定的时间。
通过改进矩阵的生成方式和设置标记变量，可以省去这部分时间。
下面是新的矩阵生成方式：
0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
0 1 0 0 0 0 0 0 0 2 1 0 0 0 0
1 0 2 0 1 0 1 0 0 0 0 0 1 0 0
0 2 0 0 0 0 0 0 0 1 1 0 0 0 0
1 0 3 0 1 0 1 0 0 0 0 0 1 0 0
0 0 0 4 0 0 0 2 1 0 0 1 0 0 0
1 0 1 0 5 0 1 0 0 0 0 0 2 0 0
1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
0 0 0 2 0 0 0 2 1 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

不用多说，你大概已经看出来了。当字符匹配的时候，我们并不是简单的给相应元素赋上1，而是赋上其左上角元素的值加一。我们用两个标记变量来标记矩阵中值最大的元素的位置，在矩阵生成的过程中来判断当前生成的元素的值是不是最大的，据此来改变标记变量的值，那么到矩阵完成的时候，最长匹配子串的位置和长度就已经出来了。

这样做速度比较快，但是花的空间太多。

*/

char* lcs(char *str1, char *str2,int* p_length)
{
    int i,j,m,n,length,x,y;

    m = strlen(str1)+1;
    n = strlen(str2)+1;
    int **matrix = new int*[m];
    for(i = 0; i < m; i++)
        matrix[i] = new int[n];
    for(i = 0; i < m; i++)
        matrix[i][0]=0;//第0列都初始化为0
    for(j = 0; j < n; j++)
        matrix[0][j]=0;//第0行都初始化为0

    length = -1;
    *p_length = -1;

    for(i = 1 ; i < m ; i++)
    {
        for(j = 1; j < n; j++)
        {
            if(str1[i-1]==str2[j-1])
            {
                //只需要跟左上方的matrix[i-1][j-1]比较就可以了
                matrix[i][j]=matrix[i-1][j-1]+1;
            }
            else{
                //不连续的时候还要跟左边的matrix[i][j-1]、上边的matrix[i-1][j]值比较，这里不需要
                matrix[i][j]=0;
            }
            if(matrix[i][j]>length)
            {
                length=matrix[i][j];
                x=i;
                y=j;
            }
        }
    }

    for(i = 0; i < m; i++)
        delete[] matrix[i];
    delete[] matrix;

    if (length>0)
    {
        *p_length = length;
        return &str1[x-length];
    }
    return NULL;
}
int main(void)
{
    char str1[1000],str2[1000],str3[1000];
    int length;

    printf("请输入第一个字符串：");
    gets(str1);
    printf("请输入第二个字符串：");
    gets(str2);
    char* pszText = lcs(str1, str2,&length);
    printf("最长公共连续子串的长度为：%d\n",length);
    if (pszText!=NULL)
    {
        strncpy(str3,pszText,length);
        str3[length] = 0;
        printf("最长公共连续子串：%s\n",str3);
    }
    system("pause");
    return 0;
}

天下 2013-03-16 13:58 发表评论

CRC16算法

天下 — Fri, 17 Aug 2012 01:36:00 GMT

#include "stdafx.h"

unsigned int GetCrc32(char* pdata,unsigned int len){
    //生成Crc32的查询表
    unsigned int Crc32Table[256];
    int i,j;
    unsigned int Crc;
    for (i = 0; i < 256; i++){
        Crc = i;
        for (j = 0; j < 8; j++){
            if (Crc & 1)
                Crc = (Crc >> 1) ^ 0xEDB88320;
            else
                Crc >>= 1;
        }
        Crc32Table[i] = Crc;
    }
    //开始计算CRC32校验值
    Crc=0xffffffff;
    for(int i=0; i<len; i++)
    {
        Crc = (Crc >> 8) ^ Crc32Table[(Crc & 0xFF) ^ pdata[i]];
    }

    Crc ^= 0xFFFFFFFF;
    return Crc;
}

static const unsigned short Crc16Table[256] =
{
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};

//生成Crc16的查询表
void GetCrc16Table()
{
    unsigned short crc16tbl[256];
    unsigned int i,j;
    unsigned short Crc;
    printf("unsigned short Crc16Table[256] = \r\n{\r\n");
    for (i = 0; i < 256; i++) {
        Crc = i;
        for (j = 0; j < 8; j++) {
            if(Crc & 0x1)
                Crc = (Crc >> 1) ^ 0xA001;
            else
                Crc >>= 1;

        }
        printf("0x%04X,",Crc);
        if ((i+1)%8==0)
        {
            printf("\r\n");
        }
        crc16tbl[i] = Crc;
    }
    printf("};\r\n");
}
unsigned short GetCrc16(char* pdata,unsigned int len)
{
    //开始计算CRC16校验值
    unsigned short crc16=0x0000;
    for(int i=0; i<len; i++){
        crc16 = (crc16 >> 8) ^ Crc16Table[(crc16 & 0xFF) ^ pdata[i]];
    }
    //Crc ^= 0x0000;
    return crc16;
}

unsigned short GetCrc16(unsigned short poly,char* pdata,unsigned int len)
{
    unsigned short crc16;
    //开始计算CRC16校验值
    crc16=poly;
    for(int i=0; i<len; i++){
        crc16 = (crc16 >> 8) ^ Crc16Table[(crc16 & 0xFF) ^ pdata[i]];
    }
    //Crc ^= 0x0000;
    return crc16;
}

//test code
#include "stdafx.h"

int main( int argc,char* argv[] )
{
    char str[]="iawene";
    unsigned short crc1 = 0;
    unsigned short crc2 = 0;
    GetCrc16Table();
    puts("\r\n\r\n\r\n-------------------------------------------");

    crc1=GetCrc16(str,5);//0x5359
    printf("<1>0x%04X\n",crc1);

    for(int i=0;i<5;i++)
    {
        crc2 = GetCrc16(crc2,&str[i],1);
    }
    printf("<2>0x%04X\n",crc2);


    return 0;
}

天下 2012-08-17 09:36 发表评论

CRC32算法（查表法）代码

天下 — Wed, 18 Apr 2012 10:02:00 GMT

#include <windows.h>
#include <stdio.h>

void PrintCrcTable()
{
    //Poly = 0xedb88320 WinRAR Poly
    DWORD Val;
    for (DWORD i = 0; i < 256; i++)
    {
        Val = i;
        for (DWORD k = 0; k < 8; k++)
        {
            if (Val & 1)
                Val = 0xedb88320L ^ (Val >> 1);
            else
                Val = Val >> 1;
        }
        printf ("0x%08x, ", Val);
        if (0 == ((i+1)%6))
            printf ("\n");
    }
}

const DWORD Crc32Table[] =
{
    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};

DWORD GenerateCrc32(DWORD PartialCrc,PUCHAR  Buffer,DWORD   Length)
{
    DWORD crc;
    DWORD i;

    // Generate the CRC32 checksum.
    crc = PartialCrc ^ 0xffffffffL;

    for (i = 0; i < Length; i++)
    {
        crc = Crc32Table[(crc ^ Buffer[i]) & 0xff] ^ (crc >> 8);
    }

    return (crc ^ 0xffffffffL);
}

//测试程序
int main(int argc,char* argv[])
{
    char* szFileName = NULL;
    if (argc<2)
    {
        printf("Usage:%s  \r\n",argv[0]);
        return -1;
    }
    szFileName = argv[1];
    FILE *fp = fopen(szFileName,"rb");
    if(NULL == fp)
    {
        printf("Open %s error:%d \r\n",szFileName);
        return 0;
    }

    DWORD crc32 = 0;
    BYTE c = 0;
    while(1 == fread(&c,1,1,fp))
        crc32 = GenerateCrc32(crc32,&c,1);

    fclose(fp);

    printf("CRC32 = 0x%08X", crc32);
    return 0;
}

天下 2012-04-18 18:02 发表评论