UVa12169 - Disgruntled Judge(模运算)

如果知道了a,就能算出x2,根据x3=(ax2+b)mod10001算出b。

然后可在O(T)时间内计算出整个序列。

如果在计算中发现和输入矛盾,则a非法,因为a是0~10000的整数,即使枚举所有a,时间效率也足够高。

枚举a,利用x1,x3求出b,判断所有x的关系能不能满足a,b。

如何通过a,x1,x3求出b呢。

x2 = (a * x1 + b) % 10001;

x3 = (a * x2 + b) % 10001;

联立2个式子

x3 = (a * (a * x1 + b) % 10001 + b ) % 10001;

x3 = (a * (a * x1 + b) + b) % 10001;

所以 x3 + 10001 * k = a * a * x1 + (a + 1) * b;

x3 - a * a * x1 = (a + 1) * b + 10001 * (-k);

这样就成了求 b 和 -k,满足这个式子,不就是扩展欧几里得的一般用法么?

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<list>
#include<string>
#include<cmath>
#include<sstream>
#include<ctime>
using namespace std;
#define _PI acos(-1.0)
#define INF 1 << 10
#define esp 1e-6
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> pill;

#define MAXD 200 + 10
#define max_size 10001
void gcd(LL a,LL b,LL &d,LL &x,LL &y){
    if(!b){
        d=a;
        x=1;y=0;
        return;
    }
    else {
        gcd(b, a%b, d, y, x);
        y -= x * (a/b);
        return ;
    }
}
int main()
{
    LL a,b,x[MAXD];
    int T;
    scanf("%d",&T);
    for(int i=1;i<2*T;i+=2)
        scanf("%lld",&x[i]);
    for(a=0;;a++){
        LL k, b, d;
        LL t = (x[3]-a*a*x[1]);
        gcd(max_size, a+1, d, k, b);
        if(t % d) continue;
        b = b * t / d;
        int yes = 1;
        for(int i=2;i<=2*T;i++){
            if(i&1){
                if(x[i]!=((a*x[i-1]+b)%max_size)){
                    yes=0;
                    break;
                }
            }
            else {
                x[i]=(a*x[i-1]+b)%max_size;
            }
        }
        if(yes)
            break;
    }
    for(int i=2;i<=2*T;i+=2)
        printf("%lld\n",x[i]);
    return 0;
}

时间: 2024-10-16 10:54:47

UVa12169 - Disgruntled Judge(模运算)的相关文章

UVa12169 Disgruntled Judge

x2 = (a * x1 + b) % 10001;x3 = (a * x2 + b) % 10001; ∴x3 = (a * (a * x1 + b) % 10001 + b ) % 10001; ∴(a + 1) * b + 10001 * (-k) = x3 - a * a * x1 由于a的范围是1~10000,所以可以枚举a,解出b,暴力判断这组a和b能否适用于所有的x 1 /*by SilverN*/ 2 #include<iostream> 3 #include<algor

小手记之与运算代替模运算

等式 先抛出一个等式, X & (2n?1) == X % 2n 右边式子,也就是模运算,最后的结果为[0, 2n?1],而左边的式子,也就是与运算,可以将X的高位清掉,最后剩下的是X的[0, n)位上面的数值,这个值当然也是∈[0, 2n?1],所以左右两边是相等的. 对比 模运算经常用来做哈希,利用上面的等式,我们完全可以使用与运算来代替模运算, 好处,与运算要比模运算来得快: 限制,模数必须是2的次幂: 参考资料 http://ifeve.com/dissecting-disruptor-

HDOJ 2769 Disgruntled Judge 扩展GCD

扩展GCD: 枚举a,扩展GCD求b,再暴力检查 Disgruntled Judge Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 329    Accepted Submission(s): 142 Problem Description Once upon a time, there was an nwerc judge with

Numpy 基本除法运算和模运算

基本算术运算符+.-和*隐式关联着通用函数add.subtract和multiply 在数组的除法运算中涉及三个通用函数divide.true_divide和floor_division,以及两个对应的运算符/和// 1. 数组的除法运算 import numpy as np # divide函数在整数和浮点数除法中均只保留整数部分(python3中的np.divide == np.true_divide) a = np.array([2,6,5]) b = np.array([1,2,3])

mysql中的优化, 简单的说了一下垂直分表, 水平分表(有几种模运算),读写分离.

一.mysql中的优化 where语句的优化 1.尽量避免在 where 子句中对字段进行表达式操作select id from uinfo_jifen where jifen/60 > 10000;优化后:Select id from uinfo_jifen where jifen>600000; 2.应尽量避免在where子句中对字段进行函数操作,这将导致mysql放弃使用索引 select uid from imid where datediff(create_time,'2011-11

大整数取模运算出现运算结果负数的解决方案

首先我们看个例子 <?php echo 12121212121 % 1000000; //结果为 -689767 //实际应该为12121 ?> 这里的取模运算(取余数)出现了BUG.那么需要声明一下,负数也是可以取模操作的,并不是出现负数就是不对的我们应该把这种长整数类型看成float型数据进行处理介绍一个函数float fmod ( float $x , float $y )返回除法的浮点数余数通过这个函数的运算,就可以得到原本想要的余数结果 <?php $a = floatval(

模运算%的结果符号

代码: #include <stdio.h> #include <stdlib.h> void display(int, int); int main(void) { // 模运算的结果取决于第一个操作数的符号 // 如果第一个操作数是正数,得到的模也是正数 // 如果第一个操作数是负数,得到的模也是负数 // a % b = a - [a / b] * b // [x]表示对数x趋零取整 // C99中,对整数除法规定趋零截尾 int a, b; a = 9; b = 5; di

取模运算

脑子不好使,老是记不住(?_?),备忘一下. 模运算与基本四则运算有些相似,但是除法例外.其规则如下: (a + b) % p = (a % p + b % p) % p (a - b) % p = (a % p - b % p) % p (a * b) % p = (a % p * b % p) % p a ^ b % p = ((a % p)^b) % p 结合律: ((a+b) % p + c) % p = (a + (b+c) % p) % p ((a*b) % p * c)% p =

10亿次的比较--PHP”与“运算和”模“运算效率比较

在涉及到计算数字的奇偶是,一般都用到"与"运算和"模运算",那么这两种运算用PHP语言来实现的话,哪个更快呢?在比较前,我是倾向于前者的.但结果却让我很诧异.代码如下: "与"运算: <?php set_time_limit(0); $i = 1; $t1 = microtime(true); while($i < 1000000001){ $i ++ & 1; } $t2 = microtime(true); echo $t