Base
对于一个最常用的10进制的数字来说: 10234
如果我们需要得到他每一个位的数字,我们会熟练的写出下面这个代码:
while(a>0){ V.PB( a%10 ); a/=10; }
这个代码可以得到a这个数字,从低位到高位的每个数字
数字是介于[0, 9]之前的, 因为这是10进制的数字
' 这个看似很简单的代码,其实里面蕴含了很多的道理.... '
num = 1 0 2 3 4
bit = 4 3 2 1 0
问题1: 我们执行a/=10,这是在干嘛呢?
' 将a这个数字,的最低位bit,“消失掉”!! '
注意,“消失掉”一词 要着重理解!!
他和( st >>= 1 )是一个道理
st = a b c ->(消失掉)-> st = a b
问题2: 对于某一bit位,他上面的数字 代表着什么呢??
比如对于bit[4] = 3, 他代表 30000
而这个30000: <0的个数,取决于bit是第几位>
根据当前的bit,你可以得到一个poww(比如bit=4,则poww=10^4)
' 这个poww的含义是: 这个bit位上的数字,+1 / -1所带来的收益 '
当前bit=4位上的数字 从3变成4,自然这个数字 就会增大poww=10^4
' 这两个问题,在10进制下 很容易理解,但 却是很重要的原理!! '
比如对于k进制,(k=3)
k=3进制的数字: 000, 001, 002, 010, 011, 012, 020, 021, 022
hash映射后: 0, 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8
我们发现,对于任何k进制的数字,他都可以进行(hash映射)后
得到一个' 10进制 '的数字,可以用来唯一的标识这个k进制的数字
' 且,这是一个(有序hash)的过程 '
即,hash后对应的10进制数字的大小关系 和 原k进制数字的大小关系,是一致的
当然,这个(hash后的10进制数字),就是这个k进制对应的10数字
之所以引入hash这个概念,是为了下面说明 k进制问题在算法方面应用
我们看任何一个k=3进制的数字0000022,假如我们要对他记录一个val值
即 mp[ 0000022 ] = xx_val 这件事情。
1, 用string/VE<int>来存0000022, 这显然效率不行
2, 直接用int来存0000022(即直接对应int=22这个数字)
这当然是可行的(前提是你这个k进制的数字,要<= int/LL)
' 但是: 如果是dp问题,你用数组肯定是存不了的 '
' 而且, 如果涉及到(加减法操作),比如: 00022 + 1 = 00100 '
' 你这种方法,的时间, 并不是O(1)的 '
当然,如果不涉及加减法 只是map记录,这种方式是可以的
但通常我们并不这样使用,比如对于常用的二进制来说
我们要存入:mp[10001101...(共22)位] = xx
用这种方式的话, (10^22)是比LL还要大的。
而,这个数字 对应的10进制, 不过才10^6左右。
3, 有序hash
k=3进制的数字: 000, 001, 002, 010, 011, 012, 020, 021, 022
hash映射后: 0, 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8
' 即00022这个3进制数字,并不用(int=22)来映射,而是用(int=8)来映射 '
1, 从k进制 获取 hash
k进制数字 = [a, b, c]
hash = a * k^2 + b * k + c
2, 从hash 获取 k进制
while(hash > 0){ V.PB( hash % k ); hash /= k; }
我们来比较下,这种方式 和 上面的2方式,有哪些优劣。
1, hash 和 k进制,之间的互转, 时间是一样的,都是O(n) {n为k进制数字的长度}
2, ' 当涉及到 加减操作时, 两者就不同了 '
因为我们平时存储的/操作的 对象,并不是这个k进制,而是这个hash值
假如说,我们要进行: += sub 的操作。
I: 2方式的时间是O(n)的 (而且很复杂,你需要从低位开始,模拟加减法运算规则)
II: 但这种方式,时间是O(1)的: 直接hash += sub即可!!!
非常简单!!!
' 这其实就是: 状压dp问题。 (状压dp不一定是2进制,也可以是k进制) '
最优秀的办法,就是使用3方式(即用该k进制对应的10进制数字,来hash)
比如对于一个k=3进制的问题(一般都是 状压dp问题) n = 4,即[] [] [] []
从[0,0,0,0] 到 [2,2,2,2] (ma = 2 + 2*3 + 2*3*3 + 2*3*3*3 = 80)
即对应dp为[80][xx]
for(st = 0; st <= 80; ++st){
int temp = st;
FOR(i, 0, 3, 1){
int cur_bit = temp % 3; ' 得到st对应的k进制的每一位 '
temp /= 3; ' cur_bit也可以通过: st / poww[i] % 3 来获取 '
for(xx){
int pre_st = st - (cur_bit * poww[i]);
}
}
}
特殊进制(重要!)
但如果对于一个“特殊进制”问题,即他不是k进制,但和进制又非常类似
首先,我们回顾k进制问题, st = [] [] [] [], 其中每一个[] 都是介于[0, k-1]之间的
' 也就是: 我给你一个(数组):[] [] [] ...,其中的每个[] 都是介于[0, k-1] '
' 这便是: k进制的一个数!!! '
' 注意,其中每个[] 都是[0, k-1]之间的,不是[0,9],此时和10进制没有任何关系!!! '
' 这是对所有数字的统一规范的表达!! '
' 比如对于16进制,即是: [0-16] [0-16] .. [0-16] '
' 只不过由于占位问题, 把10-16,用了字母来表示 '
但假如我给你一个(数组): [0-x] [0-y] [0-z]
' xyz各不相同(如果相同,就变成了k进制问题) '
比如是: [0-2] [0-3] (假如右侧是低位)
这个(特殊进制数组): [0,0] [0,1] [0,2] [1,0] [1,1] [1,2]
hash(其实就是对应的10进制数): 0 1 2 3 4 5
' 可以看到: 他和普通的k进制问题,其实是完全一样的 '
只不过,k进制是: 每一位都是逢k就进位, 而这里是: 每一位也是逢k进位 但不同的bit 其k值不同
比如以: [0-2] [0-3] [0-4] ([0-4]的意思是: 逢5进位)
poww: 12 4 1 'poww的意思是: 当前位+1,能带来多少收益 '
(他一共有3*4*5个数, 所对应的10进制 即hash值为[0, ..., 3*4*5 - 1]之间)
for(st, 0, 3*4*5 - 1, 1){
for(i, 0, 2, 1){
int cur_bit = st / poww[i] % ma[i]; ' ma[i]就对应k进制中的k,这里是3/4/5 '
} ' 当st=3*4*5 - 1时,得到的cur_bit为: [2, 3, 4] '
}
此时有个非常重要的问题: (xyz是可以为0的!!!)
比如: [0-3] [0-2] [0-0] (ma分别为:[4, 3, 1])
[0,0,0] [0,1,0] [0,2,0] [1,0,0] [1,1,0] [1,2,0]
' 即ma是可以为1的, 此时最后一位 始终为0。 相当于k=1进制的数,始终为0 '
比如对于st=1,你可能会认为他是冲突的(因为ma[0]=1,而st=1是否需要进位呢? )
比如: [0-1] [0-0] [0-0] [0-0], poww = [1, 1, 1, 1], ma = [2, 1, 1, 1]
原数: [0,0,0,0] [1,0,0,0]
st: 0 1
' 即,st=1 并不是说,他和ma[0/1/2]=1冲突,从而导致进位 '
' 甚至你可能会想, st=3 此时> ma[0/1/2]=1,这是什么情况呢? '
' 按说,不是逢k进位,这里st>=k 是什么情况呢? '
这些都是错误的想法。 st是个10进制的数,他和原数[][][] 只是一个对应映射的关系
当然,也可以理解为: st=3 -> 对应为: [0,0,0] + 3
常用的应用场景是: 状压dp
n为数的长度[0][1]...[n-1],每个数比如[1] 他有个范围比如是[0-3],则ma[1]=4(即逢4进位)
int ma_num = 1;
FOR(i, 0, n-1, 1){
ma_num *= ma[i]; ' 注意,ma[i]可以为1!!! 即该bit位 始终为0 '
if(i == 0) poww[i] = 1;
else poww[i] = poww[i-1] * ma[i-1]; ' 注意,是ma[i - 1],不是ma[i] '
} ' poww[i]表示: i这个bit位,上的数字,+1,可以带来poww[i]的收益 '
-- ma_num; ' 即所有状态是: [0, 1, ..., ma_num]
int dp[ma_num][xx]; 'ma_num 即为状压dp的状态'
for(st, 0, ma_num, 1){ ' st就表示了一个: 长为n的 (特殊进制)的数字 '
' 比如st对应的数组是: [2, 0, 1], 则pre_st对应的数组为:[1,0,1] [2,0,0] '
' 我们的任务是: 找到这2个pre_st。 即遍历所有的bit位,枚举这位数字-=1,其他位不变 '
FOR(i, 0, n-1, 1){
int cur_bit = st / poww[i] % ma[i];
if(cur_bit > 0){ ' 当前位>0,才可以-=1 '
int pre_st = st - poww[i];
FOR(xx){
MAX( dp[st][xx], dp[pre_st][xx] );
}
}
}
}