【】 Semanal Nº 180

Número de la suerte matriz C_01

Dada la mañana * n matriz de números distintos, devolver todos los números de la suerte en la matriz en cualquier orden.

Un número de la suerte es un elemento de la matriz de tal manera que es el elemento mínimo en su fila y máximo en su columna.

Example 1:
Input: matrix = [[3,7,8],[9,11,13],[15,16,17]]
Output: [15]
Explanation: 15 is the only lucky number since it is the minimum in its row and the maximum in its column

Método uno: Analógico

public List<Integer> luckyNumbers (int[][] matrix) {
  int m = matrix.length;
  int n = matrix[0].length;
  LinkedList<Integer> res = new LinkedList<>();
  
  for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
      int min = matrix[i][j];
      boolean minR = true;
      boolean maxC = true;
      //检查行，
      for (int c = 0; c < n; c++) {
        if (matrix[i][c] < min) {
          minR = false;
          break;
        }
      }
      //检查列
      for (int r = 0; r < m; r++) {
        if (matrix[r][j] > min)
          maxC = false;
      }
      if (maxC && minR)
        res.add(min);
      }
  }
  return res;
}

Análisis de la complejidad

• Complejidad de tiempo: $O (n × m)$ ,
• Espacio de la complejidad: $O (1)$ ,

---

B_02 diseñado para soportar una operación de incremento pila

Se diseña una pila de la siguiente apoyo operativo. Implementar una clase de pila CustomStack personalizado:

CustomStack(int maxSize)：用 maxSize 初始化对象，maxSize 是栈中最多能容纳的元素数量，栈在增长到 maxSize 之后则不支持 push 操作。
void push(int x)：如果栈还未增长到 maxSize ，就将 x 添加到栈顶。
int pop()：返回栈顶的值，或栈为空时返回 -1 。
void inc(int k, int val)：栈底的 k 个元素的值都增加 val 。如果栈中元素总数小于 k ，则栈中的所有元素都增加 val 。

Método uno: Analógico

class CustomStack {
  int[] stack;
  int pTop;
  int size;
  int max;
  public CustomStack(int maxSize) {
    stack = new int[maxSize];
    max = maxSize;
    size = 0;
    pTop = -1;
  }

  public void push(int x) {
    if (size == max) {
      return;
    }
    stack[++pTop] = x;
    size++;
  }

  public int pop() {
    if (size == 0) {
      return -1;
    }
    size--;
    return stack[pTop--];
  }

  public void increment(int k, int val) {
  	int bound = Math.min(size, k);
  	for (int i = 0; i < bound; i++) {
        stack[i] += val;
    }
  }
}

---

B_03 se convertirá en árbol binario de búsqueda equilibrado

Dado un árbol de búsqueda binaria, devolver un árbol binario de búsqueda equilibrado con los mismos valores de los nodos.

Un árbol de búsqueda binaria está equilibrado si y sólo si la profundidad de las dos subárboles de cada nodo no difiere en más de 1.

Si hay más de una respuesta, devolver cualquiera de ellos.

Input: root = [1,null,2,null,3,null,4,null,null]
Output: [2,1,3,null,null,null,4]
Explanation: This is not the only correct answer, [3,1,4,null,2,null,null] is also correct.

Método A: DFS + preorden

List<Integer> nums;
public TreeNode balanceBST(TreeNode root) {
  nums = new ArrayList<>();
  inOrder(root);
  return dfs(0, nums.size());
}
//构造
TreeNode dfs(int l, int r) {
  TreeNode root = null;
  if (l == r) {
    return root;
  }
  int mid = (l + r) >>> 1;
  root = new TreeNode(nums.get(mid));
  root.left =  dfs(l, mid);
  root.right = dfs(mid + 1, r);
  return root;
}
//得到有序数组
void inOrder(TreeNode root) {
  if (root == null)
    return;
  inOrder(root.left);
  nums.add(root.val);
  inOrder(root.right);
}

Análisis de la complejidad

• Complejidad de tiempo: $O (n)$ ,
• Espacio de la complejidad: $O (n)$ ,

---

A_04 valor de rendimiento equipo más grande (sin aire acondicionado)

Hay n ingenieros numeradas de 1 a N y dos matrices: velocidad y eficiencia, donde la velocidad [i] y la eficiencia [i] representan la velocidad y la eficiencia para el i-ésimo ingeniero respectivamente. Devuelve el máximo rendimiento de un equipo compuesto por al mayoría de los ingenieros k, ya que la respuesta puede ser un número enorme, devuelva este módulo 10 ^ 9 + 7.

El rendimiento de un equipo es la suma de las velocidades de sus ingenieros multiplicado por la eficiencia mínima entre sus ingenieros.

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
输出：60
解释：
我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。
他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。

Método uno: soluciones equivocadas

final static int MOD = 10^9 + 7;
public int maxPerformance(int n, int[] speed, int[] e, int k) {

  PriorityQueue<Pair> pQ = new PriorityQueue<>((s1, s2) -> s2.speed - s1.speed);

  for (int i = 0; i < n; i++) {
    pQ.add(new Pair(speed[i], i));
    if (pQ.size() > k) {
      pQ.poll();
    }
  }

  int min = e[pQ.peek().index];
  int sum = 0;
  while (k-- > 0) {
    Pair p = pQ.poll();
    min = Math.min(e[p.index], min);
    sum += p.speed;
  }
  return (sum * min) % MOD;
}

class Pair {
  int speed, index;
  public Pair(int _s, int _i) {
    speed = _s; index = _i;
  }
}

Significado de las preguntas: Cuando dos soluciones de igual eficiencia, rapidez y gran esquema de las aparentemente mejor. Transformado en cuestión de cómo obtener rápidamente una eficiencia óptima de cada programa.

algoritmo

• Todo el mundo en orden descendente de acuerdo a la eficiencia e.
• Seleccionar k mayor velocidad en una gran variedad de especies.

public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
  int[][] pair = new int[n][2];
  for (int i = 0; i < n; i++) {
      pair[i][0] = speed[i];
      pair[i][1] = efficiency[i];
  }
  Arrays.sort(pair, (e1, e2) -> e2[1] - e1[1]);
  
  PriorityQueue<Integer> pQ = new PriorityQueue<>();
  long max = 0, sd = 0;
  for (int i = 0; i < n; i++) {
      pQ.add(pair[i][0]);
      sd += pair[i][0];
      if (pQ.size() > k) {
          sd -= pQ.poll();
      }
      max = Math.max(max, sd * pair[i][1]);
  }
  return (int)(max % ((int)1e9 + 7));
}

Análisis de la complejidad

• Complejidad de tiempo: $O (n log n)$ ,
• Espacio de la complejidad: $Okay)$ ,

---