【Leetcode】1366. Rank Teams by Votes

题目地址：

https://leetcode.com/problems/rank-teams-by-votes/

给定一个字符串数组$A$，题目保证每个字符串只含不同的英文大写字母，且字母构成完全相同（种类相同，次数相同）。每个字符串$s=A[i]$代表的是第$i$个人对字符串所含英文字母的一次排序。要求返回一个字符串$t$，所含字符与$A$里字符串相同，并且按照下面要求排序：
1、被排在第$0$位的人最多的字母位于$t[0]$，若有若干字母被相同人数排在第$0$位，则按它们被排在第$1$位的人数来排，依次类推，如果最后也不分胜负，则按照字典序排；
2、排完第一个字母之后后面排序也按1中的要求进行。

先统计一下每个字母被多少人排在第$0$位、第$1$位等等，然后对所有字母排序即可。代码如下：

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public String rankTeams(String[] votes) {
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < votes[0].length(); i++) {
            list.add(votes[0].charAt(i));
        }
    
        int[][] rank = new int[26][votes[0].length()];
    
        for (String vote : votes) {
            for (int i = 0; i < vote.length(); i++) {
                rank[vote.charAt(i) - 'A'][i]++;
            }
        }
    
        list.sort((c1, c2) -> {
            for (int i = 0; i < votes[0].length(); i++) {
            	// 一旦评分人数不同，则分出了胜负
                if (rank[c1 - 'A'][i] != rank[c2 - 'A'][i]) {
                    return -Integer.compare(rank[c1 - 'A'][i], rank[c2 - 'A'][i]);
                }
            }
        
        	// 最后仍然未分胜负，则按字典序排
            return Character.compare(c1, c2);
        });
    
        StringBuilder sb = new StringBuilder();
        for (char ch : list) {
            sb.append(ch);
        }
    
        return sb.toString();
    }
}

时间复杂度$O(nl)$，$n$是字符串个数，$l$是字符串长度，空间$O(l)$。排序的时间可以看成常数，因为英文大写字母最多$26$个。

C++：

class Solution {
 public:
  string rankTeams(vector<string>& votes) {
    unordered_map<char, vector<int>> mp;
    int n = votes[0].size();
    for (auto& vote : votes)
      for (int i = 0; i < n; i++) {
        if (!mp.count(vote[i])) mp[vote[i]] = vector<int>(n, 0);
        mp[vote[i]][i]++;
      }

    string res = votes[0];
    sort(res.begin(), res.end(), [&](char a, char b) {
      auto &av = mp[a], &bv = mp[b];
      for (int i = 0; i < n; i++)
        if (av[i] != bv[i]) return av[i] > bv[i];
      return a < b;
    });

    return res;
  }
};

时空复杂度一样。