Algo_进制原理、k进制、特殊进制

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] );
			}
		}
	}
}