国产精品久久久天天影视,97久久香蕉国产线看观看,国内精品久久久久久久亚洲

判断手指按下

天下 — 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代码�?最�q�一�ơ更斎ͼ�2013-3-17 一、特征提取Feature Extraction�Q?· SIFT [1] [Demo ... 阅读全文

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

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

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

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

/*
             --- 冒��排序 ---
自下而上的两两比较，��排在大��前，一��冒��Z��个最��?br />*/

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;
            }
        }
    }
}

/*
                    --- 选择排序 ---
自下而上的两两比较，记录最��数的下标，��最上面的数与最��数交换�?br />*/

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;
    }
}

/*
                    --- 插入排序 ---
��数据插入到已排序的序列中，�Ҏ��合适的位置�Q�边�U�d��数据�Q�找到合适位�|�插入数据�?br />*/

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;
    }
}

/*
                    --- 快速排�?nbsp;---
是对冒��排序的改�q��?br />1�Q�先从数列中取出一个数作�ؓ基准�?
2�Q�分��E�，��比�q�个数大的数全放到它的右边，��于或等于它的数全放到它的左�?
3�Q�再对左叛_��间重复第二步�Q�直到各区间只有一个数.

分区�q�程可以形象的描�q�Cؓ“挖坑填数”�Q?br />1�Q�将基准数nBase挖出形成�W�一个坑nArray[nLow];
2�Q�nHigh--由后向前找比nBase��的敎ͼ�扑ֈ�后挖出此数填前一个坑nArray[nLow]�?
3�Q�nLow++由前向后找比nBase大的敎ͼ�扑ֈ�后也挖出此数填到前一个坑nArray[nHigh]�?
4�Q�再重复执行2�Q?二步�Q�直到nLow==nHigh�Q�将基准数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);
    }
}

/*
                    --- 希尔排序 ---
是对直接插入排序��法的改�q�，又称�~�小增量排序�?br />1、将数组�q�行分组�Q�下标相差d的�ؓ一�l�；
2、对每组中全部元素进行排序；
3、然后再用一个较��的增量d, 重复1�?�Q�直到d�?�Ӟ��排序完成�?br />
一般增量取��gؓ上一�ơ的一半，d = 1/2 d�Q�第一�ơ取��gؓ数组长度的一半�?br />*/

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;
        }
    }
}

/*
                    --- 归�ƈ排序 ---
是将两个已经排序的序列合�q�成一个有序序列�?br />1、待排序序列分�ؓ两个子序�?
2、每个子序列重复步骤1�Q�直到每个子序列只有一个元�?
3、按大小��序合�ƈ两个子序�?
4、重复步�?�Q�直到合�q��ؓ一个整体有序序列，排序完成�?br />*/

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);
    }
}

/*
                    --- 堆排�?nbsp;---
1、先��数�l��{换�ؓ完全二叉树；
2、调整二叉树形如大顶堆；
3、将根结点与最后一个叶子结点互换，卛_��最大元素放在数�l�的末尾�Q�数�l�的长度减一�Q?br />4、再重复2�?�Q�直到数�l�长度�ؓ1�Q�排序完成�?br />*/

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 发表评论

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

#include "stdafx.h"

int c[20][100];/*对应每种情况的最大�h�?/span>*/

//int m 背包定w��
//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;/*初始化数�l?/span>*/

    for(i=1;i    {
        for(j=1;j        {
            if(w[i]<=j) /*如果当前物品的容量小于背包容�?/span>*/
            {
                if(p[i]+c[i-1][j-w[i]]>c[i-1][j])
                {
                    //如果本物品的价值加上背包剩下的�I�间能放的物品的价�?br />                    //大于上一�ơ选择的最��x��?
                    //则更新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 背包定w��
    //int n 背包个数
    int m,n;


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

    printf("最大�h�?%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);
}

//��试�E�序
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 发表评论

天下 — 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 <字符�?> <字符�?>"
        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�Q�：菲�L那契数列

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

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

#include "stdafx.h"
using namespace std;

/*
algorithm
在数字上递归表示的问题也可以表示成递归��法�Q�在许多情�Ş下对朴素的穷举搜索得到显著的性能改进�?br />��M��数字递推公式都可以直接翻译成递归��法�Q�但是基本现实是�~�译器常�怸�能正��地对待递归��法�Q�结果��生低效的�E�序�Q�当怀疑可能是�q�种情况�Ӟ��
必须再给�~�译器提供一些帮助，��递归��法重新写成非递归��法�Q�让后者把�q�些子问题的�{�案�pȝ��地记录在一个表�Q�table�Q�内�Q?br />利用�q�种�Ҏ��的一�U�技巧称为动态规划（dynamic programming�Q��?br />

菲�L那契数列指的是这样一个数列：
1�Q?�Q?�Q?�Q?�Q?�Q?3�Q?1……
�q�个数列从第二项开始，每一��w��{�于前两��之�?br />*/

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 发表评论

天下 — 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()  //打印每个皇后的列的位�|?/span>
{
    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�?/span>
                break;      //跛_��q�一层��@环，开始摆放下一行的皇后
            }
        }
        if (!ret)  //如果循环完这一行，每个位置都冲�H?/span>
        {
            matrix[row] = 0; //��这一行的皇后位置重置�?;
            row--;       //�q�回��C��一�?/span>
            if(row==0)break; //如果已经�q�回��C��W?行，说明所有情况都扑֮��?/span>
        }
        else
        {
            if (row == 8)  //如果扑ֈ�了第8行，说明有满��x��件的�l�果
            {
                display();  //输出�l�果
                count++;
            }
            else row++;
        }
    }
    cout<<count<<endl;
}
int main()
{
    queen(1);
    system("pause");
    return 0;
}

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

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

#include "stdafx.h"

/*
��法�p�d��---回溯��法
引言
��L��问题的解的一�U�可靠的�Ҏ��是首先列出所有候选解�Q�然后依�ơ检查每一个，在检查完所有或部分候选解后，卛_��扑ֈ�所需要的解。理��Z��Q�当候选解数量有限�q�且通过��查所有或部分候选解能够得到所需解时�Q�上�q�方法是可行的。不�q�，在实际应用中�Q�很��用这�U�方法，因�ؓ候选解的数量通常都非常大(比如指数�U�，甚至是大数阶乘）�Q�即侉K��用最快的计算��Z��只能解决规模很小的问题。对候选解�q�行�pȝ��查的�Ҏ��有多�U�，其中回溯和分枝定界法是比较常用的两种�Ҏ��。按照这两种�Ҏ��对候选解�q�行�pȝ��查通常会��问题的求解时间大大减��?无论对于最坏情形还是对于一般情形）。事实上�Q�这些方法可以��我们避免对很大的候选解集合�q�行��查，同时能够保证��法�q�行�l�束时可以找到所需要的解。因此，�q�些�Ҏ��通常能够用来求解规模很大的问题�?br />��法思想
回溯(backtracking�Q�是一�U�系�l�地搜烦问题解答的方法。�ؓ了实现回溯，首先需要�ؓ问题定义一个解�I�间(solution space�Q�，�q�个�I�间必须臛_��包含问题的一个解(可能是最优的�Q��?br />下一步是�l�织解空间以便它能被�Ҏ��地搜索。典型的�l�织�Ҏ��是图(�q�宫问题)或树(N皇后问题)�?br />一旦定义了解空间的�l�织�Ҏ��Q�这个空间即可按深度优先的方法从开始节点进行搜索�?br />
回溯�Ҏ��的步骤如下：
1) 定义一个解�I�间�Q�它包含问题的解�?br />2) 用适于搜烦的方式组�l�该�I�间�?br />3) 用深度优先法搜烦该空��_��利用限界函数避免�U�d��C��可能产生解的子空间�?br />回溯��法的一个有��的�Ҏ��是在搜索执行的同时产生解空间。在搜烦期间的�Q何时刻，仅保留从开始节点到当前节点的�\径。因此，回溯��法的空间需求�ؓO(从开始节点�v最长�\径的长度�Q�。这个特性非帔R��要，因�ؓ解空间的大小通常是最长�\径长度的指数或阶乘。所以如果要存储全部解空间的话，再多的空间也不够用�?br />
��法应用
回溯��法的求解过�E�实质上是一个先序遍历一��?状态树"的过�E?只是�q�棵树不是遍历前预先建立�?而是隐含在遍历过�E�中<<数据�l�构>>(严蔚�?.

回溯��法的基本思想是：从一条�\往前走�Q�能�q�则�q�，不能�q�则退回来�Q�换一条�\再试�?br />
回溯法是一个既带有�pȝ��性又带有跌��性的搜烦��法。它在包含问题的所有解的解�I�间树中�Q�按照深度优先的�{�略�Q�从根结点出发搜索解的空间树。算法搜索至解的�I�间树的��M��l�点�Ӟ��L��先判断该�l�点是否肯定不包含问题的解。如果肯定不包含�Q�则跌��对以该结点�ؓ根的子树的系�l�搜索，逐层向其��先�l�点回溯。否则，�q�入该子树，�l�箋按深度优先的�{�略�q�行搜烦。回溯法在用来求问题的所有解�Ӟ��要回溯到根，且根�l�点的所有子树都已被搜烦遍才�l�束。而回溯法在用来求问题的�Q一解时�Q�只要搜索到问题的一个解��可以结束。这�U�以深度优先的方式系�l�地搜烦问题的解的算法称为回溯法�Q�它适用于解一些组合数较大的问题�?br />
��法框架�Q?br />
1、问题的解空��_��应用回溯法解问题�Ӟ��首先应明��定义问题的解空间。问题的解空间应臛_��包含一�?最优）解�?br />
2、回溯法的基本思想�Q�确定了解空间的�l�织�l�构后，回溯法就从开始结�?根结点）出发�Q�以深度优先的方式搜索整个解�I�间�Q�这个开始结点就成�ؓ一个活�l�点�Q�同时也成�ؓ当前的扩展结炏V��在当前的扩展结点处�Q�搜索向�U�|��方向�U�至一个新�l�点�Q�这个新�l�点��成��Z��个新的活�l�点�Q��ƈ成�ؓ当前扩展�l�点。如果在当前的扩展结点处不能再向�U�|��方向�U�d��Q�则当前扩展�l�点��成为死�l�点。换句话��_��q�个�l�点不再是一个活�l�点。此�Ӟ��应往回移�?回溯�Q�至最�q�的一个活�l�点处，�q��ɘq�个�zȝ��Ҏ��为当前的扩展�l�点。回溯法即以�q�种工作方式递归地在解空间中搜烦�Q�直��x��到所要求的解或解�I�间中已没有�zȝ��Ҏ��为止�?br />
�q�用回溯法解题通常包含以下三个步骤�Q?br />
(1�Q�针�Ҏ��l�问题，定义问题的解�I�间�Q?br />
(2�Q�确定易于搜索的解空间结构；

(3�Q�以深度优先的方式搜索解�I�间�Q��ƈ且在搜烦�q�程中用剪枝函数避免无效搜烦�?br />
3、递归回溯�Q�由于回溯法是对解的�I�间的深度优先搜索，因此在一般情况下可用递归函数来实现回溯法如下�Q?br />
void backtrace(int i)
{
    for (int j=下界;j<上界;j++)
    {
        matrix[i] = j;

        //可行{满��限界函数和约束条件}
        if ( 可行())
        {
            //�|��?br />            if (i>n)
            {
                //中止搜烦�q�输出结�?
            }
            backtrace(i+1);
        }
    }
}

说明�Q?br />
i是递归深度�Q?br />
n是深度控�Ӟ��卌��I�间树的高度�Q?br />
可行性判断有两方面的内容�Q?br />
①不满�U�束条�g则剪�ȝ��应子树；

②若限界函数越界，也剪�ȝ��应子树；

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

搜烦�Q�全面访问所有可能的情况�Q�分��Z��U�：不考虑�l�定问题的特有性质�Q�按事先讑֥�的顺序，依次�q�用规则�Q�即盲目搜烦的方法；另一�U�则考虑问题�l�定的特有性质�Q�选用合适的规则�Q�提高搜索的效率�Q�即启发式的搜烦�?br />
*/

//八皇后问�?br />//解空�?/span>
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];

        //同一�?/span>
        if(col == data)
            return false;

        //左斜�U?/span>
        if ((prev-row) == (col - data) )
            return false;

        //��x��U?/span>
        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 发表评论

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

排列�l�合
排列的定义及其计��公式：从n个不同元素中�Q��Q取m(m≤n,m与n均�ؓ自然�?下同)个元素按照一定的��序排成一列，叫做从n个不同元素中取出m个元素的一个排列；

从n个不同元素中取出m(m≤n)个元素的所有排列的个数�Q�叫做从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个不同元素中��d��m�Q�m≤n�Q�个元素�Q�按照一定的��序排列��h��Q�叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列�?/span>

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

排列敎ͼ�
A(n,m) = n!/(n-m)!

�l�合敎ͼ�
C(n,m)=A(n,m)/m!
C(n,m)=n!/(n-m)/m!

针对一个集合n�Q�连�l�子集合
E(n) = n*(1+n)/2

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

动态规划算法（2�Q�，lcs��法�Q�改�q�空间复杂度

天下 — 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(); //�U�向长度
    vector<int> arr(ylen); //当前�?/span>

    int length=0;         //矩阵元素中的最大�?/span>
    int pos=0;             //矩阵元素最大值出现在�W�几�?/span>
    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�Q�：lcs��法

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

#include "stdafx.h"

/*
求两个字�W�串的最大公共子串的问题�Q�简要说明，从另外一个地方�{的，和下面一��合成在一��P��Q?br />把字�W�串1�Q�长度m�Q�横排，�?�Q�长度n�Q�竖排，得到一个m×n的矩阵c�Q�矩�늚�每个元素的值如下，如果m[i]=n[j]�Q�则c[j][i]=1,否则�Q�c[j][i]=0。然后找出矩阵中�q�箋�?的对角线最长的一个，则对角线的长度就是公共子串的长度.

LCS问题��是求两个字�W�串最长公共子串的问题。解法就是用一个矩阉|��记录两个字符串中所有位�|�的两个字符之间的匹配情况，若是匚w��则�ؓ1�Q�否则�ؓ0。然后求出对角线最长的1序列�Q�其对应的位�|�就是最长匹配子串的位置�?nbsp;

下面是字�W�串babhbxbhhaahbz和字�W�串hababhbbhzzx的匹配矩阵，前者�ؓX方向的，后者�ؓY方向的。不难找刎ͼ��U�色部分是最长的匚w��子串。通过查找位置我们得到最长的匚w��子串为：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

但是�?�?的矩阵中找最长的1对角�U�序列又要花��M��定的旉��?br />通过改进矩阵的生成方式和讄��标记变量�Q�可以省去这部分旉��?br />下面是新的矩�는�成方式：
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

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

�q�样做速度比较快，但是��q��I�间太多�?nbsp;

*/

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;//�W?列都初始化�ؓ0
    for(j = 0; j < n; j++)
        matrix[0][j]=0;//�W?行都初始化�ؓ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{
                //不连�l�的时候还要跟左边的matrix[i][j-1]、上边的matrix[i-1][j]值比较，�q�里不需�?nbsp;
                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("误��入第一个字�W�串�Q?/span>");
    gets(str1);
    printf("误��入第二个字符�Ԍ��");
    gets(str2);
    char* pszText = lcs(str1, str2,&length);
    printf("最长公��p��l�子串的长度为：%d\n",length);
    if (pszText!=NULL)
    {
        strncpy(str3,pszText,length);
        str3[length] = 0;
        printf("最长公��p��l�子�Ԍ��%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校验�?/span>
    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校验�?/span>
    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校验�?/span>
    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 发表评论

天下 — 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);
}

//��试�E�序
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 发表评论

国产精品久久久天天影视,97久久香蕉国产线看观看,国内精品久久久久久久亚洲

判断手指按下

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

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

crc32 For Linux 存���