Campamento de vacaciones de invierno 1.20
Directorio de artículos
Una torta de cumpleaños
La idea principal del tema: divide las cerezas en el pastel por igual, no excéntrico
Idea: Todas las cerezas del pastel se consideran puntos, con coordenadas, el corte se considera una línea y el problema se convierte en un coeficiente para satisfacer que hay n puntos por encima de la línea y n puntos por debajo de la línea. No debe haber puntos en la línea.
El código principal:
for( i=-500;i<510;i++)
{
int num=0;
for( j=-500;j<500;j++)
{
int num=0;
if(i==0&&j==0)
continue;
for( k=0;k<2*n;k++)
{
if((i*p[k].x+j*p[k].y)>0)
num++;
if((i*p[k].x+j*p[k].y)==0)
break;
}
if(k==2*n&&num==n)
{
x=0;
break;
}
}
if(x==0)
break;
}
Código completo:
#include<iostream>
#include<stdio.h>
#include<cmath>
using namespace std;
struct note
{
int x,y;
}p[500];
int main()
{
int n,d,i=0,j,k;
while(scanf("%d",&n)&&n)
{
for( i=0;i<2*n;i++)
{
scanf("%d%d",&p[i].x,&p[i].y);
}
int x=1;
for( i=-500;i<510;i++)
{
int num=0;
for( j=-500;j<500;j++)
{
int num=0;
if(i==0&&j==0)
continue;
for( k=0;k<2*n;k++)
{
if((i*p[k].x+j*p[k].y)>0)
num++;
if((i*p[k].x+j*p[k].y)==0)
break;
}
if(k==2*n&&num==n)
{
x=0;
break;
}
}
if(x==0)
break;
}
printf("%d %d\n",i,j);
}
}
B - ¿Es esto una integración?
La idea principal del tema: encontrar el área de las tres partes sombreadas
Idea: Haga una línea auxiliar para encontrar la fórmula [La transferencia de la imagen del enlace externo falla, el sitio de origen puede tener un mecanismo anti-sanguijuelas, se recomienda guardar la imagen y cargarla directamente (img-YxvLoWOx-1611306381252) (C: \ Usuarios \ 29252 \ Imágenes \ título \ B1.png)]
Si lo hiciera yo mismo, nunca pensaría en hacer líneas auxiliares. . . Todavía tengo muy pocas preguntas y falta de experiencia. Es muy simple formular las preguntas de la fórmula y no puedo sacarlo. .
Código completo:
#include<iostream>
#include<cmath>
using namespace std;
double a;
#define PI acos(-1.0)
int main() {
while (cin >> a) {
printf("%.3f %.3f %.3f\n", a * a * (1 + PI / 3 - sqrt(3.0)),a * a * (PI / 3 + 2 * sqrt(3.0) - 4), a * a * (-2 * PI / 3 + 4 - sqrt(3.0)));
}
return 0;
}
C - División simple
La idea principal del tema: de acuerdo con la serie de datos dada, encuentre el número entero más grande, de modo que el resto de cada número entero dividido por el número sea el mismo
Idea: Si el resto de dividir dos números diferentes por un divisor es el mismo, la diferencia entre los dos números diferentes debe ser un múltiplo del divisor. (Realmente lo pensé al principio)
Usa la diferencia para enumerar el divisor. Entonces, primero encuentre la primera secuencia de diferencias de la secuencia original y luego encuentre el MCD de todos los elementos distintos de cero
El código principal:
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
while (true) {
n = 0;
ans = 0;
cin >> f[++n];
if (f[n] == 0)break;
while (f[n] != 0) cin >> f[++n];
n--;
for (int i = 1; i < n; ++i) {
f[i] = f[i] - f[i + 1];
}
Código completo:
#include<iostream>
#include<cmath>
using namespace std;
const int N = 1e6 + 10;
int f[N];
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
int main() {
int a, b,n,ans;
while (true) {
n = 0;
ans = 0;
cin >> f[++n];
if (f[n] == 0)break;
while (f[n] != 0) cin >> f[++n];
n--;
for (int i = 1; i < n; ++i) {
f[i] = f[i] - f[i + 1];
}
ans = f[1];
for (int i = 2; i < n; ++i) {
ans = gcd(f[i] == 0 ? ans : f[i], ans);
}
cout << fabs(ans) << endl;
}
return 0;
}
D - Problema de Euclides
Punto de conocimiento: expanda el algoritmo euclidiano
La idea principal del tema: a partir de los tiros y vueltas de Euclides, sabemos que para cualquier entero positivo A y B , existen tales números enteros X e Y , AX + BY = D , donde D es el máximo común divisor de A y SEGUNDO. Esta pregunta requiere que para A y B dados , encuentre los correspondientes X , Y y D
Idea: resuelva utilizando un algoritmo euclidiano extendido
El código principal:
int exgcd(int a, int b, int& x, int& y) {
if (b == 0) {
x = 1; y = 0;
return a;
}
int d = exgcd(b, a % b, x, y);
int tmp = x;
x = y;
y = tmp - (a / b) * y;
return d;
}
Código completo:
#include<iostream>
using namespace std;
int exgcd(int a, int b, int& x, int& y) {
if (b == 0) {
x = 1; y = 0;
return a;
}
int d = exgcd(b, a % b, x, y);
int tmp = x;
x = y;
y = tmp - (a / b) * y;
return d;
}
int main() {
int a, b;
while (cin >> a >> b) {
int x = 0, y = 0;
int d = exgcd(a, b, x, y);
cout << x << ' ' << y << ' ' << d << endl;
}
return 0;
}
E - Fracción muerta
Mike está luchando frenéticamente para terminar su tesis en el último minuto. Necesita reunir todas sus notas de investigación en una forma vagamente coherente en los próximos 3 días. Desafortunadamente, se da cuenta de que había sido extremadamente descuidado en sus cálculos. Siempre que necesitaba realizar operaciones aritméticas, simplemente la conectaba a una calculadora y anotaba la mayor parte de la respuesta que consideraba relevante. Siempre que se mostraba una fracción repetida, Mike simplemente grababa los primeros dígitos seguidos de "...". Por ejemplo, en lugar de "1/3", podría haber escrito "0.3333 ...". Desafortunadamente, ¡sus resultados requieren fracciones exactas! No tiene tiempo para rehacer todos los cálculos, por lo que necesita que escribas un programa (¡y RÁPIDO!) Para deducir automáticamente las fracciones originales.
Para hacer esto sostenible, asume que la fracción original es siempre la más simple que produce la secuencia de dígitos dada; por más simple, quiere decir el que tiene el denominador más pequeño. Además, supone que no se olvidó de escribir dígitos importantes; ningún dígito de la parte repetida de la expansión decimal se dejó sin registrar (incluso si esta parte repetida era todo ceros).
Entrada
Hay varios casos de prueba. Para cada caso de prueba hay una línea de entrada de la forma "0.dddd ..." donde dddd es una cadena de 1 a 9 dígitos, no todos cero. Una línea que contiene 0 sigue al último caso.
Salida
Para cada caso, genere la fracción original.
Entrada de muestra
0.2...
0.20...
0.474612399...
0
Salida de muestra
2/9
1/5
1186531/2500000
La idea principal del tema: convertir el decimal recurrente en una fracción. Si hay varias situaciones en la parte recurrente, conviértalo en la fracción con el denominador más pequeño.
Idea: Los números racionales se pueden escribir en forma de m / n, decimal de bucle infinito a fracción (0.xxxx) decimal parte n bits, parte del bucle un bit, parte no circular na bit
Numerador: n * 10 ^ n -n / 10 ^ a Denominador: (10 (a) -1) * (10 (na)) y luego reducido a la fracción más simple por mcd
Esta pregunta se centró en el código de Brother Run. Sólo entendió la idea después de hablar sobre ella. Cuando lo hizo, no sabía cómo convertir fracciones decimales y no encontró la regla ...
Código completo:
#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
typedef long long ll;
ll z[11]={1};
string s;
void pre(){
for(int i = 1;i<=10;++i)
z[i] = (z[i-1]<<3)+(z[i-1]<<1);
}
ll gcd(ll a,ll b){
ll c;
while(b){
c=a%b;
a=b;
b=c;
}
return a;
}
int main(){
pre();
while((cin>>s)&&s.size()>1){
ll num = 0;
ll b =0;
for(int i = 2;s[i]!='.';++i){
num = num*10+s[i]-'0';
b++;
}
ll minfz = -1;
ll minfm = -1;
ll fz,fm;
for(int i = 1;i<=b;++i){
fz = num-num/z[i];
fm = (z[i]-1)*z[b-i];
ll g = gcd(fz,fm);
if(fm/g < minfm||minfm==-1){
minfz = fz/g;
minfm = fm/g;
}
}
printf("%lld/%lld\n",minfz,minfm);
}
return 0;
}
F - ¿Qué es la probabilidad?
Idea principal: calcular la probabilidad de que el i-ésimo jugador gane en la k-ésima ronda
Idea: el i-ésimo jugador gana en la primera ronda, luego los i-1 jugadores antes del i-ésimo jugador no ganan, entonces la probabilidad de que el i-ésimo jugador gane en la primera ronda es (1-p) ^ (i-1) * p
De manera similar, el i-ésimo jugador gana en la k-ésima ronda, y la probabilidad de ganar es (1-p) ^ {n (k-1) + i-1} * p. Basado en el principio de suma y el fórmula de suma de secuencia geométrica, la primera La probabilidad de que i jugadores ganen es {(1-p) (i-1) * p} * (1 / (1- (1-p) n))
Código completo:
#include<iostream>
#include<cmath>
using namespace std;
int s, x, i;
double p;
double ans;
int main() {
cin >> s;
while (s--) {
cin >> x >> p >> i;
if(p==0) ans = 0;
else ans = pow(1 - p, i - 1) * p * (1.0 / (1 - pow(1 - p, x)));
printf("%.4f\n", ans);
}
return 0;
}
G - hamburguesa
La idea principal del tema: 20 personas asisten a la fiesta, entre ellos Ben y Bill, 10 hamburguesas de ternera, 10 hamburguesas con queso, lanzamiento de moneda, cabeza de moneda, la persona que arrojó come ternera, de lo contrario, se come queso. La pregunta le pide a Ben y Bill que coman Probabilidad de la misma hamburguesa
Idea: si preguntas positivamente, hay muchas situaciones, así que pregunta la probabilidad de que las dos personas coman hamburguesas diferentes.
Todavía soy un buen estudiante de último año y sé mucho sobre este tipo de problema recursivo. Cuando lo hice yo solo, era un poco inflexible al pensar. No esperaba pensar al revés.
El código principal:
#include<iostream>
using namespace std;
const int N = 1e6+6;
int s,n;
double p[N];
int main(){
cin>>s;
p[1] = 1;
for(int i = 1;i<1e6;++i)
p[i+1] = (2*i-1)*p[i]/(2*i);
while(s--){
cin>>n;
n = n/2;
printf("%.4f\n",1-p[n]);//反向思维
}
return 0;
}
H - Lanzamiento de monedas
En un juego de carnaval popular, se lanza una moneda a una mesa con un área cubierta con fichas cuadradas en una cuadrícula. Los premios están determinados por el número de fichas cubiertas por la moneda cuando se detiene: cuantas más fichas cubra, mejor será el premio. En el siguiente diagrama, se muestran los resultados de cinco lanzamientos de monedas:
En este ejemplo:
- moneda 1 cubre 1 ficha
- moneda 2 cubre 2 fichas
- la moneda 3 cubre 3 fichas
- moneda 4 cubre 4 fichas
- moneda 5 cubre 2 fichas
Observe que es aceptable que una moneda caiga en el límite del área de juego (moneda 5). Para que una moneda cubra una ficha, la moneda debe cubrir un área positiva de la ficha. En otras palabras, no basta con tocar el límite del mosaico. El centro de la moneda puede estar en cualquier punto del área de juego con probabilidad uniforme. Puede suponer que (1) la moneda siempre se detiene en posición horizontal y (2) el jugador es lo suficientemente bueno como para garantizar que el centro de la moneda siempre se posará en el área de juego (o en el límite).
La probabilidad de que una moneda cubra un cierto número de fichas depende del tamaño de la ficha y de la moneda, así como del número de filas y columnas de fichas en el área de juego. En este problema, se le pedirá que escriba un programa que calcule las probabilidades de que una moneda cubra un cierto número de fichas.
Entrada
La primera línea de entrada es un número entero que especifica el número de casos a seguir. Para cada caso, se le darán 4 números enteros m, n, t y c en una sola línea, separados por espacios. El área de juego consta de m filas yn columnas de baldosas, cada una de las cuales tiene una longitud lateral t. El diámetro de la moneda utilizada es c. Puede suponer que 1 <= m, n <= 5000 y 1 <= c <t <= 1000.
Salida
Para cada caso, imprima el número de caso en su propia línea. A esto le sigue la probabilidad de que una moneda cubra 1 ficha, 2 fichas, 3 fichas y 4 fichas cada una en su propia línea. La probabilidad debe expresarse como un porcentaje redondeado a 4 decimales. Utilice el formato especificado en la salida de muestra. Debe utilizar números de coma flotante de doble precisión para realizar los cálculos. Los “ceros negativos” deben imprimirse sin el signo negativo.
Separe la salida de casos consecutivos con una línea en blanco.
Entrada de muestra
3
5 5 10 3
7 4 25 20
10 10 10 4
Salida de muestra
Case 1:
Probability of covering 1 tile = 57.7600%
Probability of covering 2 tiles = 36.4800%
Probability of covering 3 tiles = 1.2361%
Probability of covering 4 tiles = 4.5239%
Case 2:
Probability of covering 1 tile = 12.5714%
Probability of covering 2 tiles = 46.2857%
Probability of covering 3 tiles = 8.8293%
Probability of covering 4 tiles = 32.3135%
Case 3:
Probability of covering 1 tile = 40.9600%
Probability of covering 2 tiles = 46.0800%
Probability of covering 3 tiles = 2.7812%
Probability of covering 4 tiles = 10.1788%
La idea principal del tema: lanzar una moneda y calcular la probabilidad de que la moneda ocupe 1, 2, 3 y 4 ladrillos respectivamente.
Idea: [Error en la transferencia de la imagen del enlace externo, el sitio de origen puede tener un mecanismo de enlace anti-sanguijuelas, se recomienda guardar la imagen y subirla directamente (img-CkxoULSM-1611306381261) (C: \ Users \ 29252 \ Pictures \ topic \ H.png)]
Es una pregunta de fórmula de derivación nuevamente. Antes de ver la explicación del maestro, realmente me sentía incapaz de comenzar. La pregunta se entendió y no pude calcular el área ocupada por las monedas.
El código principal:
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const double PI=acos(-1.0),eps=1e-8;
int main()
{
int x,cnt=0;
cin>>x;
while(x--){
double n,m,t,c,A[5];
scanf("%lf%lf%lf%lf",&n,&m,&t,&c);
A[0]=t*t*n*m;//棋盘面积
A[2] = c*(t-c)*(2*m*n-n-m)+c*(c/2.0)*(2*n+2*m-4);
A[4] = (m-1)*(n-1)*(PI*c*c)/4.0;
A[3] = (m-1)*(n-1)*c*c-(m-1)*(n-1)*(PI*c*c)/4.0;
A[1] = A[0]-A[2]-A[3]-A[4];
printf("Case %d:\n",++cnt);
for(int i=1;i<=4;i++)
printf("Probability of covering %d tile%s = %.4lf%%\n",i,(i==1)?" ":"s",A[i]/A[0]*100.0);
printf("\n");
}
return 0;
}
I - 498-bis
Idea principal:
Derivada basada en un polinomio dado
Idea: La parte difícil de esta pregunta es que no se proporciona el límite superior del número de entrada y no se puede guardar en una matriz. Usé la entrada de flujo antes y el resultado es correcto. Puede haber algunas partes que tienen No se ha tenido en cuenta. El envío es incorrecto. Las personas mayores utilizan la búsqueda recursiva. Regular. Después de leerlo, siento que soy demasiado comida. Recurrencia: A (i + 1) = A (i) * x + a1;
a0
a0x + a1;
(a0x + a1) x + a2 = a0x ^ 2 + a1x + derivación a2-> 2a1x + a1
(a0x ^ 2 + a1x + a2) x + a3 = a0x ^ 3 + a1x ^ 2 + a2x + a3 -> 求 导 3a0x ^ 2 + 2a1x + a2 -> (2a0x + a1) x + a0x ^ 2 + a1x + a2;
La derivada de la última etapa se compone de la derivada de la etapa anterior y la función original
La última etapa se multiplica por una más que la etapa anterior, por lo que su derivada es 1 más en coeficiente que la etapa anterior
La derivada de la última etapa tiene una constante adicional en relación con la etapa anterior.
Código completo:
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int x,a;
char c;
while(~scanf("%d",&x)){
int sum=0,ans = 0;
while(~scanf("%d",&a)){
ans = ans*x+sum;
sum = sum*x+a;
scanf("%c",&c);
if(c=='\n') break;
}
cout<<ans<<endl;
}
}
;
(a0x + a1) x + a2 = a0x ^ 2 + a1x + derivación a2-> 2a1x + a1
(a0x ^ 2 + a1x + a2) x + a3 = a0x ^ 3 + a1x ^ 2 + a2x + a3 -> 求 导 3a0x ^ 2 + 2a1x + a2 -> (2a0x + a1) x + a0x ^ 2 + a1x + a2;
La derivada de la última etapa se compone de la derivada de la etapa anterior y la función original
La última etapa se multiplica por una más que la etapa anterior, por lo que su derivada es 1 más en coeficiente que la etapa anterior
La derivada de la última etapa tiene una constante adicional en relación con la etapa anterior.
Código completo:
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int x,a;
char c;
while(~scanf("%d",&x)){
int sum=0,ans = 0;
while(~scanf("%d",&a)){
ans = ans*x+sum;
sum = sum*x+a;
scanf("%c",&c);
if(c=='\n') break;
}
cout<<ans<<endl;
}
}