Solución al problema: 10004 - Islas [http://acm.cs.buap.mx] con Java

Para ver el link del problema Click aqui

import java.util.Scanner;
import java.util.Stack;

/**
 * Solución al problema: 10004 - Islas [http://acm.cs.buap.mx]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0b 18 feb. 2017
 */
// ACETTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  int n; // dimension del mapa
  char[][] mapa;
  int i; // para los bucles

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  do {
   n = Lee.nextInt();
   if (n > 0) {
    mapa = new char[n][n];
    for (i = 0; i < n; i++) {
     mapa[i] = Lee.next().toCharArray();
    }
    System.out.println(obtenerSolucion(n, mapa));
   }
  } while (Lee.hasNext() && n != 0);
  Lee.close();
 }

 /**
  * Metodo que obtiene la solucion del problema
  * 
  * @param n
  *            Dimension del mapa
  * @param mapa
  *            Matriz que representa el mapa
  * @return Un String que representa la solucion
  */
 public static String obtenerSolucion(int n, char[][] mapa) {
  int[][] mp = new int[n][n]; // mapa de numeros
  // int[] dimIslas = new int[n * n]; // dimension de las islas
  int numIsla = 0;
  int i, j; // para los bucles

  // recorremos la matriz del mapa
  for (i = 0; i < n; i++) {
   for (j = 0; j < n; j++) {
    if (mapa[i][j] != 'm') {
     // pintamos la isla
     if (mp[i][j] == 0) {
      // si no esta pintado ya
      Stack pila = new Stack();
      pila.push(i); // introcucimos la primera coordenada
      pila.push(j);
      while (!pila.isEmpty()) {
       int ind_j = pila.pop();
       int ind_i = pila.pop();
       // System.out.println(ind_j + "," + ind_i);
       // buscamos los alrededores
       // coordenada NorOeste
       if (ind_i > 0 && ind_j > 0 && mapa[ind_i - 1][ind_j - 1] == 't'
         && mp[ind_i - 1][ind_j - 1] == 0) {
        pila.push(ind_i - 1);
        pila.push(ind_j - 1);
       }
       // coordenada Norte
       if (ind_i > 0 && mapa[ind_i - 1][ind_j] == 't' && mp[ind_i - 1][ind_j] == 0) {
        pila.push(ind_i - 1);
        pila.push(ind_j);
       }
       // coordenada NorEste
       if (ind_i > 0 && ind_j + 1 < n && mapa[ind_i - 1][ind_j + 1] == 't'
         && mp[ind_i - 1][ind_j + 1] == 0) {
        pila.push(ind_i - 1);
        pila.push(ind_j + 1);
       }
       // Oeste
       if (ind_j > 0 && mapa[ind_i][ind_j - 1] == 't' && mp[ind_i][ind_j - 1] == 0) {
        pila.push(ind_i);
        pila.push(ind_j - 1);
       }
       // coordenada Este
       if (ind_j + 1 < n && mapa[ind_i][ind_j + 1] == 't' && mp[ind_i][ind_j + 1] == 0) {
        pila.push(ind_i);
        pila.push(ind_j + 1);
       }
       // coordenada SurOeste
       if (ind_i + 1 < n && ind_j > 0 && mapa[ind_i + 1][ind_j - 1] == 't'
         && mp[ind_i + 1][ind_j - 1] == 0) {
        pila.push(ind_i + 1);
        pila.push(ind_j - 1);
       }
       // coordenada Sur
       if (ind_i + 1 < n && mapa[ind_i + 1][ind_j] == 't' && mp[ind_i + 1][ind_j] == 0) {
        pila.push(ind_i + 1);
        pila.push(ind_j);
       }
       // coordenada SurEste
       if (ind_i + 1 < n && ind_j + 1 < n && mapa[ind_i + 1][ind_j + 1] == 't'
         && mp[ind_i + 1][ind_j + 1] == 0) {
        pila.push(ind_i + 1);
        pila.push(ind_j + 1);
       }
       mp[ind_i][ind_j] = numIsla + 1;
      }
      numIsla++;
     }
    }
   }
  }

  // si no hay islas o solo hay una
  if (numIsla == 0)
   return "No hay islas";
  if (numIsla == 1)
   return "Solo hay una isla";

  // buscamos el menor y la mayor dimension
  int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
  for (int isla = 1; isla <= numIsla; isla++) {
   int cont = 0;
   for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
     if (mp[i][j] > 0 && mp[i][j] == isla)
      cont++;
   if (cont > 0 && cont < min)
    min = cont;
   if (cont > max)
    max = cont;
  }
  return min + " " + max;
 }
}

Solución al problema: 10003 - Burrito Amarrado [http://acm.cs.buap.mx] con Java

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solución al problema: 10003 - Burrito Amarrado [http://acm.cs.buap.mx]
 */

/**
 * @author BreakDark (Jhonny Monrroy)
 * @version 2.0 b 18 feb. 2017
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para los datos de entrada
  int r, n; /// radio y numero de intentos

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  do {
   r = Lee.nextInt();
   n = Lee.nextInt();
   if (r != 0 && n != 0)
    System.out.println(obtenerSolucion(r, n));
  } while (Lee.hasNext() && r != 0 && n != 0);
  Lee.close();
 }

 /**
  * Metodo que obtiene la solucion del problema
  * 
  * @param r
  *            Radio del corral
  * @param n
  *            Numero de intentos
  * @return Un String que representa la distancia del burrito al poste
  */
 public static String obtenerSolucion(int r, int n) {
  double x = 0, y = 0; // coordenadas del burrito
  byte dir = 0; // 0=norte, 1=este, 2=sur, 3=oeste

  while (n-- > 0) {
   switch (dir) {
   case 0: // norte
    y = (y + Math.sqrt(r * r - x * x)) / 2;
    break;
   case 1: // este
    x = (x + Math.sqrt(r * r - y * y)) / 2;
    break;
   case 2: // sur
    y = (y - Math.sqrt(r * r - x * x)) / 2;
    break;
   default: // oeste
    x = (x - Math.sqrt(r * r - y * y)) / 2;
    dir = -1; // para volver a empezar desde el principio
    break;
   }
   dir++;
  }
  // mostramos el resultado
  return String.format("%.2f", Math.sqrt(x * x + y * y)).replace(',', '.');
 }
}

Solución al problema: 10002 - El inspector [http://acm.cs.buap.mx] con Java

Para ver el link del problema Click aqui

import java.util.BitSet;
import java.util.PriorityQueue;
import java.util.Scanner;

/**
 * Solución al problema: 10002 - El inspector [http://acm.cs.buap.mx]
 * 
 * @author BreakDark
 * @version 1.0b 17 feb. 2017
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  int n; // numero de casos de prueba
  String p; // nombre de la poblacion
  String s; // informacion de los cultivos

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  n = Integer.parseInt(Lee.nextLine());
  while (n-- > 0) {
   p = Lee.nextLine();
   s = Lee.nextLine();
   System.out.print(procesar(p, s));
  }
  Lee.close();
 }

 /**
  * Metodo que resueleve el problema
  * 
  * @param p
  *            Nombre de la poblacion
  * @param s
  *            Informacion de los cultivos
  */
 static String procesar(String p, String s) {
  String resp = "";
  // contamos los cultivos
  int dim = 'z' - 'a' + 1, i;
  BitSet tipoCultivos = new BitSet(dim - 1);
  char letra;
  int d = 0; // desconocidos
  int[] cultivos = new int[dim];
  for (i = 0; i < s.length(); i++) {
   letra = s.charAt(i);
   if (letra != '*') {
    tipoCultivos.set(letra - 'a');
    cultivos[letra - 'a']++;
   } else
    d++;
  }
  resp += "POBLACION: " + p + "\n";
  resp += "TIPOS DE CULTIVOS: " + tipoCultivos.cardinality() + "\n";
  resp += "DESCONOCIDOS: " + d + "\n";
  resp += "CANTIDADES:" + "\n";
  // mostramos los conteos de los cultivos
  PriorityQueue cola = new PriorityQueue();
  for (i = 0; i < dim; i++) {
   // adicionamos los valores a una cola de prioridad
   if (cultivos[i] > 0)
    cola.add(new CultivoValor((char) ('a' + i), cultivos[i]));
   // resp += (char) ('a' + i) + " - " + cultivos[i] + "\n";
  }
  // mostramos la cola
  while (!cola.isEmpty()) {
   CultivoValor cv = cola.poll();
   resp += cv.cult + " - " + cv.val + "\n";
  }
  return resp;
 }
}

class CultivoValor implements Comparable {
 char cult;
 int val;

 public CultivoValor(char c, int v) {
  this.cult = c;
  this.val = v;
 }

 @Override
 public int compareTo(CultivoValor X) {
  if (X.val - this.val == 0)
   return this.cult - X.cult;
  return X.val - this.val;
 }
}