Maximum number of customers that can be satisfied with given quantity

A new variety of rice has been brought in supermarket and being available for the first time, the quantity of this rice is limited. Each customer demands the rice in two different packaging of size a and size b. The sizes a and b are decided by staff as per the demand. Given the size of the packets a and b, the total quantity of rice available d and the number of customers n, find out maximum number of customers that can be satisfied with the given quantity of rice. Display the total number of customers that can be satisfied and the index of customers that can be satisfied. 

Note: If a customer orders 2 3, he requires 2 packets of size a and 3 packets of size b. Assume indexing of customers starts from 1. 

Input: The first line of input contains two integers n and d; next line contains two integers a and b. Next n lines contain two integers for each customer denoting total number of bags of size a and size b that customer requires. 
Output: Print the maximum number of customers that can be satisfied and in the next line print the space-separated indexes of satisfied customers. 

Examples:

Input : n = 5, d = 5
        a = 1, b = 1
        2 0
        3 2
        4 4
        10 0
        0 1
Output : 2
         5 1 

Input : n = 6, d = 1000000000
       a = 9999, b = 10000
       10000 9998
       10000 10000
       10000 10000
       70000 70000
       10000 10000
       10000 10000
Output : 5
         1 2 3 5 6 

Explanation: In first example, the order of customers according to their demand is:

Customer ID   Demand
   5            1
   1            2
   2            5
   3            8
   4            10

From this, it can easily be concluded that only customer 5 and customer 1 can be satisfied for total demand of 1 + 2 = 3. Rest of the customer cannot purchase the remaining rice, as their demand is greater than available amount. 

Approach: In order to meet the demand of maximum number of customers we must start with the customer with minimum demand so that we have maximum amount of rice left to satisfy remaining customers. Therefore, sort the customers according to the increasing order of demand so that maximum number of customers can be satisfied. Below is the implementation of above approach: 

Implementation:

C++

// CPP program to find maximum number
// of customers that can be satisfied
#include <bits/stdc++.h>
using namespace std;

vector<pair<long long, int> > v;

// print maximum number of satisfied
// customers and their indexes
void solve(int n, int d, int a, int b,
                        int arr[][2])
{
    // Creating an vector of pair of
    // total demand and customer number
    for (int i = 0; i < n; i++) {
        int m = arr[i][0], t = arr[i][1];
        v.push_back(make_pair((a * m + b * t),
                                     i + 1));
    }

    // Sorting the customers according
    // to their total demand
    sort(v.begin(), v.end());

    vector<int> ans;

    // Taking the first k customers that
    // can be satisfied by total amount d
    for (int i = 0; i < n; i++) {
        if (v[i].first <= d) {
            ans.push_back(v[i].second);
            d -= v[i].first;
        }
    }

    cout << ans.size() << endl;
    for (int i = 0; i < ans.size(); i++)
        cout << ans[i] << " ";
}

// Driver program
int main()
{
    // Initializing variables
    int n = 5;
    long d = 5;
    int a = 1, b = 1;
    int arr[][2] = {{2, 0},
                    {3, 2},
                    {4, 4},
                    {10, 0},
                    {0, 1}};

    solve(n, d, a, b, arr);
    return 0;
}

Java

// Java program to find maximum number
// of customers that can be satisfied
import java.util.*;

public class GFG {

    static class pair {
        long first;
        int second;
        pair(long f, int s)
        {
            first = f;
            second = s;
        }
    }
    static ArrayList<pair> v;

    // print maximum number of satisfied
    // customers and their indexes
    static void solve(int n, long d, int a, int b,
                      int arr[][])
    {
        // Creating an vector of pair of
        // total demand and customer number
        for (int i = 0; i < n; i++) {
            int m = arr[i][0], t = arr[i][1];
            v.add(new pair(((long)a * m + b * t), i + 1));
        }

        // Sorting the customers according
        // to their total demand
        Collections.sort(v, (pair A, pair B) -> {
            return (A.first - B.first) >= 0 ? 1 : -1;
        });

        ArrayList<Integer> ans = new ArrayList<>();

        // Taking the first k customers that
        // can be satisfied by total amount d
        for (int i = 0; i < n; i++) {
            if (v.get(i).first <= d) {
                ans.add(v.get(i).second);
                d -= v.get(i).first;
            }
        }

        System.out.println(ans.size());
        for (int i = 0; i < ans.size(); i++)
            System.out.print(ans.get(i) + " ");
    }

    // Driver program
    public static void main(String[] args)
    {
        v = new ArrayList<>();
        // Initializing variables
        int n = 5;
        long d = 5;
        int a = 1, b = 1;
        int arr[][] = { { 2, 0 },
                        { 3, 2 },
                        { 4, 4 },
                        { 10, 0 },
                        { 0, 1 } };

        solve(n, d, a, b, arr);
    }
}
// This code is contributed by Karandeep1234

Python3

# Python3 program to find maximum number
# of customers that can be satisfied
v = []

# print maximum number of satisfied
# customers and their indexes
def solve(n, d, a, b, arr):
    first, second = 0, 1

    # Creating an vector of pair of
    # total demand and customer number
    for i in range(n):
        m = arr[i][0]
        t = arr[i][1]
        v.append([a * m + b * t, i + 1])

    # Sorting the customers according
    # to their total demand
    v.sort()

    ans = []

    # Taking the first k customers that
    # can be satisfied by total amount d
    for i in range(n):
        if v[i][first] <= d:
            ans.append(v[i][second])
            d -= v[i][first]

    print(len(ans))
    for i in range(len(ans)):
        print(ans[i], end = " ")

# Driver Code
if __name__ == '__main__':

    # Initializing variables
    n = 5
    d = 5
    a = 1
    b = 1
    arr = [[2, 0], [3, 2],
           [4, 4], [10, 0],
           [0, 1]]

    solve(n, d, a, b, arr)

# This code is contributed by PranchalK

C#

// C# program to find maximum number
// of customers that can be satisfied

using System;
using System.Collections.Generic;


class GFG
{
    static List<Tuple<int, int> > v = new List<Tuple<int, int> >();

    // print maximum number of satisfied
    // customers and their indexes
    static void solve(int n, int d, int a, int b,
                            int[,] arr)
    {
        // Creating an vector of pair of
        // total demand and customer number
        for (int i = 0; i < n; i++) {
            int m = arr[i, 0], t = arr[i, 1];
            v.Add(Tuple.Create((a * m + b * t),
                                         i + 1));
        }

        // Sorting the customers according
        // to their total demand
        v.Sort();

        List<int> ans = new List<int>();

        // Taking the Item1 k customers that
        // can be satisfied by total amount d
        for (int i = 0; i < n; i++) {
            if (v[i].Item1 <= d) {
                ans.Add(v[i].Item2);
                d -= v[i].Item1;
            }
        }

        Console.WriteLine(ans.Count);
        for (int i = 0; i < ans.Count; i++)
            Console.Write(ans[i] + " ");
    }

    // Driver program
    public static void Main(string[] args)
    {
        // Initializing variables
        int n = 5;
        int d = 5;
        int a = 1, b = 1;
        int[,] arr = {{2, 0},
                        {3, 2},
                        {4, 4},
                        {10, 0},
                        {0, 1}};

        solve(n, d, a, b, arr);
    }
}


// This code is contributed by phasing17.

Javascript

// JS program to find maximum number
// of customers that can be satisfied
let v = []

// print maximum number of satisfied
// customers and their indexes
function solve(n, d, a, b, arr)
{
    let first = 0
    let second = 1

    // Creating an vector of pair of
    // total demand and customer number
    for (var i = 0; i < n; i++)
    {
        let m = arr[i][0]
        let t = arr[i][1]
        v.push([a * m + b * t, i + 1])
    }
    // Sorting the customers according
    // to their total demand
    v.sort()

    let ans = []

    // Taking the first k customers that
    // can be satisfied by total amount d
    for (var i = 0; i < n; i++)
        if (v[i][first] <= d )
        {
            ans.push(v[i][second])
            d -= v[i][first]
        }

    console.log((ans).length)
    for (var i = 0; i < ans.length; i++)
        process.stdout.write(ans[i] + " ")
}


// Driver Code

// Initializing variables
let n = 5, d = 5, a = 1, b = 1

let arr = [[2, 0], [3, 2],
           [4, 4], [10, 0],
           [0, 1]]

solve(n, d, a, b, arr)

// This code is contributed by phasing17

Output

2
5 1 

Time Complexity: O(n*log(n))
Auxiliary Space: O(n)