Count Number of Ways to Place Houses - Practice Coding Problems

Count Number of Ways to Place Houses - Problem

Dynamic Programming Medium

Imagine a charming residential street with n plots on each side (total of 2n plots). You're a city planner tasked with determining how many different ways houses can be placed while following a strict zoning rule: no two houses can be adjacent on the same side of the street.

Here's the interesting part: houses on opposite sides of the street can be directly across from each other - the adjacency rule only applies to houses on the same side.

Goal: Count the total number of valid house placement configurations.

Input: An integer n representing the number of plots on each side

Output: Number of ways to place houses modulo 10⁹ + 7

Example: For n=2, you have 4 plots total (2 on each side). Some valid configurations include: no houses, houses only on opposite corners, houses on one side with a gap, etc.

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: 4

💡 Note: With 1 plot per side (2 plots total), we can have: (1) no houses, (2) house on left only, (3) house on right only, (4) houses on both sides (they're not adjacent since they're on different sides)

example_2.py — Medium Case

$ Input: n = 2

› Output: 9

💡 Note: For 2 plots per side, each side has 3 valid arrangements: [], [H,_], [_,H] where H=house, _=empty. Since sides are independent: 3 × 3 = 9 total arrangements

example_3.py — Larger Case

$ Input: n = 3

› Output: 25

💡 Note: Each side of 3 plots has 5 valid arrangements: [], [H,_,_], [_,H,_], [_,_,H], [H,_,H]. Total arrangements: 5 × 5 = 25

Visualization

Tap to expand

Understanding the Visualization

Identify Independence

Recognize that left and right sides of street are completely independent

Solve One Side

Use DP to count arrangements for n plots with no adjacent houses

Apply Multiplication

Square the one-side result since both sides can be arranged independently

Handle Large Numbers

Apply modular arithmetic to prevent integer overflow

Key Takeaway

🎯 Key Insight: The problem elegantly reduces to finding arrangements for one side (classic DP), then squaring the result due to independence of both sides.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n positions to build DP table

✓ Linear Growth

Space Complexity

O(1)

Only need to track previous state, can optimize to constant space

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
Answer returned modulo 10⁹ + 7
No two houses can be adjacent on the same side of the street

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses dynamic programming to recognize that both sides of the street are independent. Calculate valid arrangements for one side (similar to House Robber problem), then square the result since both sides can be arranged independently. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Calculate arrangements for one side using DP, then square the result

Dynamic Programming (Optimal) — Algorithm Steps

Define dp[i][0] = ways to arrange houses in first i plots with plot i empty
Define dp[i][1] = ways to arrange houses in first i plots with plot i having a house
Base case: dp[1][0] = 1, dp[1][1] = 1
Recurrence: dp[i][0] = dp[i-1][0] + dp[i-1][1], dp[i][1] = dp[i-1][0]
One side total = dp[n][0] + dp[n][1], final answer = (one side total)²

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

dp[1][0] = 1 (empty), dp[1][1] = 1 (house)

Build States

For each position, calculate ways ending empty or with house

Apply Transitions

Empty can follow anything, house can only follow empty

Square Result

Both sides independent, so multiply one-side result by itself

Code -

solution.c — C

#include <stdio.h>

int numWaysToPlaceHouses(int n) {
    const int MOD = 1000000007;
    
    // dp[0] = ways ending with empty plot
    // dp[1] = ways ending with house
    long long dp0 = 1, dp1 = 1;
    
    for (int i = 2; i <= n; i++) {
        long long newDp0 = (dp0 + dp1) % MOD;  // Can place empty after either empty or house
        long long newDp1 = dp0;  // Can only place house after empty
        dp0 = newDp0;
        dp1 = newDp1;
    }
    
    // Total ways for one side
    long long oneSideWays = (dp0 + dp1) % MOD;
    
    // Both sides are independent, so square the result
    return (oneSideWays * oneSideWays) % MOD;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", numWaysToPlaceHouses(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n positions to build DP table

✓ Linear Growth

Space Complexity

O(1)

Only need to track previous state, can optimize to constant space

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
Answer returned modulo 10⁹ + 7
No two houses can be adjacent on the same side of the street

38.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler