uva 1374 快速幂计算

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <cctype>
#include <string>
#include <malloc.h>
#include <queue>
#include <map>

using namespace std;

const int INF = 0xffffff;
const double esp = 10e-8;
const double Pi = 4 * atan(1.0);
const int Maxn = 2000+10;
const long long mod =  2147483647;
const int dr[] = {1,0,-1,0,-1,1,-1,1};
const int dc[] = {0,1,0,-1,1,-1,-1,1};
typedef long long LL;

LL gac(LL a,LL b){
    return b?gac(b,a%b):a;
}

int n,ans[Maxn],maxd;
bool vis[Maxn];

int dfs(int step,int s){
    ans[step] = s;
    if(step == maxd){
        if(vis[n])
            return 1;
        return 0;
    }
    if(ans[step] > 2000 || s * 1 << (maxd-step) < n){
        return 0;
    }
    for(int i = 0;i<= step;i++){
        int t = s + ans[i];
        if(!vis[t]){
            vis[t] = 1;
            if(dfs(step+1,t))
                return 1;
            vis[t] = 0;
        }
        t = abs(s-ans[i]);
        if(t > 0 && !vis[t]){
            vis[t] = 1;
            if(dfs(step+1,t))
                return 1;
            vis[t] = 0;
        }
    }
    return 0;
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("inpt.txt","r",stdin);
#endif
    while(~scanf("%d",&n) && n){

        for(maxd = 0;;maxd++){
            memset(vis,0,sizeof(vis));
            vis[1] = 1;
            if(dfs(0,1)){
                printf("%d\n",maxd);
                break;
            }
        }
    }
    return 0;
}

时间: 2024-12-14 06:00:06

uva 1374 快速幂计算的相关文章

矩阵快速幂计算hdu1575

矩阵快速幂计算和整数快速幂计算相同.在计算A^7时,7的二进制为111,从而A^7=A^(1+2+4)=A*A^2*A^4.而A^2可以由A*A得到,A^4可以由A^2*A^2得到.计算两个n阶方阵的乘积复杂度为O(n^3).k的二进制大约有logk位,总的复杂度为O(n^3*logk). #define _CRT_SECURE_NO_DEPRECATE #include<iostream> #include<queue> #include<iomanip> #incl

快速幂计算(整数快速幂/矩阵快速幂)

库函数pow是用朴素算法对浮点型数据进行幂运算的,时间复杂度为o(n),计算比较大的数可能会超时和数据溢出: //*************快速幂计算**************************************** 朴素算法实现: ll get_pow(ll x, ll n)  //** (这里的n要求不小于0,如果n小于0则令n=-n,并且最终返回1.0/ans即可){    ll ans=1;    while(n--)    {        ans*=x%MAX;    

UVa 10006 快速幂运算

知识补充: 如果a和b关于m同于,那么(a - b )是m的整数倍. 负数取余运算:不同的语言有不同的方法,其中C和JAVA是按第一个数的符号确定结果的符号,C++则要依据系统而定. 取余运算的发展: 1.(a+b)%p=(a%p+b%p)%p 2.(a?b)%p=(a%p?b%p)%p 3.(a?b)%p=(a%p?b%p)%p 4.(ab)%p=((a%p)b)%p 费马定理:对于一个不能被p整除的数a: ap≡a mod p ap?1≡1 mod p 快速幂算法(求xn%mod): 有两种

UVa 11582 (快速幂取模) Colossal Fibonacci Numbers!

题意: 斐波那契数列f(0) = 0, f(1) = 1, f(n+2) = f(n+1) + f(n) (n ≥ 0) 输入a.b.n,求f(ab)%n 分析: 构造一个新数列F(i) = f(i) % n,则所求为F(ab) 如果新数列中相邻两项重复出现的话,则根据递推关系这个数列是循环的. 相邻两项所有可能组合最多就n2中,所以根据抽屉原理得到这个数列一定是循环的. 求出数列的周期,然后快速幂取模即可. 1 #include <cstdio> 2 #include <iostrea

Power Calculus 快速幂计算 (IDA*/打表)

原题:1374 - Power Calculus 题意: 求最少用几次乘法或除法,可以从x得到x^n.(每次只能从已经得到的数字里选择两个进行操作) 举例: x^31可以通过最少6次操作得到(5次乘,1次除) x^2 = x*x x^4 = (x^2)*(x^2) x^8 = (x^4)*(x^4) x^16 = (x^8)*(x^8) x^32 = (x^16)*(x^16) x^31 = (x^32)÷x 分析: 可以看到,每次从已得到的数字中选取两个操作,这样就有了枚举的思路. 这道题又是

UVa 1374 - Power Calculus——[迭代加深搜索、快速幂]

解题思路: 这是一道以快速幂计算为原理的题,实际上也属于求最短路径的题目类型.那么我们可以以当前求出的幂的集合为状态,采用IDA*方法即可求解.问题的关键在于如何剪枝效率更高.笔者采用的剪枝方法是: 1)如果当前状态幂集合中的最大元素max满足 max*2^(maxd-cur_d)<n,则剪枝.原因是:在每一次状态转移后,max最多增大一倍.(maxd-cur_d)次转移之后,max最多变成原来的2^(maxd-cur_d)倍,然而如果当前状态的极限情况下仍有max<n,则当前状态结点一定无法

uva 11651 - Krypton Number System(矩阵快速幂)

题目链接:uva 11651 - Krypton Number System 题目大意:给定进制base,和分数score,求在base进制下,有多少个数的值为score,要求不能有连续相同的数字以及前导0.计算一个数的值即为相邻两位数的平方差和. 解题思路:因为score很大,所以直接dp肯定超时,但是即使对于base=6的情况,每次新添一个数score最大增加25(0-5),所以用dp[i][j]预处理出base平方以内的总数,然后用矩阵快速幂计算. #include <cstdio> #

uva 10870(矩阵快速幂)

题意:计算f(n) f(n) = a1 f(n - 1) + a2 f(n - 2) + a3 f(n - 3) + - + ad f(n - d), for n > d. 题解:斐波那契的变形,把2个扩大成d个,然后加了a1-ad的参数,构造矩阵直接矩阵快速幂计算. #include <stdio.h> #include <string.h> const int N = 20; struct Mat { long long g[N][N]; }res, ori; long

UVa 11149 Power of Matrix (矩阵快速幂,倍增法或构造矩阵)

题意:求A + A^2 + A^3 + ... + A^m. 析:主要是两种方式,第一种是倍增法,把A + A^2 + A^3 + ... + A^m,拆成两部分,一部分是(E + A^(m/2))(A + A^2 + A^3 + ... + A^(m/2)),然后依次计算下去,就可以分解,logn的复杂度分解,注意要分奇偶. 另一种是直接构造矩阵,,然后就可以用辞阵快速幂计算了,注意要用分块矩阵的乘法. 代码如下: 倍增法: #pragma comment(linker, "/STACK:10