BZOJ3329 Xorequ（数位dp+矩阵快速幂）

Description

Input

第一行一个正整数，表示数据组数据 ，接下来T行
每行一个正整数N

Output

2*T行
第2*i-1行表示第i个数据中问题一的解，

第2*i行表示第i个数据中问题二的解，

Sample Input

1
1

Sample Output

1
2

HINT

x=1与x=2都是原方程的根，注意第一个问题的解
不要mod 10^9+7

1<=N<=10^18

1<=T<=1000

这在BZOJ上是一道权限题，但是一道很不错的题，这里拿来讲一下

对于题意中的 x ^ 3x == 2x 可以等价于 x ^ 2x == 3x

那么 3x = x + 2x

所以我们就需要找出 x ^ 2x == x + 2x的数字个数

因为 a + b == （a ^ b） + （a & b） << 1这个大家手动模拟一下就发现是很明显的

那么我们就知道 (x & 2x) == 0 才能满足原来条件，那么意思就是 x 在二进制下不能有相邻的 1

对于 subtask1 我们就可以直接数位dp了

对于 subtask2 我们打表找规律可得 答案就是斐波那契数列的第 （n + 2） 项，那么我们就可以用矩阵快速幂快速算出答案了

详情见AC代码：

/*************************************************************************
	 > Author: wzw-cnyali
	 > Created Time: 2017/9/12 20:26:07
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>

#prag\
ma GCC optimize("O3")

using namespace std;

typedef long long LL;

typedef unsigned long long uLL;

#define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)
#define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)
#define mem(a, b) memset((a), b, sizeof(a))

template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }

template <class T>
T read(T sum = 0, T fg = 0)
{
	char c = getchar();
	while(c < '0' || c > '9') { fg |= c == '-'; c = getchar(); }
	while(c >= '0' && c <= '9') { sum = sum * 10 + c - '0'; c = getchar(); }
	return fg ? -sum : sum;
}

const LL mod = 1e9 + 7;

const int Size = 70;

int a[Size], len;

LL dp[Size][12];

LL dfs(int pos, int pre, int lim)
{
	if(pos == -1) return 1;
	if(!lim && dp[pos][pre] != -1) return dp[pos][pre];
	LL res = 0;
	REP(i, 0, lim ? a[pos] : 1)
	{
		if(pre == 1 && i == 1) continue;
		res += dfs(pos - 1, i, lim && i == a[pos]);
	}
	if(!lim) dp[pos][pre] = res;
	return res;
}

LL solve1(LL x)
{
	len = 0;
	do { a[len++] = x % 2; x /= 2; }while(x);
	return dfs(len - 1, 11, 1) - 1;
}

struct Matrix
{
	LL matrix[5][5];
	int lenx, leny;

	Matrix(int a = 0)
	{
		lenx = 2; leny = 2;
		if(a == 0) matrix[1][1] = matrix[1][2] = matrix[2][1] = matrix[2][2] = 0;
		else
		{
			matrix[1][1] = matrix[1][2] = matrix[2][1] = 1;
			matrix[2][2] = 0;
		}
	}

	void base()
	{
		matrix[1][1] = matrix[2][2] = 1;
		matrix[1][2] = matrix[2][1] = 0;
	}

	friend Matrix operator * (Matrix a, Matrix b)
	{
		Matrix res;
		res.lenx = a.lenx; res.leny = b.leny;
		REP(i, 1, res.lenx) REP(j, 1, res.leny) REP(k, 1, res.leny)
			(res.matrix[i][j] += (a.matrix[i][k] * b.matrix[k][j]) % mod) %= mod;
		return res;
	}
};

Matrix qpow(Matrix a, LL N)
{
	Matrix ans; ans.base();
	while(N)
	{
		if(N & 1LL) ans = ans * a;
		a = a * a;
		N >>= 1LL;
	}
	return ans;
}

LL solve2(LL x)
{
	Matrix a = 1, b;
	Matrix ans = qpow(a, x + 1);
	b.lenx = 2; b.leny = 1;
	b.matrix[1][1] = b.matrix[1][2] = 1;
	ans = ans * b;
	return ans.matrix[1][1];
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
	freopen("output.out", "w", stdout);
#endif
	mem(dp, -1);
	int Case = read<int>();
	while(Case--)
	{
		LL x = read<LL>();
		printf("%lld\n", solve1(x));
		printf("%lld\n", solve2(x));
	}
	return 0;
}