#include <stdio .h>
#include <stdlib .h>
 
int n=5,c=10;
int value[5]={6,3,5,4,6};
int weight[5]={2,2,6,5,4};
int cv[5]={0,0,0,0,0};
int bv[5]={0,0,0,0,0};
int cw=0;
int curv = 0 ;
int bestv =0 ;
void output()
{
   int i =0;
   for(i; i<n ; i++)
     printf("%d ",bv[i]);
   printf("%d",bestv);     
}
 
void trackback(int i)
{
     int j;
    if(i>=n)
    {
         if(bestv<curv ) 
        {
            for(j=0;j<n;j++)
                bv[j] = cv[j]; 
            bestv = curv;
        } 
    }
    else
    {
         if(cw + weight[i]<=c)
         {
          cv[i] = 1; 
          cw +=weight[i];
          curv+= value[i];
          trackback(i+1);
          cw -=weight[i];
          curv-= value[i];
          }
          cv[i] =0;
          trackback(i+1);
 
    }
 
 
}
int main(int argc, char *argv[])
{
  trackback(0);
  output();
  system("PAUSE");	
  return 0;
}

]]> http://amberlife.net/2010/05/01%e8%83%8c%e5%8c%85%e9%97%ae%e9%a2%98-%e5%9b%9e%e6%ba%af%e6%b3%95-c%e8%af%ad%e8%a8%80%e5%ae%9e%e7%8e%b0%e3%80%82/feed/ 0 http://amberlife.net/2009/12/%e6%b1%82%e4%ba%8c%e8%bf%9b%e5%88%b6%e6%95%b0%e4%b8%ad1%e7%9a%84%e4%b8%aa%e6%95%b0/ http://amberlife.net/2009/12/%e6%b1%82%e4%ba%8c%e8%bf%9b%e5%88%b6%e6%95%b0%e4%b8%ad1%e7%9a%84%e4%b8%aa%e6%95%b0/#comments Fri, 18 Dec 2009 16:16:44 +0000 amberlife http://amberlife.net/?p=156 对于一个字节（8bit）的变量，求其二进制表示中“1”的个数，要求算法的执行效率尽可能地高。

【解法一】

可以举一个八位的二进制例子来进行分析。对于二进制操作，我们知道，除以一个2，原来的数字将会减少一个0。如果除的过程中有余，那么就表示当前位置有一个1。

int Count(int v)

{

int num = 0;

while(v)

{

if(v % 2 == 1)

{

num++;

}

v = v/ 2;

}

return num;

}

【解法二】使用位操作

前面的代码看起来比较复杂。我们知道，向右移位操作同样也可以达到相除的目的。唯一不同之处在于，移位之后如何来判断是否有1存在。对于这个问题，再来看看一个八位的数字：10 100 001。

在向右移位的过程中，我们会把最后一位直接丢弃。因此，需要判断最后一位是否为1，而“与”操作可以达到目的。可以把这个八位的数字与00000001进行“与”操作。如果结果为1，则表示当前八位数的最后一位为1，否则为0。代码如下：

int Count(int v)

{

int num = 0;

While(v)

{

num += v &0×01;

v >>= 1;

}

return num;

}

【解法三】

位操作比除、余操作的效率高了很多。但是，即使采用位操作，时间复杂度仍为O（log2v），log2v为二进制数的位数。那么，还能不能再降低一些复杂度呢？如果有办法让算法的复杂度只与“1”的个数有关，复杂度不就能进一步降低了吗？

同样用10 100 001来举例。如果只考虑和1的个数相关，那么，我们是否能够在每次判断中，仅与1来进行判断呢？

为了简化这个问题，我们考虑只有一个1的情况。例如：01 000 000。

如何判断给定的二进制数里面有且仅有一个1呢？可以通过判断这个数是否是2的整数次幂来实现。另外，如果只和这一个“1”进行判断，如何设计操作呢？我们知道的是，如果进行这个操作，结果为0或为1，就可以得到结论。

int Count(int v)

{

int num = 0;

while(v)

{

v &= (v-1);

num++;

}

return num;

}

【解法五】查表法

int countTable[256] =

{

0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3,

3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3,

4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,

3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3,

4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6,

6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4,

5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,

3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3,

4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4,

4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6,

7, 6, 7, 7, 8

};

int Count(int v)

{

//check parameter

return countTable[v];

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jiju8484/archive/2008/04/03/2247823.aspx

有一次我烙了三个饼，一个两面都焦了，一个两面都是金黄色，一个一面是焦的，一面是金黄色，我把它们摞一起，只能看到最上一面，发现是焦的，问最上面这个饼的另一面是焦的概率是多少？

解法1：

1. 最上一面是焦的, 排除最上一张是两面金黄色

2. 剩下两张饼四个面, 三面是焦的, 一面金黄色, 现知道其中一面是焦的,

所以判断另一面是焦的概率就是求 二面焦 + 一面金黄 中焦的概率, = 2/2+1 = 2/3

解法2：

A=最上面的饼双面焦

B=最上面的饼双面金黄

C=最上面的饼一面金黄一面焦

J=最上面的一面焦

则P(J|A)=1，P(J|B)=0，P(J|C)=0.5

P(A|J)=P(AJ)/P(J)=(1/3)/(1/2)=2/3

先看函数，随后我来解释思路：

//c:填充字符 length:长度
//getString(c,length)返回长度为length的字符串，它的所有字符均为c
function getString(c,length)
{
var bArr = length.toString(2).split(”");
// 将length转换成2进制数，并转换成数组
// 例如length为20，对应的2进制数是10100转换为数组bArr为["1","0","1","0","0"]
var ret = “”;
var step = c;// 初始步长为字符串c
for(var i = bArr.length-1;i>=0;i–)// 从末位开始连接字符串
{
if(bArr[i]==”1″) ret += step;// 当前位为1 时，在ret字符串后增加step
step += step;// 步长加倍
}
return ret;
}

function pad(str ,len ,c ,dir)
{
var out = String(str);// 原始字符串
if(!c) c = “0″;// 如果参数c未定义，则c取默认值“0”
if(!dir) dir = 1; // 如果参数dir未定义，则dir取默认值1
var pad = getString(c ,len – out.length); // 计算需要填充的字符串
if(dir > 0 ) out= pad + out; // 在左侧填充
else out += pad; // 在右侧填充
return out;
}
alert(pad(”aaaa”,8,”1″,1));//测试。

看完这个pad函数后，可以发现其最精华的部分在它调用getstring（）函数上，getstring()函数直接返回需要添加的字符串，并且添加的长度也是刚刚好。getstring()函数，最精华的部分在于将需要添加的字符串的长度直接转换成二进制的形式，并用数组保存每一个二进制位。
在分析这个循环之前，让我们先来想一下二进制数转换成十进制从低位到高位的运算。比如 二进制数10100 计算过程是 0*2^0 +0*2^1+1*2^2+0*2^3+1*2^4 = 20（十进制） ;
我们知道高一位的权值是低一位的权值的2倍，因此依次是2^0,2^1,2^2….
而我们的运算过程就是这一位的值与这一位的权值相乘的运算，随后各位的运算结果相加。而在getstring()函数中for循环的部分中，我们相当于做了一个根据二进制的值通过给定的字符来扩充字符串长度的操作。当bArr[i]==”1″，我们就要进位了，同时要增加”权值” ,当改为是0的时候，我们只是增加”权值”，就是通过step+=step来实现字符串长度的翻倍。
通过这样一个小技巧，可以很大程度的减少循环的次数，我们可以想象如果添加的字符串的长度是10000 的话，如果按照传统的一次增加一个字符的方式，要循环一万次，而通过这种方式，我们只需要将10000（十进制）转换成10011100010000（二进制），这样14次循环就可以计算出结果。
在此只是通过js来实现了这样一个算法，能够以此来加深对二进制操作的印象。

• 栈的基本操作中，基本上都是在栈顶进行的。比如在栈顶的插入，删除，栈的初始化，栈的判空（S.base == S.top），取栈顶元素等等。所以关于top指针要引起足够的重视和理解。
• 理解栈和基本线性表的之间的关系。首先，栈就是线性表，栈是一种操作受限的线性表。可以想想就是带着镣铐跳舞的感觉，所以实现的时候必须严格按照栈的定义来执行栈的操作。
• 栈不存在的条件：base = null;
• 栈为空的条件：base = top；
• 栈满的条件：top  – base = stacksize;

下面是我上周做得实验中的关于顺序栈的部分算法的实现。链式栈的实现，在后续中还会贴出来。一个小实验贴出来，分享一下，共同进步。

实验环境:dev-c++5

定义的头文件SqStack.h。主要完成一些
宏命令的定义， 自定义类型的定义 和 函数的声明

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
 
#define STACK_INIT_SIZE 100  //存储空间初始分配量
#define STACKINCREMENT 10    //存储空间增量 
 
typedef int Status;
typedef int SElemType;
typedef struct
{
        SElemType *base;//栈底指针
        SElemType *top; //栈顶指针
        int stacksize;  //当前已经分配的空间，以元素为单位
}SqStack;
 
Status InitStack(SqStack *S);   //构造一个空栈
Status Push(SqStack *s,SElemType e); //压栈操作
Status Pop (SqStack *s,SElemType *e); //出栈操作

文件SqStack.c 完成顺序表中的部分基本操作函数的定义。

#include "SqStack.h"
#include
#include 
 
Status InitStack(SqStack *S)
{
    S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S->base) exit(OVERFLOW);
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}//InitStack
 
Status Push(SqStack *S,SElemType e)
{
    if(S->top - S->base>=S->stacksize)
    {
        S->base = (SElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*
                   sizeof(SElemType));
        if(!S->base) exit(OVERFLOW);
        S->top = S->base + S->stacksize;
        S->stacksize += STACKINCREMENT;
    }
    *(S->top++) = e; //加一句老师讲的入栈口诀：“先压后加”，
                     //可以看到元素先压入栈中，然后栈顶指针指向栈顶元素的下一个位置
    return OK;
}//Push
 
Status Pop(SqStack *S,SElemType *e)
{
    if(S->top == S->base) return ERROR;
    *e = *(--S->top); //出栈口诀：“先减后弹”
                      //可以看到栈顶指针先执行--操作，保证栈顶指针指向栈顶元素，然后弹出栈
    return OK;
}//Pop

main.c文件，测试用的主函数，这个文件借鉴了上课是老师讲的利用函数返回的状态参量来作为循环终止的判断条件。

include
#include 
 
#include "SqStack.h"
 
int main(int argc, char *argv[])
{
  int i ;
  SqStack S ;
  InitStack(&S);//构造一个空栈
  for(i=0;i<10; i++)
    Push(&S,i);//压栈操作，压入10个元素 0，1，2，3.....9；
  while(1)
  {
      SElemType e;
      if( Pop(&S,&e)==ERROR)//出栈操作，10个元素全部出栈，
          break;            //可以看到通过判断Pop返回值的状态，来终止循环的执行
      printf("%d\n",e);
  }
  system("PAUSE");
  return 0;
}

程序都在DEV-C++中测试过了，如果有问题，可以发邮件给我,共同讨论进步。
我的邮箱zhanglong19890125@163.com