Problemas de UVA Online Judge | Isaac Lozano Osorio

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;
 }
}

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;
 }
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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);
 }
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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);
 }
}

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;
}

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 — 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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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 — 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;
}

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 — 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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

13287 — UVA

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

Solución — 13287

//Problema F Swerc 2017 Shattered Cake

#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;
}

13288 — UVA

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

Solución — 13288

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

const int MAXV = 2005;

struct KM {
 int _mem[MAXV*MAXV];
 int *w[MAXV];
 int lx[MAXV], ly[MAXV];
 int16_t mx[MAXV], my[MAXV];
 int16_t aug[MAXV], vis[MAXV];
 pair<int, int> slack[MAXV];
 int nx, ny;


 int match() {
 for (int i = 0; i < nx; i++)
 lx[i] = *max_element(w[i], w[i]+ny); fill(ly, ly+ny, 0);
 fill(mx, mx+nx, -1);
 fill(my, my+ny, -1);
 fill(slack, slack+ny, make_pair(0, 0));
 for (int root = 0; root < nx; root++){
 fill(aug, aug+ny, -1);
 fill(vis, vis+nx, 0);
 vis[root] = 1;
 for (int y = 0; y < ny; y++)
 slack[y] = make_pair(lx[root]+ly[y]-w[root][y], root);
 int sy = -1;
 for (;;) {
 int delta = INT_MAX, sx = -1;
 for (int y = 0; y < ny; y++) {
 if (aug[y] == -1 && slack[y].first < delta) {
 delta = slack[y].first; sx = slack[y].second, sy = y;
 }
 }
 // assert(vis[sx]);
 if (delta > 0) {
 for (int x = 0; x < nx; x++) {
 if (vis[x]) lx[x] -= delta;
 }
 for (int y = 0; y < ny; y++) {
 if (aug[y] > -1) ly[y] += delta;
 else slack[y].first -= delta;
 }
 }
 // assert(lx[sx] + ly[sy] == w[sx][sy]);
 aug[sy] = sx; sx = my[sy];
 if (sx == -1) break;
 vis[sx] = 1;
 for (int y = 0; y < ny; y++) {
 if (aug[y] == -1) {
 if (lx[sx]+ly[y]-w[sx][y] < slack[y].first)
 slack[y] = make_pair(lx[sx]+ly[y]-w[sx][y], sx);
 }
 }
 }
 while (sy != -1) {
 int sx = aug[sy];
 int ty = mx[sx];
 my[sy] = sx;
 mx[sx] = sy;
 sy = ty;
 }
 }
 int ret = 0;
 for (int i = 0; i < nx; i++)
 ret += lx[i];
 for (int i = 0; i < ny; i++)
 ret += ly[i];
 return ret;
 }

 void init(int nx, int ny) {
 this->nx = nx, this->ny = ny;
 for (int i = 0; i < nx; i++)
 w[i] = _mem + i*ny;
 }
} km;

int main() {
 int numVine, numCouriers;
 const int MAXN = 2005;
 int bottlex[MAXN], bottley[MAXN];
 int courierx[MAXN], couriery[MAXN];
 int retuaurantx, restauranty;
 while (scanf("%d %d", &numVine, &numCouriers) == 2) {
 for (int i = 0; i < numVine; i++)
 scanf("%d %d", &bottlex[i], &bottley[i]);
 for (int i = 0; i < numCouriers; i++)
 scanf("%d %d", &courierx[i], &couriery[i]);
 scanf("%d %d", &retuaurantx, &restauranty);
 km.init(numVine, numCouriers+(numVine-1));

 //suma acumulada de distnacias de restaurante a vino.
 int ret = 0;

 for (int i = 0; i < numVine; i++) {

 int b = abs(bottlex[i]-retuaurantx)+abs(bottley[i]-restauranty);
 ret += b; //incremento
 //Presupones que tendrs que hacer el trayecto botella->restaurante
 //al menos una vez por cada botella.
 //asi que solo apuntas las distnacias casa->botella y rest->botella

 for (int j = 0; j < numCouriers; j++) {
 //distancia entre cada botella y cada repartidor
 int d = abs(bottlex[i]-courierx[j])+abs(bottley[i]-couriery[j]);
 km.w[i][j] = -d;
 }
 for (int j = 0; j < numVine-1; j++)
 //distancia entre cada botella y el restaurante
 //Aades esto numVinos-1 veces para asegurar que al menos un camino es
 //desde la casa de uno de los repartidores
 km.w[i][j+numCouriers] = -b;
 }
 //Segn este planteamiento una botella tiene que ser asignada o al restaurante(repartidor virtual) o a un repartidor.
 //Y al menos una botella ser repartida por un repartidor normal, ya que solo hay numBotellas-1 de los virtuales.
 ret += -km.match();
 printf("%d\n", ret);
 }
 return 0;
}

13291 — UVA

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

Solución — 13291


//Problema J Swerc 2017 Frosting on the Cake

#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;
}

//Problema J Swerc 2017 Frosting on the Cake CON MATRIZ
/*
#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 vals[3][3];
 memset(vals,0,sizeof(vals));
 for(int i=0; i<cases;i++)
 {
 if(i<3)
 {
 for(int j=0; j<cases;j++)
 {
 vals[i][(j+i)%3]+=arr1[j];
 }
 w+=(arr2[i]*vals[i][0]); y+=(arr2[i]*vals[i][1]); p+=(arr2[i]*vals[i][2]);
 }
 else
 {
 w+=(arr2[i]*vals[i%3][0]); y+=(arr2[i]*vals[i%3][1]); p+=(arr2[i]*vals[i%3][2]);
 }
 }
 cout<<y<<" "<<p<<" "<<w<<endl;
 }
 return 0;
}
*/

13292 — UVA

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

Solución — 13292

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

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#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;

typedef double T;
template<class T>
struct P {
 T x, y;

 explicit P(T a = 0, T b = 0) : x(a), y(b) {
 }

 bool operator<(P p) const {
 return tie(x, y) < tie(p.x, p.y);
 }

 bool operator==(P p) const {
 return tie(x, y) == tie(p.x, p.y);
 }

 P operator+(P p) const {
 return P(x + p.x, y + p.y);
 }

 P operator-(P p) const {
 return P(x - p.x, y - p.y);
 }

 P operator*(T d) const {
 return P(x*d, y * d);
 }

 P operator/(T d) const {
 return P(x / d, y / d);
 }

 T dot(P p) const {
 return x * p.x + y * p.y;
 }

 T cross(P p) const {
 return x * p.y - y * p.x;
 }

 T cross(P a, P b) const {
 return (a - * this).cross(b - * this);
 }

 T dist2() const {
 return x * x + y*y;
 }

 double dist() const {
 return sqrt((double) dist2());
 }
 // angle to x-axis in interval [-pi, pi]

 double angle() const {
 return atan2(y, x);
 }

 P unit() const {
 return *this / dist();
 } // makes dist()=1

 P perp() const {
 return P(-y, x);
 } // rotates +90 degrees

 P normal() const {
 return perp().unit();
 }
 // returns P rotated a radians ccw around the origin

 P rotate(double a) const {
 return P(x * cos(a) - y * sin(a), x * sin(a) + y * cos(a));
 }
};

template <class P>
double cross(P o, P a, P b) {
 return (a.x-o.x)*(b.y-o.y) - (a.y-o.y)*(b.x-o.x);
}
template <class P>
double cross2(P a, P b) {
 return a.x * b.y - a.y * b.x;
}

template <class P>
double dist(P p1, P p2) {
 return hypot(p1.x - p2.x, p1.y - p2.y); }

template <class P>
int CH(int n, P p[], P 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;
}

struct vec {
 double x, y;

 vec(double _x, double _y) : x(_x), y(_y) {
 }
};
template <class P>
vec toVec(P a, P 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

template <class P>
P translate(P p, vec v) { // translate p according to v
 return P(p.x + v.x, p.y + v.y);
}
template <class P>
double distToLine(P p, P a, P b, P &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);
}
template <class P>
double distToLineSegment(P p, P a, P b, P &c) {
 vec ap = toVec(a, p), ab = toVec(a, b);
 double u = dot(ap, ab) / norm_sq(ab);
 if (u < 0.0) {
 c = P(a.x, a.y); // closer to a
 return dist(p, a);
 }
 if (u > 1.0) {
 c = P(b.x, b.y); // closer to b
 return dist(p, b);
 }
 return distToLine(p, a, b, c);
} // run distToLine as above

template <class P>
double polygonDiameter(int n, P pt[]) {
 if (n <= 2) return 0;
 double ret = 1e+60;
 P aux;
 pt[n]=pt[0];
 //int n = pt.size()-1; //just end added
 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 = distToLineSegment(pt[j], pt[i], pt[i+1],aux);
 ret = min(ret, dist);
 }
 return ret;
}
int main()
{
 int n,r;
 while(scanf("%d%d",&n,&r)==2)
 {
 P<double> pt[262144], ch[262144];
 double x,y;
 for(int i=0; i<n;i++)
 {
 scanf("%lf%lf",&x,&y); pt[i] = P<double>{x,y};
 }
 n = CH(n,pt,ch);
 double sol = polygonDiameter(n,ch);
 printf("%.17lf\n",sol);
 }
 return 0;
}

136 — UVA

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

Solución — 136

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
/*
bool simp(int a)
{
 while(a%2==0) a>>=1;
 while(a%3==0) a/=3;
 while(a%5==0) a/=5;

 return a==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 u=0,n=0;
 for(int i=1;i<INF && u<1500;i++)
 {
 if(simp(i)) { n=i; u++; }
 }
 cout<<"The 1500'th ugly number is "<<n<<'\n';
 return 0;
}*/
int main()
{
 cout<<"The 1500'th ugly number is 859963392.\n";
 return 0;
}

146 — UVA

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

Solución — 146

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

int main()
{
 string id;
 while (cin >> id, id != "#")
 {
 if (next_permutation(id.begin(), id.end())) cout << id << '\n';
 else cout << "No Successor\n";
 }
 return 0;
}

147 — UVA

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

Solución — 147

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

long long int memo[300005][12];
bool mark[300005][12];
int arr[11] = {10000,5000,2000,1000,500,200,100,50,20,10,5};
int n,m;
long long int DP(int current, int c)
{
 if(current<0 || c>10) return 0;
 if(current==0) return 1;
 long long int &best = memo[current][c];
 if(mark[current][c]) return best;
 mark[current][c] = true;
 return best=DP(current-arr[c],c)+DP(current,c+1);
}
int main()
{
 string line;
 while(getline(cin,line))
 {
 string d,p;
 unsigned int i;
 for(i=0; i<line.length();i++)
 {
 if(line[i]=='.') {i++; break;}
 d+=line[i];
 }
 for(i; i<line.length();i++) p+=line[i];
 int total = stoi(d)*100+stoi(p);
 if(total==0) break;
 for(int i=0; i<total;i++)
 for(int j=0; j<12;j++)
 {
 mark[i][j]=false;
 memo[i][j]=0;
 }
 printf("%3s.%2s%17lld\n",d.c_str(),p.c_str(),DP(total,0));
 }
 return 0;
}

151 — UVA

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

Solución — 151

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

int josephus(int num,int jump)
{
 int jos=1;
 for(int i=2; i<=num;i++)
 {
 jos=((jos+jump-1)%i)+1;
 }
 return jos;
}

int main()
{
 int a;
 while(scanf("%d",&a)==1 && a!=0)
 {
 for(int i=1; i<0x3f3f3f3f;i++)
 {
 int res = josephus(a-1,i)+1;
 if(res==13) { printf("%d\n",i); break;}
 }
 }
}

156 — UVA

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

Solución — 156

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

int main(){
 string line,lineT;
 while(getline(cin,line))
 {
 if(line=="#") break;
 lineT+=line;
 lineT+=" ";
 }
 map<string,pair<int,int>> M;
 istringstream iss(lineT);
 vector<string> v((istream_iterator<string>(iss)),istream_iterator<string>());
 int i=0;
 for(auto word:v)
 {
 transform(word.begin(), word.end(), word.begin(), ::tolower);
 sort(word.begin(),word.end());
 pair<int,int> aux = M[word];
 M[word]=make_pair(aux.first+1, i);
 i++;
 }
 vector<string> sol;
 for(auto ma:M)
 {
 if(ma.second.first==1) sol.push_back(v[ma.second.second]);
 }
 sort(sol.begin(),sol.end());
 for(auto s:sol)
 {
 cout<<s<<endl;
 }
 return 0;
}

1585 — UVA

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

Solución — 1585

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

int main()
{
 int a;
 cin>>a;
 while(a--)
 {
 int res=0,cont=1;
 string b;
 cin>>b;
 for(int i=0; i<b.length();i++)
 {
 if(b[i]=='O')
 {
 res+=cont;
 cont++;
 }
 else
 cont=1;
 }
 cout<<res<<endl;
 }
 return 0;
}

1586 — UVA

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

Solución — 1586

#include <bits/stdc++.h>
using namespace std;
int main() {
 int testcase;
 char s[1024];
 double gmol[128];
 gmol['C'] = 12.01;
 gmol['H'] = 1.008;
 gmol['O'] = 16.00;
 gmol['N'] = 14.01;
 cin>>testcase;
 while (testcase--) {
 scanf("%s", s);
 double ret = 0;
 for (int i = 0; i < strlen(s); ) {
 int ele = s[i], num = 0;
 i++;
 while (s[i] >= '0' && s[i] <= '9')
 num = num * 10 + s[i] - '0', i++;
 if (num == 0)
 num = 1;
 ret += gmol[ele] * num;
 }
 printf("%.3lf\n", ret);
 }
 return 0;
}

167 — UVA

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

Solución — 167


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

int chessboard[8][8];
int solve(int X,int Y, int remaining, bool board[8][8]){
 if(remaining==0) {
 /*for(int i=0; i<8;i++){
 for(int j=0; j<8;j++) printf("%d",board[i][j]);
 printf("\n");
 }
 printf("-----\n");*/
 return 0;
 }
 if(X==8) {X=0; Y++;}
 if(Y==8) return -INF;
 int flag = 0;
 for(int i=0; i<8 && flag==0;i++) //Row and column check
 if(board[X][i]||board[i][Y]) flag=1;
 for (int i = X, j = Y; i >= 0 && j >= 0 && flag==0; i--, j--) //Diagonal
 if (board[i][j]) flag=1;
 for (int i = X, j = Y; i < 8 && j < 8 && flag==0; i++, j++) //Diagonal
 if (board[i][j]) flag=1;
 for (int i = X, j = Y; i >= 0 && j <8 && flag==0; i--, j++) //Diagonal
 if (board[i][j]) flag=1;
 for (int i = X, j = Y; i <8 && j >= 0 && flag==0; i++, j--) //Diagonal
 if (board[i][j]) flag=1;
 if(flag==0){
 board[X][Y]=true;
 int val = solve(X+1,Y,remaining-1,board)+chessboard[X][Y];
 board[X][Y]=false;
 return max(val,solve(X+1,Y,remaining,board));
 }
 else {
 return solve(X+1,Y,remaining,board);
 }

}
int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 for(int i=0; i<8;i++)
 for(int j=0; j<8;j++) scanf("%d",&chessboard[i][j]);
 bool board[8][8]; memset(board,false,sizeof(board));
 printf("%5d\n",solve(0,0,8,board));
 }
 return 0;
}

190 — UVA

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

Solución — 190

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 10-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 dist(point p1, point p2) { // Euclidean distance
 return hypot(p1.x - p2.x, p1.y - p2.y); } // return double

int circumCircle(point p1, point p2, point p3, point &ctr, double &r){
 double a = p2.x - p1.x, b = p2.y - p1.y;
 double c = p3.x - p1.x, d = p3.y - p1.y;
 double e = a * (p1.x + p2.x) + b * (p1.y + p2.y);
 double f = c * (p1.x + p3.x) + d * (p1.y + p3.y);
 double g = 2.0 * (a * (p3.y - p2.y) - b * (p3.x - p2.x));
 if (fabs(g) < EPS) return 0;

 ctr.x = (d*e - b*f) / g;
 ctr.y = (a*f - c*e) / g;
 r = dist(p1, ctr); // r = distance from center to 1 of the 3 points
 return 1; }

int main()
{
 double a,b,c,d,e,f;
 while(scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f)==6)
 {
 vector<point> V; V.push_back(point(a,b)); V.push_back(point(c,d)); V.push_back(point(e,f));
 point o;
 double r2;
 circumCircle(V[0],V[1],V[2],o,r2);
 r2 = (a-o.x)*(a-o.x)+(b-o.y)*(b-o.y);
 char c1, c2, c3;
 if(o.x >= 0) c1 = '-';
 else c1 = '+';
 if(o.y >= 0) c2 = '-';
 else c2 = '+';
 if(r2-o.x*o.x-o.y*o.y >= 0) c3 = '-';
 else c3 = '+';
 printf("(x %c %.3lf)^2 + (y %c %.3lf)^2 = %.3lf^2\n", c1, fabs(o.x), c2, fabs(o.y), sqrt(r2));
 printf("x^2 + y^2 %c %.3lfx %c %.3lfy %c %.3lf = 0\n\n", c1, fabs(2*o.x), c2, fabs(2*o.y), c3, fabs(r2-o.x*o.x-o.y*o.y));
 }
 return 0;
}

191 — UVA

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

Solución — 191

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

const double PI = 2.0*acos(0.0);
const double EPS = 1e-9; //too small/big?????
struct PT{
 double x,y;
 double length() {return sqrt(x*x+y*y); }
 int normalize()
 {
 double l = length();
 if(fabs(l)<EPS) return -1;
 x/=l; y/=l;
 return 0;
 }
 PT operator-(PT a)
 {
 PT r;
 r.x=x-a.x; r.y=y-a.y;
 return r;
 }
 PT operator+(PT a)
 {
 PT r;
 r.x=x+a.x; r.y=y+a.y;
 return r;
 }
 PT operator*(double sc)
 {
 PT r;
 r.x=x*sc; r.y=y*sc;
 return r;
 }
};



int intersect( PT p1, PT p2, PT p3, PT p4)
{
 PT 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 cases; scanf("%d",&cases);
 while (cases--)
 {
 PT p1,p2,p3,p5,p4;
 scanf("%lf%lf%lf%lf",&p1.x,&p1.y,&p2.x,&p2.y); // 4 9 11 2
 scanf("%lf%lf%lf%lf",&p3.x,&p3.y,&p5.x,&p5.y); // 1 5 7 1
 p4.x = p3.x; p4.y=p5.y; // 1 1 a 7 1
 bool res = intersect(p1,p2,p4,p5);
 res = res || intersect(p1,p2,p4,p3); //1 1 a 1 5
 p4.x = p5.x; p4.y = p3.y;
 res = res || intersect(p1,p2,p4,p3); // 7 5 a 7 1
 res = res || intersect(p1,p2,p4,p5); // 7 5 a 1 5
 res = res || (min(p3.x,p5.x)<=min(p1.x,p2.x) && max(p3.x,p5.x)>=max(p1.x,p2.x) && min(p3.y,p5.y)<=min(p1.y,p2.y) && max(p3.y,p5.y)>=max(p1.y,p2.y)); //inside
 if(res) printf("T\n");
 else printf("F\n");
 }
 return 0;
}

195 — UVA

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

Solución — 195

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

bool compare (char a, char b)
{
 bool minisculaA = true, minisculaB = true;
 if (a >= 'A' && a <= 'Z') minisculaA = false;
 if (b >= 'A' && b <= 'Z') minisculaB = false;
 if (minisculaA && minisculaB) return a < b;
 if (!minisculaA && !minisculaB) return a < b;
 if (minisculaA)
 {
 a -= ('a'-'A');
 return a < b;
 }
 else
 {
 b -= ('a'-'A');
 return a <= b;
 }
}

int main(){
 int cases;scanf("%d",&cases);
 while(cases--){
 string s;
 cin>>s;
 sort(s.begin(),s.end(),compare);
 do{
 cout<<s<<endl;
 }while(next_permutation(s.begin(),s.end(),compare));
 }
 return 0;
}

218 — UVA

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

Solución — 218

#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 c = 1,n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 if(c!=1) printf("\n");
 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 = CH(P);
 reverse(P.begin(),P.end());
 printf("Region #%d:\n",c++);
 for(unsigned int i = 0; i<P.size(); i++)
 {
 //printf("PUNTO(%3.lf,%.3lf)",P[i].x,P[i].y);
 if(i==0) printf("(%.1lf,%.1lf)",P[i].x,P[i].y);
 else printf("-(%.1lf,%.1lf)",P[i].x,P[i].y);
 }
 if(P.size()==1) printf("-(%.1lf,%.1lf)",round(P[0].x*10)/10,round(P[0].y*10)/10);
 printf("\nPerimeter length = %.2lf\n",perimeter(P));
 }
 return 0;
}

260 — UVA

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

Solución — 260

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

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

bool visited[205][205];
char arr[205][205];
int c,r,flag;
void dfs(int a,int b, char color)
{
 visited[a][b]=true;
 for(int i=0;i<6;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]==color){
 if(color=='w' && J==(c-1)) flag=0;
 else if(color=='b' && I==(c-1)) flag=1;
 visited[I][J]=true;
 dfs(I,J,color);
 }
 }
}
int main()
{
 int aux,ca=1;
 while(scanf("%d",&aux)==1 && aux!=0)
 {
 r=c=aux;
 for(int i = 0; i <aux; i++)
 for(int j = 0; j<aux; j++) cin>>arr[i][j];
 flag=-1;
 //black
 for(int i = 0; i <aux && flag==-1; i++)
 if(arr[0][i]=='b')
 {
 memset(visited,false,sizeof(visited));
 dfs(0,i,arr[0][i]);
 }
 //white
 for(int i = 0; i <aux && flag==-1; i++)
 if(arr[i][0]=='w')
 {
 memset(visited,false,sizeof(visited));
 dfs(i,0,arr[i][0]);
 }
 if(flag==0) printf("%d W\n",ca++);
 else printf("%d B\n",ca++);

 }
 return 0;
}

272 — UVA

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

Solución — 272

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string all;
 bool first=true;
 while(getline(cin,all))
 {
 string res;
 for(int i=0; i<all.length();i++)
 {
 if(all[i]==34&&first)
 {
 res+="``";
 first=false;
 }
 else if(all[i]==34&&!first)
 {
 res+="''";
 first=true;
 }
 else
 res+=all[i];
 }
 cout<<res<<endl;
 }
 return 0;
}

299 — UVA

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

Solución — 299

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

int main()
{
 int cases; cin>>cases;
 while(cases--)
 {
 int n; cin>>n;
 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<<"Optimal train swapping takes "<<swaps<<" swaps.\n";
 }
 return 0;
}

315 — UVA

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

Solución — 315

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

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const ll oo = 0x3f3f3f3f3f3f3f3fLL;



#define FOR(i, a, b) for(int i = (a); i < int(b); i++)
#define FORD(i, a, b) for(int i = (b)-1; i >= int(a); i--)
#define has(c, e) ((c).find(e) != (c).end())
#define sz(c) int((c).size())
#define all(c) c.begin(), c.end()


struct Edge{
 int u, v;
};


void ArticulationPointandBridges(vector<vi>& adj, vector<Edge> E, vi& articulation, vi& bridges) {
 int n = sz(adj), m = sz(E);
 articulation = vi(n, -1);
 bridges = vi(m, -1);
 vi dfs_low(n, -1), dfs_num(n ,-1), parent(n, -1);
 articulation = vi(n, 0);
 bridges = vi(m, 0);
 int dfsroot, rootc, cnt = 0;
 function<void(int)> ABdfs = [&](int u) {
 dfs_num[u] = dfs_low[u] = cnt++;
 for(int t : adj[u]){
 int v = E[t].u^E[t].v^u;
 if(dfs_num[v] == -1){
 if(u == dfsroot) rootc++;
 parent[v] = t;
 ABdfs(v);
 dfs_low[u] = min(dfs_low[u], dfs_low[v]);
 if(dfs_low[v] >= dfs_num[u])articulation[u] = 1;
 if(dfs_low[v] > dfs_num[u]) bridges[t] = 1;
 } else if (t != parent[u]){
 dfs_low[u] = min(dfs_low[u], dfs_num[v]);
 }
 }
 };
 FOR(i, 0, n) {
 if(dfs_num[i] == -1) {
 rootc = 0, dfsroot = i;
 ABdfs(i);
 if (rootc <= 1) articulation[i] = 0;
 }
 }
}


int main() {
 int x, y,n;
 char c;
 while(scanf("%d", &n) == 1 && n!=0)
 {

 vector<Edge> E;
 vector<vector<int>> adj(n+1);
 vi articulation;
 vi bridge;
 while(scanf("%d", &x) == 1 && x) {
 while(scanf("%d%c", &y, &c) == 2) {
 E.push_back({x,y});
 E.push_back({y,x});
 adj[x].push_back(E.size()-2);
 adj[y].push_back(E.size()-1);
 if(c == '\n') break;
 }
 }
 ArticulationPointandBridges(adj,E,articulation,bridge);
 int arts = 0;
 for(auto val : articulation){
 if(val==1)arts++;
 }
 printf("%d\n", arts);
 }
 return 0;
}

352 — UVA

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

Solución — 352

#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;
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<r && !visited[I][J]){
 visited[I][J]=true;
 if(arr[I][J]=='1') dfs(I,J);
 }
 }
}

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

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

357 — UVA

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

Solución — 357

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


long long int memo[300002][5];
bool visited[300002][5];
int v[]={50,25,10,5,1};

long long int DP(int n,int i)
{
 if(n==0) return 1;
 if(n<0||i>4) return 0;
 long long int &best = memo[n][i];
 if(visited[n][i]) return best;
 visited[n][i]=true;
 return best=DP(n-v[i],i)+DP(n-v[i+1],i+1)+DP(n-v[i+2],i+2)+DP(n-v[i+3],i+3)+DP(n-v[i+4],i+4);
}
int main()
{
 memset(visited,false,sizeof(visited));
 memset(memo,0,sizeof(memo));
 int num;
 while(scanf("%d",&num)==1)
 {
 long long int n = DP(num,0);
 if(n==1) printf("There is only 1 way to produce %d cents change.\n",num);
 else printf("There are %lld ways to produce %d cents change.\n",n,num);
 }
 return 0;
}

369 — UVA

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

Solución — 369

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

long long int binomialCoeff(long long int n, long long int k)
{
 long long int C[k+1];
 memset(C, 0, sizeof(C));
 C[0] = 1;
 for (long long int i = 1; i <= n; i++)
 for (long long int j = min(i, k); j > 0; j--)
 C[j] = C[j] + C[j-1];
 return C[k];
}

int main()
{
 long long int n,k;
 while(scanf("%lld%lld",&n,&k)==2 && (n!=0 || k!=0)) printf("%lld things taken %lld at a time is %lld exactly.\n",n,k,binomialCoeff(n, k));
 return 0;
}

378 — UVA

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

Solución — 378

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

const double PI = 2.0*acos(0.0);
const double EPS = 1e-9; //too small/big?????

struct PT{
 double x,y;
 double length() {return sqrt(x*x+y*y); }
 int normalize()
 {
 double l = length();
 if(fabs(l)<EPS) return -1;
 x/=l; y/=l;
 return 0;
 }
 PT operator-(PT a)
 {
 PT r;
 r.x=x-a.x; r.y=y-a.y;
 return r;
 }
 PT operator+(PT a)
 {
 PT r;
 r.x=x+a.x; r.y=y+a.y;
 return r;
 }
 PT operator*(double sc)
 {
 PT r;
 r.x=x*sc; r.y=y*sc;
 return r;
 }
};
struct line { double a, b, c; }; // a way to represent a line

void pointsToLine(PT p1, PT p2, line &l) {
 if (fabs(p1.x - p2.x) < EPS) { // vertical line is fine
 l.a = 1.0; l.b = 0.0; l.c = -p1.x; // default values
 } else {
 l.a = -(double)(p1.y - p2.y) / (p1.x - p2.x);
 l.b = 1.0; // IMPORTANT: we fix the value of b to 1.0
 l.c = -(double)(l.a * p1.x) - p1.y;
} }

PT sol;

int intersect( PT p1, PT p2, PT p3, PT p4)
{
 PT r;
 double d = (p4.y - p3.y)*(p2.x-p1.x) - (p4.x - p3.x)*(p2.y - p1.y);
 line l1,l2; pointsToLine(p1,p2,l1); pointsToLine(p3,p4,l2);
 if( fabs( d ) < EPS && fabs(l1.c - l2.c) < EPS) return 3;
 if( fabs( d ) < EPS ) return 2;
 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;
 sol = r;
 //cout<<r.x<<" " << r.y<<'\n';
 return 1;
}

int main ()
{
 int cases; scanf("%d",&cases);
 printf("INTERSECTING LINES OUTPUT\n");
 while (cases--)
 {
 PT p1,p2,p3,p4;
 scanf("%lf%lf%lf%lf",&p1.x,&p1.y,&p2.x,&p2.y);
 scanf("%lf%lf%lf%lf",&p3.x,&p3.y,&p4.x,&p4.y);
 int res = intersect(p1,p2,p4,p3);
 if(res==2) printf("NONE\n");
 else if(res==1) printf("POINT %.2lf %.2lf\n",sol.x,sol.y);
 else printf("LINE\n");
 }
 printf("END OF OUTPUT\n");
 return 0;
}

417 — UVA

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

Solución — 417

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

map<string,int> M;

void solve()
{
 queue<string> Q;
 for(char c='a';c<='z';c++) Q.push(string(1,c));
 string s;
 int cont=1;
 while(!Q.empty()){
 s=Q.front();
 Q.pop();
 M[s]=cont;
 cont++;
 if(s.size()==5) continue;
 for(char c=s[s.size()-1]+1;c<='z';c++) Q.push(s+c);
 }
}
int main()
{
 string a;
 solve();
 while(cin>>a)
 printf("%d\n",M[a]);
 return 0;
}

438 — UVA

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

Solución — 438

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 10-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 dist(point p1, point p2) { // Euclidean distance
 return hypot(p1.x - p2.x, p1.y - p2.y); } // return double

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 rCircumCircle(double ab, double bc, double ca) {
 return ab * bc * ca / (4.0 * area(ab, bc, ca)); }

double rCircumCircle(point a, point b, point c) {
 return rCircumCircle(dist(a, b), dist(b, c), dist(c, a)); }
int main()
{
 double a,b,c,d,e,f;
 while(scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f)==6)
 {
 vector<point> V; V.push_back(point(a,b)); V.push_back(point(c,d)); V.push_back(point(e,f));
 double resu;
 resu = 2*PI*rCircumCircle(V[0],V[1],V[2]);
 printf("%.2lf\n",resu);
 }
 return 0;
}

445 — UVA

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

Solución — 445

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

int main()
{
 string str;
 while(getline(cin,str))
 {
 if(str=="") cout<<'\n';
 else{
 int res=0;
 for(unsigned int i=0;i<str.length();i++)
 {
 if(str[i]>='0' && str[i]<='9') res=res+str[i]-'0';
 else if(str[i]=='!') cout<<'\n';
 else{
 for(int j=0; j<res;j++) if(str[i]=='b') cout<<' '; else cout<<str[i];
 res=0;
 }
 }
 cout<<'\n';
 }
 }
 return 0;
}

454 — UVA

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

Solución — 454

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

int main(){
 int cases; cin>>cases; cin.ignore();
 string line; getline(cin,line);
 while(cases--)
 {
 vector<string> orde;
 vector<string> nor;
 int cont = 0;
 while(getline(cin,line))
 {
 if(line=="") break;
 nor.push_back(line);
 }
 sort(nor.begin(),nor.end());
 for(unsigned int i=0; i<nor.size();i++)
 {
 string aux;
 line=nor[i];
 for(unsigned int i=0; i<line.length();i++)
 {
 if(line[i]==' ') continue;
 aux+=line[i];
 }
 sort(aux.begin(),aux.end());
 orde.push_back(aux);
 cont++;
 }
 for(unsigned int i=0; i<orde.size();i++)
 for(unsigned int j=i+1;j<orde.size();j++)
 if(orde[i]==orde[j]) cout<<nor[i]<<" = "<<nor[j]<<endl;
 if(cases!=0) cout<<endl;
 }
 return 0;
}

458 — UVA

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

Solución — 458

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

int main()
{
 string line;
 while(getline(cin,line))
 {
 string aux="";
 for(unsigned int i=0; i<line.length();i++) aux+=(line[i]-7);
 cout<<aux<<'\n';
 }
 return 0;
}

459 — UVA

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

Solución — 459

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

const int MAXN = 50;

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 cases; cin>>cases;
 getchar();
 getchar();
 while(cases--)
 {
 char N1; cin>>N1; int N=N1-65;
 vector<edge> edges;
 UF uf = UF(N+1);
 string line;
 cin.ignore();
 while(getline(cin,line))
 {
 if(line.length()!=2) break;
 edges.push_back(edge(line[0]-65,line[1]-65,1));
 }
 sort(edges.begin(), edges.end());
 for(unsigned int i=0;i<edges.size();i++) uf.connect(edges[i].from, edges[i].to, edges[i].weight);
 printf("%d\n",uf.components);
 if(cases!=0) printf("\n");
 }
 return 0;
}

460 — UVA

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

Solución — 460

#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; scanf("%d",&cases);
 double lx,ly,rx,ry,la,lb,ra,rb;
 while(cases--)
 {
 string line; getline(cin,line);
 scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&lx,&ly,&rx,&ry,&la,&lb,&ra,&rb);
 if(hasIntersect(lx,ly,rx,ry,la,lb,ra,rb)) printf("%.0lf %.0lf %.0lf %.0lf\n",lxsol,lysol,rxsol,rysol);
 else printf("No Overlap\n");
 if(cases!=0) printf("\n");
 }
 return 0;
}

469 — UVA

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

Solución — 469

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
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};

bool visited[105][105];
vector<string> arr;
int c,r,total;
void dfs(int a,int b)
{
 visited[a][b]=true;
 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 && !visited[I][J]&& arr[I][J]=='W'){
 visited[I][J]=true;
 total++;
 dfs(I,J);
 }
 }
}
int main()
{
 int aux;
 cin>>aux; cin.ignore();
 string s;
 getline(cin,s);
 while(aux--)
 {
 r=c=0;
 while(getline(cin,s))
 {
 if(s[0]!='W' && s[0]!='L') break;
 arr.push_back(s);
 r++;
 c=s.length();
 }
 int a,b;
 while(1){
 istringstream is2(s);
 is2>>a>>b;
 memset(visited,false,sizeof(visited));
 total = 1;
 dfs(a-1,b-1);
 cout<<total<<endl;
 getline(cin,s);
 if(s.empty()) break;
 }
 arr.clear();
 if(aux!=0) cout<<endl;
 }
 return 0;
}

476 — UVA

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

Solución — 476

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

struct point{
 double x,y,radio; char c;
 point(){x=y=radio=0; c='&';}
 point(double _x,double _y, double _radio, char _c){x=_x,y=_y; radio=_radio; 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 cross(vec a, vec b) { return a.x * b.y - a.y * b.x; }

bool collinear(point p, point q, point r) {
 return fabs(cross(toVec(p, q), toVec(p, r))) < EPS; }
bool inPolygon(point P, vector<point> poly){
 int n = poly.size();
 bool in = 0;

 for(int i = 0,j = n - 1;i < n;j = i++){
 double dx = poly[j].x - poly[i].x;
 double dy = poly[j].y - poly[i].y;

 if((poly[i].y <= P.y + EPS && P.y < poly[j].y) || (poly[j].y <= P.y + EPS && P.y < poly[i].y))
 if(P.x - EPS < dx * (P.y-poly[i].y) / dy+poly[i].x)
 in ^= 1;
 }
 for(int i=0; i<n-1;i++)
 if(collinear(poly[i],poly[i+1],P)) return false;
 if(collinear(poly[0],poly[n-1],P)) return false;
 return in;
}

int insideCircle(point p, point c, double r) { // all integer version
 double dx = p.x - c.x, dy = p.y - c.y;
 double Euc = dx * dx + dy * dy, rSq = r * r; // all integer
 return Euc < rSq ? 0 : Euc == rSq ? 1 : 2; } //inside/border/outside

int main()
{
 vector<point> V[12];
 double x,y,radio;
 char c;
 int i=0;
 while(cin>>c && c!='*')
 {
 if(c=='r') {
 double x1,y1;
 scanf("%lf%lf",&x,&y); scanf("%lf%lf",&x1,&y1);
 V[i].push_back(point(x,y1,0,c));
 V[i].push_back(point(x,y,0,c));
 V[i].push_back(point(x1,y,0,c));
 V[i].push_back(point(x1,y1,0,c));
 }
 else if(c=='c') {scanf("%lf%lf%lf",&x,&y,&radio); V[i].push_back(point(x,y,radio,c));}
 else if(c=='t') {
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 }
 i++;
 }
 int j=1,n=i;
 while(scanf("%lf %lf", &x,&y)==2 && (x!= 9999.9 || y!=9999.9))
 {
 int flag=1;
 for(int i=0;i<n;i++)
 {
 if(V[i][0].c == 'c')
 {
 int n = insideCircle(point(x,y,0,'.'),V[i][0],V[i][0].radio);
 if( n == 0) { flag++; printf("Point %d is contained in figure %d\n",j,i+1);}
 }
 else if(inPolygon(point(x,y,0,'.'),V[i])) {flag++; printf("Point %d is contained in figure %d\n",j,i+1);}
 }
 if(flag==1) printf("Point %d is not contained in any figure\n",j);
 j++;
 }
 return 0;
}

477 — UVA

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

Solución — 477

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

struct point{
 double x,y,radio; char c;
 point(){x=y=radio=0; c='&';}
 point(double _x,double _y, double _radio, char _c){x=_x,y=_y; radio=_radio; 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 cross(vec a, vec b) { return a.x * b.y - a.y * b.x; }

bool collinear(point p, point q, point r) {
 return fabs(cross(toVec(p, q), toVec(p, r))) < EPS; }
bool inPolygon(point P, vector<point> poly){
 int n = poly.size();
 bool in = 0;

 for(int i = 0,j = n - 1;i < n;j = i++){
 double dx = poly[j].x - poly[i].x;
 double dy = poly[j].y - poly[i].y;

 if((poly[i].y <= P.y + EPS && P.y < poly[j].y) || (poly[j].y <= P.y + EPS && P.y < poly[i].y))
 if(P.x - EPS < dx * (P.y-poly[i].y) / dy+poly[i].x)
 in ^= 1;
 }
 for(int i=0; i<n-1;i++)
 if(collinear(poly[i],poly[i+1],P)) return false;
 if(collinear(poly[0],poly[n-1],P)) return false;
 return in;
}

int insideCircle(point p, point c, double r) { // all integer version
 double dx = p.x - c.x, dy = p.y - c.y;
 double Euc = dx * dx + dy * dy, rSq = r * r; // all integer
 return Euc < rSq ? 0 : Euc == rSq ? 1 : 2; } //inside/border/outside

int main()
{
 vector<point> V[12];
 double x,y,radio;
 char c;
 int i=0;
 while(cin>>c && c!='*')
 {
 if(c=='r') {
 double x1,y1;
 scanf("%lf%lf",&x,&y); scanf("%lf%lf",&x1,&y1);
 V[i].push_back(point(x,y1,0,c));
 V[i].push_back(point(x,y,0,c));
 V[i].push_back(point(x1,y,0,c));
 V[i].push_back(point(x1,y1,0,c));
 }
 else if(c=='c') {scanf("%lf%lf%lf",&x,&y,&radio); V[i].push_back(point(x,y,radio,c));}
 else if(c=='t') {
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 }
 i++;
 }
 int j=1,n=i;
 while(scanf("%lf %lf", &x,&y)==2 && (x!= 9999.9 || y!=9999.9))
 {
 int flag=1;
 for(int i=0;i<n;i++)
 {
 if(V[i][0].c == 'c')
 {
 int n = insideCircle(point(x,y,0,'.'),V[i][0],V[i][0].radio);
 if( n == 0) { flag++; printf("Point %d is contained in figure %d\n",j,i+1);}
 }
 else if(inPolygon(point(x,y,0,'.'),V[i])) {flag++; printf("Point %d is contained in figure %d\n",j,i+1);}
 }
 if(flag==1) printf("Point %d is not contained in any figure\n",j);
 j++;
 }
 return 0;
}

478 — UVA

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

Solución — 478

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

struct point{
 double x,y,radio; char c;
 point(){x=y=radio=0; c='&';}
 point(double _x,double _y, double _radio, char _c){x=_x,y=_y; radio=_radio; 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 cross(vec a, vec b) { return a.x * b.y - a.y * b.x; }

bool collinear(point p, point q, point r) {
 return fabs(cross(toVec(p, q), toVec(p, r))) < EPS; }
bool inPolygon(point P, vector<point> poly){
 int n = poly.size();
 bool in = 0;

 for(int i = 0,j = n - 1;i < n;j = i++){
 double dx = poly[j].x - poly[i].x;
 double dy = poly[j].y - poly[i].y;

 if((poly[i].y <= P.y + EPS && P.y < poly[j].y) || (poly[j].y <= P.y + EPS && P.y < poly[i].y))
 if(P.x - EPS < dx * (P.y-poly[i].y) / dy+poly[i].x)
 in ^= 1;
 }
 for(int i=0; i<n-1;i++)
 if(collinear(poly[i],poly[i+1],P)) return false;
 if(collinear(poly[0],poly[n-1],P)) return false;
 return in;
}

int insideCircle(point p, point c, double r) { // all integer version
 double dx = p.x - c.x, dy = p.y - c.y;
 double Euc = dx * dx + dy * dy, rSq = r * r; // all integer
 return Euc < rSq ? 0 : Euc == rSq ? 1 : 2; } //inside/border/outside

int main()
{
 vector<point> V[9];
 double x,y,radio;
 char c;
 int i=0;
 while(cin>>c && c!='*')
 {
 if(c=='r') {
 double x1,y1;
 scanf("%lf%lf",&x,&y); scanf("%lf%lf",&x1,&y1);
 V[i].push_back(point(x,y1,0,c));
 V[i].push_back(point(x,y,0,c));
 V[i].push_back(point(x1,y,0,c));
 V[i].push_back(point(x1,y1,0,c));
 }
 else if(c=='c') {scanf("%lf%lf%lf",&x,&y,&radio); V[i].push_back(point(x,y,radio,c));}
 else if(c=='t') {
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 scanf("%lf%lf",&x,&y); V[i].push_back(point(x,y,0,c));
 }
 i++;
 }
 int j=1,n=i;
 while(scanf("%lf %lf", &x,&y)==2 && (x!= 9999.9 || y!=9999.9))
 {
 int flag=1;
 for(int i=0;i<n;i++)
 {
 if(V[i][0].c == 'c')
 {
 int n = insideCircle(point(x,y,0,'.'),V[i][0],V[i][0].radio);
 if( n == 0) { flag++; printf("Point %d is contained in figure %d\n",j,i+1);}
 }
 else if(inPolygon(point(x,y,0,'.'),V[i])) {flag++; printf("Point %d is contained in figure %d\n",j,i+1);}
 }
 if(flag==1) printf("Point %d is not contained in any figure\n",j);
 j++;
 }
 return 0;
}

483 — UVA

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

Solución — 483

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

int main()
{
 string line;
 while(getline(cin,line))
 {
 istringstream iss(line);
 vector<string> v((istream_iterator<string>(iss)),istream_iterator<string>());
 int flag=1;
 for(auto word:v)
 {
 if(flag==0) cout<<' ';
 for(int i=word.length()-1; i>=0; i--) cout<<word[i];
 flag=0;
 }
 cout<<'\n';
 }
 return 0;
}

484 — UVA

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

Solución — 484

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

int n;
map<int, int> m;
vector<int> v;

int main() {
 while(scanf("%d", &n) == 1) {
 if(m[n] == 0) v.push_back(n);
 m[n]++;
 }
 for(int i = 0; i < v.size(); i++) {
 printf("%d %d\n", v[i], m[v[i]]);
 }
}

488 — UVA

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

Solución — 488

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

int main()
{
 int n; cin>>n;
 while(n--)
 {
 cin.ignore();
 string line; getline(cin,line);
 int am,fre; cin>>am>>fre;
 for(int i=0; i<fre;i++)
 {
 for(int j=1; j<=am;j++)
 {
 for(int k=1; k<=j;k++)
 {
 cout<<j;
 }
 cout<<'\n';
 }
 for(int j=am-1; j>=1;j--)
 {
 for(int k=1; k<=j;k++)
 {
 cout<<j;
 }
 cout<<'\n';
 }
 if(n!=0 || i+1!=fre) cout<<'\n';
 }
 }
 return 0;
}

489 — UVA

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

Solución — 489

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

int main(){
 int round;
 while (scanf("%d", &round) != EOF && round != -1) {
 int ch, letter[26] = {0}, tmp = 7, win = 1;
 while (getchar() != '\n') continue;
 while ((ch = getchar()) != '\n') letter[ch - 'a'] = 1;
 while ((ch = getchar()) != '\n' && tmp) {
 if (!letter[ch - 'a']) --tmp;
 letter[ch - 'a'] = 2;
 }
 if (ch != '\n') while (getchar() != '\n') continue;
 for (int i = 0; i < 26 && win; ++i) if (letter[i] == 1) win = 0;
 printf("Round %d\nYou ", round);
 if (tmp && !win) puts("chickened out.");
 else if (win) puts("win.");
 else puts("lose.");
 }
 return 0;
}

494 — UVA

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

Solución — 494

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

int main(){
 string str;
 while(getline (cin,str)) {
 int i, flag = 0, count = 0;
 for(i = 0; str[i]; i++) {
 if((str[i] >= 'A' && str[i] <= 'Z') ||
 (str[i] >= 'a' && str[i] <= 'z'))
 flag = 1;
 else {
 count += flag;
 flag = 0;
 }
 }
 count += flag;
 cout<<count<<endl;
 }
 return 0;
}

514 — UVA

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

Solución — 514

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

int main() {

 int n;
 while (scanf("%d",&n)==1 && n!=0) {
 int rails[n];
 while (cin >> rails[0] && rails[0]!=0) {
 int index = 0;
 stack<int> Q;
 for (int i = 1; i < n; i++) cin >> rails[i];
 for (int i = 1; i <= n; i++) {
 Q.push(i);
 while (!Q.empty() && rails[index] == Q.top()) {
 index++;
 Q.pop();
 }
 }
 if(Q.empty()) cout<<"Yes\n";
 else cout<<"No\n";
 }
 cout<<endl;
 }
 return 0;
}

541 — UVA

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

Solución — 541

#include<bits/stdc++.h>
using namespace std;
int main() {
 int n;
 while(cin>>n && n!=0) {
 int matrix[n][n];
 for(int i = 0; i < n; i++)
 for(int j = 0; j < n; j++)
 cin>>matrix[i][j];
 int row[n], colum[n];
 memset(row,0,sizeof(row));
 memset(colum,0,sizeof(colum));
 for(int i = 0; i < n; i++) {
 for(int j = 0; j < n; j++) {
 colum[i] += matrix[i][j];
 row[i] += matrix[j][i];
 }
 }
 int r = 0, c = 0, er, ec;
 for(int i = 0; i < n; i++) {
 if(row[i]&1) r++, er = i;
 if(colum[i]&1) c++, ec = i;
 }
 if(r == 0 && c == 0)
 cout<<"OK\n";
 else if(r == 1 && c == 1)
 printf("Change bit (%d,%d)\n", ec+1, er+1);
 else
 cout<<"Corrupt\n";
 }
 return 0;
}

567 — UVA

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

Solución — 567

#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(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 ca = 1,aux;
 while(scanf("%d",&aux)==1)
 {
 for(int i=1;i<=20;i++) graph[i].clear(); // limpia el grafo
 int from = 1;
 for(int i=0; i<aux;i++)
 {
 int to; scanf("%d",&to);
 graph[from].push_back(edge(from,to,1));
 graph[to].push_back(edge(to, from, 1));
 }
 for(int i=2; i<20;i++)
 {
 cin>>aux;
 from=i;
 for(int j=0; j<aux;j++)
 {
 int to; scanf("%d",&to);
 graph[from].push_back(edge(from,to,1));
 graph[to].push_back(edge(to, from, 1));
 }
 }
 cin>>aux;
 printf("Test Set #%d\n",ca++);
 for(int i=0; i<aux;i++)
 {
 memset(dist,INF,sizeof(dist));
 int a,b; cin>>a>>b;
 printf("%2d to %2d: %d\n",a,b,dijkstra(a,b));
 }
 cout<<endl;
 }
 return 0;
}

572 — UVA

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

Solución — 572

#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;
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]=='@') dfs(I,J);
 }
 }
}
int main()
{
 while(scanf("%d%d",&r,&c)==2 && (c!=0 ||r!=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]=='@')
 {
 visited[i][j]=true;
 dfs(i,j);
 count++;
 }
 else visited[i][j]=true;
 cout<<count<<"\n";
 }
 return 0 ;
}

573 — UVA

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

Solución — 573

#include <bits/stdc++.h>
using namespace std;
int main()
{
 float H,U,D,F;
 while(scanf("%f%f%f%f",&H,&U,&D,&F)==4 && H!=0)
 {
 int days=1;
 double res=0,aux=U,minus=F*U/100;
 while(res<H)
 {
 res+=aux;
 if((aux-minus)>0)
 aux-=minus;
 else aux=0;
 if(res>H) break;
 res-=D;
 if(res<0) break;
 days++;
 }
 if(res>0)
 cout<<"success on day "<<days<<endl;
 else
 cout<<"failure on day "<<days<<endl;
 }
 return 0;
}

579 — UVA

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

Solución — 579

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

int main()
{
 double h,m;
 while(scanf("%lf:%2lf",&h,&m)==2 && (h!=0 || m!=0))
 {
 h*=5;
 if (h < m) h += 60;
 double ans = (h - m + m / 12.0) * 6;
 ans = (ans > 180 ? 360 - ans : ans);
 printf("%.3lf\n", (ans >= 0 ? ans : -ans));
 }
 return 0;
}

587 — UVA

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

Solución — 587

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-18
#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) {
 return hypot(p1.x - p2.x, p1.y - p2.y); }

int main()
{
 string line;
 int ca=1;
 while(getline(cin,line) && line!="END")
 {
 vector<string> v;
 //split
 char *token = strtok(strdup(line.c_str()), ",");
 while (token != NULL)
 {
 v.push_back(token);
 token = strtok(NULL, ",");
 }
 int n = v.size();
 v[n-1] = v[n-1].substr(0,v[n-1].length()-1);
 int num; string l;
 point res;
 for(int i=0; i<n;i++)
 {
 //read string
 stringstream sin(v[i]);
 sin>>num>>l;
 if(l=="N") res.y+=num;
 else if(l=="NE") { res.x+=num*sqrt(2)/2; res.y+=num*sqrt(2)/2; }
 else if(l=="E") res.x+=num;
 else if(l=="SE") { res.x+=num*sqrt(2)/2; res.y-=num*sqrt(2)/2; }
 else if(l=="S") res.y-=num;
 else if(l=="SW") { res.y-=num*sqrt(2)/2; res.x-=num*sqrt(2)/2; }
 else if(l=="W") res.x-=num;
 else if(l=="NW") {res.y+=num*sqrt(2)/2; res.x-=num*sqrt(2)/2;}
 }
 printf("Map #%d\nThe treasure is located at (%.3lf,%.3lf).\n",ca++,res.x,res.y);
 printf("The distance to the treasure is %.3lf.\n\n",dist(res,point(0,0)));
 }
 return 0;
}

591 — UVA

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

Solución — 591

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

int main() {
 int cases,p=1;
 while(scanf("%d", &cases) && cases!=0) {
 int n=0,media,res=0;
 int arr[cases];
 for(int i=0; i<cases;i++)
 {
 cin>>arr[i];
 n+=arr[i];
 }
 media=n/cases;
 for(int i=0; i<cases;i++)
 {
 if(arr[i]>media)
 res+=(arr[i]-media);
 }
 cout<<"Set #"<<p<<"\nThe minimum number of moves is "<<res<<".\n\n";
 p++;
 }
 return 0;
}

621 — UVA

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

Solución — 621

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 string a;
 cin>>a;
 if(a=="1"||a=="4"||a=="78")
 cout<<"+\n";
 else if(a[a.length()-1]=='5'&&a[a.length()-2]=='3')
 cout<<"-\n";
 else if(a[0]=='9'&&a[a.length()-1]=='4')
 cout<<"*\n";
 else
 cout<<"?\n";
 }
 return 0;
}

624 — UVA

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

Solución — 624

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

int arr[25];
int N,T,suma,cnt;
vector<int> V;
void sol(int i, int sum,int count,vector<int> R)
{
 if(i>T || sum>N) return;
 if(sum<=N && sum>=suma) { if((sum==suma && cnt<count) || sum>=suma) {V=R; cnt=count; suma=sum; }}
 sol(i+1,sum,count,R);
 R.push_back(arr[i]);
 sol(i+1,sum+arr[i],count+1,R);
}

int main()
{
 while(scanf("%d",&N)==1)
 {
 scanf("%d",&T);
 for(int i=0; i<T;i++) scanf("%d",&arr[i]);
 suma=cnt=0;
 vector<int> A; V.clear();
 sol(0,0,0,A);
 for(auto v:V) printf("%d ",v);
 printf("sum:%d\n",suma);
 }
 return 0;
}

634 — UVA

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

Solución — 634

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

struct point{
 int 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);
 }
};

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 pointInsidePolygon(point P, vector<point> poly){
 int n = poly.size();
 bool in = 0;

 for(int i = 0,j = n - 1;i < n;j = i++){
 double dx = poly[j].x - poly[i].x;
 double dy = poly[j].y - poly[i].y;

 if((poly[i].y <= P.y + EPS && P.y < poly[j].y) || (poly[j].y <= P.y + EPS && P.y < poly[i].y))
 if(P.x - EPS < dx * (P.y-poly[i].y) / dy+poly[i].x)
 in ^= 1;
 }
 return in;
}

int main()
{

 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 vector<point> P;
 int x,y;
 for(int i=0; i<n;i++)
 {
 scanf("%d%d",&x,&y);
 P.push_back(point(x, y));
 }
 point query; scanf("%d%d",&query.x,&query.y);
 if(pointInsidePolygon(query,P)) printf("T\n");
 else printf("F\n");
 }
 return 0;
}

661 — UVA

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

Solución — 661

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int n,m,c,scene=1,aux;
 while(scanf("%d%d%d",&n,&m,&c)==3 && (n!=0||m!=0||c!=0))
 {
 int arr[n]; bool onoff[n];
 memset(onoff,false,sizeof(onoff));
 for(int i=0; i<n;i++)
 {
 cin>>aux;
 arr[i]=aux;
 }
 int total=0,maximum=0; bool blow = false;
 for(int i=0; i<m;i++)
 {
 cin>>aux; aux--;
 if(onoff[aux]) { onoff[aux]=false; total-=arr[aux];}
 else { onoff[aux]=true; total+=arr[aux];}
 if(total>c)
 blow=true;
 else
 maximum=max(total,maximum);
 }
 cout<<"Sequence "<<scene<<endl;
 if(blow) cout<<"Fuse was blown.\n\n";
 else{
 cout<<"Fuse was not blown.\n";
 cout<<"Maximal power consumption was "<<maximum<<" amperes.\n\n";
 }
 scene++;
 }
 return 0;
}

673 — UVA

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

Solución — 673

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

int main()
{
 int cases;
 cin>>cases;
 cin.ignore();
 while(cases--)
 {
 string line;
 getline(cin,line);
 bool check = true;
 stack<char> S;
 for(unsigned int i=0; i<line.length()&✓i++)
 {
 if(line[i]=='('||line[i]=='{'||line[i]=='[') S.push(line[i]);
 else if(!S.empty()&&((line[i]==')'&&S.top()=='(')||(line[i]=='}'&&S.top()=='{')||(line[i]==']'&&S.top()=='['))) S.pop();
 else check=false;
 }
 if(check && S.empty()) printf("Yes\n");
 else printf("No\n");
 }
 return 0;
}

674 — UVA

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

Solución — 674

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

int v[]={50,25,10,5,1};
int memo[7850][5];
bool mark[7850][5];

int f(int a, int b)
{
 if(a==0) return 1; //Si es exactamente 0 PREMIO!
 if(a<0) return 0; //Si es menor que 0 al restar
 if(b>4) return 0; //Si excede el vector
 int &best=memo[a][b];
 if(mark[a][b]) return best;
 mark[a][b]=true;
 return best=f(a,b+1)+f(a-v[b],b);
}

int main(){
 int x;
 while(scanf("%d",&x)!=EOF)
 {
 // memset(mark,false,sizeof(mark));
 // memset(memo,0,sizeof(memo));
 cout<<f(x,0)<<endl;
 }
 return 0;
}

681 — UVA

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

Solución — 681

#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.y!=b.y) return a.y<b.y;
 return a.x<b.x;
}
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;
}


int main()
{
 int n,cases;
 while(scanf("%d",&cases)==1)
 {
 printf("%d\n",cases);
 while(cases--)
 {
 scanf("%d",&n);
 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);
 printf("%d\n",V.size());
 for(auto v:V)
 {
 printf("%.0lf %.0lf\n",v.x,v.y);
 }
 if(cases!=0) printf("-1\n");
 scanf("%d",&n);
 }
 }
 return 0;
}

694 — UVA

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

Solución — 694

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

int main()
{
 long long A,L,cont,caso=1;
 while(scanf("%lld%lld",&A,&L)==2 && (A>-1 || L>-1)){
 cout<<"Case "<<caso++<<": A = "<<A<<", limit = "<<L<<", number of terms = ";
 cont=0;
 while(A<=L && A!=1){
 if(A%2==0) A/=2;
 else A=3*A+1;
 cont++;
 }
 if(A==1) cont++;
 cout<<cont<<'\n';
 }
 return 0;
}

719 — UVA

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

Solución — 719

#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
} }

int main() {
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 memset(P,'\0',sizeof(P));
 memset(T,'\0',sizeof(T));
 scanf("%s", P);
 m = strlen(P);
 strcat(T, P);
 strcat(T, P);
 strcat(T, "{");
 n = strlen(T);
 constructSA();
 for (int i = 0; i <= n; i++) {
 if (SA[i] < m) {
 printf("%d\n", SA[i] + 1);
 break;
 }
 }
 }
 return 0;
}

722 — UVA

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

Solución — 722

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

int di[]={1,-1,0,0};
int dj[]={0,0,1,-1};
bool visited[105][105];
int R,C;
char arr[105][105];
int total=1;
void dfs(int a, int b){

 visited[a][b]=true;
 for(int i=0;i<4;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]=='0') {total++; dfs(I,J);}
 }
 }
}

int main()
{
 int cases; cin>>cases;
 while(cases--)
 {
 int r,c;
 scanf("%d%d",&r,&c); r--; c--;
 getchar();
 R = 0;
 char str[105];
 while(gets(str)&&strlen(str)>0)
 {
 strcpy(arr[R],str);
 R++;
 }
 C = strlen(arr[0]);
 for(int i=0; i<R;i++)
 for(int j=0; j<C;j++)
 visited[i][j]=false;
 if(arr[r][c]=='0')
 {
 visited[r][c]=true;
 dfs(r,c);
 printf("%d\n",total);
 total=1;
 }
 if(cases!=0) printf("\n");
 }
 return 0 ;
}

750 — UVA

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

Solución — 750

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

int col[9], cases, a, b, cnt;

bool place(int Q, int row){
 for(int ant = 1; ant < Q ; ant++)
 if(col[ant] == row || (abs(col[ant] - row) == abs(ant - Q)))
 return false;
 return true;
}

void solve(int Q)
{
 for(int row = 1; row <= 8; row++)
 if(place(Q, row)){
 col[Q] = row;
 if(Q == 8 && col[b] == a){
 printf("%2d %d", ++cnt, col[1]);
 for(int j = 2; j <= 8; j++)
 printf(" %d", col[j]);
 printf("\n");
 }
 else solve(Q+1);
 }
}
int main()
{
 scanf("%d", &cases);
 while(cases--){
 scanf("%d %d", &a, &b);
 memset(col, 0, sizeof(col));
 cnt = 0;
 printf("SOLN COLUMN\n");
 printf(" # 1 2 3 4 5 6 7 8\n\n");
 solve(1);
 if(cases) printf("\n");
 }
 return 0;
}

755 — UVA

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

Solución — 755

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

int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 string line;
 map<string,int> M;
 int num; cin>>num; num++;
 while(num--)
 {
 string aux="";
 getline(cin,line);
 for(unsigned int i=0; i<line.length();i++)
 {
 if(line[i]=='A'||line[i]=='B'||line[i]=='C') aux+='2';
 else if(line[i]=='D'||line[i]=='E'||line[i]=='F')aux+='3';
 else if(line[i]=='G'||line[i]=='H'||line[i]=='I')aux+='4';
 else if(line[i]=='J'||line[i]=='K'||line[i]=='L')aux+='5';
 else if(line[i]=='M'||line[i]=='N'||line[i]=='O')aux+='6';
 else if(line[i]=='P'||line[i]=='R'||line[i]=='S')aux+='7';
 else if(line[i]=='T'||line[i]=='U'||line[i]=='V')aux+='8';
 else if(line[i]=='W'||line[i]=='X'||line[i]=='Y')aux+='9';
 else if(line[i]=='-'||line[i]==' ') continue;
 else aux+=line[i];
 }
 if(line!="")
 M[aux]++;
 }
 int flag=1;
 for(auto m:M)
 if(m.second>1) {cout<<m.first.substr(0,3)<<"-"<<m.first.substr(3)<<" "<<m.second<<'\n'; flag=0;}
 if(flag==1) cout<<"No duplicates.\n";
 if(cases!=0)
 cout<<'\n';

 }
 return 0;
}

760 — UVA

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

Solución — 760

#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
}

int owner(int idx) { return (idx < n-m-1) ? 1 : 2; }

vector<ii> LCS() { // returns a pair (the LCS length and its index)
 vector<ii> V;
 int maxLCP = 0;
 for (int i = 1; i < n; i++) // O(n), start from i = 1
 if (owner(SA[i]) != owner(SA[i-1]) && LCP[i] > maxLCP) {V.clear(); V.push_back(ii(LCP[i],i)); maxLCP = LCP[i]; }
 else if(owner(SA[i]) != owner(SA[i-1]) && LCP[i] == maxLCP && LCP[i]!=0) V.push_back(ii(LCP[i],i));
 return V;
}
int main() {
 int flag=1;
 while(scanf("%s\n%s",T,P)==2)
 {
 if(flag==0) printf("\n");
 n = (int)strlen(T);
 T[n++] = '$';
 m = (int)strlen(P);
 strcat(T, P); // append P
 strcat(T, "#"); // add '$' at the back
 n = (int)strlen(T); // update n
 constructSA(); // O(n log n)
 computeLCP(); // O(n)
 vector<ii> ans = LCS(); // find the longest common substring between T and P
 string auxi = "";
 for(unsigned int i=0; i<ans.size();i++)
 {
 string au = T+SA[ans[i].second];
 au = au.substr(0,ans[i].first);
 if(auxi==au) continue;
 auxi = au;
 printf("%s\n", au.c_str());
 }
 if(ans.size()==0) printf("No common sequence.\n");
 flag=0;
 memset(T, '\0', sizeof(T));
 memset(P, '\0', sizeof(P));
 }
 return 0;
}

784 — UVA

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

Solución — 784

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
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};

vector<string> arr;
bool visited[105][105];
void dfs(int a,int b)
{

 visited[a][b]=true;
 for(int i=0;i<8;i++){
 int I=a+sx[i];
 int J=b+sy[i];
 if(!visited[I][J] && arr[I][J]==' '){
 visited[I][J]=true;
 arr[I][J]='#';
 dfs(I,J);
 }
 }
}
int main()
{
 int aux;
 cin>>aux; cin.ignore();
 while(aux--)
 {
 string str;
 int flag=0;
 while(getline(cin, str), str.front() != '_') arr.push_back(str);
 memset(visited,false,sizeof(visited));
 for(unsigned int i = 0; i < arr.size()&&flag==0; i++)
 for(unsigned int j = 0; j<arr[i].size()&&flag==0; j++)
 if(arr[i][j] == '*')
 {
 dfs(i, j);
 arr[i][j]='#';
 flag=0;
 }
 for(auto s: arr) cout<<s<<endl;
 cout<<str<<endl;
 arr.clear();

 }
 return 0;
}

785 — UVA

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

Solución — 785

#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;
char V[VAL][VAL];
bool visited[VAL][VAL];
int c,r;
void dfs(int a,int b, char pr)
{
 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<101 && !visited[I][J]&& V[I][J]!='X'){
 visited[I][J]=true;
 V[I][J]=pr;
 dfs(I,J,pr);
 }
 }
}
int main()
{
 while(1) {
 r=0;
 while(1) {
 if(!gets(V[r])) return 0;
 if(V[r][0] == '_') break;
 r++;
 }
 memset(visited, false, sizeof(visited));
 for(int i = 0; i < r; i++)
 for(int j = 0; V[i][j]; j++)
 if(V[i][j] != 'X' && V[i][j] != ' ' && !visited [i][j]) dfs(i, j, V[i][j]);
 for(int i = 0; i < r; i++)
 puts(V[i]);
 puts("_____________________________");
 }
 return 0;
}

787 — UVA

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

Solución — 787

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

int main()
{
 int arr[105];
 while(scanf("%d",&arr[0])==1)
 {
 int n=0,k=0;
 long long int mxV=-INF;
 while(scanf("%d",&n)==1 && n!=-999999) { k++; arr[k]=n; }
 if(k==0) printf("%d\n",arr[k]);
 else
 {
 k++;
 for(int i=0;i<k;i++)
 {
 long long int sum=1;
 for(int j=i;j<k;j++)
 {
 sum=sum*arr[j];
 if(mxV<sum)mxV=sum;
 }
 }
 printf("%lld\n",mxV);
 }
 }
 return 0;
}
*/
import java.math.*;
import java.util.*;

public class Main {

 public static void main(String args[]) {
 Scanner ob = new Scanner(System.in);
 BigInteger [] a = new BigInteger [107];
 while (ob.hasNext()) {
 int n = 0 ;
 while(true){
 int x = ob.nextInt();
 if( x == -999999)break;
 a[ n++ ] = BigInteger.valueOf(x);
 }
 BigInteger Ans = BigInteger.valueOf(-999999);
 for( int i = 0 ; i < n ; i++){
 BigInteger ret = a[i];
 Ans = Ans.max(ret);
 for( int j = i + 1 ; j < n ; j++ ){
 ret = ret.multiply(a[j]);
 Ans = Ans.max(ret);
 }
 }
 System.out.println(Ans);

 }
 }

}

793 — UVA

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

Solución — 793

#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){
 from = a;
 to = b;
 }
};

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){
 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];
 }
 components--;
 }
};

int a=1;
int N;

int main(){
 int cases; cin>>cases; cin.ignore();
 string s;
 while(cases--)
 {
 int cont1,cont2,N,x,y;
 char c;
 scanf("\n%d\n",&N);
 UF uf = UF(N+1);
 cont1=cont2=0;

 while(1){
 if(!getline(cin,s) || s.empty()) break;
 sscanf(s.c_str(),"%c %d %d",&c,&x,&y);
 if(c=='c')
 {
 uf.connect(x, y);
 }
 else
 {
 if(uf.isConnected(x,y)) cont1++;
 else cont2++;
 }
 }
 printf("%d,%d\n",cont1,cont2);
 if(cases!=0) printf("\n");
 }
 return 0;
}

796 — UVA

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

Solución — 796

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

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const ll oo = 0x3f3f3f3f3f3f3f3fLL;

#define FOR(i, a, b) for(int i = (a); i < int(b); i++)
#define FORD(i, a, b) for(int i = (b)-1; i >= int(a); i--)
#define has(c, e) ((c).find(e) != (c).end())
#define sz(c) int((c).size())
#define all(c) c.begin(), c.end()


struct Edge{
 int u, v;
};

void ArticulationPointandBridges(vector<vi>& adj, vector<Edge> E, vi& articulation, vi& bridges) {
 int n = sz(adj), m = sz(E);
 articulation = vi(n, -1);
 bridges = vi(m, -1);
 vi dfs_low(n, -1), dfs_num(n ,-1), parent(n, -1);
 articulation = vi(n, 0);
 bridges = vi(m, 0);
 int dfsroot, rootc, cnt = 0;
 function<void(int)> ABdfs = [&](int u) {
 dfs_num[u] = dfs_low[u] = cnt++;
 for(int t : adj[u]){
 int v = E[t].u^E[t].v^u;
 if(dfs_num[v] == -1){
 if(u == dfsroot) rootc++;
 parent[v] = t;
 ABdfs(v);
 dfs_low[u] = min(dfs_low[u], dfs_low[v]);
 if(dfs_low[v] >= dfs_num[u])articulation[u] = 1;
 if(dfs_low[v] > dfs_num[u]) bridges[t] = 1;
 } else if (t != parent[u]){
 dfs_low[u] = min(dfs_low[u], dfs_num[v]);
 }
 }
 };
 FOR(i, 0, n) {
 if(dfs_num[i] == -1) {
 rootc = 0, dfsroot = i;
 ABdfs(i);
 if (rootc <= 1) articulation[i] = 0;
 }
 }
}

bool cmp(Edge a,Edge b)
{
 if(a.u == b.u) return a.v<b.v;
 return a.u<b.u;
}

Edge reverse(Edge e){
 if (e.u>e.v){
 return Edge{e.v,e.u};
 }
 return e;
}

int main() {
 int n,m;
 while(scanf("%d",&n)==1)
 {
 vector<Edge> E;
 vector<vector<int>> adj(n+1);
 vi articulation;
 vi bridge;
 bool connected[n+1][n+1];
 memset(connected,false, sizeof(connected));
 for(int i=0; i<n;i++)
 {
 int x,y; scanf("%d (%d)",&x,&m);
 for(int j=0; j<m;j++)
 {
 scanf("%d",&y);
 if(connected[x][y] || connected[y][x] ) continue;
 connected[x][y] = true;
 E.push_back({x,y});
 adj[x].push_back(E.size()-1);
 adj[y].push_back(E.size()-1);
 }
 }
 ArticulationPointandBridges(adj,E,articulation,bridge);

 int cnt = 0;
 vector<Edge> resu;

 for(unsigned i=0;i<bridge.size();i++)
 if(bridge[i]==1) {
 cnt++;
 resu.push_back(reverse(E[i]));
 }

 printf("%d critical links\n",cnt);

 sort(resu.begin(),resu.end(),cmp);

 for(int i=0; i<cnt;i++)
 printf("%d - %d\n", resu[i].u,resu[i].v);
 cin.ignore();

 printf("\n");
 }
 return 0;
}

820 — UVA

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

Solución — 820

#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 n, i=1;
 while(scanf("%d", &n) && n!=0) {
 e=0;
 memset(head, -1, sizeof(head));
 int s, t, c, x, y, p;
 cin >> s >> t >> c;
 while(c--) {
 cin >> x >> y >> p;
 addEdge(x, y, p);
 addEdge(y, x, p);
 }
 int flow = maxflow(s, t);
 cout << "Network " << i << "\nThe bandwidth is " << flow <<".\n\n";
 i++;
 }

 return 0;
}

821 — UVA

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

Solución — 821

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

const int MAXN = 105;

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{
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 a,b,ca=1;
 while(scanf("%d%d",&a,&b)==2 && (a!=0 || b!=0))
 {
 int aux = 1;
 map<int,int> M;
 if(M[a]==0) { M[a]=aux; aux++;}
 if(M[b]==0) { M[b]=aux; aux++;}
 graph[M[a]].push_back(edge(M[a],M[b],1));
 //cout<<M[a]<<" -> "<<M[b]<<endl;
 while(scanf("%d%d",&a,&b)==2 && (a!=0 || b!=0))
 {
 if(M[a]==0) { M[a]=aux; aux++;}
 if(M[b]==0) { M[b]=aux; aux++;}
 graph[M[a]].push_back(edge(M[a],M[b],1));
 //cout<<M[a]<<" -> "<<M[b]<<endl;
 }

 double total=0,div=(aux-1)*(aux-2);
 for(int i=1; i<aux;i++)
 {
 memset(dist,INF,sizeof(dist));
 dijkstra(i,aux);
 for(int j=1; j<aux;j++) if(i!=j) total+=dist[j]; //cout<<i<<" ->"<<j<<" = "<<dist[j]<<endl;}
 }
 printf("Case %d: average length between pages = %.3f clicks\n",ca++,(double)total/div);
 for(int i=1;i<=aux;i++) graph[i].clear();
 }
 return 0;
}

833 — UVA

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

Solución — 833

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-18
#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;
 }
 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;
 }
};
struct line { double a, b, c; }; // a way to represent a line

void pointsToLine(point p1, point p2, line &l) {
 if (fabs(p1.x - p2.x) < EPS) { // vertical line is fine
 l.a = 1.0; l.b = 0.0; l.c = -p1.x; // default values
 } else {
 l.a = -(double)(p1.y - p2.y) / (p1.x - p2.x);
 l.b = 1.0; // IMPORTANT: we fix the value of b to 1.0
 l.c = -(double)(l.a * p1.x) - p1.y;
} }
double dist(point p1, point p2) { // Euclidean distance
 return hypot(p1.x - p2.x, p1.y - p2.y); } // return double
point sol;
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);
 line l1,l2; pointsToLine(p1,p2,l1); pointsToLine(p3,p4,l2);
 if( fabs( d ) < EPS && fabs(l1.c - l2.c) < EPS) return 3;
 if( fabs( d ) < EPS ) return 2;
 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;
 sol = r;
 //cout<<r.x<<" " << r.y<<'\n';
 return 1;
}
bool cmp(pair<point,point> a, pair<point,point> b)
{
 return max(a.first.y,a.second.y)>max(b.first.y,b.second.y);
}

int main()
{
 int n,cases; scanf("%d",&cases);
 while(cases--)
 {
 string line;
 getline(cin,line); cin.ignore();
 scanf("%d",&n);
 vector<pair<point,point>> V;
 double x,y,x_,y_;
 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_)});
 }
 scanf("%d",&n);
 sort(V.begin(),V.end(),cmp);
 for(int i=0; i<n;i++)
 {
 scanf("%lf%lf",&x,&y);
 point aux = point(x,y);
 for(auto v:V)
 {
 int miny = min(v.first.y,v.second.y);
 int minx = min(v.first.x,v.second.x);
 int maxx = max(v.first.x,v.second.x);
 intersect(v.first,v.second,aux,point(aux.x,0));
 if(aux.y >= miny && aux.x >= minx && aux.x <= maxx && sol.y<=aux.y)
 {
 if(v.first.y==miny) aux.x=v.first.x;
 else aux.x=v.second.x;
 aux.y = miny;
 }
 }
 printf("%.0lf\n",aux.x);
 }
 if(cases!=0) printf("\n");

 }
 return 0;
}

871 — UVA

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

Solución — 871

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

int di[] = {-1, 0, 1, 0, -1,-1, 1, 1};
int dj[] = { 0, 1, 0,-1, -1, 1,-1, 1};
bool visited[105][105];
int R,C;
char arr[105][105];
int total;
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]=='1') {total++; dfs(I,J);}
 }
 }
}

int main()
{
 int cases; cin>>cases;
 char str[105];
 gets(str); gets(str);
 while(cases--)
 {

 R = 0;
 while(gets(str)&&strlen(str)>0)
 {
 strcpy(arr[R],str);
 R++;
 }
 C = strlen(arr[0]);
 for(int i=0; i<R;i++)
 for(int j=0; j<C;j++)
 visited[i][j]=false;
 int res = 0;
 total=1;
 for(int i=0;i<R;i++)
 for(int j=0; j<C;j++)
 if(!visited[i][j] && arr[i][j]=='1')
 {
 visited[i][j]=true;
 dfs(i,j);
 res=max(res,total);
 total=1;
 }
 else visited[i][j]=true;
 printf("%d\n",res);
 if(cases!=0) printf("\n");
 }
 return 0 ;
}