# Interval Map Implementation

A template-based C++ implementation of an efficient interval map data structure that maps intervals (ranges) of keys to values, rather than individual key-value pairs.

## Overview

`interval_map<K, V>` is a specialized container that associates values with continuous intervals of keys. Instead of storing a value for every single key, it compresses storage by representing contiguous ranges that map to the same value.

### Key Characteristics

- **Efficient Storage**: Stores only the boundaries where values change, reducing memory overhead compared to individual key mappings
- **Standard Library Integration**: Built on top of `std::map` for reliable performance and familiarity
- **Template-Based**: Supports any comparable key type (`K`) and any value type (`V`)
- **Interval Semantics**: Follows C++ conventions with half-open intervals `[keyBegin, keyEnd)`

## How It Works

### Constructor
```cpp
interval_map(V const& val, K k_range=1000)
```
Initializes the map with a default value that covers the entire key range. Pre-populates the internal map with entries for optimization purposes.

### assign() Method
```cpp
void assign(K const& keyBegin, K const& keyEnd, V const& val)
```
Assigns a value `val` to the interval `[keyBegin, keyEnd)`.
- If `keyBegin >= keyEnd`, the interval is empty and nothing is done
- Overwrites any previous values in this interval
- Uses `std::map::lower_bound()` for efficient O(log n) interval lookup

### Operator[]
```cpp
V const& operator[](K const& key) const
```
Performs efficient O(log n) lookup to retrieve the value associated with a given key.

## Usage Example

```cpp
interval_map<int, char> m('A', 100);  // Initialize with 'A' covering [0, 100)
m.assign(-10, 50, 'B');                // Assign 'B' to [-10, 50)
m['25'];                               // Returns 'B'
m['75'];                               // Returns 'A'
```

## Building and Running

### Compile
```bash
g++ -std=c++11 -o interval_map main.cpp
```

### Run
```bash
./interval_map
```

## Implementation Details

This implementation demonstrates:
- Mastery of `std::map` operations (`lower_bound`, `upper_bound`, `insert`)
- Efficient interval range manipulation
- Template metaprogramming with multiple template parameters
- Memory-efficient data structure design
- Proper use of C++ Standard Library conventions

## Use Cases

- Graphics rendering (color transitions)
- Time-based event scheduling
- Segment compression and querying
- Network routing tables
- Configuration management with ranges