Programación Competitiva | Isaac Lozano Osorio

100 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 100

#include <iostream>
using namespace std;
int main()
{
 string numero,numerocopy,original;
 int mayor,menor,numero1,total=0,casos,temp,temp1;
 cin>>casos;
 for(int i=0;i<casos;i++)
 {
 cin >> numero;
 //Ordenar
 for(int i=0; i<7;i++)
 {
 while(numero.length()!=4)
 {
 numero = "0"+numero;
 }
 numerocopy=numero;
 original=numero;
 if(numero[0]!=numero[1]||numero[0]!=numero[2]||numero[0]!=numero[3])
 {
 for(int i=0;i<4;i++)
 {
 for(int j=0;j<3;j++)
 {
 if(numero[j]>numero[j+1])
 {
 temp=numero[j];
 numero[j]=numero[j+1];
 numero[j+1]=temp;
 }
 if(numerocopy[j]<numerocopy[j+1])
 {
 temp1=numerocopy[j];
 numerocopy[j]=numerocopy[j+1];
 numerocopy[j+1]=temp1;
 }
 }
 }
 menor = stoi(numero);
 mayor = stoi(numerocopy);

 numero1=mayor-menor;
 if(numero1==6174)
 {
 total= i+1;
 i=9;
 }
 if(original=="6174")
 {
 total=0;
 i=9;
 }
 numero=to_string(numero1);
 while(numero.length()!=4)
 {
 numero = "0"+numero;
 }
 }
 else
 {
 i=8;
 cout<<"8\n";
 }
 }
 if(numero[0]!=numero[1]||numero[0]!=numero[2]||numero[0]!=numero[3])
 {
 cout<<total<<"\n";
 }
 }
 return 0;
}

100 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 100

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int i,j;
 while(scanf("%d%d",&i,&j)==2)
 {
 int max_cycle_length = 0,cycle_length;
 cout<<i<<" "<<j<<" ";
 if ( i > j ) swap (i, j);
 while ( i <= j ) {
 int n = i;
 cycle_length = 1;
 while ( n != 1 ) {
 if ( n % 2 == 1 ) n = 3 * n + 1;
 else n /= 2;
 cycle_length++;
 }
 if ( cycle_length > max_cycle_length )
 max_cycle_length = cycle_length;
 i++;
 }
 printf ("%d\n",max_cycle_length);
 }
 return 0;
 }

10000 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10000

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

pair<int,int> memo[105][105];
vector<int> V[105];

pair<int,int> DP(int x)
{
 if(V[x].size()==0) { return {0,x};}
 pair<int,int> res = {0,INF};
 for(unsigned int i=0; i<V[x].size();i++){
 pair<int,int> &best = memo[x][V[x][i]];
 pair<int,int> r;
 if(best.first!=-1) r = best;
 else
 {
 r = DP(V[x][i]);
 best.first = r.first+1;
 best.second = r.second;
 }
 if(res.first==best.first) res.second=min(res.second,best.second);
 else if(best.first>res.first) res.second=best.second;
 res.first=max(best.first,res.first);
 }
 return res;
}
int main(){
 int ca = 1,nodes;
 while(scanf("%d",&nodes)==1 && nodes!=0)
 {

 int x,y,start;
 for(int i=0; i<101;i++) V[i].clear();
 for(int i=0; i<101;i++)
 for(int j=0; j<101;j++) memo[i][j].first = -1;
 scanf("%d",&start);
 while(scanf("%d %d",&x,&y)==2 && (x!=0 || y!=0)) V[x].push_back(y);
 pair<int,int> res = DP(start);
 printf("Case %d: The longest path from %d has length %d, finishing at %d.\n\n",ca++,start,res.first,res.second);
 }
 return 0;
}

10002 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10002

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
};

double cross(point o, point a, point b) {
 return (a.x-o.x)*(b.y-o.y) - (a.y-o.y)*(b.x-o.x);
}
bool cmp(point a,point b){
 if(a.x!=b.x) return a.x<b.x;
 return a.y<b.y;
}
double area(const vector<point> &P) {
 double result = 0.0, x1, y1, x2, y2;
 for (int i = 0; i < (int)P.size()-1; i++) {
 x1 = P[i].x; x2 = P[i+1].x;
 y1 = P[i].y; y2 = P[i+1].y;
 result += (x1 * y2 - x2 * y1);
 }
 return result / 2.0; }
vector<point> CH(vector<point> P){
 vector<point> res;
 sort(P.begin(),P.end(),cmp);
 int n = P.size();
 int m=0;
 for (int i=0;i<n;i++){
 while (m>1&&cross(res[m-2], res[m-1], P[i]) <= 0)res.pop_back(),m--;
 res.push_back(P[i]),m++;
 }
 for (int i = n-1, t = m+1; i >= 0; i--) {
 while (m>=t&&cross(res[m-2], res[m-1], P[i]) <= 0)res.pop_back(),m--;
 res.push_back(P[i]),m++;
 }
 return res;
}

point centroid(vector<point> g) //center of mass
{
 double cx = 0.0, cy = 0.0;
 for(unsigned int i = 0; i < g.size() - 1; i++)
 {
 double x1 = g[i].x, y1 = g[i].y;
 double x2 = g[i+1].x, y2 = g[i+1].y;

 double f = x1 * y2 - x2 * y1;
 cx += (x1 + x2) * f;
 cy += (y1 + y2) * f;
 }
 double res = area(g); //remove abs
 cx /= 6.0 * res;
 cy /= 6.0 * res;
 return point(cx, cy);
}


int main()
{
 int n;
 while(scanf("%d",&n)==1 && n>2)
 {
 vector<point> V;
 double x,y;
 for(int i=0; i<n;i++)
 {
 scanf("%lf%lf",&x,&y);
 V.push_back(point(x,y));
 }
 V = CH(V);
 point res = centroid(V);
 printf("%.3lf %.3lf\n",res.x,res.y);
 }
 return 0;
}

10003 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10003


#include <bits/stdc++.h>
using namespace std;

int corte[505];
int memo[505][505];
int L,N;

int dp(int i_index, int j_index, int left, int right){
 if(i_index<0 || j_index>=N || i_index>j_index) return 0;
 if(i_index == j_index) return right-left;
 int &best = memo[i_index][j_index];
 if(best!=-1) return best;
 int minCost = 0x3f3f3f3f;
 for(int i=i_index;i<=j_index;i++){
 int firstCut = dp(i_index,i-1,left,corte[i])+dp(i+1,j_index,corte[i],right);
 minCost = min(firstCut,minCost);
 }
 return best = minCost + (right-left);
}

int main(){
 //while(scanf("%d %d",&L,&N)==2 && (L!=0 || N!=0)){
 while(scanf("%d",&L)==1 && L!=0){ scanf("%d",&N);
 for(int i=0; i<N;i++) scanf("%d",&corte[i]);
 for(int i=0; i<N;i++)
 for(int j=0; j<N;j++) memo[i][j]=-1;
 sort(corte,corte+N);
 //printf("%d\n",dp(0,N-1,0,L)*2);
 printf("The minimum cutting is %d.\n",dp(0,N-1,0,L));
 }
 return 0;
}

10004 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10004

#include<bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

struct vec{
 int pos;
 vector<int> arr;
};
bool compare(vec A,vec B)
{
 for(unsigned int i=0; i<A.arr.size();i++)
 if(A.arr[i]!=B.arr[i])
 return A.arr[i]<B.arr[i];
 return A.arr[0]<B.arr[0];
}
int main()
{
 int cases; cin>>cases;
 while(cases--)
 {
 int n; cin>>n;
 vector<vec> V;
 vector<string> aux;
 string aux2;
 int m = 0;
 for(int i=1; i<=n;i++)
 {
 cin>>aux2;
 vec a;
 string actual;
 aux.push_back(aux2);
 for(unsigned int j=0; j<aux2.length();j++)
 {
 if(aux2[j]=='.') {a.arr.push_back(stoi(actual)); actual="";}
 else { actual+=aux2[j];}
 }
 a.arr.push_back(stoi(actual));
 a.pos=i;
 int l = a.arr.size();
 m = max(m,l);
 V.push_back(a);
 }
 for(unsigned int i=0; i<V.size();i++)
 {
 vec a = V[i];
 for(int i=a.arr.size(); i<m; i++)
 a.arr.push_back(0);
 V[i]=a;
 }
 sort(V.begin(),V.end(),compare);
 for(int i=0; i<n;i++)
 {
 vec a =V[i];
 if(i==0) cout<<aux[a.pos-1];
 else cout<<" "<<aux[a.pos-1];
 }
 cout<<endl;
 }
 return 0;
}

10005 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10005

#include <bits/stdc++.h>
#define PI acos(-1.0)
#define EPS 1e-8
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
};

double dist(point p1, point p2) {
 return hypot(p1.x - p2.x, p1.y - p2.y);
}

bool circle2PtsRad(point p1, point p2, double r, point &c) {
 double d2 = (p1.x - p2.x) * (p1.x - p2.x) +
 (p1.y - p2.y) * (p1.y - p2.y);
 double det = r * r / d2 - 0.25;
 if (det < 0.0) return false;
 double h = sqrt(det);
 c.x = (p1.x + p2.x) * 0.5 + (p1.y - p2.y) * h;
 c.y = (p1.y + p2.y) * 0.5 + (p2.x - p1.x) * h;
 return true; }
point circle(point &a, point &b, point &c) {
 static point ab, ac, o;
 static double a1, b1, c1, a2, b2, c2, D, D1, D2;
 ab.x = (a.x+b.x)/2, ab.y = (a.y+b.y)/2;
 ac.x = (a.x+c.x)/2, ac.y = (a.y+c.y)/2;
 a1 = a.x-b.x, b1 = a.y-b.y;
 c1 = a1*ab.x + b1*ab.y;
 a2 = a.x-c.x, b2 = a.y-c.y;
 c2 = a2*ac.x + b2*ac.y;
 D = a1*b2-a2*b1;
 D1 = c1*b2-c2*b1;
 D2 = a1*c2-a2*c1;
 o.x = D1/D;
 o.y = D2/D;
 return o;
}
double minCoverCircle(vector<point> p, int n) {
 point c;
 double cr = 0.0;
 int i, j, k;
 c = p[0];
 for(i = 1; i < n; i++) {
 if(dist(p[i], c) >= cr+EPS) {
 c = p[i], cr = 0;
 for(j = 0; j < i; j++) {
 if(dist(p[j], c) >= cr+EPS) {
 c.x = (p[i].x+p[j].x)/2;
 c.y = (p[i].y+p[j].y)/2;
 cr = dist(p[i], c);
 for(k = 0; k < j; k++) {
 if(dist(p[k], c) >= cr+EPS) {
 c = circle(p[i], p[j], p[k]);
 cr = dist(p[i], c);
 }
 }
 }
 }
 }
 }
 return sqrt(cr);
}
int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 vector<point> V;
 double x,y,rad;
 for(int i=0; i<n;i++)
 {
 scanf("%lf%lf",&x,&y);
 V.push_back(point(x,y));
 }
 scanf("%lf",&rad);
 point aux;
 bool flag = false;
 int k;
 for(int i=0; i<n && !flag;i++)
 for(int j=i+1; j<n &&!flag;j++)
 {
 circle2PtsRad(V[i],V[j],rad,aux);
 for(k=0;k<n;k++)
 if(dist(V[k],aux) > rad) break;
 if(k==n) flag=true;
 }
 if(flag) printf("The polygon can be packed in the circle.\n");
 else printf("There is no way of packing that polygon.\n");
 }
 return 0;
}

10008 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10008

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

bool so(pair<char,int> A,pair<char,int> B)
{
 if(A.second==B.second) return A.first<B.first;
 return A.second>B.second;
}
int main()
{
 int n; cin>>n; cin.ignore();
 map<char,int> M;
 while(n--)
 {
 string line;
 getline(cin,line);
 for(unsigned int i=0; i<line.length(); i++)
 if(toupper(line[i])<='Z' && toupper(line[i])>='A') M[toupper(line[i])]++;
 }
 vector<pair<char,int>> V;
 for(auto m:M)
 V.push_back(make_pair(m.first,m.second));
 sort(V.begin(),V.end(),so);
 for(auto v:V)
 cout<<v.first<<" "<<v.second<<'\n';
 return 0;
}

10018 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10018

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

bool check(long long int m)
{
 string n;
 n = to_string(m);
 for(unsigned int i=0; i<n.length()/2;i++)
 if(n[i]!=n[n.length()-i-1]) return false;
 return true;
}
long long int reverse(long long int m){

 if(m <= 0){return m;}
 vector<int> digits;
 while(m > 0){digits.push_back(m % 10); m /= 10;}
 long res(0);
 for(unsigned int p = 0; p < digits.size(); p++){res = 10 * res + digits[p];}
 return res;
}
int main(){

 long long int cases; cin>>cases;
 while(cases--)
 {
 long long int n,c=0,flag=1; cin>>n;
 while(1)
 {
 if(check(n)&&flag==0) break;
 flag=0;
 n+=reverse(n);
 c++;
 }
 cout<<c<<" "<<n<<endl;
 }
 return 0;
}

10019 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10019

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int a,b,flag=1;
void tobin(unsigned int n)
{
 if (n/2 != 0) {
 tobin(n/2);
 }
 if(flag==1) { if(n%2==1) a++; }
 else { if(n%2==1) b++; }
}

int main()
{
 int n; cin>>n;
 while(n--)
 {
 int num,f; cin>>num;
 tobin(num);
 flag=2;
 stringstream sstr;
 sstr << hex << to_string(num);
 sstr >> f;
 tobin(f);
 flag=1;
 cout<<a<<' '<<b<<'\n';
 a=b=0;
 }
 return 0;
}

10035 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10035

#include <bits/stdc++.h>
using namespace std;

int main()
{
 string a,b; cin>>a>>b;
 while(a!="0" || b!="0")
 {
 int res=0,cnt=0;
 int n,n1; n=a.length(); n1=b.length(); n--; n1--;
 for(int i = min(a.length()-1,b.length()-1); i>=0; i--)
 {
 if((a[n]-'0' + b[n1]-'0'+cnt)>9) { res++; cnt=1;}
 else cnt=0;
 n--; n1--;
 }
 for(int i=n;i>=0;i--){
 if((a[i]-'0'+cnt)>9) { res++; cnt=1;}
 else break;
 }
 for(int i=n1;i>=0;i--){
 if((b[i]-'0'+cnt)>9) { res++; cnt=1;}
 else break;
 }
 if(res==0) cout<<"No carry operation.\n";
 else if(res==1) cout<<"1 carry operation.\n";
 else cout<<res<<" carry operations.\n";
 cin>>a>>b;
 }
 return 0;
}

10036 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10036

#include <bits/stdc++.h>
using namespace std;

int arr[10005];
int memo[10005][105];
int K,N;

bool DP(int vali,int mod)
{
 if(vali==N && mod==0) return true;
 else if(vali==N) return false;
 int &best = memo[vali][mod];
 if(memo[vali][mod]!=-1) return best;
 return (best = (DP(vali+1,((mod+arr[vali])%K+K)%K)) || DP(vali+1,((mod-arr[vali])%K+K)%K));
}

int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 scanf("%d%d",&N,&K);
 for(int i=0; i<N;i++) scanf("%d",&arr[i]);
 memset(memo,-1,sizeof(memo));
 if(DP(1,(arr[0]+K)%K)) printf("Divisible\n");
 else printf("Not divisible\n");
 }
 return 0;
}

10038 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10038

#include<stdio.h>
#include<stdlib.h>
int main() {
 int n, A[3001], i;
 while(scanf("%d", &n) == 1) {
 for(i = 0; i < n; i++)
 scanf("%d", &A[i]);
 int mark[3001] = {0}, flag = 0;
 for(i = 1; i < n; i++) {
 if(abs(A[i] - A[i-1]) < n)
 mark[abs(A[i] - A[i-1])]++;
 }
 for(i = 1; i < n; i++)
 if(mark[i] == 0)
 flag = 1;
 if(flag)
 puts("Not jolly");
 else
 puts("Jolly");
 }
 return 0;
}

10050 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10050

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 int num,n,aux,sum,res=0; cin>>num;
 cin>>n;
 int arr[num+1];
 memset(arr,0,sizeof(arr));
 while(n--)
 {
 cin>>sum;
 aux=sum;
 while(aux<=num)
 {
 if(!(aux%7==6 || aux%7==0)&&arr[aux]==0) {arr[aux]=1; res++;}
 aux+=sum;
 }
 }
 cout<<res<<endl;
 }
 return 0;
}

10054 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10054

#include <bits/stdc++.h>
#define FOR(i, a, b) for(int i = (a); i < int(b); i++)
#define trav(i, v) for(auto &i : v)
#define has(c, e) ((c).find(e) != (c).end())
#define sz(c) int((c).size())
#define all(c) c.begin(), c.end()
#define debug(x) cerr << #x << ": " << x << endl;
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

struct edge{
int u, v;
bool used;
};
void Eulerdfs(int u, vi &nxt, vi &Euler, vector<edge> &E, const vector<vi> &adj) {
while(nxt[u] < adj[u].size()){
int go = adj[u][nxt[u]++];
if(!E[go].used){
E[go].used = 1;
int to = (E[go].u ^ E[go].v ^ u);
Eulerdfs(to, nxt, Euler, E, adj);
}
}
Euler.push_back(u);
}
vi Eulerian(int u, vector<edge> &E, const vector<vi> &adj) {
 vi nxt (adj.size(), 0); vi Euler;
 Eulerdfs(u, nxt, Euler, E, adj);
 reverse(Euler.begin(), Euler.end());
 return Euler;
}


int main()
{
 int cases,ca=1;
 scanf("%d",&cases);
 while(cases--)
 {
 int n; scanf("%d",&n);
 vector<edge> E;
 vector<vector<int>> adj(51);
 vector<int> degree(51);
 for(int i=0; i<n;i++)
 {
 int x,y; scanf("%d%d",&x,&y);
 E.push_back({x,y,false});
 adj[x].push_back(E.size()-1);
 adj[y].push_back(E.size()-1);
 degree[x - 1]++;
 degree[y - 1]++;
 }
 printf("Case #%d\n",ca++);
 bool good = true;
 int start = -1;
 for (int i = 0; i < 50; i++) {
 if (degree[i] % 2) {
 good = false;
 break;
 }
 else if (degree[i] && start == -1)
 start = i;
 }
 if(!good) printf("some beads may be lost\n");
 else{
 vector<int> res = Eulerian(start+1,E,adj);
 for(int i=0; i<sz(res)-1;i++) printf("%d %d\n",res[i],res[(i+1)%sz(res)]);
 }
 printf("\n");
 }
 return 0;
}

10055 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10055

#include <bits/stdc++.h>
using namespace std;

int main()
{
 long long int A,B;
 while(scanf("%lld%lld",&A,&B)!=EOF)
 {
 if(A > B) cout<< A - B<<endl;
 else cout<<B - A<<endl;
 }
}

1005A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,aux; cin>>n;
 vector<int> total;
 int res = 0;
 for(int i=0; i<n;i++)
 {
 cin>>aux;
 if(i!=0 && aux==1) {total.push_back(res); res=0;}
 res++;
 }
 total.push_back(res);
 cout<<total.size()<<'\n';
 for(unsigned int i=0; i<total.size();i++) if(i==0) cout<<total[i]; else cout<<" "<<total[i];
 return 0;
}

1005B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 string a,b; cin>>a; cin>>b;
 int flag=1,resu=a.length()+b.length();
 int al=a.length(); int bl=b.length();
 if (a==b) { flag=0; resu=0;}
 else if(al==bl) {
 for(int i=al; i>=0;i--) {
 if(a[i]!=b[i]) { if(flag==1) resu=(i+1)*2; break;} else flag=1;
 }
 }
 else
 {
 int aux=0,aa=al,bb=bl; aa--; bb--;
 for(int i=min(aa,bb); i>=0;i--){
 if(a[aa]!=b[bb]) break; else flag=1; aux++; aa--; bb--;
 }
 if(flag==1)
 {
 resu=(min(al,bl)-aux)*2;
 if(al>bl) resu+=(al-bl);
 else resu+=(bl-al);
 }
 }
 cout<<resu<<'\n';
 return 0;
}

1005C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 long long int nu; cin>>nu; int resu=0;
 int num[nu];
 map<long long int,int> M;
 for(int i=0; i<nu;i++) { cin>>num[i]; M[num[i]]++; }
 for (int i = 0; i < nu; i++)
 {
 int flag=0;
 for (int k = 0; k < 32 && flag==0; k++) {
 int x = (1 << k) - num[i];
 if(M.count(x) && (M[x] > 1 || (M[x] == 1 && x != num[i]))) flag=1;
 }
 if(flag==0) resu++;
 }
 cout<<resu<<'\n';
 return 0;
}

1005D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005D

#include <bits/stdc++.h>
using namespace std;

int main()
{
 string s;
 cin >> s;
 int n = s.length(), ans = 0;
 string t, z, q;
 for(int i=0; i<n; i++){
 t += s[i];
 z = s[i];
 q = t;
 q.erase(0, 1);
 long long x = stoll(t);
 long long y = stoll(z);
 long long xx;
 if(!q.empty()) xx = stoll(q);
 else xx = 1;
 if(x % 3 == 0 || y%3==0 || xx % 3 == 0){ ans++; t.clear();}
 else if(t.length() >= 18) t.erase(0,1);
 }
 cout << ans;
 return 0;
}

10065 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10065

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI acos(-1.0)
using namespace std;


struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
 bool operator <(point other) const{
 if (fabs(x-other.x)>EPS)return x<other.x;
 return y<other.y;
 }bool operator ==(point other) const{
 return (fabs(x-other.x)<EPS)&&
 (fabs(y-other.y)<EPS);
 }
 point operator +(point other) const{
 return point(x+other.x,y+other.y);
 }point operator -(point other) const{
 return point(x-other.x,y-other.y);
 }
};

int cross(const point &O, const point &A, const point &B)
{
 return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
}

double area(const vector<point> &P) {
 double result = 0.0, x1, y1, x2, y2;
 for (int i = 0; i < (int)P.size()-1; i++) {
 x1 = P[i].x; x2 = P[i+1].x;
 y1 = P[i].y; y2 = P[i+1].y;
 result += (x1 * y2 - x2 * y1);
 }
 return fabs(result) / 2.0; }
double calc_area(vector<point> P) {
 double ans = 0;
 int i;
 for(i = 0; i < P.size()-1; i++)
 ans += P[i].x*P[i+1].y - P[i].y*P[i+1].x;
 return fabs(ans)/2;
}

vector<point> CH(vector<point> P){
 vector<point> res;
 sort(P.begin(),P.end());
 int n = P.size();
 int m=0;
 for (int i=0;i<n;i++){
 while (m>1&&cross(res[m-2], res[m-1], P[i]) <= 0)res.pop_back(),m--;
 res.push_back(P[i]),m++;
 }
 for (int i = n-1, t = m+1; i >= 0; i--) {
 while (m>=t&&cross(res[m-2], res[m-1], P[i]) <= 0)res.pop_back(),m--;
 res.push_back(P[i]),m++;
 }
 return res;
}
int main()
{
 int n,ca=1;
 while(scanf("%d",&n)==1 && n!=0)
 {
 vector<point> P;
 double x,y;
 for(int i=0; i<n;i++)
 {
 scanf("%lf%lf",&x,&y);
 P.push_back(point(x, y));
 }
 P.push_back(P[0]);
 double val = area(P);
 P = CH(P);
 double res = calc_area(P);
 //printf("%.2lf %.2lf\n", val, res);
 printf("Tile #%d\n",ca++);
 printf("Wasted Space = %.2lf %%\n\n",(res-val)*100/res);

 }
 return 0;
}

10070 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10070

#include <bits/stdc++.h>
using namespace std;
int main()
{
 long long int leap,mod4,mod100,mod400,mod15,mod55,flag,space=0;
 string year;
 while(cin>>year)
 {
 if(space!=0) cout<<endl;
 leap = flag = mod4 = mod100 = mod400 = mod15 = mod55 = 0;
 for (unsigned int i=0; i<year.length(); i++)
 {
 mod4 = ((mod4 * 10) + (year[i]-'0')) % 4;
 mod100 = ((mod100 * 10) + (year[i]-'0')) % 100;
 mod400 = ((mod400 * 10) + (year[i]-'0')) % 400;
 mod15 = ((mod15 * 10) + (year[i]-'0')) % 15;
 mod55 = ((mod55 * 10) + (year[i]-'0')) % 55;
 }
 if ((mod4==0 && mod100!=0) || mod400==0){ printf("This is leap year.\n"); flag=1; leap=1; }
 if (mod15==0) { printf("This is huluculu festival year.\n"); flag=1; }
 if(leap==1&& mod55==0) printf("This is bulukulu festival year.\n");
 if(flag==0) printf("This is an ordinary year.\n");
 space=1;
 }
 return 0;
}

10071 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10071

#include<bits/stdc++.h>
using namespace std;
int main(){
 int v,t;
 while(scanf("%d%d",&v,&t)==2){
 cout<<2*v*t<<endl;
 }
 return 0;
}

10079 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10079

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 long long int n;
 while(scanf("%lld",&n) && n>-1)
 cout<<(n*(n+1))/2+1<<'\n';
 return 0;
}

10082 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10082

#include <bits/stdc++.h>
using namespace std;
#define Key "`1234567890-=QWERTYUIOP[]\\ASDFGHJKL;'ZXCVBNM,./"

int main() {
 int m = strlen(Key);
 string s;
 while (getline(cin,s)) {
 int n = s.length();
 for (int i=0; i<n; i++)
 if (s[i]==' ') printf(" ");
 else {
 for (int j=0; j<m; j++)
 if (s[i]==Key[j]) {
 printf("%c", Key[j-1]);
 break;
 }
 }
 cout << endl;
 }
}

101 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 int arr[n][n];
 map<int,int> M;
 for(int i=0; i<n;i++)
 for(int j=0; j<n;j++) { cin>>arr[i][j]; M[arr[i][j]]++; }
 int suma,flag,cm1,flag1;
 flag=suma=cm1=flag1=0;
 //filas
 for(int i=0; i<n && flag1==0 ;i++)
 {
 for(int j=0; j<n && flag1==0 ;j++) { suma+=arr[i][j]; }
 if(flag==0) { flag=1; cm1=suma; }
 if(suma!=cm1) flag1=1;
 suma=0;
 }
 //columnas
 for(int i=0; i<n && flag1==0 ;i++)
 {
 for(int j=0; j<n && flag1==0 ;j++) { suma+=arr[j][i]; }
 if(suma!=cm1) flag1=1;
 suma=0;
 }
 //diagonal principal
 for(int i=0; i<n && flag1==0 ;i++) { suma+=arr[i][i]; }
 if(suma!=cm1) flag1=1;
 //diagonal reversa
 suma=0;
 for(int i=0; i<n && flag1==0 ;i++) { suma+=arr[i][n-i-1]; }
 if(suma!=cm1) flag1=1;
 int corner,cm2=(cm1*4)/n;
 //comprobar numeros
 if(flag1==0)
 {
 flag1=2;
 for(int i=1; i<=n*n && flag1==2;i++) if(M[i]!=1) flag1=0;
 if(flag1!=0)
 {
 corner=arr[0][n-1]+arr[n-1][0]+arr[0][0]+arr[n-1][n-1];
 if(corner!=cm2) { flag1=0; break; }
 int center = n/2;
 if(n%2!=0)
 {
 if(arr[center][center]*4 != cm2) flag1=0;
 if((arr[0][center]+arr[center][0]+arr[n-1][center]+arr[center][n-1])!=cm2) flag1=0;
 }
 else
 {
 center--;
 if((arr[center][center]+arr[center+1][center+1]+arr[center][center+1]+arr[center+1][center]) != cm2) flag1=0;
 if((arr[0][center]+arr[0][center+1]+arr[center][0]+arr[center+1][0]+arr[n-1][center]+arr[n-1][center+1]+arr[center][n-1]+arr[center+1][n-1])!=(cm2*2)) flag1=0;
 }
 }
 }
 if(flag1==0) cout<<"DIABOLICO\n";
 else if(flag1==1) cout<<"NO\n";
 else if(flag1==2) cout<<"ESOTERICO\n";
 }
 return 0;
}

10102 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10102


#include <bits/stdc++.h>
using namespace std;

int main(){
 int n;
 while(scanf("%d",&n)==1){
 cin.ignore();
 vector<pair<int,int>> V,V2;
 int res = 0x3f3f3f3f;
 for(int i=0; i<n;i++){
 for(int j=0; j<n;j++){
 char c; scanf("%c",&c);
 int num = c-'0';
 if(num==3) V2.push_back({i,j});
 if(num==1) V.push_back({i,j});
 }
 cin.ignore();
 }
 int total=-0x3f3f3f3f;
 for(unsigned int i=0; i<V.size();i++)
 {
 for(unsigned int j=0; j<V2.size();j++){
 res = min(res,abs(V[i].first-V2[j].first)+abs(V[i].second-V2[j].second));
 }
 total=max(total,res);
 res = 0x3f3f3f3f;
 }
 printf("%d\n",total);
 }
 return 0;
}

10107 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10107

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n;
 vector<int> v;
 while(cin>>n)
 {
 v.push_back(n);
 sort(v.begin(),v.end());
 if(v.size()%2==1) cout<<v[(v.size()+1)/2-1]<<endl;
 else cout<<(v[(v.size()+1)/2-1]+v[(v.size()+1)/2])/2<<endl;
 }
 return 0;
}

10112 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10112

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 char c;
 point(){x=y=0; c='$';}
 point(double _x,double _y, char _c){x=_x,y=_y, c=_c;}
};


struct vec { double x, y; // name: `vec' is different from STL vector
 vec(double _x, double _y) : x(_x), y(_y) {} };

vec toVec(point a, point b) { // convert 2 points to vector a->b
 return vec(b.x - a.x, b.y - a.y); }

double dot(vec a, vec b) { return (a.x * b.x + a.y * b.y); }

double norm_sq(vec v) { return v.x * v.x + v.y * v.y; }

double angle(point a, point o, point b) { // returns angle aob in rad
 vec oa = toVec(o, a), ob = toVec(o, b);
 return acos(dot(oa, ob) / sqrt(norm_sq(oa) * norm_sq(ob))); }

double cross(vec a, vec b) { return a.x * b.y - a.y * b.x; }

// note: to accept collinear points, we have to change the `> 0'
// returns true if point r is on the left side of line pq
bool ccw(point p, point q, point r) {
 return cross(toVec(p, q), toVec(p, r)) > 0; }

double cross(point o, point a, point b) {
 return (a.x-o.x)*(b.y-o.y) - (a.y-o.y)*(b.x-o.x);
}
bool cmp(point a,point b){
 return a.c<b.c;
}
bool inPolygon(point test, vector<point> g){
 bool result = false;
 for (unsigned i = 0, j = g.size() - 1; i < g.size(); j = i++) {
 if ((g[i].y > test.y) != (g[j].y > test.y) &&
 (test.x < (g[j].x - g[i].x) * (test.y - g[i].y) / (g[j].y-g[i].y) + g[i].x)) {
 result = !result;
 }
 }
 return result;
}
double area(vector<point> P) {
 return abs(0.5 * (((P[2].y - P[0].y)*(P[1].x - P[0].x)) - ((P[1].y - P[0].y)*(P[2].x - P[0].x))));
}
// double area = Math.abs(0.5*(((tri.g[2].y-tri.g[0].y)(tri.g[1].x-tri.g[0].x))-((tri.g[1].y-tri.g[0].y)(tri.g[2].x-tri.g[0].x))));
int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 vector<point> V;
 vector<point> R;
 double x,y;
 char c;
 for(int i=0; i<n;i++)
 {
 cin.ignore();
 scanf("%c %lf %lf",&c,&x,&y);
 V.push_back(point(x,y,c));
 }
 double areaR = -INF;
 for(unsigned int i=0; i<V.size();i++)
 for(unsigned int j=i+1; j<V.size();j++)
 for(unsigned int k=j+1; k<V.size();k++)
 {
 vector<point> T; T.push_back(V[i]); T.push_back(V[j]); T.push_back(V[k]);
 int flag=0;
 for(unsigned int m=0; m<V.size() && flag==0;m++)
 {
 if(m==i || m==j || m==k) continue;
 if(inPolygon(V[m],T)) flag=1;
 }
 if(flag==0) {
 double res = area(T); if(res>areaR) { areaR=res; R=T; }
 //printf("%c %c %c %lf %lf\n",T[0].c,T[1].c,T[2].c,areaR, res);
 }
 }
 sort(R.begin(),R.end(),cmp);
 for(auto v:R)
 {
 printf("%c",v.c);
 }
 printf("\n");
 }
 return 0;
}

10114 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10114

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int loanDur, nRec,m;
 double downPayment, loan, decP[101],p;
 while (scanf("%d%lf%lf%d",&loanDur,&downPayment,&loan,&nRec)==4 && loanDur>-1) {
 while (nRec--) {
 cin >> m >> p;
 for (int i = m; i < 101; i++)
 decP[i] = p;
 }
 int now = 0;
 double monthlyPayment = loan / loanDur;
 double curVal = (loan + downPayment) * (1 - decP[0]);
 double curLoan = loan;
 while (curVal < curLoan) {
 now++;
 curLoan -= monthlyPayment;
 curVal *= (1-decP[now]);
 }
 cout << now << " month";
 if (now != 1) cout << "s";
 cout << endl;
 }
 return 0;
}

10141 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10141

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n, p, bestMet, tempMet, t = 1,flag=0;
 double tempPrice, bestPrice;
 string temp, best, junk;
 while (scanf("%d %d", &n, &p)==2 &&(n!=0||p!=0))
 {
 if(flag==1) cout<<endl;
 flag=1;
 bestMet = bestPrice = -1;
 cin.ignore();
 for (int i = 0; i < n; ++i) getline(cin, junk);
 while (p--)
 {
 getline(cin, temp);
 cin>>tempPrice>>tempMet;
 cin.ignore();
 for (int i = 0; i < tempMet; ++i) getline(cin, junk);
 if (tempMet > bestMet || (tempMet == bestMet && (tempPrice < bestPrice || bestPrice == -1)))
 {
 best = temp;
 bestPrice = tempPrice;
 bestMet = tempMet;
 }
 }
 printf("RFP #%d\n%s\n", t, best.c_str());
 t++;
 }
 return 0;
}

101482C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101482C

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int round(int num)
{
 if (num%10<5)return num-(num%10);
 return num+(10-(num%10));
}
int main()
{
 int n,d,aux,total=0;
 scanf("%d%d",&n,&d);
 int memo[n][d+1];
 int arracu[n];
 for(int i=0; i<n;i++) { scanf("%d",&aux); total+=aux; arracu[i]=total;}
 for(int i = 0; i<=d;i++)
 for(int j=0; j<n;j++)
 {
 if(i==0) memo[j][i]=round(arracu[j]);
 else
 {
 int mini = round(arracu[j]);
 for(int k=0; k<j;k++)
 {
 aux = round(memo[k][i-1]+round(arracu[j]-arracu[k]));
 mini=min(mini,aux);
 }
 memo[j][i]=mini;
 }
 }
 printf("%d\n",round(memo[n-1][d]));
 return 0;
}

101482H — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101482H

import java.util.*;
import java.util.stream.Collectors;

public class Main {

 private static Scanner sc = new Scanner(System.in);
 private static Set<Integer> visitados = new HashSet<>();
 private static int next = 1;

 public static void main(String[] args) {
 int n = sc.nextInt();

 Node[] nodes = new Node[n+1];

 for (int i = 1; i < nodes.length; i++) {
 nodes[i] = new Node();
 }

 while(sc.hasNextInt()){
 int parent = sc.nextInt();
 int child = sc.nextInt();

 nodes[parent].children.add(child);
 nodes[child].children.add(parent);
 }

 assignFreq(nodes, 1, next++, next++);

 for (int i = 1; i < nodes.length; i++) {
// if(nodes[i].freqA == -1 || nodes[i].freqB == -1){
// while (true);
// }
 System.out.println(nodes[i].freqA + " " + nodes[i].freqB);
 }
 }

 /**
 *
 * @param nodes
 * @param mFreq mandatory frecuency
 * @param vFreq voluntary frecuency
 */
 public static void assignFreq(Node[] nodes, int i, int mFreq, int vFreq){

 visitados.add(i);

 Node n = nodes[i];
 n.freqA = mFreq;
 List<Integer> children = n.children.stream().filter(e -> !visitados.contains(e)).collect(Collectors.toList());
 if(children.isEmpty()){
 n.freqB = vFreq;
 } else {
 n.freqB = next++;
 for (int i1 = 0; i1 < (children.size() + 1)/2; i1++) {
 int child = children.get(i1);
 assignFreq(nodes, child, n.freqB, n.freqA);
 }
 for (int i1 = (children.size() + 1)/2; i1 < children.size(); i1++) {
 int child = children.get(i1);
 assignFreq(nodes, child, n.freqA, n.freqB);
 }
 }
 }

 public static class Node {
 ArrayList<Integer> children = new ArrayList<>();
 int freqA = -1;
 int freqB = -1;
 }
}

101482J — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101482J

#include <bits/stdc++.h>
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int n; scanf("%d",&n);
 map<string,int> M;
 map<string,int> Maux;
 for(int i=0; i<n;i++)
 {
 string line; cin>>line;
 M[line]++;
 }
 for(int i=0; i<n;i++)
 {
 string line; cin>>line;
 Maux[line]++;
 }
 long long int res = 0;
 for(auto m:M)
 {
 if(Maux[m.first]==0) continue;
 else res+=min(Maux[m.first],m.second);
 }
 printf("%lld\n",res);
 return 0;
}

101620_CERC2017A_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101620_CERC2017A_CODEFORCES

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int r,p; scanf("%d%d",&r,&p);
 int peopleleft=0, peopleright=0;
 char matrix[r+3][11];
 int numasientos[r+3][11]; memset(numasientos,0,sizeof(numasientos));
 int arr[r+3]; memset(arr,0,sizeof(arr));
 char a;
 for(int i=0; i<r+3;i++)
 {
 for(int j=0; j<11;j++)
 {
 cin>>a; matrix[i][j]=a;
 if(a=='#' && j<5) peopleleft++;
 else if(a=='#' && j>5) peopleright++;
 if(a=='#') { arr[i]++; numasientos[i][j]++;}
 }
 }
 char letra = 'a';
 for(int i=0; i<p;i++)
 {
 //solve A and B rule
 int mini = INF,row=-1;
 /*
 ........... 0
 ---.---.--- 1
 ........... 2
 ---.---.--- 3
 ........... 4

 2 + 3 = 5/2 = 2
 */
 int middlexit = (r+3)/2;
 if(arr[1]!=9 || arr[middlexit+1]!=9)
 {
 //filas no completas cerca de salidas
 if(arr[middlexit+1]<arr[1]) row=middlexit+1;
 else row=1;
 }
 else
 {
 int flag=0;
 vector<int> V;
 for(int k=0; k<r+3;k++)
 {
 if(k==0 || k==r+2 || k==middlexit) continue;
 if(mini>arr[k]) { mini=arr[k]; row=k; flag=0; V.clear();}
 else if(mini==arr[k]) { if(flag==0) V.push_back(row); flag=1; V.push_back(k); }
 }
 if(flag==1)
 {
 flag=0;
 vector<int> aux;
 mini = INF;
 for(unsigned int k1=0; k1<V.size();k1++)
 {
 //r = 2 -> r = 5 -> 0 2 4
 int minaux = min(abs(V[k1]-0),min(abs(V[k1]-(middlexit)),abs(V[k1]-(r+2))));
 if(mini>minaux) { mini=minaux; row=V[k1]; flag=0; aux.clear();}
 else if(mini==minaux) {
 if(flag==0) aux.push_back(row); flag = 1; aux.push_back(V[k1]);
 }
 }
 if(flag==1)
 {
 sort(aux.begin(),aux.end());
 row = aux[0];
 }
 }
 }
 // ---.---.---
 // 012345678910
 //Seleccionar asiento
 if(numasientos[row][4]==0 || numasientos[row][6]==0)
 {
 if(numasientos[row][4]==0 && numasientos[row][6]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][4]++;
 matrix[row][4]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][6]++;
 matrix[row][6]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][4]==0)
 {
 peopleleft++;
 numasientos[row][4]++;
 matrix[row][4]= letra;
 }
 else{
 peopleright++;
 numasientos[row][6]++;
 matrix[row][6]= letra;
 }
 }
 else if(numasientos[row][2]==0 || numasientos[row][8]==0)
 {
 if(numasientos[row][2]==0 && numasientos[row][8]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][2]++;
 matrix[row][2]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][8]++;
 matrix[row][8]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][2]==0)
 {
 peopleleft++;
 numasientos[row][2]++;
 matrix[row][2]= letra;
 }
 else{
 peopleright++;
 numasientos[row][8]++;
 matrix[row][8]= letra;
 }

 }
 else if(numasientos[row][0]==0 || numasientos[row][10]==0)
 {
 if(numasientos[row][0]==0 && numasientos[row][10]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][0]++;
 matrix[row][0]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][10]++;
 matrix[row][10]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][0]==0)
 {
 numasientos[row][0]++;
 matrix[row][0]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][10]++;
 matrix[row][10]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][5]==0)
 {
 numasientos[row][5]++;
 matrix[row][5] = letra;
 }
 else{
 if(numasientos[row][1]==0 && numasientos[row][9]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][1]++;
 matrix[row][1]= letra;
 peopleleft++;
 }
 else{
 peopleright++;
 numasientos[row][9]++;
 matrix[row][9]= letra;
 }
 }
 else if(numasientos[row][1]==0)
 {
 peopleleft++;
 numasientos[row][1]++;
 matrix[row][1]= letra;
 }
 else{
 peopleright++;
 numasientos[row][9]++;
 matrix[row][9]= letra;
 }
 }
 arr[row]++;
 letra++;
 }
 //imprimir
 for(int i=0; i<r+3;i++)
 {
 for(int j=0; j<11;j++)
 cout<<matrix[i][j];
 cout<<'\n';
 }
 return 0;
}

101620_CERC2017H_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101620_CERC2017H_CODEFORCES

import java.util.*;

public class Main {

 public static final StringBuilder sb = new StringBuilder(10000);

 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 Node root = new Node(0);
 int lines = sc.nextInt();
 sc.nextLine();
 for (int i = 0; i < lines; i++) {
 String line = sc.nextLine();
 String[] temp = line.split(" ");
 int fileSize = Integer.parseInt(temp[1]);
 String[] folders = temp[0].split("/");
 root.add(folders, 1, fileSize);
 }
 int limit = sc.nextInt();
 root.calculateSize();
 root.recursivePrint("", limit);
 System.out.print(sb.toString());
 }

 static class Node {
 long size;
 long accumulatedSize = -1;
 boolean hasFolder = false;

 public Node(long size) {
 this.size = size;
 }

 Map<String, Node> children = new HashMap<>();

 public void add(String[] array, int position, int size){
 if(array.length - 1 == position){
 this.children.put(array[position], new Node(size));
 } else {
 if(!this.children.containsKey(array[position])){
 this.children.put(array[position], new Node(0));
 }
 this.hasFolder = true;
 this.children.get(array[position]).add(array, position+1, size);
 }
 }

 public long calculateSize(){
 if(this.accumulatedSize == -1){
 this.accumulatedSize = this.children.size() == 0 ? this.size: this.children.entrySet().stream().map(Map.Entry::getValue).mapToLong(Node::calculateSize).reduce(0, (a,b) -> a+b);
 }
 return this.accumulatedSize;
 }

 public void recursivePrint(String path, int limit){
 if(this.children.size() == 0) return;
 boolean expandIt = hasFolder && this.children.entrySet().stream().map(Map.Entry::getValue).anyMatch(e -> !e.children.isEmpty() && e.accumulatedSize >= limit);
 if(expandIt){
 sb.append("- ");
 }
 else if(hasFolder) {
 sb.append("+ ");
 }
 else {
 sb.append(" ");
 }
 sb.append(path).append('/').append(' ').append(accumulatedSize).append('\n');

 if(expandIt){
 this.children.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getKey)).forEach((e) -> e.getValue().recursivePrint(path + '/' + e.getKey(), limit));
 }
 }
 }
}

101635A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635A

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases;
 while(scanf("%d",&cases)!=EOF)
 {
 int m; cin>>m;
 map<long long int, long long int> a;
 long long int arr1[cases]; long long int arr2[m];
 for(int i=0; i<cases;i++) cin>>arr1[i];
 for(int i=0; i<m;i++) cin>>arr2[i];

 for(int i=0; i<cases;i++)
 for(int j=0; j<m;j++)
 {
 long long int res = arr2[j]-arr1[i];
 if(res<=0) continue;
 if(a.insert(pair<long long int,long long int>(res,1)).second == false)
 {
 long long int k = a.find(res)->second;
 k++;
 map<long long int,long long int>::iterator it = a.find(res);
 if (it != a.end())
 it->second = k;
 }
 }
 map<long long int,long long int>::iterator it = a.begin();
 long long int sol=0, resul=0;
 for (it=a.begin(); it!=a.end(); ++it)
 {
 if(it->second>sol){ resul=it->first; sol=it->second;}
 // cout << it->first <<" "<< it->second << '\n';
 }
 cout<<resul<<endl;
 }
 return 0;
}

101635F — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635F

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases;
 while(scanf("%d",&cases)!=EOF)
 {
 long long int num,a,b,res=0; cin>>num;
 for(int i=0; i<num;i++)
 {
 cin>>a>>b;
 res+=(a*b);
 }
 cout<<res/cases<<endl;
 }
 return 0;
}

101635J — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635J

#include <bits/stdc++.h>
using namespace std;
int main(){
long long int y,p,w; int cases;
 while(scanf("%d",&cases)!=EOF)
 {
 y=0; p=0; w=0;
 int arr1[cases]; int arr2[cases];
 for(int i=0; i<cases;i++) cin>>arr1[i];
 for(int i=0; i<cases;i++) cin>>arr2[i];

 long long int aw=0,ay=0,ap=0,aw1=0,ay1=0,ap1=0,aw2=0,ay2=0,ap2=0,aw3=0,ay3=0,ap3=0;

 for(int i=0; i<cases;i++)
 {
 if(i<3)
 {
 for(int j=0; j<cases;j++)
 {
 if(i==0){ aw+=arr1[j]; if(j+1>=cases) break; j++; ay+=arr1[j]; if(j+1>=cases) break; j++; ap+=arr1[j]; }
 else if(i==1){ ay+=arr1[j]; if(j+1>=cases) break; j++; ap+=arr1[j]; if(j+1>=cases) break; j++; aw+=arr1[j]; }
 else{ ap+=arr1[j]; if(j+1>=cases) break; j++; aw+=arr1[j]; if(j+1>=cases) break; j++; ay+=arr1[j]; }
 }
 if(i==0){ ap1=ap; aw1=aw; ay1=ay; }
 else if(i==1){ ap2=ap; aw2=aw; ay2=ay; }
 else{ ap3=ap; aw3=aw; ay3=ay; }
 y+=arr2[i]*ay; p+=arr2[i]*ap; w+=arr2[i]*aw; ap=0; aw=0; ay=0;
 }
 else
 {
 if(i%3==0){ y+=arr2[i]*ay1; p+=arr2[i]*ap1; w+=arr2[i]*aw1; }
 else if(i%3==1){ y+=arr2[i]*ay2; p+=arr2[i]*ap2; w+=arr2[i]*aw2; }
 else{ y+=arr2[i]*ay3; p+=arr2[i]*ap3; w+=arr2[i]*aw3; }
 }
 }
 cout<<y<<" "<<p<<" "<<w<<endl;
 }
 return 0;
}

101635K — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635K

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <algorithm>
using namespace std;
#define eps 1e-8
struct Pt {
 double x, y;
 Pt(double a = 0, double b = 0):
 x(a), y(b) {}
 bool operator<(const Pt &a) const {
 if(fabs(x-a.x) > eps) return x < a.x;
 return y < a.y;
 }
 bool operator==(const Pt &a) const {
 return fabs(x-a.x) < eps && fabs(y-a.y) < eps;
 }
 Pt operator+(const Pt &a) const {
 return Pt(x + a.x, y + a.y);
 }
 Pt operator-(const Pt &a) const {
 return Pt(x - a.x, y - a.y);
 }
 Pt operator/(const double val) const {
 return Pt(x / val, y / val);
 }
 Pt operator*(const double val) const {
 return Pt(x * val, y * val);
 }
};
typedef Pt Vector;
double dist(Pt a, Pt b) {
 return hypot(a.x - b.x, a.y - b.y);
}
double dot(Pt a, Pt b) {
 return a.x * b.x + a.y * b.y;
}
double cross2(Pt a, Pt b) {
 return a.x * b.y - a.y * b.x;
}
double cross(Pt o, Pt a, Pt b) {
 return (a.x-o.x)*(b.y-o.y)-(a.y-o.y)*(b.x-o.x);
}
int between(Pt a, Pt b, Pt c) {
 return dot(c - a, b - a) >= 0 && dot(c - b, a - b) >= 0;
}
int onSeg(Pt a, Pt b, Pt c) {
 return between(a, b, c) && fabs(cross(a, b, c)) < eps;
}
int cmpZero(double x) {
 if (fabs(x) < eps) return 0;
 return x > 0 ? 1: -1;
}
double ptToLine(Pt p, Pt s, Pt e) {
 double area = fabs(cross(p, s, e));
 double h = area / dist(s, e);
 return h;
}
int monotone(int n, Pt p[], Pt ch[]) {
 sort(p, p+n);
 int m = 0;
 for (int i = 0; i < n; i++) {
 while (m >= 2 && cross(ch[m-2], ch[m-1], p[i]) <= 0)
 m--;
 ch[m++] = p[i];
 }
 for (int i = n-1, t = m+1; i >= 0; i--) {
 while (m >= t && cross(ch[m-2], ch[m-1], p[i]) <= 0)
 m--;
 ch[m++] = p[i];
 }
 return m-1;
}
double convex_width(Pt pt[], int n) {
 if (n <= 2)
 return 0;
 double ret = 1e+60;
 pt[n] = pt[0];
 // rotating caliper
 for (int i = 0, j = 0; i < n; i++) {
 while (cross(pt[i], pt[i+1], pt[j+1]) >= cross(pt[i], pt[i+1], pt[j]))
 j = (j+1)%n;
 double dist = ptToLine(pt[j], pt[i], pt[i+1]);
 ret = min(ret, dist);
 }
 return ret;
}
int main() {
 static const int MAXN = 262144;
 static Pt pt[MAXN], ch[MAXN];
 int n, m;
 int64_t r;
 while (scanf("%d %lld", &n, &r) == 2) {
 for (int i = 0; i < n; i++) {
 int x, y;
 scanf("%d %d", &x, &y);
 pt[i] = Pt(x, y);
 }
 m = monotone(n, pt, ch);
 double mn_width = convex_width(ch, m);
 printf("%.17lf\n", mn_width);
 }
 return 0;
}

101889_COMPLETENARBBIRACS_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101889_COMPLETENARBBIRACS_CODEFORCES

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int k,n; scanf("%d%d",&k,&n);
 int arr[k]; memset(arr,0,sizeof(arr));
 int maxi=0,mini=INF,medio=0;
 int num1,num2,flag; num1=num2=flag=-1;
 for(int i=0; i<n;i++)
 {
 int x; scanf("%d",&x);
 arr[x-1]++;
 }
 for(int i=0; i<k;i++) {
 if(maxi<arr[i]) {maxi=arr[i]; num1=i+1;}
 if(mini>arr[i]) {mini=arr[i]; num2=i+1;}
 }
 if(n%k == 0) medio = n/k;
 else if(n%k==1) medio = n/k;
 else if(n%k==k-1) medio = (n+1)/k;
 else medio = INF;

 if(maxi==medio) flag=1;
 else if(mini==medio) flag=0;
 else if((maxi-1)==medio && (mini+1) == medio) flag=2;

 if(flag==-1) printf("*\n");
 else if(flag==0)printf("-%d\n",num1);
 else if(flag==1) printf("+%d\n",num2);
 else printf("-%d +%d\n",num1,num2);
 return 0;
}

101889_HARDCHOICE_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101889_HARDCHOICE_CODEFORCES

#include <bits/stdc++.h>
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int n1,n2,n3,m1,m2,m3;
 scanf("%d%d%d",&n1,&n2,&n3);
 scanf("%d%d%d",&m1,&m2,&m3);
 int ac = 0;
 if((m1-n1)>0) ac+=(m1-n1);
 if((m2-n2)>0) ac+=(m2-n2);
 if((m3-n3)>0) ac+=(m3-n3);
 printf("%d\n",ac);
 return 0;
}

10189 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10189

#include <bits/stdc++.h>
using namespace std;

int sx[]={1,-1,0,0,1,-1,-1,1}; //8 directions
int sy[]={0,0,1,-1,1,-1,1,-1};
char arr[105][105];
int arrsol[105][105];
int r,c;
void solve(int a, int b){
 for(int i=0;i<8;i++)
 {
 int I=a+sx[i];
 int J=b+sy[i];
 if(I>=0 && I<r && J>=0 && J<c){
 if(arr[I][J]!='*')
 arrsol[I][J]++;
 }
 }
}
int main(){
 int ca=1;

 while(scanf("%d%d",&r,&c)==2 && (r!=0 || c!=0))
 {
 if(ca!=1) cout<<endl;
 memset(arrsol,0,sizeof(arrsol));
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) cin>>arr[i][j];
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) if(arr[i][j]=='*') solve(i,j);
 printf("Field #%d:\n",ca++);
 for(int i=0; i<r;i++)
 {
 for(int j=0; j<c;j++)
 {
 if(arr[i][j]=='*') cout<<'*';
 else cout<<arrsol[i][j];
 }
 cout<<endl;
 }

 }
return 0;
}

10195 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10195

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 10e-8
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
 bool operator <(point other) const{
 if (fabs(x-other.x)>EPS)return x<other.x;
 return y<other.y;
 }
};

double perimeter(double ab, double bc, double ca) {
 return ab + bc + ca; }

double area(double ab, double bc, double ca) {
 // Heron's formula, split sqrt(a * b) into sqrt(a) * sqrt(b); in implementation
 double s = 0.5 * perimeter(ab, bc, ca);
 return sqrt(s) * sqrt(s - ab) * sqrt(s - bc) * sqrt(s - ca); }

double rInCircle(double ab, double bc, double ca) {
 double per = perimeter(ab, bc, ca);
 if(per==0) return 0;
 return area(ab, bc, ca) / (0.5 * per); }


int main()
{
 double d1,d2,d3;
 while(scanf("%lf%lf%lf",&d1,&d2,&d3)==3)
 {
 printf("The radius of the round table is: %.3lf\n",rInCircle(d1,d2,d3));
 }
 return 0;
}

101954A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101954A

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class die {

 public static void main(String[] args) throws IOException {
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 StringBuilder sb = new StringBuilder(1000);
 String[] lines = new String[3];
 lines[0] = br.readLine();
 lines[1] = br.readLine();
 lines[2] = br.readLine();
 if (checkpos(lines, ":::", ":o:", ":::")){
 sb.append(1);
 }
 else if (checkpos(lines, "o::", ":::", "::o")){
 sb.append(2);
 }
 else if (checkpos(lines, "::o", ":::", "o::")){
 sb.append(2);
 }
 else if (checkpos(lines, "o::", ":o:", "::o")){
 sb.append(3);
 }
 else if (checkpos(lines, "::o", ":o:", "o::")){
 sb.append(3);
 }
 else if(checkpos(lines, "o:o", ":::", "o:o")){
 sb.append(4);
 }
 else if (checkpos(lines, "o:o", ":o:", "o:o")){
 sb.append(5);
 }
 else if (checkpos(lines,"ooo",":::","ooo")){
 sb.append(6);
 }
 else if (checkpos(lines,"o:o","o:o","o:o")){
 sb.append(6);
 } else {
 sb.append("unknown");
 }
 System.out.println(sb.toString());
 }

 public static boolean checkpos(String[] lines, String l1, String l2, String l3){
 boolean ret = true;
 ret = ret && lines[0].equals(l1);
 ret = ret && lines[1].equals(l2);
 ret = ret && lines[2].equals(l3);
 return ret;
 }

}

101954B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101954B

#include <iostream>
#include <queue>
#include <string.h>
#define INF 0x3f3f3f3f
#define fi first
#define se second
using namespace std;

int res[5005][5005];
bool flag[5005][5005];
int sx[]={1,-1,0,0,1,-1,-1,1}; //8 directions
int sy[]={0,0,1,-1,1,-1,1,-1};
int c,r;
queue<pair<int,int> > f;

void BFS()
{
 while(!f.empty()){
 auto x=f.front();
 f.pop();
 for(int i=0;i<8;i++){
 auto y=x;
 y.fi+=sx[i];
 y.se+=sy[i];
 if(y.fi>=0&&y.fi<=c&&y.se>=0&&y.se<=r && !flag[y.fi][y.se]){
 flag[y.fi][y.se]=true;
 res[y.fi][y.se]=res[x.fi][x.se]+1;
 f.push(y);
 }
 }
 }
}

int main()
{
 int n,m,x,y; scanf("%d%d",&n,&m);
 memset(res,0,sizeof(res));
 memset(flag,false,sizeof(flag));
 c=r=5000;
 for(int i=0; i<n;i++)
 {
 scanf("%d%d",&x,&y);
 if(flag[x][y]==false) f.push({x,y});
 flag[x][y]=true;
 }
 BFS();
 for(int i=0; i<m;i++)
 {
 scanf("%d%d",&x,&y);
 printf("%d\n",res[x][y]);
 }
 return 0;
}

102 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int res;
int sum(char a)
{
 if((a+res)>90) return (a+res-90+64);
 else if((a+res)<65) return (a+res-65+91);
 return a+res;
}
int main()
{
 string line;
 while(getline(cin,line))
 {
 char aux = toupper(line[0]);
 res = 'P'-aux;
 int total = 0;
 if(line.length()==4&&sum(line[1])=='F'&&sum(line[2])=='I'&&sum(line[3])=='N') break;
 for ( auto &c : line ) c = toupper( c );
 for(unsigned int i=1; i<line.length();i++)
 {
 if(!(line[i]>='A'&&line[i]<='Z')) continue;
 else if(sum(line[i]) == 'I' || sum(line[i]) == 'A' || sum(line[i]) == 'E' ||sum(line[i]) == 'O' ||sum(line[i]) == 'U')
 total++;
 }
 cout<<total<<endl;
 }
 return 0;
}

102 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{

 int B[3], G[3], C[3];

 while (scanf("%d %d %d %d %d %d %d %d %d", &B[0], &G[0], &C[0], &B[1],&G[1], &C[1], &B[2], &G[2], &C[2])==9) {
 int min = INF, temp;
 string ans;
 //BCG
 temp = C[0] + G[0] + B[1] + G[1] + B[2] + C[2];
 if (temp < min) {
 min = temp;
 ans="BCG";
 }
 //BGC
 temp = C[0] + G[0] + B[1] + C[1] + B[2] + G[2];
 if (temp < min) {
 min = temp;
 ans="BGC";
 }
 //CBG
 temp = B[0] + G[0] + C[1] + G[1] + B[2] + C[2];
 if (temp < min) {
 min = temp;
 ans="CBG";
 }
 //CGB
 temp = B[0] + G[0] + B[1] + C[1] + G[2] + C[2];
 if (temp < min) {
 min = temp;
 ans="CGB";
 }
 //GBC
 temp = C[0] + B[0] + C[1] + G[1] + B[2] + G[2];
 if (temp < min) {
 min = temp;
 ans="GBC";
 }
 //GCB
 temp = C[0] + B[0] + B[1] + G[1] + G[2] + C[2];
 if (temp < min) {
 min = temp;
 ans="GCB";
 }
 cout<<ans<<" "<<min<<'\n';
 }
 return 0;
}

10209 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10209

#include <bits/stdc++.h>
#define PI acos(-1)
using namespace std;

int main()
{
 double a;
 while(scanf("%lf",&a)==1)
 {
 double x, y, z;
 z = a*a - a*a*PI/4;
 z -= a*a*PI/4 - a*a*PI/6 - ( a*a*PI/6 - a*a*sqrt(3.0)/4 );
 y = a*a - a*a*PI/4 - 2*z;
 x = a*a - 4*y - 4*z;
 printf("%.3lf %.3lf %.3lf\n", x, 4*y ,4*z);
 //https://www.mathalino.com/reviewer/plane-geometry/01-arcs-quarter-circle
 //https://www.mathalino.com/reviewer/plane-geometry/02-area-common-arcs-quarter-circles
 }
 return 0;
}

10221 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10221

#include <bits/stdc++.h>
#define PI acos(-1)
using namespace std;

double DEG_to_RAD(double d) { return d * PI / 180.0; }

int main()
{
 double s,a,arc; char st[4];
 while(scanf("%lf %lf %s",&s,&a,st)==3)
 {
 if(st[0]=='m') arc = a/=60;
 if(a > 180) a = 360-a;
 s += 6440; arc = s*DEG_to_RAD(a);
 double d= 2*sqrt(s*s-pow(s*cos(a/360*PI), 2));
 printf("%.6lf %.6lf\n", arc,d);
 }
 return 0;
}

10226 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10226

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n;
 scanf("%d\n\n",&n);
 while(n--)
 {
 int count=0;
 string aux;
 map<string,int> M;
 while(getline(cin,aux))
 {
 if(aux=="") break;
 count++;
 M[aux]++;
 }
 for(auto m:M)
 {

 cout<<m.first<<" "<<fixed<<setprecision(4)<<(double)(m.second*100)/count<<endl;
 }
 if(n!=0)
 cout<<endl;
 }
 return 0;
}

10242 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10242

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI acos(-1.0)
using namespace std;

struct point { double x, y; // only used if more precision is needed
 point() { x = y = 0.0; } // default constructor
 point(double _x, double _y) : x(_x), y(_y) {} // user-defined
 bool operator < (point other) const { // override less than operator
 if (fabs(x - other.x) > EPS) // useful for sorting
 return x < other.x; // first criteria , by x-coordinate
 return y < other.y; } // second criteria, by y-coordinate
 // use EPS (1e-9) when testing equality of two floating points
 bool operator == (point other) const {
 return (fabs(x - other.x) < EPS && (fabs(y - other.y) < EPS)); }
};

int main()
{
 point p1,p2,p3,p4,p5;
 while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&p1.x,&p1.y,&p2.x,&p2.y,&p3.x,&p3.y,&p4.x,&p4.y)==8)
 {
 if(p1==p3) {p5.x=p2.x-p1.x+p4.x; p5.y=p2.y-p1.y+p4.y; }
 else if(p1==p4) {p5.x=p2.x-p1.x+p3.x; p5.y=p2.y-p1.y+p3.y;}
 else if(p2==p3) {p5.x=p1.x-p2.x+p4.x; p5.y=p1.y-p2.y+p4.y;}
 else if(p2==p4) {p5.x=p1.x-p2.x+p3.x; p5.y=p1.y-p2.y+p3.y;}
 printf("%.3lf %.3lf\n",p5.x,p5.y);
 }
 return 0;
}

102465A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102465A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,on,off,res=0,k,num;
 scanf("%d",&n); on=n; off=0;
 bool arr[n+1];
 memset(arr,true,sizeof(arr));
 scanf("%d",&k);
 while(k--)
 {
 scanf("%d",&num);
 for(int i=num; i<=n; i+=num)
 {
 if(arr[i-1]) { off++; on--; arr[i-1]=false;}
 else {off--; on++; arr[i-1]=true;}
 }
 res = max(off,res);
 }
 printf("%d\n",res);
 return 0;
}

102501B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501B


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 map<string,int> M;
 int total=0;
 while(cases--){
 string s; cin>>s;
 M[s]++;
 total++;
 }
 int flag=0;
 for(auto m:M){
 if(m.second>(total-m.second)) { cout<<m.first<<endl; flag=1; break;}
 }
 if(flag==0) printf("NONE\n");
 return 0;
}

102501C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501C


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 set<int> S;
 for(int i=0; i<cases;i++){
 string num; cin>>num;
 if(num[0]=='-' || num.length()>8) continue;
 S.insert(stoi(num));
 }
 set<int>::iterator it = S.begin();
 int flag = 0,last=0;
 while (it != S.end())
 {
 if(*it==last) { it++; last++; continue; }
 else { flag=2; printf("%d\n",last); break;}
 it++;
 }
 if(flag==0) printf("%d\n",last);
 return 0;
}

102501F — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501F


#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-9
#define PI acos(-1.0)
typedef long long int ll;
struct point{
 double x,y;
 point(){x=y=0;}
 point(int _x,int _y){x=_x,y=_y;}
 bool operator <(point other) const{
 if (fabs(x-other.x)>EPS)return x<other.x;
 return y<other.y;
 }bool operator ==(point other) const{
 return (fabs(x-other.x)<EPS)&&
 (fabs(y-other.y)<EPS);
 }
 point operator +(point other) const{
 return point(x+other.x,y+other.y);
 }point operator -(point other) const{
 return point(x-other.x,y-other.y);
 }
};

double calc_area(vector<point> Pa) {
 double ans = 0;
 for (int i = 0; i < (int) Pa.size() - 1; i++)
 ans += Pa[i].x * Pa[i + 1].y - Pa[i].y * Pa[i + 1].x;
 return fabs(ans) / 2.0;
}

int main(){
 int cases; scanf("%d",&cases);
 double area = 0;
 while(cases--){
 int points; scanf("%d",&points);
 vector<point> V;
 for(int i=0; i<points;i++){
 int x,y; scanf("%d %d",&x,&y);
 V.push_back(point{x,y});
 }
 V.push_back(V[0]);
 area+=calc_area(V);
 }
 printf("%lld\n",(long long int)area);
}

102501I — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501I


#include <bits/stdc++.h>
using namespace std;

int main(){
 int n1,n2,n3; scanf("%d %d %d",&n1,&n2,&n3);
 printf("%d\n",((n1+1)*(n2+1))/(n3+1)-1);
 return 0;
}

102501K — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501K

#include <bits/stdc++.h>
using namespace std;

int N,E;
const int MAXN = 100100;
struct edge{
 int from, to;
 edge(){}
 edge(int a, int b){
 from = a;
 to = b;
 }
};

vector<edge> graph[MAXN];
vector<edge> rgraph[MAXN];

int main(){
 int CHECK;
 scanf("%d %d %d",&N,&E,&CHECK);
 bool visited[N+2],visited2[N+2];
 int visited1[N+2];
 memset(visited,false,sizeof(visited));
 set<int> C,S;
 for(int i=0;i<E;i++){
 int from, to; scanf("%d %d",&from, &to);
 if(to==CHECK && from!=CHECK) { C.insert(from); S.insert(from); visited[from]=true;} //nodes with direct path and diffent to check
 else if(to!=CHECK && from!=CHECK) { graph[from].push_back(edge(from,to)); rgraph[to].push_back(edge(to,from));}//delete edge
 }
 map<int,bool> M;
 memset(visited1,-1,sizeof(visited1));
 for(int i:C){
 if(M[i]) continue;
 memset(visited2,false,sizeof(visited2));
 queue<int> q; q.push(i);
 bool flag = true;
 while(!q.empty() && flag){
 int ele = q.front();
 q.pop();
 for(unsigned int j=0;j<graph[ele].size();j++){
 if(visited[graph[ele][j].to] && graph[ele][j].to!=i) {
 S.erase(i);
 M[i]=true;
 if(visited1[graph[ele][j].from]==-1){
 queue<int> test;
 test.push(graph[ele][j].from); visited1[i]=i;
 while(!test.empty()){
 int aux = test.front();
 test.pop();
 for(unsigned int l=0;l<rgraph[aux].size();l++){
 if(rgraph[aux][l].to!=i && visited1[rgraph[aux][l].to]==-1 && visited2[rgraph[aux][l].to]) test.push(rgraph[aux][l].to);
 if(visited2[rgraph[aux][l].to]) {
 visited1[rgraph[aux][l].to]=graph[ele][j].to;
 }
 }
 }
 }
 flag=false;
 break;
 }
 if(visited1[graph[ele][j].to]!=-1 && visited1[graph[ele][j].to]!=i){
 //cout<<"PODA\n";
 S.erase(i);
 M[i]=true;
 flag=false;
 break;
 }
 if(!visited2[graph[ele][j].to]) q.push(graph[ele][j].to);
 visited2[graph[ele][j].to]=true;
 }
 }
 }
 printf("%d\n",S.size());
 for(auto s:S){
 printf("%d\n",s);
 }
 return 0;
}

/*
5 7 0
1 0
2 1
1 3
3 2
2 0
3 4
4 0
*/

/*
5 6 0
2 0
1 0
1 6
3 6
6 2
2 3
*/

10260 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10260

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main()
{
 string aux;
 while(getline(cin,aux))
 {
 int aux1=-1,aux2;
 for(unsigned int i=0; i<aux.length();i++)
 {
 if(aux[i]=='B'||aux[i]=='F'||aux[i]=='P'||aux[i]=='V') aux2=1;
 else if(aux[i]=='C'||aux[i]=='G'||aux[i]=='J'||aux[i]=='K'||aux[i]=='Q'||aux[i]=='S'||aux[i]=='X'||aux[i]=='Z')aux2=2;
 else if(aux[i]=='D'||aux[i]=='T')aux2=3;
 else if(aux[i]=='L')aux2=4;
 else if(aux[i]=='M'||aux[i]=='N')aux2=5;
 else if(aux[i]=='R') aux2=6;
 else aux2=-1;
 if(aux2!=aux1 && aux2!=-1) cout<<aux2;
 aux1=aux2;
 }
 cout<<'\n';
 }
 return 0;
}

10263 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10263

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
};

double dist(point p1, point p2) { // Euclidean distance
 // hypot(dx, dy) returns sqrt(dx * dx + dy * dy)
 return hypot(p1.x - p2.x, p1.y - p2.y); } // return double

struct vec { double x, y; // name: `vec' is different from STL vector
 vec(double _x, double _y) : x(_x), y(_y) {} };

vec toVec(point a, point b) { // convert 2 points to vector a->b
 return vec(b.x - a.x, b.y - a.y); }

double dot(vec a, vec b) { return (a.x * b.x + a.y * b.y); }

double norm_sq(vec v) { return v.x * v.x + v.y * v.y; }

vec scale(vec v, double s) { // nonnegative s = [<1 .. 1 .. >1]
 return vec(v.x * s, v.y * s); } // shorter.same.longer

point translate(point p, vec v) { // translate p according to v
 return point(p.x + v.x , p.y + v.y); }

double distToLine(point p, point a, point b, point &c) {
 // formula: c = a + u * ab
 vec ap = toVec(a, p), ab = toVec(a, b);
 double u = dot(ap, ab) / norm_sq(ab);
 c = translate(a, scale(ab, u)); // translate a to c
 return dist(p, c); } // Euclidean distance between p and c

double distToLineSegment(point p, point a, point b, point &c) {
 vec ap = toVec(a, p), ab = toVec(a, b);
 double u = dot(ap, ab) / norm_sq(ab);
 if (u < 0.0) { c = point(a.x, a.y); // closer to a
 return dist(p, a); } // Euclidean distance between p and a
 if (u > 1.0) { c = point(b.x, b.y); // closer to b
 return dist(p, b); } // Euclidean distance between p and b
 return distToLine(p, a, b, c); } // run distToLine as above
int main()
{
 double x,y,x_,y_;
 while(scanf("%lf\n%lf",&x,&y)==2)
 {
 point pn = point(x,y);
 point resP;
 int n; scanf("%d",&n);
 double res = INF;
 vector<point> V;
 for(int i=0; i<n+1;i++)
 {
 scanf("%lf\n%lf",&x_,&y_);
 V.push_back(point(x_,y_));
 }
 for(int i=0; i<n;i++)
 {
 point p3;
 double resl = distToLineSegment(pn,V[i],V[i+1],p3);
 if(res>resl){ res=resl; resP = p3;}
 }

 printf("%.4lf\n%.4lf\n",resP.x,resP.y);
 }
 return 0;
}

10281 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10281

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {

 char str[90];
 int hh, mm, ss;
 double ans = 0, ltime = 0, rtime, v = 0;
 while(gets(str))
 {
 sscanf(str, "%d:%d:%d", &hh, &mm, &ss);
 rtime = hh + mm/60.0 + ss/3600.0;
 if(str[8] == '\0') {
 ans += (rtime-ltime)*v;
 printf("%s %.2lf km\n", str, ans);
 } else {
 ans += (rtime-ltime)*v;
 sscanf(str+8, "%lf", &v);
 }
 ltime = rtime;
 }
 return 0;
}

10282 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10282

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string line,se;
 map<string,string> M;
 getline(cin,line);
 while(line!="")
 {
 stringstream ss(line);
 ss >> line>> se;
 M[se] = line;
 getline(cin, line);
 }
 while(cin>>line)
 {
 if(M[line]!="") cout<<M[line]<<"\n";
 else cout<<"eh\n";
 }
 return 0;
}

10285 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10285

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int memo[105][105];
int arr[105][105];
int x,y;

int DP(int xval,int yval, int last)
{
 if(xval<0 || xval>=x || yval<0 || yval>=y || last<=arr[xval][yval]) return 0;
 int &best = memo[xval][yval];
 if(memo[xval][yval]!=-1) return best;
 return best = max(DP(xval+1,yval,arr[xval][yval]),max(DP(xval-1,yval,arr[xval][yval]),max(DP(xval,yval-1,arr[xval][yval]),DP(xval,yval+1,arr[xval][yval]))))+1;
}
int main(){
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 string name; cin>>name;
 scanf("%d%d",&x,&y);
 memset(memo,-1,sizeof(memo));
 int res = 0;
 for(int i=0; i<x;i++)
 for(int j=0; j<y;j++) scanf("%d",&arr[i][j]);
 for(int i=0; i<x;i++)
 for(int j=0; j<y;j++)
 {
 res=max(DP(i,j,INF),res);
 }
 cout<<name;
 printf(": %d\n",res);
 }
 return 0;
}

10286 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10286

#include <bits/stdc++.h>
#define PI acos(-1.0)
using namespace std;

int main()
{
 double d1,conv=sin(108*PI/180)/sin(63*PI/180); //radians = length
 while(scanf("%lf",&d1)==1)
 printf("%.10lf\n",d1*conv);
 return 0;
}

10295 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10295

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,m;
 while(scanf("%d%d",&n,&m)==2)
 {
 map<string,int> M;
 int salary;
 for(int i=0; i<n;i++) {string aux; cin>>aux; cin>>salary; M[aux]=salary;}
 while(m--)
 {
 salary=0;
 string aux;
 while(getline(cin,aux))
 {
 if(aux==".") break;
 istringstream iss(aux);
 vector<string> v((istream_iterator<string>(iss)),istream_iterator<string>());
 for(auto word:v) salary+=M[word];
 }
 cout<<salary<<endl;
 }
 }
 return 0;
}

10298 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10298

#include<bits/stdc++.h>
using namespace std;

int memo[1000005];

int solve(string str)
{
 int n = str.length();
 memo[0] = memo[1] = 0;
 int j = 0;
 for (int i = 2; i <= n; i++) {
 while (j && str[i - 1] != str[j]) j = memo[j];
 if (str[i - 1] == str[j]) j++;
 memo[i] = j;
 }
 return n/(n - memo[n]);
}

int main(){

 string line;
 while(getline(cin,line))
 {
 if(line==".") break;
 printf("%d\n",solve(line));
 }
 return 0;
}

1029A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1029A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,k,aux;
 string res,resu;
 cin>>n>>k>>res; aux=n-1;
 while(res.substr(0,aux)!=res.substr(n-aux)) aux--;
 for(unsigned int i=aux; i<res.length();i++) resu+=res[i];
 for(int i=0; i<k-1;i++) res+=resu;
 cout<<res<<'\n';
 return 0;
}

1029B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1029B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n; cin>>n;
 int arr[n];
 for(int i=0; i<n;i++) cin>>arr[i];
 int res=1,sum=1,aux=0;
 for (int i=0;i<n;i++)
 {
 for(int j=i+1; j<n;j++)
 {
 sum++;
 if(arr[j-1]*2>=arr[j]) { res= max(res,sum); aux=j;}
 else
 {
 i=j-1; sum=1; break;
 }
 }
 if(aux==n-1) break;
 }
 cout<<res<<'\n';
 return 0;
}

103 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 103

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int n;
double arr[21];

double f (double num)
{
 double value=0;
 for(int i=0; i<n;i++) { value+=(arr[i]*pow(num,(double)n-i-1));}
 num=value;
 if(num<0) return 0;
 else if(num>1) return 1;
 return num;
}
int main()
{
 while(scanf("%d",&n)==1 && n!=20)
 {
 n++;
 for(int i=0; i<n;i++) cin>>arr[i];
 double sum=0,rec;
 cin>>rec;
 for(int i=0; i<rec;i++)
 {
 sum+=((1/rec)*f(((double)i)/rec));
 }
 if(abs(sum-0.5)<=0.001) cout<<"JUSTO\n";
 else if(sum>0.5) cout<<"CAIN\n";
 else cout<<"ABEL\n";
 }
 return 0;
}

10300 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10300

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases,num,a,b,c;
 cin>>cases;
 while(cases--)
 {
 int res=0;
 cin>>num;
 while(num--)
 {
 cin>>a>>b>>c;
 res+=a*c;
 }
 cout<<res<<endl;
 }
return 0;
}

10305 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10305

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

typedef vector<int> vi;

vector<vi> graph;
vi dfs_num, answer;

void dfs(int node)
{
 dfs_num[node] = 1;
 for(unsigned int x=0; x<graph[node].size(); x++)
 if(dfs_num[graph[node][x]] == -1)
 dfs(graph[node][x]);
 answer.push_back(node);
}

int main()
{
int vertices, edges;
while(scanf("%d %d", &vertices, &edges) && (vertices!=0 || edges!=0))
{
 graph.assign(vertices, vi());
 dfs_num.assign(vertices, -1);
 int vertex1, vertex2;
 for(int i=1; i<=edges; i++)
 {
 scanf("%d %d", &vertex1, &vertex2);
 graph[vertex1 - 1].push_back(vertex2 - 1);
 }

 for(unsigned int x=0; x<graph.size(); x++)
 if(dfs_num[x] == -1)
 dfs(x);

 reverse(answer.begin(), answer.end());
 for(unsigned int x=0; x<answer.size(); x++)
 {
 if(x<answer.size() - 1) printf("%d ", answer[x]+1);
 else printf("%d\n", answer[x]+1);
 }
 answer.clear();
}
return 0;
}

10324 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10324

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string aux;
 int count=1;
 while(cin>>aux)
 {
 int cases,left,right;
 cin>>cases;
 cout<<"Case "<<count<<":\n";
 while(cases--)
 {
 cin>>left>>right;
 bool yes = true;
 if(left>right) {int aux1; aux1=left; left=right; right=aux1;};
 char a = aux[left];
 for(int i=left+1;i<=right;i++)
 {
 if(aux[i]!=a) {yes=false; break;}
 }
 if(yes) cout<<"Yes\n";
 else cout<<"No\n";
 }
 count++;
 }
 return 0;
}

10327 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10327

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n;
 while(scanf("%d",&n)==1)
 {
 int swaps=0;
 int arr[n];
 for(int i=0; i<n;i++) cin>>arr[i];
 for (int i = 0; i < n - 1; i++)
 for (int j = i+1; j < n; j++)
 if (arr[i] > arr[j])
 swaps++;
 cout<<"Minimum exchange operations : "<<swaps<<"\n";
 }
 return 0;
}

10336 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10336

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int sx[]={1,-1,0,0}; //4 directions
int sy[]={0,0,1,-1};

const int VAL = 105;
bool visited[VAL][VAL];
char arr[VAL][VAL];
int c,r;
void dfs(int a,int b, char c_)
{
 visited[a][b]=true;
 for(int i=0;i<4;i++){
 int I=a+sx[i];
 int J=b+sy[i];
 if(I>=0 && I<r && J>=0 && J<c && !visited[I][J]&& arr[I][J]==c_){
 visited[I][J]=true;
 dfs(I,J,c_);
 }
 }
}
bool cmp(pair<char,int> a,pair<char,int> b)
{
 if(a.second == b.second) return a.first<b.first;
 return a.second > b.second;
}
int main()
{
 int aux,ca=1;
 cin>>aux;
 while(aux--)
 {
 map<char,int> M;
 set<char> S;
 scanf("%d%d",&r,&c);
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) { cin>>arr[i][j]; S.insert(arr[i][j]);}
 for(auto s:S)
 {
 memset(visited,false,sizeof(visited));
 int cont = 0;
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++)
 if(arr[i][j]==s && !visited[i][j]) { dfs(i,j,s); cont++;}
 M[s]=cont;
 }

 vector<pair<char,int>> V;
 for(auto m:M)
 V.push_back(make_pair(m.first,m.second));
 sort(V.begin(), V.end(), cmp);
 printf("World #%d\n",ca++);
 for(auto v:V)
 printf("%c: %d\n",v.first,v.second);

 }
 return 0;
}

10339 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10339

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int k, m;
 while (scanf("%d%d", &k, &m) == 2)
 {
 unsigned int diff = abs(k-m);
 unsigned int numSeconds = (43200 * (86400 - k) / diff) % 43200 + 30;
 unsigned int hour = numSeconds / 3600 % 12;
 unsigned int min = numSeconds / 60 % 60;
 printf("%d %d %02d:%02d\n", k, m, hour == 0 ? 12 : hour, min);
 }
 return 0;
}

10340 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10340

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string input1,input2;
 while(cin>>input1)
 {
 cin>>input2;
 int T[input1.length()+1][input2.length()+1];
 for(unsigned int i=0; i<=input1.length();i++) T[i][0]=0;
 for(unsigned int i=0; i<=input2.length();i++) T[0][i]=0;

 for(unsigned int i=1; i <= input1.length(); i++)
 for(unsigned int j=1; j <= input2.length(); j++)
 {
 if(input1[i-1]==input2[j-1]) T[i][j]=T[i-1][j-1]+1;
 else T[i][j]=max(T[i-1][j],T[i][j-1]);
 }
 if(T[input1.length()][input2.length()] == input1.length()) cout<<"Yes\n";
 else cout<<"No\n";
 }
 return 0;
}

10346 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10346

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,m;
 while(scanf("%d%d",&n,&m)==2)
 {
 int total=0; total+=n;
 while(n/m!=0)
 {
 int aux = n%m;
 n/=m;
 total+=n;
 n+=aux;
 }
 cout<<total<<'\n';
 }
 return 0;
}

10347 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10347

#include <bits/stdc++.h>
#define EPS 10e-8
using namespace std;

int main()
{
 double d1,d2,d3;
 while(scanf("%lf%lf%lf",&d1,&d2,&d3)==3)
 {
 //Heron Theorem 4/3 with medians
 double res = (d1+d2+d3)/2;
 res=(res-d1)*(res-d2)*(res-d3)*res;
 if(res<EPS) printf("-1.000\n");
 else printf("%.3lf\n",sqrt(res)*4/3);
 }
 return 0;
}

103577H — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 103577H


#include<bits/stdc++.h>
#define mid ((l+r)/2)
using namespace std;
typedef double db;
db d;
db gett(db x1,db v1,db x2,db v2)
{
 db l=0,r=fabs((x1-x2)/(v1-v2));
 for(int i=1;i<=100;i++)
 {
 if(v2<0)
 {
 if(x2+v2*mid-min(d,x1+v1*mid)>1e-10)l=mid;
 else r=mid;
 }
 else
 {
 if(x2+v2*mid-min(d,x1+v1*mid)>1e-10)r=mid;
 else l=mid;
 }
 }
 return mid;
}
int main()
{
 db v0,v1,v2,t;
 db x0=0,x1=1,x2=0;
 cin>>d>>v0>>v1>>v2>>t;
 while(1)
 {
 db r=gett(x1,v1,x2,v2);
 if(r-t>1e-8||fabs(r-t)<=1e-8){printf("%.12f\n",x2+v2*t);return 0;}
 x2=x2+v2*r;
 x0=min(d,x0+v0*r);
 x1=min(d,x1+v1*r);
 t-=r;

 r=gett(x0,v0,x2,-v2);
 if(r-t>1e-8||fabs(r-t)<=1e-8){printf("%.12f\n",x2-v2*t);return 0;}
 x2=x2-v2*r;
 x0=min(d,x0+v0*r);
 x1=min(d,x1+v1*r);
 t-=r;
 if(fabs(x0-d)<1e-8)break;
 }
 printf("%.12f\n",x2);
 return 0;
}

10370 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10370

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n; cin>>n;
 while(n--)
 {
 int n1,res=0; cin>>n1;
 double average=0;
 double arr[n1];
 for(int i=0; i<n1;i++) { cin>>arr[i]; average+=arr[i];}
 average/=n1;
 for(int i=0; i<n1;i++) { if(arr[i]>average) res++; }
 printf("%.3lf%\n",(double)(((double)res/(double)n1)*100));
 }
 return 0;
}

104 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 104

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

bool isBalanced(int pi, int di, int pd, int dd, int &w) {
 bool left = true;
 if (pi == 0) {
 int pii, dii, pdi, ddi;
 scanf("%d%d%d%d",&pii,&dii,&pdi,&ddi);
 left = isBalanced(pii, dii, pdi, ddi, pi);
 }

 bool right = true;
 if (pd == 0) {
 int pid, did, pdd, ddd;
 scanf("%d%d%d%d",&pid,&did,&pdd,&ddd);
 right = isBalanced(pid, did, pdd, ddd, pd);
 }
 w = pi + pd;
 return left && right && pi*di == pd*dd;
}
int main()
{
 int pd,pi,di,dd,w;
 while(scanf("%d%d%d%d",&pi,&di,&pd,&dd)==4 && (pi!=0||pd!=0||di!=0||dd!=0))
 {
 bool balanced=isBalanced(pi,di,pd,dd,w);
 if(balanced) cout<<"SI\n";
 else cout<<"NO\n";
 }
 return 0;
}

10405 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10405

#include<bits/stdc++.h>
using namespace std;
string X;
string Y;
int memo[1005][1005];
bool mark[1005][1005];
int lcs(int m, int n )
{
 if (m == 0 || n == 0) return 0;
 int &best= memo[m][n];
 if(mark[m][n]) return best;
 mark[m][n]=true;
 if (X[m-1] == Y[n-1]) return best=1+lcs(m-1, n-1);
 return best=max(lcs(m, n-1),lcs(m-1, n));
}
int main()
{
 while(getline(cin,X))
 {
 memset(mark,false,sizeof(mark));
 memset(memo,0,sizeof(memo));
 getline(cin,Y);
 printf("%d\n", lcs(X.length(),Y.length()));
 }
 return 0;
}

10420 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10420

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n; cin>>n;
 map<string,int> M;
 string str,line;
 while(n--)
 {
 cin>>str; getline(cin,line);
 M[str]++;
 }
 for(auto m:M)
 {
 cout<<m.first<<' '<<m.second<<'\n';
 }
 return 0;
}

10424 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10424

#include <bits/stdc++.h>
using namespace std;

int sumName(string name1)
{
 int sum1=0;
 for(unsigned int i=0; i<name1.length();i++)
 {
 if(name1[i]>='A'&&name1[i]<='Z')
 sum1+=(name1[i]-64);
 else if(name1[i]>='a'&&name1[i]<='z')
 sum1+=(name1[i]-96);
 }
 return sum1;
}
int main()
{
 string name1,name2;
 while(getline(cin,name1))
 {
 getline(cin,name2);
 int sum1=0,sum2=0;
 sum1=sumName(name1);
 if(sum1%9==0) sum1=9;
 else sum1%=9;
 sum2=sumName(name2);
 if(sum2%9==0) sum2=9; //Nos devuelve la suma de digitos exacta
 else sum2%=9;
 if(sum1>=sum2) printf("%.2f %%\n",sum2*100.0/sum1);
 else printf("%.2f %%\n",sum1*100.0/sum2);
 }
 return 0;
}

10432 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10432

#include <bits/stdc++.h>
using namespace std;

int main()
{
 double r,n;
 while(scanf("%lf%lf",&r,&n)==2)
 printf("%.3lf\n",r*r*n*sin(2*acos(-1)/n)/2); //area of polygon with circumradio (r*r*n*sin(360/n))/2;
 return 0;
}

10450 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10450

#include <bits/stdc++.h>
using namespace std;

int main()
{

 string input1;
 while(getline(cin,input1))
 {
 string input2; getline(cin,input2);
 int T[input1.length()+1][input2.length()+1];
 for(unsigned int i=0; i<=input1.length();i++) T[i][0]=0;
 for(unsigned int i=0; i<=input2.length();i++) T[0][i]=0;

 for(unsigned int i=1; i <= input1.length(); i++)
 {
 for(unsigned int j=1; j <= input2.length(); j++)
 {
 if(input1[i-1]==input2[j-1]) T[i][j]=T[i-1][j-1]+1;
 else T[i][j]=max(T[i-1][j],T[i][j-1]);
 }
 }
 cout<<T[input1.length()][input2.length()]<<'\n';
 }
 return 0;
}

10465 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10465

#include <bits/stdc++.h>
#define INF 0x3f3f3f
using namespace std;

int n,m,t;
bool visited1[10005];
bool visited[10005];
int memo[10005];

//all possible combinations
void possible(int time)
{
 if(time>t) return;
 if(visited1[time]) return;
 visited1[time]=true;
 possible(time+n);
 possible(time+m);
}
//less beer combinations
int DP(int time)
{
 if(time<0) return -INF;
 if(time==0) return 0;
 int &best = memo[time];
 if(visited[time]) return best;
 visited[time]=true;
 return best=max(DP(time-n),DP(time-m))+1;
}
int main()
{
 while(scanf("%d%d%d",&n,&m,&t)==3)
 {
 memset(memo,-1,sizeof(memo));
 memset(visited1,false,sizeof(visited1));
 memset(visited,false,sizeof(visited));
 possible(0);
 if(!visited1[t]){
 for(int i=t; i>=0; i--) //less time = less beer
 if(visited1[i]) { printf("%d %d\n",DP(i),(t-i)); break;}
 }
 else printf("%d\n",DP(t));
 }
 return 0;
}

10466 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10466

#include <bits/stdc++.h>
#define PI acos(-1.0)
using namespace std;

int main()
{
 int n,T;
 while(scanf("%d%d",&n,&T)==2)
 {
 double r,t,x=0,y=0;
 for(int i=0; i<n;i++)
 {
 scanf("%lf %lf",&r,&t);
 double angle = T * PI * 2.0 / t;
 x += r * cos(angle); y += r * sin(angle);
 if(i==0) printf("%.4lf", sqrt(x * x + y * y));
 else printf(" %.4lf", sqrt(x * x + y * y));
 }
 printf("\n");
 }
 return 0;
}

10469 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10469

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 unsigned int a,b;
 while(scanf("%d%d",&a,&b)==2)
 {
 printf("%d\n",a^b);
 }
 return 0;
}

10474 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10474

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,m,cases=1;
 while(scanf("%d%d",&n,&m)==2 && (n!=0 || m!=0))
 {
 int arr[n];
 int query;
 for(int i=0; i<n;i++) cin>>arr[i];
 sort(arr,arr+n);
 printf("CASE# %d:\n",cases++);
 for(int i=0; i<m;i++)
 {
 cin>>query;
 int flag=1;
 for(int i=0; i<n;i++)
 {
 if(arr[i]==query) { printf("%d found at %d\n",query,i+1); flag=0; break;}
 else if(arr[i]>query) { printf("%d not found\n",query); flag=0; break;}
 }
 if(flag==1) printf("%d not found\n",query);
 }
 }
 return 0;
}

10487 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10487

#include <bits/stdc++.h>
using namespace std;
int main(){
 long long int A[1000];
 long long int ans, cur, mid;

 int N, q, cs=1;
 while(scanf("%d", &N) == 1 && N){
 printf("Case %d:\n", cs++);

 for( int i = 0; i < N; i++ )
 cin>>A[i];

 cin>>q;

 while(q--){
 cin>>mid;
 ans = A[0] + A[1];
 for(int i = 0; i < N; i++ ){
 for( int j = i+1; j < N; j++ ){
 cur = A[i] + A[j];
 if( abs(ans - mid) > abs(cur - mid)) ans = cur;
 }
 }
 printf("Closest sum to %lld is %lld.\n", mid, ans);
 }
 }
 return 0;
}

105 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 105

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int i=0,valor1=0,valor2=0;
 double media=0,domingo;
 vector<string> dia= {"MARTES","MIERCOLES","JUEVES","VIERNES","SABADO","DOMINGO"};
 double numero=0,maxi=INT_MIN,mini=INT_MAX;
 while(scanf("%lf",&numero)!=EOF)
 {
 if(numero==-1)
 break;
 if(maxi<numero)
 {
 maxi=numero;
 valor1=i;
 }
 if(mini>numero)
 {
 mini=numero;
 valor2=i;
 }
 if(i==5)
 domingo=numero;

 media+=numero;
 i++;
 if(i==6)
 {
 i=0;
 media/=6;
 cout << dia[valor1]<<" "<<dia[valor2];
 if(media==domingo)
 cout<<" EMPATE\n";
 else if(media>domingo)
 cout<<" NO\n";
 else
 cout<<" SI\n";

 media=0; maxi=INT_MIN,mini=INT_MAX;
 }
 }
 return 0;
}

10550 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10550

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int start, first, second, third;
 while (scanf("%d %d %d %d", &start, &first, &second, &third), (start || first || second || third))
 {
 printf("%d\n", 1080 + ((start - first + 40) % 40 + (second - first + 40) % 40 + (second - third + 40) % 40) * 9);
 }
}

1055A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1055A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,s; scanf("%d%d",&n,&s); s--;
 bool res[n];
 for(int i=0; i<n;i++)
 {
 int num; scanf("%d",&num);
 if(num==1) res[i]=true;
 else res[i]=false;
 }
 bool res1[n];
 for(int i=0; i<n;i++)
 {
 int num; scanf("%d",&num);
 if(num==1) res1[i]=true;
 else res1[i]=false;
 }
 bool resn=false;
 for(int i=n-1; i>=s && !resn;i--)
 {
 if(res[i] && res1[i] && res1[s]) resn=true;
 }
 if((resn && res[0]) || (res[0] && res[s])) printf("YES\n");
 else printf("NO\n");
 return 0;
}

1055B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1055B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 long long int n,m,l,q,p,d,res=0; scanf("%lld%lld%lld",&n,&m,&l);
 long long int arr[n];
 for(int i=0; i<n;i++) scanf("%lld",&arr[i]);
 bool first=false;
 int memo[n]; memset(memo,0,sizeof(memo));
 for(int i=0; i<n;i++)
 {
 if(arr[i]>l && first) res--;
 else first=false;
 if(arr[i]>l) { first=true; res++; memo[i]=1; }
 }
 while(m--)
 {
 scanf("%lld",&q);
 if(q==0){
 printf("%lld\n",res);
 }
 else{
 scanf("%lld%lld",&p,&d);
 arr[p-1]+=d;
 if(arr[p-1]>l && memo[p-1]!=1)
 {
 memo[p-1]=1; res++;
 if(p!=n) { res-=memo[p]; }
 if(p!=1) { res-=memo[p-2];}
 }
 }
 }
 return 0;
}

1056A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1056A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; scanf("%d",&n);
 map<int,int> M;
 for(int i=0; i<n;i++)
 {
 int r; scanf("%d",&r);
 for(int j=0; j<r;j++)
 {
 int aux; scanf("%d",&aux);
 M[aux]++;
 }
 }
 int flag=1;
 for(auto m:M)
 {
 if(m.second == n)
 {
 if(flag==1) { flag=2; printf("%d",m.first);}
 else printf(" %d",m.first);
 }
 }
 return 0;
}

1056B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1056B

//B
#include <bits/stdc++.h>
using namespace std;
int main()
{
 int n,m; scanf("%d%d",&n,&m);
 long long int res = 0;
 if(m==1) { res=n; printf("%lld",res*res); }
 else if(m>n) {
 for(int i=1; i<=n;i++)
 for(int j=1; j<=i;j++)
 if((i*i+j*j) % m ==0)
 {
 if(i==j) res++; else res+=2;
 }
 printf("%lld",res);
 }
 else{
 for(int i=1; i<=m;i++)
 for(int j=1; j<=i;j++)
 if((i*i+j*j) % m ==0)
 {
 if(i==j) res++; else res+=2;
 }

 //sobrante
 long long int p =0;
 for(int i=1; i<=n%m;i++)
 for(int j=1; j<=m;j++)
 if((i*i+j*j) % m ==0) p++;

 int aux = n/m;
 res=res*aux*aux; res+=p*(n/m)*2;
 p=0;
 for(int i=1; i<=n%m;i++)
 for(int j=1; j<=n%m;j++)
 if((i*i+j*j) % m ==0) p++;
 res+=p;
 printf("%lld",res);
 }
 return 0;
}

10583 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10583

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

const int MAXN = 50005;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
 bool operator<(const edge &other)const{ // sobrecarga de operadores para ordenar
 return weight < other.weight;
 }
};

struct UF{
 int parents[MAXN];
 int sz[MAXN];
 int components;
 int mst_sum;
 UF(int n){
 for(int i=0;i<n;i++){
 parents[i] = i; sz[i] = 1;
 }
 components = n;
 mst_sum = 0;
 }
 int find(int n){
 return n == parents[n] ? n : find(parents[n]);
 }
 bool isConnected(int a, int b){
 return find(a) == find(b);
 }
 void connect(int a, int b, int weight){
 if(isConnected(a, b)) return;
 int A,B; A = find(a); B = find(b);
 if(sz[A] > sz[B]){
 parents[B] = A;
 sz[A] += sz[B];
 }
 else{
 parents[A] = B;
 sz[B] += sz[A];
 }
 mst_sum += weight;
 components--;
 }
};

int main(){
 int N,E,c=1;
 while(scanf("%d %d",&N,&E)==2 && (N!=0||E!=0))
 {
 vector<edge> edges;
 UF uf = UF(N);
 for(int i=0; i<E;i++)
 {
 int from,to; scanf("%d %d",&from,&to);
 from--; to--;
 edges.push_back(edge(from,to,1));
 }
 sort(edges.begin(), edges.end());
 for(int i=0;i<E;i++) uf.connect(edges[i].from, edges[i].to, edges[i].weight);
 printf("Case %d: %d\n",c++,uf.components);
 }
 return 0;
}

10585 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10585

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 0
#define PI acos(-1.0)
using namespace std;

struct point{
 long long int x,y;
 point(){x=y=0;}
 point(long long int _x,long long int _y){x=_x,y=_y;}
 bool operator <(point other) const{
 if (x!=other.x)return x<other.x;
 return y<other.y;
 }
};

int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 long long int x,y;
 int n; scanf("%d",&n);
 vector<point> V;
 for(int i=0; i<n;i++)
 {
 scanf("%lld%lld",&x,&y);
 V.push_back(point(x,y));
 }
 sort(V.begin(),V.end());
 point res; res.x = V[0].x + V[n-1].x ; res.y= V[0].y + V[n-1].y ;
 int flag=0;
 for(int i=1; i<n/2 && flag==0;i++)
 {
 if(!(V[i].x + V[n-i-1].x == res.x && V[i].y + V[n-i-1].y == res.y)) flag++;
 }
 if(flag==0) printf("yes\n");
 else printf("no\n");
 }
 return 0;
}

10589 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10589

#include <bits/stdc++.h>
#define PI acos(-1)
using namespace std;

int main()
{
 double a,x,y; int n;
 while(scanf("%d %lf",&n,&a)==2 && (n!=0 || a!=0))
 {
 int m = 0;
 for(int i = 0; i < n; i++) {
 scanf("%lf %lf", &x, &y);
 if(x*x+y*y <= a*a && (x-a)*(x-a)+y*y <= a*a && x*x+(y-a)*(y-a) <= a*a && (x-a)*(x-a)+(y-a)*(y-a) <= a*a)
 m++;
 }
 printf("%.5lf\n", (double)m*a*a/n);
 }
 return 0;
}

10594 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10594

#include <bits/stdc++.h>
#define INF LLONG_MAX
#define MAX_V 1+2*100
#define MAX_E 2*10001
using namespace std;

typedef long long edge_type;
int V,E,previ[MAX_V],last[MAX_V];
edge_type flowVal,flowCost,cap[MAX_E],cost[MAX_E],to[MAX_E],nexti[MAX_E],dist[MAX_V],pot[MAX_V];

void init(){
 memset(last,-1,sizeof(last));
 E = 0;
}
void add_edge(int u, int v, edge_type capacity, edge_type cst){
 to[E] = v, cap[E] = capacity;
 cost[E] = cst, nexti[E] = last[u];
 last[u] = E++;
 to[E] = u, cap[E] = 0;
 cost[E] = -cst, nexti[E] = last[v];
 last[v] = E++;
}

void mincostmaxflow(int s, int t){
 flowVal = flowCost = 0;
 memset(pot,0,sizeof(pot));

 while(true){
 memset(previ,-1,sizeof(previ));
 for(int i = 0;i<V;++i) dist[i] = INF;
 set< pair<edge_type, int> > Q;
 Q.insert(make_pair(0,s));
 dist[s] = previ[s] = 0;
 while(!Q.empty()){
 int aux = Q.begin()->second; Q.erase(Q.begin());
 for(int e = last[aux];e!=-1;e = nexti[e]){
 if(cap[e]<=0) continue;
 edge_type new_dist = dist[aux]+cost[e]+pot[aux]-pot[to[e]];
 if(new_dist<dist[to[e]]){
 Q.erase(make_pair(dist[to[e]],to[e]));
 dist[to[e]] = new_dist;
 previ[to[e]] = e;
 Q.insert(make_pair(new_dist,to[e]));
 }
 }
 }
 if (previ[t]==-1) break;
 edge_type f = INF;
 for(int i = t;i!=s;i = to[previ[i]^1]) f = min(f,cap[previ[i]]);
 for(int i = t;i!=s;i = to[previ[i]^1]){
 cap[previ[i]] -= f;
 cap[previ[i]^1] += f;
 }
 flowVal += f;
 flowCost += f*(dist[t]-pot[s]+pot[t]);

 for(int i = 0;i<V;++i) if (previ[i]!=-1) pot[i] += dist[i];
 }
}


int main(){
 int N,M,u[5000],v[5000];
 long long cst[5000],D,K;

 while(scanf("%d %d",&N,&M)==2){
 V = 2*N+1;

 for(int i = 0;i<M;++i){
 scanf("%d %d %lld",&u[i],&v[i],&cst[i]);
 --u[i]; --v[i];
 }
 scanf("%lld %lld",&D,&K);

 init();
 add_edge(0,1,D,0);

 for(int i = 0;i<N;++i) add_edge(1+2*i,1+2*i+1,INF,0);

 for(int i = 0;i<M;++i){
 add_edge(1+2*u[i]+1,1+2*v[i],K,cst[i]);
 add_edge(1+2*v[i]+1,1+2*u[i],K,cst[i]);
 }

 mincostmaxflow(0,2*N-1);

 if(flowVal!=D) printf("Impossible.\n");
 else printf("%lld\n",flowCost);
 }
 return 0;
}

106 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 106

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string line;
 while(getline(cin,line))
 {
 int flag=0;
 if(line=="0") break;
 int total = 0;
 if(line.length()<14)
 {
 for(int i=line.length()-2; i>=0;i--)
 {
 if(flag==0)
 {
 total+=(line[i]-48)*3; flag=1;
 }
 else
 {total+=line[i]-48; flag=0;}
 }
 if((total+line[line.length()-1]-48)%10==0)
 {
 cout<<"SI";
 if(line.length()>8)
 {
 if(line.length()<13) cout<<" EEUU";
 else if(line.substr(0,3)=="380") cout<<" Bulgaria";
 else if(line.substr(0,3)=="539") cout<<" Irlanda";
 else if(line.substr(0,3)=="560") cout<<" Portugal";
 else if(line.substr(0,3)=="759") cout<<" Venezuela";
 else if(line.substr(0,3)=="850") cout<<" Cuba";
 else if(line.substr(0,3)=="890") cout<<" India";
 else if(line.substr(0,2)=="50") cout<<" Inglaterra";
 else if(line.substr(0,2)=="70") cout<<" Noruega";
 else if(line[0]=='0') cout<<" EEUU";
 else cout<<" Desconocido";
 }
 }
 else cout<<"NO";
 }
 else cout<<"NO";
 cout<<'\n';
 }
return 0;
}

10608 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10608

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
const int MAXN = 100100;

struct UF{
 int parents[MAXN];
 int sz[MAXN];
 int components;
 int mst_sum;
 UF(int n){
 for(int i=0;i<n;i++){
 parents[i] = i; sz[i] = 1;
 }
 }
 int find(int n){
 return n == parents[n] ? n : find(parents[n]);
 }
 bool isConnected(int a, int b){
 return find(a) == find(b);
 }
 int connect(int a, int b){
 int A,B; A = find(a); B = find(b);
 if(A!=B)
 {
 if(sz[A] > sz[B]){
 parents[B] = A;
 sz[A] += sz[B];
 return sz[A];
 }
 else{
 parents[A] = B;
 sz[B] += sz[A];
 return sz[B];
 }
 }
 return sz[A];
 }
};

int a=1;
int N=100000,E;

int main(){
 int cases;
 cin>>cases;
 while(cases--)
 {
 map<string,int> M;
 int contador=1;
 string a,b;
 cin>>E;
 UF uf = UF(N);
 for(int i=0;i<E;i++)
 {
 cin>>a>>b;
 if(M[a]==0) {M[a]=contador; contador++;}
 if(M[b]==0) {M[b]=contador; contador++;}
 cout<<uf.connect(M[a],M[b])<<endl;
 }
 }
 return 0;
}

1061A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1061A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,S; scanf("%d%d",&n,&S);
 if(S%n==0) printf("%d",S/n);
 else printf("%d",S/n+1);
 return 0;
}

1061B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1061B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 long long int n,s, c=0;
 scanf("%lld%lld",&n,&s);
 int arr[n]; s=0;
 for(int i=0;i<n;i++) {scanf("%d",&arr[i]); s+=arr[i]; }
 sort(arr,arr+n);
 for(int i=0;i<n;i++)c+=arr[i]>c;
 printf("%lld",s-n-arr[n-1]+c); //total blocks - number of blocks top - number of block rigth + blocks
 return 0;
}

1064A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1064A

#include <bits/stdc++.h>

using namespace std;

int main() {
 int A,B,C;
 while(scanf("%d%d%d",&A,&B,&C)==3)
 {
 int res = 0;
 if(A>=B && A>=C)
 {
 if(!(A<(B+C))) res=A-B-C+1;
 }
 if(B>=A && B>=C)
 {
 if(!(B<(A+C))) res=B-A-C+1;
 }
 if(C>=B && C>=A)
 {
 if(!(C<(B+A))) res=C-B-A+1;
 }
 cout<<res<<'\n';
 }
 return 0;
}

1064B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1064B

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int main() {
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 long long int a; scanf("%lld",&a);
 string binary = bitset<32>(a).to_string(); //to binary
 long long int res = 0;
 for(unsigned int i=0; i<binary.length();i++) if(binary[i]=='1') res++;
 res = powl(2,res);
 cout<<res<<"\n";
 }
 return 0;
}

1064C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1064C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; cin>>n;
 string s; cin>>s;
 sort(s.begin(), s.end()); cout<<s<<'\n';
 /*
 int res = 0;
 char last = '\0';
 string au;
 for(int i=0;i<n;i++)
 {
 if(s[i]==last) res+=au.length();
 else au = "";
 res++;
 last=s[i];
 au += s[i];
 }
 printf("%d\n",res);*/
 return 0;
}

10653 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10653

#include <bits/stdc++.h>
using namespace std;

char matrix[1005][1005];
int r,c;
bool visited[1005][1005];
int movx[]={1,-1,0,0}; //4 directions
int movy[]={0,0,1,-1};
int endx,endy;

struct state{
 int x,y,steps;
};
int BFS(int startX,int startY)
{
 queue<state> Q;
 visited[startX][startY]=true;
 Q.push(state{startX,startY,0});
 while(Q.size()>0)
 {
 state cur = Q.front(); Q.pop();
 for(int i=0; i<4;i++)
 {
 int nextx = movx[i]+cur.x;
 int nexty = movy[i]+cur.y;
 if(nextx==endx && nexty==endy && matrix[nextx][nexty]=='1') return cur.steps+1;
 if(!visited[nextx][nexty] && nextx>=0 && nextx<r && nexty>=0 && nexty<c && matrix[nextx][nexty]=='1')
 {
 visited[nextx][nexty]=true;
 Q.push({nextx,nexty,cur.steps+1});
 }
 }
 }
 return -1;
}

int main() {
 while(scanf("%d%d",&r,&c)==2 && (r!=0 || c!=0))
 {
 memset(matrix,'1',sizeof(matrix));
 memset(visited,false,sizeof(visited));
 int bombs; scanf("%d",&bombs);
 for(int i=0; i<bombs;i++){
 int row, total, pos;
 scanf("%d %d ",&row,&total);
 for(int j=0; j<total;j++) { scanf("%d",&pos); matrix[row][pos]='0';}
 }
 int startx,starty; scanf("%d%d",&startx,&starty);
 scanf("%d%d",&endx,&endy);
 printf("%d\n",BFS(startx,starty));
 }
 return 0;
}

1066A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1066A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases,L,l,v,r; cin>>cases;
 while(cases--)
 {
 scanf("%d%d%d%d",&L,&v,&l,&r);
 int res = (l-1)/v;
 res+=(L-r)/v;
 int resto = (L-r)%v;
 int aux = 0;
 if(r%v!=0) {
 aux=((r/v)+1)*v;
 if(r+resto>=aux) res++;
 }
 printf("%d\n",res);
 }
 return 0;
}

1066C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1066C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int q;cin>>q;
 int l=1,r=0,i;
 int arr[200009];
 while(q--)
 {
 char c; cin>>c>>i;
 if(c=='L') {l--;arr[i]=l;}
 else if(c=='R') {r++;arr[i]=r;}
 else {printf("%d\n",min(arr[i]-l,r-arr[i]));}
 }
return 0;
}

10683 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10683

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int h, m, s, c;
 while(scanf("%2d%2d%2d%2d", &h, &m, &s, &c) == 4) {
 long long sum;
 sum = c*10+s*1000+m*60000+h*3600000;
 h = sum/8640000;
 sum %= 8640000;
 m = sum/86400;
 sum %= 86400;
 s = sum/864;
 sum %= 864;
 c = sum*100/864;
 printf("%d%02d%02d%02d\n", h, m, s, c);
 }
 return 0;
}

10684 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10684

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 long long int maxval,acu,aux,temp,maxacu,tempAcu,flag=0,last=0;
 scanf("%lld",&maxval); acu=temp=maxacu=tempAcu=maxval;
 acu = max(acu,(long long int)0);
 for(int i=1; i<n;i++)
 {
 scanf("%lld",&aux);
 tempAcu+=aux;
 acu+=aux;
 if(acu<0) acu=0;
 maxval=max(maxval,acu);
 }
 if(maxval<=0) printf("Losing streak.\n");
 else printf("The maximum winning streak is %lld.\n",maxval);
 }
 return 0;
}

10696 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10696

#include<bits/stdc++.h>
using namespace std;

int main(){
 int N;
 while(cin>>N && N!=0){
 if(N<=101) printf("f91(%d) = 91\n",N);
 else printf("f91(%d) = %d\n",N,N-10);
 }
 return 0;
}

107 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 107

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

bitset<100005> bs;
vector<int> primes;

void sieve() {
 bs.set();
 bs[0] = bs[1] = 0;
 for (unsigned int i = 2; i < bs.size(); i++)
 if (bs[i]) {
 for (long long j = (long long) i * i; j < bs.size(); j += i) bs[j] = 0;
 primes.push_back(i);
 }
}

int main()
{
 double delta[6] = {1, .1, .01, .001, .0001, .00001};
 sieve();
 int n,m;
 while(scanf("%d%d",&n,&m)==2 && (n!=0 || m!=0))
 {
 if (m == 1) cout << "Menor\n";
 else {
 int pi = distance(primes.begin(), upper_bound(primes.begin(), primes.end(), n));
 double error = abs((double) pi / n - (double) 1 / log(n));
 if (error < delta[m]) cout << "Menor\n";
 else if (error == delta[m]) cout << "Igual\n";
 else cout << "Mayor\n";
 }
 }
 return 0;
}

10773 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10773

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 double d,v,u,t1,t2;
 int T,ca=1;
 cin>>T;
 while(T--){
 cin>>d>>v>>u;
 if(v>=u || u==0 || v==0)
 printf("Case %d: can't determine\n",ca++);
 else {
 t1=d/u;
 t2=d/sqrt(u*u-v*v);
 printf("Case %d: %.3lf\n",ca++,fabs(t2-t1));}
 }
 return 0;
}

10779 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10779

#include <bits/stdc++.h>
using namespace std;

const int maxn = 10000 + 7;
const int inf = 0x3f3f3f3f;

struct Edge{
 int from, to, cap, flow;
};

struct Dinic{
 int n, m, s, t;
 vector<Edge>edges;
 vector<int>G[maxn];
 bool vis[maxn];
 int d[maxn];
 int cur[maxn];

 void init(int nn){
 edges.clear();
 for (int i = 0; i < nn; ++i)G[i].clear();
 }

 void addEdge(int from,int to,int cap){
 edges.push_back((Edge){from,to,cap,0});
 edges.push_back((Edge){to,from,0,0});
 m = edges.size();
 G[from].push_back(m-2);
 G[to].push_back(m-1);
 }

 bool BFS(){
 memset(vis,0,sizeof vis);
 queue<int>Q;
 Q.push(s);
 d[s] = 0;
 vis[s] = 1;
 while(!Q.empty()){
 int x = Q.front(); Q.pop();
 for (unsigned int i = 0; i < G[x].size(); ++i){
 Edge& e = edges[G[x][i]];
 if (!vis[e.to] && e.cap > e.flow) {
 vis[e.to] = 1;
 d[e.to] = d[x] + 1;
 Q.push(e.to);
 }
 }
 }
 return vis[t];
 }

 int DFS(int x,int a){
 if (x == t || a == 0) return a;
 int flow = 0, f;
 for (int& i = cur[x]; i < G[x].size(); ++i){
 Edge& e = edges[G[x][i]];
 if (d[x] + 1 == d[e.to] && (f = DFS(e.to,min(a,e.cap-e.flow))) > 0){
 e.flow += f;
 edges[G[x][i]^1 ].flow -= f;
 flow += f;
 a -= f;
 if (!a)break;


 }

 }
 return flow;
 }

 int maxflow(int s,int t){
 this->s = s; this->t = t;
 int flow = 0;
 while(BFS()){
 memset(cur,0,sizeof cur);
 flow += DFS(s,inf);
 }
 return flow;
 }

}dic;

int main() {

 int n,m,x,ca=1, k,cases;
 scanf("%d",&cases);
 while(cases--) {
 scanf("%d %d", &n, &m);
 dic.init(n+m+1);
 int S,T; S=1; T=n+m+1;
 int cromos[100][100];
 memset(cromos,0,sizeof(cromos));
 for(int i = 1; i <=n; i++)
 {
 scanf("%d",&k);
 for(int j = 0; j <k; j++) {
 scanf("%d",&x);
 cromos[i][x]++;
 }
 }
 for(int i=1; i<=m;i++)
 {
 dic.addEdge(S,n+i,cromos[1][i]);
 dic.addEdge(n+i,T,1);
 }
 for(int i=2; i<=n;i++)
 {
 for(int j=1; j<=m;j++)
 {
 if(cromos[i][j]==0) dic.addEdge(n+j,i,1);
 else if(cromos[i][j]>1) dic.addEdge(i,n+j,cromos[i][j]-1);
 }
 }
 int flow = dic.maxflow(S,T);
 printf("Case #%d: %d\n",ca++,flow);
 }
 return 0;
}

10783 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10783

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main(){
 int cases,c=1;
 cin>>cases;
 while(cases--)
 {
 int a,b,res=0;
 cin>>a>>b;
 for(int i=a;i<=b;i++)
 {
 if(i%2!=0) res+=i;
 }
 printf("Case %d: %d\n",c++,res);
 }
 return 0;
}

108 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 108

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main()
{
 char a[5];
 map<char, double> M;
 double countA=0,countB=0,d;
 while(scanf("%s%lf",a,&d)!=EOF)
 {
 if(a[0]=='N')
 {
 string aux = "DAMIC",maxi,mini;
 double maximo,minimo,total=0;
 bool empatemax=false,empatemin=false;
 for(int i=0;i<5;i++)
 {
 M[aux[i]]+=0;
 if(i==0) {maximo=M[aux[i]]; minimo=M[aux[i]]; mini=aux[i]; maxi=aux[i];}
 else
 {
 if(M[aux[i]]<minimo) {minimo=M[aux[i]]; mini=aux[i]; empatemin=false;}
 else if(M[aux[i]]>maximo) {maximo=M[aux[i]]; maxi=aux[i]; empatemax=false;}
 else if(M[aux[i]]==minimo) empatemin=true;
 else if(M[aux[i]]==maximo) empatemax=true;
 }
 total+=M[aux[i]];
 }
 if(minimo==maximo) {empatemin=true; empatemax=true;}
 if(empatemax) cout<<"EMPATE#";
 else {
 if(maxi=="C") maxi="COPAS";
 else if(maxi=="A") maxi="COMIDAS";
 else if(maxi=="I") maxi="CENAS";
 else if(maxi=="M") maxi="MERIENDAS";
 else if(maxi=="D") maxi="DESAYUNOS";
 cout<<maxi<<"#";
 }
 if(empatemin) cout<<"EMPATE#";
 else
 {
 if(mini=="C") mini="COPAS";
 else if(mini=="A") mini="COMIDAS";
 else if(mini=="I") mini="CENAS";
 else if(mini=="M") mini="MERIENDAS";
 else if(mini=="D") mini="DESAYUNOS";
 cout<<mini<<"#";
 }
 if((M['A']/countA)>(total/countB)) cout<<"SI\n";
 else cout<<"NO\n";
 countA=0; countB=0;
 M.clear();
 }
 else
 {
 M[a[0]]+=d;
 if(a[0]=='A') countA++;
 countB++;
 }
 }
 return 0;
}

10812 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10812

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main(){
 int cases; cin>>cases;
 while(cases--)
 {
 int s,t,x,y;
 scanf("%d %d",&s,&t);
 y=abs(s-t)/2;
 x=s-y;
 if((x+y==s) && (abs(x-y)==t)) printf("%d %d\n",max(x,y),min(x,y));
 else printf("impossible\n");
 }
 return 0;
}

10815 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10815

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string line;
 set<string> S;
 while(getline(cin,line))
 {
 if(line=="") continue;
 istringstream iss(line);
 vector<string> v((istream_iterator<string>(iss)),istream_iterator<string>());
 for(auto word:v)
 {
 transform(word.begin(), word.end(), word.begin(), ::tolower);
 string aux2;
 for(unsigned int i=0; i<word.length();i++) if(word[i]>='a'&&word[i]<='z') aux2+=word[i]; else { S.insert(aux2); aux2="";}
 if(aux2.length()>0) S.insert(aux2);
 }
 }
 for(auto word:S) if(word!="") cout<<word<<'\n';

 return 0;
}

109 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 109

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string res,team1,team2;
 int l,v;
 while(cin>>team1)
 {
 map <string,int> M;
 int count =0,flag = 0,actual = -1;
 if(team1=="FIN") break;
 while(1)
 {
 cin>>team1;
 if(team1=="FIN") break;
 cin>>l>>team2>>v;
 if(l<v)
 {
 M[team2]+=2;
 M[team1]+=1;
 }
 else if(l>v)
 {
 M[team1]+=2;
 M[team2]+=1;
 }
 count++;
 }
 map<string,int>::iterator it = M.begin();
 for(; it!=M.end();it++)
 {
 if(it->second>actual){ actual=it->second; res=it->first; flag=0;}
 else if(it->second==actual) {flag=1;}
 }
 if(flag==1) cout<<"EMPATE "<<(M.size()*(M.size()-1))-count<<'\n';
 else cout<<res<<" "<<(M.size()*(M.size()-1))-count<<'\n';
 }
 return 0;
}

10902 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10902

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
 point operator-(point a)
 {
 point r;
 r.x=x-a.x; r.y=y-a.y;
 return r;
 }
 point operator+(point a)
 {
 point r;
 r.x=x+a.x; r.y=y+a.y;
 return r;
 }
 point operator*(double sc)
 {
 point r;
 r.x=x*sc; r.y=y*sc;
 return r;
 }
};

int intersect( point p1, point p2, point p3, point p4)
{
 point r;
 double d = (p4.y - p3.y)*(p2.x-p1.x) - (p4.x - p3.x)*(p2.y - p1.y);
 if( fabs( d ) < EPS ) return 0;
 double ua;
 ua = (p4.x - p3.x)*(p1.y-p3.y) - (p4.y-p3.y)*(p1.x-p3.x);
 ua /= d;
 r = p1 + (p2-p1)*ua;
 //cout<<r.x<<" " << r.y<<'\n';
 if(min(p1.x,p2.x)<=r.x && max(p1.x,p2.x)>=r.x && min(p1.y,p2.y)<=r.y && max(p1.y,p2.y)>=r.y && min(p3.x,p4.x)<=r.x && max(p3.x,p4.x)>=r.x && min(p3.y,p4.y)<=r.y && max(p3.y,p4.y)>=r.y)
 return 1;
 return 0;
}

int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 double x,y,x_,y_;
 vector<pair<point,point>> V;
 for(int i=0; i<n;i++)
 {
 scanf("%lf %lf %lf %lf",&x,&y,&x_,&y_);
 V.push_back({point(x,y),point(x_,y_)});
 }
 printf("Top sticks:");
 int res=0;
 for(int i=0; i<n;i++)
 {
 int flag=1;
 for(int j=i+1;j<n && flag==1;j++)
 if(intersect(V[i].first,V[i].second,V[j].first,V[j].second)) flag=0;
 if(flag==1 && res!=0) printf(",");
 if(flag==1) { res++; printf(" %d",i+1);}
 }
 printf(".\n");
 }
 return 0;
}

10919 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10919

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int k,m,n,c;
 while ( scanf ("%d", &k)==1 && k!=0 )
 {
 cin>>m;
 map <string, int> mapping;
 string a;
 for ( int i = 0; i < k; i++) {
 cin>>a;
 mapping [a] = 1;
 }
 int flag = 1;
 for ( int i = 0; i < m; i++ ) {
 cin>>n>>c;
 for ( int j = 0; j < n; j++ ) {
 cin>>a;
 if ( mapping [a]==1 ) c--;
 }
 if ( c > 0 ) flag=0;
 }
 if (flag==1) cout<<"yes\n";
 else cout<<"no\n";
 }
 return 0;
}

10921 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10921

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string line;
 while(getline(cin,line))
 {
 for(unsigned int i=0; i<line.length();i++)
 {
 if(line[i]=='A' || line[i]=='B' || line[i]=='C') cout<<2;
 else if(line[i]=='D' || line[i]=='E' || line[i]=='F') cout<<3;
 else if(line[i]=='G' || line[i]=='H' || line[i]=='I') cout<<4;
 else if(line[i]=='J' || line[i]=='K' || line[i]=='L') cout<<5;
 else if(line[i]=='M' || line[i]=='N' || line[i]=='O') cout<<6;
 else if(line[i]=='P' || line[i]=='Q' || line[i]=='R' || line[i]=='S') cout<<7;
 else if(line[i]=='T' || line[i]=='U' || line[i]=='V') cout<<8;
 else if(line[i]=='W' || line[i]=='X' || line[i]=='Y' || line[i]=='Z') cout<<9;
 else cout<<line[i];
 }
 cout<<'\n';
 }
 return 0;
}

10940 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10940

#include <bits/stdc++.h>
using namespace std;

int ans [500005];

int main ()
{
 ans [1] = 1; ans [2] = 2;
 int next = 2,n;
 for (int i = 3; i <= 500000; i++ ) {
 if ( i < next ) next = 2;
 ans [i] = next;
 next += 2;
 }
 while ( scanf ("%d", &n)==1 && n!=0) printf ("%d\n", ans [n]);
 return 0;
}

10945 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10945

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string line;

 while(getline(cin,line))
 {
 if(line=="DONE") break;
 bool flag=true;
 string lineaux;
 for(unsigned int i=0; i<line.length()&&flag;i++)
 {
 if(line[i]==' '||line[i]=='.' || line[i]==',' || line[i]== '!' || line[i]=='?') continue;
 lineaux+=line[i];
 }
 line=lineaux;
 for(unsigned int i=0; i<line.length()/2&&flag;i++)
 {
 if(tolower(line[i])!=tolower(line[line.length()-i-1])) flag=false;
 }
 if(!flag) printf("Uh oh..\n");
 else printf("You won't be eaten!\n");
 }
 return 0;
}

10946 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10946

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int sx[]={1,-1,0,0}; //4 directions
int sy[]={0,0,1,-1};

const int VAL = 150;
bool visited[VAL][VAL];
char arr[VAL][VAL];
int c,r,total;
void dfs(int a,int b, char ch)
{
 visited[a][b]=true;
 for(int i=0;i<4;i++){
 int I=a+sx[i];
 int J=b+sy[i];
 if(I>=0 && I<r && J>=0 && J<c && !visited[I][J]&& arr[I][J]==ch){
 visited[I][J]=true;
 total++;
 dfs(I,J,ch);
 }
 }
}
bool compare(pair<char,int> a,pair<char,int> b)
{
 if(a.second==b.second) return a.first<b.first;
 return a.second>b.second;
}
int main()
{
 int ca = 1;
 while(scanf("%d%d",&r,&c)==2 && (r!=0 || c!=0))
 {
 vector<pair<char,int>> V;
 memset(visited,false,sizeof(visited));
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) cin>>arr[i][j];
 total=1;
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) {
 if(!visited[i][j]&&arr[i][j]!='.') { dfs(i,j,arr[i][j]); V.push_back(make_pair(arr[i][j],total)); total=1;}
 }
 printf("Problem %d:\n",ca++);
 sort(V.begin(),V.end(),compare);
 for(auto v:V) cout<<v.first<<" "<<v.second<<endl;
 }
 return 0;
}

10954 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10954

#include <bits/stdc++.h>
using namespace std;
struct compare{
 int weight;
 bool operator<(const compare &other)const{ return weight > other.weight; }
};
int main()
{
 int cases,a;
 while(cin>>cases && cases!=0)
 {
 priority_queue<compare> pq;
 while(cases--)
 {
 cin>>a;
 compare aux;
 aux.weight=a;
 pq.push(aux);
 }
 compare aux1,aux2;
 int res=0,a,b;
 while(1)
 {
 aux1=pq.top();
 a=aux1.weight;
 pq.pop();
 aux2=pq.top();
 b=aux2.weight;
 res+=(a+b);
 pq.pop();
 aux1.weight=(a+b);
 if(pq.empty()) break;
 pq.push(aux1);
 }
 cout<<res<<endl;
 }
 return 0;
}

10963 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10963

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int T, n, up, down;
 cin>>T;
 while (T--) {
 cin>>n;
 bool yes = true;
 cin>>up>>down;
 int d = up - down;
 for (int i = 0; i < n - 1; i++) {
 cin>>up>>down;
 if (d != up - down)
 yes = false;
 }
 if (yes) cout<<"yes\n";
 else cout<<"no\n";
 if (T) cout<<endl;
 }
 return 0;
}

10970 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10970

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,m;
 while(scanf("%d%d",&n,&m)==2)
 {
 printf("%d\n", n*m-1);
 }
 return 0;
}

10976 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10976

#include<iostream>
using namespace std;

int main(){
 int num;
 while(scanf("%d",&num)==1){
 string res = "";
 int cnt=0;
 for(int i=num+1;i<=2*num;i++){
 double x=((double)num*(double)i)/((double)i-(double)num);
 if(x==(int)x){
 res+="1/"+to_string(num)+" = 1/"+to_string((int)x)+" + 1/" + to_string(i) + '\n';
 cnt++;
 }
 }
 printf("%d\n",cnt);
 cout<<res;
 }
 return 0;
}

10986 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10986

#include<bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

const int MAXN = 100100;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
};

struct state{
 int node, dist;
 state(){}
 state(int a, int b){
 node = a; dist = b;
 }
 bool operator<(const state &other)const{ // sobrecarga de operadores para ordenar
 return other.dist < dist;
 }
};

vector<edge> graph[MAXN];
int dist[MAXN];

int a=1, b=3;
int N,E;

int dijkstra(int start, int end){
 dist[start] = 0;
 priority_queue<state> pq;
 pq.push(state(start, 0));
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(dist[cur.node] < cur.dist) continue;
 if(cur.node == end) return cur.dist;
 for(unsigned int i=0;i<graph[cur.node].size();i++){
 int dest = graph[cur.node][i].to;
 int wht = graph[cur.node][i].weight + cur.dist;
 if(dist[dest] <= wht) continue;
 dist[dest] = wht;
 pq.push(state(dest, wht));
 }
 }
 return -1;
}

int main(){
 int cases,c=1; scanf("%d",&cases);
 while(cases--)
 {
 int s,t;
 scanf("%d %d %d %d",&N,&E,&s,&t);
 memset(dist,0x3f,sizeof(dist));
 for(int i=0;i<=N;i++) graph[i].clear(); // limpia el grafo
 for(int i=0;i<E;i++){
 int from, to, weight; scanf("%d %d %d",&from, &to, &weight);
 graph[from].push_back(edge(from,to,weight));
 graph[to].push_back(edge(to, from, weight)); // borrar linea si es dirigido
 }
 int aux = dijkstra(s,t);
 if(aux==-1) printf("Case #%d: unreachable\n",c++);
 else printf("Case #%d: %d\n",c++,aux);
 }
 return 0;
}

10989 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10989

#include <bits/stdc++.h>
using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;

const int INF = 1000000000;

pair<int, VI> GetMinCut(VVI &weights) {
 int N = weights.size();
 VI used(N), cut, best_cut;
 int best_weight = -1;

 for (int phase = N-1; phase >= 0; phase--) {
 VI w = weights[0];
 VI added = used;
 int prev, last = 0;
 for (int i = 0; i < phase; i++) {
 prev = last;
 last = -1;
 for (int j = 1; j < N; j++)
 if (!added[j] && (last == -1 || w[j] > w[last])) last = j;
 if (i == phase-1) {
 for (int j = 0; j < N; j++) weights[prev][j] += weights[last][j];
 for (int j = 0; j < N; j++) weights[j][prev] = weights[prev][j];
 used[last] = true;
 cut.push_back(last);
 if (best_weight == -1 || w[last] < best_weight) {
 best_cut = cut;
 best_weight = w[last];
 }
 } else {
 for (int j = 0; j < N; j++)
 w[j] += weights[last][j];
 added[last] = true;
 }
 }
 }
 return make_pair(best_weight, best_cut);
}
int main() {
 int N;
 cin >> N;
 for (int i = 0; i < N; i++) {
 int n, m;
 cin >> n >> m;
 VVI weights(n, VI(n));
 for (int j = 0; j < m; j++) {
 int a, b, c;
 cin >> a >> b >> c;
 weights[a-1][b-1] = weights[b-1][a-1] = c;
 }
 pair<int, VI> res = GetMinCut(weights);
 cout << "Case #" << i+1 << ": " << res.first << endl;
 }
}

10991 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 10991

#include <bits/stdc++.h>
using namespace std;

double perimeter(double ab, double bc, double ca) {
 return ab + bc + ca; }
double getAngle(double a,double b,double c)
{
 return acos((a*a+b*b-c*c)/(2*a*b));
}
double area(double ab, double bc, double ca) {
 // Heron's formula, split sqrt(a * b) into sqrt(a) * sqrt(b); in implementation
 double s = 0.5 * perimeter(ab, bc, ca);
 return sqrt(s) * sqrt(s - ab) * sqrt(s - bc) * sqrt(s - ca); }

int main()
{
 double r,r1,r2; int cases; scanf("%d",&cases);
 while(cases--)
 {
 scanf("%lf%lf%lf",&r,&r1,&r2);
 double a=r+r1,b=r+r2,c=r1+r2;
 double ar =area(a,b,c); //total area from center
 double an1=getAngle(a,b,c);
 double an2=getAngle(a,c,b);
 double an3=getAngle(b,c,a);
 ar-=((r*r)*(an1/2.0));
 ar-=((r1*r1)*(an2/2.0));
 ar-=((r2*r2)*(an3/2.0));
 /*
 The area of a sector of a circle is 1/2 r*r angle,
 where r is the radius and angle the angle in radians
 subtended by the arc at the centre of the circle.
 */
 printf("%.6lf\n",ar);
 }
}

110 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 110

#include <bits/stdc++.h>
using namespace std;

bool isVowel(char a){
 return tolower(a) == 'a' || tolower(a) == 'e' || tolower(a) == 'i' ||
 tolower(a) == 'o' || tolower(a) == 'u';
}

//Una silaba es hasta leer la segunda vocal incluida
bool isConsonante(string a, string b){
 //Tiene 2 vocales -> consonante
 if(a.length()==b.length() && a.length()==2)
 return isVowel(a[0]) && isVowel(a[1]) && a==b;
 //Tiene 2 vocales y 1 o más consonantes que son iguales -> consonante
 return a==b && a.length()>1;
}
//Tiene 2 vocales y 1 o más consonantes que son diferentes -> asonante
bool isAsonante(string a, string b){
 string vowelA="", vowelB="";
 for(int i=0; i<a.length();i++) {
 if(isVowel(a[i])) vowelA+=a[i];
 }
 for(int i=0; i<b.length();i++) {
 if(isVowel(b[i])) vowelB+=b[i];
 }
 return vowelA==vowelB && a!=b && vowelA.length()>1 && vowelB.length()>1;
}
int main() {
 //freopen("C:\\Users\\isaac\\CLionProjects\\URJC_Entenamientos\\110_random.in","r",stdin);
 //freopen("C:\\Users\\isaac\\CLionProjects\\URJC_Entenamientos\\110_random_isaac.ans","w",stdout);
 int n;
 while (scanf("%d", &n) == 1 && n != 0) {
 string line;
 cin.ignore();
 vector<string> rimas;
 for (int i = 0; i < n; i++) {
 getline(cin, line);
 string rima = "";
 int vowel = 0;
 string line2 = "";
 for (int j = 0; j < line.length(); j++) {
 if(tolower(line[j])>='a' && tolower(line[j])<='z') line2+=tolower(line[j]);
 }
 line = line2;
 for (int j = line.length() - 1; j >= 0; j--) {
 if (isVowel(line[j])) vowel++;
 rima=line[j]+rima;
 if(vowel == 2)
 break;
 }
 rimas.push_back(rima);
 }
 bool print = false;
 if(n==2) {
 //Pareado: rima consonante AA.
 if(isConsonante(rimas[0],rimas[1])) {
 print = true;
 printf("PAREADO\n");
 }
 }
 else if(n==3){
 //Terceto: rima consonante en el primer y último verso (A-A). Ten en cuenta que AAA no se considerará terceto.
 if(isConsonante(rimas[0],rimas[2]) && !isConsonante(rimas[0],rimas[1])) {
 print = true;
 printf("TERCETO\n");
 }
 }
 else if(n==4){
 if(isConsonante(rimas[0],rimas[3]) && isConsonante(rimas[1],rimas[2]) && !isConsonante(rimas[0],rimas[1])) {
 //Cuarteto: rima consonante ABBA.
 print = true;
 printf("CUARTETO\n");
 }
 else if (isConsonante(rimas[0],rimas[1]) && isConsonante(rimas[1],rimas[2]) && isConsonante(rimas[2],rimas[3])) {
 //Cuaderna via: rima consonante igual en todos los versos (AAAA).
 print = true;
 printf("CUADERNA VIA\n");
 }
 else if (isConsonante(rimas[0],rimas[2]) && isConsonante(rimas[1],rimas[3]) && !isConsonante(rimas[0],rimas[1])) {
 //Cuarteta: rima consonante ABAB.
 print = true;
 printf("CUARTETA\n");
 } else if(isAsonante(rimas[1],rimas[3])
 && !isAsonante(rimas[0],rimas[1])
 && !isAsonante(rimas[0],rimas[2])
 && !isAsonante(rimas[0],rimas[3])
 && !isAsonante(rimas[1],rimas[2])
 && !isAsonante(rimas[2],rimas[3])
 && !isConsonante(rimas[0],rimas[1])
 && !isConsonante(rimas[0],rimas[2])
 && !isConsonante(rimas[0],rimas[3])
 && !isConsonante(rimas[1],rimas[2])
 && !isConsonante(rimas[1],rimas[3])
 && !isConsonante(rimas[2],rimas[3])) {
 //Seguidilla: rima asonante en los pares (-a-a).
 // Ten en cuenta que otras combinaciones con más rimas o con rima consonante
 // en lugar de asonante (por ejemplo -aaa o -A-A) no se consideran seguidillas.
 print = true;
 printf("SEGUIDILLA\n");
 }
 }
 if(!print)
 printf("DESCONOCIDO\n");
 }
 return 0;
}

11044 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11044

#include <bits/stdc++.h>
using namespace std;
int main() {
 int tc, w,h;
 cin>>tc;
 while(tc--){
 cin>>w>>h;
 printf("%d\n",(w/3)*(h/3));
 }
 return 0;
}

11045 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11045

#include <bits/stdc++.h>

using namespace std;

struct Node {
 int x, y, v;// x->y, v
 int next;
} edge[50005];
int e, head[1005], dis[1005], previ[1005], record[1005];
void addEdge(int x, int y, int v) {
 edge[e].x = x, edge[e].y = y, edge[e].v = v;
 edge[e].next = head[x], head[x] = e++;
 edge[e].x = y, edge[e].y = x, edge[e].v = 0;
 edge[e].next = head[y], head[y] = e++;
}
int maxflow(int s, int t) {
 int flow = 0;
 int i, j, x, y;
 while(1) {
 memset(dis, 0, sizeof(dis));
 dis[s] = 0xffff; // oo
 queue<int> Q;
 Q.push(s);
 while(!Q.empty()) {
 x = Q.front();
 Q.pop();
 for(i = head[x]; i != -1; i = edge[i].next) {
 y = edge[i].y;
 if(dis[y] == 0 && edge[i].v > 0) {
 previ[y] = x;
 record[y] = i;
 dis[y] = std::min(dis[x], edge[i].v);
 Q.push(y);
 }
 }
 if(dis[t]) break;
 }
 if(dis[t] == 0) break;
 flow += dis[t];
 for(x = t; x != s; x = previ[x]) {
 int ri = record[x];
 edge[ri].v -= dis[t];
 edge[ri^1].v += dis[t];
 }
 }
 return flow;
}

int main() {

 int cases;
 cin >> cases;
 while(cases--) {
 e=0;
 memset(head, -1, sizeof(head));
 int num_t, num_v;
 cin >> num_t >> num_v;
 num_t /= 6;
 int S = 1, T = 8+num_v;
 for(int i=1; i<=6; i++) {
 addEdge(S, i+1, num_t);
 }
 string t1, t2;
 cin.ignore();
 for(int i=0; i<num_v; i++) {
 cin >> t1 >> t2;
 if(t1=="XXL") addEdge(2, 8+i, 1);
 else if(t1=="XL") addEdge(3, 8+i, 1);
 else if(t1=="L") addEdge(4, 8+i, 1);
 else if(t1=="M") addEdge(5, 8+i, 1);
 else if(t1=="S") addEdge(6, 8+i, 1);
 else if(t1=="XS") addEdge(7, 8+i, 1);
 t1=t2;
 if(t1=="XXL") addEdge(2, 8+i, 1);
 else if(t1=="XL") addEdge(3, 8+i, 1);
 else if(t1=="L") addEdge(4, 8+i, 1);
 else if(t1=="M") addEdge(5, 8+i, 1);
 else if(t1=="S") addEdge(6, 8+i, 1);
 else if(t1=="XS") addEdge(7, 8+i, 1);
 }

 for(int i=0; i<num_v; i++) {
 addEdge(8+i,T,1);
 }
 int flow = maxflow(S, T);
 if(flow==num_v) cout << "YES\n";
 else cout << "NO\n";
 }

 return 0;
}

11049 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11049

#include <bits/stdc++.h>
using namespace std;

struct s{
 int f1,c1,f2,c2;
};
struct state{
 string s;
 int x,y;
};

int xe,ye;
int sx[]={1,-1,0,0}; //4 directions
int sy[]={0,0,1,-1};
vector<s> V;
int visited[10][10];

bool muro(int curx,int cury, int x,int y)
{
 if(curx>x || cury>y) { swap(curx,x); swap(cury,y);}
 for(auto v:V)
 {
 int equal;
 if(v.f1==v.f2) equal = v.f1;
 else equal = v.c1;
 if(equal==v.c1 && cury==v.c2 && y!=v.c2 && x>v.f1 && x<=v.f2) return false;
 else if(equal==v.f1 && curx==v.f2 && x!=v.f2 && y>v.c1 && y<=v.c2) return false;
 }
 return true;
}
void solve(int x,int y)
{
 queue<state> Q;
 Q.push({"",x,y});
 while(!Q.empty())
 {
 state cur = Q.front(); Q.pop();
 if(cur.x==xe && cur.y==ye) { cout<<cur.s<<'\n'; return;}
 for(int i=0; i<4;i++)
 {
 int I=cur.x+sx[i];
 int J=cur.y+sy[i];
 if(I>=0 && I<6 && J>=0 && J<6 &&!visited[I][J] && muro(cur.x,cur.y,I,J)){
 visited[I][J]=true;
 if(i==0) Q.push({cur.s+"E",I,J});
 else if(i==1) Q.push({cur.s+"W",I,J});
 else if(i==2) Q.push({cur.s+"S",I,J});
 else Q.push({cur.s+"N",I,J});
 }
 }
 }
}

int main()
{
 int x,y;
 while(scanf("%d %d",&x,&y)==2 && (x!=0 || y!=0))
 {
 scanf("%d %d",&xe,&ye); xe--; ye--;
 memset(visited,false,sizeof(visited));
 V.clear();
 for(int i=0; i<3;i++)
 {
 int a,b,c,d; scanf("%d %d %d %d",&a,&b,&c,&d);
 V.push_back({a-1,b-1,c-1,d-1});
 }
 solve(x-1,y-1);
 }
 return 0;
}

11056 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11056

#include <bits/stdc++.h>
using namespace std;

struct state{
 string name;
 long long int total;
};
bool comp(state a, state b)
{
 transform(a.name.begin(), a.name.end(), a.name.begin(), ::tolower);
 transform(b.name.begin(), b.name.end(), b.name.begin(), ::tolower);
 if(a.total==b.total) return lexicographical_compare(a.name.begin(),a.name.end(),b.name.begin(),b.name.end());
 return a.total<b.total;

}
int main()
{
 int n;
 while(scanf("%d",&n)==1)
 {
 string name;
 vector<state> V;
 long long int m,s,ms,total=0;
 for(int i=0; i<n;i++)
 {
 cin>>name;
 scanf(" : %lld min %lld sec %lld ms",&m,&s,&ms); total=m*60000+s*1000+ms;
 V.push_back({name,total});
 }
 sort(V.begin(),V.end(),comp);
 int cont=0;
 for(auto v:V)
 {
 if(cont%2==0) printf("Row %d\n",cont/2+1);
 printf("%s\n",v.name.c_str());
 cont++;
 }
 printf("\n");
 }
 return 0;
}

11068 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11068

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 0
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
};
struct line { double a, b, c; }; // a way to represent a line

bool areIntersect(line l1, line l2, point &p) {
 int den = l1.a*l2.b - l1.b*l2.a;
 if(!den) return false; //paralelo o la misma linea
 p.x = l1.c*l2.b - l1.b*l2.c;
 if(p.x) p.x /= den;
 p.y = l1.a*l2.c - l1.c*l2.a;
 if(p.y) p.y /= den;
 return true;
}

int main()
{
 double a,b,c,a1,b1,c1;
 while(scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&a1,&b1,&c1)==6 && (a!=0 || b!=0 || c!=0 || a1!=0 || b1!=0 || c1!=0))
 {
 line l1; l1.a=a; l1.b=b; l1.c=c;
 line l2; l2.a=a1; l2.b=b1; l2.c=c1;
 point res;
 if(areIntersect(l1,l2,res)) printf("The fixed point is at %.2lf %.2lf.\n",res.x,res.y);
 else printf("No fixed point exists.\n");
 }
 return 0;
}

1108A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);
 for(int i=0; i<cases;i++)
 {
 int n,n1,n2,n3; scanf("%d%d%d%d",&n,&n1,&n2,&n3);
 bool flag=true;
 for(int i=n; i<=n1 && flag; i++)
 for(int j=n2; j<=n2 && flag;j++)
 if(n<=i&&n1>=i && n2<=j && n3>=j && i!=j) { flag=false; printf("%d %d\n",i,j); }
 }
 return 0;
}

1108B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);
 int maxnum = -0x3f3f3f3f,nextnum=-0x3f3f3f3f;
 int arr[cases];
 map<int,int> M;
 map<int,int> Flag;
 for(int i=0; i<cases;i++)
 {
 scanf("%d",&arr[i]);
 maxnum=max(maxnum,arr[i]);
 M[arr[i]]++;
 }
 for(int i=0; i<cases;i++)
 {
 if(maxnum%arr[i]==0 && Flag[arr[i]]==0) { Flag[arr[i]]++; M[arr[i]]--; }
 }
 for(auto m:M)
 if(m.second!=0) nextnum=max(m.first,nextnum);
 printf("%d %d",maxnum,nextnum);
 return 0;
}

1108C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; scanf("%d",&n);
 string lamps; cin>>lamps;
 int count,count1;
 count=count1=0;
 string l,l1; l=l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //RGB
 {
 if(i%3==0 && lamps[i]!='R') { l[i]='R'; count++;}
 else if(i%3==1 && lamps[i]!='G'){ l[i]='G'; count++;}
 else if(i%3==2 && lamps[i]!='B') { l[i]='B'; count++;}
 }
 for(unsigned int i=0; i<lamps.size();i++) //RBG
 {
 if(i%3==0 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==2 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==1 && lamps[i]!='B'){ l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //GRB
 {
 if(i%3==1 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==0 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==2 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //GBR
 {
 if(i%3==2 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==0 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==1 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //BRG
 {
 if(i%3==1 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==2 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==0 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //BGR
 {
 if(i%3==2 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==1 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==0 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 printf("%d\n",count);
 cout<<l;
 return 0;
}

1108D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108D

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; scanf("%d",&n);
 string lamps; cin>>lamps;
 int count=0;
 char c;
 for(unsigned int i=1; i<lamps.size();i++)
 {
 if(lamps[i-1]!=lamps[i]) continue;
 if(i+1<lamps.size())
 {
 c = lamps[i+1];
 if(c=='R' && lamps[i-1]=='B') lamps[i]='G';
 else if(c=='R' && lamps[i-1]=='G') lamps[i]='B';
 else if(c=='B' && lamps[i-1]=='G') lamps[i]='R';
 else if(c=='B' && lamps[i-1]=='R') lamps[i]='G';
 else if(c=='G' && lamps[i-1]=='B') lamps[i]='R';
 else if(c=='G' && lamps[i-1]=='R') lamps[i]='B';
 else if(c=='R' && lamps[i-1]=='R') lamps[i]='G';
 else if(c=='G' && lamps[i-1]=='G') lamps[i]='R';
 else if(c=='B' && lamps[i-1]=='B') lamps[i]='R';
 }
 else {
 c = lamps[i-1];
 if(c=='R') lamps[i]='G';
 else if(c=='B') lamps[i]='R';
 else if(c=='G') lamps[i]='R';
 }
 count++;
 }
 printf("%d\n",count);
 cout<<lamps;
 return 0;
}

11096 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11096

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
 bool operator <(point other) const{
 if (fabs(x-other.x)>EPS)return x<other.x;
 return y<other.y;
 }bool operator ==(point other) const{
 return (fabs(x-other.x)<EPS)&&
 (fabs(y-other.y)<EPS);
 }
 point operator +(point other) const{
 return point(x+other.x,y+other.y);
 }point operator -(point other) const{
 return point(x-other.x,y-other.y);
 }
};

double dist(point p1, point p2) {
 return hypot(p1.x - p2.x, p1.y - p2.y); }

double perimeter(const vector<point> &P) {
 double result = 0.0;
 for (int i = 0; i < (int)P.size()-1; i++)
 result += dist(P[i], P[i+1]);
 return result; }

double cross(point o, point a, point b) {
 return (a.x-o.x)*(b.y-o.y) - (a.y-o.y)*(b.x-o.x);
}

vector<point> CH(vector<point> P){
 vector<point> res;
 sort(P.begin(),P.end());
 int n = P.size();
 int m=0;
 for (int i=0;i<n;i++){
 while (m>1&&cross(res[m-2], res[m-1], P[i]) <= 0)res.pop_back(),m--;
 res.push_back(P[i]),m++;
 }
 for (int i = n-1, t = m+1; i >= 0; i--) {
 while (m>=t&&cross(res[m-2], res[m-1], P[i]) <= 0)res.pop_back(),m--;
 res.push_back(P[i]),m++;
 }
 return res;
}

int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 vector<point> P;
 int n;
 double x,y,r; scanf("%lf%d",&r,&n);
 for(int i=0; i<n;i++)
 {
 scanf("%lf%lf",&x,&y);
 P.push_back(point(x, y));
 }
 P = CH(P);
 double res = max(r, perimeter(P));
 printf("%.5lf\n",res);
 }
 return 0;
}

111 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 111

#include <bits/stdc++.h>

using namespace std;

int main() {
 int c[19] = {2, 2, 6, 2, 6, 2, 10, 6, 2, 10, 6, 2, 14, 10, 6, 2, 14, 10, 6};
 string n[19] = {"1s", "2s", "2p", "3s", "3p", "4s", "3d", "4p", "5s", "4d", "5p", "6s", "4f", "5d", "6p", "7s", "5f", "6d", "7p"};

 string s;
 while (cin >> s && s != "Exit") {
 int Z;
 cin >> Z;
 int i = 0;
 while (Z > c[i]) {
 printf("%s%d ", n[i].c_str(), c[i]);
 Z -= c[i];
 i++;
 }

 printf("%s%d\n", n[i].c_str(), Z);
 }

 return 0;
}

111 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 111

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int N,K,num;
 scanf("%d",&N);
 int arr[N];
 int arraux[N];
 int dp[22][22];
 for(int i=0; i<N;i++) { scanf("%d",&num); arraux[num-1]=i; }
 while(scanf("%d",&K)==1)
 {
 memset(dp,0,sizeof(dp));
 arr[K-1]=0;
 for(int i=1; i<N;i++) { scanf("%d",&num); arr[num-1]=i; }
 //LIS
 for(int i=1; i<=N; i++)
 for(int j=1; j<=N;j++)
 {
 if(arraux[i-1]==arr[j-1]) dp[i][j]=dp[i-1][j-1]+1;
 else dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
 }
 /*
 2 3 4 1
 1 0 0 0 1
 2 1 1 1 1
 3 1 2 2 2
 4 1 2 3 3
 */
 printf("%d\n",dp[N][N]);
 }
 return 0;
}

11101 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11101

#include <bits/stdc++.h>
using namespace std;

#define MAXN 2001

struct state {
 int x, y;
};

int board[MAXN][MAXN];
bool visited[MAXN][MAXN];
int sx[]={1,-1,0,0}; //4 directions
int sy[]={0,0,1,-1};

int bfs(queue<state> Q) {
 while (!Q.empty()) {
 state cur = Q.front(); Q.pop();
 for(int i=0; i<4;i++)
 {
 int I=cur.x+sx[i];
 int J=cur.y+sy[i];
 if (I>=0 && I<MAXN && J>=0 && J<MAXN &&!visited[I][J]) {
 if(board[I][J]==-2) return board[cur.x][cur.y]+1;
 visited[I][J]=true;
 board[I][J] = board[cur.x][cur.y]+1;
 Q.push({I, J});
 }
 }
 }
 return 0;
}

int main() {
 int t, x, y;
 queue<state> Q;
 while (scanf("%d",&t)==1 && t!=0) {
 memset(board,-1,sizeof(board));
 memset(visited,false,sizeof(visited));
 while (!Q.empty()) Q.pop();
 while (t--) {
 scanf("%d%d",&x,&y);
 board[x][y] = 0;
 visited[x][y]=true;
 Q.push({x, y});
 }
 scanf("%d",&t);
 while (t--) {
 scanf("%d%d",&x,&y);
 board[x][y] = -2;
 }
 printf("%d\n",bfs(Q));
 }
 return 0;
}

11137 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11137

#include <bits/stdc++.h>
using namespace std;

long long int memo[10005][25];
int coin[25];

long long int DP(int sum, int i)
{
 if(sum==0) return 1;
 if(i==24 || sum<0 || sum-coin[i]<0) return 0;
 long long int &best = memo[sum][i];
 if(best!=-1) return best;
 return best = DP(sum-coin[i],i) + DP(sum,i+1);
}

int main()
{
 for(int i=1; i<=23;i++) coin[i]=i*i*i;
 int N; memset(memo,-1,sizeof(memo));
 while(scanf("%d",&N)==1)
 printf("%lld\n",DP(N,1));
 return 0;
}

11150 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11150

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n;
 while(scanf("%d", &n) == 1)
 {
 int sum = n;
 while(n >= 3) {
 sum += n/3;
 n = n/3 + n%3;
 }
 if(n == 2) sum++;
 printf("%d\n", sum);
 }
 return 0;
}

11151 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11151

#include <bits/stdc++.h>
using namespace std;
string word;
int memo[1005][1005];
bool mark[1005][1005];
int DP(int start,int end)
{
 if(start==end) return 1; //ara quedara r
 if(start+1==end)
 {
 if(word[start]==word[end]) return 2; // arra 4
 return 1; //araa sera ra y la a coincidira ara
 }
 int &best = memo[start][end];
 if (mark[start][end]) return best;
 mark[start][end]=true;
 if(word[start]==word[end]) return best=DP(start+1,end-1)+2; //arra +2 a
 return best=max(DP(start+1,end),DP(start,end-1)); //Si no son iguales vemos las del medio
}
int main()
{
 int testcase;
 cin>>testcase;
 getchar();
 while(testcase--)
 {
 memset(mark,false,sizeof(mark));
 memset(memo,-1,sizeof(memo));
 getline(cin,word);
 if(word.length()==0)
 {
 cout<<0<<endl;
 }
 else
 cout<<DP(0,word.length()-1)<<endl;
 }
 return 0;
}

11152 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11152

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 10e-8
#define PI acos(-1.0)
using namespace std;

double perimeter(double ab, double bc, double ca) {
 return ab + bc + ca; }

double area(double ab, double bc, double ca) {
 // Heron's formula, split sqrt(a * b) into sqrt(a) * sqrt(b); in implementation
 double s = 0.5 * perimeter(ab, bc, ca);
 return sqrt(s) * sqrt(s - ab) * sqrt(s - bc) * sqrt(s - ca); }

double rInCircle(double ab, double bc, double ca) {
 double per = perimeter(ab, bc, ca);
 if(per==0) return 0;
 return area(ab, bc, ca) / (0.5 * per); }

double rCircumCircle(double ab, double bc, double ca) {
 return ab * bc * ca / (4.0 * area(ab, bc, ca)); }


int main()
{
 double d1,d2,d3;
 while(scanf("%lf%lf%lf",&d1,&d2,&d3)==3)
 {
 double violets = area(d1,d2,d3);
 double sunflowers = PI*pow(rCircumCircle(d1,d2,d3),2);
 double roses = PI*pow(rInCircle(d1,d2,d3),2);
 printf("%.4lf %.4lf %.4lf\n",sunflowers-violets,violets-roses,roses);
 }
 return 0;
}

11172 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11172

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int a;
 cin>>a;
 while(a--)
 {
 long long int b,c;
 cin>>b>>c;
 if(b<c)
 cout<<"<"<<endl;
 else if(b>c)
 cout<<">"<<endl;
 else
 cout<<"="<<endl;
 }
 return 0;
}

11192 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11192

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
void re(string s)
{
 for(int i=s.length()-1; i>=0;i--) cout<<s[i];
}
int main()
{
 int cases;
 while(scanf("%d",&cases)==1 && cases!=0)
 {
 string s,aux="";
 cin>>s;
 cases = s.length()/cases;
 for(unsigned int i=0; i<s.length();i++)
 {
 if(i%cases==0) { re(aux);aux="";}
 aux+=s[i];
 }
 re(aux);
 cout<<endl;
 }
 return 0;
}

112 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 112

#include <iostream>

using namespace std;

int main() {
 int d, v, t;
 while (cin >> d >> v >> t && !(d == 0 && v == 0 && t == 0)) {
 if (d <= 0 || v <= 0 || t <= 0) {
 cout << "ERROR" << endl;
 continue;
 }

 if (18*d <= 5*t*v) cout << "OK" << endl;
 else if (3*d < t*v) cout << "MULTA" << endl;
 else cout << "PUNTOS" << endl;
 }

 return 0;
}

11207 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11207

#include <bits/stdc++.h>
#define PI acos(-1)
using namespace std;

int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 double x,y,res=-1; int sol=0;
 for(int i=1; i<=n;i++)
 {
 scanf("%lf %lf", &x, &y);
 if (x < y) swap(x, y);
 double size = max((min(x, y) / 2), (min(x / 4, y)));
 if (size > res)
 res = size, sol = i;
 /*
 There are 3 different ways in which we could cut out the 4 squares: all in a row along the height,
 all in a row along the width, or in a 2x2 pattern.
 */
 }
 printf("%d\n",sol);
 }
 return 0;
}

11219 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11219

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int t, test = 0;
 cin>>t;
 while(t--) {
 int age, a, b, c, e, f, g;
 scanf("%d/%d/%d", &a, &b, &c);
 scanf("%d/%d/%d", &e, &f, &g);
 age = c-g;
 if(f > b) age--;
 if(f == b && e > a) age--;
 printf("Case #%d: ", ++test);
 if(age < 0)
 cout<<"Invalid birth date\n";
 else if(age > 130)
 cout<<"Check birth date\n";
 else
 printf("%d\n", age);
 }
 return 0;
}

11235 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11235

#include <bits/stdc++.h>
using namespace std;

struct node {
 pair<long long int, long long int> l; //elemento y frecuencia
 pair<long long int, long long int> r;
 long long int f;
};
node join(node left,node right)
{
 node res; res.l=left.l; res.r=right.r;
 if (left.l.first==right.l.first) res.l.second+=right.l.second; //Si ambos tienen el mismo por la izquierda sumar
 if (left.r.first==right.r.first) res.r.second+=left.r.second; //Si ambos tienen el mismo por la derecha sumar
 res.f=max(max(left.r.second,right.l.second),max(left.f,right.f)); //Calcular la frecuencia
 if (left.r.first==right.l.first)res.f=max(res.f,left.r.second+right.l.second); //Si encima derecha e izquierda son iguales
 return res;
}
void buildTree(node *tree,int *a,int index,int s,int e)
{
 //base case
 if(s>e)
 return;
 //reached leaf node
 if(s==e)
 {
 tree[index].l={a[s],1}; tree[index].r={a[s],1}; tree[index].f=1;
 return ;
 }
 //now build the segment tree in bottom up manner
 int m = (s+e)/2;
 buildTree(tree,a,2*index,s,m);
 buildTree(tree,a,2*index+1,m+1,e);
 node left = tree[2*index]; node right = tree[2*index+1];
 tree[index]=join(left,right);
 return;
}

//function to query the segment tree for RSQ
node query(node *tree,int index,int s,int e,int qs,int qe)
{
 //base case: if query range is outside the node range
 if(qs>e || s>qe)
 return node{{0,0},{0,0},0};
 //complete overlap
 if(s>=qs && e<=qe)
 return tree[index];
 //now partial overlap case is executed
 int m = (s+e)/2;
 node left = query(tree,2*index,s,m,qs,qe);
 node right = query(tree,2*index+1,m+1,e,qs,qe);
 return join(left,right);
}
int main()
{
 int n,c;
 while(scanf("%d",&n)==1 && n!=0)
 {
 scanf("%d",&c);
 int a[n];
 for(int i=0; i<n; i++) scanf("%d",&a[i]);
 node*tree = new node[4*n+1]; //array to store the segment tree
 int index = 1; //index of 1st node
 int s =0,e=n-1;
 buildTree(tree,a,index,s,e); //now tree has been built
 for(int i=0; i<c;i++)
 {
 int j,k; scanf("%d %d",&j,&k);
 printf("%lld\n",query(tree,index,s,e,j-1,k-1).f);
 }
 }
 return 0;
}

1124 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1124

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string a;
 while(getline(cin,a))
 cout<<a<<endl;
return 0;
}

11244 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11244

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int di[]={1,1,1,-1,-1,-1,0,0};
int dj[]={1,0,-1,1,0,-1,1,-1};
bool visited[101][101];
int r,c,m;
char arr[101][101];

void dfs(int a, int b){

 visited[a][b]=true;
 for(int i=0;i<8;i++){
 int I=a+di[i];
 int J=b+dj[i];
 if(I>=0 && I<r && J>=0 && J<c && !visited[I][J]){
 visited[I][J]=true;
 if(arr[I][J]=='*'){m++; dfs(I,J);}
 }
 }
}

int main()
{
 while(scanf("%d%d",&r,&c)==2 && (r!=0||c!=0))
 {
 int count=0;
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++)
 visited[i][j]=false;

 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++)
 {
 char a;
 cin>>a;
 arr[i][j]=a;
 }
 for(int i=0;i<r;i++)
 for(int j=0; j<c;j++)
 if(!visited[i][j] && arr[i][j]=='*')
 {
 m=1;
 visited[i][j]=true;
 dfs(i,j);
 if(m==1) count++;
 }
 else visited[i][j]=true;
 printf("%d\n",count);
 }
 return 0 ;
}

11292 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11292


#include <bits/stdc++.h>
using namespace std;

vector<int> V;
int find(int searched){
 int first = 0, middle, last = V.size() -1;
 while (first<=last) {
 middle = (first + last) / 2;
 if (searched == V[middle]) return middle;
 else {
 if (V[middle] > searched) last = middle - 1;
 else first = middle + 1;
 }
 }
 return first;
}
int main(){
 int n,m;
 while(scanf("%d %d",&n,&m)==2 && (n!=0||m!=0)){
 int dragon[n];
 for(int i=0; i<n;i++) scanf("%d",&dragon[i]);
 for(int i=0; i<m;i++) { int aux; scanf("%d",&aux); V.push_back(aux); }
 sort(V.begin(),V.end());
 int res = 0;
 bool solution=true;
 for(int i=0; i<n && solution;i++){
 int index = find(dragon[i]);
 if(index==(int)V.size()) { solution=false; continue;}
 else res+=V[index];
 V.erase(V.begin()+index);
 }
 if(!solution) printf("Loowater is doomed!\n");
 else printf("%d\n",res);
 V.clear();
 }
 return 0;
}

113 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 113

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 double x,n;
 while(scanf("%lf%lf",&n,&x)==2)
 {
 printf("%.0lf\n",pow(x,1.0/n));
 }
 return 0;
}

11309 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11309

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

bool check(int m)
{
 string n;
 int h=m/60;
 int m1=m-(h*60);
 h*=100;h+=m1;
 n = to_string(h);
 for(unsigned int i=0; i<n.length()/2;i++)
 if(n[i]!=n[n.length()-i-1]) return false;
 return true;
}
int main(){
 int cases; cin>>cases;
 while(cases--)
 {
 int h; int m;
 scanf("%d:%d",&h,&m);
 m=m+h*60;
 m++;
 if(m==1440) m=0;
 while(!check(m))
 {
 m++;
 if(m==1440) m=0;
 }
 h=m/60;
 m=m-(h*60);
 printf("%02d:%02d\n",h,m);
 }
 return 0;
}

11332 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11332

#include<bits/stdc++.h>
using namespace std;
int res(int n) {
 if(n < 10) return n;
 int sum = 0;
 while(n) {
 sum += n%10;
 n /= 10;
 }
 return res(sum);
}
int main() {
 int cases;
 while(scanf("%d", &cases) == 1 && cases!=0)
 printf("%d\n", res(cases));
 return 0;
}

11340 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11340

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 long long int arr[257];
 memset(arr,0,sizeof(arr));
 long long int num,n,res=0; cin>>num;
 string line;
 while(num--)
 {
 cin>>line>>n;
 arr[line[0]+128]=n;
 }
 cin>>n;
 cin.ignore();
 while(n--)
 {
 getline(cin,line);
 for(unsigned int i=0; i<line.length();i++)
 res+=arr[line[i]+128];
 }
 printf("%lld.%02lld$\n",res/100,res%100);
 }
 return 0;
}

11343 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11343

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
 point operator-(point a)
 {
 point r;
 r.x=x-a.x; r.y=y-a.y;
 return r;
 }
 point operator+(point a)
 {
 point r;
 r.x=x+a.x; r.y=y+a.y;
 return r;
 }
 point operator*(double sc)
 {
 point r;
 r.x=x*sc; r.y=y*sc;
 return r;
 }
};
int orientation(point a,point b,point c){
 int v = (b.y-a.y) * (c.x-b.x) - (b.x-a.x) * (c.y-b.y);
 if(!v) return 0; //colinear
 return v>0?1:2; // clock or counterclock wise
}
//Comprueba si el punto q pertenece al segmento pr
bool onSegment(point p, point q, point r)
{
 if (q.x <= max(p.x, r.x) && q.x >= min(p.x, r.x) &&
 q.y <= max(p.y, r.y) && q.y >= min(p.y, r.y))
 return true;
 return false;
}
// The main function that returns true if line segment 'p1q1'
// and 'p2q2' intersect.
bool intersect(point p1, point q1, point p2, point q2)
{
 // Find the four orientations needed for general and
 // special cases
 int o1 = orientation(p1, q1, p2);
 int o2 = orientation(p1, q1, q2);
 int o3 = orientation(p2, q2, p1);
 int o4 = orientation(p2, q2, q1);

 // General case
 if (o1 != o2 && o3 != o4)
 return true;

 // Special Cases
 // p1, q1 and p2 are colinear and p2 lies on segment p1q1
 if (o1 == 0 && onSegment(p1, p2, q1)) return true;

 // p1, q1 and p2 are colinear and q2 lies on segment p1q1
 if (o2 == 0 && onSegment(p1, q2, q1)) return true;

 // p2, q2 and p1 are colinear and p1 lies on segment p2q2
 if (o3 == 0 && onSegment(p2, p1, q2)) return true;

 // p2, q2 and q1 are colinear and q1 lies on segment p2q2
 if (o4 == 0 && onSegment(p2, q1, q2)) return true;

 return false; // Doesn't fall in any of the above cases
}

int main()
{
 int n,cases; scanf("%d",&cases);
 while(cases--)
 {
 scanf("%d",&n);
 double x,y,x_,y_;
 vector<pair<point,point>> V;
 for(int i=0; i<n;i++)
 {
 scanf("%lf %lf %lf %lf",&x,&y,&x_,&y_);
 V.push_back({point(x,y),point(x_,y_)});
 }
 int res=0;
 for(int i=0; i<n;i++)
 {
 int flag=1;
 for(int j=0;j<n && flag==1;j++)
 {
 if(j==i) continue;
 if(intersect(V[i].first,V[i].second,V[j].first,V[j].second)) flag=0;
 }
 if(flag==1) res++;
 }
 printf("%d\n",res);
 }
 return 0;
}

11345 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11345

#include <bits/stdc++.h>
using namespace std;

double lxsol, lysol, rxsol,rysol;

int hasIntersect(int lx, int ly, int rx, int ry, int la, int lb, int ra, int rb) {
 lx = lxsol = max(lx, la);
 ly = lysol = max(ly, lb);
 rx = rxsol = min(rx, ra);
 ry = rysol = min(ry, rb);
 return lx < rx && ly < ry;
}

int main()
{
 int cases,ca=1; scanf("%d",&cases);
 double lx,ly,rx,ry;
 while(cases--)
 {
 int n; scanf("%d",&n);
 bool flag=false;
 scanf("%lf%lf%lf%lf",&lxsol,&lysol,&rxsol,&rysol);
 for(int i=1;i<n;i++)
 {
 scanf("%lf%lf%lf%lf",&lx,&ly,&rx,&ry);
 if(!hasIntersect(lx,ly,rx,ry,lxsol,lysol,rxsol,rysol)) flag=true;
 }
 double areassr = abs(rysol-lysol)*abs(rxsol-lxsol);
 if(flag) areassr=0;
 printf("Case %d: %0.lf\n",ca++,areassr);
 }
 return 0;
}

11362 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11362

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

const int put = 11; //alphabet size
struct TrieNode
{
 struct TrieNode *children[put];
 bool isEndOfWord = false;
 int num = 0;
};

struct TrieNode *getNode(void)
{
 struct TrieNode *pNode = new TrieNode;
 pNode->num=0;
 pNode->isEndOfWord=false;
 for (int i = 0; i < put; i++) pNode->children[i] = NULL;
 return pNode;
}
int insert(struct TrieNode *root, string key)
{
 struct TrieNode *pCrawl = root;

 for (unsigned int i = 0; i < key.length(); i++)
 {
 int index = key[i] - '0';
 if (!pCrawl->children[index]) pCrawl->children[index] = getNode();
 pCrawl->num++; //add to get repetitions
 if(pCrawl->isEndOfWord) return true;
 pCrawl = pCrawl->children[index];
 }
 pCrawl->num++;
 pCrawl->isEndOfWord = true;
 return pCrawl->num!=1;
}


int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 struct TrieNode *root = getNode();
 int phones; scanf("%d",&phones); cin.ignore();
 bool flag=true;
 for(int i=0; i<phones;i++)
 {
 string num;
 getline(cin,num);
 if(flag && insert(root,num)) flag=false;
 }
 if(!flag) printf("NO\n");
 else printf("YES\n");
 }
 return 0;
}

11364 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11364

#include <bits/stdc++.h>
using namespace std;
int main() {
 int t, n, x;
 cin>>t;
 while(t--) {
 cin>>n;
 int max = 0, min = 99;
 while(n--) {
 scanf("%d", &x);
 if(x > max) max = x;
 if(x < min) min = x;
 }
 printf("%d\n", (max-min)*2);
 }
 return 0;
}

11396 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11396

#include<bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int color[310];
vector<int> adj[310];
bool posible;
bool visitado[310];
void bipartite(int s)
{
queue<int> Q;
color[s]=1;
Q.push(s);
visitado[s]=true;
while(!Q.empty())
{
 s=Q.front();
 Q.pop();
 for(unsigned int i=0;i<adj[s].size();++i)
 {
 int u=adj[s][i];
 if(color[u]==-1)
 {
 color[u]=1-color[s];
 Q.push(u);
 visitado[u]=true;
 }
 else if(color[u]==color[s])
 posible = false;
 }
}
}

int main()
{
 int x,y,N;
 while(scanf("%d",&N)==1 && N!=0)
 {
 posible=true;
 memset(color,-1,sizeof(color));
 memset(visitado,false,sizeof(visitado));
 while(scanf("%d%d",&x,&y)==2 && (x!=0||y!=0))
 {
 adj[x].push_back(y);
 adj[y].push_back(x);
 }
 for (int i = 0; i < N&&posible; i++)
 if (!visitado[i])
 bipartite(i);

 if(posible) cout<<"YES\n";
 else cout<<"NO\n";
 for(int i=0; i<=N;i++) adj[i].clear();
 }
 return 0;
}

114 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 114

#include <bits/stdc++.h>
using namespace std;

int main() {
 int T;
 cin >> T;
 while (T--) {
 int n; cin >> n;
 if (n == 0) cout << 1 << endl;
 else if (n == 3) cout << 6 << endl;
 else if (n < 5) cout << n << endl;
 else cout << 0 << endl;
 }

 return 0;
}

11417 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11417

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
long long int gcd(long long int a, long long int b) {
 while (b > 0) {
 int temp = b; b = a % b; a = temp;
 }
 return a;
}
int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 long long int G=0;
 for(int i=1;i<n;i++)
 for(int j=i+1;j<=n;j++)
 G+=gcd(i,j);
 cout<<G<<'\n';
 }
 return 0;
}

1144A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; string a; scanf("%d",&cases);
 while(cases--)
 {
 bool flag = true,flag1=true;
 cin>>a;
 set<char> S;
 for(unsigned int i=0; i<a.length();i++) S.insert(a[i]);
 int ant = 0;
 for(auto s:S){

 if(flag1) { ant = s; flag1=false; continue;}
 if(ant+1!=s) { flag=false; break;}
 ant = s;
 }
 if(a.length()==S.size() && flag) printf("Yes\n");
 else printf("No\n");
 }
 return 0;
}

1144B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);int arr[cases];
 int par,impar; par=impar=0;
 for(int i=0;i<cases;i++) { scanf("%d",&arr[i]); if(arr[i]%2==0) par++; else impar++;}
 if(abs(par-impar)<2) printf("0\n");
 else {
 long long int sum = 0;
 sort(arr,arr+cases);
 if (par>impar) { for(int i=0; i<cases && abs(par-impar)>1;i++) if(arr[i]%2==0) { sum+=arr[i]; par--; } }
 else {
 for(int i=0; i<cases && abs(par-impar)>1;i++) if(arr[i]%2!=0) { sum+=arr[i]; impar--; }
 }
 printf("%lld\n",sum);
 }
 return 0;
}

1144C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);
 stack<int> S; int arr[cases];
 vector<int> R;
 for(int i=0;i<cases;i++) scanf("%d",&arr[i]);
 sort(arr,arr+cases);
 for(int i=0;i<cases;i++){
 if((R.size() != 0 && arr[i]==R[R.size()-1]) && (S.size()==0 || S.top()!=arr[i])) S.push(arr[i]);
 else if((R.size()==0 || arr[i]!=R[R.size()-1])) R.push_back(arr[i]);
 else break;
 }
 if(R.size()+S.size()!=cases) printf("NO\n");
 else {
 printf("YES\n%d\n",R.size());
 for(unsigned int i=0; i<R.size();i++) if(i==0) printf("%d",R[i]); else printf(" %d",R[i]);
 if(R.size()==0) printf("\n");
 printf("\n");
 printf("%d\n",S.size());
 int flag = 1;
 int aux = S.size();
 while(!S.empty()) { int e = S.top(); S.pop(); if(flag==1) {flag=0; printf("%d",e);} else printf(" %d",e); }
 if(aux==0) printf("\n");
 }
 return 0;
}

1144D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144D

#include <bits/stdc++.h>
using namespace std;

bool visited[200500];
int cases;

bool check(int elem)
{
 return !((elem==0 && visited[elem+1]) || (elem == cases-1 && visited[cases-2]) || (elem != 0 && elem!=cases-1 && visited[elem+1] && visited[elem-1]));
}
int main()
{
 scanf("%d",&cases);
 int arr[cases];
 map<int,int> M;
 for(int i=0; i<cases;i++) { scanf("%d",&arr[i]); M[arr[i]]++; }
 int actual = 0,rep=0;
 for(auto m:M) if(m.second>actual) { actual=m.second; rep=m.first; }
 queue<int> index;
 memset(visited,false,sizeof(visited));
 for(int i=0; i<cases;i++) if(arr[i]==rep) { visited[i]=true; index.push(i);}
 printf("%d\n",cases-actual);
 int test = cases-actual;
 while(!index.empty() && test!=0)
 {
 int elem = index.front(); index.pop();
 if(elem-1>=0 && arr[elem-1]>rep && !visited[elem-1]) { printf("2 %d %d\n",elem,elem+1); visited[elem-1]=true; if(check(elem-1)) index.push(elem-1); test--; }
 if(elem+1<cases && arr[elem+1]>rep && !visited[elem+1]){ printf("2 %d %d\n",elem+2,elem+1); visited[elem+1]=true; if(check(elem+1)) index.push(elem+1); test--;}
 if(elem-1>=0 && arr[elem-1]<rep && !visited[elem-1]) { printf("1 %d %d\n",elem,elem+1); visited[elem-1]=true; if(check(elem-1)) index.push(elem-1); test--;}
 if (elem+1<cases && arr[elem+1]<rep && !visited[elem+1]){ printf("1 %d %d\n",elem+2,elem+1);visited[elem+1]=true; if(check(elem+1)) index.push(elem+1); test--; }
 if(check(elem)) index.push(elem);
 }
 return 0;
}

11450 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11450

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int model[21][21];
bool mark[210][21];
int memo[210][21];
int m1[21];
int g,mn;

int dp(int money, int c)
{
 if(money<0) return -INF;
 if(c==g) return mn-money;
 int &best = memo[money][c];
 if(mark[money][c]) return best;
 mark[money][c]=true;
 int ans = -INF;
 for(int i=0; i<m1[c]; i++)
 ans = max(ans, dp(money-model[c][i],c+1));
 return best = ans;
}
int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 memset(mark,false,sizeof(mark));
 scanf("%d%d",&mn,&g);
 for(int i=0; i<g;i++)
 {
 scanf("%d",&m1[i]);
 for(int j=0; j<m1[i]; j++) scanf("%d",&model[i][j]);
 }
 int res = dp(mn,0);
 if(res==-INF) printf("no solution\n");
 else printf("%d\n",res);
 }
 return 0;
}

11455 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11455

#include <bits/stdc++.h>
using namespace std;

bool canFormQuadrangle(double a, double b, double c,double d) {
 return (a + b + c> d) && (a + c + d > b) && (b + c + d > a) && (a+b+d>c); }

int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 double arr[4];
 scanf("%lf%lf%lf%lf",&arr[0],&arr[1],&arr[2],&arr[3]);
 sort(arr,arr+4);
 if((arr[0]==arr[1])&&(arr[2]==arr[3])&&(arr[0]==arr[2])) printf("square\n");
 else if(arr[0]==arr[1] && arr[2]==arr[3]) printf("rectangle\n");
 else if(canFormQuadrangle(arr[0],arr[1],arr[2],arr[3])) printf("quadrangle\n");
 else printf("banana\n");
 }
 return 0;
}

11461 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11461

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,m;
 long long int arr[320];
 for(int i=1; i<=320;i++) arr[i]=i*i;
 while(scanf("%d%d",&n,&m)==2 && (n!=0 || m!=0))
 {
 int res=0;
 for(int i=1; i<=320;i++) { if(arr[i]>m) break; else if(arr[i]>=n) res++; }
 cout<<res<<'\n';
 }
 return 0;
}

11463 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11463

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int ca = 1, aux;
 cin >> aux;
 while(aux--)
 {
 int N,R;
 cin>>N>>R;

 vector<vector<int>> buildings(N, vector<int>(N, INF));
 for (int i = 0; i < N; i++) buildings[i][i] = 0;
 for (int i = 0; i < R; i++)
 {
 int u, v;
 cin>>u>>v;
 buildings[u][v] = 1;
 buildings[v][u] = 1;
 }

 for (int k = 0; k < N; k++)
 for (int i = 0; i < N; i++)
 for (int j = 0; j < N; j++)
 buildings[i][j] = min(buildings[i][j], buildings[i][k] + buildings[k][j]);

 int s, d;
 cin>>s>>d;
 int res = 0;
 for (int i = 0; i < N; ++i)
 if (buildings[s][i] != INF && buildings[i][d] != INF)
 res = max(res, buildings[s][i] + buildings[i][d]);
 printf("Case %d: %d\n",ca++,res);
 }
 return 0;
}

11473 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11473

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-15
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
};

double dist(point p1, point p2) { // Euclidean distance
 return hypot(p1.x - p2.x, p1.y - p2.y); } // return double

int main()
{
 int cases,n,m,ca=1;
 while(scanf("%d",&cases)==1)
 {
 while(cases--)
 {
 scanf("%d%d",&n,&m);
 vector<point> V;
 double x,y;
 for(int i=0; i<n;i++)
 {
 scanf("%lf %lf",&x,&y);
 V.push_back(point(x,y));
 }
 double dista = 0;
 printf("Road #%d:\n",ca++);
 printf("%.2lf %.2lf\n",V[0].x,V[0].y);
 for(unsigned int i=0; i<V.size()-1;i++)
 dista+=dist(V[i],V[i+1]);
 dista/=((double) m-1);
 double distacu = 0;
 int cont = 1;
 for(unsigned int i=0; i<V.size()-1;i++)
 {
 double distactual = dist(V[i],V[i+1]);
 double xuni = (V[i+1].x-V[i].x)/distactual;
 double yuni = (V[i+1].y-V[i].y)/distactual;
 if(distactual+distacu>=dista)
 {
 double recorrido=dista-distacu;
 while(recorrido<=distactual)
 {
 cont++;
 //sacar punto
 printf("%.2lf %.2lf\n",V[i].x+recorrido*xuni,V[i].y+recorrido*yuni);
 recorrido+=dista;
 //dista = longitud donde plantar arbol
 //distactual = distancia segmento actual
 //distacu = distancia acumulada anterior
 //recorrido parte distancia actual usada
 }
 distacu = distactual-(recorrido-dista);
 }
 else distacu +=distactual;
 }
 if(cont!=m) printf("%.2lf %.2lf\n",V[V.size()-1].x,V[V.size()-1].y);
 printf("\n");
 }
 }
 return 0;
}

11475 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11475

#include <bits/stdc++.h>
#define FOR(i, a, b) for(int i = (a); i <int(b); i++)
using namespace std;

void manacher(int n, string str, int *r) {
 r[0] = 0;
 int p = 0;
 FOR(i, 1, 2*n-1) {
 r[i] = (p/2 + r[p] >= (i+1)/2) ? min(r[2*p - i], p/2 + r[p] - i/2) : 0;
 while (i/2 + r[i] + 1 < n && (i+1)/2 - r[i] - 1 >= 0
 && str[i/2 + r[i] + 1] == str[(i+1)/2 - r[i] - 1]) r[i]++;
 if (i/2 + r[i] > p/2 + r[p]) p = i;
 }
 FOR(i,0,2*n-1) r[i] = r[i]*2 + !(i&1); // change radius to diameter
}

int main()
{
 string line;
 while(getline(cin,line))
 {
 if(line==".") break;
 int arr[line.length()*2-1]; memset(arr,0,sizeof(arr));
 manacher(line.length(),line,arr);
 int sol = line.length()-1; //In worst case last n-1 characters to get the palindromic
 FOR(i,0,2*line.length()-2)
 if(i+arr[i]-1==2*line.length()-2){ sol=min(sol,(i-(arr[i]-1))/2); }
 //(Position - movement to left - 1)/2 position to start
 cout<<line;
 for(int i=sol-1;i>=0;i--)
 printf("%c",line[i]);
 printf("\n");
 }
 return 0;
}

11479 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11479

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int l,cases=1; cin>>l;
 while(l--)
 {
 long long int first, second, third;
 cin >> first >> second >> third;
 cout << "Case " << cases++ << ": ";
 if (first <= 0 || second <= 0 || third <= 0 ||first + second <= third || first + third <= second || second + third <= first) cout << "Invalid\n";
 else if (first == second && second == third) cout << "Equilateral\n";
 else if (first == second || first == third || second == third) cout << "Isosceles\n";
 else cout << "Scalene\n";
 }
 return 0;
}

11498 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11498

#include <bits/stdc++.h>
using namespace std;
int main() {
 int n, x, y, a, b;
 while(scanf("%d", &n) == 1 && n) {
 cin>>x>>y;
 while(n--) {
 cin>>a>>b;
 if(a == x || b == y)
 cout<<"divisa\n";
 else if(a > x && b > y)
 cout<<"NE\n";
 else if(a < x && b > y)
 cout<<"NO\n";
 else if(a < x && b < y)
 cout<<"SO\n";
 else
 cout<<"SE\n";
 }
 }
 return 0;
}

115 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 115

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n;
 while (scanf("%d",&n)==1 && n != 0)
 {
 if(n==1||n==9||n==45||n==55||n==99||n==297||n==703||n==999||n==2223||n==2728||n==4879||n==4950||n==5050||n==5292||n==7272||n==7777||n==9999||n==17344||n==22222||n==38962)
 printf("SI\n");
 else printf("NO\n");
 }

 return 0;
}

11507 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11507

#include <bits/stdc++.h>
using namespace std;
int main() {
 int cases;
 while(scanf("%d", &cases)&& cases!=0) {
 int dir = 0;
 string aux;
 //+x(0), -x(1), +y(2), -y(3), +z(4), -z(5)
 for(int i=1; i<cases; i++)
 {
 cin>>aux;
 if(aux=="No")
 continue;
 if(aux=="+z") {
 if(dir == 0) dir = 4;//+x->+z
 else if(dir == 1) dir = 5;//-x->-z
 else if(dir == 4) dir = 1;//+z->-x
 else if(dir == 5) dir = 0;//-z->+x
 }
 if(aux=="-z") {
 if(dir == 0) dir = 5;//+x->-z
 else if(dir == 1) dir = 4;//-x->+z
 else if(dir == 4) dir = 0;//+z->+x
 else if(dir == 5) dir = 1;//-z->-x
 }
 if(aux== "+y") {
 if(dir == 0) dir = 2;//+x->+y
 else if(dir == 1) dir = 3;//-x->-y
 else if(dir == 2) dir = 1;//+y->-x
 else if(dir == 3) dir = 0;//-y->+x
 }
 if(aux=="-y") {
 if(dir == 0) dir = 3;//+x->-y
 else if(dir == 1) dir = 2;//-x->+y
 else if(dir == 2) dir = 0;//+y->+x
 else if(dir == 3) dir = 1;//-y->-x
 }
 }
 if(dir == 0) cout<<"+x\n";
 if(dir == 1) cout<<"-x\n";
 if(dir == 2) cout<<"+y\n";
 if(dir == 3) cout<<"-y\n";
 if(dir == 4) cout<<"+z\n";
 if(dir == 5) cout<<"-z\n";
 }
 return 0;
}

11512 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11512

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

typedef pair<int, int> ii;

#define MAX_N 100010 // second approach: O(n log n)
char T[MAX_N]; // the input string, up to 100K characters
int n; // the length of input string
int RA[MAX_N], tempRA[MAX_N]; // rank array and temporary rank array
int SA[MAX_N], tempSA[MAX_N]; // suffix array and temporary suffix array
int c[MAX_N]; // for counting/radix sort

char P[MAX_N]; // the pattern string (for string matching)
int m; // the length of pattern string

int Phi[MAX_N]; // for computing longest common prefix
int PLCP[MAX_N];
int LCP[MAX_N]; // LCP[i] stores the LCP between previous suffix T+SA[i-1]
 // and current suffix T+SA[i]
bool cmp(int a, int b) { return strcmp(T + a, T + b) < 0; } // compare

void countingSort(int k) { // O(n)
 int i, sum, maxi = max(300, n); // up to 255 ASCII chars or length of n
 memset(c, 0, sizeof c); // clear frequency table
 for (i = 0; i < n; i++) // count the frequency of each integer rank
 c[i + k < n ? RA[i + k] : 0]++;
 for (i = sum = 0; i < maxi; i++) {
 int t = c[i]; c[i] = sum; sum += t;
 }
 for (i = 0; i < n; i++) // shuffle the suffix array if necessary
 tempSA[c[SA[i]+k < n ? RA[SA[i]+k] : 0]++] = SA[i];
 for (i = 0; i < n; i++) // update the suffix array SA
 SA[i] = tempSA[i];
}

void constructSA() { // this version can go up to 100000 characters
 int i, k, r;
 for (i = 0; i < n; i++) RA[i] = T[i]; // initial rankings
 for (i = 0; i < n; i++) SA[i] = i; // initial SA: {0, 1, 2, ..., n-1}
 for (k = 1; k < n; k <<= 1) { // repeat sorting process log n times
 countingSort(k); // actually radix sort: sort based on the second item
 countingSort(0); // then (stable) sort based on the first item
 tempRA[SA[0]] = r = 0; // re-ranking; start from rank r = 0
 for (i = 1; i < n; i++) // compare adjacent suffixes
 tempRA[SA[i]] = // if same pair => same rank r; otherwise, increase r
 (RA[SA[i]] == RA[SA[i-1]] && RA[SA[i]+k] == RA[SA[i-1]+k]) ? r : ++r;
 for (i = 0; i < n; i++) // update the rank array RA
 RA[i] = tempRA[i];
 if (RA[SA[n-1]] == n-1) break; // nice optimization trick
} }

void computeLCP() {
 int i, L;
 Phi[SA[0]] = -1; // default value
 for (i = 1; i < n; i++) // compute Phi in O(n)
 Phi[SA[i]] = SA[i-1]; // remember which suffix is behind this suffix
 for (i = L = 0; i < n; i++) { // compute Permuted LCP in O(n)
 if (Phi[i] == -1) { PLCP[i] = 0; continue; } // special case
 while (T[i + L] == T[Phi[i] + L]) L++; // L increased max n times
 PLCP[i] = L;
 L = max(L-1, 0); // L decreased max n times
 }
 for (i = 0; i < n; i++) // compute LCP in O(n)
 LCP[i] = PLCP[SA[i]]; // put the permuted LCP to the correct position
}

pair<int,pair<int,int>> LRS() { // returns a pair (the LRS length and its index)
 int i, idx = 1, maxLCP = -1, j=0,flag=0;
 for (i = 1; i < n; i++) // O(n), start from i = 1
 if (LCP[i] > maxLCP) { maxLCP = LCP[i], idx = 2; j=i; flag=1;}
 else if (LCP[i] == maxLCP && flag==1) idx++;
 else flag=0;
 return make_pair(maxLCP,make_pair(j,idx));
}

int main() {
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 memset(T, '\0', sizeof(T));
 scanf("%s",T);
 n = (int)strlen(T);
 T[n++] = '$';
 constructSA(); // O(n log n)
 computeLCP(); // O(n)
 pair<int,pair<int,int>> ans = LRS(); // find the LRS of the first input string
 pair<int,int> res = ans.second;
 string a = T + SA[res.first];
 a = a.substr(0,ans.first);
 if(ans.first ==0) printf("No repetitions found!\n");
 else printf("%s %d\n", a.c_str(), res.second);
 }
 return 0;
}

11547 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11547

#include <bits/stdc++.h>
using namespace std;
int main() {
 int t, n;
 cin>>t;
 while(t--) {
 cin>>n;
 int x = (n*63+7492)*5-498;
 if(x < 0)
 x *= -1;
 printf("%d\n", x/10%10);
 }
 return 0;
}

11559 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11559

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main()
{
 int n,b,h,w,p,wh;
 while(scanf("%d%d%d%d",&n,&b,&h,&w)==4)
 {
 int res = INF;
 while(h--)
 {
 cin>>p;
 for(int i=0; i<w;i++)
 {
 cin>>wh;
 if(wh>=n)
 res=min(res,n*p);
 }
 }
 if(res<=b)
 cout<<res<<endl;
 else
 cout<<"stay home\n";
 }
 return 0;
}

11586 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11586

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases,count=0;
 cin>>cases;
 cin.ignore();
 while(cases--)
 {
 count=0;
 string temp;
 getline(cin, temp);
 for (unsigned int i = 0; i< temp.length(); i++)
 {
 if (temp[i] == 'M')
 count++;
 else if (temp[i] == 'F')
 count--;
 }

 if (count == 0 && temp.length() > 3)
 cout << "LOOP\n";
 else
 cout << "NO LOOP\n";
 }
 return 0;
}

116 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 116

#include <bits/stdc++.h>
using namespace std;
int main() {
 int cases; cin>>cases;
 while(cases--)
 {
 cout<<"Hola mundo.\n";
 }
 return 0;
}

11608 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11608

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int sum,aux=1;
 while(scanf("%d",&sum)==1 && sum>-1)
 {
 int arr[12],num;
 printf("Case %d:\n",aux++);
 for(int i=0; i<12;i++) cin>>arr[i];
 for(int i=0; i<12;i++)
 {
 cin>>num;
 if(num<=sum) { cout<<"No problem! :D\n"; sum=arr[i]+sum-num;}
 else { cout<<"No problem. :(\n"; sum+=arr[i];}
 }
 }
 return 0;
}

11614 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11614

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {

 double d;
 int T;
 cin>>T;
 while(T--){
 long long int x,lo=0, hi=10000000000,ans=0;
 cin>>x;
 while(lo<=hi)
 {
 long long mid=(lo+hi)/2;
 long long temp=mid*(mid+1)/2;
 if(temp<=x)
 {
 ans=mid;
 lo=mid+1;
 }
 else hi=mid-1;
 }
 cout<<ans<<'\n';
 }
 return 0;
}

11626 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11626

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
using namespace std;

struct point{
 long long int x,y;
};

point arr[100005];
point res[100005];

long long int cross(const point &O, const point &A, const point &B)
{
 return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
}
bool cmp(point a, point b) {
 if(a.x != b.x) return a.x < b.x;
 return a.y < b.y;
}
int CH(int n) {
 sort(arr, arr+n,cmp);
 int i, m = 0, t;
 for (i = 0; i < n; i++) {
 //if == 0 is collinear
 while(m >= 2 && cross(res[m-2], res[m-1], arr[i]) < 0)
 m--;
 res[m++] = arr[i];
 }
 //n-2 para ignorar un punto que se repetira
 for (i = n-2, t = m+1; i >= 0; i--) {
 while(m >= t && cross(res[m-2], res[m-1], arr[i]) < 0)
 m--;
 res[m++] = arr[i];
 }
 return m-1;
}

int main()
{
 freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/out.txt","w",stdout);

 int cases; scanf("%d",&cases);
 while(cases--)
 {
 int n,j=0;
 char c;
 scanf("%d",&n);
 for(int i=0; i<n;i++)
 {
 scanf("%lld %lld %c",&arr[j].x,&arr[j].y,&c);
 if(c=='Y') j++;
 }
 n = CH(j);
 printf("%d\n",n);
 for(int i=0; i<n;i++)
 printf("%lld %lld\n",res[i].x,res[i].y);
 }
 return 0;
}

11629 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11629

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,m,c=1;
 while(scanf("%d %d",&n,&m)==2)
 {
 map<string,double> M;
 for(int i=0; i<n;i++)
 {
 string aux; double a; cin>>aux>>a;
 M[aux]=a;
 }
 cin.ignore();
 for(int i=0; i<m;i++)
 {
 string aux;
 getline(cin,aux);
 istringstream iss(aux);
 vector<string> v((istream_iterator<string>(iss)),istream_iterator<string>());
 int flag=0; double res=0;
 string op;
 for(auto word:v)
 {
 if(word=="+") continue;
 if(word!="<"&&word!=">"&&word!="<="&&word!=">="&&word!="=")
 res+=M[word];
 else { op=word; break; }
 }
 res = ceilf(res*1000)/1000;
 int res1= stoi(v[v.size()-1]);
 if(op=="=") {if(res!=res1) flag=1;}
 else if(op=="<") {if(!(res<res1)) flag=1;}
 else if(op==">") {if(!(res>res1)) flag=1;}
 else if(op==">=") {if(!(res>=res1)) flag=1;}
 else if(op=="<=") {if(!(res<=res1)) flag=1;}

 if(flag==0) printf("Guess #%d was correct.\n",c++);
 else printf("Guess #%d was incorrect.\n",c++);
 }
 }
 return 0;
}

11631 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11631

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

const int MAXN = 200100;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
 bool operator<(const edge &other)const{ // sobrecarga de operadores para ordenar
 return weight < other.weight;
 }
};

struct UF{
 int parents[MAXN];
 int sz[MAXN];
 int components;
 int mst_sum;
 UF(int n){
 for(int i=0;i<n;i++){
 parents[i] = i; sz[i] = 1;
 }
 components = n;
 mst_sum = 0;
 }
 int find(int n){
 return n == parents[n] ? n : find(parents[n]);
 }
 bool isConnected(int a, int b){
 return find(a) == find(b);
 }
 void connect(int a, int b, int weight){
 if(isConnected(a, b)) return;
 int A,B; A = find(a); B = find(b);
 if(sz[A] > sz[B]){
 parents[B] = A;
 sz[A] += sz[B];
 }
 else{
 parents[A] = B;
 sz[B] += sz[A];
 }
 mst_sum += weight;
 components--;
 }
};

int N,E;

int main(){
 while(scanf("%d %d",&N,&E)==2 && (N!=0||E!=0))
 {
 vector<edge> edges;
 UF uf = UF(N);
 int total = 0;
 for(int i=0;i<E;i++){
 int from, to, weight; scanf("%d %d %d",&from, &to, &weight);
 total+=weight;
 edges.push_back(edge(from,to,weight));
 }
 sort(edges.begin(), edges.end());
 for(int i=0;i<E;i++) uf.connect(edges[i].from, edges[i].to, edges[i].weight);
 printf("%d\n",total-uf.mst_sum);
 }
 return 0;
}

11639 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11639

#include <bits/stdc++.h>
using namespace std;

double lxsol, lysol, rxsol,rysol;

int hasIntersect(int lx, int ly, int rx, int ry, int la, int lb, int ra, int rb) {
 lx = lxsol = max(lx, la);
 ly = lysol = max(ly, lb);
 rx = rxsol = min(rx, ra);
 ry = rysol = min(ry, rb);
 return lx < rx && ly < ry;
}

int main()
{
 int cases,ca=1; scanf("%d",&cases);
 double lx,ly,rx,ry,la,lb,ra,rb;
 while(cases--)
 {
 scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&lx,&ly,&rx,&ry,&la,&lb,&ra,&rb);
 double areassr,areawsr,areausr;
 if(!hasIntersect(lx,ly,rx,ry,la,lb,ra,rb)) {lxsol=lysol=rxsol=rysol=0;}
 //printf("%lf %lf %lf %lf\n",lxsol,lysol,rxsol,rysol);
 areassr=abs(rysol-lysol)*abs(rxsol-lxsol);
 areawsr=abs(lx-rx)*abs(ly-ry); areawsr-=areassr;
 double aux =abs(la-ra)*abs(lb-rb); areawsr+=aux-areassr;
 areausr=100*100; areausr-=areassr; areausr-=areawsr;
 printf("Night %d: %0.lf %0.lf %0.lf\n",ca++,areassr,areawsr,areausr);
 }
 return 0;
}

11650 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11650

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int T;
 cin>>T;
 while (T--)
 {
 int hr, min;
 char temp;
 cin>>hr>>temp>>min;
 min = (60 - min) % 60;
 hr = 12 - hr;
 if (min != 0)
 hr--;
 hr = (hr + 12) % 12;
 if (hr == 0)
 hr = 12;
 printf("%02d:%02d\n", hr, min);
 }
}

11661 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11661

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main()
{
 int cases;
 while(scanf("%d",&cases)&&cases!=0)
 {
 int res=INF,lastdrug=-INF,lastburguer=-INF;
 char c;
 for(int i=0; i<cases;i++)
 {
 cin>>c;
 if(c=='Z') res=0;
 if(c=='D') {res=min(res,i-lastburguer); lastdrug=i;}
 if(c=='R') {res=min(res,i-lastdrug); lastburguer=i;}
 }
 cout<<res<<endl;
 }
 return 0;
}

11677 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11677

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int h1,m1,h2,m2;
 while(scanf("%d%d%d%d",&h1,&m1,&h2,&m2)==4&&(h1!=0||m1!=0||h2!=0||m2!=0))
 {
 if(h2==h1 && m2<m1) h2+=24;
 else if(h2<h1) h2+=24;
 cout<<(h2*60+m2)-(h1*60+m1)<<endl;
 }
 return 0;
}

11679 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11679

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int B, N, owe=0, owed=0, amount=0;
 int owes[20];
 while(scanf("%d %d", &B, &N)==2 && (B!=0 || N!=0))
 {
 for (int i = 0; i < B; i++) cin>>owes[i];
 while (N--)
 {
 cin>>owe>>owed>>amount;
 owes[owe - 1] -= amount;
 owes[owed - 1] += amount;
 }
 bool positive=true;
 for (int i = 0; i < B; i++)
 if (owes[i] < 0) {positive = false; break;}

 if (positive) cout<<"S\n";
 else cout<<"N\n";
 }
 return 0;
}

11683 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11683

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int height, length,wantedSize[10010];
 while (scanf("%d", &height) && height!=0)
 {
 cin>>length;
 int count=0;
 cin>>wantedSize[0];
 count += height - wantedSize[0];
 for (int i = 1; i < length; ++i)
 {
 cin>>wantedSize[i];
 if (wantedSize[i] != height)
 {
 int temp = wantedSize[i - 1] - wantedSize[i];
 if (temp > 0) count += temp;
 }
 }
 cout<<count<<endl;
 }
 return 0;
}

11687 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11687

#include <bits/stdc++.h>
using namespace std;

string toString(long number){
 stringstream ss;
 ss << number;
 return ss.str();
}
int main() {
 string str ;
 while(cin >> str){
 if( str=="END" ) break ;
 int ans = 1 ;
 while(str != "1" ){
 int len = str.length();
 ans++;
 str = toString(len);
 }
 cout<<ans<<endl;
 }
 return 0;
}

117 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 117

#include <iostream>
using namespace std;

int main()
{
 int n=0;
 scanf("%d",&n);
 char nombre[n][100];
 string basura;
 for(int i=0; i<n; i++)
 {
 std::cin >> basura >>nombre[i];
 std::cout << "Hola, " << nombre[i] << ".\n";
 }
 return 0;
}

11710 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11710

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

const int MAXN = 200100;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
};

struct state{
 int node, dist;
 state(){}
 state(int a, int b){
 node = a; dist = b;
 }
 bool operator<(const state &other)const{ // sobrecarga de operadores para ordenar
 return other.dist < dist;
 }
};

vector<edge> graph[MAXN];
bool visited[MAXN];
int dist[MAXN];

int N,E;

int prim(int start){
 priority_queue<state> pq;
 pq.push(state(start, 0));
 dist[start] = 0;
 int sum = 0;
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(dist[cur.node] < cur.dist) continue;
 if(visited[cur.node]) continue;
 sum += cur.dist;
 visited[cur.node] = true;
 for(unsigned int i=0;i<graph[cur.node].size();i++){
 int dest = graph[cur.node][i].to;
 int wht = graph[cur.node][i].weight;
 if(visited[dest]) continue;
 pq.push(state(dest, wht));
 dist[dest] = wht;
 }
 }
 return sum;
}
int main(){
 while(scanf("%d %d",&N,&E)==2 && (N!=0||E!=0))
 {
 memset(visited,0,sizeof(visited));
 for(int i=1;i<=N;i++) {dist[i]=INF; graph[i].clear();} // limpia el grafo
 map<string,int> M;
 for(int i=0; i<N;i++) {string r; cin>>r; M[r]=i+1;}
 for(int i=0;i<E;i++){
 string a,b; int weight; cin>>a>>b>>weight;
 graph[M[a]].push_back(edge(M[a],M[b],weight));
 graph[M[b]].push_back(edge(M[b], M[a], weight)); // borrar linea si es dirigido
 }
 string aux; cin>>aux;
 int res = prim(M[aux]);
 int flag=1;
 for(int i=1; i<=N;i++) if(dist[i]==INF) {flag=0; break;}
 if(flag==0) printf("Impossible\n");
 else printf("%d\n",res);
 }
 return 0;
}

11723 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11723

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 int n, m, ca = 1;
 while(scanf("%d %d", &n, &m) == 2 && (n!=0 || m!=0)) {
 int ans = (n-1)/m;
 if(ans > 26) printf("Case %d: impossible\n", ca++);
 else printf("Case %d: %d\n",ca++, ans);
 }
 return 0;
}

11727 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11727

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int a,m=0;
 cin>>a;
 while(m!=a)
 {
 int salary[3];
 cin>>salary[0]>>salary[1]>>salary[2];
 sort(salary,salary+3);
 cout<<"Case "<<m+1<<": "<<salary[1]<<endl;
 m++;
 }
 return 0;
}

1174 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1174

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

const int MAXN = 200100;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
};

struct state{
 int node, dist,res;
 state(){}
 state(int a, int b){
 node = a; dist = b;
 }
 bool operator<(const state &other)const{ // sobrecarga de operadores para ordenar
 return other.dist < dist;
 }
};

vector<edge> graph[MAXN];
bool visited[MAXN];
int dist[MAXN];

int N,E;

int prim(int start){
 priority_queue<state> pq;
 pq.push(state(start, 0));
 dist[start] = 0;
 int sum = 0;
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(dist[cur.node] < cur.dist) continue;
 if(visited[cur.node]) continue;
 sum += cur.dist;
 visited[cur.node] = true;
 for(unsigned int i=0;i<graph[cur.node].size();i++){
 int dest = graph[cur.node][i].to;
 int wht = graph[cur.node][i].weight;
 if(visited[dest]) continue;
 pq.push(state(dest, wht));
 dist[dest] = wht;
 }
 }
 return sum;
}
int main(){
 int cases; cin>>cases;
 string line;
 while(cases--)
 {
 getline(cin,line);
 cin.ignore();
 scanf("%d %d",&N,&E);
 memset(visited,0,sizeof(visited));
 map<string,int> M;
 int c=1;
 for(int i=1;i<=N;i++) {dist[i]=INF; graph[i].clear();}
 for(int i=0; i<E;i++)
 {
 string to,from; int weight; cin>>to>>from>>weight;
 if(M[to]==0) { M[to]=c; c++;}
 if(M[from]==0) { M[from]=c; c++;}
 graph[M[from]].push_back(edge(M[from],M[to],weight));
 graph[M[to]].push_back(edge(M[to], M[from], weight));
 }
 printf("%d\n",prim(1));
 if(cases!=0) cout<<'\n';
 }
 return 0;
}

11743 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11743

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int cases; cin>>cases; cin.ignore();
 while(cases--)
 {
 string credit; getline(cin,credit);
 vector<string> d;
 int n=0,sum=0,c=0;
 for(unsigned int i=0; i<credit.length();i++)
 {
 if(credit[i]==' ') continue;
 if(c%2==0)d.push_back(to_string((credit[i]-48)*2));
 else n+=(credit[i]-48);
 c++;
 }
 for(unsigned int i=0; i<d.size();i++)
 {
 string aux = d[i];
 for(unsigned int i=0; i<aux.length();i++) sum+=(aux[i]-48);
 }
 int res = sum+n;
 if(res%10==0) cout<<"Valid\n";
 else cout<<"Invalid\n";
 }
 return 0;
}

11764 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11764

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int casos,num,valor,salb,sala,valor2,val=1;
 cin>>casos;
 while(casos+1!=val)
 {
 salb=0; sala=0;
 cin>>num;
 cin>>valor;
 for(int i=0; i<num-1;i++)
 {
 cin>>valor2;
 if(valor<valor2)
 sala++;
 if(valor>valor2)
 salb++;
 valor=valor2;
 }
 cout<< "Case "<<val << ": "<<sala << " " <<salb<<"\n";
 val++;
 }
 return 0;
}

11777 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11777

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {

 int n,ca=1; cin>>n;
 while (n--) {
 int arr[3];
 int T1,T2,F,A; cin>>T1>>T2>>F>>A>>arr[0]>>arr[1]>>arr[2];
 sort(arr,arr+3);
 int res = T1+T2+F+A+(int)(arr[2]+arr[1])/2;
 printf("Case %d: ",ca++);
 if(res>=90) cout<<"A"<<'\n';
 else if(res>=80) cout<<"B"<<'\n';
 else if(res>=70) cout<<"C"<<'\n';
 else if(res>=60) cout<<"D"<<'\n';
 else cout<<"F"<<'\n';
 }
 return 0;
}

11792 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11792

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

struct edge{
int from, to; edge(){}
edge(int a, int b){
from = a; to = b;}};

const int MAXN = 10005;
vector<edge> graph[MAXN];
map<int,int> M;
int totalVar;

inline int BFS(int start){

 map<int,int> V;
 int auxTotal = 0;
 queue<pair<int,int> > q;
 int res = 0;
 q.push(make_pair(start,0));
 V[start] = 1;
 while(!q.empty()){
 pair<int,int> current = q.front(); q.pop();
 if(M[current.first]>1) { res+=current.second; auxTotal++;}
 if(auxTotal==totalVar) return res;
 for(unsigned int i=0;i<graph[current.first].size();i++){
 int dest = graph[current.first][i].to;
 if(V[dest]!=0) continue;
 V[dest] = 1;
 q.push(make_pair(dest,current.second+10));
 }
 }
 return res;
}

inline int getchar_unlocked() { return getchar(); }
inline void fastInput(int &n){
 char ch;
 int sign = 1;
 while(ch = getchar_unlocked(), isspace(ch)) {

 };
 n = 0;
 if(ch == '-')
 sign = -1;
 else n = ch - '0';
 while(ch = getchar_unlocked(), isdigit(ch))
 n = (n << 3) + (n << 1) + ch - '0';
 n *= sign;
}

int main(){
 int a,b,cases; fastInput(cases);
 while(cases--)
 {
 fastInput(a); fastInput(b);
 set<int> S;
 set<pair<int,int>> inserted;
 for(int i=0; i<b;i++)
 {
 int n,m;
 fastInput(m); if(m==0) continue; fastInput(n);
 while(1)
 {
 if(inserted.count(make_pair(n,m))==0 || inserted.count(make_pair(m,n))==0 )
 {
 graph[n].push_back(edge(n,m));
 graph[m].push_back(edge(m,n));
 inserted.insert(make_pair(n,m));
 inserted.insert(make_pair(m,n));
 }

 M[m]++;
 if(M[m]>1) S.insert(m);
 m=n;
 fastInput(n);
 if(n==0) break;
 }
 M[m]++;
 if(M[m]>1) S.insert(m);
 }
 totalVar=S.size();
 int res=INF,sol=-1;
 for(auto s:S)
 {
 int resaux = BFS(s);
 if(res>resaux) { sol=s; res=resaux;}
 }
 printf("Krochanska is in: %d\n",sol);
 for(int i=0;i<=a;i++) graph[i].clear();
 M.clear();
 }
return 0;
}

11799 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11799

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases,i=1;
 cin>>cases;
 while(cases--)
 {
 int m=0,num,a;
 cin>>num;
 while(num--)
 {
 cin>>a;
 m=max(m,a);
 }
 cout<<"Case "<<i<<": "<<m<<endl;
 i++;
 }
 return 0;
}

11805 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11805

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 int T,N,K,P, ca = 1; cin>>T;
 while(T--) {
 cin>>N>>K>>P;
 int n = (K+P)%N;
 if(n==0) n =N;
 printf("Case %d: %d\n",ca++, n);
 }
 return 0;
}

11831 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11831

#include<bits/stdc++.h>
using namespace std;

char matrix[105][105];
int sx[]={-1,0,1,0}; //4 directions N L S O
int sy[]={0,1,0,-1};
int main(){
 int N,M,Q;
 char dir;
 while(scanf("%d%d%d",&N,&M,&Q)==3 && (N!=0 || M!=0 || Q!=0))
 {
 cin.ignore();
 int pos,x,y,sol=0;
 for(int i=0; i<N;i++)
 {
 for(int j=0; j<M;j++) {
 scanf("%c",&matrix[i][j]);
 if(matrix[i][j]!='.' && matrix[i][j]!='*' && matrix[i][j]!='#') { x=i; y=j; dir = matrix[i][j];}
 }
 cin.ignore();
 }
 string line; cin>>line;
 if(dir=='N') pos = 0;
 else if(dir=='L') pos = 1;
 else if(dir=='S') pos = 2;
 else if(dir=='O') pos = 3;
 for(int i=0; i<Q;i++)
 {
 int I = x+sx[pos];
 int J = y+sy[pos];
 if(line[i]=='D') pos=(pos+1)%4;
 else if(line[i]=='E') { pos--; if(pos==-1) pos = 3; }
 else if(line[i]=='F' && I>=0 && I<N && J>=0 && J<M &&matrix[I][J] != '#')
 {
 if(matrix[I][J]=='*') { sol++; matrix[I][J]='.'; }
 x=I; y=J;
 }
 }
 printf("%d\n",sol);
 }
 return 0;
}

11834 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11834

#include <bits/stdc++.h>
using namespace std;

int main()
{
 double l,w,r,r1;
 while(scanf("%lf%lf%lf%lf",&l,&w,&r,&r1)==4 && (l!=0 || w!=0 || r!=0 || r1!=0))
 {
 int nl = l-r-r1;
 int nw = w-r-r1;
 int nr = r+r1;
 if(r*2>min(l,w) || r1*2>min(l,w)) printf("N\n");
 else if(nl*nl+nw*nw>=nr*nr) printf("S\n"); //diagonal distance more than r diagonal distance
 else printf("N\n");
 }
 return 0;
}

11849 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11849

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
int n,m;
 while(scanf("%d %d",&n,&m)==2 && (n!=0 || m!=0))
 {
 int aux;
 map<int,int> M;
 for(int i=0; i<n+m;i++) {cin>>aux; M[aux]++;}
 int sol = 0;
 for(auto m:M) if(m.second==2) sol++;
 cout<<sol<<endl;
 }
 return 0;
}

11854 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11854

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int a,b,c;
 while(scanf("%d%d%d",&a,&b,&c)==3 && (a!=0 || b!=0 || c!=0))
 {
 if(a>=b && a>=c) { if(sqrt(b*b + c*c)==a) cout<<"right\n"; else cout<<"wrong\n"; }
 else if(b>=a && b>=c) { if(sqrt(a*a + c*c)==b) cout<<"right\n"; else cout<<"wrong\n"; }
 else if(c>=a && c>=b) { if(sqrt(b*b + a*a)==c) cout<<"right\n"; else cout<<"wrong\n"; }
 }
return 0;
}

11888 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11888

#include <bits/stdc++.h>
#define FOR(i, a, b) for(int i = (a); i <int(b); i++)
using namespace std;

void manacher(int n, string str, int *r) {
 r[0] = 0;
 int p = 0;
 FOR(i, 1, 2*n-1) {
 r[i] = (p/2 + r[p] >= (i+1)/2) ? min(r[2*p - i], p/2 + r[p] - i/2) : 0;
 while (i/2 + r[i] + 1 < n && (i+1)/2 - r[i] - 1 >= 0
 && str[i/2 + r[i] + 1] == str[(i+1)/2 - r[i] - 1]) r[i]++;
 if (i/2 + r[i] > p/2 + r[p]) p = i;
 }
 FOR(i,0,2*n-1) r[i] = r[i]*2 + !(i&1); // change radius to diameter
}

int main()
{
 string line;
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 cin>>line;
 int arr[line.length()*2-1]; memset(arr,0,sizeof(arr));
 int len = line.length();
 manacher(len,line,arr);

 bool flag = false;
 int totalLength = 2*line.length()-1;
 FOR(i,0,(totalLength-1)/2)
 {
 int leng = i*2+1;
 int other = (totalLength-leng)/2 + leng;
 if (arr[i]+arr[other]==line.length()){
 flag = true;
 break;
 }
 }
 if(flag) printf("alindrome\n");
 else if(arr[len-1]==len) printf("palindrome\n");
 else printf("simple\n");
 }
 return 0;
}

119 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 119

#include <bits/stdc++.h>
using namespace std;

int main() {
 int n;
 while (scanf("%d",&n)==1 && n != 0)
 {
 int total=0;
 while(n>3)
 {
 int res = sqrt(n);
 n-=(res*res);
 total += (((res*2+(res-2)*2)*2+4)+(res-2)*(res-2));
 }
 if(n!=0) total+=(n*5);
 cout<<total<<'\n';
 }
 return 0;
}

119 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 119

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int n,flag=0;
 while(scanf("%d",&n)==1){
 if(flag==1) cout<<endl;
 flag=1;
 int cant,friends;
 string s1,s2;
 vector<string> v;
 map<string, int> M;
 for(int i=0;i<n;i++){
 cin>>s1;
 v.push_back(s1);
 }
 for(int i=0;i<n;i++){
 cin>>s1>>cant>>friends;
 if(friends!=0) M[s1]-=friends*(cant/friends);
 for(int j=0;j<friends;j++){
 cin>>s2;
 M[s2]+=cant/friends;
 }
 }
 for(int i=0;i<n;i++)
 cout<<v[i]<<" "<<M[v[i]]<<endl;
 }
 return 0;
}

11909 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11909

#include <bits/stdc++.h>
#define PI acos(-1.0)
using namespace std;

int main()
{
 double L,W,H,G;
 while(scanf("%lf%lf%lf%lf",&L,&W,&H,&G)==4)
 {
 double volt = L*W*H;
 double d = (L*sin(G*PI/180))/sin((90-G)*PI/180);
 if(G==90) printf("0 mL\n");
 else if(d<=H)
 {
 d = (L*sin(G*PI/180))/sin((90-G)*PI/180);
 double vola = L*d*W/2;
 printf("%.3lf mL\n",volt-vola);
 }
 else if(G){
 d = H*sin((90-G)*PI/180)/sin(G*PI/180);
 double vola = H*d*W/2;
 printf("%.3lf mL\n",vola);
 }
 else{
 printf("%.3lf mL\n",volt);
 }
 }
}

11934 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11934

#include <bits/stdc++.h>
using namespace std;
int main ()
{
 int a,b,c,d,L;
 while ( scanf ("%d%d%d%d%d", &a,&b,&c,&d,&L)==5 && (a!=0 || b!=0 || c!=0 || d!=0 || L!=0))
 {
 int res = 0;
 for(int i=0; i<=L;i++)
 {
 if((a*i*i+b*i+c)%d==0) res++;
 }
 printf("%d\n",res);
 }
 return 0;
}

11935 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11935

#include <bits/stdc++.h>
using namespace std;

int main(){
 string s;
 int x,y,leak,fph;
 while (scanf("%d Fuel consumption %d",&x,&fph)==2 && (x!=0 || fph!=0)){
 y=leak=0;
 double res = 0.0, cur = 0.0;
 while(1)
 {
 scanf("%d", &y); cin>>s;
 cur += (y - x) * fph / 100.0;
 cur += (y - x) * leak;
 res = max(res, cur);
 if (s[0] == 'G' && s[1] == 'o') break;
 else if (s[0] == 'L') leak++ ;
 else if (s[0] == 'M') leak = 0;
 else if (s[0] == 'G') { cin>>s; cur = 0.0;}
 else { cin>>s; scanf("%d", &fph); }
 x = y;
 }
 printf("%.3lf\n", res);
 }
 return 0;
}

11936 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11936

#include <bits/stdc++.h>
using namespace std;

bool canFormTriangle(double a, double b, double c) {
 return (a + b > c) && (a + c > b) && (b + c > a); }

int main()
{
 int cases; scanf("%d",&cases);
 double d1,d2,d3;
 while(cases--)
 {
 scanf("%lf%lf%lf",&d1,&d2,&d3);
 if(canFormTriangle(d1,d2,d3)) printf("OK\n");
 else printf("Wrong!!\n");
 }
 return 0;
}

11942 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11942

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases;
 cin>>cases;
 cout<<"Lumberjacks:\n";
 while(cases--)
 {
 int a,b,c;
 bool menor = false, sol=true;
 cin>>a>>b;
 if(a<b)
 menor=true;
 if(menor)
 {
 for(int i=0; i<8;i++)
 {// 13=a 25=b 39=b 40=a
 cin>>a;
 if(a<b)
 sol=false;
 b=a;
 }
 }
 else
 { //78=b 61=a
 for(int i=0; i<8;i++)
 {
 cin>>a;
 if(a>b)
 sol=false;
 b=a;
 }
 }
 if(sol)
 cout<<"Ordered\n";
 else
 cout<<"Unordered\n";
 }
 return 0;
}

11947 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11947

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

bool Bisiesto(int years){return years % 4 == 0 && !(years % 100 == 0 && years % 400 != 0);}
int dayss (int m, int y)
{
 if (m == 11 || m == 4 || m == 6 || m == 9) return 30;
 if (m == 2) return 28 + Bisiesto (y);
 return 31;
}
int main () {
 int t, i=1, months, day, years;
 cin>>t;
 while(t--)
 {
 scanf("%2d%2d%4d", &months , &day, &years);

 for (int j = 0; j < 40; ++j) {
 int c = dayss(months, years);
 day = (day + 6) % c + 1;
 if (day < 8) {
 months = months % 12 + 1;
 if (months == 1) ++years;
 }
 }

 printf ("%d %02d/%02d/%04d ", i++, months, day, years % 10000);;

 if ((day>=21 && months==1) || (day<=19 && months==2)) printf("aquarius\n");
 if ((day>=20 && months==2) || (day<=20 && months==3)) printf( "pisces\n");
 if ((day>=21 && months==3) || (day<=20 && months==4)) printf( "aries\n");
 if ((day>=21 && months==4) || (day<=21 && months==5)) printf( "taurus\n");
 if ((day>=22 && months==5) || (day<=21 && months==6)) printf( "gemini\n");
 if ((day>=22 && months==6) || (day<=22 && months==7)) printf( "cancer\n");
 if ((day>=23 && months==7) || (day<=21 && months==8)) printf( "leo\n");
 if ((day>=22 && months==8) || (day<=23 && months==9)) printf( "virgo\n");
 if ((day>=24 && months==9) || (day<=23 && months==10)) printf( "libra\n");
 if ((day>=24 && months==10) || (day<=22 && months==11)) printf( "scorpio\n");
 if ((day>=23 && months==11) || (day<=22 && months==12)) printf( "sagittarius\n");
 if ((day>=23 && months==12) || (day<=20 && months==1)) printf( "capricorn\n");
 }
}

11953 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11953

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int sx[]={1,-1,0,0}; //4 directions
int sy[]={0,0,1,-1};

const int VAL = 105;
bool visited[VAL][VAL];
char arr[VAL][VAL];
int c,r;
void dfs(int a,int b)
{
 visited[a][b]=true;
 for(int i=0;i<4;i++){
 int I=a+sx[i];
 int J=b+sy[i];
 if(I>=0 && I<r && J>=0 && J<c && !visited[I][J]&& arr[I][J]!='.'){
 visited[I][J]=true;
 dfs(I,J);
 }
 }
}
int main()
{
 int aux,ca=1;
 cin>>aux;
 while(aux--)
 {
 scanf("%d",&r);
 c=r;
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) cin>>arr[i][j];
 memset(visited,false,sizeof(visited));
 int cont = 0;
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++)
 if(arr[i][j]=='x' && !visited[i][j]) { dfs(i,j); cont++;}

 printf("Case %d: %d\n",ca++,cont);
 }
 return 0;
}

11956 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11956

#include <bits/stdc++.h>
using namespace std;
int main() {
 int t, cases = 0;
 char cmd[100005];
 cin>>t;
 getchar();
 while(t--) {
 gets(cmd);
 unsigned char mem[100] = {};
 int idx = 0, i;
 for(i = 0; cmd[i]; i++) {
 switch(cmd[i]) {
 case '>':idx++;break;
 case '<':idx--;break;
 case '+':mem[idx]++;break;
 case '-':mem[idx]--;break;
 }
 if(idx >= 100) idx = 0;
 if(idx < 0) idx = 99;
 }
 printf("Case %d:", ++cases);
 for(i = 0; i < 100; i++)
 printf(" %02X", mem[i]);
 puts("");
 }
 return 0;
}

11957 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11957

#include <bits/stdc++.h>
#define MOD 1000007
using namespace std;

int n;
int memo[110][110];
bool visited[110][110];
char arr[110][110];

//x altura y fila
int DP(int x, int y)
{
 if(y>=n || y<0 || x<0 || arr[x][y]=='B') return 0;
 if(x==0 && arr[x][y]!='B') return 1;
 int &best = memo[x][y];
 if(visited[x][y]) return best;
 visited[x][y]=true;
 int cur,cur2;
 if(arr[x-1][y+1]=='B') cur = DP(x-2,y+2);
 else cur=DP(x-1,y+1);
 if(arr[x-1][y-1]=='B') cur2 = DP(x-2,y-2);
 else cur2=DP(x-1,y-1);
 return best = (cur%MOD + cur2%MOD)%MOD;
}
int main()
{
 int ca=1;
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 scanf("%d",&n);
 int x,y;
 memset(memo,0,sizeof(memo));
 memset(visited,false,sizeof(visited));
 memset(arr,' ',sizeof(arr));
 for(int i=0; i<n;i++)
 for(int j=0; j<n;j++)
 {
 cin>>arr[i][j];
 if(arr[i][j]=='W') {x=i; y=j;}
 }
 printf("Case %d: %d\n",ca++,DP(x,y)%MOD);
 }
 return 0;
}

11958 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11958

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main()
{
 int cases,count=1;
 cin>>cases;
 while(cases--)
 {
 int bus,h,m,h1,m1,time,res = INF;
 char point;
 cin>>bus;
 cin>>h>>point>>m;
 while(bus--)
 {
 cin>>h1>>point>>m1>>time;
 if(h1<h || (h1==h && m1<m)) h1+=24;
 res=min(res,((h1*60+m1)-(h*60+m)+time));
 }
 cout<<"Case "<<count<<": "<<res<<endl;
 count++;
 }
 return 0;
}

11984 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11984

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main(){
 int cases,c=1; cin>>cases;
 while(cases--)
 {
 double C,d; cin>>C>>d;
 C = C + 5.0 / 9.0 * d;
 printf("Case %d: %.2lf\n",c++,C);
 }
 return 0;
}

11991 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11991

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {

 int n,m;
 while (scanf("%d%d", &n,&m)==2) {
 int a,b,aux;
 map<pair<int,int>,int> M;
 map<int,int> Ma;
 for(int i=0; i<n;i++)
 {
 cin>>aux; Ma[aux]++; M[make_pair(aux,Ma[aux])]=i+1;
 }
 for(int i=0; i<m;i++)
 {
 cin>>a>>b; cout<<M[make_pair(b,a)]<<'\n';
 }
 }
 return 0;
}

11995 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 11995

#include <bits/stdc++.h>
using namespace std;

int main() {
 //freopen("C:/Users/Isaac/Desktop/in.txt","r",stdin);
 //freopen("C:/Users/Isaac/Desktop/out.txt","w",stdout);
 int n, op, x;
 while (scanf("%d", &n) ==1) {
 queue<int> q;
 stack<int> s;
 priority_queue<int> pq;
 bool isS = true, isQ = true, isPQ = true;

 for (int i = 0; i < n; i++) {
 scanf("%d %d", &op, &x);
 if(op==1){
 if (isS) s.push(x);
 if (isQ) q.push(x);
 if (isPQ) pq.push(x);
 }
 else{
 if (isS) if (s.empty() || s.top() != x) isS = false;
 else s.pop();
 if (isQ) if (q.empty() || q.front() != x) isQ = false;
 else q.pop();

 if (isPQ) if (pq.empty() || pq.top() != x) isPQ = false;
 else pq.pop();
 }
 }
 if (isS == true && isQ == false && isPQ == false) cout << "stack" << endl;
 else if (isS == false && isQ == true && isPQ == false) cout << "queue" << endl;
 else if (isS == false && isQ == false && isPQ == true) cout << "priority queue" << endl;
 else if (isS == false && isQ == false && isPQ == false)cout << "impossible" << endl;
 else cout << "not sure" << endl;
 }
 return 0;
}

120 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 120

#include <bits/stdc++.h>
using namespace std;

int main() {
 int n, k;
 while (scanf("%d%d",&n,&k)==2 && (n != 0 || k != 0))
 cout << (n*n*n + n) / 2 + (k-1) * n << '\n';

 return 0;
}

12015 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12015

#include <bits/stdc++.h>
using namespace std;
struct Web{
 string url;
 int rel;
};
int main()
{
 int T,count=1;
 cin >> T;
 while(T--)
 {
 Web pages[100];
 int mxRel = -1;
 for(int i = 0; i < 10; i++){
 cin >> pages[i].url >> pages[i].rel;
 if(pages[i].rel > mxRel)mxRel = pages[i].rel;
 }
 cout << "Case #"<< count++ << ":" << endl;
 for(int i = 0; i < 10; i++)if(pages[i].rel == mxRel)cout << pages[i].url << endl;
 }
 return 0;
}

12019 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12019

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int Month[13][32], i, j;
 int day = 6, Day[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; //last day is 6 (Saturday)
 for(i = 12; i >= 1; i--) {
 for(j = Day[i]; j >= 1; j--) {
 Month[i][j] = day;
 day--;
 if(day < 1) day = 7;
 }
 }
 char s[8][10] = {"", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
 int T;
 cin>>T;
 while(T--) {
 scanf("%d %d", &i, &j);
 printf("%s\n", s[Month[i][j]]);
 }
 return 0;
}

1206 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1206

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
#define mp(_x,_y) make_pair((_x),(_y))
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}

};

double dist(point p1, point p2) {
 return hypot(p1.x - p2.x, p1.y - p2.y); }

double cross(point o, point a, point b) {
 return (a.x-o.x)*(b.y-o.y) - (a.y-o.y)*(b.x-o.x);
}
bool cmp(point a, point b) {
 if(a.y != b.y)
 return a.y <b.y;
 return a.x < b.x;
}
int CH(point p[], int n, point ch[]) {
 sort(p, p+n, cmp);
 int i, m = 0, t;
 for(i = 0; i < n; i++) {
 while(m >= 2 && cross(ch[m-2], ch[m-1], p[i]) <= 0)
 m--;
 ch[m++] = p[i];
 }
 for(i = n-1, t = m+1; i >= 0; i--) {
 while(m >= t && cross(ch[m-2], ch[m-1], p[i]) <= 0)
 m--;
 ch[m++] = p[i];
 }
 return m-1;
}

int main()
{
 string line;
 double x, y;
 char cha;
 while(getline(cin, line)) {
 point p[1005], ch[1005];
 int j =0;
 stringstream sin(line);
 while(sin >> cha >> x >> cha >> y >> cha)
 {
 p[j]=point(x,y); j++;
 }
 int n1 = CH(p,j,ch);
 int flag = 1;
 for(int i=0; i<=n1;i++)
 if(flag==1) { printf("(%g,%g)",ch[i].x,ch[i].y); flag++;}
 else printf(" (%g,%g)",ch[i].x,ch[i].y);
 printf("\n");
 }
 return 0;
}

12086 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12086

#include <bits/stdc++.h>
using namespace std;

void buildTree(int *tree,int *a,int index,int s,int e)
{
 //base case
 if(s>e)
 return;
 //reached leaf node
 if(s==e)
 {
 tree[index]=a[s];
 return ;
 }
 //now build the segment tree in bottom up manner
 int m = (s+e)/2;
 buildTree(tree,a,2*index,s,m);
 buildTree(tree,a,2*index+1,m+1,e);
 tree[index]= tree[2*index]+tree[2*index+1];
 return;
}

//function to query the segment tree for RSQ
int query(int *tree,int index,int s,int e,int qs,int qe)
{
 //base case: if query range is outside the node range
 if(qs>e || s>qe)
 return 0;
 //complete overlap
 if(s>=qs && e<=qe)
 return tree[index];
 //now partial overlap case is executed
 int m = (s+e)/2;
 int left_ans = query(tree,2*index,s,m,qs,qe);
 int right_ans = query(tree,2*index+1,m+1,e,qs,qe);
 return left_ans+right_ans;
}

//function to update a value at position to "pos"
void updateNode(int *tree,int index,int s,int e,int pos,int val)
{
 if(pos<s || pos>e)
 return ;
 if(s==e)
 {
 tree[index] = val;
 return ;
 }
 int m = (s+e)/2;
 updateNode(tree,2*index,s,m,pos,val);
 updateNode(tree,2*index+1,m+1,e,pos,val);
 tree[index] = tree[2*index]+tree[2*index+1];
 return;
}

int main()
{
 int n,ncase=1,flag=1;
 while(scanf("%d",&n)==1 && n!=0)
 {
 if(flag==0)printf("\n");
 int a[n];
 for(int i=0; i<n; i++) scanf("%d",&a[i]);
 int *tree = new int[4*n+1]; //array to store the segment tree
 int index = 1; //index of 1st node
 int s =0,e=n-1;
 buildTree(tree,a,index,s,e); //now tree has been built
 string n;
 printf("Case %d:\n",ncase++);
 while(cin>>n && n!="END")
 {
 int j,k; scanf("%d %d",&j,&k);
 if(n=="S") updateNode(tree,index,s,e,j-1,k);
 else printf("%d\n",query(tree,index,s,e,j-1,k-1));
 }
 flag=0;
 }
 return 0;
}

121 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 121

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main()
{
 long long int ch,en,to,res;
 while(scanf("%lld%lld%lld",&ch,&en,&to)==3&&ch+en+to)
 {
 res=to;
 if(ch<=en && to>=ch) printf("RUINA\n");
 else if(en==0) printf("%lld %lld\n",res,to);
 else
 {
 while(to>=ch)
 {
 int var = to/ch;
 res+=(var*en);
 to=(var*en+to%ch);
 }
 printf("%lld %lld\n",res,to);
 }
 }
 return 0;
}

121 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 121

#include <bits/stdc++.h>
using namespace std;

/*
Get triangle with the center points of circles (1 1 1), divide it by 2 (0.5 0.5 0.5),
then get the length of the triangles height (0.5 0.25 x) solve x, multiply by 2 and that is the "extra height"
*/
int skew(double x, double y){
 double diff = 1-0.13397459621556135323627682924706;
 if (y<1) return 0;
 int a = floor(x), b = floor((y-1)/diff)+1;
 if (x>=a+0.5) return a*b;
 if (b%2==0) return a*b/2+(a-1)*b/2;
 return a*(b+1)/2+(a-1)*(b-1)/2;
}

int main()
{
 double x,x1;
 while(scanf("%lf%lf",&x,&x1)==2)
 {
 int crew = floor(x)*floor(x1);
 int skewres = skew(x,x1); skewres=max(skewres,skew(x1,x));
 if(skewres>crew) printf("%d skew\n",skewres);
 else printf("%d grid\n",crew);
 }
}

12136 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12136

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int cases,count=1;
 cin>>cases;
 while(cases--)
 {
 map<int,int> M;
 int h1,m1,h2,m2,total,total1,flag=0;
 scanf("%d:%d %d:%d",&h1,&m1,&h2,&m2);
 total=(h1*100+m1); total1=(h2*100+m2);
 int h3,m3,h4,m4,total2,total3;
 scanf("%d:%d %d:%d",&h3,&m3,&h4,&m4);
 total2=(h3*100+m3); total3=(h4*100+m4);
 for(int i=total;i<=total1;i++) M[i]++;
 for(int i=total2;i<=total3;i++) if(M[i]>0) {printf("Case %d: Mrs Meeting\n",count++); flag=1; break;}
 if(flag==0) printf("Case %d: Hits Meeting\n",count++);
 }
 return 0;
}

12149 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12149

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 int n;
 while(scanf("%d",&n)==1 && n!=0) {
 printf("%d\n",n*(n+1)*(2*n+1)/6);
 }
 return 0;
}

12157 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12157

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int T,count=1;
 cin>>T;
 while(T--)
 {
 int aux,aux1; cin>>aux;
 int mile=0;
 int juice=0;
 while(aux--)
 {
 cin>>aux1; mile+= ((aux1/30)+1)*10; juice+=((aux1/60)+1)*15;
 }
 if(mile<juice) cout<<"Case "<<count++<<": Mile "<<mile<<endl;
 else if(mile==juice) cout<<"Case "<<count++<<": Mile Juice "<<juice<<endl;
 else cout<<"Case "<<count++<<": Juice "<<juice<<endl;
 }
 return 0;
}

122 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 122

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int n,res=0,KM,res1=0,CONT=0,m=0,cur=0;
 cin>>n;
 bool prim=false;
 while(n!=-1)
 {
 while(m!=-1)
 {
 cin>>m;
 if(m==n)
 {
 res++;
 if(res1<res)
 {
 res1=res;
 if(!prim)
 {
 KM=cur;
 prim=true;
 }
 }
 n=m;
 CONT++;
 }
 else
 {
 prim=false;
 res=0;
 n=m;
 CONT++;
 cur=CONT;
 }
 }
 if(res1!=0)
 cout<<KM<<" "<<res1<<endl;
 else
 cout<<"HOY NO COMEN"<<endl;

 res=0; CONT=0; m=0; res=0; prim=false; res1=0; KM=0; cur=0;
 cin>>n;
 }
 return 0;
}

1223 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1223

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

typedef pair<int, int> ii;

#define MAX_N 100010 // second approach: O(n log n)
char T[MAX_N]; // the input string, up to 100K characters
int n; // the length of input string
int RA[MAX_N], tempRA[MAX_N]; // rank array and temporary rank array
int SA[MAX_N], tempSA[MAX_N]; // suffix array and temporary suffix array
int c[MAX_N]; // for counting/radix sort

char P[MAX_N]; // the pattern string (for string matching)
int m; // the length of pattern string

int Phi[MAX_N]; // for computing longest common prefix
int PLCP[MAX_N];
int LCP[MAX_N]; // LCP[i] stores the LCP between previous suffix T+SA[i-1]
 // and current suffix T+SA[i]
bool cmp(int a, int b) { return strcmp(T + a, T + b) < 0; } // compare

void countingSort(int k) { // O(n)
 int i, sum, maxi = max(300, n); // up to 255 ASCII chars or length of n
 memset(c, 0, sizeof c); // clear frequency table
 for (i = 0; i < n; i++) // count the frequency of each integer rank
 c[i + k < n ? RA[i + k] : 0]++;
 for (i = sum = 0; i < maxi; i++) {
 int t = c[i]; c[i] = sum; sum += t;
 }
 for (i = 0; i < n; i++) // shuffle the suffix array if necessary
 tempSA[c[SA[i]+k < n ? RA[SA[i]+k] : 0]++] = SA[i];
 for (i = 0; i < n; i++) // update the suffix array SA
 SA[i] = tempSA[i];
}

void constructSA() { // this version can go up to 100000 characters
 int i, k, r;
 for (i = 0; i < n; i++) RA[i] = T[i]; // initial rankings
 for (i = 0; i < n; i++) SA[i] = i; // initial SA: {0, 1, 2, ..., n-1}
 for (k = 1; k < n; k <<= 1) { // repeat sorting process log n times
 countingSort(k); // actually radix sort: sort based on the second item
 countingSort(0); // then (stable) sort based on the first item
 tempRA[SA[0]] = r = 0; // re-ranking; start from rank r = 0
 for (i = 1; i < n; i++) // compare adjacent suffixes
 tempRA[SA[i]] = // if same pair => same rank r; otherwise, increase r
 (RA[SA[i]] == RA[SA[i-1]] && RA[SA[i]+k] == RA[SA[i-1]+k]) ? r : ++r;
 for (i = 0; i < n; i++) // update the rank array RA
 RA[i] = tempRA[i];
 if (RA[SA[n-1]] == n-1) break; // nice optimization trick
} }

void computeLCP() {
 int i, L;
 Phi[SA[0]] = -1; // default value
 for (i = 1; i < n; i++) // compute Phi in O(n)
 Phi[SA[i]] = SA[i-1]; // remember which suffix is behind this suffix
 for (i = L = 0; i < n; i++) { // compute Permuted LCP in O(n)
 if (Phi[i] == -1) { PLCP[i] = 0; continue; } // special case
 while (T[i + L] == T[Phi[i] + L]) L++; // L increased max n times
 PLCP[i] = L;
 L = max(L-1, 0); // L decreased max n times
 }
 for (i = 0; i < n; i++) // compute LCP in O(n)
 LCP[i] = PLCP[SA[i]]; // put the permuted LCP to the correct position
}
ii LRS() { // returns a pair (the LRS length and its index)
 int i, idx = 0, maxLCP = -1;
 for (i = 1; i < n; i++) // O(n), start from i = 1
 if (LCP[i] > maxLCP)
 maxLCP = LCP[i], idx = i;
 return ii(maxLCP, idx);
}

int owner(int idx) { return (idx < n-m-1) ? 1 : 2; }

int main() {
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 scanf("%s",T);
 n = (int)strlen(T);
 T[n++] = '$';
 constructSA(); // O(n log n)
 computeLCP(); // O(n)
 int ans = 0;
 for (int i = 0; i < n; i++) ans=max(LCP[i],ans);
 printf("%d\n", ans);
 memset(T,'\0',sizeof(T));
 }
 return 0;
}

12250 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12250

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases = 1;
 string a;
 while(getline(cin,a)&& a!="#")
 {
 string language;
 if(a=="HELLO")
 language="ENGLISH";
 else if(a=="HOLA")
 language="SPANISH";
 else if(a=="HALLO")
 language="GERMAN";
 else if(a=="BONJOUR")
 language="FRENCH";
 else if(a=="CIAO")
 language="ITALIAN";
 else if(a=="ZDRAVSTVUJTE")
 language="RUSSIAN";
 else
 language="UNKNOWN";
 cout<<"Case "<<cases<<": "<<language<<endl;
 cases++;
 }

return 0;
}

12279 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12279

#include <bits/stdc++.h>
using namespace std;
int main() {
 int t, n,number=1;
 while(cin>>t && t!=0) {
 int res=0;
 for(int i=0; i<t;i++)
 {
 cin>>n;
 if(n!=0)
 res++;
 else
 res--;
 }
 cout<<"Case "<<number<<": "<<res<<endl;
 number++;
 }
 return 0;
}

12289 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12289

#include <bits/stdc++.h>
using namespace std;
int main() {
 int cases;
 string s;
 cin>>cases;
 while (cases--) {
 cin>>s;
 if (s.length() > 3)
 printf("3\n");
 else {
 if(s[0] == 'o' && s[1] == 'n' && s[2] == 'e') printf("1\n");
 else if(s[0] == 'o' && s[1] == 'n') printf("1\n");
 else if(s[0] == 'o' && s[2] == 'e') printf("1\n");
 else if(s[1] == 'n' && s[2] == 'e') printf("1\n");
 else if(s[0] == 't' && s[1] == 'w' && s[2] == 'o') printf("2\n");
 else if(s[0] == 't' && s[1] == 'w') printf("2\n");
 else if(s[0] == 't' && s[2] == 'o') printf("2\n");
 else if(s[1] == 'w' && s[2] == 'o') printf("2\n");
 }
 }
 return 0;
}

123 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 123

#include <bits/stdc++.h>

using namespace std;

int main() {
 string sol[3][3][6] = {
 {
 {"o", "as", "a", "amos", "ais", "an"},
 {"e", "aste", "o", "amos", "asteis", "aron"},
 {"are", "aras", "ara", "aremos", "areis", "aran"},
 },
 {
 {"o", "es", "e", "emos", "eis", "en"},
 {"i", "iste", "io", "imos", "isteis", "ieron"},
 {"ere", "eras", "era", "eremos", "ereis", "eran"},
 },
 {
 {"o", "es", "e", "imos", "is", "en"},
 {"i", "iste", "io", "imos", "isteis", "ieron"},
 {"ire", "iras", "ira", "iremos", "ireis", "iran"}
 }
 };

 string p[6] = {"yo", "tu", "el", "nosotros", "vosotros", "ellos"};
 string s, t;
 while (cin >> s >> t && t != "T") {
 int r,j;
 if (s[s.length()-2] == 'a') r = 0;
 else if (s[s.length()-2] == 'e') r = 1;
 else if (s[s.length()-2] == 'i') r = 2;
 if (t == "A") j = 0;
 else if (t == "P") j = 1;
 else if (t == "F") j = 2;
 for (int i = 0; i < 6; i++)
 printf("%s %s%s\n", p[i].c_str(), s.substr(0, s.length()-2).c_str(), sol[r][j][i].c_str());
 }

 return 0;
}

12356 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12356

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int a,b;
 int L1[100005],R1[100005];
 while(scanf("%d%d",&a,&b)==2 && (a!=0 || b!=0))
 {
 for(int i=0; i<=a;i++)
 {
 L1[i]= i-1;
 R1[i]= i+1;
 }
 int L,R;
 for(int i=0; i<b;i++)
 {
 cin>>L>>R;
 if(L1[L]<1) cout<<"* ";
 else cout<<L1[L]<<" ";
 if(R1[R]>a) cout<<"*\n";
 else cout<<R1[R]<<"\n";
 L1[R1[R]]=L1[L];
 R1[L1[L]]=R1[R];
 }
 cout<<"-\n";
 }
 return 0;
}

12372 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12372

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases = 1,a,b,c,number=1;
 cin>>cases;
 while(cases+1!=number)
 {
 cin>>a>>b>>c;
 if(a<=20 && b<=20 && c<=20)
 cout<<"Case "<< number <<": "<<"good\n";
 else
 cout<<"Case "<< number <<": "<<"bad\n";
 number++;
 }
return 0;
}

1237A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1237A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int n,m,add=0; scanf("%d",&n);
 for(int i=0; i<n;i++){
 scanf("%d",&m);
 if(m==0) printf("0\n");
 else if(m%2!=0) {
 if(m<0) add++;
 if(m>0) add--;
 if(add==-2 || add==2 ) { printf("%d\n",m/2-(add/2)); add=0;}
 else printf("%d\n",m/2);

 }
 else printf("%d\n",m/2);
 }
 return 0;
}

1237B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1237B

#include <bits/stdc++.h>
using namespace std;

int main(){
 int n,aux,res=0,j=0; scanf("%d",&n);
 vector<int> V,V2;
 for(int i=0; i<n;i++){
 scanf("%d",&aux);
 V.push_back(aux);
 }
 for(int i=0; i<n;i++){
 scanf("%d",&aux);
 V2.push_back(aux);
 }
 bool visited[n+1];
 memset(visited,false,sizeof(visited));
 for(int i=0; i<n && j<n;i++){
 if(visited[V[i]]) continue;
 while(V[i]!=V2[j]) {
 visited[V2[j]]=true;
 //cout<<V2[j]<<endl;
 j++; res++;
 }
 j++;
 visited[V[i]]=true;
 }
 printf("%d\n",res);
 return 0;
}

1237C1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1237C1

#include <bits/stdc++.h>
using namespace std;

struct state{
 int x,y,z;
};

bool inside(state a, state b, state c){
 //min(xa,xb)<=xc≤max(xa,xb), min(ya,yb)<=yc≤max(ya,yb), and min(za,zb)<=zc<=max(za,zb)
 int minx = min(a.x,b.x);
 int maxx = max(a.x,b.x);
 int miny = min(a.y,b.y);
 int maxy = max(a.y,b.y);
 int minz = min(a.z,b.z);
 int maxz = max(a.z,b.z);
 return ((minx<=c.x && c.x<=maxx) && (miny<=c.y && c.y<=maxy) && (minz<=c.z && c.z<=maxz));
}
int main(){
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/out.txt","w",stdout);
 int n; scanf("%d",&n);
 vector<state> V;
 for(int i=0; i<n;i++){
 int x,y,z; scanf("%d %d %d",&x,&y,&z); V.push_back(state{x,y,z});
 }
 bool visited[n];
 memset(visited,false,sizeof(visited));
 for(int i=0; i<n; i++){
 if(visited[i]) continue;
 for(int j=0; j<n; j++){
 if(visited[j] || i==j) continue;
 bool flag=false;
 for(int z=0; z<n && flag==false;z++){
 if(visited[z] || z==j || z==i) continue;
 if(inside(V[i],V[j],V[z])) flag=true;
 }
 //cout<<flag<<endl;
 if(!flag) {
 visited[i]=true; visited[j]=true; printf("%d %d\n",i+1,j+1);
 break;
 }
 }
 }

 return 0;
}

124 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 124

import java.util.*;
public class Aer124
{

 public static int acarreos(String s1, String s2)
 {
 int cuenta=0; //cuenta de acarreos
 int acarreo=0; //acarreo actual
 int i=0; //posicin por la izquierda
 boolean terminado=false; //bandera para controlar el bucle
 while (!terminado)
 {
 //Coger el siguiente dgito de cada nmero por la izquierda.
 //Si he superado la longitud, el dgito en el que estoy es 0
 int i1=i<s1.length()?s1.charAt(s1.length()-i-1)-'0':0;
 int i2=i<s2.length()?s2.charAt(s2.length()-i-1)-'0':0;
 int suma=acarreo+i1+i2; //sumamos ambos mas el posible acarreo anterior
 acarreo=suma>=10?1:0; //Hay acarreo si la suma es es > 10
 cuenta+=acarreo;
 i++; //pasar al siguiente por la izquierda
 //terminamos si hemos sobrepasado la longitud de alguna de las dos cifras y no hay acarreos
 terminado=!(acarreo>0) && (i>=s1.length() || i>s2.length());
 }
 return cuenta;
 }

 public static void main(String[] args)
 {
 Scanner in=new Scanner(System.in);
 boolean terminar=false;
 do
 {
 String s1=in.next(); //lee primer nmero como cadena
 String s2=in.next(); //lee segundo como cadena
 in.nextLine(); //cambia de lna (no es necesario)
 terminar=s1.equals("0")&&s2.equals("0");
 if (!terminar)
 {
 System.out.println(acarreos(s2,s1));
 }
 } while (!terminar);

 }
}

12403 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12403

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases = 1,number,sum=0;
 cin>>cases;
 string a;
 while(cases--)
 {
 cin>>a;
 if(a=="report")
 cout<<sum<<endl;
 else
 {
 cin>>number;
 sum+=number;
 }
 }
return 0;
}

12439 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12439

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string m,m1;
 char aux;
 int cases,y,y1,d,d1,count=1;
 cin>>cases;
 while(cases--)
 {
 int res=0;
 cin>>m>>d>>aux>>y;
 cin>>m1>>d1>>aux>>y1;
 if(!(m=="January"||m=="February")) y++;
 if(m1=="January"||(m1=="February"&&d1<29)) y1--;
 res = y1/4 - (y-1)/4;
 res -= y1/100 - (y-1)/100;
 res += y1/400 - (y-1)/400;
 cout<<"Case "<<count<<": "<<res<<endl;
 count++;
 }
 return 0;
}

12467 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12467

#include <bits/stdc++.h>
using namespace std;

vector<int> Z(string &s) {
 int n = s.size();
 int L, R;
 L = R = 0;
 vector<int> Z(n, 0);
 for (int i = 1; i < n; ++i){
 if (i < R) Z[i] = min(Z[i-L], R-i);
 else Z[i] = 0;
 while (Z[i] + i < n and s[Z[i]] == s[i+Z[i]]) ++Z[i];
 if (i+Z[i] > R){
 L = i;
 R = i + Z[i];
 }
 }
 return Z;
}

int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 string s;
 cin>>s;
 int n = s.length();
 for(int i=n-1; i>=0; i--) s+=s[i];
 vector<int> R = Z(s);
 int sol = 0;
 int index,index2;
 for(unsigned int i=n;i<s.length();i++){
 if(R[i]>sol) { sol=R[i]; index=i; index2=R[i]+i-1;}
 }
 for(int i=index2; i>=index;i--) cout<<s[i];
 cout<<'\n';

 }
 return 0;
}

12468 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12468

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int num1,num2,max1,max2,resul;
 while(cin>>num1>>num2,(num1!=-1 || num2!=-1))
 {
 if(num2>=num1)
 {
 max1=num2-num1;
 max2=100-num2+num1;
 }
 else
 {
 max1=num1-num2;
 max2=100-num1+num2;
 }
 resul=min(max1,max2);
 cout<<resul<<"\n";
 }
 return 0;
}

12478 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12478

#include <bits/stdc++.h>
using namespace std;
int main()
{
 cout<<"KABIR\n";
 return 0;
}

1247A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1247A

#include <bits/stdc++.h>
using namespace std;

int main(){
 long long int da,db;
 scanf("%lld %lld",&da,&db);
 if(db>=da+2 || (da>db && (da!=9 || db!=1)) || (db==0 && da==0) ) printf("-1\n");
 else if(db!=da) {
 if(!(da!=9 && db!=1)) printf("9 10\n");
 else printf("%lld %lld\n",da,db);
 }
 else printf("%lld %lld\n",db*10,db*10+1);
 return 0;
}

1247B1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1247B1


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int n,k,d; scanf("%d %d %d",&n,&k,&d);
 int arr[n];
 set<int> S;
 map<int,int> M;
 for(int i=0; i<n;i++) {
 scanf("%d",&arr[i]);
 if(i<d) {
 S.insert(arr[i]);
 M[arr[i]]++;
 }
 }
 int res = S.size();
 for(int i=0; i<n;i++){
 if(M[arr[i]]==1) S.erase(arr[i]);
 M[arr[i]]--;
 if(d+i==n) break;
 S.insert(arr[d+i]);
 M[arr[d+i]]++;
 res = min((int)S.size(),res);
 }
 printf("%d\n",res);
 }
 return 0;
}

1247B2 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1247B2


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int n,k,d; scanf("%d %d %d",&n,&k,&d);
 int arr[n];
 set<int> S;
 map<int,int> M;
 for(int i=0; i<n;i++) {
 scanf("%d",&arr[i]);
 if(i<d) {
 S.insert(arr[i]);
 M[arr[i]]++;
 }
 }
 int res = S.size();
 for(int i=0; i<n;i++){
 if(M[arr[i]]==1) S.erase(arr[i]);
 M[arr[i]]--;
 if(d+i==n) break;
 S.insert(arr[d+i]);
 M[arr[d+i]]++;
 res = min((int)S.size(),res);
 }
 printf("%d\n",res);
 }
 return 0;
}

1248A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1248A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int q; scanf("%d",&q);
 while(q--){
 long long int n; scanf("%lld",&n);
 long long int aux,par,impar; par=impar=0;
 for(long long int i=0; i<n;i++){
 scanf("%lld",&aux);
 if(aux%2==0) par++;
 else impar++;
 }
 long long int m,res=0; scanf("%lld",&m);
 for(long long int i=0; i<m;i++){
 long long int aux; scanf("%lld",&aux);
 if(aux%2==0) res+=par;
 else if(aux%2!=0) res+=impar;
 }
 printf("%lld\n",res);
 }
 return 0;
}

1249A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int q; scanf("%d",&q);
 while(q--){
 int n; scanf("%d",&n);
 vector<int> V2;
 for(int j=0; j<n;j++){
 int num;
 scanf("%d",&num); V2.push_back(num);
 }
 bool flag=false;
 for(int i=0; i<n && !flag;i++)
 for(int j=i+1; j<n && !flag;j++){
 if(abs(V2[i]-V2[j])==1) flag=true;
 }
 if(!flag) printf("1\n");
 else printf("2\n");
 }
 return 0;
}

1249B1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249B1

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 100100;
const int INF = 0x3f3f3f3f;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
};

struct state{
 int node, dist;
 state(){}
 state(int a, int b){
 node = a; dist = b;
 }
 bool operator<(const state &other)const{ // sobrecarga de operadores para ordenar
 return other.dist < dist;
 }
};

vector<edge> graph[MAXN];
int dist[MAXN];

int a=1, b=3;
int N,E;

int dijkstra(int start, int end){
 dist[start] = 0;
 priority_queue<state> pq;
 pq.push(state(start, 0));
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(dist[cur.node] < cur.dist) continue;
 if(cur.node == end) return cur.dist;
 for(int i=0;i<graph[cur.node].size();i++){
 int dest = graph[cur.node][i].to;
 int wht = graph[cur.node][i].weight + cur.dist;
 if(dist[dest] <= wht) continue;
 dist[dest] = wht;
 pq.push(state(dest, wht));
 }
 }
 return -1;
}

int main(){
 int n,m; scanf("%d",&n);
 while(n--){
 scanf("%d",&m);
 N=E=m;
 memset(dist,0x3f,sizeof(dist));
 int arr[m+1];
 for(int i=1;i<=N;i++) graph[i].clear(); // limpia el grafo
 for(int i=1;i<=E;i++){
 int to; scanf("%d",&to); arr[i]=to;
 graph[i].push_back(edge(i,to,1));
 }
 for(int i=1; i<=m;i++) {
 memset(dist,0x3f,sizeof(dist));
 if(i==1) printf("%d",dijkstra(arr[i],i)+1);
 else printf(" %d",dijkstra(arr[i],i)+1);
 }
 printf("\n");
 for(int i=1;i<=N;i++) graph[i].clear();
 }
 return 0;
}

1249B2 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249B2

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 200100;
const int INF = 0x3f3f3f3f;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
};

struct state{
 int node, dist;
 state(){}
 state(int a, int b){
 node = a; dist = b;
 }
 bool operator<(const state &other)const{ // sobrecarga de operadores para ordenar
 return other.dist < dist;
 }
};

vector<edge> graph[MAXN];
int dist[MAXN];
int check[MAXN];
int index=0;

int N,E;

int dijkstra(int start, int end){
 dist[start] = 0;
 priority_queue<state> pq;
 pq.push(state(start, 0));
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(dist[cur.node] < cur.dist) continue;
 if(cur.node == end) return cur.dist;
 for(int i=0;i<graph[cur.node].size();i++){
 int dest = graph[cur.node][i].to;
 int wht = graph[cur.node][i].weight + cur.dist;
 if(dist[dest] <= wht) continue;
 dist[dest] = wht;
 check[dest]=index;
 check[cur.node]=index;
 pq.push(state(dest, wht));
 }
 }
 return -1;
}

int main(){
 int n,m; scanf("%d",&n);
 while(n--){
 scanf("%d",&m);
 N=E=m;
 memset(dist,0x3f,sizeof(dist));
 int arr[m+1];
 for(int i=1;i<=N;i++) graph[i].clear(); // limpia el grafo
 for(int i=1;i<=E;i++){
 int to; scanf("%d",&to); arr[i]=to;
 graph[i].push_back(edge(i,to,1));
 }
 memset(check,-1,sizeof(check));
 vector<int> V;
 index=-1;
 memset(dist,0x3f,sizeof(dist));
 for(int i=1; i<=m;i++) {
 //memset(dist,0x3f,sizeof(dist));
 int indexRes;
 if(check[i]==-1) { index++; V.push_back(dijkstra(arr[i],i)+1); indexRes=index; }
 else indexRes=check[i];
 if(i==1) printf("%d",V[indexRes]);
 else printf(" %d",V[indexRes]);
 }
 printf("\n");
 for(int i=1;i<=N;i++) graph[i].clear();
 }
 return 0;
}

1249C1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249C1

#include <bits/stdc++.h>
#define INF
using namespace std;

struct state{
 int curIndex;
 int sum;
};

int main(){
 set<int> S;
 queue<state> Q;
 for(int i=0; i<=9;i++) {state aux; aux.curIndex=i; aux.sum= pow(3,i); Q.push(aux); S.insert(pow(3,i)); }
 while(!Q.empty()){
 state q = Q.front(); Q.pop();
 S.insert(q.sum);
 state aux = q; aux.curIndex++;
 if(aux.curIndex<9) Q.push(aux);
 for(int i=q.curIndex+1; i<=9;i++){
 q.sum+=pow(3,i); q.curIndex=i;
 if(q.sum<20000) Q.push(q);
 else break;
 }
 }

 int q; scanf("%d",&q);
 while(q--){
 int n; scanf("%d",&n);
 for(auto s:S){
 if(s>=n) { printf("%d\n",s); break; }
 }
 }
}

125 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 125

#include <bits/stdc++.h>
using namespace std;

vector<pair<int,int>> V;
void divisor(int n,unsigned int m)
{
 for (int i=1; i<=sqrt(n); i++)
 {
 if (n%i == 0)
 {
 if (n/i == i) { string na = to_string(i); if(m==na.length()) V.push_back(make_pair(i,i)); }
 else { string na = to_string(i); int d = n/i; string n1 = to_string(d); if(m==na.length() && m==n1.length()) V.push_back(make_pair(i,d)); }
 }
 }
}


int main()
{
 int cases; cin>>cases;
 while(cases--)
 {
 string n; cin>>n;
 if(n.length()%2==0)
 {
 int m = n.length()/2;
 map<char,int> M;
 map<char,int> Maux;
 for(unsigned int i=0; i<n.length();i++) M[n[i]]++;
 divisor(stoi(n),m);
 int flag=2;
 for(unsigned int i=0; i<V.size()&&flag!=0;i++)
 {
 flag=2;
 Maux=M;
 string resu = to_string(V[i].first);
 string resu2 = to_string(V[i].second);
 string total = resu+resu2;
 for(unsigned int i=0; i<total.length();i++) Maux[total[i]]--;
 for(auto m:Maux) if(m.second!=0) flag=1;
 if(resu[resu.length()-1]=='0' && resu2[resu2.length()-1]=='0') continue;
 if(flag==2) flag=0;
 }
 if(flag!=0) cout<<"NO\n";
 else cout<<"SI\n";
 }
 else cout<<"NO\n";
 V.clear();
 }
 return 0;
}

12502 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12502

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {

 int T;
 scanf("%d", &T);
 while (T--) {
 int a, b, mon; cin>>a>>b>>mon;
 double ans=mon,field = a + b;
 if (a <= field / 3) ans = 0;
 else if (a < 2 * field / 3) ans = ((double) mon * ((double) a - field / 3.0)) / (field / 3.0);
 printf("%.0lf\n", ans);
 }
 return 0;
}

12503 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12503

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases,count;
 cin>>cases;
 while(cases--)
 {
 int i=0,sum=0,b;
 string a;
 cin>>count;
 int arr[count];
 while(count--)
 {
 cin>>a;
 if(a=="LEFT")
 {
 arr[i]=-1;
 sum--;
 }
 else if(a=="RIGHT")
 {
 arr[i]=1;
 sum++;
 }
 else
 {
 cin>>a>>b;
 arr[i]=arr[b-1];
 sum+=arr[b-1];
 }
 i++;
 }
 cout<<sum<<endl;
 }
 return 0;
}

1251A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1251A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 string line; cin>>line;
 set<char> S;
 for(unsigned int i=0;i<line.length();i++){
 if(i+1==line.length()) S.insert(line[i]);
 for(unsigned int j=i+1; j<line.length();j++){
 if(line[j]!=line[i] && (j-i)%2!=0) {
 S.insert(line[i]); i=j-1; break;
 }
 else if(line[j]!=line[i]) { i=j-1; break; }
 else if(j+1==line.length()) { if((j-i+1)%2!=0) S.insert(line[i]); i=j+1;}
 }
 }
 for(auto s:S) printf("%c",s);
 printf("\n");
 }
 return 0;
}

12531 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12531

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main ()
{
 int a ;
 while (scanf ("%d",&a) == 1)
 cout<<((a%6==0) ? "Y\n" : "N\n" ) ;
 return 0 ;
}

12532 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12532

#include <bits/stdc++.h>
using namespace std;

void buildTree(int *tree,int *a,int index,int s,int e)
{
 //base case
 if(s>e)
 return;
 //reached leaf node
 if(s==e)
 {
 tree[index]=a[s];
 return ;
 }
 //now build the segment tree in bottom up manner
 int m = (s+e)/2;
 buildTree(tree,a,2*index,s,m);
 buildTree(tree,a,2*index+1,m+1,e);
 tree[index]= tree[2*index]*tree[2*index+1];
 return;
}

//function to query the segment tree for RSQ
int query(int *tree,int index,int s,int e,int qs,int qe)
{
 //base case: if query range is outside the node range
 if(qs>e || s>qe)
 return 1;
 //complete overlap
 if(s>=qs && e<=qe)
 return tree[index];
 //now partial overlap case is executed
 int m = (s+e)/2;
 int left_ans = query(tree,2*index,s,m,qs,qe);
 int right_ans = query(tree,2*index+1,m+1,e,qs,qe);
 return left_ans*right_ans;
}

//function to update a value at position to "pos"
void updateNode(int *tree,int index,int s,int e,int pos,int val)
{
 if(pos<s || pos>e)
 return ;
 if(s==e)
 {
 tree[index] = val;
 return ;
 }
 int m = (s+e)/2;
 updateNode(tree,2*index,s,m,pos,val);
 updateNode(tree,2*index+1,m+1,e,pos,val);
 tree[index] = tree[2*index]*tree[2*index+1];
 return;
}

int main()
{
 int n,c;
 while(scanf("%d %d",&n,&c)==2)
 {
 int a[n];
 for(int i=0; i<n; i++) { scanf("%d",&a[i]); if(a[i]<0) a[i]=-1; if(a[i]>0) a[i]=1;}
 int *tree = new int[4*n+1]; //array to store the segment tree
 int index = 1; //index of 1st node
 int s =0,e=n-1;
 buildTree(tree,a,index,s,e); //now tree has been built
 for(int i=0; i<c;i++)
 {
 char ca; cin.ignore();
 int j,k; scanf("%c %d %d",&ca,&j,&k);
 if(ca=='C') {if(k<0) k=-1; if(k>0) k=1; updateNode(tree,index,s,e,j-1,k); }
 else
 {
 int sol = query(tree,index,s,e,j-1,k-1);
 if(sol==0) printf("0");
 else if(sol<0) printf("-");
 else printf("+");
 }
 }
 printf("\n");
 }
 return 0;
}

12554 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12554

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string a[]={"Happy", "birthday", "to", "you", "Happy", "birthday", "to", "you", "Happy", "birthday", "to", "Rujia", "Happy", "birthday", "to", "you"};
 int cases,i=0,j=0,flag=0;
 cin>>cases;
 vector<string> c;
 while(cases--)
 {
 string p;
 cin>>p;
 c.push_back(p);
 }
 int b = c.size();
 while(1) {
 cout<<c[i%b]<<": "<<a[j%16]<<endl;
 if(i%b == b-1) flag = 1;
 if(j%16 == 15 && flag) break;
 i++, j++;
 }
 return 0;
}

12577 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12577

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases = 1;
 string a;
 while(getline(cin,a)&& a!="*")
 {
 string text;
 if(a=="Hajj")
 text="Akbar";
 else if(a=="Umrah")
 text="Asghar";

 cout<<"Case "<<cases<<": Hajj-e-"<<text<<endl;
 cases++;
 }
return 0;
}

12578 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12578

#include <bits/stdc++.h>
#define PI acos(-1.0)
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 double W,H,R; scanf("%lf",&W);
 R=W/5; H=(W*6)/10;
 double AR = W*H;
 double AC = PI * R * R;
 printf("%.2lf %.2lf\n", AC, AR-AC);
 }
 return 0;
}

126 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 126

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,m;
 while(scanf("%d%d",&n,&m)==2 && (n>=0 || m>=0))
 {
 if(n<=m || n==1) printf("YES\n");
 else printf("NO\n");
 }
 return 0;
}

12646 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 12646

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int A,B,C;
 while(scanf("%d%d%d",&A,&B,&C)==3)
 {
 if(A!=B&&A!=C)
 cout<<"A"<<endl;
 else if(B!=A&&B!=C)
 cout<<"B"<<endl;
 else if(C!=A&&C!=B)
 cout<<"C"<<endl;
 else if(C==A && A==B)
 cout<<"*"<<endl;
 }
 return 0;
}

127 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 127

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,d,cases; cin>>cases;
 while(cases--)
 {
 vector<string> vec;
 string name;
 while(1) { cin>>name; if(name.length()==1 && name[0]=='F') break; vec.push_back(name); }
 cin>>n>>d;
 int cnt = 0; d--;
 int l = vec.size();
 if (n>=l){ cout<<"TODOS TIENEN CAMA\n"; continue; }
 if(n==0) { cout<<"NADIE TIENE CAMA\n"; continue;}
 while(l!=n)
 {
 cnt += d;
 cnt=cnt%l;
 vec.erase(vec.begin() + cnt);
 l--;
 }
 int flag= 0;
 for(auto v:vec) if(flag==0) { cout<<v; flag=1; } else cout<<' '<<v;
 cout<<'\n';
 }
 return 0;
}

128 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 128


#include <bits/stdc++.h>
using namespace std;

int main(){
 int l;
 while(scanf("%d",&l)==1 && l!=-1){
 int n,s,ls,sol,solAc,res,sig,flag; sig=solAc=flag=sol=res=0;
 while(scanf("%d",&n)==1 && n!=-1){
 scanf("%d %d",&s,&ls);
 if(flag==1) continue;
 if(l<ls || ls==0) { printf("IMPOSIBLE\n"); flag=1; continue; }
 int c = (l/ls); //Varillas por varilla
 int resPb = l-c*ls; //Restante de varilla
 int total = n*s; //Varillas necesarias
 //USAR RESTANTE
 if(sig!=0){ //Si nos sobra de la ultima varilla del ultimo paraguas
 if(sig/ls!=0) {
 if(sig/ls>=total) { sig-=total*ls; total=0; }
 else { total-=sig/ls; res+=sig%ls; sig=0; }
 } //Si es mayor que la medida de una varilla del nuevo restar
 else { res+=sig; sig=0;} //Si no tirar y sumar a desperdicios
 if(total==0) continue; //Si hemos acabado el paraguas continuar
 }
 if(total%c==0) { solAc=total/c; sig=resPb;}
 else { solAc=total/c; sig=l-((total-(solAc*c))*ls); solAc++; }
 res+=resPb*(solAc-1);
 sol+=solAc;
 }
 res+=sig;
 if(flag==0) printf("%d %d\n",sol,res);
 }
 return 0;
}

/*
200
79 36 73 89 73 76 -1
100
89 10 43 64 87 30 -1
20
92 100 77 63 85 89 -1
10
78 13 74 64 41 92 -1
50
35 1 61 15 86 39 -1
400
65 18 19 99 68 95 -1
300
50 55 70 7 12 7 -1
5
76 38 34 18 95 91 -1
4
76 59 80 94 7 31 -1
1
61 55 10 19 71 2 -1
8000
60 75 62 74 10 4 96 61 40 -1
852
51 29 62 77 36 88 14 63 55 -1
752
98 81 96 73 78 43 97 69 40 -1
852
72 68 5 48 1 94 76 22 35 -1
1585
41 78 30 56 18 29 6 32 56 -1
850
35 19 66 24 19 74 88 88 15 -1
458
18 61 66 65 49 67 75 56 80 -1
5
33 24 92 12 87 20 42 87 34 -1
85448
74 77 28 9 68 44 51 96 13 -1
875
4 92 74 46 77 31 56 14 87 -1
858744
39 99 44 2 34 39 76 53 71 -1
57854
52 76 25 65 83 69 99 54 26 -1
1874587
7 100 58 75 100 10 32 76 18 -1
555
41 44 100 26 49 7 22 92 76 -1
1598
79 45 67 43 84 56 88 73 4 -1
58
96 48 59 54 2 26 84 35 6 -1
122
23 38 13 81 66 31 36 52 1 -1
54454
67 99 15 99 42 85 6 66 19 -1
8758754
5 79 25 46 29 59 42 4 26 -1
123
46 54 81 24 7 100 31 67 7 -1
-1

--------------

4671 232816
2301 24790
IMPOSIBLE
IMPOSIBLE
IMPOSIBLE
1739 33830
690 13912
IMPOSIBLE
IMPOSIBLE
IMPOSIBLE
65 3800
481 25668
1841 109822
104 1096
88 3556
236 6806
1554 89869
IMPOSIBLE
3 6224
239 3883
1 400220
11 26343
1 1715211
666 26488
300 13247
IMPOSIBLE
1895 52230
9 29637
1 8665805
2774 108659


*/

129 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 129

#include <bits/stdc++.h>
using namespace std;

int num[11][7] = {
 {1,1,1,0,1,1,1}, //4
 {0,0,1,0,0,1,0}, //3 6
 {1,0,1,1,1,0,1}, //2 6
 {1,0,1,1,0,1,1}, //2 5
 {0,1,1,1,0,1,0}, //1 5 7
 {1,1,0,1,0,1,1}, //3 5
 {1,1,0,1,1,1,1}, //3
 {1,0,1,0,0,1,0},
 {1,1,1,1,1,1,1},
 {1,1,1,1,0,1,1}, //5
 {0,0,0,0,0,0,0}
};
int results[11][11];
void solve()
{
 /*
 - 1
 | | 2 3
 - 4
 | | 5 6
 - 7
 */
 for (int i = 0; i < 11; i++)
 for (int j = i; j < 11; j++) {
 int cnt = 0;
 for (int k = 0; k < 7; k++)
 if (num[i][k] != num[j][k]) cnt++;
 results[i][j] = results[j][i] = cnt;
 }
}
int main()
{
 int n,n1;
 solve();
 while(scanf("%d",&n)==1 && n!=-1)
 {
 long long int total = 0;
 int cnt = 1;
 total += results[10][n];
 while(scanf("%d",&n1)==1 && n1!=-1)
 {
 cnt++;
 total+=results[n][n1];
 n=n1;
 }
 total += results[n][10];
 printf("%lld\n",cnt*total);
 }
 return 0;
}

130 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 130

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 int x,y,x1,y1; cin>>x>>y>>x1>>y1;
 int res = abs(x-x1) + abs(y-y1);
 int res1 = abs(x-x1);
 if(x<n && x1<n && y<n && y1<n && res%2==0) { if(x!=x1 && y!=y1 && (res1+y==y1 || y-res1==y1)) cout<<1<<'\n'; else if(x==x1 && y1==y) cout<<"0\n"; else cout<<2<<'\n';}
 else cout<<"IMPOSIBLE\n";
 }
 return 0;
}

13017 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13017

#include <bits/stdc++.h>
using namespace std;
struct cosa{
 long long int weight;
 bool operator<(const cosa &other)const{ return weight > other.weight; }
};

int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 priority_queue<cosa> pq;
 long long int n,res=0,num;
 cin>>n;
 for(int i=0; i<n;i++)
 {
 cin>>num;
 pq.push(cosa{num});
 }
 if(pq.size()==2)
 {
 cosa a=pq.top(); pq.pop(); cosa b=pq.top(); pq.pop();
 res+=(a.weight+b.weight);
 }
 else
 {
 while(pq.size()>1)
 {
 cosa a = pq.top(); pq.pop(); cosa b=pq.top(); pq.pop();
 res+=(a.weight+b.weight);
 pq.push(cosa{a.weight+b.weight});
 }
 }
 cout<<res<<endl;
 }
 return 0;
}

13018 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13018

#include <bits/stdc++.h>

using namespace std;

int main()
{
 int a,b,cases=0;
 while(scanf("%d",&a)!=EOF)
 {
 if (cases++) puts("");
 cin>>b;
 int vals[60];
 memset(vals,0,sizeof(vals));
 for(int i=1; i<=a;i++)
 for(int j=1;j<=b;j++)
 {
 vals[i+j]++;
 }
 int maximo =0;
 for(int i=1;i<=a+b;i++)
 maximo=max(maximo,vals[i]);
 for(int i=1;i<=a+b;i++)
 if(maximo==vals[i])
 cout<<i<<endl;
 }
 return 0;
}

13022 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13022

#include <bits/stdc++.h>
using namespace std;

int main() {
 vector<unsigned long long> ret;
 unsigned long long a = 0;
 for (int N = 1; N <= 64; N++) { //Number of ones
 a = a<<1 | 1;
 for (int M = 1; M <= 64; M++) {
 unsigned long long v = a;
 for (int i = N; i <= 64; i += N + M) { //Number of zeros and ones
 ret.push_back(v);
 v = v << M; //Add 0
 v = v << N | a; //Add 1
 }
 v = a << M; //zero
 for (int i = N+M; i <= 64; i += N + M) { //Generate ones and zeros
 ret.push_back(v);
 v = v << N | a; //Add 1
 v = v << M; //Add 0
 }
 }
 }
 sort(ret.begin(), ret.end()); //Order
 ret.resize(unique(ret.begin(), ret.end()) - ret.begin()); //Delete same numbers
 unsigned long long L, R;
 while (scanf("%llu %llu", &L, &R) == 2) {
 int sum = 0;
 for (unsigned int i=0; i<ret.size(); i++) {
 if(ret[i]<=R&&ret[i]>=L)
 sum++;
 }
 cout<<sum<<endl;
 }
 return 0;
}

13024 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13024

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define PI acos(-1.0)
using namespace std;

struct point{
 double x,y;
 point(){x=y=0;}
 point(double _x,double _y){x=_x,y=_y;}
 bool operator <(point other) const{
 if (fabs(x-other.x)>EPS)return x<other.x;
 return y<other.y;
 }bool operator ==(point other) const{
 return (fabs(x-other.x)<EPS)&&
 (fabs(y-other.y)<EPS);
 }
};

point arr[100005];
point res[100005];


double cross(const point &O, const point &A, const point &B)
{
 return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
}

int pointInsidePolygon(point p,int n) {
 if (n < 3) return false;
 if (cross(res[0], p, res[1]) > EPS) return false;
 if (cross(res[0], p, res[n-1]) < -EPS) return false;

 int l = 2, r = n-1;
 int line = -1;
 while (l <= r) {
 int mid = (l + r)>>1;
 if (cross(res[0],p, res[mid]) > -EPS) {
 line = mid;
 r = mid - 1;
 } else l = mid + 1;
 }
 return cross(res[line-1], p, res[line]) < EPS;
}

int CH(int n) {
 sort(arr, arr+n);
 int i, m = 0, t;
 for (i = 0; i < n; i++) {
 while(m >= 2 && cross(res[m-2], res[m-1], arr[i]) <= 0)
 m--;
 res[m++] = arr[i];
 }
 for (i = n-1, t = m+1; i >= 0; i--) {
 while(m >= t && cross(res[m-2], res[m-1], arr[i]) <= 0)
 m--;
 res[m++] = arr[i];
 }
 return m-1;
}
int main()
{
 int n;
 while(scanf("%d",&n)==1)
 {
 double x,y;
 for(int i=0; i<n;i++)
 {
 scanf("%lf %lf",&x,&y);
 arr[i] = point(x, y);
 }
 int resn = CH(n);
 scanf("%d",&n);
 int res = 0;
 for(int i=0; i<n;i++)
 {
 point query; scanf("%lf%lf",&query.x,&query.y);
 res+=pointInsidePolygon(query,resn);
 }
 printf("%d\n",res);
 }
 return 0;
}

13069 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13069

#include<bits/stdc++.h>
using namespace std;

int used[10500];
int BFS(int start, int target){
 queue<pair<int,int> > q;
 q.push(make_pair(start,0));
 while(!q.empty()){
 pair<int,int> current = q.front(); q.pop();
 if(current.first == target) return current.second;
 int sum = (current.first+1+10000)%10000;
 if(used[sum]==0)
 {
 used[sum]= 1;
 q.push(make_pair(sum ,current.second+1));
 }
 int mul = (current.first*2+10000)%10000;
 if(used[mul]==0)
 {
 used[mul]= 1;
 q.push(make_pair(mul,current.second+1));
 }
 int div = current.first/3;
 if(used[div]==0)
 q.push(make_pair((current.first/3),current.second+1));
 }
 return -1;
}


int main()
{
 int a,b;
 while(scanf("%d",&a)!=EOF)
 {
 cin>>b;
 memset(used,0,sizeof(used));
 cout<<BFS(a,b)<<endl;
 }
 return 0;
}

13070 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13070

#include <iostream>
using namespace std;
int main() {
 int casos;
 cin >> casos;
 while (casos--) {
 int nieve, arboles;
 cin >> nieve >> arboles;
 int p[arboles];
 int i = 0, j = 0, l = 0, enpie = 0;

 while (arboles--) {
 cin >> p[j];
 if (p[j] >= nieve && ++enpie > 5)
 while (enpie > 5) {
 if (p[i] >= nieve)
 enpie--;
 i++;
 }
 l = max(l, j-i+1);
 j++;
 }
 cout << l << endl;
 }
 return 0;
}

13071 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13071

#include <iostream>
using namespace std;
int main()
{
 int a,b,casos;
 int vector[5000];
 for(int i=0; i<5000; i++)
 {
 if(i==0)
 vector[i]= 1;
 if(i!=0)
 vector[i]=vector[i-1]+i;
 }

 cin>> casos;
 while(casos--)
 {
 cin>>a>>b;

 cout<<vector[b+a]+a<<"\n";
 }
 return 0;
}

13072 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13072

#include <bits/stdc++.h>
using namespace std;

string line;
string res;
int memo[1005][1005];
int DP(int i, int j)
{
 if (i == j) return 1;
 // Base Case 2: If there are only 2 characters and both are same
 if (line[i] == line[j] && i + 1 == j) return 2;
 int &best = memo[i][j];
 if(best!=-1) return best;
 if (line[i] == line[j]) return best = DP(i+1, j-1) + 2; // If the first and last characters match
 return best = max(DP(i, j-1), DP(i+1,j)); // If the first and last characters do not match
}
void print_DP(int i, int j) {
 if(i == j || (line[i] == line[j] && i + 1 == j)) { res=line[i]+res; return;}
 if (line[i]==line[j] && DP(i+1,j-1)+2 == memo[i][j]) {
 print_DP(i+1,j-1);
 res=line[i]+res;
 }
 else if(DP(i+1,j) == memo[i][j]) print_DP(i+1,j);
 else if(DP(i, j-1) == memo[i][j]) print_DP(i,j-1);
}
int main()
{
 while(getline(cin,line))
 {
 for(unsigned int i=0; i<line.length();i++)
 for(unsigned int j=0; j<line.length();j++) memo[i][j]=-1;
 int sol = DP(0,line.length()-1);
 print_DP(0,line.length()-1);
 printf("%s",res.c_str());
 if((res.length()+res.length()-1)!=sol) printf("%c",res[res.length()-1]);
 for(int i=res.length()-2;i>=0; i--) printf("%c",res[i]);
 printf("\n");
 res="";
 }
 return 0;
}

13073 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13073

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int cnt(int n)
{
 int di = 0;
 while (n > 0) {
 di++;
 n/=10;
 }
 return di;
}
int cntNum(int n)
{
 int d = cnt(n),p = 10, s = 1;
 if (n < 1) return 0;
 if (d == 1) return n;
 for (int i = 1; i <= d-2; i++) {
 s += p * (i+1);
 p *= 10;
 }
 return 9*s + d * (n-p+1);
}
int getCount(int ini,int fin)
{
 return cntNum(fin)-cntNum(ini-1);
}
int main()
{
 int ini,fin;
 while(scanf("%d%d",&ini,&fin)==2 && (ini!=0||fin!=0))
 {
 int i=ini,j=fin,m,mid=(getCount(ini,fin))/2;
 while(i<=j)
 {
 m = (i+j)/2;
 int d1 = getCount(ini,m);
 if(d1==mid) break;
 if(d1<mid) i = m+1;
 else j = m-1;
 }
 if(getCount(ini,m)>getCount(m+1,fin)) m--;
 printf("%d\n",m);
 }
 return 0;
}

13074 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13074

#include <bits/stdc++.h>
using namespace std;

long long int gcd(long long int a, long long int b) {
while (b > 0) {
long long int temp = b; b = a % b; a = temp; }
return a; }
long long int lcm(long long int a, long long int b){ return a*(b/gcd(a,b));}

int main() {
 int n;
 while (scanf("%d", &n) == 1 && n!=0) {
 int arr[105], used[105];
 memset(arr,0,sizeof(arr)); memset(used,0,sizeof(used));
 for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
 long long ret = 1;
 for (int i = 1; i <= n; i++) {
 if (used[i]) continue;
 int j = i, cicle = 0;
 while (!used[j]) //Cycle count
 {
 used[j] = 1;
 cicle++;
 j = arr[j];
 }
 ret = lcm(ret, cicle); //LCM of cycles
 }
 printf("%lld\n", ret);
 }
 return 0;
}

13075 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13075

#include <bits/stdc++.h>
using namespace std;

int main() {
 int casos;
 scanf("%d", &casos);
 while (casos--) {
 int C, V, A[17] = {};
 char s[17], mm[3] = "CV";
 scanf("%d %d", &C, &V);
 for (int i = C; i < C+V; i++)
 A[i] = 1;

 int f = 0;
 do {
 for (int i = 0; i < C+V; i++)
 s[i] = mm[A[i]];
 s[C+V] = '\0';
 if (f) putchar(' ');
 printf("%s", s), f = 1;
 } while (next_permutation(A, A+C+V));
 puts("");
 }
 return 0;
}

13076 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13076


#include <bits/stdc++.h>
using namespace std;

int par[1010050];
int size[1010050];
bool matrix[1005][1005];
int F,C;

inline void fastInput(int &n){
 char ch;
 int sign = 1;
 while(ch = getchar_unlocked(), isspace(ch)) {

 };
 n = 0;
 if(ch == '-')
 sign = -1;
 else n = ch - '0';
 while(ch = getchar_unlocked(), isdigit(ch))
 n = (n << 3) + (n << 1) + ch - '0';
 n *= sign;
}

int root(int i){
 if (par[i] == i)
 return i;
 else
 return par[i] = root(par[i]);
}

void merge(int a, int b){
 int p = root(a);
 int q = root(b);
 if (p == q)
 return;
 if (size[p] > size[q])
 swap(p, q);
 par[p] = q;
 size[q] += size[p];
}

int main(){
 int N,M,K,n;
 while(scanf("%d",&N)==1){ fastInput(M); fastInput(K); fastInput(n);
 vector<pair<int,int>> arboles;
 vector<pair<int,int>> connected;
 N++;M++;
 for (int i = 0; i <= N*M; i++) {
 par[i] = i;
 size[i] = 1;
 }
 for (int i = 0; i <= N; i++)
 for (int j = 0; j <= M; j++) matrix[i][j]=false;
 connected.push_back({0,0}); matrix[0][0]=true;
 connected.push_back({N-1,M-1}); matrix[N-1][M-1]=true;
 for(int i=0;i<n;i++){
 int x, y; fastInput(x); fastInput(y);
 arboles.push_back({x,y});
 }
 int lastX, lastY; lastX=lastY=-1;
 bool flag = false;
 for(int i=n-1;i>=0 &&!flag;i--){
 int ID = arboles[i].first*M+arboles[i].second;
 lastX = arboles[i].first; lastY=arboles[i].second;
 for (int j = -K; j <= K && !flag; j++) {
 for (int m = -K; m <= K && !flag; m++) {
 int I = arboles[i].first + j;
 int J = arboles[i].second + m;
 bool correct = 0 <= I && I < N && 0 <= J && J < M;
 if (sqrt(j*j + m * m) <= K && correct && matrix[I][J]) {
 merge(ID, I * M + J);
 }
 if (root(0)==root(N * M - 1)) flag = true;
 }
 }
 matrix[arboles[i].first][arboles[i].second]=true;
 }
 if(flag) printf("%d %d\n",lastX,lastY);
 else printf("NUNCA SE PUDO\n");
 }
 return 0;
}

13078 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13078

#include <bits/stdc++.h>
using namespace std;

const char dir[] = "NESW";
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int main() {
 int casos,Q,N,M;
 cin>>casos;
 while (casos--) {
 cin>>N>>M>>Q;
 int G[N][M];
 for(int lm=0;lm<N;lm++)
 for(int pk=0; pk<M;pk++)
 G[lm][pk]=0;
 for (int i = 0; i < Q; i++) {
 char s;
 int x, y, v;
 cin>>x>>y>>s>>v;
 x--; y--;
 int d = 0;
 for (int p = 0; p < 4; p++) {
 if (s == dir[p])
 {
 d = p; break;
 }
 }
 if (x >= N || y >= M || x < 0 ||y < 0)
 break;
 G[x][y]++;
 for (int l = 1; l<500; l++) {
 for (int j = 0; j < 2; j++) {
 for (int k = 0; k < l; k++) {
 x += dx[d], y += dy[d];
 if (x >= N || y >= M || x < 0 ||y < 0)
 break;
 G[x][y]++;
 v--;
 if (v == 0) break;
 }
 if (x >= N || y >= M || x < 0 ||y < 0)
 break;
 if (v == 0) break;
 d = (d + 1)%4;
 }
 if (x >= N || y >= M || x < 0 ||y < 0)
 break;
 if (v == 0) break;
 }
 }
 for (int i = 0; i < N; i++) {
 for (int j = 0; j < M; j++)
 printf("%d%c", G[i][j], j == M-1 ? '\n' : ' ');
 }
 cout<<"---\n";
 }
 return 0;
}

13079 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13079


#include <bits/stdc++.h>
using namespace std;

struct node{
 int x,y;
 bool operator<(const node &other)const{ if(x==other.x) return y>other.y; return x > other.x; }
};

int main(){
 int cases;
 while(scanf("%d",&cases)==1 && cases!=0){
 int x,y;
 priority_queue<node> pq;
 for(int i=0; i<cases;i++){
 scanf("%d %d",&x,&y);
 pq.push(node{x,y});
 }
 int res = 0,size=0;
 while(!pq.empty()){
 res++;
 node aux = pq.top(); pq.pop();
 size = aux.y-1;
 while(!pq.empty()){
 aux = pq.top();
 if(aux.x>size) break;
 size = min(aux.y-1,size);
 pq.pop();
 }
 }
 printf("%d\n",res);
 }
 return 0;
}

/*
INPUT
1
0 10
3
1 8
5 10
0 5
3
4 5
0 2
7 10
2
0 2
1 2
10
0 7
1 8
1 5
2 6
3 7
4 8
5 9
9 10
10 12
10 11
4
2 5
3 5
2 3
2 5
2
0 10
0 10
4
0 2
2 4
4 6
6 8
3
0 1
1 20
1 19
5
0 4
1 2
1 3
3 4
4 5
230
0 5
0 4
0 3
0 2
0 1
1 6
1 5
1 4
1 3
1 2
2 7
2 6
2 5
2 4
2 3
3 8
3 7
3 6
3 5
3 4
4 9
4 8
4 7
4 6
4 5
5 10
5 9
5 8
5 7
5 6
6 11
6 10
6 9
6 8
6 7
7 12
7 11
7 10
7 9
7 8
8 13
8 12
8 11
8 10
8 9
9 14
9 13
9 12
9 11
9 10
10 15
10 14
10 13
10 12
10 11
11 16
11 15
11 14
11 13
11 12
12 17
12 16
12 15
12 14
12 13
13 18
13 17
13 16
13 15
13 14
14 19
14 18
14 17
14 16
14 15
15 20
15 19
15 18
15 17
15 16
16 21
16 20
16 19
16 18
16 17
17 22
17 21
17 20
17 19
17 18
18 23
18 22
18 21
18 20
18 19
19 24
19 23
19 22
19 21
19 20
20 25
20 24
20 23
20 22
20 21
21 26
21 25
21 24
21 23
21 22
22 27
22 26
22 25
22 24
22 23
23 28
23 27
23 26
23 25
23 24
24 29
24 28
24 27
24 26
24 25
25 30
25 29
25 28
25 27
25 26
26 31
26 30
26 29
26 28
26 27
27 32
27 31
27 30
27 29
27 28
28 33
28 32
28 31
28 30
28 29
29 34
29 33
29 32
29 31
29 30
30 35
30 34
30 33
30 32
30 31
31 36
31 35
31 34
31 33
31 32
32 37
32 36
32 35
32 34
32 33
33 38
33 37
33 36
33 35
33 34
34 39
34 38
34 37
34 36
34 35
35 40
35 39
35 38
35 37
35 36
36 41
36 40
36 39
36 38
36 37
37 42
37 41
37 40
37 39
37 38
38 43
38 42
38 41
38 40
38 39
39 44
39 43
39 42
39 41
39 40
40 45
40 44
40 43
40 42
40 41
41 46
41 45
41 44
41 43
41 42
42 47
42 46
42 45
42 44
42 43
43 48
43 47
43 46
43 45
43 44
44 49
44 48
44 47
44 46
44 45
45 50
45 49
45 48
45 47
45 46
31
691 707
872 874
841 852
337 356
441 456
780 787
396 407
788 808
805 810
14 21
213 217
154 162
341 348
337 351
219 220
451 466
478 493
376 388
956 957
294 297
880 888
937 944
490 498
412 431
926 933
540 555
236 242
414 434
845 853
220 227
318 336
26
12 21
803 815
896 908
3 13
112 125
831 835
792 795
268 274
753 767
476 491
991 1000
991 1000
661 665
818 822
574 578
329 340
536 556
269 285
22 35
655 672
909 914
635 644
727 741
644 662
729 744
308 315
27
599 607
61 77
86 101
690 710
982 983
654 669
735 749
392 396
759 767
462 468
30 38
374 390
171 189
801 803
645 649
117 120
841 857
6 18
91 101
24 40
978 986
452 457
739 755
653 670
138 140
691 708
972 976
9
620 638
138 142
590 600
277 290
331 350
166 176
145 160
813 833
70 75
9
865 874
307 312
355 359
509 512
213 232
205 214
481 485
466 478
28 40
38
920 935
354 369
41 47
504 523
292 298
183 199
371 379
835 853
246 250
468 476
270 286
214 220
194 202
35 44
320 321
997 1000
475 486
492 497
930 949
183 187
783 785
40 44
901 920
337 348
74 81
294 295
883 899
36 45
843 857
480 485
134 150
275 286
952 955
222 227
908 919
576 596
395 405
675 685
26
750 768
8 23
267 283
638 642
446 458
80 96
422 434
514 530
97 99
47 53
441 447
45 64
750 761
990 1000
721 724
68 82
885 902
840 846
494 509
71 73
461 473
230 237
518 523
893 906
882 892
805 812
12
444 463
140 151
197 204
508 511
764 782
676 692
188 195
545 564
277 287
514 530
759 767
639 657
13
937 941
984 1000
610 614
583 589
110 119
493 501
464 483
634 648
961 979
673 691
720 735
212 231
76 93
1
455 464
16
377 397
532 548
285 288
923 934
16 32
559 560
539 546
902 922
643 653
985 1000
260 277
490 507
760 775
541 561
438 454
939 951
3
811 816
116 127
397 401
39
296 303
507 526
214 233
364 370
576 594
605 608
438 455
216 225
866 870
835 853
112 129
572 579
614 625
656 669
948 964
340 356
234 237
708 717
977 980
872 878
303 315
519 529
210 217
257 275
297 306
543 558
570 585
638 646
975 983
932 949
665 666
271 287
489 504
858 866
415 434
525 537
165 181
748 756
347 367
2
919 932
113 128
9
458 477
348 358
244 248
231 246
901 912
66 71
87 88
429 441
494 503
0


OUTPUT
1
2
3
1
4
2
1
4
2
3
46
24
20
21
9
8
28
20
11
13
1
14
3
27
2
8

*/

13080 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13080


#include <bits/stdc++.h>
using namespace std;

struct state{
 string val;
 int index;
};

string convert(string c){
 if(c.length()!=4) return c;
 string add(1, c[3]);
 string add2(1, c[3]+1);
 string add3(1, c[3]-1);
 //cout<<add<<endl;
 if(c[0]=='S'&&c[1]=='i'&&c[2]=='#') return "Do"+add2;
 else if(c[0]=='R'&&c[1]=='e'&&c[2]=='b') return "Do#"+add;
 else if(c[0]=='M'&&c[1]=='i'&&c[2]=='b') return "Re#"+add;
 else if(c[0]=='F'&&c[1]=='a'&&c[2]=='b') return "Mi"+add;
 else if(c[0]=='M'&&c[1]=='i'&&c[2]=='#') return "Fa"+add;
 else if(c[0]=='F'&&c[1]=='a'&&c[2]=='#') return "Solb"+add;
 else if(c[0]=='L'&&c[1]=='a'&&c[2]=='b') return "Sol#"+add;
 else if(c[0]=='S'&&c[1]=='i'&&c[2]=='b') return "La#"+add;
 else if(c[0]=='D'&&c[1]=='o'&&c[2]=='b') return "Si"+add3;
 return c;
}
int main(){
 int N;
 while(scanf("%d",&N)==1 && N!=0){
 string nota;
 map<string,int> M;
 string arr[]={"Do","Do#","Re","Re#","Mi","Fa","Solb","Sol","Sol#","La","La#","Si"};
 vector<state> elements;
 for(int i=1; i<8;i++){
 for(int j=0; j<12;j++) { state aux; aux.index=(i-1)*8+j+1; aux.val=arr[j]+to_string(i); elements.push_back(aux); }
 }
 cin.ignore();
 for(int i=0; i<N;i++){
 cin>>nota;
 string r = convert(nota);
 //cout<<nota<<" ---> "<<r<<endl;
 M[r]++;
 }
 int index=0x3f3f3f3f,index2=-0x3f3f3f3f;
 for(int i= 0; i<elements.size(); i++)
 if(M[elements[i].val]!=0) { index=min(index,i); index2=max(index2,i); }

 for(int i=index; i<=index2;i++)
 if(i==index) printf("%d",M[elements[i].val]);
 else printf(" %d",M[elements[i].val]);
 printf("\n");
 }
 return 0;
}

131 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 131

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F

using namespace std;
int getCount(int pisA,int baA,int bajA)
{
 int aux1=0,k=2,resultado;
 while(k>1)
 {
 resultado=pisA/baA;
 k=pisA-(resultado*baA)+resultado*bajA;
 aux1+=resultado;
 if(k<=0) break;
 if(k<=baA) { aux1++; break; }
 pisA=k;
 }
 return aux1;
}
int main()
{
 int pisA,pisB,baA,baB,bajB,bajA,k,m;
 while(scanf("%d%d%d%d%d%d",&pisA,&baA,&bajA,&pisB,&baB,&bajB)&&pisA!=0&&pisB!=0)
 {
 if(pisA==0||pisB==0) break;
 if(bajA>=baA && baA<pisA) k=INF;
 else if(baA>=pisA) k=1;
 else k = getCount(pisA,baA,bajA);
 if(bajB>=baB && baB<pisB) m=INF;
 else if(baB>=pisB) m=1;
 else m = getCount(pisB,baB,bajB);
 if(m==INF && k==INF) m=k=0;
 if(m>k) cout<<"YO "<<k<<'\n';
 else if(m<k) cout<<"VECINO "<<m<<'\n';
 else cout<<"EMPATE "<<k<<'\n';
 }
 return 0;
}

13161 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13161

#include <bits/stdc++.h>
using namespace std;

int main() {
 int D, R, T;
 while (scanf("%d %d %d", &D, &R, &T) == 3) {
 int x = 0, y = 0;
 int a = 0, b = 0;
 while (true) {
 x++;
 if (x >= 4)
 a += x;
 if (x-y > D) {
 y++;
 if (y >= 3)
 b += y;
 }
 if (a + b == R + T)
 break;
 }
 printf("%d\n", R-a);
 }
 return 0;
}

13171 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13171

#include <iostream>
using namespace std;

int main() {
 int casos;
 cin>>casos;
 while(casos--)
 {
 int c1=0,c2=0,c3=0;
 cin>>c1>>c2>>c3;
 string aux="";
 cin>>aux;
 for(int i=0;i<aux.length();i++)
 {
 switch(aux[i])
 {
 case 'M': c1--; break;
 case 'Y': c2--; break;
 case 'C': c3--; break;
 case 'R': c1--;c2--; break;
 case 'B': c2--;c3--;c1--; break;
 case 'G': c2--;c3--; break;
 case 'V': c1--;c3--; break;
 case 'W': break;
 }
 }
 if(c1<0||c2<0||c3<0)
 cout<<"NO"<<"\n";
 else
 cout<<"YES"<<" "<<c1<<" "<<c2<<" "<<c3<<"\n";
 }
 return 0;
}

13173 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13173

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int amigos, iteraciones,a,b;
 while(scanf("%d%d",&amigos,&iteraciones)==2 && (amigos!=0||iteraciones!=0))
 {
 bool regala[amigos][amigos]; //Array con posibles regalos
 bool amigo[amigos]; //Ya se sabe a quien regalo
 memset(regala,false,sizeof(regala));
 memset(amigo,false,sizeof(amigo));
 for(int j=0; j<amigos;j++) regala[j][j]=true; //Asi mismo no puede regalarse a true
 while(iteraciones--)
 {
 cin>>a>>b;
 a--; b--;
 regala[a][b]=true;
 amigo[a]=true;
 for(int j=0; j<amigos;j++)
 {
 regala[a][j]=true; //Ese no puede regalar a otro ya regalo, se pone a true
 regala[j][b]=true; //Al que le regalo el anterior no puede regalarse otro, se pone a true
 }
 }
 int contador=0,flag=0;
 bool change = true;
 while(change)
 {
 change=false;
 for(int i=0; i<amigos&&!change;i++)
 {
 if(!amigo[i]) //Si ese amigo no regalo se busca a quien puede regalar
 {
 for(int j=0; j<amigos&&!change;j++) //Change para que pueda empezar desde el principio
 { //Ya que quizas este antes que l el que regalar
 for(int s=0;s<amigos&&!change;s++) //Comprobar por columnas
 if(!regala[s][j]) contador++; //Solo debe haber uno para que pueda regalar si es as entrar abajo y significa que regal
 if(contador==1)
 {
 for(int k=0; k<amigos;k++) //Ponemos columnas y filas de este a true
 {
 regala[i][k]=true; //Ese no puede regalar a otro ya regalo, se pone a true
 regala[k][i]=true; //Al que le regalo el anterior no puede regalarse otro, se pone a true
 }
 amigo[i]=true; //Ponemos que regalo
 change=true; //Que se salga del for para comenzar desde el principio
 }
 contador=0; //Lo ponemos a 0 de nuevo
 }
 }
 }
 }
 for(int i=0; i<amigos;i++)
 {
 for(int j=0; j<amigos;j++)
 if(!regala[i][j])
 {
 cout<<"NO"<<endl;
 flag=1;
 break;
 }
 if(flag==1) break;
 }
 if(flag==0)
 cout<<"SI"<<endl;
 }
 return 0;
}

13174 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13174

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int n,m;
char matrix[201][201];
int sx[]={1,-1,0,0,1,-1,-1,1};
int sy[]={0,0,1,-1,1,-1,1,-1};
const int put = 2;
struct TrieNode
{
 struct TrieNode *children[put];
 bool isEndOfWord;
 int num;
};

struct TrieNode *getNode(void)
{
 struct TrieNode *pNode = new TrieNode;
 pNode->isEndOfWord = false;
 pNode->num=0;
 for (int i = 0; i < put; i++) pNode->children[i] = NULL;
 return pNode;
}
struct TrieNode *auxNode;
struct TrieNode *auxNode1;
struct TrieNode *auxNode2;
void insert(struct TrieNode *root, string key)
{
 struct TrieNode *pCrawl = root;

 for (unsigned int i = 0; i < key.length(); i++)
 {
 int index = key[i] - '0';
 if (!pCrawl->children[index])
 pCrawl->children[index] = getNode();

 pCrawl = pCrawl->children[index];
 }
 pCrawl->isEndOfWord = true;
}

int search(char key,int a)
{
 int index = key - '0';
 if (!auxNode->children[index]) return -1;
 auxNode = auxNode->children[index];
 if(auxNode->isEndOfWord) auxNode->num++;
 if (a==1) auxNode2=auxNode;
 return 0;
}
int searchN(struct TrieNode *root, string key)
{
 struct TrieNode *pCrawl = root;
 for (unsigned int i = 0; i < key.length(); i++)
 {
 int index = key[i] - '0';
 pCrawl = pCrawl->children[index];
 }
 return pCrawl->num;
}

void getWord(int x,int y, int i)
{
 if(x < n && y <m && x >= 0 && y >= 0) {
 if(search(matrix[x][y],0)==-1) return;
 getWord(x+sx[i], y+sy[i],i);
 }
}

void addWords(int i,int j)
{
 auxNode = auxNode1;
 if(search(matrix[i][j],1)==-1) return;
 for(int k=0; k<8;k++)
 {
 auxNode = auxNode2;
 getWord(i+sx[k],j+sy[k],k);
 }
}
int main()
{
 while(scanf("%d%d",&m,&n)==2)
 {
 map<string,int> M;
 for(int i=0; i<n;i++)
 for(int j=0; j<m;j++) cin>>matrix[i][j];
 struct TrieNode *root = getNode();
 auxNode1 = root;
 int t; cin>>t;
 while(t--)
 {
 string check;
 cin>>check;
 M[check]=0;
 insert(root, check);
 }
 for(int i=0; i<n;i++)
 for(int j=0; j<m;j++) addWords(i,j);

 for(auto m:M)
 {
 int aux = searchN(root,m.first);
 if(aux!=0) cout<<m.first<<" "<<aux<<'\n';
 }
 cout<<"---\n";
 }
 return 0;
}

13175 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13175

#include <bits/stdc++.h>
using namespace std;
int sol,pos;
string aux;
int solve()
{
 pos+=2;
 if(aux[pos]=='0')
 return 0;
 else if(aux[pos]=='1')
 {
 solve();
 return 0;
 }
 else
 {
 int hd = solve();
 int hi = solve();
 int hijos=min(hd,hi)+1;
 sol=max(sol,hijos);
 return hijos;
 }

}
int main()
{
 int cases;
 cin>>cases;
 cin.ignore();
 while(cases--)
 {
 getline(cin,aux);
 sol=0,pos=-2;
 solve();
 cout<<sol<<endl;

 }
 return 0;
}

13176 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13176

#include <bits/stdc++.h>
using namespace std;

int par[1010050];
int size[1010050];
bool matrix[1005][1005];
int F,C;

inline void fastInput(int &n){
 char ch;
 int sign = 1;
 while(ch = getchar_unlocked(), isspace(ch)) {

 };
 n = 0;
 if(ch == '-')
 sign = -1;
 else n = ch - '0';
 while(ch = getchar_unlocked(), isdigit(ch))
 n = (n << 3) + (n << 1) + ch - '0';
 n *= sign;
}

int root(int i){
 if (par[i] == i)
 return i;
 else
 return par[i] = root(par[i]);
}

void merge(int a, int b){
 int p = root(a);
 int q = root(b);
 if (p == q)
 return;
 if (size[p] > size[q])
 swap(p, q);
 par[p] = q;
 size[q] += size[p];
}

int main(){
 int N,M,K,n;
 while(scanf("%d",&N)==1){ fastInput(M); fastInput(K); fastInput(n);
 vector<pair<int,int>> arboles;
 vector<pair<int,int>> connected;
 N++;M++;
 for (int i = 0; i <= N*M; i++) {
 par[i] = i;
 size[i] = 1;
 }
 for (int i = 0; i <= N; i++)
 for (int j = 0; j <= M; j++) matrix[i][j]=false;
 connected.push_back({0,0}); matrix[0][0]=true;
 connected.push_back({N-1,M-1}); matrix[N-1][M-1]=true;
 for(int i=0;i<n;i++){
 int x, y; fastInput(x); fastInput(y);
 arboles.push_back({x,y});
 }
 int lastX, lastY; lastX=lastY=-1;
 bool flag = false;
 for(int i=n-1;i>=0 &&!flag;i--){
 int ID = arboles[i].first*M+arboles[i].second;
 lastX = arboles[i].first; lastY=arboles[i].second;
 for (int j = -K; j <= K && !flag; j++) {
 for (int m = -K; m <= K && !flag; m++) {
 int I = arboles[i].first + j;
 int J = arboles[i].second + m;
 bool correct = 0 <= I && I < N && 0 <= J && J < M;
 if (sqrt(j*j + m * m) <= K && correct && matrix[I][J]) {
 merge(ID, I * M + J);
 }
 if (root(0)==root(N * M - 1)) flag = true;
 }
 }
 matrix[arboles[i].first][arboles[i].second]=true;
 }
 if(flag) printf("%d %d\n",lastX,lastY);
 else printf("NUNCA SE PUDO\n");
 }
 return 0;
}

13177 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13177

#include <bits/stdc++.h>
using namespace std;

struct cosa{
 int weight;
 int modificado;
 int inicial;
 bool operator<(const cosa &other)const{ return weight < other.weight; }
};

int main() {
 int part=0,inst=0,numer,casos;
 while(scanf("%d",&part)!=EOF)
 {
 priority_queue<cosa> pq;
 cin>>inst;
 for(int i=0;i<inst;i++)
 {
 cin>>numer;
 pq.push(cosa{numer,2,numer});
 }
 casos=part-inst;
 while(casos--)
 {
 cosa t1 = pq.top();
 if((t1.inicial%t1.modificado)==0)
 {
 t1.weight=t1.inicial/t1.modificado;
 t1.modificado++;
 }
 else
 {
 t1.weight=t1.inicial/t1.modificado+1;
 t1.modificado++;
 }
 pq.pop();
 pq.push(t1);
 }
 cosa t2 = pq.top();
 cout<<t2.weight<<"\n";
 }
 return 0;
}

13178 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13178

#include <iostream>
#include <math.h>
using namespace std;

int main() {
 long long int casos,numero;
 cin>>casos;
 while(casos!=0)
 {
 cin.ignore();
 cin>>numero;

 if(numero%3==0||numero%3==2)
 cout<<"SI"<<"\n";
 else
 cout<<"NO"<<"\n";
 casos--;
 }

 return 0;
}

13180 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13180

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
 vector<long long int> collar,aux;
 long long int perla;
 cin >> perla;
 while(perla!=0)
 {
 while(perla!=0){
 collar.push_back(perla);
 cin>>perla;
 }
 for(long long int y=0;y<collar.size();y++)
 {
 aux.push_back(collar[y]);
 }
 int sepuede=1;
 sort(collar.begin(),collar.end());

 for (long long int i =0;i<collar.size() && sepuede==1;i++){
 if(i%2==1){
 if (collar[i]!=collar[i-1]||collar.size()%2==0){
 sepuede=0;
 }
 }
 }
 if (sepuede==1){
 int f=0;
 for (int j =0;j<collar.size();j+=2){
 if (j!=collar.size()-1){
 aux[f]=collar[j];
 aux[aux.size()-1-f]=collar[j+1];
 }
 else
 aux[f]=collar[j];
 f++;
 }
 for (long long int k=0;k<aux.size();k++){
 if(k!=aux.size()-1)
 cout<<aux[k]<<" ";
 else
 cout<<aux[k];
 }
 cout<<endl;
 }
 else
 cout<<"NO"<<endl;
 cin>>perla;
 collar.clear();
 aux.clear();
 }
 return 0;
}

13181 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13181

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string linea;
 while(getline(cin,linea))
 {
 int contador=0,resultado=-3;
 bool primero=false;
 for(int i=0; i<linea.length();i++)
 {
 if(linea[i]=='.')
 {
 contador++;
 if(i==0)
 {
 primero=true;
 }
 if(i==linea.length()-1)
 {
 resultado=max(resultado,contador-1);
 }

 }
 else
 {
 if(primero)
 {
 resultado=max(resultado,contador-1);
 primero=false;
 }
 else if(contador%2==0)
 {
 resultado=max(resultado,contador/2-1);
 }
 else
 {
 if(contador!=1)
 resultado=max(resultado,(contador+1)/2-1);
 else
 resultado=max(resultado,0);
 }
 contador=0;
 }
 }
 cout<<resultado<<"\n";
 }
 return 0;
}

132 — AceptaelReto

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 132

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 string line;
 while(getline(cin,line))
 {
 int n,cnt=0; cin>>n;
 if(n==0) break;
 char aux = line[0];
 int res[line.length()]; res[0]=cnt;
 for(unsigned int i=1; i<line.length();i++)
 {
 if(aux==line[i]) res[i]=cnt;
 else { aux=line[i]; cnt++; res[i]=cnt;}
 }
 for(int i=0; i<n;i++)
 {
 int a,b; cin>>a>>b;
 if(res[a]==res[b]) cout<<"SI\n";
 else cout<<"NO\n";
 }
 cout<<'\n'; cin.ignore();
 }
 return 0;
}

13282 — UVA

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 13282

//Problema A Swerc 2017 Cakey McCakeFace

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases;
 while(scanf("%d",&cases)!=EOF)
 {
 int m; cin>>m;
 map<long long int, long long int> a;
 long long int arr1[cases]; long long int arr2[m];
 for(int i=0; i<cases;i++) cin>>arr1[i];
 for(int i=0; i<m;i++) cin>>arr2[i];

 for(int i=0; i<cases;i++)
 for(int j=0; j<m;j++)
 {
 long long int res = arr2[j]-arr1[i];
 if(res<=0) continue;
 if(a.insert(pair<long long int,long long int>(res,1)).second == false)
 {
 long long int k = a.find(res)->second;
 k++;
 map<long long int,long long int>::iterator it = a.find(res);
 if (it != a.end())
 it->second = k;
 }
 }
 map<long long int,long long int>::iterator it = a.begin();
 long long int sol=0, resul=0;
 for (it=a.begin(); it!=a.end(); ++it)
 {
 if(it->second>sol){ resul=it->first; sol=it->second;}
 // cout << it->first <<" "<< it->second << '\n';
 }
 cout<<resul<<endl;
 }
 return 0;
}