O(1)求解自然数异或和
序
又是一个不眠之夜。
求：
思路1：周期分析
\(O(logn)\)算法
考虑按位分析
对于\(f_i\)的第\(j\)位，它的值只与该位1出现次数有关。
而第\(j\)位1的出现又是呈周期性分布的。
我们考虑\(f_i=0 \bigoplus 1 \bigoplus 2 \bigoplus 3 \bigoplus...\bigoplus (i-1) \bigoplus i\)。
注意这里多加了一个0。
那么，在上式的各数中，第1位的变化为01010101
而第2位为00110011
第3位为00001111
以此类推。
周期分析
所以我们可以发现，第\(j\)位的值的出现是连续的，且每连续一组的相同值的个数为\(2^{j-1}\)，这恰好是第\(j\)位的位权！
而对于数字的总个数，我们可以用\(x=i+1\)来表示。
分析第\(j\)位的值\((j \ge 2)\)：
则第\(j\)位的出现的整组共有\(t=\lfloor{{x}\over{2^{j-1}}}\rfloor\)个，其中奇数组为0，偶数组为1，且其中出现数字1的总个数必定为偶数。
若\(t\)为奇数，说明剩余的不完整组的值为1，同时若\(x\)也为奇数，说明\(f_i\)的第\(j\)位为1；否则\(f_i\)的第\(j\)位为0。
由此，我们可以得到第\(j\)位的值\((j \ge 2)\)。
对于第1位，它出现的组共有\(x\)个，其中值为1的有\(\lfloor{{x}\over{2}}\rfloor\)个，故\(f_i\)的第1位等于\(x\)的第2位。
综上可以在\(O(logn)\)时间复杂度内求解。
\(O(1)\)算法
其实就是对\(O(logn)\)的算法作了一个小的总结。
分析第\(j\)位的值\((j \ge 2)\)：
我们知道，当且仅当\(t = \lfloor{{x}\over{2^{j-1}}}\rfloor\)为奇数，同时\(x\)也为奇数时，第\(j\)位才为1；否则第\(j\)位为0。
体现在\(x\)这个数本身上，就是当\(x\)第1位为1时，\(f_i\)的第2位及以上与\(x\)的相同。
而当\(x\)第1位为0时，\(f_i\)的第2位及以上都为0。
然后第1位的特判很好处理，就是\(f_i\)的第1位等于\(x\)的第2位。
由此可以在\(O(1)\)时间复杂度内求解。
代码实现
闲来无事写个代码（因为太菜所以不会更简单的写法）
int xorsum(int x)
{
++x;
return ( (x&1) ? (x&(INT_MAX-1)) : 0 ) | ( (x&2) ? 1 : 0 );
}
数据检验
顺便学了一下二进制输出的方法
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<bitset>
using namespace std;
int xorsum(int x)
{
++x;
return ( (x&1) ? (x&(INT_MAX-1)) : 0 ) | ( (x&2) ? 1 : 0 );
}
int main()
{
int n=10;
for(int i=1;i<=n;++i)
{
cout<<"number:"<<bitset<sizeof(i)*8>(i)<<'\n';
cout<<"xorsum:"<<bitset<sizeof(i)*8>(xorsum(i))<<'\n';
}
return 0;
}
输出如下：
思路2：数学化简
看了ltao思路和Limit给的正解，发现自己的做法实在是......太菜了。
一个很明显的劣势在于：我们的周期性分析是以\(x=i+1\)算出总数字个数再来分析性质的。
这样的转义分析最大的缺点就在于，性质推广，或者说移植的时候，会将定义转来转去，非常难以处理。
所以在这里再整理一下\(ltao\)的思路：
核心性质
定义\(g_{i,j}=i \bigoplus (i+1) \bigoplus ... \bigoplus j\)
有性质：\(g_{0,2^{k}-1} = g_{2^{k},2^{k+1}-1}(k \ge 1)\)，即右式第\(k+1\)位全部被异或消掉
将左右两式异或可得：\(g_{0,2^{k+1}-1} = g_{0,2^{k}-1} \bigoplus g_{2^{k},2^{k+1}-1} = 0\)
得到核心性质：\(g_{0,2^{k-1}-1} = 0（k \ge 3)\)，即可以用这个性质消掉函数中第\(k\)位为0的所有数，注意这个\(k\)的边界很重要！
\(O(logn)\)算法
有了这个性质，我们就可以很方便地对原式最高位进行化简，设所求函数\(g_{0,i}\)的\(i\)的最高位为\(k\)，有：
\(g_{0,i} = g_{0, 2^{k-1}-1} \bigoplus g_{2^{k-1},i} = g_{2^{k-1},i}\)
然后组成\(g_{2^{k-1},i}\) 的数的第\(k\)位都为1，且共有\(m = i - 2^{k-1} + 1\)个这样的数
这样就可以化简掉第\(k\)位：
若\(i\)为奇数，则\(m\)为偶数，结果的第\(k\)位必然为0，即\(g_{2^{k-1},i} = g_{0,i-2^{k-1}}\);
若\(i\)为偶数，则\(m\)为奇数，结果的第\(k\)位必然为1，即\(g_{2^{k-1},i} = g_{0,i-2^{k-1}} + 2^{k-1}\)。
递归处理，至\(k \le 2\)，达到了我们上面所说性质的边界以外，特判即可。
由此可以在\(O(logn)\)时间复杂度内求解。
\(O(1)\)算法
然后再对这个算法作一个小的总结：
我们可以发现上式的\(g_{0,i}-> g_{0,i-2^{k-1}}\)的过程当中，\(i\)的奇偶性始终不变。
因此只需一次分析起始状态\(g_{0,i}\)：
若\(i\)为奇数，则\(m\)为偶数，结果的第3位及以上都为0。
若\(i\)为偶数，则\(m\)为奇数，结果的第3位及以上与\(i\)的相同。
剩下两位特判即可。
由此可在\(O(1)\)时间复杂度内完成求解。
代码实现
int f[4]={0,1,3,0};
int xorsum(int x)
{
return ( (x&1) ? 0 : (x&(INT_MAX-3)) ) | f[x&3];
}
或者更直观的写法：
int xorsum(int x)
{
switch(x&3)
{
case 0:
return x;
case 1:
return 1;
case 2:
return x+1;
case 3:
return 0;
}
}
非常重要的一点在于，这种直接将x&3的值和xorsum的值对应的直观函数表示，能够有效地解决一些扩展问题，有兴趣的可见这道基于Limit's idea的水题。
