Timus 1057

#include <iostream>
using namespace std;

int X,Y,K,B;
int X_value[33] = { 0 }, X_len;
int Y_value[33] = { 0 }, Y_len;
unsigned
long long count_Y, count_X, ret;

void to_base(int base, int *new_value, int *value_len, int value) {
int mod, div, len=0;
while( value ) {
div
= value / base;
mod
= value % base;
new_value[len
++] = mod;
value
= div;
}
*value_len = len;
}

void to_little_bigger() {
int len = X_len, i;
for(i=len-1;i>=0 && X_value[i] <= 1;i--) ;
if( i < 0 )
return;

X_value[i
+1] += 1;
for(int j=i+1;j<len;j++) {
X_value[j
+1] += X_value[j] / 2;
X_value[j]
%= 2;
}
if(X_value[len] == 1)
X_len
++;

if( i+1 > 0 )
memset(X_value,
0, sizeof(int) * (i+1));
}

void to_little_smaller() {
int len = Y_len, i;
for( i=len-1;i>=0 && Y_value[i] <= 1;i-- ) ;
if( i < 0 )
return;

for( ;i>=0;i--)
if( Y_value[i] != 1 )
Y_value[i]
= 1;
}

int tmp[32] = { 0 };

unsigned
long long C(int m, int n) {
int i;
if( n == 0 || n == m )
return 1;
if( n > m || m == 0 || n < 0 )
return 0;

memset(tmp,
0, sizeof(int) * 32);
for(int j=0;j<n;j++) tmp[j]=j+1;

unsigned
long long ret = 1;
for(i=m-n+1;i<=m;i++) {
ret
*= i;
for(int j=0;j<n;j++) {
if(tmp[j] != -1 && (ret%tmp[j]) == 0) {
ret
/= tmp[j];
tmp[j]
= -1;
}
}
}
return ret;
}

unsigned
long long count_combination(int *value, int len, int K) {
int i,k;
unsigned
long long count = 0;
for(i=0,k=len-1;k>=0;k--) {
if(value[k] == 1) {
count
+= C(k,K-i);
i
++;
}
}
return count;
}

int main() {

cin
>>X>>Y;
cin
>>K;
cin
>>B;

to_base(B, X_value,
&X_len, X);
to_base(B, Y_value,
&Y_len, Y);
to_little_bigger();
to_little_smaller();

count_Y
= count_combination(Y_value, Y_len, K);
count_X
= count_combination(X_value, X_len, K);

ret
= count_Y - count_X;
int cnt = 0;
for(int i=0;i<Y_len;i++) {
if( Y_value[i] == 1 )
cnt
++;
}
if( cnt == K ) ret++;
cout
<<ret<<endl;
return 0;
}

一开始的想法是枚举,最坏的情况下是

1到2^31-1中,由16个 以2为底的指数的和。那么组合数就是C(31, 16),不知道这样会不会超时,因为当时马上认为这会超时,所以就放弃了这个想法。

苦思了很久,发现原来这问题可以转化成2进制模式处理

例如以下数字

十进制  365  五进制  2430    <=> 2* 5^3 + 4* 5^2 + 3* 5^1 + 0 * 5^1

十进制  2348  五进制  33343    <=> 3* 5^4 + 3* 5^3 + 3* 5^2 + 4* 5^1 + 3* 5^0

而题目条件中,符合要求的数据都是由 系数为1的K个以B为底的项相加之和

因此要符合给定区间[X, Y],那么就可以把X和Y先转换成对应的符合要求的形式

假如现在X=365,Y=2348

那么2340就应该转换成10000,33343转换成11111

这里展示的规律是:

1. 对一个B进制数D1,要构造一个B进制数D2,D2只由0和1构成,而且是大于等于D1的所有数里面最小的那个,那么D2的构造方法就是

设D1长度为L1,从左到右第i位大于1,那么第i到L1位全部设为0;第i-1位加1,并且缝二进一。

例如

11234 => 100000, 2345 => 10000,0 => 1, 1110011 => 1110011

2. 对一个B进制数D1,要构造一个B进制数D2,D2只由0和1构成,而且是小于等于D1的所有数里面最大的那个,那么D2的构造方法就是

设D1长度为L1,从左到右第i位大于1,那么第i到L1位全部设为1;其他位不变

例如

11234 => 11111,2345 => 1111,11011 => 11011

进行这样的转换之后,无论原来的X,Y是什么数,只要求出X'和Y'之前的符合条件的数,就肯定等价于原来的答案。

直到这里,已经把原来的题目转换成:在二进制数区间[X', Y']中,有多少个数是恰好有K个1的。(这就比原来那题意要清晰多了)

这里如果题目要求没那么严格,只是求在[X,Y]内所有任意个以B为底的项相加之和的数的个数,那么直接Y' - X'就完事了,不过要注意X'可能大于Y',尽管X小于等于Y。

既然要求恰好K个1的数,那么也是枚举就好,对枚举的结果判断是否在[X', Y']内,但这样其实跟一开始就枚举没区别。

而现在需要一种更快的方法。

求区间之间有多少个数字,有点麻烦,不如求小于等于X'的数的个数Nx,再求小于等Y'的数的个数Ny,那么结果就等于Ny - Nx,因此只要有一种快速计算小于等于二进制数D,而且恰好有K个1的数的个数的方法就OK了。

观察这样的规律:

对二进制数D=1001110001,假如要求小于等于D的数,并且恰好有4个1,那么首先要少于1000000000,肯定有C(9, 4)个(9个0代表9个可选位置,然后在里面选4个位置放1)

再求小于1001000000的,肯定有C(6, 3)个(6个0,选3个位置,不选4个的原因是有一个1已经固定在1000000000的第一个1上了)

再求小于1001100000,有C(5, 2)个

再求小于1001110000,有C(4, 1)个

虽然1001110001还有一个1的位置,但是4个1已经都被固定了,也就是说用4个1是怎么也组合不出在[10001110000,10001110001]之间的数(很优雅!)

综上,少于D的恰好有4个1的数的个数是C(6, 3) + C(5, 2) + C(4, 1)。

那如果D=1001110000,那就会少了一个,就是D本身,所以在最后处理一下,看D是否刚好符合要求就OK了。

如果D=1111呢,那么也是在最后处理一下看D是否刚好符合要求就OK了。

至此就是完整的解题思路。

你可能感兴趣的:(IM)