caso de respuesta
Puntuación total: 169 Ranking: NaN3
Tl:. T2 9: 100 T3: 60
Cada análisis sujeto
Tema 1:
Estimación del resultado: Puntuación 20 Actual: 9 exámenes: dos y treinta-03:00, 4:00 - 5:00
Inicio Sike T1, lanzó una hermosa pero relativamente poco uso de la fórmula.
Leer otras preguntas después de la primera visita de la violencia.
Tema 2:
100 exámenes :: estimado: 100 resultados de rendimiento real de 3:00 - 3:20
Título de la plantilla Fermat Teorema pequeña.
Antes de que haya contacto, hecho rápidamente.
Tema 3:
60 :: exámenes estimado: 100 resultados de rendimiento real de 3:30 - 3:50
Anteriormente hecho un bloque similares es divisible.
Sobre esta base, hemos añadido algunos cálculos.
Dado que el cálculo de la ráfaga perdida longlong 40 minutos.
- Lección: Tenga en cuenta que el rango de datos! Si el rango de datos más grande de tiempos de módulo recordar.
portada analítica
T1:
18 puntos:
la violencia de enumeración s, determinación de la violencia.
100:
jugando a la metafísica de mesa puede lanzar fórmula.
T2:
poca aplicación teorema de Fermat sencilla.
Índice de operación es exponencial grande, rápida no se puede realizar directamente.
Debido a que el módulo es primo, pequeño teorema de Fermat, se encuentran: \ (A ^ {P-1.} \ Equiv 1 \ PMOD P \.)
Entonces \ (a ^ {b ^ c } \ equiv a ^ {b ^ c \ % (p - 1)} \ pmod p \)
Y el número base del índice de potencia rápido puede tomar el relevo.
Complejidad \ (O (\ log k) \)
T3:
aplicaciones simples bloque divisible.
Para cualquier \ (D \) , (\. 1 \ n-SIM) \ en la que el número de veces de factor de ocurrencia \ (\ {n-dfrac} {D} \) .
Se puede encontrar en \ (\ dfrac {n} { d} \) en \ (D \) decrementa se incrementa.
La contribución de este factor a la respuesta es \ (\ lfloor \ {n-dfrac} {D} \ rfloor \ tiempo D ^ 2 \) .
Para \ (1 \ sim n \) cuadrada y tiene la fórmula: \ (\ {... N-dfrac (n- + 1) (2 N + 1) 6} {} \) .
Nota \ (f (i) = \ dfrac {i (i + 1) (i + 1)} {6} \)
Debido a \ (\ lfloor \ dfrac {n } {d} \ rfloor \) monótonamente decreciente, hay una gama continua de muchos valores.
Para el número de ocurrencias son \ (\ dfrac {n} { i} \) factor de \ (I \ J SIM \) ,
la contribución total de: . \ ((F (J) - F (1-I)) \ times \ lfloor \ dfrac {n} { i} \ rfloor \)
Obviamente la fórmula anterior puede ser resuelto mediante el bloqueo divisible.
Para cada bloque de \ (\ lfloor \ dfrac {n } {i} \ rfloor \) intervalo, que contribución es el \ ((f (j) - f (i-1)) \ times \ lfloor \ dfrac {n} {i} \ rfloor \)
Para tomar notas en cualquier momento
la implementación del código
T1:
Sala de reconocimiento Código
//
/*
By:Luckyblock
*/
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <algorithm>
#define ll long long
const int MARX = 110 + 10;
const int mod = 1e9 + 7;
//=============================================================
int N, K, Ans, f[MARX] = {1};
//=============================================================
inline int read()
{
int f = 1, w = 0; char ch = getchar();
for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
for(; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
return f * w;
}
//=============================================================
int main()
{
freopen("cute.in", "r", stdin);
freopen("cute.out", "w", stdout);
N = read(), K = read();
for(int i = 1; i <= N; i ++) f[i] = f[i - 1] * K;
for(int s = 1; s < f[N]; s ++)
{
int flag = 1;
for(int i = 1; i < N - 1; i ++)
if(s % f[i] * f[N - i] <= s)
{flag = 0; break;}
Ans += flag, Ans %= mod;
}
printf("%d", Ans);
return 0;
}
correcto
#include <iostream>
#include <algorithm>
using namespace std;
long long const P=1000000007,M=100000;
int m;
long long n,k,g[M],f[M];
bool isprime(long long x)
{
if (x==1) return false;
for (long long i=2;i*i<=x;i++)
if (x % i==0) return false;
return true;
}
long long comp(long long b,long long c,long long m)
{
long long ans=1;
long long l=b;
long long j=1;
while (j<=c)
{
if ((j & c)>0) ans=(ans*l) % m;
j*=2;
l=(l*l) % m;
}
return ans;
}
int main()
{
freopen("cute.in","r",stdin);
freopen("cute.out","w",stdout);
cin>>n>>k;
for (long long i=1;i*i<=n;i++)
if (n % i==0)
{
g[++m]=i;
if (i*i<n) g[++m]=n/i;
}
sort(g+1,g+m+1);
f[1]=k;
for (int i=2;i<=m;i++)
{
f[i]=comp(k,g[i],P);
for (int j=1;j<=i-1;j++)
if (g[i] % g[j]==0) f[i]=(f[i]+P-f[j]) % P;
}
printf("%lld\n",f[m]*comp(n,P-2,P) % P);
}
T2:
códigos de examen (solución positiva)
//
/*
By:Luckyblock
*/
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <algorithm>
#define ll long long
//=============================================================
ll a, b, c, p;
//=============================================================
inline ll read()
{
ll f = 1, w = 0; char ch = getchar();
for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
for(; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
return f * w;
}
ll qpow(ll x, ll y, ll mod)
{
ll ret = 1;
for(; y; x = x * x % mod, y >>= 1)
if(y & 1) ret = ret *x % mod;
return ret;
}
//=============================================================
int main()
{
freopen("number.in", "r", stdin);
freopen("number.out", "w", stdout);
a = read(), b = read(), c = read(), p = read();
ll x = qpow(b, c, p - 1);
printf("%lld", qpow(a, x, p));
return 0;
}
T3:
códigos de examen (solución positiva)
//
/*
By:Luckyblock
*/
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <algorithm>
#define ll long long
//=============================================================
ll N, Mod, ans, inv;
//=============================================================
inline ll read()
{
ll f = 1, w = 0; char ch = getchar();
for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
for(; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
return f * w;
}
ll qpow(ll x, ll y, ll mod)
{
ll ret = 1;
for(; y; x = x * x % mod, y >>= 1)
if(y & 1) ret = ret * x % mod;
return ret;
}
ll SquareSum(ll L, ll R)
{
ll suml = L * (L + 1) % Mod * (2 * L % Mod + 1) % Mod * inv % Mod;
ll sumr = R * (R + 1) % Mod * (2 * R % Mod + 1) % Mod * inv % Mod;
return (sumr - suml + Mod) % Mod;
}
//=============================================================
int main()
{
N = read(), Mod = read();
inv = qpow(6, Mod - 2, Mod);
for(ll i = 1, j; i <= N; i = j + 1)
{
j = N / (N / i);
ans = (ans + SquareSum((i - 1) % Mod , j % Mod) * (N / i) % Mod) % Mod;
}
printf("%lld\n", ans);
system("pause");
return 0;
}