thảo luận Leetcode mỗi ngày

class Solution {
  public int[] kWeakestRows(int[][] mat, int k) {
    int[] ans = new int[k];
    int p = 0;
    int M = mat.length, N = mat[0].length;
    boolean[] used = new boolean[M];
    for (int i = 0; p < k && i < N; ++i) {
      for (int j = 0; p < k && j < M; ++j) {
        if (mat[j][i] == 0 && !used[j]) {
          ans[p++] = j;
          used[j] = true;
        }
      }
    }
    for (int i = 0; p < k; ++i) {
      if (!used[i]) {
        ans[p++] = i;
      }
    }
    return ans;
  }
}

class Solution {
    struct cmp{
        bool operator()(const pair<int,int>& a, const pair<int,int>& b){
            if(a.second == b.second)
                return a.first > b.first;
            return a.second > b.second;
        }
    };
public:
    vector<int> kWeakestRows(vector<vector<int>>& mat, int k) {
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;
        for(int i = 0; i < mat.size(); ++i){
            pq.emplace(make_pair(i, accumulate(mat[i].begin(), mat[i].end(), 0)));
        }
        vector<int> result;
        while(k--){
            result.push_back(pq.top().first);
            pq.pop();
        }
        return result;
    }
};

function kWeakestRows(mat, k) {
  const result = [];
  const rowStrengths = [];

  for (let i = 0; i < mat.length; i++) {
    let count = 0;
    for (let j = 0; j < mat[i].length; j++) {
      if (mat[i][j] === 1) {
        count++;
      } else {
        break;
      }
    }
    rowStrengths.push([i, count]);
  }

  rowStrengths.sort((a, b) => a[1] - b[1] || a[0] - b[0]);

  for (let i = 0; i < k; i++) {
    if (rowStrengths[i] && rowStrengths[i][1] < k) {
      result.push(rowStrengths[i][0]);
    }
  }

  return result;
}

function kWeakestRows(mat: number[][], k: number): number[] {
    const ans = []
    for (let i = 0; i < mat.length; i++) {
        ans.push([i, bs(mat[i])]);
    }
    return ans.sort((a, b) => {
        if (a[1] !== b[1]) {
            return a[1] - b[1];
        } else {
            return a[0] - b[0];
        }
    }).slice(0, k).map(x => x[0]);
};

function bs(arr: number[]) {
    let left = 0, right = arr.length - 1
    while (left <= right) {
        const mid = (left + right) >> 1;
        if (arr[mid] === 1) left++;
        else right--
    }
    return left;
}

class Solution:
    def kWeakestRows(self, mat: List[List[int]], k: int) -> List[int]:
        mat = [(i,sum(mat[i])) for i in range(len(mat))]
        mat.sort(key = lambda x: x[1])
        return [row[0] for row in mat[:k]]

/**
 * @param {number[][]} mat
 * @param {number} k
 * @return {number[]}
 */
var kWeakestRows = function(mat, k) {
    return _.chain(mat)
        .map((row, idx) => [idx, (row.lastIndexOf(1) + 1)* 1000 + idx])
        .sortBy(1)
        .map(0)
        .slice(0, k)
        .value();
};

public class TheKWeakestRowsInMatrix_1337 {
    public static int[] findWeakestRows(int[][] mat, int m, int n, int k) {
   
        int[] soldierCounts = new int[m];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                soldierCounts += mat[j];
            }
        }

       
        int[] result = new int[m];
        for (int i = 0; i < m; i++) {
            result = soldierCounts;
        }
       
        int[] weakestRows = new int[m];
        for (int i = 0; i < m; i++) {
            weakestRows = i;
        }
       
        for (int i = 0; i < m - 1; i++) {
            for (int j = 0; j < m - i - 1; j++) {
                if (result[j] > result[j + 1]) {
                    int temp = result[j];
                    result[j] = result[j + 1];
                    result[j + 1] = temp;

                    int tempRow = weakestRows[j];
                    weakestRows[j] = weakestRows[j + 1];
                    weakestRows[j + 1] = tempRow;
                }
            }
        }

        int[] resultx = new int[k];
        for (int i = 0; i < k; i++) {
            resultx = weakestRows;
        }
       
        return resultx;
       
    }
   


    public static void main(String[] args) {
        int[][] mat = new int[][]{
            {1,0,0,0},
            {1,1,1,1},
            {1,0,0,0},
            {1,0,0,0}
        };
        int m = mat.length;
        int n = mat[0].length;
        int k = 2;

        int[] result = findWeakestRows(mat, m, n, k);
        System.out.println(Arrays.toString(result));
    }
}

class Solution {
    public int[] kWeakestRows(int[][] mat, int k) {
        
        int m = mat.length;
        int n = mat[0].length;
        int[] result = new int[k];
        List<Integer> list = new ArrayList<>();
        int cK = 0;
        
        for (int i = 0; i <= n - 1; i++) {
            if (list.size() == k) break;
            for (int j = 0; j <= m - 1; j++) {
                if (list.size() == k) {
                    break;
                }

                if (list.contains(j) == false && mat[j][i] == 0) {
                    list.add(j);
                    cK++;
                }
            }
        }

        if (list.size() < k) {
            for (int i = 0; i <= k -1; i++) {
                if (list.contains(i) == false && list.size() < k) {
                    list.add(i);
                }
            }
        }

        for (int i = 0; i <= k - 1; i++) {
            result[i] = list.get(i);
        }

        return result;
        
    }
}