D. GukiZ and Binary Operations（矩阵+二进制）

D. GukiZ and Binary Operations

 

We all know that GukiZ often plays with arrays.

Now he is thinking about this problem: how many arrays a, of length n, with non-negative elements strictly less then 2l meet the following condition: ? Here operation  means bitwise AND (in Pascal it is equivalent to and, in C/C++/Java/Python it is equivalent to &), operation  means bitwise OR (in Pascal it is equivalent to , inC/C++/Java/Python it is equivalent to |).

Because the answer can be quite large, calculate it modulo m. This time GukiZ hasn't come up with solution, and needs you to help him!

Input

First and the only line of input contains four integers n, k, l, m (2 ≤ n ≤ 1018, 0 ≤ k ≤ 1018, 0 ≤ l ≤ 64, 1 ≤ m ≤ 109 + 7).

Output

In the single line print the number of arrays satisfying the condition above modulo m.

Sample test(s)

input

2 1 2 10

output

3

input

2 1 1 3

output

1

input

3 3 2 10

output

9

Note

In the first sample, satisfying arrays are {1, 1}, {3, 1}, {1, 3}.

In the second sample, only satisfying array is {1, 1}.

In the third sample, satisfying arrays are{0, 3, 3}, {1, 3, 2}, {1, 3, 3}, {2, 3, 1}, {2, 3, 3}, {3, 3, 0}, {3, 3, 1}, {3, 3, 2}, {3, 3, 3}.

 

 

 

题意：你可以任意挑选小于2^l的n个数，让它们以这个公式，两两取与再取或的方式最后答案为k，问你有多少种方案数，答案取余m

思路：这题看了别人的题解之后终于明白了。首先，我们把k转换为二进制来看，若某一位为1，则必须存在n个数中至少有相邻的两个数那一位都为1，若某一位为0，组必须存在n个数它们不能有相邻的两个数那一位都为1.这样我们相当于求k每一位在n个数字中的方案数，答案是每一位的方案数相乘起来。

注意l=64的时候，要特别注意一下

 

我用了无符号的long long 各种错。。。最后还是long long 过的。

不知道是不是我编译器坏了。

转载请注明出处：寻找&星空の孩子

题目链接：http://codeforces.com/contest/551/problem/D

 

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define LL  long long
using namespace std;//unsigned
struct matrix
{
    LL mat[2][2];
};
LL mod;

matrix multiply(matrix a,matrix b)
{
    matrix c;
    memset(c.mat,0,sizeof(c.mat));
    for(int i=0;i<2;i++)
    {
        for(int j=0;j<2;j++)
        {
            if(a.mat[i][j]==0)continue;
            for(int k=0;k<2;k++)
            {
                if(b.mat[j][k]==0)continue;
                c.mat[i][k]+=a.mat[i][j]*b.mat[j][k]%mod;
  //              c.mat[i][k]%=mod;
                if(c.mat[i][k]>mod) c.mat[i][k]-=mod;
                else if(c.mat[i][k]<0) c.mat[i][k]+=mod;
            }
        }
    }
    return c;
}

matrix quicklymod(matrix a,LL n)
{
    matrix res;
    memset(res.mat,0,sizeof(res.mat));
    for(int i=0;i<2;i++) res.mat[i][i]=1;
    while(n)
    {
        if(n&1)
            res=multiply(a,res);
        a=multiply(a,a);
        n>>=1;
    }
    return res;
}

LL ppow(LL a,LL b)
{
    LL c=1;
    while(b)
    {
        if(b&1) c=c*a%mod;
        b>>=1;
        a=a*a%mod;
    }
    return c;
}


int main()
{
    LL n,k,l,m;
    scanf("%I64d%I64d%I64d%I64d",&n,&k,&l,&mod);
    if(l!=64&&k>=(unsigned long long )(1ULL<<l)){printf("0\n");return 0;}
    matrix ans;
    ans.mat[0][0]=1;ans.mat[0][1]=1;
    ans.mat[1][0]=1;ans.mat[1][1]=0;
    ans=quicklymod(ans,n);
    //相邻没有连续两个1
    LL x=(ans.mat[0][0]+ans.mat[0][1])%mod;
    //至少有一个连续两个1
    LL y=((ppow(2,n)-x)%mod+mod)%mod;
 //  printf("x=%I64d\ty=%I64d\n",x,y);
    LL sum=1;
    for(LL i=0;i<l;i++)
    {
        if(k&(1LL<<i)) sum=(sum*y)%mod;
        else sum=sum*x%mod;
    }
    printf("%I64d\n",sum%mod);
    return 0;
}

 

 

 

别人的 无符号过的。。。

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
typedef unsigned long long LL;
LL N,K,L,MOD;
struct Matrix
{
    LL mat[2][2];
    Matrix(){memset(mat,0,sizeof(mat));}
    Matrix operator*(Matrix A)
    {
        Matrix res;
        for(int i=0;i<2;i++)
            for(int j=0;j<2;j++)
                for(int k=0;k<2;k++)
                res.mat[i][j]=(res.mat[i][j]+mat[i][k]*A.mat[j][k]%MOD)%MOD;
        return res;
    }
};
LL pow_mul(LL x,LL n)
{
    LL res=1;
    while(n)
    {
        if(n&1)res=(res*x)%MOD;
        x=(x*x)%MOD;
        n>>=1;
    }
    return res;
}
Matrix matrix_pow_mul(Matrix A,LL n)
{
    Matrix res;
    for(int i=0;i<2;i++)res.mat[i][i]=1;
    while(n)
    {
        if(n&1)res=res*A;
        A=A*A;
        n>>=1;
    }
    return res;
}
int main()
{
    while(cin>>N>>K>>L>>MOD)
    {
        if(L!=64&&K>=(1ULL<<L)){printf("0\n");continue;}
        Matrix A,B;
        A.mat[0][0]=A.mat[0][1]=A.mat[1][0]=1;
        A=matrix_pow_mul(A,N-2);
        B.mat[0][0]=3;
        B.mat[0][1]=2;
        A=A*B;
        LL ans=1;
        LL sum=pow_mul(2,N);
        for(LL i=0;i<L;i++)
        {
            if(K&(1LL<<i))ans=(ans*((sum-A.mat[0][0]+MOD)%MOD))%MOD;
            else ans=(ans*A.mat[0][0])%MOD;
        }
        cout<<ans%MOD<<endl;
    }
    return 0;
}

 

 

 

我用dp[i][j]表示有i个数，j表示最后一个数为0还是为1时满足没有相邻为1的方案数，因为n>=2，所以i只有大于2才有意义。首先dp[1][0]=1,dp[1][1]=1 , dp[2][0]=dp[1][0]+dp[1][1],dp[2][1]=dp[1][0] ………… 通项公式就是dp[n][0]=dp[n-1][0]+dp[n-1][1],dp[n][1]=dp[n-1][0] ，意思是当你长度为n最后一个数字为0时，你可以在长度为n-1最后一个数字为0或为1后面补0，这样不存在相邻为1的方案，若最后一位要为1，就只能在n-1最后一位为0的时候补1，这样才不会有相邻的1。最后你要计算的是all[n]=dp[n][0]+dp[n][1],其中dp[n][0]==all[n-1],dp[n][1]==dp[n-1][0]==all[n-2]，推出all[n]=all[n-1]+all[n-2]，这就是斐波那契数列。但这初始值有些不同，all[n] = fib[n+1] ，fib第0个元素跟第1个元素为1. 算出不相邻的方案之后，只要算出总的方案数2^n(每一位取0或取1)减去不相邻的方案，即为相邻的方案。你也可以用dp去推一下，我稍微提一下，我用c[n]表示长度为n时具有相邻1的方案数，c[2]=1 , c[3]=c[2]*2+dp[2][1]………… c[n]=c[n-1]*2+dp[n-1][1]=c[n-1]*2+all[n-3]这里的dp是上面求的不存在相邻的1，由于c[n-1]具有相邻的1所以下一位任意，dp[n-1][1]是长度为n-1最后一位为1，我们补1让它有相邻的1.
得出是斐波那契数列之后，我们可以用矩阵快速幂求解斐波那契数，也可以用矩阵快速幂求c
注意：这道题wa点挺多的，首先是unsigned long long在判断是否越界的时候用，还有快速幂的次数是long long，枚举l位时候，第63位已经暴了10^18，所以需要特判。最后输出结果要%mod，不然它有mod为1且l=0的样例