¿Cuáles son los algoritmos en lenguaje C con ejemplos y análisis?

3. Cómo encontrar números primos

A. Determinar si un número es primo dentro de un rango pequeño:

función prima (n: entero): booleano;

var. I: entero;

comenzar

for I:=2 to trunc(sqrt(n)) hacer

si n mod I=0 entonces comenzar

prime:=falso; salir;

fin;

prime:=true;

fin

B Determinar entero largo si el número en el rango es un número primo (incluyendo encontrar la tabla de números primos dentro de 50000):

procedimiento getprime;

var

i. ,j:longint;

p>

p:array:=true.

Para I:=1 to n do

Para j:= w[I] to v do F[I,j ]:=f[I-1,j-w[I]];

Optimización: el estado actual solo está relacionado con el estado de la etapa anterior y puede reducirse a una dimensión.

F[0]:=true;

Para I:=1 a n comenzar

F1:=f;

Para j:=w[I] a v hacer

Si f[j-w[I]] entonces f1[j]:=true;

F:=f1;

Fin;

B. Encuentra el valor máximo que se puede poner.

F[I,j] es el valor máximo que se puede obtener cogiendo las primeras j mochilas cuando la capacidad es I.

F [i,j] = max { f [ i – w [ j ], j-1] + p [ j ], f[ i,j-1] }

C. Encuentre el número de casos en los que está exactamente lleno.

DP:

Actualización de procedimiento;

var j,k:integer;

comenzar

c: =a;

para j:=0 a n hacer

si a[j]>0 entonces

si j+ahora<=n entonces inc( c[j+ahora],a[j]);

a:=c;

fin

2. Mochila reutilizable

A Encuentra el peso máximo que se puede meter en ella.

F[I,j] es un signo que selecciona varios elementos de los primeros i y los coloca de manera que su volumen sea exactamente j. Es de tipo booleano.

La ecuación de transición de estado es

f[I,j] = f [ I-1, j – w[I]*k ] (k=1.. j div w [ I])

B. Encuentra el valor máximo que se puede poner.

USACO 1.2 Inflación de puntaje

Realiza una competencia con un tiempo total fijo T. Hay varias preguntas opcionales. No hay límite para el número de entradas para cada pregunta. A ti (el tiempo necesario para resolver esta pregunta) y a si (la puntuación obtenida al resolver esta pregunta). Ahora necesitamos seleccionar una cantidad de preguntas para que la puntuación total obtenida se pueda maximizar al mismo tiempo que el tiempo total para resolver estas preguntas. está dentro de T. Encuentre la puntuación máxima.

*Fácil de pensar:

f[i,j] = max { f [i- k*w[j], j-1] + k*p[j ] } (0<=k<= i div w[j])

Donde f[i,j] representa el valor máximo que pueden alcanzar las primeras j mochilas cuando la capacidad es i.

*Implementación:

Comenzar

FillChar(f,SizeOf(f),0);

Para i:=1 A M Do

Para j:=1 Para N Do

Si i-problem[j].time>=0 Entonces

Comenzar

t:=problem[j].point+f[i-problem[j].time];

Si t>f[i] Entonces f[i]:=t;

Fin;

Writeln(f[M]);

Fin

C. Encuentra el número de casos en los que está exactamente lleno.

Ahoi2001 Problema 2

Encuentra el número de expresiones para la suma de números primos con números naturales esencialmente diferentes n.

La primera idea es generar la disposición de los coeficientes de cada número primo y probarlos uno por uno. Este es un método general.

procedure try(dep:integer);

var i,j:integer;

begin

cal {Este proceso calcula; El resultado del cálculo del coeficiente actual, ahora es el resultado}

si ahora>n entonces salga;

si dep=l+1 entonces comience {Generar todos los coeficientes}

cal;

si ahora=n entonces inc(tot);

salir;

end;

para i:=0 a n div pr[dep] comenzar

xs[dep]:=i;

try(dep+1);

xs [dep]:=0;

end;

end;

Idea 2, la búsqueda recursiva es un procedimiento más eficiente

try( dep,rest:integer);

var i,j,x:integer;

comenzar

si (rest<=0) o (dep =l +1) luego comenzar

si rest=0 entonces inc(tot);

salir;

fin;

para i: =0 para descansar div pr[dep] do

try(dep+1,rest-pr[dep]*i);

end;

{ main: try(1,n); }

Idea 3: se puede utilizar la programación dinámica para resolver el problema

Sistema monetario USACO1.2

V artículos, capacidad de la mochila Para n, encuentre el número total de formas de colocarlos.

Transferir ecuación:

Actualización de procedimiento;

var j,k:integer;

begin

c :=a;

para j:=0 a n hacer

si a[j]>0 entonces

para k:=1 a n div ahora hacer

si j+now*k<=n entonces inc(c[j+now*k],a[j]);

a:=c;

fin;

{main}

comenzar

leer(ahora); {Leer el peso del primer artículo}

i:=0; {a[i] es el número total de formas de poner cuando la capacidad de la mochila es i}

mientras i<=n comienza

a[ i]: =1; inc(i,now); end; {Defina el peso como un valor que sea un múltiplo entero del peso del primer elemento como 1, como valor inicial}

para i :=2 a v hacer

comenzar

leer(ahora);

actualizar {actualización dinámica}

finalizar;

writeln(a [n]);

4. Algoritmo de clasificación

A. Clasificación rápida:

procedimiento qsort(l, r:integer);

var i,j,mid:integer;

comenzar

i:=l;j:=r; mid:=a [(l+r) div 2]; {Defina el número en el medio de la secuencia actual como el número del medio}

repetir

mientras a[i]

mientras a[j]>mid do dec(j);{Busca un número más pequeño que el número del medio en la mitad derecha }

si i<=j entonces comienza {Si se encuentra un conjunto de pares de números que no coincide con el objetivo de clasificación, intercámbielos}

swap(a[i],a [j]);

inc(i); dec(j); {seguir buscando}

fin;

hasta i>j;

if l

if i

end;{sort}

B. Ordenación por inserción:

Idea: Actualmente a[1]..a[i-1]. ] ha sido ordenado, ahora necesitamos insertar a[i] para hacer un[1].. a[i] está ordenado.

procedimiento insert_sort;

var i,j:integer;

comenzar

for i:=2 to n comenzar p>

a[0]:=a[i];

j:=i-1;

mientras a[0]

a[j+1]:=a[j];

j:=j-1;

fin;

a [j+1]:=a[0];

end;

end;{inset_sort}

Clasificación de selección:

clasificación de procedimiento;

var i,j,k:integer;

comenzar

para i:=1 a n-1 hacer

para j:=i+1 to n hacer

si a[i]>a[j] entonces swap(a[i],a[j]);

fin;

D. Clasificación de burbujas

procedimiento bubble_sort;

var i,j,k:integer;

comenzar

para i:=1 a n-1 hacer

para j:=n hasta i+1 hacer

si a[j]

fin

E.

procedure sift(i,m:integer);{Ajusta el subárbol con i como raíz para convertirlo en un montón, m es el número total de nodos}

var k:integer ;

begin

a[0]:=a[i]; k:=2*i;{En un árbol binario completo, el hijo izquierdo del nodo i es 2* i, y el hijo correcto es 2* i+1}

mientras k<=m comienzan

if (k

si a[0]

else k:=m+1;

fin;

a[i]:= a[0]; {Colocar la raíz en la posición adecuada}

fin

procedimiento heapsort;

var<; /p>

j: entero;

comenzar

para j:=n div 2 hasta 1 hacer sift(j,n);

para j:=n hasta 2 comienza

swap(a[1],a[j]);

sift(1,j-1);

fin;