Water and Jug Problem

Water and Jug Problem - Problem

You are given two jugs with capacities x liters and y liters. You have an infinite water supply. Return whether the total amount of water in both jugs may reach target using the following operations:

Fill either jug completely with water
Completely empty either jug
Pour water from one jug into another until the receiving jug is full, or the transferring jug is empty

Determine if you can measure exactly target liters using these operations.

Input & Output

Example 1 — Achievable Target

$ Input: x = 3, y = 5, target = 4

› Output: true

💡 Note: Fill 5-liter jug, pour into 3-liter jug (2 liters remain in 5-liter jug). Empty 3-liter jug, pour the 2 liters from 5-liter jug into 3-liter jug. Fill 5-liter jug again, pour 1 liter into 3-liter jug (which had 2 liters). Now 5-liter jug has 4 liters.

Example 2 — Impossible Target

$ Input: x = 2, y = 6, target = 5

› Output: false

💡 Note: GCD(2,6) = 2. Since 5 is not divisible by 2, it's impossible to measure exactly 5 liters using 2L and 6L jugs.

Example 3 — Edge Case Zero

$ Input: x = 1, y = 2, target = 0

› Output: true

💡 Note: We can always achieve 0 liters by keeping both jugs empty.

Constraints

1 ≤ x, y ≤ 10⁶
0 ≤ target ≤ x + y

Visualization

Tap to expand

Asked in

M Microsoft 15 G Google 12 a Amazon 8

The key insight is that this is a mathematical problem solvable using number theory. You can measure exactly target liters if and only if target is divisible by GCD(x,y) and target ≤ max(x,y). The optimal approach uses the mathematical property in O(log min(x,y)) time and O(1) space.

Common Approaches

✓ BFS State Exploration

⏱️ Time: O(x × y) Space: O(x × y)

Try all combinations of operations (fill, empty, pour) and track visited states. Each state represents the current water amounts in both jugs.

Mathematical GCD Solution

⏱️ Time: O(log min(x, y)) Space: O(1)

Based on Bézout's identity: you can measure target amount if and only if target is divisible by GCD(x,y) and target ≤ max(x,y).

BFS State Exploration — Algorithm Steps

Start with empty jugs (0, 0)
For each state, try all 6 operations
Track visited states to avoid cycles
Return true if target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with both jugs empty (0,0)

Explore Operations

Try fill, empty, pour operations

Check Target

See if any state reaches target amount

Code -

solution.c — C

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

#define MAX_STATES 100000

typedef struct {
    int a, b;
} State;

bool solution(int x, int y, int target) {
    if (target > x + y) return false;
    if (target == 0) return true;
    
    State queue[MAX_STATES];
    char visited[MAX_STATES][30];
    int front = 0, rear = 0, visitedCount = 0;
    
    queue[rear++] = (State){0, 0};
    sprintf(visited[visitedCount++], "0,0");
    
    while (front < rear) {
        State curr = queue[front++];
        int a = curr.a, b = curr.b;
        
        if (a == target || b == target || a + b == target) {
            return true;
        }
        
        State operations[6] = {
            {x, b},
            {a, y},
            {0, b},
            {a, 0},
            {(a - (y - b)) > 0 ? (a - (y - b)) : 0, (a + b) < y ? (a + b) : y},
            {(a + b) < x ? (a + b) : x, (b - (x - a)) > 0 ? (b - (x - a)) : 0}
        };
        
        for (int i = 0; i < 6; i++) {
            char key[30];
            sprintf(key, "%d,%d", operations[i].a, operations[i].b);
            
            bool found = false;
            for (int j = 0; j < visitedCount; j++) {
                if (strcmp(visited[j], key) == 0) {
                    found = true;
                    break;
                }
            }
            
            if (!found && rear < MAX_STATES && visitedCount < MAX_STATES) {
                strcpy(visited[visitedCount++], key);
                queue[rear++] = operations[i];
            }
        }
    }
    
    return false;
}

int main() {
    int x, y, target;
    scanf("%d %d %d", &x, &y, &target);
    
    bool result = solution(x, y, target);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(x × y)

In worst case, visit all possible states (a,b) where 0≤a≤x and 0≤b≤y

✓ Linear Growth

Space Complexity

O(x × y)

Need to store visited states in set, plus BFS queue

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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

BFS State Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler