Take notes fast learning

background:

Today, I have found fast ride $\Theta(1)$ approach.

Topic:

The solution is to ride fast $x*y \mod p$ issues.
sometimes $x,y,p$ particularly large,

$\Theta(\log n)$：

principle:
$y≡0(\mod2):x*y \mod p=2*x*\frac{y}{2}\mod p$
$y≡1(\mod2):x*y \mod p=(2*x*\lfloor\frac{y}{2}\rfloor+y)\mod p$
written recursive or recursive form, in which each position can be $\mod p$ can be.
note: $a \mod b$ results from the symbol $a$ determination, therefore $x*y\mod p$ result from the symbol $x * y$ OK.

#include<cstdio>
#include<cstring>
#include<algorithm>
#define LL long long
using namespace std;
	LL x,y,mod;
LL dg(LL x,LL y,LL mod)
{
	if(y==1) return x;
	LL op=dg(x,y>>1,mod);
	if(y&1) return (op*2%mod+x)%mod; else return op*2%mod;
}
int main()
{
	scanf("%lld %lld %lld",&x,&y,&mod);
	int op=((x<0&&y>0)||(x>0&&y<0));
	printf("%lld\n",(op?-1ll:1ll)*dg(abs(x),abs(y),abs(mod)));
}

$\Theta(1)$ :

principle:
$x*y\mod p=(x*y-\lfloor\frac{x*y}{p}\rfloor*p)\mod p$
At this point, our process with the amount $\text{long double}$ to store can be.
note: $a \mod b$ results from the symbol $a$ determination, therefore $x*y\mod p$ result from the symbol $x * y$ OK.

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
typedef long double LD;
	LL x,y,mod;
LL times(LL x,LL y,LL mod)
{
	LD t=LD(x)*LD(y)-LL(LD(x)*LD(y)/LD(mod))*LD(mod);
	LL tt=(LL)t;
	return tt>=0?tt%mod:(tt+mod)%mod;
}
int main()
{
	scanf("%lld %lld %lld",&x,&y,&mod);
	int op=((x<0&&y>0)||(x>0&&y<0));
	printf("%lld\n",(op?-1ll:1ll)*times(abs(x),abs(y),abs(mod)));
}