Round Numbers(POJ--3252

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

题意：输入两个数l,r，求区间[l,r]内“round numbers”的个数。“round numbers”：一个十进制数转换成二进制数之后，如果该二进制数中0的个数大于等于1的个数，则该十进制数就是“round numbers”。

借鉴：点击打开链接【更详细的题解】

Sample Input

2 12

Sample Output

6

组合数的做法：

#include <cstdio>
using namespace std;
int c[35][35]= {0},len[35];
void play_table()                        //相当于打表，将组合数全部预处理出来
{
    for(int i=0; i<=35; i++)
        for(int j=0; j<=i; j++)
        {
            if(!j||i==j)
                c[i][j]=1;
            else
                c[i][j]=c[i-1][j]+c[i-1][j-1];
        }
    return ;
}
void del(int n)                            //将十进制转换成二进制数
{
    len[0]=0;
    while(n)
    {
        len[++len[0]]=n%2;
        n/=2;
    }
    return ;
}
int round(int n)
{
    int sum=0,zero=0;
    del(n);
    for(int i=1; i<len[0]-1; i++)                 //枚举位数少于n的数
        for(int j=i/2+1; j<=i; j++)
            sum+=c[i][j];
    for(int i=len[0]-1; i>=1; i--)                 //枚举位数等于n的数
        if(len[i])
            for(int j=(len[0]+1)/2-(zero+1); j<=i-1; j++)
                sum+=c[i-1][j];
        else
            zero++;
    return sum;
}
int main()
{
    int l,r;
    while(~scanf("%d %d",&l,&r))
    {
        play_table();
        printf("%d\n",round(r+1)-round(l));
    }
    return 0;
}<strong>
</strong>

数位dp的做法：

<span style="font-size:24px;">#include <cstdio>
#include <cstring>
using namespace std;
int dp[35][2][63];  //第一维代表的是转换成二进制后的长度，第二位代表当前位置含不含有前导零，第三维代表0的个数与1的个数之差，为了防止出现负数，让其差加31，则当差为31时指0的个数与1的个数相等。dp数组是用来存储当前位置所有可能的方案数，即当前位置的数还没有到达数n当前位置的最大值。
int len[35];           //存储十进制数转换后的二进制数
int dfs(int pos,int big,bool zero,bool high)
{
    if(pos==-1)  return big>=31;   //如果已经到了最后一位的下一位则返回该数是否为</span><span style="text-align: center;"><span style="font-size:18px;">Round Numbers</span></span><span style="font-size:24px;">
    if(!high&&~dp[pos][zero][big])return dp[pos][zero][big];   //如果当前位置没有达到当前位置的最大值并且之前已经算过当前位置的方案数则直接返回当前位置的方案数
    int en,sum=0,nbig;
    bool nzero;
    en=high?len[pos]:1;           //如果当前位置的数是当前位置能到达的最大值，则en就等于当前位置能达到的最大值，否则就可以等于所允许的所有数字
    for(int i=0; i<=en; i++)
    {
        nbig=big;                   //big记录的是当前0个数与1个数之差
        nzero=zero;               //如果zero=1说明当前位置之前还没有出现1，则此时出现0则不累加；如果zero=0说明当前位置之前已经出现了1，此时再出现0则可以计入0的个数
        if(i)
        {
            nbig--;            //当前数为1，0个数与1个数之差减少1
            nzero=0;        //出现1
        }
        else if(!zero)
            nbig++;          //当前位置之前有1，此时出现0，个数之差加1
        sum+=dfs(pos-1,nbig,nzero,high&&i==en);    继续遍历后一位数
    }
    if(!high)
        dp[pos][zero][big]=sum;
    return sum;
}
int round(int n)
{
    int ll=0;
    while(n)                     //将十进制数转换成二进制数
    {
        len[ll++]=n%2;
        n/=2;
    }
    return dfs(ll-1,31,1,1);          //参数：二进制数的最高位；0个数与1个数之差（为了防止出现负数，此时的31就相当于0）；当前位置是最高位，则当前位置之前肯定没有1，就相当于之前有前导零；最高位肯定是1且此时当前位置已经达到最大值
}
int main()
{
    int l,r;
    while(~scanf("%d %d",&l,&r))
    {
        memset(dp,-1,sizeof(dp));
        printf("%d\n",round(r)-round(l-1));
    }
    return 0;
}
</span>