Problemas de SPOJ | Isaac Lozano Osorio

ABCPATH — Spoj

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

Solución — ABCPATH

#include <bits/stdc++.h>
using namespace std;
int row, col;
char map1[51][51];
int visited[51][51];
int result;
int dx[8] = {1, 1, 1, 0, 0, -1, -1,-1};
int dy[8] = {1,-1, 0, 1, -1, 1, -1, 0};

void DFS(int x, int y, int count)
{
 int i=0;
 if(count>result)
 result = count;
 visited[x][y] = 1;
 for(i=0; i<8; i++)
 {
 int tempx = x + dx[i];
 int tempy = y + dy[i];
 if(tempx>=0&&tempx<row&&tempy>=0&&tempy<col&&map1[tempx][tempy]==(char)map1[x][y]+1&&!visited[tempx][tempy])
 {
 DFS(tempx, tempy, count+1);
 }
 }
}
int main()
{
 int i, j, test=0;
 while(++test)
 {
 result = 0;
 cin>>row>>col;
 if(row==0&&col==0)break;
 for(i=0; i<row; i++)
 scanf("%s", &map1[i]);
 for(i=0; i<row; i++)
 for(j=0; j<col; j++)
 {
 if(map1[i][j] == 'A')DFS(i,j,1);
 }
 printf("Case %d: %d\n", test, result);
 for(i=0; i<row; i++)
 for(j=0; j<col; j++)visited[i][j] = 0;
 }
 return 0;
}

ABSYS — Spoj

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

Solución — ABSYS

#include<bits/stdc++.h>
#define FOR(i,a,n) for(long long i=a;i<=n;i++)
#define rep(i,n) FOR(i,0,n-1)
using namespace std;
typedef long long ll;
bool check(string s){
 ll i=0;
 rep(i,s.size()){
 if(isalpha(s[i])) return false;
 }
 return true;
}
int main() {
 ll t;
 cin>>t;
 while(t--){
 string a,b,c;
 char plus,equal;
 cin>>a>>plus>>b>>equal>>c;
 ll A=-1,B=-1,C=-1;
 if(check(a)) A=atol(a.c_str());
 if(check(b)) B=atol(b.c_str());
 if(check(c)) C=atol(c.c_str());
 if(A == -1) {
 A = C-B;
 }
 else if(B == -1){
 B = C-A;
 }
 else C = A+B;
 cout<<A<<" + "<<B<<" = "<<C<<endl;
 }
 return 0;
}

ACODE — Spoj

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

Solución — ACODE

#include <bits/stdc++.h>
#define lli long long int

using namespace std;

string cad;
int memo[6005][30];
bool mark[6005][30];

int DP(int id,int prev){
 if(prev>26 || prev==0) return 0;
 if(id==cad.length()) return 1;
 int &best = memo[id][prev];
 if(mark[id][prev]) return best;
 mark[id][prev]=true;
 return best = DP( id + 1 , cad[id] - 48 ) + DP( id + 1 , prev * 10 + (cad[id] - 48) );
}

int main(){
 cin>>cad;
 while(cad!="0"){
 memset( memo , -1 ,sizeof(memo) );
 memset( mark , false ,sizeof(mark) );
 cout<<DP( 1 , cad[0] - 48 )<<'\n';
 cin>>cad;
 }
 return 0;
}

ACT — Spoj

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

Solución — ACT

#include<bits/stdc++.h>
using namespace std;
int main()
{
int t,n;
string s;
cin>>t;
while(t--)
{

cin>>n>>s;
n=s.length()-1;
cout<<s[n]<<endl;
}
return 0;
}

ADAINDEX — Spoj

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

Solución — ADAINDEX

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
const int put = 26;
struct TrieNode
{
 struct TrieNode *children[put];
 int num;
};

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

 for (unsigned int i = 0; i < key.length(); i++)
 {
 int index = key[i] - 'a';
 if (!pCrawl->children[index]) pCrawl->children[index] = getNode();
 pCrawl->num++;
 pCrawl = pCrawl->children[index];
 }
 pCrawl->num++;
}

int search(struct TrieNode *root, string key)
{
 struct TrieNode *pCrawl = root;
 for (unsigned int i = 0; i < key.length(); i++)
 {
 int index = key[i] - 'a';
 if (!pCrawl->children[index]) return 0;
 pCrawl = pCrawl->children[index];
 }
 return pCrawl->num;
}

int main()
{
 int n,m;
 while(scanf("%d%d",&n,&m)==2)
 {
 string word;
 struct TrieNode *root = getNode();
 for(int i=0; i<n;i++) {cin>>word; insert(root,word);}
 for(int i=0; i<m;i++) {cin>>word; cout<<search(root,word)<<'\n';}
 }
 return 0;
}

ADATRIP — Spoj

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

Solución — ADATRIP

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

const int MAXN = 500005;

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];
vector<pair<int,int>> V[MAXN];
int N,E,T;

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(){
 while(scanf("%d %d %d",&N,&E,&T)==3)
 {
 for(int i=0;i<=N;i++) {V[i].clear(); graph[i].clear();}
 for(int j=0;j<E;j++){
 int to,from, weight; scanf("%d %d %d", &from,&to, &weight);
 graph[from].push_back(edge(from,to,weight));
 graph[to].push_back(edge(to,from,weight));
 }
 for(int i=0; i<T;i++)
 {
 for(int i=0;i<=N;i++) dist[i]=INF;
 int arrival; scanf("%d",&arrival);
 if(V[arrival].size()!=0)
 {
 printf("%d %d\n",V[arrival][0].first,V[arrival][0].second);
 }
 else
 {
 dijkstra(arrival,N);
 map<int,int> M;
 for(int i=0; i<N;i++)
 if(dist[i]!=INF)
 M[dist[i]]++;
 int aux=-INF,aux2;
 for(auto m: M)
 if(m.first>aux){ aux=m.first; aux2=m.second;}
 printf("%d %d\n",aux,aux2);
 V[arrival].push_back(make_pair(aux,aux2));
 }
 }
 }
 return 0;
}

AGGRCOW — Spoj

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

Solución — AGGRCOW

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

int n,c;
int func(int num,int array[])
{
 int cows=1,pos=array[0];
 for (int i=1; i<n; i++)
 {
 if (array[i]-pos>=num)
 {
 pos=array[i];
 cows++;
 if (cows==c) return 1;
 }
 }
 return 0;
}
int bs(int array[])
{
 int ini=0,last=array[n-1],max=-1;
 while (last>ini)
 {
 int mid=(ini+last)/2;
 if (func(mid,array)==1)
 {
 if (mid>max) max=mid;
 ini=mid+1;
 }
 else last=mid;
 }
 return max;
}
int main()
{
 int t; cin>>t;
 while (t--)
 {
 cin>>n>>c;
 int array[n];
 for (int i=0; i<n; i++) cin>>array[i];
 sort(array,array+n);
 cout<<bs(array)<<endl;
 }
 return 0;
}

AIBOHP — Spoj

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

Solución — AIBOHP

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

#define INF 6910

bool mark[6910][6910];
int memo[6910][6910];
string s;

int DP(int begin,int end)
{
 if(begin==end) return 0;
 if(begin==end-1) return s[begin]==s[end] ? 0 : 1;
 int &best = memo[begin][end];
 if(mark[begin][end]) return best;
 mark[begin][end] = true;
 if(s[begin]==s[end])
 return best=DP(begin+1,end-1);
 return best = min(DP(begin+1,end),DP(begin,end-1))+1;
}

int main()
{
 int a;
 cin>>a;
 while(a--)
 {
 cin>>s;
 memset(mark,false,sizeof(mark));
 memset(memo,INF,sizeof(memo));
 cout<<DP(0,s.length()-1)<<endl;
 }
 return 0;
}

ALICESIE — Spoj

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

Solución — ALICESIE

#include <bits/stdc++.h>

using namespace std;

int main() {
 int t;
 long long int n;
 scanf( "%d", &t );
 while (t--) {
 scanf( "%lld", &n );
 if (n%2==0 ) {
 printf("%lld\n", n/2 );
 }
 else {
 printf( "%lld\n", n / 2 + 1 );
 }
 }
 return 0;
}

ANGELS — Spoj

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

Solución — ANGELS

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

const int SINK = 50001;
const int MAX_N = 50005;
const int INF = 0x3f3f3f3f;

int N, M;
int pair_g1[MAX_N], pair_g2[MAX_N], dist[MAX_N];
list< int > adj[MAX_N];

bool bfs() {
 queue< int > q; // queue of G1 nodes

 for (int v = 0; v < N; ++v) {
 if (pair_g1[v] == SINK) {
 dist[v] = 0;
 q.push(v);
 }
 else {
 dist[v] = INF;
 }
 }
 dist[SINK] = INF;

 while (!q.empty()) {
 int v = q.front();
 q.pop();

 if (dist[v] < dist[SINK]) {
 for (list< int >::iterator it = adj[v].begin(); it != adj[v].end(); ++it) {
 int u = *it;

 if (dist[pair_g2[u]] == INF) {
 dist[pair_g2[u]] = dist[v] + 1;
 q.push(pair_g2[u]);
 }
 }
 }
 }
 return dist[SINK] != INF;
}

bool dfs(int u) {
 // DFS starting at a node u in G1

 if (u == SINK) {
 // we've reached a free node in G2 (i.e. one pointing to SINK)
 return true;
 }

 for (list< int >::iterator it = adj[u].begin(); it != adj[u].end(); ++it) {
 int v = *it;

 if (dist[pair_g2[v]] == dist[u] + 1) {
 if (dfs(pair_g2[v])) {
 pair_g1[u] = v;
 pair_g2[v] = u;
 return true;
 }
 }
 }
 dist[u] = INF;
 return false;
}
//Bipartite Maching Problem -> O(sqrt(V)*e)
int hopcroft_karp() {
 int matching = 0;

 for (int i = 0; i < N; ++i) {
 pair_g1[i] = SINK;
 }
 for (int j = 0; j < M; ++j) {
 pair_g2[j] = SINK;
 }

 while (bfs()) {
 for (int i = 0; i < N; ++i) {
 if (pair_g1[i] == SINK) {
 matching += dfs(i);
 }
 }
 }
 return matching;
}
int main() {
 int n,m,cases; scanf("%d",&cases);
 while(cases--)
 {
 scanf("%d%d",&n,&m);
 for (int i = 0; i < N; i++) adj[i].clear();
 cin.ignore();
 char arr[n][m];
 int hori[n][m],vert[n][m];
 string car;
 for(int i=0; i<n;i++)
 for(int j=0;j<m;j++) { cin>>car; arr[i][j]=car[0];}
 int counthor = 0,colocados=0,countver=0;
 for(int i=0; i<n;i++)
 {
 for(int j=0;j<m;j++)
 {
 if(arr[i][j]=='A')
 {
 if(colocados>=1)
 {
 counthor++; colocados=0; continue;
 }
 }
 else if(arr[i][j]=='D') continue;
 else { hori[i][j]=counthor; colocados++;}
 }
 if(colocados>=1) { counthor++; colocados=0; }
 }
 colocados=0;
 for(int i=0; i<m;i++)
 {
 for(int j=0;j<n;j++)
 {
 if(arr[j][i]=='A')
 {
 if(colocados>=1)
 {
 countver++; colocados=0; continue;
 }
 }
 else if(arr[j][i]=='D') continue;
 else { vert[j][i]=countver; colocados++;}
 }
 if(colocados>=1) { countver++; colocados=0; }
 }
 N=countver; M=counthor;
 for(int i=0; i<n;i++)
 {
 for(int j=0;j<m;j++)
 {
 if(arr[i][j]=='H')
 {
 int val = vert[i][j];
 adj[val].push_back(hori[i][j]);
 }

 }
 }
 printf("%d\n",hopcroft_karp());
 }
 return 0;
}

ARDA1 — Spoj

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

Solución — ARDA1

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main()
{
 int n,m,n1,m1;
 while(scanf("%d%d",&n1,&m1)==2)
 {
 bool checked=false;
 char arr[n1][m1];
 for(int i=0; i<n1;i++)
 for(int j=0; j<m1;j++) cin>>arr[i][j];
 cin>>n>>m;
 char mapa[n][m];
 for(int i=0; i<n;i++)
 for(int j=0; j<m;j++) cin>>mapa[i][j];
 //check
 for(int i=0; i<n-n1+1;i++)
 for(int j=0; j<m-m1+1;j++)
 {
 if(mapa[i][j]==arr[0][0])
 {
 //check
 bool check = true;
 for(int i1=0; i1<n1&✓i1++)
 for(int j1=0; j1<m1&✓j1++)
 {
 if(mapa[i1+i][j1+j]!=arr[i1][j1])
 check=false;
 }
 if(check) {printf("(%d,%d)\n",i+1,j+1); checked=true;}
 }
 }
 if(!checked) cout<<"NO MATCH FOUND...\n";
 }
 return 0;
}

BEENUMS — Spoj

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

Solución — BEENUMS

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
map<long long,bool> a;

int main()
{
 a[1]=true;
 long long b=1,c=1,n;
 while(b<=1000000000)
 {
 b=3*c*(c+1)+1;
 c++;
 a[b]=true;
 }
 while(scanf("%lld",&n)==1&&n!=-1)
 {
 if(a[n]) cout<<"Y"<<endl;
 else cout<<"N"<<endl;
 }
 return 0;
}

BLINNET — Spoj

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

Solución — BLINNET

#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;
 }
 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 T,to, weight,num;
 cin>>T;
 while(T--)
 {
 vector<edge> edges;
 int p; cin>>p;
 for(int i=0; i<p;i++)
 {
 string name; cin>>name>>num;
 for(int j=0; j<num;j++)
 {
 scanf("%d %d",&to, &weight);
 edges.push_back(edge(i,to-1,weight));
 }
 }
 UF uf = UF(p);
 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.mst_sum);

 }
 return 0;
}

BRCKTS — Spoj

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

Solución — BRCKTS

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

struct node {
 long long int pa;
 long long int pc;
};
node join(node left,node right)
{
 node res;
 int n = min(left.pa, right.pc);
 res.pa = right.pa + left.pa - n;
 res.pc = left.pc + right.pc - n;
 return res;
}
void buildTree(node *tree,string a,int index,int s,int e)
{
 //base case
 if(s>e) return;
 //reached leaf node
 if(s==e)
 {
 if(a[s]==')') { tree[index].pc=1; tree[index].pa=0;}
 else { tree[index].pa=1;tree[index].pc=0; }
 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{INF,INF};
 //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);
}

void updateNode(node *tree,int index,int s,int e,int pos)
{
 if(pos<s || pos>e) return ;
 if(s==e)
 {
 if(tree[index].pc==1) { tree[index].pc=0; tree[index].pa=1; }
 else { tree[index].pc=1; tree[index].pa=0; }
 return;
 }
 int m = (s+e)/2;
 updateNode(tree,2*index,s,m,pos);
 updateNode(tree,2*index+1,m+1,e,pos);
 tree[index] = join(tree[2*index],tree[2*index+1]);
 return;
}
int main()
{
 int n,c,ca=1;
 while(scanf("%d",&n)==1)
 {
 string a;
 cin.ignore();
 getline(cin,a);
 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
 scanf("%d",&c);
 printf("Test %d:\n",ca++);
 for(int i=0; i<c;i++)
 {
 int f; scanf("%d",&f);
 if(f==0)
 {
 node aux = query(tree,index,s,e,0,n);
 if(aux.pa==0 && aux.pc==0) printf("YES\n");
 else printf("NO\n");
 }
 else updateNode(tree,index,s,e,f-1);
 }
 }
 return 0;
}

CAM5 — Spoj

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

Solución — CAM5

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

int check[100005];
queue <int> q[100005];

void dfs(int x)
{
 check[x]=1;
 int size=q[x].size();
 for(int i=0;i<size;i++)
 {
 int temp=q[x].front();
 q[x].pop();
 if(!check[temp])
 dfs(temp);
 }
}

int main()
{
 int t,n,e,x,y,count;
 cin>>t;
 while(t--)
 {
 count=0;
 memset(check,0,sizeof(check)); //Pone a 0 el array
 cin>>n>>e;
 for(int i=0;i<e;i++)
 {
 cin>>x>>y;
 q[x].push(y);
 q[y].push(x);
 }
 for(int i=0;i<n;i++)
 {
 if(!check[i])
 {
 check[i]=1;
 dfs(i);
 count++;
 }
 }
 cout<<count<<"\n";
 }
}

CANTON — Spoj

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

Solución — CANTON

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int i;
 cin>>i;
 while(i--)
 {
 int k=1,p=1,u=2;

 bool bajar=false;
 bool arriba=false;
 bool derecha=true;
 bool baja1=false;
 int m,ko;
 cin>>m;
 ko=m;
 m--;
 while(m--)
 {
 if(derecha)
 {
 p++;
 derecha=false;
 arriba=false;
 baja1=true;
 continue;
 }
 if(arriba)
 {
 k--;
 p++;
 if(p==u)
 {
 u++;
 derecha=true;
 }
 continue;
 }
 if(bajar)
 {
 k++;
 bajar=false;
 arriba=true;
 continue;
 }
 if(baja1)
 {
 p--;
 k++;
 if(k==u)
 {
 bajar=true;
 u++;
 }
 continue;
 }
 }
 cout<<"TERM "<<ko<<" IS "<<k<<"/"<<p<<endl;
 }
 return 0;
}

CAPCITY — Spoj

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

Solución — CAPCITY

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;

const int MAX = 100005;

int N, M;
int componentCount[2];
int componentID[2][MAX];
int degree[MAX];
bool visited[2][MAX];
vector<int> orders;
vector<int> Graph[MAX], reverseGraph[MAX];

void dfs1 (int node) {
 visited[0][node] = true;
 componentID[0][node] = componentCount[0];
 for (int i : reverseGraph[node]) {
 if (!visited[0][i]) {
 dfs1(i);
 }
 }
 orders.push_back(node);
}
void dfs2 (int node) {
 visited[1][node] = true;
 componentID[1][node] = componentCount[1];
 for (int i : Graph[node]) {
 if (!visited[1][i]) {
 dfs2(i);
 }
 }
}

int main(int argc, const char * argv[]) {
 scanf("%d%d", &N, &M);
 for (int i = 0; i < M; i ++) {
 int u, v;
 scanf("%d%d", &u, &v);
 Graph[u].push_back(v);
 reverseGraph[v].push_back(u);
 }
 for (int i = 1; i <= N; i ++) {
 if (!visited[0][i]) {
 componentCount[0] ++;
 dfs1(i);
 }
 }
 reverse(orders.begin(), orders.end());
 for (int i : orders) {
 if (!visited[1][i]) {
 componentCount[1] ++;
 dfs2(i);
 }
 }
 //for (int i = 1; i <= N; i ++) {
 // cout << i << " --> " << componentID[1][i] << endl;
 //}
 //cout << endl;
 for (int i = 1; i <= N; i ++) {
 for (int j : reverseGraph[i]) {
 if (componentID[1][i] != componentID[1][j]) {
 degree[componentID[1][j]] ++;
 }
 }
 }
 //for (int i = 1; i <= componentCount[1]; i ++) {
 // cout << i << " --> " << degree[i] << endl;
 //}
 int startings = 0;
 for (int i = 1; i <= componentCount[1]; i ++) {
 if (!degree[i]) {
 startings ++;
 }
 }
 if (startings > 1) {
 puts("0");
 }
 else {
 vector<int> output;
 for (int i = 1; i <= N; i ++) {
 if (!degree[componentID[1][i]]) {
 output.push_back(i);
 }
 }
 printf("%d\n", (int)output.size());
 for (int i = 0; i < (int)output.size(); i ++) {
 printf("%d", output[i]);
 if (i < (int)output.size() - 1) {
 putchar(' ');
 }
 }
 putchar('\n');
 }

 return 0;
}

CDC12_D — Spoj

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

Solución — CDC12_D

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

 int P,M,V,S,J,D; //Distancia del marciano, metros, velocidad normal, suma a velocidad si usa power, cantidad de usos, si se para lo que suma
 int memo[10005][105];
 bool mark[10005][105];

int DP(int distance, int power)
{
 if(distance<=0) return 0; //Si hemos llegado devolvemos 0
 if(power<0 || power>J) return INF; //Si es menor que cero no se contempla y no puede ser mayor que la del principio
 int &best= memo[distance][power];
 if(mark[distance][power]) return best;
 mark[distance][power]=true;
 if(power==0) return best = min(DP(distance-V,power),DP(distance,power+D))+1;
 return best = min(DP(distance-V-S,power-1),DP(distance,power+D))+1;
}
int main()
{
 int cases,cnt=1;
 cin>>cases;
 while(cases--)
 {
 cin>>P>>M>>V>>S>>J>>D;
 memset(mark,false,sizeof(mark));
 memset(memo,INF,sizeof(memo));
 int res = DP(M,J);
 if(res<P)
 cout<<"Scenario #"<<cnt<<": Ronny wins in time "<<res<<endl;
 else
 cout<<"Scenario #"<<cnt<<": Ronny will be annihilated\n";
 cnt++;
 }
 return 0;
}

CDC12_E — Spoj

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

Solución — CDC12_E

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

const int MAXN = 1000000;

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 H,W,K;

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+1;
 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 F,E;

 scanf("%d %d %d",&H,&W,&K);
 for(int i=0;i<=H*W;i++) {dist[i]=INF; graph[i].clear();}
 char arr[H][W];
 for(int i=0; i<H;i++)
 for(int j=0; j<W;j++)
 {
 cin>>arr[i][j];
 if(arr[i][j]=='R') { F=i*W+j; arr[i][j]='0'; }
 else if(arr[i][j]=='D') {E=i*W+j; arr[i][j]='0';}
 else if(arr[i][j]=='.') arr[i][j]='0';
 }
 //cout<<F<<E<<endl;
 for(int i=0; i<H;i++)
 for(int j=0; j<W;j++)
 {
 if(i+1!=H) graph[i*W+j].push_back(edge(i*W+j,(i+1)*W+j,arr[i+1][j]-48)); //cout<<i*W+j<<(i+1)*W+j<<endl; }
 if(j!=0) graph[i*W+j].push_back(edge(i*W+j,i*W+j-1,arr[i][j-1]-48)); //cout<<i*W+j<<i*W+j-1<<endl;}
 if(i!=0) graph[i*W+j].push_back(edge(i*W+j,(i-1)*W+j,arr[i-1][j]-48)); //cout<<i*W+j<<(i-1)*W+j<<endl;}
 if(j+1!=W) graph[i*W+j].push_back(edge(i*W+j,i*W+j+1,arr[i][j+1]-48)); //cout<<i*W+j<<i*W+j+1<<endl;}

 }
 int res = dijkstra(F,E);
 //cout<<res<<endl;
 if(res==-1 || res>=K) printf("Scenario #%d: Ronny will be destroyed\n",c++);
 else printf("Scenario #%d: %d\n",c++,res);
 }
 return 0;
}

CHICAGO — Spoj

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

Solución — CHICAGO

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

double grid[101][101];

int main()
{
 int n, e, u, v, i, j, k;
 double d;
 while(scanf("%d", &n)==1 && n)
 {
 scanf("%d", &e);
 memset(grid, 0, sizeof(grid));
 for(i=0; i<e; i++)
 {
 scanf("%d%d%lf", &u, &v, &d);
 grid[u][v] = grid[v][u] = d/100.0;
 }
 for(k=1; k<=n; k++)
 for(i=1; i<=n; i++)
 for(j=1; j<=n; j++)
 grid[i][j] = max(grid[i][j], grid[i][k]*grid[k][j]);
 printf("%.6lf percent\n", grid[1][n]*100.0 + 1e-10);
 }
 return 0;
}

CHMAZE — Spoj

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

Solución — CHMAZE

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

typedef pair< int, int > pii;
typedef pair< int, pii > pip;
const int ROW = 25, COL = 25, PAT = 15;
char grid[PAT][ROW][COL];
int R, C, P, dist[PAT][ROW][COL];
int dr[5] = {0, 0, 0, 1,-1};
int dc[5] = {0, 1,-1, 0, 0};

int bfs(pip start) {
 int i, r1, r2, c1, c2, p1, p2;
 queue< pip > Q;
 p1 = start.first;
 r1 = start.second.first;
 c1 = start.second.second;
 if(r1==R-1 && c1==C-1) return 0;
 grid[p1][r1][c1] = '1';
 dist[p1][r1][c1] = 0;
 Q.push(start);
 while(!Q.empty()) {
 p1 = Q.front().first;
 r1 = Q.front().second.first;
 c1 = Q.front().second.second;
 Q.pop();
 for(i=0; i<5; i++) {
 p2 = (p1+1) % P;
 r2 = r1+dr[i];
 c2 = c1+dc[i];
 if(grid[p2][r2][c2]=='0') {
 grid[p2][r2][c2] = '1';
 dist[p2][r2][c2] = dist[p1][r1][c1]+1;
 if(r2==R-1 && c2==C-1) return dist[p2][r2][c2];
 Q.push(pip(p2, pii(r2, c2)));
 }
 }
 }
 return -1;
}

int main() {
 int k, i, d, cs = 1;
 while(scanf("%d%d%d", &R, &C, &P)==3 && (R!=0||C!=0||P!=0)) {
 for(k=0; k<P; k++)
 for(i=0; i<R; i++)
 scanf("%s", grid[k][i]);
 d = bfs(pip(0, pii(0, 0)));
 if(d>=0) printf("Case %d: Luke and Leia can escape in %d steps.\n", cs++, d);
 else printf("Case %d: Luke and Leia cannot escape.\n", cs++);
 }
 return 0;
}

CISTFILL — Spoj

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

Solución — CISTFILL

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

struct Cis{
 int b,h,w,d;
};
int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 Cis a;
 vector<Cis> vec;
 int aux;
 double V,totalVolum=0,lowLevel,highLevel,Level;
 cin>>aux;
 for(int i=0; i<aux;i++)
 {
 cin>>a.b>>a.h>>a.w>>a.d;
 totalVolum+=(a.h*a.w*a.d);
 vec.push_back(a);
 }
 cin>>V;
 if(totalVolum<V) cout<<"OVERFLOW\n";
 else
 {
 lowLevel = 0.0;
 highLevel = 1e7;
 while(highLevel - lowLevel > 0.000001) {
 Level = (highLevel + lowLevel)/2;
 totalVolum = 0.0;
 for(int i=0; i<aux;i++) {
 if(vec[i].b >= Level) continue;
 else if((vec[i].b < Level) && ((vec[i].b + vec[i].h) >= Level))
 totalVolum += ((Level - vec[i].b) * (vec[i].w) * (vec[i].d));
 else if((vec[i].b + vec[i].h) < Level)
 totalVolum += ((vec[i].h) * (vec[i].w) * (vec[i].d));
 }
 if(totalVolum >= V) highLevel = Level;
 else lowLevel = Level;

 }
 printf("%.2lf\n", Level);
 }
 }
 return 0;
}

CLONE — Spoj

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

Solución — CLONE

#include <bits/stdc++.h>

using namespace std;

int main(){
 int n, m, j;
 cin>>n>>m;
 while(n != 0 && m != 0){
 map<string, int> CLONES;
 string nda;
 j = n;
 int A[n];
 for (int i = 0; i < n; ++i){
 A[i] = 0;
 }
 while(n--){
 cin >> nda;
 CLONES[nda]++;
 }
 for (map<string, int>::iterator it=CLONES.begin(); it != CLONES.end(); it++) {
 ++A[it->second - 1];
 }
 for (int i = 0; i < j; ++i){
 cout<<A[i]<<endl;
 }
 cin>>n>>m;
 }
 return 0;
}

CPRMT — Spoj

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

Solución — CPRMT

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

int main()
{
 int a_count[27];
 int b_count[27];
 string a, b;
 while(cin>>a>>b)
 {
 memset(a_count,0,sizeof(a_count));
 memset(b_count,0,sizeof(a_count));
 for(unsigned int i=0; i<a.length();i++) a_count[a[i]-'a']++;
 for(unsigned int i=0; i<b.length();i++) b_count[b[i]-'a']++;
 for(int i=0; i<26;i++)
 for(int j=0; j<min(a_count[i],b_count[i]);j++)
 {
 cout<<(char)(i+'a');
 }
 cout<<endl;
 }
 return 0;
}

CSTREET — Spoj

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

Solución — CSTREET

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

const int MAXN = 1005;

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

bool visited[MAXN];
vector<edge> graph[MAXN];
int cases,N,E,c;

int prim(int start){
 priority_queue<state> pq;
 pq.push(state(start, 0));
 int sum = 0;
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 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));
 }
 }
 return sum;
}

int main(){
 scanf("%d",&cases); c=1;
 while(cases--)
 {
 int p; cin>>p;
 scanf("%d %d",&N,&E);
 for(int i=0; i<N;i++) {visited[i]=false; graph[i].clear(); }
 for(int i=0;i<E;i++){
 int from,to,w;
 scanf("%d %d %d",&from,&to,&w);
 from--; to--;
 graph[from].push_back(edge(from,to,w*p));
 graph[to].push_back(edge(to,from,w*p));
 }
 printf("%d\n",prim(0));
 }
 return 0;
}

CTOI09_1 — Spoj

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

Solución — CTOI09_1

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

int cx[4] = {1, -1, 0, 0};
int cy[4] = {0, 0, 1, -1};

char mainMap[2000][2000];
bool reachable[2000][2000];
int beeDistance[2000][2000];

int n, s,dx, dy, mx, my;

bool test(int delay)
{
 if (delay * s >= beeDistance[mx][my]) return false;
 memset(reachable, 0, sizeof(reachable));
 deque<pair<int, pair<int, int> > > q;
 q.push_back(make_pair(delay * s, make_pair(mx, my)));
 reachable[mx][my] = true;
 while (!q.empty())
 {
 int distance = q.front().first;
 int x = q.front().second.first;
 int y = q.front().second.second;
 q.pop_front();
 if (mainMap[x][y] == 'D') return true;
 for (int c = 0; c < 4; c++)
 {
 int nx = x + cx[c];
 int ny = y + cy[c];
 if (nx < 0 || nx >= n || ny < 0 || ny >= n || mainMap[nx][ny] == 'T' || (distance + 1) >= beeDistance[nx][ny] || reachable[nx][ny]) continue;
 q.push_back(make_pair(distance + 1, make_pair(nx, ny)));
 reachable[nx][ny] = true;
 }
 }
 return false;
}
int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 cin>>n>>s;
 deque<pair<int, int> > bq;
 memset(beeDistance, -1, sizeof(beeDistance));

 for (int i = 0; i < n; i++)
 {
 cin >> ws;
 for (int j = 0; j < n; j++)
 {
 cin >> mainMap[i][j];
 if (mainMap[i][j] == 'H')
 {
 bq.push_back(make_pair(i, j));
 beeDistance[i][j] = 0;
 }
 else if (mainMap[i][j] == 'M')
 {
 mx = i;
 my = j;
 mainMap[i][j] = 'G';
 }
 else if (mainMap[i][j] == 'D')
 {
 dx = i;
 dy = j;
 }
 }
 }
 //Tiempo de las abejas llegar a otro sitio
 while (!bq.empty())
 {
 int x = bq.front().first;
 int y = bq.front().second;
 bq.pop_front();
 for (int c = 0; c < 4; c++)
 {
 int nx = x + cx[c];
 int ny = y + cy[c];
 if (nx < 0 || nx >= n || ny < 0 || ny >= n || mainMap[nx][ny] != 'G' || beeDistance[nx][ny] != -1) continue;
 beeDistance[nx][ny] = beeDistance[x][y] + s;
 bq.push_back(make_pair(nx, ny));
 }
 }
 //A su casa INF tiempo
 beeDistance[dx][dy] = INF;

 int low = -1, high = n * n;
 while (high - low > 1)
 {
 int mid = (low + high)/2;
 if (test(mid))
 low = mid;
 else
 high = mid;
 }
 cout << low << '\n';
 }
 return 0;
}

CTRICK — Spoj

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

Solución — CTRICK

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main() {
 int cases,n;
 cin>>cases;
 while(cases--) {
 cin>>n;
 queue <int> deck;
 vector <int> B;
 int C[20001];
 for(int i=1; i<=n; i++) deck.push(i);
 for(int i=1; i<=n; i++) {
 int j=i;
 while(j--) {
 int card=deck.front();
 deck.pop();
 deck.push(card);
 }
 int card=deck.front();
 deck.pop();
 B.push_back(card);
 }
 for(int i=1; i<=n; i++) C[B[i-1]]=i;
 for(int i=1;i<=n; i++) printf("%d ",C[i]);
 printf("\n");
 }
 return 0;
}

DAVIDG — Spoj

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

Solución — DAVIDG

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

const int MAXN = 1005;

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

bool visited[MAXN];
int arr1[MAXN];
int arr2[MAXN];
int dist[MAXN];
int cases,N,E,c;

int prim(int start){
 priority_queue<state> pq;
 pq.push(state(start, 0));
 int sum = 0;
 dist[start]=0;
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(visited[cur.node] || cur.dist > dist[cur.node]) continue;
 sum += cur.dist;
 visited[cur.node] = true;
 for(int i=0;i<N;i++){
 if(visited[i] || i==cur.node) continue;
 int dista = ceil(sqrt(pow(arr1[i]-arr1[cur.node],2)+pow((arr2[i]-arr2[cur.node]),2))*E);
 if(dist[i] > dista)
 {
 dist[i]=dista;
 pq.push(state(i,dista));
 }
 }
 }
 return sum;
}

int main(){
 scanf("%d",&cases); c=1;
 while(cases--)
 {
 scanf("%d %d",&N,&E);
 for(int i=0;i<N;i++){
 dist[i]=INF;
 visited[i]=false;
 scanf("%d %d",&arr1[i],&arr2[i]);
 }
 int res = prim(0);
 printf("Scenario #%d: %d\n",c++,(res%100000007));
 }
 return 0;
}

DICT — Spoj

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

Solución — DICT

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

const int put = 26; //alphabet size
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;
}
void insert(struct TrieNode *root, string key)
{
 struct TrieNode *pCrawl = root;
 for (unsigned int i = 0; i < key.length(); i++)
 {
 int index = key[i] - 'a';
 if (!pCrawl->children[index]) pCrawl->children[index] = getNode();
 pCrawl->num++;
 pCrawl = pCrawl->children[index];
 }
 pCrawl->isEndOfWord = true;
}

int search(struct TrieNode *root, string key) {
 struct TrieNode *pCrawl = root;
 for (unsigned int i = 0; i < key.length(); i++)
 {
 int index = key[i] - 'a';
 if (!pCrawl->children[index]) return 0;
 pCrawl = pCrawl->children[index];
 }
return pCrawl->num;
}
char str[26000];
int sizel;
void display(struct TrieNode* root, char str[], int level)
{
 if (root->isEndOfWord && sizel!=level) { str[level] = '\0'; cout << str << endl;}
 for (int i = 0; i < put; i++)
 {
 if (root->children[i])
 {
 str[level] = i + 'a';
 display(root->children[i], str, level + 1);
 }
 }
}
void searchPrefix(struct TrieNode *root, string key) {
 struct TrieNode *pCrawl = root;
 for (unsigned int i = 0; i < key.length(); i++)
 {
 str[i]=key[i];
 int index = key[i] - 'a';
 pCrawl = pCrawl->children[index];
 }
 sizel=key.length();
 display(pCrawl,str,key.length());
 memset(str,'\0',sizeof(str));
}

int main(){
 int n,m,c=1;
 while(scanf("%d",&n)==1)
 {
 string word; struct TrieNode *root = getNode();
 for(int i=0; i<n;i++) {cin>>word; insert(root,word);}
 scanf("%d",&m);
 for(int i=0; i<m;i++) {
 cin>>word;
 int aux = search(root,word);
 printf("Case #%d:\n",c++);
 if(aux==0) printf("No match.\n");
 else searchPrefix(root,word);
 }
 }
 return 0;
}

DISUBSTR — Spoj

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

Solución — DISUBSTR

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

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)
 long long int res = 0;
 for (int i = 1; i < n; i++)
 {
 //printf("%2d\t%2d\t%s\n", i, LCP[i],T + SA[i]);
 string a = T + SA[i];
 res+= a.length()-LCP[i]-1;
 }
 printf("%lld\n",res);
 }
 return 0;
}

DQUERY — Spoj

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

Solución — DQUERY

#include <bits/stdc++.h>
using namespace std;
const int MAX = 300005;
const int MAX1 = 1e6+5;
int BIT[MAX], p[MAX1], ans[MAX], a[MAX];
pair <int, pair<int, int> > pr[MAX];

void update(int idx, int val)
{
 while(idx < MAX)
 {
 BIT[idx] += val;
 idx += (idx & -idx);
 }
}

int read(int idx)
{
 int sum = 0;
 while(idx > 0)
 {
 sum += BIT[idx];
 idx -= (idx & -idx);
 }
 return sum;
}

int main()
{
 int n, q, x;
 while(scanf("%d", &n)==1)
 {
 for(int i = 1;i <= n;++i) scanf("%d", &a[i]);
 scanf("%d", &q);
 for(int i = 0;i < q;i++)
 {
 scanf("%d %d", &pr[i].second.first, &pr[i].first);
 pr[i].second.second = i;
 }
 sort(pr, pr + q);
 memset(p, -1, sizeof(p));
 memset(BIT, 0, sizeof(BIT));
 x = 0;
 for(int i = 1;i <= n;i++)
 {
 if(p[a[i]] != -1) update(p[a[i]], -1);
 p[a[i]] = i;
 update(i, 1);
 while(x < q and pr[x].first == i)
 {
 ans[pr[x].second.second] = read(pr[x].first) - read(pr[x].second.first-1);
 x++;
 }
 }
 for(int i = 0;i < q; i++) printf("%d\n", ans[i]);
 }
 return 0;
}

DRAWM — Spoj

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

Solución — DRAWM

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

int main()
{
 int cases,num,last;
 char arr[71][71];
 while(scanf("%d",&cases)==1&&cases!=-1)
 {
 int maxi=0,mini=INF,actual,flag=5;
 memset(arr,0x20,sizeof(arr));
 cin>>last;
 actual=70-last;
 last=70-last;
 for(int i=0; i<cases;i++) //column
 {

 cin>>num; //row
 num=70-num;
 if(last==num)
 {
 if(flag==2) actual--;
 arr[actual][i]='_';
 flag=3;
 }
 else if(last>num)
 {
 if(flag!=3) actual--;
 arr[actual][i]='/';
 flag=2;
 }
 else if(last<num)
 {
 if(flag==3) actual++;
 arr[actual][i]='\\';
 flag=3;
 }
 last=num;
 mini=min(mini,actual);
 maxi=max(maxi,actual);
 }
 //print
 for(int i=mini; i<maxi+1;i++)
 {
 for(int j=0; j<cases;j++)
 cout<<arr[i][j];
 cout<<'\n';
 }
 cout<<"***\n";
 }
 return 0;
}

EC_MODE — Spoj

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

Solución — EC_MODE

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

const int MAXN = 1005;
int cases,N,E,r,w,u,v;

struct edge{
 int from, to ,aux;
 double weight;
 edge(){}
 edge(int a, int b, double c, int d){
 from = a;
 to = b;
 weight = c;
 aux=d;
 }
 bool operator<(const edge &other)const{ // sobrecarga de operadores para ordenar
 return weight < other.weight;
 }
};
vector<edge> graph;
vector<pair<int,int>> edges;
struct UF{
 int parents[MAXN];
 int sz[MAXN];
 int components;
 double res2;
 double res1;
 UF(int n){
 for(int i=0;i<n;i++){
 parents[i] = i; sz[i] = 1;
 }
 components = n;
 res2=res1=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, double weight, double aux){
 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];
 }
 if(aux==1) res1+=weight;
 else res2 += weight;
 components--;
 }
};

int main(){
 int c=1;
 scanf("%d",&cases);
 while(cases--)
 {
 graph.clear();
 edges.clear();
 scanf("%d %d %d %d %d",&N,&r,&w,&u,&v);
 UF uf = UF(N);
 for(int i=0;i<N;i++){
 int x,y;
 scanf("%d%d",&x,&y);
 edges.push_back(make_pair(x,y));
 }
 for(int i=0;i<N;i++)
 {
 for(int j=i+1;j<N;j++)
 {
 double d = sqrt(pow((edges[i].first - edges[j].first),2)+pow((edges[i].second - edges[j].second),2));
 int daux;
 if(d>r) { d*=v; daux=1;}
 else { d*=u; daux=0;}
 graph.push_back(edge(i,j,d,daux));
 }
 }
 sort(graph.begin(), graph.end());
 for(unsigned int i=0; i<graph.size();i++)
 if(uf.components==w || uf.components==1) break;
 else uf.connect(graph[i].from, graph[i].to, graph[i].weight , graph[i].aux);
 printf("Caso #%d: %.3f %.3f\n",c++,uf.res2,uf.res1);
 }
 return 0;
}

EDIST — Spoj

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

Solución — EDIST

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

string str1,str2;

int editDist(int m ,int n)
{
 int dp[m+1][n+1];
 for (int i=0; i<=m; i++)
 for (int j=0; j<=n; j++)
 {

 if (i==0) dp[i][j] = j;
 else if (j==0) dp[i][j] = i;
 else if (str1[i-1] == str2[j-1]) dp[i][j] = dp[i-1][j-1];
 else dp[i][j] = 1 + min(dp[i][j-1],min(dp[i-1][j],dp[i-1][j-1]));
 }
 return dp[m][n];
}


int main() {
 int cases; cin>>cases;
 while(cases--)
 {
 cin>>str1>>str2;
 printf("%d\n",editDist(str1.length(),str2.length()));
 }
 return 0;
}

ELEVTRBL — Spoj

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

Solución — ELEVTRBL

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

int main() {
 queue<int> Q;
 vector<int> visited(1000000);
 int d,u,s,g,f;
 cin>>f>>s>>g>>u>>d;
 if(s==g)
 printf("0\n");
 else
 {
 visited[s]=1;
 Q.push(s);
 while(!Q.empty())
 {

 int k=Q.front();
 Q.pop();

 if((k+u)<=f && visited[k+u]==0)
 {
 visited[k+u]=visited[k]+1;
 Q.push(k+u);
 }
 if((k-d)>=1 && visited[k-d]==0)
 {
 visited[k-d]=visited[k]+1;
 Q.push(k-d);
 }
 }
 if(visited[g]!=0)
 printf("%d\n",visited[g]-1);
 else
 printf("use the stairs\n");
 }
 return 0;
}

FASHION — Spoj

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

Solución — FASHION

#include <bits/stdc++.h>

using namespace std;

int main()
{
 int n;
 cin>>n;
 while(n--)
 {
 int p,sol=0;
 cin>>p;
 int m[p];
 int f[p];
 for(int i=0;i<p;i++)
 {
 cin>>m[i];
 }
 for(int i=0;i<p;i++)
 {
 cin>>f[i];
 }
 sort(f, f + p);
 sort(m, m + p);
 for(int i=0;i<p;i++)
 {
 sol+=(m[i]*f[i]);
 }
 cout<<sol<<endl;
 }
 return 0;
}

FASTFLOW — Spoj

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

Solución — FASTFLOW

// Adjacency list implementation of FIFO push relabel maximum flow
// with the gap relabeling heuristic. This implementation is
// significantly faster than straight Ford-Fulkerson. It solves
// random problems with 10000 vertices and 1000000 edges in a few
// seconds, though it is possible to construct test cases that
// achieve the worst-case.
//
// Running time:
// O(|V|^3)
//
// INPUT:
// - graph, constructed using AddEdge()
// - source
// - sink
//
// OUTPUT:
// - maximum flow value
// - To obtain the actual flow values, look at all edges with
// capacity > 0 (zero capacity edges are residual edges).

#include <cmath>
#include <vector>
#include <iostream>
#include <queue>

using namespace std;

typedef long long LL;

struct Edge {
 int from, to, cap, flow, index;
 Edge(int from, int to, int cap, int flow, int index) :
 from(from), to(to), cap(cap), flow(flow), index(index) {}
};

struct PushRelabel {
 int N;
 vector<vector<Edge> > G;
 vector<LL> excess;
 vector<int> dist, active, count;
 queue<int> Q;

 PushRelabel(int N) : N(N), G(N), excess(N), dist(N), active(N), count(2*N) {}

 void AddEdge(int from, int to, int cap) {
 G[from].push_back(Edge(from, to, cap, 0, G[to].size()));
 if (from == to) G[from].back().index++;
 G[to].push_back(Edge(to, from, 0, 0, G[from].size() - 1));
 }

 void Enqueue(int v) {
 if (!active[v] && excess[v] > 0) { active[v] = true; Q.push(v); }
 }

 void Push(Edge &e) {
 int amt = int(min(excess[e.from], LL(e.cap - e.flow)));
 if (dist[e.from] <= dist[e.to] || amt == 0) return;
 e.flow += amt;
 G[e.to][e.index].flow -= amt;
 excess[e.to] += amt;
 excess[e.from] -= amt;
 Enqueue(e.to);
 }

 void Gap(int k) {
 for (int v = 0; v < N; v++) {
 if (dist[v] < k) continue;
 count[dist[v]]--;
 dist[v] = max(dist[v], N+1);
 count[dist[v]]++;
 Enqueue(v);
 }
 }

 void Relabel(int v) {
 count[dist[v]]--;
 dist[v] = 2*N;
 for (int i = 0; i < G[v].size(); i++)
 if (G[v][i].cap - G[v][i].flow > 0)
 dist[v] = min(dist[v], dist[G[v][i].to] + 1);
 count[dist[v]]++;
 Enqueue(v);
 }

 void Discharge(int v) {
 for (int i = 0; excess[v] > 0 && i < G[v].size(); i++) Push(G[v][i]);
 if (excess[v] > 0) {
 if (count[dist[v]] == 1)
 Gap(dist[v]);
 else
 Relabel(v);
 }
 }

 LL GetMaxFlow(int s, int t) {
 count[0] = N-1;
 count[N] = 1;
 dist[s] = N;
 active[s] = active[t] = true;
 for (int i = 0; i < G[s].size(); i++) {
 excess[s] += G[s][i].cap;
 Push(G[s][i]);
 }

 while (!Q.empty()) {
 int v = Q.front();
 Q.pop();
 active[v] = false;
 Discharge(v);
 }

 LL totflow = 0;
 for (int i = 0; i < G[s].size(); i++) totflow += G[s][i].flow;
 return totflow;
 }
};

// BEGIN CUT
// The following code solves SPOJ problem #4110: Fast Maximum Flow (FASTFLOW)

int main() {
 int n, m;
 scanf("%d%d", &n, &m);

 PushRelabel pr(n);
 for (int i = 0; i < m; i++) {
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 if (a == b) continue;
 pr.AddEdge(a-1, b-1, c);
 pr.AddEdge(b-1, a-1, c);
 }
 printf("%Ld\n", pr.GetMaxFlow(0, n-1));
 return 0;
}

// END CUT

FEENTREE — Spoj

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

Solución — FEENTREE

#include <bits/stdc++.h>
using namespace std;
#define MAX 100005
long long bit[MAX];

long long query(int indx){
 long long sum = 0;
 while (indx) {
 sum += bit[indx];
 indx -= (indx & -indx);
 }
 return sum;
}

void update(int indx, int x){
 while (indx < MAX) {
 bit[indx] += x;
 indx += (indx & -indx);
 }
}

int main() {
 int n;
 while(scanf("%d",&n)==1)
 {
 long long a[n+1];
 for (int i = 1; i <= n; i++) { //EMPEZAR EN 1
 scanf("%lld",&a[i]);
 update(i, a[i]);
 }
 int q; scanf("%d",&q);
 while (q--) {
 string choice;
 cin >> choice;
 if (choice == "q") {
 int l, r;
 scanf("%d%d",&l,&r);
 printf("%lld\n",query(r) - query(l-1));
 } else {
 int p; long long int x;
 scanf("%d%lld",&p,&x);
 update(p, x);
 }
 }
 }
}

FISHER — Spoj

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

Solución — FISHER


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

const int MAXN = 105;

int T[MAXN][MAXN];
int cost[MAXN][MAXN];
int dis[MAXN][10*MAXN];
int N,A;
void solve()
{
 priority_queue<pair<int,int> > pq ;
 pq.push(make_pair(0,1)) ;
 dis[1][0] = 0 ;
 while( !pq.empty() )
 {
 pair<int,int> now ;
 now = pq.top();
 pq.pop();
 for (int i=1 ; i <= N ; i++ )
 {
 if( i == now.second || (now.first+T[now.second][i])>A ) continue ;
 int tt = now.first + T[now.second][i];
 if( dis[i][tt] > dis[now.second][now.first] + cost[now.second][i] )
 {
 dis[i][tt] = dis[now.second][now.first] + cost[now.second][i];
 pq.push( make_pair( tt , i ) ) ;
 }
 }
 }
}
int main()
{
 while(scanf("%d %d",&N,&A) == 2 && (N!=0 || A!=0))
 {
 for (int i =1; i <= N; i++)
 for (int j=0; j<=A; j++) dis[i][j] = INF ;
 for (int i=1; i<=N; i++)
 for (int j=1; j<=N; j++) scanf("%d",&T[i][j]);
 for (int i=1; i<=N; i++)
 for (int j=1; j<=N; j++) scanf("%d",&cost[i][j]);
 solve();
 int ans = INF , aux;
 for (int i=0; i<=A; i++)
 {
 if(ans > dis[N][i] )
 {
 ans = dis[N][i];
 aux = i ;
 }
 }
 if(ans==INF) printf("-1\n");
 else printf("%d %d\n",ans,aux);
 }

 return 0;
}

FPOLICE — Spoj

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

Solución — FPOLICE

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

const int MAXN = 105;

int T[MAXN][MAXN];
int cost[MAXN][MAXN];
int dis[MAXN][10*MAXN];
int N,A;
void solve()
{
 priority_queue<pair<int,int> > pq ;
 pq.push(make_pair(0,1)) ;
 dis[1][0] = 0 ;
 while( !pq.empty() )
 {
 pair<int,int> now ;
 now = pq.top();
 pq.pop();
 for (int i=1 ; i <= N ; i++ )
 {
 if( i == now.second || (now.first+T[now.second][i])>A ) continue ;
 int tt = now.first + T[now.second][i];
 if( dis[i][tt] > dis[now.second][now.first] + cost[now.second][i] )
 {
 dis[i][tt] = dis[now.second][now.first] + cost[now.second][i];
 pq.push( make_pair( tt , i ) ) ;
 }
 }
 }
}
int main()
{
 int cases;cin>>cases;
 while(cases--)
 {
 scanf("%d %d",&N,&A);
 for (int i =1; i <= N; i++)
 for (int j=0; j<=A; j++) dis[i][j] = INF ;
 for (int i=1; i<=N; i++)
 for (int j=1; j<=N; j++) scanf("%d",&T[i][j]);
 for (int i=1; i<=N; i++)
 for (int j=1; j<=N; j++) scanf("%d",&cost[i][j]);
 solve();
 int ans = INF , aux;
 for (int i=0; i<=A; i++)
 {
 if(ans > dis[N][i] )
 {
 ans = dis[N][i];
 aux = i ;
 }
 }
 if(ans==INF) printf("-1\n");
 else printf("%d %d\n",ans,aux);
 }

 return 0;
}

FREQUENT — Spoj

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

Solución — FREQUENT

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

GEORGE — Spoj

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

Solución — GEORGE

#include<bits/stdc++.h>

using namespace std;

#define Road pair<int, int>
#define cost first
#define id second

int N, M, A, B, K, G;
vector<Road> graph[1010];

int vis[1010];
int blocked[1001][1001][4];

int wait_time(int ct, int s, int d){
 if (d<s){
 int tmp = s;
 s = d;
 d = tmp;
 }
 if (ct>=blocked[s][d][0]&&ct<=blocked[s][d][1]){
 return blocked[s][d][1]-ct+1;
 }
 else if (ct>=blocked[s][d][2]&&ct<=blocked[s][d][3]){
 return blocked[s][d][3]-ct+1;
 }
 else return 0;
}

int dijkstra(int s, int d){
 memset(vis, 0, sizeof vis);
 priority_queue<Road, vector<Road>, greater<Road> > pq;
 pq.push(Road(K,s));
 while(!pq.empty()){
 Road r = pq.top();
 pq.pop();
 if (r.id==d)
 return r.cost;
 if (vis[r.id])
 continue;
 vis[r.id] = 1;
 for (int i=0;i<graph[r.id].size();i++){
 Road r1 = graph[r.id][i];
 pq.push(Road(r.cost+wait_time(r.cost,r.id,r1.id)+r1.cost,r1.id));
 }
 }
 return -1;
}

int main(){
 int x,y,z;
 memset(blocked, -1, sizeof blocked);
 scanf("%d %d", &N, &M);
 scanf("%d %d %d %d", &A, &B, &K, &G);
 vector<int> path;
 for (int i=0;i<G;i++){
 scanf("%d",&x);
 path.push_back(x);
 }
 for (int i=0;i<M;i++){
 scanf("%d %d %d", &x, &y, &z);
 graph[x].push_back(Road(z,y));
 graph[y].push_back(Road(z,x));
 }
 int ct = 0;
 for (int i=0;i<G-1;i++){
 x = path[i];
 y = path[i+1];
 if (y<x){
 int tmp = x;
 x = y;
 y = tmp;
 }
 for (int i=0;i<graph[x].size();i++){
 Road r = graph[x][i];
 if (r.id==y){
 if (blocked[x][y][0]==-1){
 blocked[x][y][0] = ct;
 blocked[x][y][1] = ct+r.cost-1;
 }
 else{
 blocked[x][y][2] = ct;
 blocked[x][y][3] = ct+r.cost-1;
 }
 ct += r.cost;
 break;
 }
 }
 }
 printf("%d\n",dijkstra(A,B)-K);
 return 0;
}

GSS1 — Spoj

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

Solución — GSS1

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

struct node {
 long long int m;
 long long int ml;
 long long int mr;
 long long int s;
};
node join(node left,node right)
{
 /*
 Maximum sum of a subarray, starting at the leftmost index of this range
 Maximum sum of a subarray, ending at the rightmost index of this range
 Maximum sum of any subarray in this range
 Sum of all elements in this range
 */
 node res;
 res.s = left.s+right.s;
 res.ml = max(left.ml,left.s+right.ml);
 res.mr = max(right.mr,right.s+left.mr);
 res.m = max(res.ml, max(res.mr, max(left.m, max(right.m, left.mr + right.ml))));

 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].m=tree[index].mr=tree[index].ml=tree[index].s=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);
 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{-INF,-INF,-INF,-INF};
 //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)
 {
 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
 scanf("%d",&c);
 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).m);
 }
 }
 return 0;
}

GSS3 — Spoj

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

Solución — GSS3

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

struct node {
 long long int m;
 long long int ml;
 long long int mr;
 long long int s;
};
node join(node left,node right)
{
 /*
 Maximum sum of a subarray, starting at the leftmost index of this range
 Maximum sum of a subarray, ending at the rightmost index of this range
 Maximum sum of any subarray in this range
 Sum of all elements in this range
 */
 node res;
 res.s = left.s+right.s;
 res.ml = max(left.ml,left.s+right.ml);
 res.mr = max(right.mr,right.s+left.mr);
 res.m = max(res.ml, max(res.mr, max(left.m, max(right.m, left.mr + right.ml))));

 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].m=tree[index].mr=tree[index].ml=tree[index].s=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);
 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{-INF,-INF,-INF,-INF};
 //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);
}

void updateNode(node *tree,int index,int s,int e,int pos,int val)
{
 if(pos<s || pos>e) return ;
 if(s==e)
 {
 tree[index].m=tree[index].mr=tree[index].ml=tree[index].s=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] = join(tree[2*index],tree[2*index+1]);
 return;
}
int main()
{
 int n,c;
 while(scanf("%d",&n)==1)
 {
 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
 scanf("%d",&c);
 for(int i=0; i<c;i++)
 {
 int j,k,f; scanf("%d %d %d",&f,&j,&k);
 if(f==1) printf("%lld\n",query(tree,index,s,e,j-1,k-1).m);
 else updateNode(tree,index,s,e,j-1,k);
 }
 }
 return 0;
}

HIGHWAYS — Spoj

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

Solución — HIGHWAYS

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

const int MAXN = 100005;

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

vector<edge> graph[MAXN];
int dis[MAXN];
int N,E;

int dijkstra(int s, int d){
 queue<int> q;
 memset(dis,INF,sizeof(dis));
 dis[s] = 0;
 q.push(s);
 while(!q.empty()){
 int node = q.front();
 q.pop();
 for(unsigned int i=0;i<graph[node].size();i++){
 int nextNode = (graph[node][i]).to;
 if(dis[nextNode] > dis[node] + graph[node][i].weight){
 q.push(nextNode);
 dis[nextNode] = dis[node] + graph[node][i].weight;
 }
 }
 }
 return dis[d];
}

int main(){
 int cases; cin>>cases;
 while(cases--)
 {
 int F, En;
 scanf("%d %d %d %d",&N,&E, &F,&En);
 for(int i=1;i<=N;i++) { graph[i].clear(); }
 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));
 }
 int res = dijkstra(F,En);
 if (res==INF) printf("NONE\n");
 else printf("%d\n",res);
 }
 return 0;
}

HISIX — Spoj

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

Solución — HISIX

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

const int MAXN = 200002;

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 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--)
 {
 scanf("%d",&N);
 for(int i=0;i<=N*2;i++) { dist[i]=INF; graph[i].clear(); }
 map<string,int> M;
 int count=1;
 for(int i=0; i<N;i++)
 {
 string n1,n2; int weight; cin>>n1>>n2>>weight;
 if(M[n1]==0) {M[n1]=count; count++;}
 if(M[n2]==0) {M[n2]=count; count++;}
 graph[M[n1]].push_back(edge(M[n1],M[n2],weight));
 graph[M[n2]].push_back(edge(M[n2],M[n1],weight));
 }
 int T=-INF;
 for(int i=1; i<count;i++)
 {
 dijkstra(i,count);
 for(int i=1;i<count;i++) { T=max(T,dist[i]); dist[i]=INF;}
 }
 if(T==INF) printf("Case #%d: INFINITE\n",c++);
 else printf("Case #%d: %d\n",c++,T);
 }
 return 0;
 }

HOMO — Spoj

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

Solución — HOMO

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

string check(int hete, int homo)
{
 if(hete>1 && homo==0) return "hetero";
 else if(homo>0 && hete<2) return "homo";
 else if(hete>1&&homo>0) return "both";
 return "neither";

}
int main()
{
int cases;
while(scanf("%d",&cases)==1)
{
 int hete=0,homo=0;
 map<int,int> M;
 string name;
 int num;
 for(int i=0; i<cases;i++)
 {
 cin>>name>>num;
 if(name=="insert") { M[num]++; if(M[num]==2) homo++; else if(M[num]==1) hete++; }
 else
 if(M[num]>1) {M[num]--; if(M[num]==1) homo--; }
 else if(M[num]==1){ M.erase(num); hete--;}
 cout<<check(hete,homo)<<"\n";
 }
}
return 0;
}

IGALAXY — Spoj

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

Solución — IGALAXY

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

vector<int> graph[200005];
bool visited[200005];
vector<int> sols;
vector<string> aux;

vector<int> compare(vector<int> a, vector<int> b,int dest)
{
 for(unsigned int i=0; i<min(a.size(),b.size());i++)
 {
 int aures = strcmp(aux[a[i]-1].c_str(),aux[b[i]-1].c_str());
 if(aures<0) return a;
 else if(aures>0) break;
 }
 if(b[b.size()-1]!=dest)
 b.push_back(dest);
 return b;
}
int BFS2(int start, int target){
 queue<int> q;
 q.push(start);
 visited[start] = true;
 while(!q.empty()){
 int aux = q.front(); q.pop();
 for(unsigned int i=0;i<graph[aux].size();i++){
 int dest = graph[aux][i];
 if(visited[dest]) continue;
 if(dest == target) return 1;
 visited[dest]=true;
 q.push(dest);
 }
 }
 return -1;
}
int BFS(int start, int target){
 vector<int> solsAUX;
 map <int,int> M;
 int res=INF;
 queue<pair<vector<int>,map<int,int>> > q;
 solsAUX.push_back(start);
 M[start]=1;
 q.push(make_pair(solsAUX,M));
 while(!q.empty()){
 pair<vector<int>,map<int,int>> current = q.front(); q.pop();
 int si= current.first.size()+1;
 int aux = current.first[si-2];
 if(res>=si)
 {
 for(unsigned int i=0;i<graph[aux].size();i++){
 int dest = graph[aux][i];
 if(current.second[dest]!=0) continue;
 if(dest == target) { if(res==si) sols=compare(sols,current.first,dest);
 else { sols=current.first; sols.push_back(dest);}
 res=si;
 }
 else {current.second[dest]=1; current.first.push_back(dest); q.push(make_pair(current.first,current.second)); current.first.erase(current.first.end()-1); }
 }
 }
 }
 return res;
}

int main()
{
 //freopen("C:/Users/Isaac/Desktop/in.txt","r",stdin);
 //freopen("C:/Users/Isaac/Desktop/out.txt","w",stdout);
 int n,s=0,cases=1;
 string a,b,D,F;
 cin>>n;
 while(n--)
 {
 cin>>s;
 memset(visited,false,sizeof(visited));
 aux.clear();
 sols.clear();
 for(int i=0; i<=s*2+2;i++)
 graph[i].clear();
 int count=1;
 map<string,int> M;
 for(int i=0; i<s;i++)
 {
 cin>>a>>b;
 if(M[a]==0) {M[a]=count; aux.push_back(a); count++; }
 if(M[b]==0) {M[b]=count; aux.push_back(b); count++; }
 graph[M[a]].push_back(M[b]);
 graph[M[b]].push_back(M[a]);
 //cout<<M[a]<<" -> "<<M[b]<<endl;
 }
 cin>>D>>F;
 int result = INF;
 if(M[D]!=0 && M[F]!=0)
 if(BFS2(M[D],M[F])==1)
 result = BFS(M[D],M[F]);
 if(result==INF) printf("Scenario #%d: -1\n",cases++);
 else {
 printf("Scenario #%d: %d\n",cases++,result);
 for(unsigned int i=0; i<sols.size();i++)
 {
 if(i==0)cout<<aux[sols[i]-1];
 else cout<<" "<<aux[sols[i]-1];
 }
 cout<<'\n';
 }
 }
 return 0;
}

IITWPC4I — Spoj

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

Solución — IITWPC4I

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

const int MAXN = 100005;
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,N,E; scanf("%d",&cases);
 while(cases--)
 {
 scanf("%d %d",&N,&E);
 UF uf = UF(N+1);
 vector<edge> edges;
 int arr[N];
 for(int i=0; i<N;i++) cin>>arr[i];
 for(int i=0; i<N;i++) if(arr[i]!=0) edges.push_back(edge(i,N,0));
 for(int i=0;i<E;i++){
 int from,to,w;
 scanf("%d %d %d",&from,&to,&w);
 from--; to--;
 edges.push_back(edge(from,to,w));
 }
 long long int res=0;
 sort(edges.begin(), edges.end());
 for(unsigned int i=0;i<edges.size();i++)
 {
 if(!uf.isConnected(edges[i].from,edges[i].to))
 {
 res+=edges[i].weight;
 uf.connect(edges[i].from, edges[i].to, edges[i].weight);
 }
 }
 int flag=0;
 for(int i=1; i<=N&&flag==0;i++)
 if (!uf.isConnected(0, i)) flag=1;
 if(flag==1) printf("impossible\n");
 else printf("%lld\n",res);
 }
 return 0;
}

INVCNT — Spoj

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

Solución — INVCNT

#include <bits/stdc++.h>
using namespace std;
#define MAX 1000005
long long bit[MAX];

long long query(int indx){
 long long sum = 0;
 while (indx) {
 sum += bit[indx];
 indx -= (indx & -indx);
 }
 return sum;
}

void update(int indx, int x){
 while (indx <= MAX) {
 bit[indx] += x;
 indx += (indx & -indx);
 }
}

int main() {
 int n,cases; scanf("%d",&cases);
 while(cases--)
 {
 cin.ignore();
 memset(bit,0,sizeof(bit));
 scanf("%d",&n);
 long long a[n], b[n];
 long long int inv = 0;
 for (int i = 0; i <n; i++) scanf("%lld",&a[i]);
 //coordinate compression-O(nlog(n)) time
 for(int i=0;i<n;i++)
 b[i]=a[i];
 sort(b, b + n);
 for (int i = 0; i < n; i++)
 a[i] = int(lower_bound(b, b + n, a[i]) - b) + 1;
 for (int i = n-1; i >= 0; i--) {
 inv+=query(a[i]-1);
 update(a[i],1);
 }
 printf("%lld\n",inv);
 }
}

JRIDE — Spoj

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

Solución — JRIDE


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

int main(){
 int roads,cases=1; scanf("%d",&roads);
 while(roads--){
 int stops,first=0,last=0,sol=0,curSol=0,correctFirst=0,curLength=1,maxLength=0; scanf("%d",&stops);
 for(int i=0; i<stops-1;i++) {
 int val; scanf("%d",&val);
 curSol+=val;
 if(curSol<0) { first=i+1; curSol=0; curLength=0; }
 else{
 if(sol==curSol && curLength>maxLength) { correctFirst=first; last=i; maxLength=curLength;}
 else if(sol<curSol) { correctFirst=first; last=i; sol=curSol; maxLength=curLength; }
 }
 curLength++;
 }
 if(sol==0) printf("Route %d has no nice parts\n",cases);
 else printf("The nicest part of route %d is between stops %d and %d\n",cases,correctFirst+1,last+2);
 cases++;
 }
 return 0;
}

/*
28
6
1
0
0
0
1
6
1
0
0
1
-1
10
4
-5
4
-3
4
4
-4
4
-5
10
4
-5
4
-3
4
4
-4
4
5
6
-1
1
-1
1
-1
6
1
-1
1
-1
1
11
1
-1
1
-1
1
-1
1
-1
1
-1
12
1
-1
1
-1
1
-1
1
-1
1
-1
1
7
1
-1
1
-100
1
-1
6
-7
9
15
-16
100
6
-1
-1
-1
-1
6
8
-1
-1
-1
-1
6
-1
7
8
-1
-1
-1
-1
6
-1
7
9
100
-50
-60
-70
-6
-6
-5
-4
6
-4
-3
-2
100
200
4
1
2
3
4
-1000
100
1
2
13
5
1
2
-3
4
3
-19
19
8
1
4
1
3
5
-7
100
4
1
3
5
3
-1 6
10
4 -5 4 1 -10 4 -5 4 1
4
-2 -3 -4
3
-1 6
11
4 -5 4 1 -10 4 -5 2 2 1
4
-2 -3 -4


The nicest part of route 1 is between stops 1 and 6
The nicest part of route 2 is between stops 1 and 5
The nicest part of route 3 is between stops 3 and 9
The nicest part of route 4 is between stops 3 and 10
The nicest part of route 5 is between stops 2 and 5
The nicest part of route 6 is between stops 1 and 6
The nicest part of route 7 is between stops 1 and 10
The nicest part of route 8 is between stops 1 and 12
The nicest part of route 9 is between stops 1 and 4
The nicest part of route 10 is between stops 2 and 6
The nicest part of route 11 is between stops 5 and 6
The nicest part of route 12 is between stops 5 and 8
The nicest part of route 13 is between stops 5 and 8
The nicest part of route 14 is between stops 1 and 2
The nicest part of route 15 is between stops 4 and 6
The nicest part of route 16 is between stops 1 and 4
The nicest part of route 17 is between stops 2 and 4
The nicest part of route 18 is between stops 1 and 2
The nicest part of route 19 is between stops 1 and 5
The nicest part of route 20 is between stops 2 and 3
The nicest part of route 21 is between stops 1 and 8
The nicest part of route 22 is between stops 1 and 4
The nicest part of route 23 is between stops 2 and 3
The nicest part of route 24 is between stops 3 and 5
Route 25 has no nice parts
The nicest part of route 26 is between stops 2 and 3
The nicest part of route 27 is between stops 8 and 11
Route 28 has no nice parts

*/

KGSS — Spoj

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

Solución — KGSS

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

struct sum {
 long long int n;
 long long int f;
};

void buildTree(sum *tree,int *a,int index,int s,int e)
{
 //base case
 if(s>e) return;
 //reached leaf node
 if(s==e)
 {
 tree[index]=((sum){a[s],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);
 sum left = tree[2*index]; sum right = tree[2*index+1];
 tree[index].f= max(left.msum,max(right.msum,left.m+right.m));
 tree[index].n= max(left.n,right.n);
 return;
}

//function to query the segment tree for RSQ
sum query(sum *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,0};
 //complete overlap
 if(s>=qs && e<=qe)
 return tree[index];
 //now partial overlap case is executed
 int m = (s+e)/2;
 sum left = query(tree,2*index,s,m,qs,qe);
 sum right = query(tree,2*index+1,m+1,e,qs,qe);
 return ( ( sum ) { max( left.n, max( right.msum, left.m + right.m ) ), max( left.f, right.f) } );
}

int main()
{
 freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/out.txt","w",stdout);
 int n,c;
 while(scanf("%d%d",&n,&c)==1)
 {
 int a[n];
 for(int i=0; i<n; i++) scanf("%d",&a[i]);
 sum*tree = new sum[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).n);
 }
 }
 return 0;
}

KROW — Spoj

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

Solución — KROW

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
bool winx,wino;
int m,n,c;
char board[201][201];
void checkDiagonal(int a,int b)
{
 int cx=0,co=0;
 for(int i=a,j=b;i<m&&j<n&&!winx&&!wino;j++,i++)
 {
 if(board[i][j]=='x'){ cx++; co=0;}
 else if(board[i][j]=='o') { co++; cx=0;}
 else { break;}
 if(cx>=c) winx=true;
 if(co>=c) wino=true;
 }
 cx=0,co=0;
 for(int i=a,j=b;i<m&&j<n&&!winx&&!wino;j--,i--)
 {
 if(board[i][j]=='x'){ cx++; co=0;}
 else if(board[i][j]=='o') { co++; cx=0;}
 else { break;}
 if(cx>=c) winx=true;
 if(co>=c) wino=true;
 }
 cx=0,co=0;
 for(int i=a,j=b;i<m&&j<n&&!winx&&!wino;j++,i--)
 {
 if(board[i][j]=='x'){ cx++; co=0;}
 else if(board[i][j]=='o') { co++; cx=0;}
 else { break;}
 if(cx>=c) winx=true;
 if(co>=c) wino=true;
 }
 cx=0,co=0;
 for(int i=a,j=b;i<m&&j<n&&!winx&&!wino;j--,i++)
 {
 if(board[i][j]=='x'){ cx++; co=0;}
 else if(board[i][j]=='o') { co++; cx=0;}
 else { break;}
 if(cx>=c) winx=true;
 if(co>=c) wino=true;
 }
}
int main()
{
 //freopen("C:/Users/Isaac/Desktop/in.txt","r",stdin);
 int cases,a=0,b=0,cx=0,co=0;
 cin>>cases;
 while(cases--)
 {
 winx=false,wino=false;
 cin>>n>>m>>c;
 for(int i=0; i<m;i++)
 for(int j=0; j<n;j++)
 cin>>board[i][j];
 //check row
 for(int i=0; i<m&&!winx&&!wino;i++)
 {
 cx=co=0;
 for(int j=0; j<n&&!winx&&!wino;j++)
 {
 if(board[i][j]=='x'){ cx++; co=0;}
 else if(board[i][j]=='o') { co++; cx=0;}
 else { cx=0; co=0;}
 if(cx>=c) winx=true;
 if(co>=c) wino=true;
 if(board[i][j]!='.') checkDiagonal(i,j);
 }
 }
 //check column
 for(int i=0; i<n&&!winx&&!wino;i++)
 {
 cx=co=0;
 for(int j=0; j<m&&!winx&&!wino;j++)
 {
 if(board[j][i]=='x'){ cx++; co=0;}
 else if(board[j][i]=='o') { co++; cx=0;}
 else { cx=0; co=0;}
 if(cx>=c) winx=true;
 if(co>=c) wino=true;
 }
 }

 if(winx) a++;
 if(wino) b++;
 }
 cout<<a<<':'<<b<<endl;
 return 0;
}

LASTDIG — Spoj

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

Solución — LASTDIG

#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ULLI;
typedef unsigned int UI;

UI bin_pow(UI a, ULLI n) {
 UI result = 1;
 while (n) {
 if (n & 1) {
 result = (result * a) % 10;
 n -= 1;
 } else {
 a = (a * a) % 10;
 n >>= 1;
 }
 }
 return result;
}

int main() {
 int n;
 cin >> n;
 while (n--) {
 string a;
 ULLI b;
 cin >> a >> b;
 cout << bin_pow(a.back() - '0', b) << endl;
 }
}

LASTSHOT — Spoj

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

Solución — LASTSHOT

#include<bits/stdc++.h>
using namespace std;
void dfs(vector< vector<int> > &bomb,bool visit[],int b,int &temp)
{
 temp++;
 visit[b]=true;
 for(int i=0;i<bomb[b].size();i++)
 {
 int a=bomb[b][i];
 if(!visit[a])
 dfs(bomb,visit,a,temp);
 }
}
int main()
{
 int n,m;
 cin>>n>>m;
 vector< vector<int> >bomb(n+1);
 while(m--)
 {
 int a,b;
 cin>>a>>b;
 bomb[a].push_back(b);
 }
 bool visit[n+1];
 int res=0;
 for(int i=1;i<=n;i++)
 {
 memset(visit,false,sizeof(visit));
 int temp=0;
 dfs(bomb,visit,i,temp);
 res=max(temp,res);
 }
 cout<<res;
 return 0;
}

LPS — Spoj

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

Solución — LPS

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

#define FOR(i, a, b) for(int i = (a); i < int(b); i++)

void manacher(int n, char *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 sol = 0;
 for(int i=0; i<2*n-1;i++) sol=max(r[i],sol);
 printf("%d\n",sol);
}

int main()
{
 int n; char s[100005];
 scanf("%d",&n); scanf("%s",s);
 int arr[n*2-1]; memset(arr,0,sizeof(arr));
 manacher(n,s,arr);
 return 0;
}

MAKEMAZE — Spoj

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

Solución — MAKEMAZE

#include<bits/stdc++.h>
using namespace std ;
int m1[]={1,0,-1,0};
int m2[]={0,1,0,-1};
bool visited[21][21] ;
int r , c , i , j , x , y ,t,total ;
char s[21][21] ;

void bfs()
{
 queue < pair< int , int > > q ;
 pair< int , int > p ;
 for( i = 0 ; i < r ; i++ )
 {
 for( j = 0 ; j < c ; j++ )
 {
 if( s[i][j] == '.' && (i==0 || (i+1) == r || j==0 || (j+1)==c ))
 {
 total++;
 if(total==1)
 {
 visited[i][j] = true;
 q.push( make_pair( i , j ) ) ;
 }
 }
 }
 }
 if(total==2)
 while( !q.empty( ) )
 {
 p = q.front( ) ;
 q.pop( ) ;
 for( i = 0 ; i < 4 ; i++ )
 {
 x = m1[i] + p.first ;
 y = m2[i] + p.second ;
 if( x >= 0 && x < r && y >= 0 && y < c && ( s[x][y] == '.' ) )
 {
 if( !visited[x][y] )
 {
 visited[x][y] = true ;
 if((x+1) ==r || (y+1) == c || x==0 || y==0)
 {
 total--;
 break;
 }
 q.push( make_pair( x , y ) ) ;
 }
 }
 }
 }
 else
 total=5;
}
int main( )
{
 cin >> t;
 while(t--)
 {
 total=0;
 cin>>r>>c;
 memset( visited , false , sizeof( visited ) ) ;
 for( i = 0 ; i < r ; i++ )
 scanf("%s",s[i]) ;

 bfs();

 if(total==1)
 cout<<"valid"<<endl;
 else
 cout<<"invalid"<<endl;
 }
 return 0 ;
}

MATCHING — Spoj

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

Solución — MATCHING

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

using namespace std;

const int SINK = 50001;
const int MAX_N = 50005;
const int INF = 0x3f3f3f3f;

int N, M, P;
int pair_g1[MAX_N], pair_g2[MAX_N], dist[MAX_N];
list< int > adj[MAX_N];

bool bfs() {
 queue< int > q; // queue of G1 nodes

 for (int v = 0; v < N; ++v) {
 if (pair_g1[v] == SINK) {
 dist[v] = 0;
 q.push(v);
 }
 else {
 dist[v] = INF;
 }
 }
 dist[SINK] = INF;

 while (!q.empty()) {
 int v = q.front();
 q.pop();

 if (dist[v] < dist[SINK]) {
 for (list< int >::iterator it = adj[v].begin(); it != adj[v].end(); ++it) {
 int u = *it;

 if (dist[pair_g2[u]] == INF) {
 dist[pair_g2[u]] = dist[v] + 1;
 q.push(pair_g2[u]);
 }
 }
 }
 }
 return dist[SINK] != INF;
}

bool dfs(int u) {
 // DFS starting at a node u in G1

 if (u == SINK) {
 // we've reached a free node in G2 (i.e. one pointing to SINK)
 return true;
 }

 for (list< int >::iterator it = adj[u].begin(); it != adj[u].end(); ++it) {
 int v = *it;

 if (dist[pair_g2[v]] == dist[u] + 1) {
 if (dfs(pair_g2[v])) {
 pair_g1[u] = v;
 pair_g2[v] = u;
 return true;
 }
 }
 }
 dist[u] = INF;
 return false;
}

int hopcroft_karp() {
 int matching = 0;

 for (int i = 0; i < N; ++i) {
 pair_g1[i] = SINK;
 }
 for (int j = 0; j < M; ++j) {
 pair_g2[j] = SINK;
 }

 while (bfs()) {
 for (int i = 0; i < N; ++i) {
 if (pair_g1[i] == SINK) {
 matching += dfs(i);
 }
 }
 }
 return matching;
}

int main() {
 int a,b;
 while (scanf("%d %d %d", &N, &M, &P) == 3) {
 for (int i = 0; i < N; i++) adj[i].clear();
 for (int i = 0; i < P; i++) {
 scanf("%d%d",&a,&b);
 adj[a-1].push_back(b-1);
 }
 printf("%d\n", hopcroft_karp());
 }
 return 0;
}

MAY99_2 — Spoj

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

Solución — MAY99_2

#include <iostream>
using namespace std;

int main()
{
 int casos;
 long long int n, modValor;
 char valores[6] = {'u', 'm', 'a', 'n', 'k'};
 string str;
 cin>>casos;
 while(casos--)
 {
 cin>>n;
 while(n > 0)
 {
 modValor = n % 5;
 if(modValor == 0)
 n--;
 str = valores[modValor]+str;
 n /= 5;
 }

 cout <<str<<"\n";
 str="";
 }
 return 0;
}

MISERMAN — Spoj

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

Solución — MISERMAN

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

const int MAX = 128;
const int INF = 0x3F3F3F3F;

int dp[MAX][MAX];
int main() {
 int m, n, i, j, ans;
 scanf("%d%d", &n, &m);
 for(i = 0; i < n; i++) {
 for(j = 1; j <= m; j++)
 scanf("%d", &dp[i][j]);
 dp[i][0] = dp[i][j] = INF; //Poner valores Infinitos al final y principio
 }
 for(i = 1; i < n; i++)
 for(j = 1; j <= m; j++)
 dp[i][j] += min(dp[i-1][j], min(dp[i-1][j-1], dp[i-1][j+1])); //Diagonal, Arriba, Derecha cogiendo el minimo siempre
 for(i = n-1, ans = INF, j = 1; j <= m; j++)
 ans = min(ans, dp[i][j]);
 printf("%d\n", ans);
 return 0;
}

MIXTURES — Spoj

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

Solución — MIXTURES

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

long long int dp[105][105];
long long int arr[105];

long long int sum(int j,int e)
{
 long long res=0;
 for(int i=j; i<=e;i++)
 {
 res+=arr[i];
 res%=100;
 }
 return res;
}
long long int solve(int i, int j)
{
 if(i>=j) return 0;
 if(dp[i][j]!=-1) return dp[i][j];
 dp[i][j]=INF;
 for(int k=i; k<=j;k++)
 {
 long long int temp = solve(i,k)+solve(k+1,j);
 temp+=sum(i,k)*sum(k+1,j); //arr[i-1]*arr[k]*arr[j];
 dp[i][j]=min(dp[i][j],temp);
 //dp[i][j] =min(dp[i][j],solve(i,k)+solve(k+1,j)+sum(i,k)*sum(k+1,j));
 }
 return dp[i][j];
}

int main()
{
 int n;
 while(scanf("%d",&n)==1)
 {
 memset(dp,-1,sizeof(dp));
 for(int i=0; i<n;i++) cin>>arr[i];
 cout<<solve(0,n-1)<<'\n';
 }
 return 0;
}

MKBUDGET — Spoj

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

Solución — MKBUDGET

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

int emp,sal,sev;
int arr[25];
int n;

int memo[5001][25];
bool mark[5001][25];

int DP(int e,int m){
 if(m>=n) return 0;
 if(e>=5001 || e<0) return INF;
 int &best=memo[e][m];
 if(mark[e][m]) return best;
 mark[e][m]=true;
 best=INF;
 best=min(DP(e+1,m)+emp,best);
 if(e>=arr[m])
 best=min(best,DP(e,m+1)+(sal*e));
 best=min(best,DP(e-1,m)+sev);
 return best;
}

int main()
{
 int cnt=1;
 while(scanf("%d",&n)==1 && n!=0)
 {
 memset(mark,false,sizeof(mark));
 cin>>emp>>sal>>sev;
 for(int i=0; i<n;i++) cin>>arr[i];
 printf("Case %d, cost = $%d\n",cnt++,DP(0,0));
 }
 return 0;
}

MTHUR — Spoj

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

Solución — MTHUR

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

int N,M,X,Y,A,B;
int gr[50001],a[10001], b[10001];
int f(int grace)
{
 int sum=0;
 for (int i=0; i<N; i++) sum+=(abs(a[i] - (b[i]+grace)));
 return sum;
}
int ternaryx()
{
 int minx = 0;
 int maxx = M-1;
 int midl,midh;
 while (midh - midl + 1 > 3)
 {
 midl = ((2 * minx) + maxx) / 3;
 midh = (minx + (2 * maxx)) / 3;
 if (f(gr[midl]) > f(gr[midh])) minx = midl;
 else maxx = midh;
 }
 int mini=INF,val;
 for (int i=minx; i<=maxx; i++)
 if ( mini > f( gr[ i ] ) )
 {
 mini = f( gr[ i ] );
 val = gr[ i ];
 }
 return val;
}
int main()
{
 int T;
 cin>>T;
 while(T--)
 {
 cin>>N;
 for (int i=0; i<N; i++) cin>>a[i];
 for (int i=0; i<N; i++) cin>>b[i];
 cin>>M;
 for (int i=0; i<M; i++) cin>>gr[i];
 sort(gr,gr+M);
 cout<<ternaryx()<<endl;
 }
 return 0;
}

MTOTALF — Spoj

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

Solución — MTOTALF

#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;
 while(scanf("%d", &n)==1) {
 memset(head, -1, sizeof(head));
 int c, x, y,cnt=1;
 string start,end;
 map<string,int> M;
 for(int i=0; i<n;i++){
 cin >> start >> end >> c;
 if(M[start]==0){M[start]=cnt; cnt++;}
 if(M[end]==0){M[end]=cnt; cnt++;}
 x=M[start];
 y=M[end];
 addEdge(x, y, c);
 addEdge(y, x, c);
 }
 int flow = maxflow(M["A"], M["Z"]);
 cout << flow <<"\n";
 }
 return 0;
}

NHAY — Spoj

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

Solución — NHAY

#include <vector>
#include <iostream>
#include <string>
#include <cstdio>
using namespace std;

void kmp(const string &needle, const string &haystack) {
 int m = needle.size();
 vector<int> border(m + 1);
 border[0] = -1;
 for (int i = 0; i < m; ++i) {
 border[i+1] = border[i];
 while (border[i+1] > -1 and needle[border[i+1]] != needle[i]) {
 border[i+1] = border[border[i+1]];
 }
 border[i+1]++;
 }

 int n = haystack.size();
 int seen = 0;
 for (int i = 0; i < n; ++i){
 while (seen > -1 and needle[seen] != haystack[i]) {
 seen = border[seen];
 }
 if (++seen == m) {
 printf("%d\n", i - m + 1);
 seen = border[m];
 }
 }
}

int main(){
 int m;
 bool first = true;
 while (scanf("%d",&m)==1) {
 if (!first) puts("");
 first = false;

 string needle; getline(cin, needle);
 getline(cin, needle);
 string haystack;
 getline(cin, haystack);
 kmp(needle, haystack);
 }
 return 0;
}

OLOLO — Spoj

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

Solución — OLOLO

#include<bits/stdc++.h>

int main()
{
 long long n, i, num, result = 0;
 scanf("%lld", &n);
 for(i=0; i< n; i++)
 {
 scanf("%lld", &num);
 result = result ^ num;
 }
 printf("%lld\n", result);
 return 0;
}

PANCAKES — Spoj

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

Solución — PANCAKES

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

int main() {
 int n,r;
 while(scanf("%d%d",&n,&r)==2 && n+r)
 {
 int arr[n],res=INF,aux1,res1=0,rec=1;
 for(int i=0; i<n;i++) cin>>arr[i];
 for(int i=0; i<r;i++)
 {
 for(int j=0; j<n;j++)
 {
 cin>>aux1;
 if(aux1!=0)
 res=min(res,(10*arr[j])/aux1);
 }
 if(res1<res) { res1=res; rec=i+1;}
 res=INF;
 }
 cout<<rec<<" "<<res1<<endl;
 }
 return 0;
}

PFDEP — Spoj

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

Solución — PFDEP

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

stack<int> s;
bool visited[105];
vector<long long int> adj[105];

void dfs(long long source)
{
 visited[source] = true;

 for(long long i=0; i<adj[source].size(); i++)
 {
 if(!visited[adj[source][i]])
 dfs(adj[source][i]);
 }
 s.push(source);
}

int main()
{
 long long n,m;
 cin>>n>>m;

 for(long long int i=m;i>0;i--)
 {
 long long a,k;
 cin>>a>>k;

 while(k--)
 {
 long long b;
 cin>>b;
 adj[b].push_back(a);
 }
 }

 for(long long i=1;i<=n;i++)
 sort(adj[i].rbegin(),adj[i].rend());

 memset(visited, false, sizeof(visited));
 for(long long i=n; i>0; i--)
 {
 if(!visited[i])
 dfs(i);
 }
 while(!s.empty())
 {
 cout<<s.top()<<" ";
 s.pop();
 }
 return 0;
}

PHONELST — Spoj

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

Solución — PHONELST

#include <bits/stdc++.h>
using namespace std;
struct trie {
 trie *next[10];
 bool end;
 trie() {
 for(int i=0; i<10; i++) next[i] = NULL;
 end = false;
 }
};

int main() {
 int t, n, i, p;
 char str[15];
 bool flag;
 cin>>t;
 while(t--) {
 cin>>n;
 trie *head, *tail;
 head = new trie;
 flag = true;
 while(n--) {
 cin>>str;
 if(flag) {
 tail = head;
 for(i=0; str[i]; i++) {
 if(tail->end) {
 flag = false;
 break;
 }
 p = str[i]-48;
 if(tail->next[p]==NULL) tail->next[p] = new trie;
 tail = tail->next[p];
 }
 tail->end = true;
 for(i=0; i<10; i++) {
 if(tail->next[i]) {
 flag = false;
 break;
 }
 }
 }
 }
 if(flag) printf("YES\n");
 else printf("NO\n");
 }
 return 0;
}

POTHOLE — Spoj

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

Solución — POTHOLE

// Adjacency list implementation of FIFO push relabel maximum flow
// with the gap relabeling heuristic. This implementation is
// significantly faster than straight Ford-Fulkerson. It solves
// random problems with 10000 vertices and 1000000 edges in a few
// seconds, though it is possible to construct test cases that
// achieve the worst-case.
//
// Running time:
// O(|V|^3)
//
// INPUT:
// - graph, constructed using AddEdge()
// - source
// - sink
//
// OUTPUT:
// - maximum flow value
// - To obtain the actual flow values, look at all edges with
// capacity > 0 (zero capacity edges are residual edges).

#include <cmath>
#include <vector>
#include <iostream>
#include <queue>

using namespace std;

typedef long long LL;

const int INF = 1000000000;

struct Edge {
 int from, to, cap, flow, index;
 Edge(int from, int to, int cap, int flow, int index) :
 from(from), to(to), cap(cap), flow(flow), index(index) {}
};

struct PushRelabel {
 int N;
 vector<vector<Edge> > G;
 vector<LL> excess;
 vector<int> dist, active, count;
 queue<int> Q;

 PushRelabel(int N) : N(N), G(N), excess(N), dist(N), active(N), count(2*N) {}

 void AddEdge(int from, int to, int cap) {
 G[from].push_back(Edge(from, to, cap, 0, G[to].size()));
 if (from == to) G[from].back().index++;
 G[to].push_back(Edge(to, from, 0, 0, G[from].size() - 1));
 }

 void Enqueue(int v) {
 if (!active[v] && excess[v] > 0) { active[v] = true; Q.push(v); }
 }

 void Push(Edge &e) {
 int amt = int(min(excess[e.from], LL(e.cap - e.flow)));
 if (dist[e.from] <= dist[e.to] || amt == 0) return;
 e.flow += amt;
 G[e.to][e.index].flow -= amt;
 excess[e.to] += amt;
 excess[e.from] -= amt;
 Enqueue(e.to);
 }

 void Gap(int k) {
 for (int v = 0; v < N; v++) {
 if (dist[v] < k) continue;
 count[dist[v]]--;
 dist[v] = max(dist[v], N+1);
 count[dist[v]]++;
 Enqueue(v);
 }
 }

 void Relabel(int v) {
 count[dist[v]]--;
 dist[v] = 2*N;
 for (int i = 0; i < G[v].size(); i++)
 if (G[v][i].cap - G[v][i].flow > 0)
 dist[v] = min(dist[v], dist[G[v][i].to] + 1);
 count[dist[v]]++;
 Enqueue(v);
 }

 void Discharge(int v) {
 for (int i = 0; excess[v] > 0 && i < G[v].size(); i++) Push(G[v][i]);
 if (excess[v] > 0) {
 if (count[dist[v]] == 1)
 Gap(dist[v]);
 else
 Relabel(v);
 }
 }

 LL GetMaxFlow(int s, int t) {
 count[0] = N-1;
 count[N] = 1;
 dist[s] = N;
 active[s] = active[t] = true;
 for (int i = 0; i < G[s].size(); i++) {
 excess[s] += G[s][i].cap;
 Push(G[s][i]);
 }

 while (!Q.empty()) {
 int v = Q.front();
 Q.pop();
 active[v] = false;
 Discharge(v);
 }

 LL totflow = 0;
 for (int i = 0; i < G[s].size(); i++) totflow += G[s][i].flow;
 return totflow;
 }
};

int main() {
 int t;
 cin >> t;
 for (int i = 0; i < t; i++) {
 int n;
 cin >> n;
 PushRelabel pr(n);
 for (int j = 0; j < n-1; j++) {
 int m;
 cin >> m;
 for (int k = 0; k < m; k++) {
 int p;
 cin >> p;
 p--;
 int cap = (j == 0 || p == n-1) ? 1 : INF;
 pr.AddEdge(j, p, cap);
 }
 }

 cout << pr.GetMaxFlow(0, n-1) << endl;
 }
 return 0;
}

PQUEUE — Spoj

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

Solución — PQUEUE

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

struct state
{
 bool mine;
 int value;
 int site;
 bool operator<(const state &other)const{ return value < other.value; }
};
int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 int time=0;
 queue<state> Q;
 priority_queue<state> PQ;
 int mine, total; cin>>total>>mine;
 for(int i=0; i<total;i++) {
 int num;
 state N;
 if(i==mine) N.mine=true;
 else N.mine=false;
 cin>>num; N.value=num; N.site=i;
 PQ.push(N); Q.push(N);}
 while(!Q.empty())
 {
 state actual = PQ.top();
 if(actual.mine) break;
 PQ.pop();
 for(unsigned int i=0; i<Q.size();i++)
 {
 state move = Q.front();
 Q.pop();
 if(move.site==actual.site) break;
 Q.push(move);
 }
 priority_queue<state> modify;
 queue<state> aux;
 aux = Q;
 for(unsigned int i=0; i<Q.size();i++)
 {
 state move = aux.front();
 aux.pop();
 modify.push(move);
 }
 PQ=modify;
 time++;
 }
 cout<<time+1<<endl;
 }
 return 0;
}

PRIME1 — Spoj

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

Solución — PRIME1

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

int prime(long long int x){
 if(x==1) return 0;
 if(x==2) return 1;
 if(x%2==0) return 0;
 for(int i=3;i<=sqrt(x);i++){
 if(x%i==0)
 return 0;
 }
 return 1;
}

int main() {
 int flag=1;
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 if(flag==0) printf("\n");
 long long int a,b; scanf("%lld%lld",&a,&b);
 for(long long int i=a;i<=b;i++) if(prime(i)==1) printf("%lld\n",i);
 flag=0;
 }
 return 0;
}

PT07Y — Spoj

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

Solución — PT07Y


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

void BFS(int start, vector<bool> &visited, vector<vector<int>> &graph){
 queue<int> q;
 q.push(start);
 visited[start] = true;
 while(!q.empty()){
 int current = q.front(); q.pop();
 for(unsigned int i=0;i<graph[current].size();i++){
 int dest = graph[current][i];
 if(visited[dest]) continue;
 visited[dest] = true;
 q.push(dest);
 }
 }
}

void dfs(int u, vector<bool> &visited, vector<vector<int>> &graph) {
 visited[u] = true;
 for (unsigned int v = 0; v<graph[u].size(); v++)
 if (!visited[graph[u][v]])
 dfs(graph[u][v],visited,graph);
}

int main(){
 int from, to,A,V;
 while(scanf("%d %d",&V,&A)==2){
 if(V==0 && A ==0 ){ printf("NO\n"); continue;}
 vector<vector<int>> graph(V+1);
 vector<bool> visited(V+1,false);
 for(int i=0;i<A;i++){
 scanf("%d %d",&from, &to);
 graph[from].push_back(to);
 graph[to].push_back(from);
 }
 dfs(1,visited,graph);
 bool flag = true; //BFS(from)
 for(int i=1;i<=V &&flag;i++){
 if(!visited[i]) flag=false;
 }

 if(flag && A==V-1) printf("YES\n"); //un grafo es aciclico si tiene A==V-1 y es conexo
 else printf("NO\n");
 }
 return 0;
}

QUEST4 — Spoj

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

Solución — QUEST4

#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; scanf("%d",&cases);
 while(cases--) {
 e=0;
 memset(head, -1, sizeof(head));
 int s = 240, t = 241, c, x, y;
 cin >> c;
 while(c--) {
 cin >> x >> y;
 addEdge(x, y+120, 1);
 }
 for(int i=0; i<120;i++){
 addEdge(s, i, 1);
 addEdge(120+i, t, 1);
 }
 int flow = maxflow(s, t);
 cout << flow <<"\n";
 }
 return 0;
}

RPLD — Spoj

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

Solución — RPLD

#include<iostream>
using namespace std;
int main(){
 struct set{int alumnos,materias;
 };
 int casos,columna,fila;
 bool posible=true;
 cin>>casos;
 for(int x=1;x<=casos;x++)
 {
 set base[100055];
 cin>>fila>>columna;
 for(int i=0;i<columna;i++){
 cin>>base[i].alumnos>>base[i].materias;
 }
 for(int i=0;i<columna-1&&posible;i++){
 for(int j=i+1;j<columna;j++){
 if(base[i].alumnos==base[j].alumnos && base[i].materias==base[j].materias){
 posible=false;
 break;
 }
 }
 }
 if(!posible)
 cout<<"Scenario #"<<x<<": impossible"<<endl;
 else
 cout<<"Scenario #"<<x<<": possible"<<endl;

 posible=true;
 }

 return 0;
}

RPLN — Spoj

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

Solución — RPLN

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

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]= min(tree[2*index],tree[2*index+1]);
 return;
}

//function to query the segment tree for RMQ
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 INF;
 //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 min(left_ans,right_ans);
}

int main()
{
 int n,c,cases,ca=1;
 scanf("%d",&cases);
 while(cases--)
 {
 scanf("%d%d",&n,&c);
 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
 printf("Scenario #%d:\n",ca++);
 for(int i=0; i<c;i++)
 {
 int k,j; scanf("%d%d",&k,&j);
 printf("%d\n",query(tree,index,s,e,k-1,j-1));
 }
 }
 return 0;
}

SAMER08D — Spoj

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

Solución — SAMER08D

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

int main()
{
 string input1;
 string input2;
 int n;
 while(scanf("%d",&n)==1 && n!=0)
 {
 cin>>input1; cin>>input2;
 int T[input1.length()+1][input2.length()+1];
 memset(T,0,sizeof(T));

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

}

SARRAY — Spoj

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

Solución — SARRAY

#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() {
 while(scanf("%s",T)==1)
 {
 n = (int)strlen(T);
 T[n++] = '$';
 constructSA(); // O(n log n)
 for (int i = 1; i < n; i++) printf("%d\n", SA[i]);
 }
 return 0;
}

SBANK — Spoj

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

Solución — SBANK

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int n;
 cin>>n;
 while(n--)
 {
 int p;
 cin>>p;
 map<string,int> a;
 cin.ignore();
 for(int i=0; i<p;i++)
 {
 string m;
 getline(cin,m);
 if(a.insert(pair<string,int>(m,1)).second == false)
 {
 int k = a.find(m)->second;
 k++;
 map<string, int>::iterator it = a.find(m);
 if (it != a.end())
 it->second = k;
 }
 }
 cout<<endl;
 map<string,int>::iterator it = a.begin();
 for (it=a.begin(); it!=a.end(); ++it)
 std::cout << it->first << it->second << '\n';

 }
 return 0;
}

SBETS — Spoj

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

Solución — SBETS

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

int main()
{
 int n;
 cin>>n;
 while(n--)
 {
 int n=16;
 map<string,bool> teams;
 while(n--){
 string t1,t2;
 int g1,g2;
 cin>>t1>>t2>>g1>>g2;
 teams.insert(make_pair(t1,true));
 teams.insert(make_pair(t2,true));
 teams[g1>g2?t2:t1]=false;
 }
 map<string,bool>::iterator i;
 for(i=teams.begin();i!=teams.end();i++){
 if(i->second!=false){
 cout<<(i->first)<<endl;
 break;
 }
 }
 }
 return 0;
}

SCUBADIV — Spoj

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

Solución — SCUBADIV

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

int N_[1050]; int O_[1050]; int W_[1050];
bool mark[1050][25][82];
int memo[1050][25][82];
int N,O,K;

int DP(int i,int Ox,int Ni) {
 if(Ox>=O&&Ni>=N) return 0; //Si hemos llegado retorna 0
 if(i==K) return INF; //Si te pasas INFINITO
 if(Ox>=O) Ox=O; if(Ni>=N) Ni=N;
 int &best = memo[i][Ox][Ni];
 if(mark[i][Ox][Ni]) return best; //Si fue marcado tienes mejor resultado
 mark[i][Ox][Ni]=true;
return best= min(DP(i+1,Ox,Ni),DP(i+1,O_[i]+Ox,N_[i]+Ni)+W_[i]);
}
int main() {
int a;
cin>>a;
 while(a--)
 {
 cin>>O>>N; //Nitrogeno y Oxigeno que se necesita
 memset(mark,false,sizeof(mark));
 memset(memo,INF,sizeof(memo));
 cin>>K; //Total de Cilindros
 for(int i=0; i<K;i++)
 cin>>O_[i]>>N_[i]>>W_[i];
 cout<<DP(0,0,0)<<endl;
 }
return 0;
}

SGAME — Spoj

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

Solución — SGAME

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

int main()
{
 int i,start,a,b;
 int A[301];
 cin>>i;
 while(i--)
 {
 cin>>start;
 memset(A,0,sizeof(A));
 while(scanf("%d%d",&a,&b) && (a!=-1 && b!=-1)){
 A[a]++;
 A[b]++;
 }
 bool flag=true;
 for(int k=0;k<301&&flag;k++)
 if(A[k]%2==1) flag=false;
 if(flag) cout<<"YES\n";
 else cout<<"NO\n";
 }
 return 0;
}

SHAHBG — Spoj

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

Solución — SHAHBG

#include <bits/stdc++.h>

using namespace std;

int main()
{
 int i,l,contador=0;
 cin>>i;
 bool q[20002];
 for(int k=0;k<20002;k++)
 q[k]=false;

 while(i--)
 {
 cin>>l;
 q[l]=true;
 if(q[l+1]&&q[l-1])
 {
 contador--;
 cout<<contador<<endl;
 }
 else if(q[l+1]||q[l-1])
 {
 cout<<contador<<endl;
 }
 else
 {
 contador++;
 cout<<contador<<endl;
 }
 }
 cout<<"Justice\n";
 return 0;
}

SHPATH — Spoj

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

Solución — SHPATH

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

const int MAXN = 10005;

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 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; cin>>cases;
 while(cases--)
 {
 cin>>N;
 map<string,int> M;
 for(int i=0;i<=N;i++) graph[i].clear();
 for(int i=0; i<N;i++)
 {
 string name; cin>>name;
 M[name]=i;
 scanf("%d",&E);
 for(int j=0;j<E;j++){
 int to, weight; scanf("%d %d", &to, &weight);
 to--;
 graph[i].push_back(edge(i,to,weight));
 }
 }
 int cases2; cin>>cases2;
 while(cases2--)
 {
 memset(dist,INF,sizeof(dist));
 string n1,n2; cin>>n1>>n2;
 printf("%d\n",dijkstra(M[n1],M[n2]));
 }
 M.clear();
 }
 return 0;
}

STAMPS — Spoj

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

Solución — STAMPS

#include <bits/stdc++.h>

using namespace std;

int main()
{
 long long int a,l=1,j=0,u=0,y=0;
 cin>>a;
 while(a--)
 {
 long long int m,k,po;
 cin>>m>>k;
 int arr[k];
 for(int i=0;i<k;i++)
 {
 cin>>po;
 arr[i]=po;
 }
 sort(arr,arr+k);
 for(j=k-1;j>=0;j--)
 {
 u+=arr[j];
 y++;
 if(u>=m)
 break;
 }
 if(u>=m)
 cout<<"Scenario #"<<l<<":\n"<<y<<endl;
 else
 cout<<"Scenario #"<<l<<":\nimpossible"<<endl;
 l++; u=0; y=0;
 j=0;
 }
 return 0;
}

TAXI — Spoj

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

Solución — TAXI

#include <bits/stdc++.h>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;

bool FindMatch(int i, const VVI &w, VI &mr, VI &mc, VI &seen) {
 for (unsigned int j = 0; j < w[i].size(); j++) {
 if (w[i][j] && !seen[j]) {
 seen[j] = true;
 if (mc[j] < 0 || FindMatch(mc[j], w, mr, mc, seen)) {
 mr[i] = j;
 mc[j] = i;
 return true;
 }
 }
 }
 return false;
}

int BipartiteMatching(const VVI &w, VI &mr, VI &mc) {
 mr = VI(w.size(), -1);
 mc = VI(w[0].size(), -1);

 int ct = 0;
 for (unsigned int i = 0; i < w.size(); i++) {
 VI seen(w[0].size());
 if (FindMatch(i, w, mr, mc, seen)) ct++;
 }
 return ct;
}
int main() {
 freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int a,b,cases; scanf("%d",&cases);
 while(cases--)
 {
 int s,c,N,M; scanf("%d%d%d%d",&N,&M,&s,&c);
 VVI adj(M, VI(N));
 //for (int i = 0; i <= M; i++) adj[i].clear();
 vector<pair<int,int>> P;
 for (int i = 0; i < N; i++) {
 scanf("%d%d",&a,&b);
 P.push_back({a,b});
 }
 for (int i = 0; i < M; i++) {
 scanf("%d%d",&a,&b);
 for(int j=0; j<N;j++)
 {
 pair<int,int> person = P[j];
 if(((abs(person.first-a)+abs(person.second-b))<=s*c/200)) adj[i][j]=1;
 }
 }
 vector<int> V; vector<int> V_;
 printf("%d\n",BipartiteMatching(adj, V,V_));
 //printf("%d\n", hopcroft_karp());
 //for (int i = 0; i <= M; i++) adj[i].clear();
 }
 return 0;
}

TEMPTISL — Spoj

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

Solución — TEMPTISL

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

long long int memo[55][55];
bool mark[55][55];
long long int N,K,A,B;

long long int DP(int a,int b)
{
 if(b==K) return a==B;
 long long int &best=memo[a][b];
 if(mark[a][b]) return best;
 mark[a][b]=true;
 int u = a+1; int v=a-1;
 if(u==N) u=0;
 if(v==-1) v=N-1;
 return best=DP(u,b+1)+DP(v,b+1);
}

int main()
{
 cin>>N>>K;
 while(N!=-1&&K!=-1)
 {
 cin>>A>>B;
 A--; B--;
 memset(mark,false,sizeof(mark));
 memset(memo,0,sizeof(memo));
 cout<<DP(A,0)<<endl;
 cin>>N>>K;
 }
 return 0;
}

TEST — Spoj

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

Solución — TEST

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string numero;
 getline(cin,numero);
 while(atoi(numero.c_str())!=42)
 {
 cout<<numero<<"\n";
 getline(cin,numero);
 }
 return 0;
}

TOANDFRO — Spoj

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

Solución — TOANDFRO

#include <bits/stdc++.h>

using namespace std;

int main()
{
 int n;
 cin>>n;
 while(n!=0)
 {
 string te,resul;
 cin>>te;
 int c= n;
 int m=0,l=0,j=1;
 while(c!=m)
 {
 l=m;
 for(int i=0;i<te.length()/n;i++)
 {
 resul+=te[l];
 if(i%2==0)
 l+=(n*2)-j;
 else
 l+=j;
 }
 m++;
 j+=2;
 }
 cout<<resul<<endl;
 cin>>n;
 }
 return 0;
}

TRAFFICN — Spoj

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

Solución — TRAFFICN

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

const int MAXN = 10005;

vector<pair<int,int>> graph[MAXN],Rgraph[MAXN];
int dist[MAXN],Rdist[MAXN];
bool flagG[MAXN], flagR[MAXN];

int N,E,res;

void dijkstra(int s, vector<pair<int,int>> *graph, int *dist, bool *flag) {
 priority_queue< pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>> > Q;
 Q.push(make_pair(0,s));
 int u, v, w, i, sz;
 dist[s] = 0;
 while(!Q.empty()) {
 u = Q.top().second;
 Q.pop();
 if(flag[u]) continue;
 sz = graph[u].size();
 for(i = 0; i < sz; i++) {
 v = graph[u][i].second;
 w = graph[u][i].first;
 if(!flag[v] && dist[v] > dist[u] + w) {
 dist[v] = dist[u] + w;
 Q.push(make_pair(dist[v], v));
 }
 }
 flag[u] = true;
 }
}

int main(){

 int cases; cin>>cases;
 while(cases--)
 {
 int k,s,t;
 scanf("%d %d %d %d %d",&N,&E,&k,&s,&t);
 s--; t--;
 for(int i=0;i<=N;i++) {flagR[i]=false; flagG[i]=false; dist[i]=INF; Rdist[i]=INF; graph[i].clear(); Rgraph[i].clear();}
 for(int j=0;j<E;j++){
 int to,from, weight; scanf("%d %d %d", &from,&to, &weight);
 to--; from--;
 graph[from].push_back(make_pair(weight,to));
 Rgraph[to].push_back(make_pair(weight,from));
 }
 dijkstra(s,graph,dist,flagG);
 dijkstra(t,Rgraph,Rdist,flagR);
 res = INF;
 for(int i=0; i<k;i++)
 {
 int from,to,weight; scanf("%d %d %d", &from,&to, &weight);
 from--; to--;
 res = min(res,min(dist[t],min(dist[from]+weight+Rdist[to],dist[to]+weight+Rdist[from])));
 }
 if(res==INF) printf("-1\n");
 else printf("%d\n",res);
 }
 return 0;
}

TRVCOST — Spoj

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

Solución — TRVCOST

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

const int MAXN = 505;

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];
vector<int> V[MAXN];
int N=505,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(){
 freopen("C:/Users/Isaac/Desktop/in.txt","r",stdin);
 freopen("C:/Users/Isaac/Desktop/out.txt","w",stdout);
 while(scanf("%d",&E)==1)
 {
 for(int i=0;i<=N;i++) {V[i].clear(); graph[i].clear();}
 for(int j=0;j<E;j++){
 int to,from, weight; scanf("%d %d %d", &from,&to, &weight);
 graph[from].push_back(edge(from,to,weight));
 graph[to].push_back(edge(to,from,weight));
 }
 int F; cin>>F;
 int T; cin>>T;
 for(int i=0; i<T;i++)
 {
 for(int i=0;i<=501;i++) dist[i]=INF;
 int arrival; scanf("%d",&arrival);
 if(V[arrival].size()!=0)
 {
 if(V[arrival][0]==-1) printf("NO PATH\n");
 else printf("%d\n",V[arrival][0]);
 }
 else
 {
 int res = dijkstra(F,arrival);
 if(res==-1) printf("NO PATH\n");
 else printf("%d\n",res);
 V[arrival].push_back(res);
 }
 }
 }
 return 0;
}

TWENDS — Spoj

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

Solución — TWENDS

#include <bits/stdc++.h>
using namespace std;
int memo[1001][1001];
bool mark[1001][1001];
int cartas[1001];
int K;
int DP(int start,int end)
{
 if(start>end) return 0;
 int &best = memo[start][end];
 if(mark[start][end]) return best;
 mark[start][end]=true;

 best = max(cartas[start+1]>=cartas[end]?DP(start+2,end)+cartas[start]:DP(start+1,end-1)+cartas[start],
 cartas[start]>=cartas[end-1]?DP(start+1,end-1)+cartas[end]:DP(start,end-2)+cartas[end]);
 return best;
}

int main()
{
 int cnt=1,sum;
 cin>>K;
 while(K!=0)
 {
 sum=0;
 memset(mark,false,sizeof(mark));
 memset(memo,-1,sizeof(memo));
 for(int i=0; i<K;i++)
 {
 cin>>cartas[i];
 sum+=cartas[i];
 }
 int a=DP(0,K-1);
 cout<<"In game "<<cnt<<", the greedy strategy might lose by as many as "<<a-(sum-a)<<" points.\n";
 cin>>K;
 cnt++;
 }
return 0;
}

UCV2013A — Spoj

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

Solución — UCV2013A

#include <bits/stdc++.h>

using namespace std;
int m= 1000000007;
int main()
{
 long long int a,b,result,in;
 cin>>a>>b;
 while(a!=0&&b!=0)
 {
 result=0;
 in=1;
 for(int i=1;i<=b;i++)
 {
 in=(in*a)%m;
 result=(result+in)%m;
 }
 cout<<result<<endl;
 cin>>a>>b;
 }
 return 0;
}

UCV2013H — Spoj

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

Solución — UCV2013H

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

int dx[]={1,-1,0,0}; //4 directions
int dy[]={0,0,1,-1};
bool visited[255][255];
int arr[255][255];
int r,c,num;
void dfs(int a, int b){
visited[a][b]=true;
 for(int i=0;i<4;i++)
 {
 int I=a+dx[i];
 int J=b+dy[i];
 if(I>=0 && I<r && J>=0 && J<c &&!visited[I][J]){
 visited[I][J]=true;
 if(arr[I][J]==1) { num++; dfs(I,J);}
 }
 }
}
int main(){
 while(scanf("%d%d",&r,&c)==2 && (r!=0||c!=0))
 {
 memset(visited,false,sizeof(visited));
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) cin>>arr[i][j];
 map<int,int> M;
 int cont = 0;
 for(int i=0; i<r;i++)
 for(int j=0; j<c;j++) if(arr[i][j]==1 && !visited[i][j]){ num=1; dfs(i,j); M[num]++; cont++;}
 cout<<cont<<endl;
 for(auto m:M) cout<<m.first<<" "<<m.second<<endl;

 }
return 0;
}

UCV2013J — Spoj

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

Solución — UCV2013J

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

URJC1_A — Spoj

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

Solución — URJC1_A


///Pokemons

#include <iostream>
#include <cstdio>
#include <math.h>
using namespace std;
int main()
{
 double a,b,c,calcua;
 cin>>a>>b>>c;
 double diferencia= b/a;
 calcua= c*c;
 double resultado1= calcua/diferencia;
 resultado1=sqrt(resultado1);
 printf("%.4f\n",resultado1);
 return 0;
}

//10000 1000000 100
//100000 200000 50
//10431 5200087 100

URJC1_D — Spoj

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

Solución — URJC1_D

///Rollitos URJC

#include <iostream>
using namespace std;
int main()
{
 int casos,rollitos,personas;
 cin >> casos;
 while(casos--)
 {
 cin>>personas>>rollitos;
 if(rollitos%personas==0)
 {
 cout << rollitos/personas<<"\n";
 }
 else
 cout << "BRING ME MOAR SUSHI!\n";
 }
 return 0;
}

URJC2_A — Spoj

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

Solución — URJC2_A

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

struct horarios
{
 int a;
 int b;
 string horari;
 bool operator<(const horarios &other)const{ return a < other.a; }
};
int main()
{
 vector<horarios> mn;
int i;
cin>>i;
while(i--)
{
 int j;
 cin>>j;
 while(j--)
 {
 string hora1,hora2,programa;
 cin>>hora1>>hora2>>programa;
 int hg=(hora1[0]-48)*1000;
 hg+=(hora1[1]-48)*100;
 hg+=(hora1[3]-48)*10;
 hg+=hora1[4]-48;
 int hg1=(hora2[0]-48)*1000;
 hg1+=(hora2[1]-48)*100;
 hg1+=(hora2[3]-48)*10;
 hg1+=hora2[4]-48;
 mn.push_back(horarios{hg,hg1,programa});
 }
 sort(mn.begin(),mn.end());
 int m;
 cin>>m;
 while(m--)
 {
 string hora1;
 cin>>hora1;
 int ha=(hora1[0]-48)*1000;
 ha+=(hora1[1]-48)*100;
 ha+=(hora1[3]-48)*10;
 ha+=hora1[4]-48;
 horarios m;
 bool entra=false;
 for(unsigned int l=0; l<mn.size();l++)
 {
 if(mn[l].a<=ha&&mn[l].b>ha)
 {
 m.horari=mn[l+1].horari;
 entra=true;
 break;
 }
 }
 if(!entra)
 m.horari=mn[0].horari;
 cout<<m.horari<<endl;
 }
 mn.clear();
}
return 0;
}

URJC2_C — Spoj

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

Solución — URJC2_C

#include <bits/stdc++.h>
using namespace std;
int main()
{
int i;
cin>>i;
while(i--)
{
 int p,m;
 cin>>p>>m;
 while(p--)
 {
 int n;
 cin>>n;
 if(n<m)
 cout<<"Yes, it blends!\n";
 else
 cout<<"Well, it mostly blended\n";
 }
}
return 0;
}

URJC2_D — Spoj

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

Solución — URJC2_D

#include <bits/stdc++.h>
using namespace std;
bool alfabeto[27];
void alfa(char letra)
{
 int numero = letra-97;
 alfabeto[numero]=true;
}
bool comprobar(char letra)
{
 int numero = letra-97;
 if(alfabeto[numero])
 return true;
 else return false;
}

int main()
{
int i;
cin>>i;
while(i--)
{
 for(int i=0;i<27;i++)
 {
 alfabeto[i]=false;
 }
 int total=0;
 string sabido, leer;
 cin>>sabido;
 for(int p=0; p<sabido.length();p++)
 {
 alfa(sabido[p]);

 }
 cin>>leer;
 for(int p=0; p<leer.length();p++)
 {
 bool a;
 a=comprobar(leer[p]);
 if(a)
 total+=50;
 else
 total+=150;
 alfa(leer[p]);
 }
 cout<<total<<endl;

}
return 0;
}

URJC2_E — Spoj

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

Solución — URJC2_E

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

int main(){
 int t,k,h,n,auxi,contador=0;
 cin>>t;
 while(t--){
 cin>>k>>h>>n;
 n++;
 int principal[k][n];
 for(int m=0;m<k;m++)
 {
 for(int g=1;g<n;g++)
 {
 cin>>auxi;
 contador+=auxi;
 principal[m][g]=contador;
 }
 principal[m][n-n]=0;
 contador=0;
 }
 int d, inicio,fin,estresados=0;
 cin>>d;
 while(d--){
 cin>>inicio>>fin;
 for(int i=0;i<k;i++){
 if((principal[i][fin]-principal[i][inicio - 1])>h)
 estresados ++;
 }
 printf("%d - %d\n",estresados,k-estresados);
 estresados=0;
 }
 }
}

URJC3_A — Spoj

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

Solución — URJC3_A

//CONCURSO URJC3 CLASIFICATORIO SWERC

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

struct punto{
 long long int x;
 long long int y;
 long long int z;
};
int check[3010];
vector<punto> q;
long long int eucle;
int m=0;
punto a;
void dfs(int x, punto actual)
{
 check[x]=1;
 for(long long int i=0;i<q.size();i++)
 {
 if(!check[i])
 {
 long double myDistance=sqrt(pow(q[i].x-actual.x,2.0)+pow(q[i].y-actual.y,2.0)+pow(q[i].z-actual.z,2.0));
 if(myDistance<=eucle)
 {

 a.x = q[i].x;
 a.y = q[i].y;
 a.z = q[i].z;
 dfs(i,a);
 }
 }
 }
}

int main()
{
 long long int l,to,x,y,z,count;
 cin>>l;
 while(l--)
 {
 count = 0;
 memset(check,0,sizeof(check)); //Pone a 0 el array
 cin>>to>>eucle;
 for(int i=0; i<to;i++)
 {
 cin>>x>>y>>z;
 q.push_back(punto{x,y,z});
 }
 for(unsigned int i=0;i<q.size();i++)
 {
 if(!check[i])
 {
 check[i]=1;
 punto actual;
 actual.x = q[i].x;
 actual.y = q[i].y;
 actual.z = q[i].z;
 m=i;
 dfs(i,actual);
 count++;
 }
 }
 cout<<count<<"\n";
 q.clear();
 }
return 0;
}

URJC3_C — Spoj

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

Solución — URJC3_C

//Problema C

 //Triangulos de Pascal
#include <bits/stdc++.h>
using namespace std;
int main()
{
 int m,n,x,temp;
 cin>>m;
 while(m--)
 {
 cin >> temp>>n;
 for(int i=0;i<n;i++)
 {
 x=temp;
 for(int k=0;k<=i;k++)
 {
 cout << x<<" ";
 x = x *(i-k)/(k+1);
 }
 cout << endl;
 }
 }
 return 0;
}

URJC3_D — Spoj

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

Solución — URJC3_D

//Problema D
//caso espacio entre consonante y vocal
//Notas de canciones solo consonante vocal
/*
#include <bits/stdc++.h>
using namespace std;
int main()
{
 string m;
 int k;
 cin>>k;
 cin.ignore();
 while(k--)
 {
 int resultado=0;
 bool consonante=false;
 getline(cin,m);
 for(unsigned int i=0; i<m.length();i++)
 {
 if(consonante&&(m[i]=='a'||m[i]=='e'||m[i]=='i'||m[i]=='o'||m[i]=='u'))
 {
 resultado++;
 consonante=false;
 }
 else if(m[i]==' ')
 {
 consonante=false;
 }
 else
 {
 consonante=true;
 }
 }
 cout<<resultado<<endl;
 }
 return 0;
}
*/
//Problema D con espaciador deespacios

#include <bits/stdc++.h>
using namespace std;
int main()
{
 string m;
 int k;
 cin>>k;
 cin.ignore();
 while(k--)
 {
 long long int resultado=0;
 bool res = true;
 getline(cin,m);
 for(unsigned int i=0; i<m.length();i++)
 {
 if((m[i]=='a'||m[i]=='e'||m[i]=='i'||m[i]=='o'||m[i]=='u')&&res)
 {
 resultado++;
 res =false;

 }
 else if((m[i]=='a'||m[i]=='e'||m[i]=='i'||m[i]=='o'||m[i]=='u'))
 continue;
 else
 {
 res = true;
 }
 }
 cout<<resultado<<endl;
 }
 return 0;
}

URJC3_E — Spoj

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

Solución — URJC3_E

//Problema E
//Bar Progress

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int m;
 cin>>m;
 while(m--)
 {
 long double a,b;
 cin>>a>>b;
 if(a==b)
 cout<<"||||||||||\n";
 else if(a==0)
 cout<<"----------\n";
 else
 {
 long double k = (a/b)*10;
 int a = (int) k;
 if(k>a)
 a++;
 for(int i=1; i<=10;i++)
 {
 if(a>=i)
 cout<<"|";
 else
 cout<<"-";
 }
 cout<<endl;
 }
 }
 return 0;

}

URJC4_A — Spoj

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

Solución — URJC4_A

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

int main()
{
 int cases;
 while(scanf("%d",&cases)==1)
 {
 vector<string> s;
 for(int i=0; i<cases;i++)
 {
 string aux; cin>>aux;
 s.push_back(aux);
 }
 int num = 0;
 for(int i=0; i<cases;i++)
 for(int j=0; j<cases;j++)
 {
 string a = s[i];
 string b = s[j];
 if(i!=j && a.substr(a.length()-2,a.length())==b.substr(0,2))
 num++;
 }
 cout<<num<<endl;
 }
 return 0;
}

URJC4_B — Spoj

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

Solución — URJC4_B

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

int main()
{
 int cases; cin>>cases;
 while(cases--)
 {
 int n,m,flag=1; cin>>n>>m;
 string name;
 for(int i=0; i<m;i++)
 {
 bool posible=true;
 int m1,n1;
 cin>>name;
 cin>>m1;
 for(int j=1; j<n;j++)
 {
 cin>>n1;
 if(m1>=n1) posible=false;
 m1=n1;
 }
 if(flag==1&&posible) { cout<<name; flag=0;}
 else if(posible)cout<<" "<<name;
 }
 cout<<endl;
 }
 return 0;
}

URJC4_C — Spoj

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

Solución — URJC4_C

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

bool bisiesto(int numero)
{
 if (numero % 4 == 0 && numero %100!= 0) return true;
 else if (numero %4 == 0 && numero %100 == 0 && numero %400 == 0) return true;
 else return false;
}
int main()
{
 int cases;
 cin>>cases;
 while(cases--)
 {
 int n; cin>>n;
 if(bisiesto(n)) n++;
 while(!bisiesto(n))
 n++;
 cout<<n<<endl;
 }
 return 0;
}

URJC4_D — Spoj

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

Solución — URJC4_D

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

int color[100100];
vector<int> adj[100100];
bool posible;
bool visitado[100100];
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 edge,x,y,N,cases;
 cin>>cases;
 while(cases--)
 {
 posible=true;
 memset(color,-1,sizeof(color));
 memset(visitado,false,sizeof(visitado));
 cin>>N>>edge;
 for(int i=0; i<=N;i++)
 adj[i].clear();
 for(int i=0;i<edge;i++)
 {
 cin>>x>>y;
 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<<"SI\n";
 else cout<<"NO\n";
 }
 return 0;
}

URJC4_E — Spoj

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

Solución — URJC4_E

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