Google Kickstart 2020 Round A: Plates Solution

标签：ever   try   sam   check   header   man   const   BMI   ++   

Problem Statement 

Problem

Input

Output

Limits

Test set 1

Test set 2

Sample

2
2 4 5
10 10 100 30
80 50 10 50
3 2 3
80 80
15 50
20 10

  

Case #1: 250
Case #2: 180

  

• He can pick the top 3 plates from the first stack (10 + 10 + 100 = 120).
• He can pick the top 2 plates from the second stack (80 + 50 = 130) .

In total, the sum of beauty values is 250.

• He can pick the top 2 plates from the first stack (80 + 80 = 160).
• He can pick no plates from the second stack.
• He can pick the top plate from the third stack (20).

In total, the sum of beauty values is 180.

Problem link

Video Tutorial

You can find the detailed video tutorial here

• Youtube
• B站

 Thought Process

First thought is similar to merging multiple lists, this won‘t work since the lists are not sorted and we are not allowed to sort due to the order constraint.

Second thought is keep a max heap, and always merge the largest value from all the top elements in the lists. This is wrong since greedy won‘t work here. E.g., below if we want to pick 3 plates, using max heap will pick 2, 2, 2, instead of 1, 1, 100

2, 2, 2, 2, 2

1, 1, 100, 100, 100

Third thought seems we have to brute force, for all the combos of P, we check what‘s the maximum value. Quote from the analysis, it‘s exponential time complexity

For example, if N = 3 and for any given values of K and P, generate all possible triples (S₁, S₂, S₃) such that S₁+S₂+S₃ = P and 0 ≤ S_i ≤ K. Note: S_i is the number of plates picked from the i-th stack.

This can be done via recursion and the total time complexity is O(K^N) which abides by the time limits.

Forth and final solution to optimize this is using dynamic programming. It‘s very common in those coding competitions.

Quote from the analysis

First, let‘s consider an intermediate state dp[i][j] which denotes the maximum sum that can be obtained using the first i stacks when we need to pick j plates in total.

Next, we iterate over the stacks and try to answer the question: What is the maximum sum if we had to pick j plates in total using the i stacks we‘ve seen so far? This would give us dp[i][j]. However, we need to also decide, among those j plates, how many come from the i-th stack? i.e., Let‘s say we pick x plates from the i-th stack, then dp[i][j] = max(dp[i][j], sum[i][x]+dp[i-1][j-x]). Therefore, in order to pick j plates in total from i stacks, we can pick anywhere between [0, 1, ..., j] plates from the i-th stack and [j, j-1, ..., 0] plates from the previous i-1 stacks respectively. Also, we need to do this for all values of 1 ≤ j ≤ P.

The flow would look like:

for i [1, N]:

 for j [0, P]:

  dp[i][j] := 0

   for x [0, min(j, K)]:

    dp[i][j] = max(dp[i][j], sum[i][x]+dp[i-1][j-x])

If we observe closely, this is similar to the 0-1 Knapsack Problem with some added complexity. To conclude, the overall time complexity would be O(N*P*K).

Solutions

 1 public static void main(String[] args) {
 2     Scanner s = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
 3 
 4     int testCases = s.nextInt();
 5     int caseNum = 1;
 6     Plates plates = new Plates();
 7 
 8     while (caseNum <= testCases) {
 9         int n = s.nextInt();
10         int k = s.nextInt();
11         int p = s.nextInt();
12 
13         int[][] values = new int[n][k];
14         for (int i = 0; i < n; i++) {
15             for (int j = 0; j < k; j++) {
16                 values[i][j] = s.nextInt();
17             }
18         }
19 
20         System.out.println(String.format("Case #%d: %d", caseNum, plates.maxPlatesBeautyValue(values, p)));
21         caseNum++;
22     }
23 }
24 
25 private int maxPlatesBeautyValue(int[][] values, int numberOfPlates) {
26     int n = values.length;
27     int k= values[0].length;
28     int p = numberOfPlates;
29 
30 
31     // could use a one dimension array
32     int[][] prefixSum = new int[n + 1][k + 1];
33     int[][] lookup = new int[n + 1][p + 1];
34 
35     for (int i = 1; i <= n; i++) {
36         for (int j = 1; j <= k; j++) {
37             prefixSum[i][j] = prefixSum[i][j - 1] + values[i - 1][j - 1];
38         }
39     }
40 
41     for (int i = 1; i <= n; i++) {
42         for (int j = 1; j <= p; j++) {
43             lookup[i][j] = 0;
44 
45             for (int x = 0; x <= Math.min(j, k); x++) {
46                 lookup[i][j] = Math.max(lookup[i][j], prefixSum[i][x] + lookup[i - 1][j - x]);
47             }
48         }
49     }
50 
51     return lookup[n][p];
52 }

DP solution

Time Complexity: O(N*P*K)

Space Complexity: O(N*max(P, K))

References

• Google kickstart official solution

Google Kickstart 2020 Round A: Plates Solution

标签：ever   try   sam   check   header   man   const   BMI   ++   

原文地址：https://www.cnblogs.com/baozitraining/p/12596326.html