We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Greedy
  4. Luck Balance
  5. Discussions

Luck Balance

Sort by

recency

|

929 Discussions

|

  • spriyamalar
     + 0 comments
    public static int luckBalance(int canlose, List<List<Integer>> contests) {        
    List<Integer> prioritycontestluck = new ArrayList<>();
    List<Integer> optionalcontestluck = new ArrayList<>();

    for(int i=0;i<contests.size(); i++) {
        List<Integer> lst = contests.get(i);
        int priority = lst.get(1);
        int luck = lst.get(0);
        if(priority==1) {
            prioritycontestluck.add(luck);
        } else {
            optionalcontestluck.add(luck);
        }
    }

    Collections.sort(prioritycontestluck);
    int mustwin = prioritycontestluck.size()-canlose < 0 ? 0 : prioritycontestluck.size()-canlose;
    int maxluck = 0;
    for(int i=0;i<mustwin;i++) {
        maxluck -= prioritycontestluck.get(i);
    }

    for(int i=mustwin;i<prioritycontestluck.size();i++) {
        maxluck += prioritycontestluck.get(i);
    }


    for(int i=0;i<optionalcontestluck.size();i++) {
        maxluck += optionalcontestluck.get(i);
    }
    return maxluck;
}

  • mh00062
     + 0 comments
    def luckBalance(k, contests):
    all_l = 0
    ls_ls = []
    for row in contests:
        if row[1] == 0:
            all_l += row[0]
        elif row[1] == 1:
            ls_ls.append(row[0])
    
    ls_ls = sorted(ls_ls, reverse=True)
    all_l = all_l + sum(ls_ls[:k]) - sum(ls_ls[k:])
    return all_l

  • csaiml1a_2311553
     + 0 comments

    public static int luckBalance(int k, List> contests) { PriorityQueue que = new PriorityQueue<>(); // min-heap int sum = 0;

    for (int i = 0; i < contests.size(); i++) {
    int l = contests.get(i).get(0);
    int imp = contests.get(i).get(1);
    if (imp == 1) {
        que.add(l);
    } else {
        sum += l; 
    }
}
while (que.size() > k) {
    sum -= que.poll(); 
}
while (!que.isEmpty()) {
    sum += que.poll();
}
return sum;

}

  • alban_tyrex
     + 0 comments

    Here is my c++ solution, you can watch the explanation here : https://youtu.be/7L1lI6JScR8

    int luckBalance(int k, vector<vector<int>> contests) {
    sort(contests.begin(), contests.end(), [](vector<int> l, vector<int>r){
        return l[0] > r[0];
    });
    int ans = 0, im = 0;
    for(int i = 0; i < contests.size(); i++){
        if(im < k || contests[i][1] == 0) ans += contests[i][0];
        else ans -= contests[i][0];
        if(contests[i][1] == 1) im++;
    }
    return ans;
}

  • emhhacker
     + 0 comments

    My Java solution with o(n log n) time and o(n) space:

    public static int luckBalance(int k, List<List<Integer>> contests) {
        // determine total luck balance 
        
        // get list of important contests that holds each luck val
        int luckBalance = 0;
        List<Integer> importantContests = new ArrayList<>();
        
        // add the uninmportant contests to the luck val
        for(int i = 0; i < contests.size(); i++){
            int luckVal = contests.get(i).get(0);
            int important = contests.get(i).get(1);
            if(important == 1) importantContests.add(luckVal);
            else luckBalance += luckVal;
        }
        
        //sort descending to get highest competitions added first
        Collections.sort(importantContests, Collections.reverseOrder());
        
        //for each important contest add the important vals
        for(int j = 0; j < importantContests.size(); j++){
            luckBalance += (j < k) ? importantContests.get(j) : -importantContests.get(j);
        }
        
        return luckBalance;
    }