Pizza With 3n Slices - Practice Coding Problems

Pizza With 3n Slices - Problem

Pizza With 3n Slices

Imagine you're at a pizza party with your friends Alice and Bob! There's a circular pizza cut into 3n slices of varying sizes, arranged in clockwise order. The three of you will take turns picking slices according to these rules:

📍 Game Rules:
1. You pick any slice from the pizza
2. Alice immediately takes the slice counterclockwise from your pick
3. Bob immediately takes the slice clockwise from your pick
4. This continues until all slices are taken

Since the pizza is circular, when you pick a slice, the adjacent slices are automatically taken by your friends, and those three slices are removed from the pizza. The remaining slices form a new circular arrangement.

🎯 Goal: Maximize the total sum of slice sizes that you can obtain.

Input: An integer array slices representing the sizes of pizza slices in clockwise order
Output: The maximum possible sum of slice sizes you can pick

Input & Output

example_1.py — Basic Case

$ Input: [1,2,3,4,5,6]

› Output: 10

💡 Note: Pick slice 2 (size 3): Alice gets slice 1 (size 2), Bob gets slice 3 (size 4). Remaining: [1,5,6]. Pick slice 5 (size 6): Alice gets slice 6 (size 1), Bob gets slice 4 (size 5). Total: 3 + 6 = 9. But optimal is picking slices with values 4 and 6 for total 10.

example_2.py — Larger Array

$ Input: [8,9,8,6,1,1]

› Output: 16

💡 Note: With 6 slices, we pick 2. Optimal strategy picks the slices with sizes 8 and 8, avoiding adjacent selections. Total: 8 + 8 = 16.

example_3.py — Small Case

$ Input: [4,1,2]

› Output: 4

💡 Note: With 3 slices, we pick 1. The best choice is the slice with size 4, giving us a total of 4.

Constraints

1 ≤ slices.length ≤ 500
slices.length % 3 == 0
1 ≤ slices[i] ≤ 10³
The number of slices is always divisible by 3

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Realize this is equivalent to House Robber: pick n non-adjacent items

Handle Circularity

Split into two linear problems: with/without first element

Apply DP

Use 2D DP: dp[i][j] = max sum with j picks from first i elements

Combine Results

Return maximum of both linear solutions

Key Takeaway

🎯 Key Insight: Transform circular constraint problem into classic House Robber DP by handling first/last element circularity with two separate cases.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution transforms this into a House Robber in Circle problem. Since you pick n slices and adjacent slices are taken by friends, this becomes selecting n non-adjacent elements from a circular array. Use dynamic programming with two cases: include first element or exclude it, then take the maximum result.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n²)	Transform into House Robber problem and solve with DP in linear time
Brute Force (Try All Combinations)	O(C(3n,n) * n)	O(n)	Generate all possible ways to pick n non-adjacent slices and find maximum sum

Dynamic Programming (Optimal) — Algorithm Steps

Recognize this as House Robber in Circle problem variant
Create helper function to solve linear House Robber problem
Solve two cases: rob with first element, rob without first element
Use DP to track maximum sum possible with k selections
Return maximum of both cases

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform Problem

Recognize as House Robber variant: pick n non-adjacent elements

Handle Circular Nature

Split into two cases: with first element, without first element

Build DP Table

dp[i][j] = max sum using j selections from first i elements

Return Maximum

Take maximum result from both cases

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int max(int a, int b) {
    return (a > b) ? a : b;
}

int robLinear(int* arr, int n, int k) {
    if (n == 0 || k == 0) return 0;
    if (k > n) return 0;
    
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)calloc(k + 1, sizeof(int));
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            dp[i][j] = dp[i-1][j];
            if (j > 0 && i >= 2) {
                dp[i][j] = max(dp[i][j], dp[i-2][j-1] + arr[i-1]);
            } else if (j == 1) {
                dp[i][j] = max(dp[i][j], arr[i-1]);
            }
        }
    }
    
    int result = dp[n][k];
    
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int rob(int* slices, int slicesSize) {
    int n = slicesSize / 3;
    if (n == 1) {
        int maxVal = slices[0];
        for (int i = 1; i < slicesSize; i++) {
            if (slices[i] > maxVal) maxVal = slices[i];
        }
        return maxVal;
    }
    
    int case1 = robLinear(slices + 1, slicesSize - 1, n);
    int case2 = robLinear(slices, slicesSize - 1, n);
    
    return max(case1, case2);
}

int main() {
    int slices[100];
    int size = 0;
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        slices[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", rob(slices, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We solve the problem twice (with/without first element), each taking O(n²) time for DP table

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table storing maximum sum for each position and number of selections

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler