LeetCode1337. 矩阵中战斗力最弱的 K 行

给你一个大小为 m * n 的矩阵 mat，矩阵由若干军人和平民组成，分别用 1 和 0 表示。

请你返回矩阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。

如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。

军人 总是 排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。

示例 1：

输入：mat = 
[[1,1,0,0,0],
 [1,1,1,1,0],
 [1,0,0,0,0],
 [1,1,0,0,0],
 [1,1,1,1,1]], 
k = 3
输出：[2,0,3]
解释：
每行中的军人数目：
行 0 -> 2 
行 1 -> 4 
行 2 -> 1 
行 3 -> 2 
行 4 -> 5 
从最弱到最强对这些行排序后得到 [2,0,3,1,4]
示例 2：

输入：mat = 
[[1,0,0,0],
 [1,1,1,1],
 [1,0,0,0],
 [1,0,0,0]], 
k = 2
输出：[0,2]
解释： 
每行中的军人数目：
行 0 -> 1 
行 1 -> 4 
行 2 -> 1 
行 3 -> 1 
从最弱到最强对这些行排序后得到 [0,2,3,1]
 

提示：

m == mat.length
n == mat[i].length
2 <= n, m <= 100
1 <= k <= m
matrix[i][j] 不是 0 就是 1。

思路就是建立一个军人个数对应行数的哈希（考虑行数可能重复，value值使用vector<int>）

因为行数值是从小到大的，所以哈希的value值（vector<int>一定有序），考虑key值（也就是

军人个数值也可能重复，使用set<int>存储，顺便排序。）

然后遍历一下，取vector<int>的值，小于k的个数即可。（vector<int> 存储的此军人个数相等

的所有行）。下面写的归并请无视，白写的。

#include<iostream>
#include<vector>
#include<set>
#include<unordered_map>
using namespace std;

class Solution {
public:
    vector<int> kWeakestRows(vector<vector<int>>& mat, int k) {
        unordered_map<int, vector<int>> mp; /* key:军人个数，val：行的数组*/

        int lineIndex = 0;          /* 行下标 */
        int soldierIndex = 0;       /* 排序数组下标 */
        set<int> soldierSet;        /* 军人数组去重 */

        vector<int> result;

        for (int i = 0; i < mat.size(); i++) {
            int soldier = 0;
            for (int j = 0; j < mat[i].size(); j++) {
                if (mat[i][j] != 1) {
                    break;
                }
                soldier++;
            }
            soldierSet.insert(soldier);
            mp[soldier].push_back(i);
        }

        /* 排序去重军人 */
        for (set<int>::iterator it = soldierSet.begin(); it != soldierSet.end(); it++){
            if (k == 0) {
                break;
            }
            for (int i = 0; i < mp[*it].size(); i++) {
                if (k == 0) {
                    break;
                }
                result.push_back(mp[*it][i]);
                k--;
            }
        }

        //for (int i = 0; i < soldierArray.size(); i++) {
        //    cout << "solder num:" << soldierArray[i] << endl;
        //    for (int j = 0; j < mp[soldierArray[i]].size(); j++) {
        //        cout << mp[soldierArray[i]][j] << endl;
        //        //result.push_back(mp[soldierArray[i]][j]);
        //    }
        //}

        return result;
    }

public:
    vector<int> merge(vector<int>& arr1, vector<int>& arr2) {
        int index1 = 0, index2 = 0;
        vector<int> result(arr1.size() + arr2.size(), 0);
        while (index1 < arr1.size() && index2 < arr2.size()) {
            if (arr1[index1] <= arr2[index2]) {
                result[index1 + index2] = arr1[index1];
                index1++;
            }
            else {
                result[index1 + index2] = arr2[index2];
                index2++;
            }
        }
        while (index1 < arr1.size()) {
            result[index1 + index2] = arr1[index1];
            index1++;
        }

        while (index2 < arr2.size()) {
            result[index1 + index2] = arr2[index2];
            index2++;
        }
        return result;
    }


    vector<int> mergeSort(vector<int>& arr, int start, int end) {
        if (start >= end) {
            vector<int> res(1, arr[start]);
            return res;
        }
        
        int mid = (start + end) / 2;
        vector<int> left = mergeSort(arr, start, mid);
        vector<int> right = mergeSort(arr, mid + 1, end);

        return merge(left, right);
    }
};


int main() {
    Solution* ps = new Solution();

    vector<vector<int>> test = { {1, 0},{1, 0},{1, 0},{1, 1} };
    vector<int> result =  ps->kWeakestRows(test, 4);

    cout << "result" << endl;

    for (int i = 0; i < result.size(); i++) {
        cout << result[i] << endl;
    }

    system("pause");
	return 0;
}


//vector<int> test = { 9,12,2,41,10,5,8 };
//test = ps->mergeSort(test, 0, test.size()-1);  //白写个归并
//for (int i = 0; i < test.size(); i++) {
//    cout << test[i] << endl;
//}