506. Relative Ranks

方法一，借助关联容器，此方法时间复杂度和空间复杂度都较高

 1 class Solution 
 2 {
 3 public:
 4     vector<string> findRelativeRanks(vector<int>& nums) 
 5     {
 6         int sz=nums.size();
 7         vector<int> copynums=nums;
 8         sort(copynums.begin(),copynums.end());
 9         reverse(copynums.begin(),copynums.end());
10         unordered_map<int,int> itoimap;
11         int rank=0;
12         for(int i:copynums)   
13             itoimap[i]=++rank;
14         vector<string> res(sz);
15         for(int j=0;j<sz;j++)
16         {
17             if(itoimap[nums[j]]==1)
18                 res[j]="Gold Medal";
19             else if(itoimap[nums[j]]==2)
20                 res[j]="Silver Medal";
21             else if(itoimap[nums[j]]==3)
22                 res[j]="Bronze Medal";
23             else
24                 res[j]=to_string(itoimap[nums[j]]);
25         }
26         return res;
27     }
28 };

方法二，核心思想是把分数当做下标，最大的分数下标最远。

新建一个容器，把分数作为下标，将该下标处的值置该分数在原容器中的位置。

之后从右到左扫描容器，顺序输出排名即可

 1 class Solution {
 2 public:
 3     string rankString(int rank) {
 4         if (rank == 1) return "Gold Medal";
 5         if (rank == 2) return "Silver Medal";
 6         if (rank == 3) return "Bronze Medal";
 7         return to_string(rank);
 8     }
 9     
10     vector<string> findRelativeRanks(vector<int>& nums) {
11         if (nums.size() == 0) return vector<string>();
12         
13         int m = nums[0];
14         for (int i = 0; i < nums.size(); i++) {
15             if (nums[i] > m) m = nums[i];
16         }
17         
18         vector<int> index(m + 1, -1);
19         
20         for (int i = 0; i < nums.size(); i++) {
21             index[nums[i]] = i;
22         }
23         
24         vector<string> rank(nums.size());
25         int current_rank = 1;
26         
27         for (int j = index.size() - 1; j >= 0; --j) {
28             if (index[j] >= 0) {
29                 rank[index[j]] = rankString(current_rank);
30                 current_rank++;
31             }
32         }
33         
34         return rank;
35     }
36 };

此方法时间复杂度和空间复杂度均较低。