Problemas Programacion PDF

LIMA-PERU 2008
STL
Librería Estándar de Plantilla
Por:
Adolfo Ccanto Llactahuaman
Comunidad ACM-ICPC-UNI
LIMA - PERU
2008
1/33
Tutorial Por: Adolfo Ccanto Llactahuaman
STL Comunidad ACM-ICPC-UNI 2008
LIMA-PERU 2008
CONTENIDO
STL, definición.....................................................................................................................................4
Clase de Contenedores:....................................................................................................................5
VECTOR.............................................................................................................................................. 6
Declaracion: ................................................................................................................................... 6
Funciones Miembros: ..................................................................................................................... 6
push_back: .............................................................................................................................. 6
size: ........................................................................................................................................... 6
begin: ..........................................................................................................................................6
end: .............................................................................................................................................7
erase: .......................................................................................................................................... 7
clear: ...........................................................................................................................................7
empty: .........................................................................................................................................7
asignación: ........................................................................................................................... 7
find: .......................................................................................................................................... 7
reverse: ....................................................................................................................................... 8
sort: .........................................................................................................................................8
PROBLEMA: ...................................................................................................................................... 9
SOLUCION:.......................................................................................................................................10
DEQUE...............................................................................................................................................11
LIST....................................................................................................................................................12
push_front: ................................................................................................................................... 12
push_back: ................................................................................................................................... 12
iterator: ..........................................................................................................................................12
STACK ( LIFO )................................................................................................................................ 13

PUSH............................................................................................................................................. 13
POP................................................................................................................................................ 13
QUEUE ( FIFO )................................................................................................................................ 15
PRIORITY_QUEUE.......................................................................................................................... 16
PROBLEMA: .................................................................................................................................... 17
SOLUCION: ............................................................................................................................... 18
2/33
LIMA-PERU 2008
SET ( conjunto).................................................................................................................................. 20
insert: .......................................................................................................................................... 20
size: .............................................................................................................................................. 20
iterator: ..........................................................................................................................................20
find: ..............................................................................................................................................20
PROBLEMA: .................................................................................................................................... 21
SOLUCION:
MAP .................................................................................................................................................. 23
CLASE STRING................................................................................................................................ 25
declaracion:....................................................................................................................................25
ingreso de datos:............................................................................................................................ 25
lectura:........................................................................................................................................... 25
concatenacion:............................................................................................................................... 25
longitud: .................................................................................................................................... 25
substring: .......................................................................................................................................25
find : .............................................................................................................................................26
FLUJO DE ENTRADA Y SALIDA.................................................................................................. 27

conversion de datos:.......................................................................................................................27
distribución de datos...................................................................................................................... 27
PROBLEMA: .................................................................................................................................... 28
SOLUCION:.......................................................................................................................................29
PROBLEMA: .................................................................................................................................... 30
SOLUCION:.......................................................................................................................................32
REFERENCIAS................................................................................................................................. 33
3/33
LIMA-PERU 2008
INTRODUCCION
En este documento recopilo algunas de las informaciones mas importantes sobre las Librerías
Estándar de Plantillas, así como los conceptos básicos que ayudaran ah impulsar a la investigación
de este tema, y aplicaciones de estas librerías para el fácil manejo y planteamiento al dar solución a
algún problema, basado básicamente en problemas relacionados al concurso de programación
ACM.
Es importante debido a que estas librerías nos ahorraran tiempo al momento de codificar, claro que
antes de codificar debemos pensar y analizar la solución optima y posteriormente usar las librerías
del STL para tal fin.
Adolfo Ccanto Llactahuaman

Comunidad ACM-ICPC-UNI
LIMA - PERU
2008
4/33
LIMA-PERU 2008
STL, definición
El STL es una librería de C++ que incluye estructura de datos y algoritmos que utilizaremos por su
facilidad de uso.
El C++ incorpora todas las librerías de Estándar C y también añade sus propias librerías. Estas
librerías son mucho más potentes que las de C.
Un contenedor es cualquier TAD cuyas funciones principales es insertar, quitar elementos el cual
esta implementado con clases genéricas o clase de plantillas, quiere decir una clase cuyo atributo
toma cualquier tipo de datos (enteros, cadenas, estructuras,…) y su implementación es única para
todas ellas.
Clase de Contenedores:
Contenedores Secuenciales:
● vector
● deque
● list
Contenedores Asociativos:
● set
● map
● multiset
● hash_set
● hash_map
Contenedores Adaptadores:
● snack
● queue
● priority_queue
Clase string
Flujo de datos
5/33
LIMA-PERU 2008
VECTOR
Permite almacenar elementos del mismo tipo, es parecido al Arreglo aunque el numero de
elementos no se precisa ya que es dinámico el almacenamiento de datos, se puede acceder a un
elemento por su índice por ello se dice que es de acceso aleatorio, el tiempo de acceso inserción y
borrado es en tiempo constante O(1)
Declaracion:
vector<tipo> nombre;
vector<string> a;
vector<int> b(100); // vector de 100 elementos
vector<poligonos>b;
Funciones Miembros:
push_back:
para insertar datos
vector<int> v;
v.push_back(2);
v.push_back(5);
v.push_back(4);
v.push_back(1);
v.push_back(20);
size:
devuelve el tamaño del vector
int n = v.size();
for(int i=0;i<n;i++)
cout<< v[i]<<endl;
begin:
devuelve un iterador que referencia el comienzo del vector
int n = v.size();
cout<< *(v.begin()+i)<<endl;
6/33
LIMA-PERU 2008
end:
devuelve un iterador que referencia el final del vector
int n = v.size();
for(int i=n;i>=1;i--)
cout<< *(v.end()-i)<<endl;
erase:
elimina los elementos que se encuentran entre los iteradores indicados
v.erase(v.begin()+1,v.begin()+2); // estamos borrando el v[1]

// v={2,4,1,20}
v.erase(v.begin()+1) ; // borramos v[1]
// v={2,1,10};
clear:
elimina todos los elementos del Vector
v.clear();
empty:
devuelve VERDAD si el vector esta vacío
if(v.empty()==false)
cout<<”hay elementos aun en el vector”<<ende;
asignación:
vector<int >b;
b.push_back(3);
b.push_back(5);
b.push_back(1);
b.push_back(0);
a=b; // el vector a ahora contiene los elementos de b
find:
busca un elemento en el vector , esto lo hace en un tiempo lineal O(n)
si encuentra el elemento retorna el iterador donde se encontró
find( inicio de búsqueda, final de búsqueda, elemento a buscar )
if ( find(a.begin(),b.end(),5) ! = a.end() )
cout<<”Elemento encontrado”<<endl;
else cout<<”no se encontró dicho elemento”<<ende;
7/33
LIMA-PERU 2008
reverse:
invierte los elementos del contenedor incluidos en el rango establecido por un
iterador inicial y otro final reverse( iterador_inicial, iterador_final)
obs: invierte los elemento desde iterador_inicial hasta un elemento antes

del iterador_final
// a ={3,5,1,0}
reverse(a.begin(),a.begin()+2) ; // invertimos desde a[0] hasta a[1]
// a ={5,3,1,0}
reverse(a.begin(),a.end()); // invierte todo el vector
// a ={0,1,3,5}
sort:
ordena de manera creciente los elementos de un contenedor incluidos en el
rango establecido por un iterador inicial y otro final
obs: invierte los elemento desde iterador_inicial hasta un elemento antes de

iterador_final
// b ={3,5,1,0}
sort(b.begin() , b.end());
// b={0,1,3,5}
8/33
LIMA-PERU 2008
PROBLEMA:
S Number ( TJU - 2859)
Dado un conjunto de números. El S-number es el máximo elemento
menor que el mayor de todos. Por ejemplo para el conjunto el cual
contiene 8 números: 3, 6, 0, -5, 7, 7, 6, 2. El número mayor es 7.
Así que el S-number es 6 porque es máximo menor que 7.
Input
La primera línea de cada entrada contiene un numero entero “n” que

indica el tamaño del conjunto. Luego los n números siguientes, son
los elementos del conjunto. La entrada culmina por una solo línea
n = 0. Todos los números en la entrada serán menor que 100.
Output
Una línea que contiene el S-Number por cada caso de la entrada.
Sample Input
8
3 6 0 -5 7 7 6 2
0
Sample Output
9/33
LIMA-PERU 2008
SOLUCION:
//////////////////////////////////////////////////
// Coder: Ad
//////////////////////////////////////////////////
#include<iostream>
#include<vector>
#define fa(i,a,b) for(int i=a;i<b;++i)
#define pb push_back
using namespace std;
int main(){
int n,x;
while(scanf("%d",&n)==1&&n){
vector<int>a;
fa(i,0,n){scanf("%d",&x); a.pb(x);}
// almacenamos elementos en el vector
sort(a.rbegin(),a.rend());
// ordena los elementos de mayor a menor
int m=a[0];
fa(i,1,a.size())if(a[i]!=m){cout<<a[i]<<endl;break;}
}
}
//////////////////////////////////////////////////
10/33
LIMA-PERU 2008
DEQUE
Las Colas de doble extremo son como los vectores, excepto que en éstas la inserción y borrado de
elementos es más rápida, además de permitir insertar y borrar elementos al principio así como al
final del contenedor. La mayoría de los métodos aplicables a la clase vector son aplicables a la
clase deque, pero la clase deque posee además los métodos push_front y pop_front para insertar y
borrar elementos al principio
Tiene acceso aleatorio es decir es indexado.
11/33
LIMA-PERU 2008
LIST
Están implementadas como listas doblemente enlazada

Inserción y Eliminación de elementos lo hacen en tiempo constante O(1)
Posee las mismas funciones miembros que el vector
No tiene acceso aleatorio a los elemento es decir no posee indexación.
push_front:
para insertar elementos del contenedor en el inicio
list<char>L;
L.push_front(‘c’);
L.push_front(‘a’);
push_back:
para insertar elementos del contenedor en el final
L.push_back(‘b’);
iterator:
sirve para acceder a los elementos
list<char>::iterator it;
for(it=L.begin(); it!=L.end(); it++)
cout<<*it<<endl;
12/33
LIMA-PERU 2008
STACK ( LIFO )
Esta es una implementacion de una Pila.

LIFO = Ultimo elemento en entrar es el Primer elemeto en Salir
push : para insertar los datos en la pila en tiempo constante

pop: para eliminar elemento de la pila en tiempo constante
top: para extraer el valor del elemento tope de la pila en tiempo constante
PUSH
POP
13/33
LIMA-PERU 2008
tendriamos:
stack<int>pila;
pila.push(2);
pila.push(3);
pila.push(5);
while( ! pila.empty() ){ // si aun la pila no esta vacía

cout<<pila.top()<<endl;
pila.pop();
}
Con la pila se puede realizar el recorrido de un árbol en profundidad pre-orden (DFS)
14/33
LIMA-PERU 2008
QUEUE ( FIFO )
Es la implementacion de una Cola .

FIFO: Primero elemento en entrar es el primer elemento en Salir
push: para ingresar elementos a la cola , siempre al final en tiempo constante

pop: para eliminar elementos de la cola , siempre el primero en tiempo constante,
front: para extraer el valor del primer elemento de la cola en tiempo constante
PUSH
POP
tendriamos:
queue<int>Q;
q.push(1);
q.push(5);
q.push(3);
q.push(6);
while(!Q.empty()){
cout<<Q.front()<<endl;
q.pop();
}
La clase queue es muy importante para el recorrido en anchura de un arbol (BFS)
15/33
LIMA-PERU 2008
PRIORITY_QUEUE
Idea: cuando se realiza en ingreso de pacientes a un hospital simula una cola simple pero cuando
viene un paciente grave el tendrá la mayor prioridad para estar en el primera posición de la cola ,
por ello el nombre de Colas de prioridad
Solo se recuperara el elemento de mayor prioridad

Su estructura radica en árbol de montículo ( heap )
priority_queue<int , vector<int> > Q;

q.push(1);
q.push(20);
q.push(10);
q.push(15);
q.push(5);
cout<<q.top()<<endl; // 20
while(!q.empty()){
cout<<q.top()<<endl; // 20 15 10 5 1
q.pop();
}
haciendo que el primer elemento sea siempre el menor
priority_queue<int,vector<int>,greater<int> >d;
d.push(1);
d.push(3);
d.push(5);
while(!d.empty()){
int t=d.top();
cout<<t<<endl; // 1 3 5
d.pop();
}
16/33
LIMA-PERU 2008
PROBLEMA:
UGLY NUMBERS
(http://acm.uva.es/p/v1/136.html)
Ugly numbers son numeros cuyos factores primos son unicamente 2, 3 or 5. La secuencia:
1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, ...
Muestra los 11 ugly numbers. Por convencion 1 es incluido.
Escribe un programa que encuentre y muestre el 1500'th ugly number.
Input and Output
No hay entradas para este programa. La salida debe consisitir de una sola linea como se muestra
abajo, con <number> reemplazado por el numero calculado.
Sample output
The 1500'th ugly number is <number>.
17/33
LIMA-PERU 2008
SOLUCION:
//////////////////////////////////////////////////
// Coder: Ad
//////////////////////////////////////////////////
#include<iostream>
#include<set>
#include<vector>
#include<queue>
int main(){
set< long long >s;
// aca almacenamos los elementos ordenados
priority_queue<long long, vector<long long>,greater<long long> > pq;

s.insert(1);
pq.push(1);
// almacenamos el numero 1 por convencion al problema
while (s.size() < 1597) {

long long t= pq.top(),a=t*2,b=t*3,c=t*5;
// en t se almacena el menor de la cola
pq.pop();
if(s.find(a)==s.end()){s.insert(a);pq.push(a);} // si a no esta en el conjunto
if (s.find(b)==s.end()){s.insert(b);pq.push(b);} // si b no esta en el conjunto
if (s.find(c)==s.end()){s.insert(c);pq.push(c);} // si c no esta en el conjunto
}
int k=1;long long t;
fore(it,s){if(k==1500)t=*it;k++;}
cout<<"The 1500'th ugly number is "<<t<<"."<<endl;
18/33
LIMA-PERU 2008
CONTENEDORES ASOCIATIVOS
Contenedor que almacena elementos únicos, es decir no existen elementos repetidos , su

implementación se basa en árboles AVL que no es mas que la equilibración de árboles binarios. Por
tanto para la búsqueda de un elemento lo realiza en tiempo logarítmico así como su inserción y
borrado de elementos.
No tiene acceso aleatorio, no se puede indexar, se recorre mediante los iteradotes.
así como también ordena los elementos del contenedor automáticamente en forma ascendente
19/33
LIMA-PERU 2008
SET ( conjunto)
insert:
ingresar datos
set<int>s;
s.insert(2);
s.insert(5);
s.insert(4);
s.insert(3);
s.insert(3);
size:
tamaño del contenedor
int n=s.size();
cout<<n<<endl; // 4
iterator:
para realizar el recorrido del contenedor
set<int>::iterator it;
for(it=s.begin();it!=s.end();it++){
cout<<*it<<endl; // 2 3 4 5
}
find:
realiza la búsqueda de un elemento en el contenedor
if( s.find(3) !=s.end())
cout<<”si existe”<<endl;
else cout<<”no existe ”<<endl;
20/33
LIMA-PERU 2008
PROBLEMA:
DOUBLES ( TJU – 1930 )
Como parte de un curso de aritmética, se entrega a los
participantes listas de numeros generadas al azar de 2 a 15
enteros positivos únicos y se les pide determinar cuántos números
en cada lista es dos veces algún otro numero de la misma lista.
Deberá crear un programa para realizar dicha tarea. Este programa
recibira como entrada las listas y mostrará la respuesta correcta
para cada grupo. Por ejemplo, teniendo en cuenta la lista
1 4 3 2 9 7 18 22
Su programa debe responder a 3, porque 2 es dos veces 1, 4 es dos

veces 2, y 18 es dos veces 9.
El archivo de entrada constará de una o mas listas de los números.

Habrá una lista de los números por cada renglón. Cada lista
contendrá una cantidad de enteros positivos únicos entre 2 y 15.
Ningún número entero será más grande que 99. Cada línea será
puesta fin con el número entero 0, que no es considerado parte de
la lista. Un renglón con solo el número -1 caracterizará el final
del fichero. El ejemplo ingresado abajo indica 3 listas distintas.
Algunas listas no podrían contener cualquier dobles.
El resultado constará de una línea por la lista de entrada,

conteniendo un recuento de los números que son doble de algún otro
elemento.
Sample Input Sample Output
1 4 3 2 9 7 18 22 0 3
2 4 8 10 0 2
7 5 11 13 1 3 0 0
-1
21/33
LIMA-PERU 2008
SOLUCION:
//////////////////////////////////////////////////
// Coder: Ad
//////////////////////////////////////////////////
#include<iostream>
#include<string>
#include<vector>
#include<set>
int main(){
int x,ct;
while(cin>>x){
ct=0;
if(x==-1)break;
// si el primer elemento es -1 acaba la lectura de datos
vector<int>v; // aca almacenamos la lista de numeros

v.push_back(x); // almacenamos el primer elemento
while(cin>>x){
if(x==0)break;
// si ingresa un numero 0 acaba la lectura para la lista
v.push_back(x);
// almacenamos los elementos diferentes a 0
}
int n=v.size();
// se almacena la cantidad de numeros que ingresamos
set<int>s;
for(int i=0;i<n;i++)s.insert(2*v[i]);
// almacenamos en s los dobles
if(s.find(v[i])!=s.end())
// buscamos en time logaritmico si algun numero es doble
ct++;
cout<<ct<<endl;
}
}
22/33
LIMA-PERU 2008
MAP
(MAPEO)
Es un contenedor al igual que el set formado por un conjunto de la clase pair .
El pair es una estructura formada por un par de elemento( first y second).

Por ejemplo un pair puede servir para almacenar el numero complejo 2+3i , en el first la parte real y
en el second la parte imaginaria:
pair<int,int> complejo1;
complejo1.fisrt = 2 ;
complejo1.second=3;
también se puede ingresar los datos a un pair de forma directa usando su constructor de esta
forma:
complejo1=make_pair(2,3);
pero para almacenar un conjunto de complejos , podría usar un vector de pairs es decir:
vector< pair<int,int> >conjunto_complejo;

int n;
cout<<"ingrese el numero de complejos"<<endl;
cin>>n;
// almacenamos los n numeros complejos sin usar constructor
pair<int,int> numero;
for(int i=0;i<n;i++){
cout<<"complejo :"<<endl:
cout<<"parte real = "; cin>>x;
cout<<"parte imaginaria = "; cin>>y;
numero.first=x;
numero.second=y;
conjunto_complejo.push_back(numero);
}
// otra manera a almacenar es usando usando el constructor del pair

// en este caso ya no es necesario tener el pair<int,int> numero
for(int i=0;i<n;i++){
23/33
LIMA-PERU 2008
cout<<"complejo :"<<endl:
cout<<"parte real = "; cin>>x;
cout<<"parte imaginaria = "; cin>>y;
conjunto_complejo.push_back(make_pair(x,y));
}
El map es un contenedor basado en un conjuntos de pair, en donde en los first se almacena la clave
primaria (elementos que nunca se repetirán) , y en los second se almacena el valor referido a su
clave primaria .
Por ejemplo un map de personas donde la llave primaria que nunca se repite es el DNI y el valor
puede ser la edad . su implementacion se basa en arboles binarios.
Queremos insertar codigo y edad de 4 personas:
map<int,int>m;
m[1]=15;
m[2]=17;
m[3]= 21;
m[4]=20;
if(m.find(5)!=m.end()){
cout<<”se encontro dicha clave”<<ende;
}
else cout<<”no existe dicha clave”<<ende;
Para recorrer el map hago uso de los iteradores:
map<int,int>:: iterator it;
for(it=m.begin();it!=m.end();it++){
cout<<(*it).first<<" "<<(*it).second<<endl;
// tambien se puede escribir como sigue sin el “*”
cout<<it->first<<" "<<it->second<<endl;
}
Obs: si insertamos un elemento del map con una misma clave el valor se actualiza.
24/33
LIMA-PERU 2008
CLASE STRING
Es la implementación de una cadena de caracteres con el manejo de diversas funciones miembros

de forma sencilla y rápida.
declaracion:
string cadena;
ingreso de datos:
string cadena="acm";
lectura:
solo una palabra: cin>>cadena;
una linea de palabras: getline(cin,cadena);
concatenacion:
string a="acm";
string b="icpc";
string c= a+" "+b;
cout<<c<<endl; // c="acm icpc"
longitud:
nos devuelve la longitud de la cadena
int n=c.size();
cout<<"la cadena tiene "<<n<<" caracteres"<<endl;
substring:
permite extraer una subcadena
substring(posicion_inicial , longitud a extraer);
string s="comunidad acm";

string a=s.substr(3,3); // c o m u n i d a d a c m
0 1 2 3 4 5 6 7 8 9 10 11 12
// a=”uni”
Para extraer de una posicion hacia el final de la cadena basta hacer:
string b=s.substr(3); // b=”unidad acm”;
25/33
LIMA-PERU 2008
find :
devuelve la posición donde empieza la cadena buscada
string a="acmc";
int p= s.find(‘c’);
cout<<p<<endl; // p=1 encuentra la primera ocurrencia y devuelve el valor
pero si no encuentra la letra o cadena devuelve el valor -1
26/33
LIMA-PERU 2008
FLUJO DE ENTRADA Y SALIDA
conversion de datos:
float x;
string s="123.156";
stringstream in;
in<< s;
in>>x;
cout<<x<<endl; // ahora en x se almaceno 123.156 como numero real
distribución de datos
string s="jose 3 vs 1 carlos ";

string a,b,c;
int g1,g2;
stringstream in;
in<<s;
in>>a>>g1>>c>>g2>>b;
if(g1>g2)cout<<"gano "<<a;
else if(g1<g2)cout<<"gano "<<b<<endl;
else cout<<"empates"<<endl;
27/33
LIMA-PERU 2008
PROBLEMA:
BABELFISH ( TJU – 1378 )
Usted acaba de viajar de Waterloo, una ciudad grande. Las personas ahí hablan un dialecto
incomprensible de una lengua extranjera. Afortunadamente, usted tiene un diccionario para ayudar a
comprenderlos.
La entrada consta de hasta 100,000 entradas de diccionario, seguido por una línea en blanco,
seguido por un mensaje de hasta 100,000 palabras. Cada entrada de diccionario es una línea que
contiene una palabra inglesa, seguido por un espacio y una palabra de la lengua extranjera. Ninguna
palabra extranjera aparece más de una vez en el diccionario. El mensaje es una secuencia de las
palabras en la lengua extranjera, una palabra sobre cada línea. Cada palabra en la entrada es una
secuencia de a lo más 10 letras minúsculas. El resultado es el mensaje traducido a inglés, una por
cada renglón. Las palabras extranjeras que no se encuentren en el diccionario deben ser traducido
como "eh".
Sample Input Output for Sample Input
dog ogday cat

cat atcay eh
pig igpay loops
froot ootfray
loops oopslay
atcay
ittenkay
oopslay
28/33
LIMA-PERU 2008
SOLUCION:
//////////////////////////////////////////////////
// Coder: Ad
//////////////////////////////////////////////////
#include<iostream>
#include<map>
int main(){
map<string,string> mapa;
// aca guardamos el diccionario
string a,b,s;
while(getline(cin,s)){
if(s=="")break;
stringstream in(s);
in>>a>>b;
// “a” es palabra conocida y “b” es palabra desconocida
mapa[b]=a;
// en el first guardamos la palabra desconocida “b”
// en el second guardamos su significado “a”
}
while(cin>>a){
if(mapa.find(a)!=mapa.end())
// buscamos en time logaritmico si existe “a”
cout<<mapa[a]<<endl;
else
cout<<"eh"<<endl ;
}
29/33
LIMA-PERU 2008
PROBLEMA:
THE HEROES ( TJU - 2781 )
Dr. Suresh ha descubierto que piezas genéticas especiales permitirían que los seres humanos tengan
habilidades especiales, como volar, para el tiempo, etc. Le gustaría mostrar una lista que contendra a todas
las personas especiales. Una persona individual está en la lista si y solo si su código genético contiene uno
de las piezas especiales como una sub-cadena. Por favor ayude a Dr.Suresh a realizar dicha tarea.
Input
La primera línea contiene un número entero N, que indica la cantidad de piezas genéticas especiales. Las
siguientes N lineas contienen un cadena, cada una indica el código genético de cada pieza. La siguiente line
contiene un numero entero M, que indica la cantidad de personas individuales a analizar. La siguientes M
lineas ,cada uno tiene un cadena, que es el código genético de cada persona individual.
Output
Para cada persona, si está en la lista, muestre en una linea "A new hero discovered". De lo contrario muestre
“Just an ordinary person".
Notes
* Un codigo genetico es un string que contiene 'A', 'T', 'C' y 'G' solamente y no contiene espacios en
blanco.
* Un string A es un substring de B, si y solo si A aparece continuamente en B ( ejemplo ATC un
substring de AATCTC, pero ATT no lo es).
* El código genético de un Héroe puede contener varios tipos de códigos genéticos especiales como
substrings.
Constraints
* 1 ≤ N ≤ 10, 1 ≤ M ≤ 50
* La longitud de cualquier código genético es mayor a 0 y no excede a 50.
30/33
LIMA-PERU 2008
Sample Input
2
ATA
ATC
3
ACATAG
AATTCCGG
ATCGGATACG
Sample Output
A new hero discovered

Just an ordinary person
A new hero discovered
31/33
LIMA-PERU 2008
SOLUCION:
//////////////////////////////////////////////////
// Coder: Ad
//////////////////////////////////////////////////
#include<iostream>
#include<vector>
#define fa(i,a,b) for(int i=a;i<b;++i)
#define pb push_back
int main()
{int n,m;
scanf("%d",&n);
// leemos el numeros de piezas a ingresar
vector<string>x,y;
string a;
while(n--){cin>>a;x.pb(a);}
// almacenamos las piezas geneticas especiales
scanf("%d",&m);
while(m--){cin>>a;y.pb(a);}
// almacenamos los codigos geneticos de las personas
fa(i,0,y.size())
// para cada persona buscamos alguna pieza genetica especial
{int k=1;
fa(j,0,x.size())
if(y[i].find(x[j])!=-1)
// si encontre una pieza genetica especial entonces k=0
{ k=0;
break;
}
if(k)puts("Just an ordinary person");
else puts("A new hero discovered");
}
}
32/33
LIMA-PERU 2008
REFERENCIAS
Para mayor informacion sobre las STL pueden visitar la siguiente pagina:
● http://www.sgi.com/tech/stl/stl_index.html
33/33

Problemas Programacion PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Problemas Programacion PDF

Cargado por

Copyright:

Formatos disponibles

LIMA-PERU 2008

STACK ( LIFO )................................................................................................................................ 13

QUEUE ( FIFO )................................................................................................................................ 15

FLUJO DE ENTRADA Y SALIDA.................................................................................................. 27

Adolfo Ccanto Llactahuaman

v.erase(v.begin()+1,v.begin()+2); // estamos borrando el v[1]

a=b; // el vector a ahora contiene los elementos de b

obs: invierte los elemento desde iterador_inicial hasta un elemento antes

obs: invierte los elemento desde iterador_inicial hasta un elemento antes de

La primera línea de cada entrada contiene un numero entero “n” que

Una línea que contiene el S-Number por cada caso de la entrada.

Están implementadas como listas doblemente enlazada

Esta es una implementacion de una Pila.

push : para insertar los datos en la pila en tiempo constante

while( ! pila.empty() ){ // si aun la pila no esta vacía

Con la pila se puede realizar el recorrido de un árbol en profundidad pre-orden (DFS)

Es la implementacion de una Cola .

push: para ingresar elementos a la cola , siempre al final en tiempo constante

La clase queue es muy importante para el recorrido en anchura de un arbol (BFS)

Solo se recuperara el elemento de mayor prioridad

priority_queue<int , vector<int> > Q;

haciendo que el primer elemento sea siempre el menor

1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, ...

Muestra los 11 ugly numbers. Por convencion 1 es incluido.

Escribe un programa que encuentre y muestre el 1500'th ugly number.

Input and Output

The 1500'th ugly number is <number>.

priority_queue<long long, vector<long long>,greater<long long> > pq;

while (s.size() < 1597) {

Contenedor que almacena elementos únicos, es decir no existen elementos repetidos , su

Su programa debe responder a 3, porque 2 es dos veces 1, 4 es dos

El archivo de entrada constará de una o mas listas de los números.

El resultado constará de una línea por la lista de entrada,

Sample Input Sample Output

vector<int>v; // aca almacenamos la lista de numeros

El pair es una estructura formada por un par de elemento( first y second).

vector< pair<int,int> >conjunto_complejo;

// almacenamos los n numeros complejos sin usar constructor

// otra manera a almacenar es usando usando el constructor del pair

Queremos insertar codigo y edad de 4 personas:

Para recorrer el map hago uso de los iteradores:

map<int,int>:: iterator it;

Es la implementación de una cadena de caracteres con el manejo de diversas funciones miembros

string s="comunidad acm";

FLUJO DE ENTRADA Y SALIDA

string s="jose 3 vs 1 carlos ";

Sample Input Output for Sample Input

dog ogday cat

A new hero discovered

También podría gustarte