Por un lado hay cuatro preguntas de programación.
1. Soportes a juego
Dada una cadena, solo '(', ')', '+', '-', '*', '/', números 0 ~ 9.
Estadísticas de realización: la cantidad de paréntesis coincidentes y la cantidad de paréntesis restantes.
Por ejemplo, (1 + 2 + 3 + 4 + /) ((()) - + ((// *)
devuelve 4,2,0
4: indica que el número de paréntesis coincidentes es 4
2: indica que el número restante de paréntesis izquierdos es 2
0: indica que el número de paréntesis de cierre restantes es 0
Análisis
- Usando la estructura de la pila, el paréntesis izquierdo se empuja sobre la pila, y se encuentra el paréntesis derecho: si la pila no está vacía, la pila se empuja hacia afuera.
Implementación de código (java)
import java.util.*;
public class Solution {
public static void main(String[] args) {
//(1+2+3+4+/)((())-+((//*)
Scanner sc = new Scanner(System.in);
String s = sc.next();
char [] sArr = s.toCharArray();
//记录匹配数
int couple = 0;
//剩余左括号
int left = 0;
//剩余右括号
int right = 0;
Stack<Character> stack = new Stack<>();
//遍历字符串
for (int i = 0; i < sArr.length; i++) {
//找出（
if(sArr[i] == '('){
//入栈
stack.push(sArr[i]);
}else if(sArr[i] == ')'){
//不为空可以匹配
if(!stack.empty()){
stack.pop();
couple++;
}else{
//没有匹配的 剩余右括号增加
right++;
}
}
}
//剩余的肯定是左括号
while(!stack.empty()){
left++;
stack.pop();
}
System.out.print(couple+" ");
System.out.print(left+" ");
System.out.println(right);
}
}
2. número perfecto
Dado un entero positivo R, N. Si R = N ^ m1 + N ^ m2 + ...
mi no es un número repetido.
Como
1, 3 ^ 2 + 3 ^ 3 + 3 ^ 5 = 279
279 es un número perfecto de 3.
La salida 2 3 5
2, 2 ^ 0 = 1
1 es el número perfecto para 2.
La salida 1
3, 3 + 3 ^ 2 + 3 ^ 2 = 19
19 no es un número perfecto de salida 3
1 2 2 (2 repeticiones)
[]
Análisis:
- Tome la potencia máxima, como 44, encuentre 2 ^ 5 primero, ahorre 5
- 44-2 ^ 5 = 12, luego encuentra 2 ^ 3 de 12 y guarda 3
- ...
- El juicio no se repite.
Implementación de código (java)
public static int [] kuaishou2(int R,int N){
int cur = R;
ArrayList<Integer> list = new ArrayList<>();
while(cur > 0){
int res[] = findMax(cur,N);
int m = res[0];
int multi = res[1];
list.add(m);
cur -= multi;
}
int size = list.size();
int res [] = new int[size];
//先看看有没重复的
for (int i = 0; i < list.size()-1; i++) {
if(list.get(i) == list.get(i+1)){
return res;
}
}
//到这就没重复的了 翻位置
for (int i = 0; i < size; i++) {
res[size-1-i] = list.get(i);
}
for (int i = 0; i < res.length; i++) {
System.out.println(res[i]);
}
return res;
}
private static int [] findMax(int cur, int n) {
// n^m 小于等于cur，而且是最接近的
int res [] = new int [2];
int multi = 1;
int times = 0;
while(multi <= cur){
multi *= n;
times++;
}
// res[0] 最高次幂
//res[1] 对应次幂值
res[0] = times-1;
res[1] = multi/n;
return res;
}
3. Problema de colas
Las personas con números i = 1,2,3 ~ n se alinean en la posición j = 1,2,3 ~ n. Todos quieren hacer las cosas lo antes posible. Entonces, cada persona tiene una fórmula de cálculo en una determinada posición para expresar su insatisfacción: ai * (j-1) + bi * (nj), donde j indica que está en la posición j, y hay n posiciones en total. ai, bi son únicos para cada persona y se expresarán en forma de matriz, como a = [8,9,7], b = [5,8,3]. Esto significa que el cliente No. 1 tiene a1 = 8 y b1 = 5. Si se clasifica primero, su insatisfacción es 8 * (1-1) + 5 * (3-1). Pero el jefe que vende cosas quiere que la suma de toda la insatisfacción del cliente sea mínima. Por favor, da la mejor solución.
Por ejemplo: dado a = [8,9,7], b = [5,8,3]
insatisfacción total de salida 37, orden 2,0,1
Análisis
- En primer lugar, este es un problema de arreglo.
implementación de código java
1 、
//总不满意度
static int unsatisify = Integer.MAX_VALUE;
//最优顺序
static int res [] = null;
public static void kuaishou3(int [] a,int [] b){
// a= {8,9,7}
//b={5,8,3}
//排除非正常输入 略
res = new int [a.length];
helper(a,b,new int[a.length],0,new boolean[a.length]);
System.out.println(unsatisify);
for (int i = 0; i < res.length; i++) {
System.out.print(res[i]+" ");
}
}
// seq：当前顺序 cur：到哪了 visited：是否使用过
public static void helper(int a[],int b[],int seq [] ,int cur,boolean [] visited){
//次序好了
if(cur == a.length){
//计算总不满意度
int curValue = calculAll(a, b, seq);
if(curValue < unsatisify){
unsatisify = curValue;
for (int i = 0; i < seq.length; i++) {
//seq装的是 从0开始的顾客编号 要加1
res[i] = seq[i] + 1;
}
}
}else{
//游标cur处 选择合适顾客
for (int i = 0; i < visited.length; i++) {
if(!visited[i]){
//没有参与排队
visited[i] = true;
seq[cur] = i;
helper(a,b,seq,cur+1,visited);
visited[i] = false;
}
}
}
}
//计算某一个顺序的总不满意度 三个数组维度相同 seq数组下标表示位置j=0~ n-1(实际上位置要加1，j+1)
// 下标j对应的元素，seq[j] 属于（0~n-1）是在该位置的顾客编号，实际上的顾客编号要加1
//ai*(j-1)+bi*(n-j)
public static int calculAll(int a[], int [] b,int [] seq){
int sum = 0;
for(int j = 0;j < seq.length;j++){
//j位置 就是第j+1位置
// no是顾客编号 0~n-1
int no = seq[j];
int ai = a[no];
int bi = b[no];
//j+1是从1开始的位置
sum += ai*((j+1)-1) + bi*(seq.length-(j+1));
}
return sum;
}
2. Repentinamente recordado, ¡el retroceso puede ser podado de antemano! ! ! Ahora la función auxiliar se mejora de la siguiente manera: al llamar a la función helperImprove, un curResult adicional indica que los clientes que estaban en cola antes de curIndex no están satisfechos. Si se va a colocar a un cliente en curIndex, si la insatisfacción total en este momento excede la insatisfacción óptima actual, la sucursal se descartará directamente.
// seq：当前顺序 cur：到哪了 visited：是否使用过
public static void helperImprove(int a[],int b[],int seq [] ,int curIndex,boolean [] visited,int curResult){
//次序好了
if(curIndex == a.length){
//计算总不满意度
if(curResult < unsatisify){
unsatisify = curResult;
for (int i = 0; i < seq.length; i++) {
//seq装的是 从0开始的顾客编号 要加1
res[i] = seq[i] + 1;
}
}
}else{
//游标cur处 选择合适顾客
for (int i = 0; i < visited.length; i++) {
if(!visited[i]){
int delta = calculOne(a, b, curIndex, i);
if(curResult + delta < unsatisify){
//没有参与排队
visited[i] = true;
seq[curIndex] = i;
helperImprove(a,b,seq,curIndex+1,visited,curResult + delta);
visited[i] = false;
}
}
}
}
}
public static int calculOne(int a[], int [] b,int pos,int consumer){
int ai = a[consumer];
int bi = b[consumer];
//j+1是从1开始的位置
int sum = ai*((pos+1)-1) + bi*(a.length-(pos+1));
return sum;
}
4. Organizar estaciones de trabajo
Dado un carácter de matriz bidimensional pos [m] [n], que representa m * n estaciones de la compañía, algunas estaciones tienen fuente de alimentación, el elemento de matriz correspondiente es '+', y algunas no tienen fuente de alimentación, el elemento correspondiente es'- '. Ahora quiero organizar a los empleados en un lugar con poder. Debido al impacto de la epidemia, cada empleado no debe tener otros empleados uno al lado del otro. ¿Cuántos empleados se pueden organizar como máximo?
La matriz dada como: [-, +, +, -, -], [+, -, +, -, +], [+, +, +, -, -]
salida 5
Análisis
- Mediante la programación dinámica, configure una matriz booleana m * n bidimensional para indicar si desea organizar a los empleados aquí
- Inicialización, primero organice si hay potencia en (0,0).
- Línea 0 Otro: vea si hay una fuente de alimentación en su propia posición y si hay un arreglo en el lado izquierdo.
- Y el otro en la columna 0: la misma razón que la fila 0.
- A partir de (1,1), primero vea si tiene una fuente de alimentación, pero también si hay empleados en la parte superior e izquierda.
- Finalmente, se atraviesa la matriz booleana y se contará la posición de los empleados.
código java
public static void kuaishou4(char pos[][]){
// char pos [][] = {{'-','+','+','-','-'},{'+','-','+','-','+'},{'+','+','+','-','-'}};
//if() 去除特殊值
int m = pos.length;
int n = pos[0].length;
//默认全false
boolean gongwei [][] = new boolean[m][n];
if(pos[0][0] == '+'){
gongwei[0][0] = true;
}
for(int i = 1;i < m;i++){
//i行0列 如果有电源 而且 上一行0列没有安排员工
if(pos[i][0] == '+' && !gongwei[i-1][0]){
gongwei[i][0] = true;
}
}
for(int i = 1;i < n;i++){
//0行i列 如果有电源 而且 同行上一列没有安排员工
if(pos[0][i] == '+' && !gongwei[0][i-1]){
gongwei[0][i] = true;
}
}
for(int i = 1;i < m;i++){
for(int j = 1;j<n;j++){
if(pos[i][j] =='+' && !gongwei[i-1][j] && !gongwei[i][j-1]){
gongwei[i][j] = true;
}
}
}
int sum = 0;
for(int i = 0;i<gongwei.length;i++){
for(int j=0;j<gongwei[0].length;j++){
if(gongwei[i][j]){
sum++;
}
}
}
System.out.println(sum);
}
