Hacer preguntas Notas
- El nombre de la clase principal se debe a
- Introduzca preguntas acerca de la clase de escáner, el método Scanner.nextInt () sólo puede recibir un número entero positivo, tales como entrada entero negativo será ignorado cabo de un número negativo, que es equivalente a los abs tomadas de entrada (), con el fin de resolver este error, por
int num1 = Integer.parseInt(scanner.next());
Resuelto.
next () y nextLine () recibe cadena;
next () método debe ser una cadena de caracteres válida sólo puede ser recibida por un extremo de entrada de la barra espaciadora encontrado antes de introducir un carácter válido, tecla Tab o la tecla enter, next () el método se eliminará automáticamente después de introducir un carácter válido, la barra espaciadora siguiente () método antes de la entrada posterior, Tab o la tecla enter como un separador o un terminador;
terminador nextLine () método simplemente retorno la llave del coche, nextLine () devuelve el método a todos los personajes tecla enter.
1001 A + B Format (20 minutos)
Calcula a + b y la salida de la suma en el formato estándar - es decir, los dígitos se deben separar en grupos de tres por comas (a menos que haya menos de cuatro dígitos).
Especificación de entrada:
Cada archivo de entrada contiene un caso de prueba. Cada caso contiene un par de números enteros a y b, donde -10 6 ≤a, b≤10 6. Los números están separados por un espacio.
Especificación de la salida:
Para cada caso de prueba, se debe dar salida a la suma de A y B en una línea. La suma debe ser escrito en el formato estándar.
Ejemplo de entrada:
-1000000 9
Salida de muestra:
-999991
Solución
import java.util.LinkedList;
import java.util.Scanner;
//CreateTime: 2019/3/21 23:21
//Author: 月小水长(https://github.com/inspurer/PAT)
/*
类名:首字母大写，其他单词中首字母大写，其他小写
方法名:首字母小写，其他单词中首字母大写，其他小写
变量:与方法名规则同
包名:全部小写
*/
public class Main {
public static void main(String [] args){
Scanner scanner = new Scanner(System.in);
int num1 = Integer.parseInt(scanner.next());
int num2 = Integer.parseInt(scanner.next());
scanner.close();
num1 += num2;
int flag = num1>=0?1:0;
num1 = num1>0?num1:-num1;
if(String.valueOf(num1).length()<4) {
if (flag == 0) {
System.out.print(-num1);
} else {
System.out.print(num1);
}
return;
}
LinkedList<String> result = new LinkedList<String>();
do{
result.add(String.valueOf(num1%10));
num1 /= 10;
if((result.size()+1)%4==0&&num1>0){
result.add(",");
}
}while (num1>0);
if(flag==0){
result.add("-");
}
for(int i = result.size()-1;i>=0;i--)
System.out.print(result.get(i));
}
}
1002 A + B para los polinomios (25 分)
En esta ocasión, se supone que encontrar A + B donde A y B son dos polinomios.
Especificación de entrada:
Cada archivo de entrada contiene un caso de prueba. Cada caso ocupa 2 líneas, y cada línea contiene la información de un polinomio:
KN 1 un N 1 N 2 un N 2 ... N K a N K
donde K es el número de términos no nulos en el polinomio, N i y una N i (i = 1,2, ⋯, K) son los exponentes y coeficientes, respectivamente. Se da que 1≤K≤10,0≤N K <⋯ <N 2 <N 1 ≤1000.
Especificación de la salida:
Para cada caso de prueba que debe ser la salida a la suma de A y B en una línea, con el mismo formato que el de entrada. Tenga en cuenta que debe haber un espacio NO extra al final de cada línea. Por favor, tener una precisión de 1 posición.
Ejemplo de entrada:
2 1 2,4 0 3,2
2 2 1,5 1 0,5
Salida de muestra:
3 2 1,5 1 2,9 0 3,2
Solución
import java.util.*;
//CreateTime: 2019/3/21 23:21
//Author: 月小水长(https://github.com/inspurer/PAT)
/*
类名:首字母大写，其他单词中首字母大写，其他小写
方法名:首字母小写，其他单词中首字母大写，其他小写
变量:与方法名规则同
包名:全部小写
*/
public class Main {
public static void main(String [] args){
Scanner sc = new Scanner(System.in);
String aLine = null;
String [] l = null;
HashMap<Integer,Float> [] hm = new HashMap[2];
for(int i = 0; i < 2; i++){
aLine = sc.nextLine();
l = aLine.split(" ");
hm[i] = new HashMap<Integer, Float>(Integer.parseInt(l[0]));
for(int j = 1; j < l.length; j += 2){
hm[i].put(Integer.parseInt(l[j]),Float.parseFloat(l[j+1]));
}
}
sc.close();
HashSet<Integer> setKeys = new HashSet<>(hm[0].keySet());
setKeys.addAll(hm[1].keySet());
ArrayList<Integer> sumKeys = new ArrayList<>(setKeys);
HashMap<Integer,Float> res = new HashMap<Integer,Float>();
// 排除掉系数为 0
for(int i = 0; i < sumKeys.size(); i++){
int key = sumKeys.get(i);
float value = hm[0].getOrDefault(key,0.0f)+hm[1].getOrDefault(key,0.0f);
if(value == 0.0f)
continue;
res.put(key,value);
}
ArrayList resultKeys = new ArrayList(res.keySet());
Collections.sort(resultKeys, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
// 如果项数为0，只把0输出就可以了
if(res.size() == 0) {
System.out.print(0);
return;
}
System.out.print(res.size());
System.out.print(" ");
for(int i = 0; i < resultKeys.size(); i++){
int key = (int)resultKeys.get(i);
System.out.print(key);
System.out.print(" ");
System.out.printf("%.1f",res.get(key));
if(i == resultKeys.size() - 1)
break;
System.out.print(" ");
}
}
}
/*
格式错误，要求跟输入一样，浮点数保留一位小数，最后不能有空格
没有考虑到如果两个多项式相加，会出现系数为0的情况，此时不再记录（多虑的是demo分明有0输出了么，但是它是指数不是系数）
数据的类型，一定尽量开始就合适
*/
1003 de emergencia (25 分)
Como líder del equipo de rescate de emergencia de una ciudad, se le da un mapa especial de su país. El mapa muestra varias ciudades dispersas conectadas por algunas carreteras. Cantidad de los equipos de rescate en cada ciudad y la longitud de cada carretera entre cualquier par de ciudades están marcados en el mapa. Cuando hay una llamada de emergencia a usted de alguna otra ciudad, su trabajo consiste en conducir a sus hombres al lugar tan pronto como sea posible, y en la media hora, llamar a la mayor cantidad de manos en la manera de lo posible.
Especificación de entrada:
Cada archivo de entrada contiene un caso de prueba. Para cada caso de prueba, la primera línea contiene 4 números enteros positivos: N (≤500) - el número de ciudades (y las ciudades están numeradas de 0 a N-1), M - el número de caminos, C 1 y C2 - las ciudades que se encuentra actualmente y que debe guardar, respectivamente. La siguiente línea contiene N enteros, donde el i-ésimo número entero es el número de equipos de rescate en el i-ésimo de la ciudad. Entonces M líneas siguen, cada una describe una carretera con tres enteros c 1, c 2 y L, que son el par de ciudades conectadas por una carretera y la longitud de esa carretera, respectivamente. Se garantiza que existe al menos un camino de C 1 a C 2.
Especificación de la salida:
Para cada caso de prueba, imprima en una línea de dos números: el número de diferentes caminos más cortos entre C1 y C2, y la cantidad máxima de los equipos de rescate que posiblemente puede recoger. Todos los números en una línea deben estar separados por un espacio exactamente, y no hay espacio adicional permitido al final de una línea.
Ejemplo de entrada:
5 6 0 2
1 2 1 5 3
0 1 1
0 2 2
0 3 1
1 2 1
2 4 1
3 4 1
Salida de muestra:
2 4
Solución
import java.util.*;
//CreateTime: 2019/3/21 23:21
//Author: 月小水长(https://github.com/inspurer)
/*
类名:首字母大写，其他单词中首字母大写，其他小写
方法名:首字母小写，其他单词中首字母大写，其他小写
变量:与方法名规则同
包名:全部小写
*/
public class Main {
public static void main(String [] args){
int maxPathLength = 66666666;
Scanner sc = new Scanner(System.in);
int numOfCities = sc.nextInt();
int numOfRoads = sc.nextInt();
int C1 = sc.nextInt();
int C2 = sc.nextInt();
// 城市 i 的救援队数
int [] numOfRescue = new int[numOfCities];
int [][] roads = new int [numOfCities][numOfCities];
for(int i = 0; i < numOfCities; i++){
numOfRescue[i] = sc.nextInt();
}
//构建无向图
for(int i = 0; i < numOfCities; i++)
for(int j = 0; j < numOfCities; j++)
roads[i][j] = maxPathLength;
int start,stop,value;
for(int i = 0; i < numOfRoads; i++){
start = sc.nextInt();
stop = sc.nextInt();
value = sc.nextInt();
roads[start][stop] = value;
roads[stop][start] = value;
}
// 标记城市 i 是否被访问过
Boolean [] visited = new Boolean[numOfCities];
for(int i = 0; i < numOfCities; i++){
visited[i] = false;
}
// 到城市 i 的最短路径长度
int [] lengthOfShortestPath = new int[numOfCities];
for(int i = 0; i < numOfCities; i++){
lengthOfShortestPath[i] = maxPathLength;
}
// 到城市 i 的最短路径条数
int [] numOfShortestPath = new int[numOfCities];
for(int i = 0; i < numOfCities; i++){
numOfShortestPath[i] = 0;
}
// 到城市 i 的总救援队数
int [] numOfTotalRescue = new int[numOfCities];
for(int i = 0; i < numOfCities; i++){
numOfTotalRescue[i] = 0;
}
// visited[C1] = true;
lengthOfShortestPath[C1] = 0;
numOfShortestPath[C1] = 1;
numOfTotalRescue[C1] = numOfRescue[C1];
for(int i = 0; i < numOfCities; i++){
int min = maxPathLength;
int u = -1;
for(int j = 0; j < numOfCities; j++){
if(!visited[j]&&lengthOfShortestPath[j]<min){
min = lengthOfShortestPath[j];
u = j;
}
}
if(u == -1){
break;
}
visited[u] = true;
for(int k = 0; k < numOfCities; k++){
if(!visited[k]&&roads[u][k]!=maxPathLength){
if(lengthOfShortestPath[k] > lengthOfShortestPath[u] + roads[u][k]){
lengthOfShortestPath[k] = lengthOfShortestPath[u] + roads[u][k];
numOfShortestPath[k] = numOfShortestPath[u];
numOfTotalRescue[k] = numOfTotalRescue[u] + numOfRescue[k];
}
else if(lengthOfShortestPath[k] == lengthOfShortestPath[u] + roads[u][k]){
numOfShortestPath[k] += numOfShortestPath[u];
if(numOfTotalRescue[u] + numOfRescue[k] > numOfTotalRescue[k]){
numOfTotalRescue[k] = numOfTotalRescue[u] + numOfRescue[k];
}
}
}
}
}
System.out.printf("%d %d",numOfShortestPath[C2],numOfTotalRescue[C2]);
}
}
1004 hojas, contando (30 分)
Una jerarquía de la familia se presenta generalmente por un árbol genealógico. Su trabajo consiste en contar los miembros de la familia que no tienen ningún hijo.
Especificación de entrada:
Cada archivo de entrada contiene un caso de prueba. Cada caso comienza con una línea que contiene 0 <n <100, el número de nodos en un árbol, y M (<N), el número de nodos que no son hojas. Luego siguen las líneas M, cada uno en el formato:
ID K ID [1] ID [2] ... ID [K]
donde ID es un número de dos dígitos que representa un nodo no hoja dado, K es el número de sus hijos, seguido de una secuencia de ID de dos dígitos es de sus hijos. En aras de la simplicidad, vamos a arreglar el ID de raíz a ser 01.
Los extremos de entrada con N siendo 0. este caso, no debe ser procesada.
Especificación de la salida:
Para cada caso de prueba, que se supone que contar aquellos miembros de la familia que no tienen ningún hijo para todos los niveles de antigüedad a partir de la raíz. Los números deben ser impresos en una línea, separadas por un espacio, y debe haber ningún espacio adicional al final de cada línea.
El caso muestra representa un árbol con sólo 2 nodos, donde 01 es la raíz y 02 es su único hijo. Por lo tanto en el nivel de raíz 01, hay 0 nodo hoja; y en el siguiente nivel, hay 1 nodo hoja. Entonces debe ser la salida 0 1 en una línea.
Ejemplo de entrada:
2 1
01 1 02
Salida de muestra:
0 1
Solución
(Este código es aprender de nuestros predecesores)
#include <vector>
#include<stdio.h>
#include <algorithm>
using namespace std;
vector<int> v[100];
int book[100], maxdepth = -1;
void dfs(int index, int depth) {
if(v[index].size() == 0) {
book[depth]++;
maxdepth = max(maxdepth, depth);
return ;
}
for(int i = 0; i < v[index].size(); i++)
dfs(v[index][i], depth + 1);
}
int main() {
int n, m, k, node, c;
scanf("%d %d", &n, &m);
for(int i = 0; i < m; i++) {
scanf("%d %d",&node, &k);
for(int j = 0; j < k; j++) {
scanf("%d", &c);
v[node].push_back(c);
}
}
dfs(1, 0);
printf("%d", book[0]);
for(int i = 1; i <= maxdepth; i++)
printf(" %d", book[i]);
return 0;
}
1005 Mágicas It Right (20 分)
Dado un número entero no negativo N, su tarea consiste en calcular la suma de todos los dígitos de N, y la salida de cada dígito de la suma en Inglés.
Especificación de entrada:
Cada archivo de entrada contiene un caso de prueba. Cada caso ocupa una línea que contiene una N (≤10 100).
Especificación de la salida:
Para cada caso de prueba, la producción en una línea los dígitos de la suma de las palabras en inglés. Debe haber un espacio entre dos palabras consecutivas, pero no hay espacio extra al final de una línea.
Ejemplo de entrada:
12345
Salida de muestra:
Uno Cinco
Solución
import java.util.HashMap;
import java.util.Scanner;
//CreateTime: 2019/3/21 23:21
//Author: 月小水长(https://github.com/inspurer)
/*
类名:首字母大写，其他单词中首字母大写，其他小写
方法名:首字母小写，其他单词中首字母大写，其他小写
变量:与方法名规则同
包名:全部小写
*/
public class Main {
public static void main(String [] args){
Scanner scanner = new Scanner(System.in);
String input = scanner.next();
scanner.close();
int count = 0;
for(int i = 0; i < input.length(); i++){
count += Integer.parseInt(input.substring(i,i+1));
}
HashMap<String,String> hm = new HashMap<String, String>();
hm.put("0","zero");
hm.put("1","one");
hm.put("2","two");
hm.put("3","three");
hm.put("4","four");
hm.put("5","five");
hm.put("6","six");
hm.put("7","seven");
hm.put("8","eight");
hm.put("9","nine");
String res = String.valueOf(count);
System.out.printf("%s",hm.get(res.substring(0,1)));
for(int i = 1; i < res.length(); i++){
System.out.printf(" %s",hm.get(res.substring(i,i+1)));
}
}
}
Do pregunta de reflexión
- Después de hacer cinco preguntas, o encontrar ACM Java sí tienen unas grandes limitaciones, o después de que en C ++. Yo era un plato de pollo.
- Todo el código en mi almacén Github PAT https://github.com/inspurer/PAT la bienvenida a los espectadores.
