【週刊】No.180

ラッキーナンバーC_01行列

午前* n個の異なる数字の行列を考えると、任意の順序で行列内のすべての幸運の数字を返します。

幸運な数は、その列内の行と最大最小要素であるように、行列の要素です。

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

方法の一つ：アナログ

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

複雑性分析

• 時間計算： $O（M×N）$、
• 宇宙の複雑さ： $O（1）$、

---

スタックインクリメント操作をサポートするように設計さB_02

あなたは、次のオペレーティング・サポートのスタックを設計します。カスタムスタッククラスCustomStackを実装します。

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 。

方法の一つ：アナログ

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は平衡二分探索木になります

二分探索木を考えると、同じノード値との平衡二分探索木を返します。

二分探索木があればバランスされ、すべてのノードの2つのサブツリーの深さが1以上で異なることはありません場合にのみ。

複数の回答がある場合は、それらのいずれかを返します。

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.

方法a：DFS +予約限定！

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

複雑性分析

• 時間計算： $O（N）$、
• 宇宙の複雑さ： $O（N）$、

---

A_04最大のチームのパフォーマンス値（なし交流）

あるNエンジニアは、n及び二つの配列に1から番号：速度[i]と効率[i]は、それぞれi番目のエンジニアのための速度及び効率を表し、速度と効率を、。答えは膨大な数とすることができるので、ほとんどのk個のエンジニアで構成チームの最高のパフォーマンスを返し、このモジュロ10 ^ 9 + 7を返します。

チームのパフォーマンスは彼らのエンジニアの中で最小の効率を乗じた彼らのエンジニアの速度の合計です。

输入：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 。

方法の一つ：間違ったソリューション

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

質問の意味：場合は同等の効率、スピード、明らかに、より良いの大きいスキームの2つのソリューション。各プログラムの最適な効率を得るどのように迅速に問題に変身。

アルゴリズム

• 効率Eに従って降順でみんな。
• 種の配列にk個の最大速度を選択します。

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

複雑性分析

• 時間計算： $O（N Nログ）$、
• 宇宙の複雑さ： $OK）$、

---