Round Numbers（组合数学）

Round Numbers

Time Limit : 4000/2000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)

Total Submission(s) : 11   Accepted Submission(s) : 8

Problem Description

The cows, as you know, have no fingers or thumbs and thus are unable to play Scissors, Paper, Stone' (also known as 'Rock, Paper, Scissors', 'Ro, Sham, Bo', and a host of other names) in order to make arbitrary decisions such as who gets to be milked first. They can't even flip a coin because it's so hard to toss using hooves.

They have thus resorted to "round number" matching. The first cow picks an integer less than two billion. The second cow does the same. If the numbers are both "round numbers", the first cow wins,
otherwise the second cow wins.

A positive integer N is said to be a "round number" if the binary representation of N has as many or more zeroes than it has ones. For example, the integer 9, when written in binary form, is 1001. 1001 has two zeroes and two ones; thus, 9 is a round number. The integer 26 is 11010 in binary; since it has two zeroes and three ones, it is not a round number.

Obviously, it takes cows a while to convert numbers to binary, so the winner takes a while to determine. Bessie wants to cheat and thinks she can do that if she knows how many "round numbers" are in a given range.

Help her by writing a program that tells how many round numbers appear in the inclusive range given by the input (1 ≤ Start < Finish ≤ 2,000,000,000).

 

Input

Line 1: Two space-separated integers, respectively Start and Finish.

 

Output

Line 1: A single integer that is the count of round numbers in the inclusive range Start..Finish

 

Sample Input

2 12

 

Sample Output

6

 

Source

PKU

题意：

输入两个十进制正整数a和b，求闭区间[a ,b]内有多少个Round number

所谓的Round Number就是把一个十进制数转换为一个无符号二进制数，若该二进制数中0的个数大于等于1的个数，则它就是一个Round Number

规定输入范围：1<= a <b<=2E

用组合做

分析：

要知道闭区间[a ,b]内有多少个Round number，只需要分别求出

闭区间[0 ,a]内有T个RN

闭区间[0 ,b+1]内有S个RN

再用S – T就是闭区间[a ,b]内的RN数了

至于为什么是b+1，因为对于闭区间[0 ,k]，我下面要说的算法求出的是比k小的RN数，就是说不管k是不是RN,都没有被计算在内，所以若要把闭区间[a ,b]的边界a和b都计算在内，就要用上述的处理方法。

思路：

注意，转换所得的二进制数，最高位必然是1，最高位的前面不允许有0

规定输入范围：1<= a <b<=2E

用组合做

很猥琐的题，我首先说说猥琐的地方，再说说解题思路，有四点很猥琐：

（1）规定输入范围：1<= a <b<=2E

这是一个忽悠人的幌子！！！输入数是大于2E的!!!但却又不是大数！！

网上看很多同学都说要用到精度，其实完全没必要，int能表示21E+的整数，精确的int极限能表示的正整数为2147483647，区区2E小意思。

但是即使这样，面对这题也不能松懈啊！2E转化为二进制有28位，一般同学都是用一维数组bin[]去存储二进制数的，这个数组的边界你要是定在28、29、30之类的就以为save那就大错特错了！！经过我孜孜不倦的提交，bin[]边界的最小值为35！！说明了用于测试的数据库是存在超过2E的数的！很多同学就因为这点不断WA（越界问题竟然不是RE，太卑鄙了），但又找不到任何算法错误，郁闷几天。

（2）bin[]数组若果定义为局部数组，等着WA吧！

    我找不到任何原因为什么会这样，bin不管是全局定义还是局部定义，本地是完全AC的，上传就出问题了，局部WA，全局AC。

    人家有强权，我被迫把传参del掉，把bin改为全局，郁闷！猥琐！

（3）组合数打表，同(1)的猥琐，c[][]边界的最小值为33，就是说如果定义组合表的大小比

c[33][33]小的，就等着RE吧!  我一开始很小白的定义了c[29][29]。。。。呼吁大家别为别人的服务器省空间了= =

还有就是这个算法有一个违背常识的处理，要把c[0][0]=1，不然某些最终结果会少1

（4）输入不能用循环输入while(cin>>…)，不然你就等着OLE (就是Output Limit Excessed，很少见吧！)。不知道数据库是怎么回事，输入竟然不会根据读取数据结束而结束，而是无限输出最后一次输入所得的结果……老老实实一次输出就end file吧！

解题思路：

组合数学题，不知道为什么会被归类到递推数学，可能是因为杨辉三角和组合数之间的关系。。。

我根据我写的程序讲解好了

要知道闭区间[a ,b]内有多少个Round number，只需要分别求出

闭区间[0 ,a]内有T个RN

闭区间[0 ,b+1]内有S个RN

再用S – T就是闭区间[a ,b]内的RN数了

至于为什么是b+1，因为对于闭区间[0 ,k]，我下面要说的算法求出的是比k小的RN数，就是说不管k是不是RN,都没有被计算在内，所以若要把闭区间[a ,b]的边界a和b都计算在内，就要用上述的处理方法。

现在问题的关键就是如何求[0 ,k]内的RN数了

首先要把k转化为二进制数bin-k，并记录其位数（长度）len

那么首先计算长度小于len的RN数有多少（由于这些数长度小于len，那么他们的值一定小于k，因此在进行组合时就无需考虑组合所得的数与k之间的大小了）

for(i=1;i<bin[0]-1;i++)         //bin[0]记录的是二进制数的长度len

              for(j=i/2+1;j<=i;j++)

                     sum+=c[i][j];

可以看到，i<len-1，之所以减1，是因为这些长度比len小的数，最高位一定是1，那么剩下可供放入数字的位数就要再减少一个了

这条程序得到的sum为

1表示当前处理的二进制数的最高位，X表示该二进制数待放入数字的位

显然这段程序把 二进制数0  排除在外了，这个是最终结果没有影响的，因为最后要把区间[a , b]首尾相减，0存不存在都一样了。

然后计算长度等于len的RN数有多少（由于这些数长度等于len，那么他们的值可能小于k，可能大于k，因此在进行组合时就要考虑组合所得的数与k之间的大小了）

int zero=0;  //从高位向低位搜索过程中出现0的位的个数

       for(i=bin[0]-1;i>=1;i--)

              if(bin[i])   //当前位为1

                     for(j=(bin[0]+1)/2-(zero+1);j<=i-1;j++)

                            sum+=c[i-1][j];

              else

                     zero++;

之所以初始化i=bin[0]-1，是因为bin[]是逆向存放k的二进制的，因此要从高位向低位搜索，就要从bin[]后面开始，而要bin[0]-1 ，是因为默认以后组合的数长度为len，且最高位为1，因此最高位不再搜索了。

那么问题的关键就是怎样使得以后组合的数小于k了

这个很简单：

从高位到低位搜索过程中，遇到当前位为0，则不处理，但要用计数器zero累计当前0出现的次数

遇到当前位为1，则先把它看做为0，zero+1，那么此时当前位后面的所有低位任意组合都会比k小，找出这些组合中RN的个数，统计完毕后把当前位恢复为原来的1，然后zero-1，继续向低位搜索

那么问题就剩下当当前位为1时，把它看做0之后，怎样去组合后面的数了

此时组合要考虑2个方面：

（1）       当前位置i后面允许组合的低位有多少个，我的程序由于bin是从bin[1]开始存储二进制数的，因此当前位置i后面允许组合的低位有i-1个

（2）       组合前必须要除去前面已出现的0的个数zero

我的程序中初始化j=(bin[0]+1)/2-(zero+1)，j本来初始化为(bin[0]+1)/2就可以了，表示对于长度为bin[0]的二进制数，当其长度为偶数时，至少其长度一半的位数为0，它才是RN，当其长度为奇数时，至少其长度一半+1的位数为0，它才是RN。

但是现在还必须考虑前面出现了多少个0，根据前面出现的0的个数，j的至少取值会相应地减少。  -(zero+1) ，之所以+1，是因为要把当前位bin[i]看做0

然后到了最后，剩下一个问题就是怎样得到每一个的值，这个我发现很多同学都是利用打表做的，利用的就是组合数与杨辉三角的关系（建立一个二维数组C[n]

就能看到他们之间关系密切啊！区别就是顶点的值，杨辉三角为1，组合数为0）

其实这个“关系”是有数学公式的

 AC代码：

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int kiss[45][45];
int c()
{
    memset(kiss,0,sizeof(kiss));
    int i,j;
    kiss[0][0]=1;
    for(i=1;i<45;i++)
        for(j=0;j<=i;j++){
            if(j==0){
                kiss[i][j]=kiss[i-1][j];
            }
            else{
                kiss[i][j]=kiss[i-1][j-1]+kiss[i-1][j];
            }
        }
    return 0;
}

int round(int n)
{
    int ans=0;
    int d[45];
    memset(d,0,sizeof(d));
    int len=0;
    int zero=0;
    while(n){//将数用二进制表示出来
        d[len++]=n%2;
        n/=2;
    }
    int i,j;
    for(i=1;i<len-1;i++){//i+1位的数进行组合，第一位一定是1所以需要进行排列的有i位
        for(int j=i/2+1;j<=i;j++){//i位数中有j位是0的排列有多少
            ans+=kiss[i][j];
        }
    }
    for(i=len-2;i>=0;i--){//计算位数为len的数中有多少小于n的round number,方法见上
        if(d[i]){
            for(j=(len+1)/2-zero-1;j<=i;j++){
                ans+=kiss[i][j];
            }
        }
        else zero++;//zero记录在搜索过程中,已发现的0的个数//  
    }
    return ans;
}


int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    c();
    printf("%d
",round(b+1)-round(a));//此处亦有讲究,由于我们的round()所得为小于n的round number的个数,所以b+1
}