# Maximize the happiness of the groups on the Trip

A trip to mystical land is going to be organized in ByteLand, the city of Bytes. Unfortunately, there are limited seats say A and there are N number of groups of people. Every group can have old person o, child c, man m and woman w. The organizing committee wants to maximize the happiness value of the trip. Happiness value of the trip is the sum of the happiness value of all the groups that are going. A group will go for the trip if every member can get a seat (Breaking a group is not a good thing).

1. The happiness of child c = 4
2. The happiness of woman w = 3
3. The happiness of man m = 2
4. The happiness of the old person o = 1

The happiness of group G, H(G) = (sum of happiness of people in it) * (number of people in the group).
The happiness of the group (‘coow’) = (4 + 1 + 1 + 3) * 4 = 36.

Given the groups and the total seating capacity, the task is to maximize the happiness and print the maximized happiness of the groups going on the trip.

Examples:

Input: groups[] = {“mmo”, “oo”, “cmw”, “cc”, “c”}, A = 5
Output: 43
Pick these groups [‘cmw’, ‘cc’] to get the maximum profit of (4 + 2 + 3) * 3 + (4 + 4) * 2 = 43

Input: groups[] = {“ccc”, “oo”, “cm”, “mm”, “wwo”}, A = 10
Output: 77

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The problem can be considered as a slight modification of the 0-1 knapsack problem. The total seats available can be considered as the size of the knapsack. The happiness of each group can be considered as the profit of each item and the number of people in each group can be considered as the weight of each item. Now similar to the dynamic programming approach for 0-1 knapsack problem apply dynamic programming here to get the maximum happiness.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the maximized happiness ` `int` `MaxHappiness(``int` `A, ``int` `N, vector v) ` `{ ` `    ``string str; ` ` `  `    ``// Two arrays similar to ` `    ``// 0 1 knapsack problem ` `    ``int` `val[N], wt[N], c = 0; ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``str = v[i]; ` ` `  `        ``// To store the happiness ` `        ``// of the current group ` `        ``c = 0; ` `        ``for` `(``int` `j = 0; str[j]; j++) { ` ` `  `            ``// Current person is a child ` `            ``if` `(str[j] == ``'c'``) ` `                ``c += 4; ` ` `  `            ``// Woman ` `            ``else` `if` `(str[j] == ``'w'``) ` `                ``c += 3; ` ` `  `            ``// Man ` `            ``else` `if` `(str[j] == ``'m'``) ` `                ``c += 2; ` ` `  `            ``// Old person ` `            ``else` `                ``c++; ` `        ``} ` ` `  `        ``// Group's happiness is the sum of happiness ` `        ``// of the people in the group multiplied by ` `        ``// the number of people ` `        ``c *= str.length(); ` `        ``val[i] = c; ` `        ``wt[i] = str.length(); ` `    ``} ` ` `  `    ``// Solution using 0 1 knapsack ` `    ``int` `k[N + 1][A + 1]; ` `    ``for` `(``int` `i = 0; i <= N; i++) { ` `        ``for` `(``int` `w = 0; w <= A; w++) { ` `            ``if` `(i == 0 || w == 0) ` `                ``k[i][w] = 0; ` `            ``else` `if` `(wt[i - 1] <= w) ` `                ``k[i][w] = max(val[i - 1] ` `                                  ``+ k[i - 1][w - wt[i - 1]], ` `                              ``k[i - 1][w]); ` `            ``else` `                ``k[i][w] = k[i - 1][w]; ` `        ``} ` `    ``} ` `    ``return` `k[N][A]; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``// Number of seats ` `    ``int` `A = 5; ` ` `  `    ``// Groups ` `    ``vector v = { ``"mmo"``, ``"oo"``, ``"cmw"``, ``"cc"``, ``"c"` `}; ` `    ``int` `N = v.size(); ` `    ``cout << MaxHappiness(A, N, v); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `class` `GFG  ` `{ ` `    ``// Function to return the maximized happiness ` `    ``static` `int` `maxHappiness(``int` `A, ``int` `N, String[] v)  ` `    ``{ ` `        ``String str; ` ` `  `        ``// Two arrays similar to ` `        ``// 0 1 knapsack prolem ` `        ``int``[] val = ``new` `int``[N]; ` `        ``int``[] wt = ``new` `int``[N]; ` `        ``int` `c = ``0``; ` `        ``for` `(``int` `i = ``0``; i < N; i++)  ` `        ``{ ` `            ``str = v[i]; ` ` `  `            ``// To store the happiness ` `            ``// of the current goup ` `            ``c = ``0``; ` `            ``for` `(``int` `j = ``0``; j < str.length(); j++)  ` `            ``{ ` `                ``// Current person is a child ` `                ``if` `(str.charAt(j) == ``'c'``) ` `                    ``c += ``4``; ` ` `  `                ``// Woman ` `                ``else` `if` `(str.charAt(j) == ``'w'``) ` `                    ``c += ``3``; ` ` `  `                ``// Man ` `                ``else` `if` `(str.charAt(j) == ``'m'``) ` `                    ``c += ``2``; ` ` `  `                ``// Old Person ` `                ``else` `                    ``c++; ` `            ``} ` ` `  `            ``// Group's happiness is the sum of happiness ` `            ``// of the people in the group multiplie ` `            ``// the number of people ` `            ``c *= str.length(); ` `            ``val[i] = c; ` `            ``wt[i] = str.length(); ` `        ``} ` ` `  `        ``// Solution using 0 1 knapsack ` `        ``int``[][] k = ``new` `int``[N + ``1``][A + ``1``]; ` `        ``for` `(``int` `i = ``0``; i <= N; i++)  ` `        ``{ ` `            ``for` `(``int` `w = ``0``; w <= A; w++)  ` `            ``{ ` `                ``if` `(i == ``0` `|| w == ``0``) ` `                    ``k[i][w] = ``0``; ` `                ``else` `if` `(wt[i - ``1``] <= w)  ` `                ``{ ` `                    ``k[i][w] = Math.max(val[i - ``1``]+ k[i - ``1``][w - wt[i - ``1``]], k[i-``1``][w]); ` `                ``}  ` `                ``else`  `                ``{ ` `                    ``k[i][w] = k[i - ``1``][w]; ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `k[N][A]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``// Number of seats ` `        ``int` `A = ``5``; ` ` `  `        ``// Groups ` `        ``String[] v = { ``"mmo"``, ``"oo"``, ``"cmw"``, ``"cc"``, ``"c"` `}; ` `        ``int` `N = v.length; ` `        ``System.out.println(maxHappiness(A, N, v)); ` `    ``} ` `} ` ` `  `// This code is contributed by Vivek Kumar Singh `

## Python3

 `# Python3 implementation of the approach  ` `import` `numpy as np ` ` `  `# Function to return the maximized happiness  ` `def` `MaxHappiness(A, N, v) : ` `     `  `    ``# Two arrays similar to  ` `    ``# 0 1 knapsack problem  ` `    ``val ``=` `[``0``] ``*` `N; wt ``=` `[``0``] ``*` `N; c ``=` `0``;  ` `     `  `    ``for` `i ``in` `range``(N) : ` `        ``string ``=` `v[i];  ` ` `  `        ``# To store the happiness  ` `        ``# of the current group  ` `        ``c ``=` `0``;  ` `        ``for` `j ``in` `range``(``len``(string)) : ` ` `  `            ``# Current person is a child  ` `            ``if` `(string[j] ``=``=` `'c'``) : ` `                ``c ``+``=` `4``;  ` ` `  `            ``# Woman  ` `            ``elif` `(string[j] ``=``=` `'w'``) : ` `                ``c ``+``=` `3``;  ` ` `  `            ``# Man  ` `            ``elif` `(string[j] ``=``=` `'m'``) : ` `                ``c ``+``=` `2``;  ` ` `  `            ``# Old person  ` `            ``else` `: ` `                ``c ``+``=` `1``;  ` ` `  `        ``# Group's happiness is the sum of happiness  ` `        ``# of the people in the group multiplied by  ` `        ``# the number of people  ` `        ``c ``*``=` `len``(string);  ` `         `  `        ``val[i] ``=` `c; ` `         `  `        ``wt[i] ``=` `len``(string);  ` ` `  `    ``# Solution using 0 1 knapsack  ` `    ``k ``=` `np.zeros((N ``+` `1``, A ``+` `1``)) ` `     `  `    ``for` `i ``in` `range``(N ``+` `1``) : ` `         `  `        ``for` `w ``in` `range``(A ``+` `1``) : ` `            ``if` `(i ``=``=` `0` `or` `w ``=``=` `0``) : ` `                ``k[i][w] ``=` `0``;  ` `            ``elif` `(wt[i ``-` `1``] <``=` `w) : ` `                ``k[i][w] ``=` `max``(val[i ``-` `1``] ``+`  `                                ``k[i ``-` `1``][w ``-` `wt[i ``-` `1``]],  ` `                                ``k[i ``-` `1``][w]);  ` `            ``else` `: ` `                ``k[i][w] ``=` `k[i ``-` `1``][w];  ` `                 `  `    ``return` `k[N][A];  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``# Number of seats  ` `    ``A ``=` `5``;  ` ` `  `    ``# Groups  ` `    ``v ``=` `[ ``"mmo"``, ``"oo"``, ``"cmw"``, ``"cc"``, ``"c"` `];  ` `     `  `    ``N ``=` `len``(v);  ` `    ``print``(MaxHappiness(A, N, v));  ` `     `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach  ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `    ``// Function to return the maximized happiness ` `    ``static` `int` `maxHappiness(``int` `A, ``int` `N, ` `                              ``String[] v)  ` `    ``{ ` `        ``String str; ` ` `  `        ``// Two arrays similar to ` `        ``// 0 1 knapsack prolem ` `        ``int``[] val = ``new` `int``[N]; ` `        ``int``[] wt = ``new` `int``[N]; ` `        ``int` `c = 0; ` `        ``for` `(``int` `i = 0; i < N; i++)  ` `        ``{ ` `            ``str = v[i]; ` ` `  `            ``// To store the happiness ` `            ``// of the current goup ` `            ``c = 0; ` `            ``for` `(``int` `j = 0; j < str.Length; j++)  ` `            ``{ ` `                ``// Current person is a child ` `                ``if` `(str[j] == ``'c'``) ` `                    ``c += 4; ` ` `  `                ``// Woman ` `                ``else` `if` `(str[j] == ``'w'``) ` `                    ``c += 3; ` ` `  `                ``// Man ` `                ``else` `if` `(str[j] == ``'m'``) ` `                    ``c += 2; ` ` `  `                ``// Old Person ` `                ``else` `                    ``c++; ` `            ``} ` ` `  `            ``// Group's happiness is the sum of happiness ` `            ``// of the people in the group multiplie ` `            ``// the number of people ` `            ``c *= str.Length; ` `            ``val[i] = c; ` `            ``wt[i] = str.Length; ` `        ``} ` ` `  `        ``// Solution using 0 1 knapsack ` `        ``int``[ , ] k = ``new` `int``[N + 1, A + 1]; ` `        ``for` `(``int` `i = 0; i <= N; i++)  ` `        ``{ ` `            ``for` `(``int` `w = 0; w <= A; w++)  ` `            ``{ ` `                ``if` `(i == 0 || w == 0) ` `                    ``k[i, w] = 0; ` `                ``else` `if` `(wt[i - 1] <= w)  ` `                ``{ ` `                    ``k[i, w] = Math.Max(val[i - 1]+  ` `                                       ``k[i - 1, w - wt[i - 1]], ` `                                       ``k[i - 1, w]); ` `                ``}  ` `                ``else` `                ``{ ` `                    ``k[i, w] = k[i - 1, w]; ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `k[N, A]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``// Number of seats ` `        ``int` `A = 5; ` ` `  `        ``// Groups ` `        ``String[] v = { ``"mmo"``, ``"oo"``, ``"cmw"``, ``"cc"``, ``"c"` `}; ` `        ``int` `N = v.Length; ` `        ``Console.WriteLine(maxHappiness(A, N, v)); ` `    ``} ` `} ` ` `  `// This code is contributed by Mohit kumar 29 `

Output:

```43
``` My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.