Hdu 5187 zhx's contest【思维+快速幂+快速乘】

zhx's contest

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2524    Accepted Submission(s): 778

Problem Description

As one of the most powerful brushes, zhx is required to give his juniors  n  problems.
zhx thinks the  ith  problem's difficulty is  i . He wants to arrange these problems in a beautiful way.
zhx defines a sequence  {ai}  beautiful if there is an  i  that matches two rules below:
1:  a1..ai  are monotone decreasing or monotone increasing.
2:  ai..an  are monotone decreasing or monotone increasing.
He wants you to tell him that how many permutations of problems are there if the sequence of the problems' difficulty is beautiful.
zhx knows that the answer may be very huge, and you only need to tell him the answer module  p .

 

Input

Multiply test cases(less than  1000 ). Seek  EOF  as the end of the file.
For each case, there are two integers  n  and  p  separated by a space in a line. ( 1≤n,p≤1018 )

 

Output

For each test case, output a single line indicating the answer.

 

Sample Input

  
  

   
   2 233
3 5
  
  

 

Sample Output

  
  

   
   2
1


   
   

    
    

     
     Hint
    
    
In the first case, both sequence {1, 2} and {2, 1} are legal.
In the second case, sequence {1, 2, 3}, {1, 3, 2}, {2, 1, 3}, {2, 3, 1}, {3, 1, 2}, {3, 2, 1} are legal, so the answer is 6 mod 5 = 1
   
   
   
    
  
  

 

Source

BestCoder Round #33

 

题目大意：

给你N个数的全排列，让你随意规定序列的数字位子，使得序列必须为单调递增或者单调递减，亦或者是先单调递增在单调递减，再或者是先单调递减再单调递增的。

问你一共有多少个合法序列。

思路：

1、分两种情况讨论：

①先单调递减，在单调递增，那么最低点的数字一定是1，那么其左侧的数字我们可以通过2^(n-1)枚举得到，那么在左侧的数字按照从大到小排序，右侧的数字按照从小到大排序排列即可，那么答案数就是2^(n-1)；

②先单调递增，再单调递减，那么最高点的数字一定是n，那么同理，2^(n-1)枚举其左侧的数据，那么答案数也是2^(n-1)；

2、那么两种情况分别有两个重复情况，去掉即可，那么ans=（2^n-2+mod）%mod

因为数据范围比较大，两个long long int的数据相乘会爆掉，所以这里再运用快速乘就可以避免爆掉的情况。

Ac代码：

#include<stdio.h>
#include<string.h>
using namespace std;
#define ll __int64
ll kuaisucheng(ll a,ll b,ll mod)
{
    ll ans=0;
    while(b)
    {
        if(b&1)
        {
            ans=(ans+a);
            if(ans>=mod)ans-=mod;
        }
        a=(a+a);
        if(a>=mod)a-=mod;
        b/=2;
    }
    return ans;
}
ll kuaisumi(ll a,ll b,ll mod)
{
        a%=mod;
        ll ans=1;
        while(b)
        {
            if(b&1)
            {
                ans=kuaisucheng(ans,a,mod);
            }
            a=kuaisucheng(a,a,mod);
            b/=2;
        }
        return ans;
}
int main()
{
    ll n,mod;
    while(~scanf("%I64d%I64d",&n,&mod))
    {
        printf("%I64d\n",(kuaisumi(2,n,mod)-2+mod)%mod);
    }
}