leetcode 1244. Design A Leaderboard

Design a Leaderboard class, which has 3 functions:

1. addScore(playerId, score): Update the leaderboard by adding score to the given player's score. If there is no player with such id in the leaderboard, add him to the leaderboard with the given score.
2. top(K): Return the score sum of the top K players.
3. reset(playerId): Reset the score of the player with the given id to 0. It is guaranteed that the player was added to the leaderboard before calling this function.

Initially, the leaderboard is empty.

 

Example 1:

Input: 
["Leaderboard","addScore","addScore","addScore","addScore","addScore","top","reset","reset","addScore","top"]
[[],[1,73],[2,56],[3,39],[4,51],[5,4],[1],[1],[2],[2,51],[3]]
Output: 
[null,null,null,null,null,null,73,null,null,null,141]

Explanation: 
Leaderboard leaderboard = new Leaderboard ();
leaderboard.addScore(1,73);   // leaderboard = [[1,73]];
leaderboard.addScore(2,56);   // leaderboard = [[1,73],[2,56]];
leaderboard.addScore(3,39);   // leaderboard = [[1,73],[2,56],[3,39]];
leaderboard.addScore(4,51);   // leaderboard = [[1,73],[2,56],[3,39],[4,51]];
leaderboard.addScore(5,4);    // leaderboard = [[1,73],[2,56],[3,39],[4,51],[5,4]];
leaderboard.top(1);           // returns 73;
leaderboard.reset(1);         // leaderboard = [[2,56],[3,39],[4,51],[5,4]];
leaderboard.reset(2);         // leaderboard = [[3,39],[4,51],[5,4]];
leaderboard.addScore(2,51);   // leaderboard = [[2,51],[3,39],[4,51],[5,4]];
leaderboard.top(3);           // returns 141 = 51 + 51 + 39;

 

Constraints:

• 1 <= playerId, K <= 10000
• It's guaranteed that K is less than or equal to the current number of players.
• 1 <= score <= 100
• There will be at most 1000 function calls.

---

权值线段树+hashMap。权值线段树的节点还要维护 区间统计个数值，区间sum值。hashmap维护id和其score。

每种操作复杂度均为O（log n）.

class Leaderboard {
    class Node{
        Node lNode,rNode;
        int sum,cnt;
    }
    Node root;
    HashMap<Integer,Integer> map;
    public Leaderboard() {
        root=new Node();
        map=new HashMap<>();
    }
    
    public void addScore(int playerId, int score) {
        int v=0;
        if(map.containsKey(playerId)){
            v=map.get(playerId);
            remove(root,v,0,10000);
        }
        v+=score;
        map.put(playerId,v);
        add(root,v,0,10000);
    }
    
    public int top(int K) {
        return querySum(root,K,0,10000);
    }
    
    public void reset(int playerId) {
        if(map.get(playerId)==null)return;
        int v=map.get(playerId);
        map.remove(playerId);
        remove(root,v,0,10000);
    }
    void add(Node node,int v,int l,int r){
        if(l==r){
            node.cnt++;
            node.sum+=v;
        }else{
            if(node.lNode==null)node.lNode=new Node();
            if(node.rNode==null)node.rNode=new Node();
            int m=l+(r-l)/2;
            if(v<=m){
                add(node.lNode,v,l,m);
            }else{
                add(node.rNode,v,m+1,r);
            }
            node.cnt=node.lNode.cnt+node.rNode.cnt;
            node.sum=node.lNode.sum+node.rNode.sum;
        }
    }
    void remove(Node node,int v,int l,int r){
        if(l==r){
            if(node.cnt>0){
                node.cnt--;
                node.sum-=v;
            }
            return;
        }       
        int m=l+(r-l)/2;
        if(v<=m){
            remove(node.lNode,v,l,m);    
        }else{
            remove(node.rNode,v,m+1,r);        
        }
        node.cnt=node.lNode.cnt+node.rNode.cnt;
        node.sum=node.lNode.sum+node.rNode.sum;
    }
    int querySum(Node node,int K,int l,int r){
        if(l==r)return K*(node.sum/node.cnt);
        int m=l+(r-l)/2;
        if(K<=node.rNode.cnt){
            return querySum(node.rNode,K,m+1,r);
        }else{
            return node.rNode.sum+querySum(node.lNode,K-node.rNode.cnt,l,m);
        }
    }
}

/**
 * Your Leaderboard object will be instantiated and called as such:
 * Leaderboard obj = new Leaderboard();
 * obj.addScore(playerId,score);
 * int param_2 = obj.top(K);
 * obj.reset(playerId);
 */