class Solution {
public:
    vector<int> optimizeRanking(vector<vector<double>>& students) {
        vector<pair<double, int>> gpaIds;
        for (const auto& s : students) {
            gpaIds.push_back({s[1], s[0]});
        }
        
        sort(gpaIds.begin(), gpaIds.end(), [](const auto& a, const auto& b) {
            if (a.first != b.first) return a.first > b.first;
            return a.second < b.second;
        });
        
        vector<int> result;
        for (const auto& p : gpaIds) {
            result.push_back(p.second);
        }
        return result;
    }
};

class Solution {
    public List<Integer> optimizeRanking(List<List<Double>> students) {
        List<int[]> gpaIds = new ArrayList<>();
        for (List<Double> s : students) {
            gpaIds.add(new int[]{s.get(0).intValue(), s.get(1).intValue()});
        }
        
        gpaIds.sort((a, b) -> {
            if (a[1] != b[1]) return b[1] - a[1];
            return a[0] - b[0];
        });
        
        List<Integer> result = new ArrayList<>();
        for (int[] p : gpaIds) {
            result.add(p[0]);
        }
        return result;
    }
}

class Solution:
    def optimizeRanking(self, students: List[List[float]]) -> List[int]:
        gpa_ids = [(s[1], s[0]) for s in students]
        gpa_ids.sort(key=lambda x: (-x[0], x[1]))
        return [id for _, id in gpa_ids]

/**
 * @param {number[][]} students
 * @return {number[]}
 */
var optimizeRanking = function(students) {
    const gpaIds = students.map(s => ({ gpa: s[1], id: s[0] }));
    
    gpaIds.sort((a, b) => {
        if (a.gpa !== b.gpa) return b.gpa - a.gpa;
        return a.id - b.id;
    });
    
    return gpaIds.map(item => item.id);
};