vector<int> v;              // empty
vector<int> v(5);           // 5 elements, all 0
vector<int> v(5, 10);       // 5 elements, all 10
vector<int> v = {1, 2, 3};  // initializer list

v.push_back(x);     // add to end — O(1) amortized
v.pop_back();       // remove from end — O(1)
v.size();           // number of elements
v.empty();          // true if size is 0
v.clear();          // remove all elements
v.front();          // first element
v.back();           // last element
v[i];               // access by index (no bounds check)
v.at(i);            // access by index (throws if out of bounds)

v.begin();   // iterator to first element
v.end();     // iterator past last element
v.rbegin();  // reverse iterator to last element
v.rend();    // reverse iterator past first element

// n x m grid initialized to 0
vector<vector<int>> grid(n, vector<int>(m, 0));

// Jagged 2D vector
vector<vector<int>> adj(n);  // adjacency list
for (int i = 0; i < m; i++) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
    adj[v].push_back(u);
}

pair<int, int> p = {3, 4};
cout << p.first << " " << p.second;  // 3 4

// Nested pairs
pair<int, pair<int, int>> nested = {1, {2, 3}};
cout << nested.second.first;  // 2

pair<int,int> a = {1, 5};
pair<int,int> b = {1, 3};
a < b;  // false (same first, 5 > 3)

pair<int,int> c = {2, 1};
a < c;  // true (1 < 2)

tuple<int, string, double> t = {1, "hello", 3.14};

// Access
cout << get<0>(t) << " " << get<1>(t);  // 1 hello

// Structured binding (C++17)
auto [id, name, score] = t;

tuple<int,int,int> a = {1, 2, 3};
tuple<int,int,int> b = {1, 2, 4};
a < b;  // true

string s = "hello world";

// Sorting characters
sort(s.begin(), s.end());         // " dehllloorw"

// Reversing
reverse(s.begin(), s.end());      // "dlrow olleh"

// Removing duplicates (must sort first)
sort(s.begin(), s.end());
s.erase(unique(s.begin(), s.end()), s.end());

// Counting
int count = std::count(s.begin(), s.end(), 'l');  // 3

// Finding
auto it = std::find(s.begin(), s.end(), 'w');
if (it != s.end()) {
    int index = it - s.begin();
}

// Forward iteration
for (auto it = v.begin(); it != v.end(); ++it) {
    cout << *it << " ";
}

// Reverse iteration
for (auto it = v.rbegin(); it != v.rend(); ++it) {
    cout << *it << " ";
}

// With structured bindings
for (auto it = v.begin(); it != v.end(); ++it) {
    int index = it - v.begin();
    int value = *it;
}

// Sorting
sort(v.begin(), v.end());
sort(v.begin(), v.end(), greater<int>());  // descending

// Binary search (on sorted range)
binary_search(v.begin(), v.end(), x);  // true/false
auto it = lower_bound(v.begin(), v.end(), x);  // first >= x
auto it = upper_bound(v.begin(), v.end(), x);  // first > x

// Min/Max
int mn = *min_element(v.begin(), v.end());
int mx = *max_element(v.begin(), v.end());
auto [minIt, maxIt] = minmax_element(v.begin(), v.end());

// Reversing
reverse(v.begin(), v.end());

// Rotating
rotate(v.begin(), v.begin() + k, v.end());  // rotate left by k

// Permutations
next_permutation(v.begin(), v.end());  // next lexicographic permutation

// Accumulate
long long sum = accumulate(v.begin(), v.end(), 0LL);

// Unique (on sorted range, removes consecutive duplicates)
auto last = unique(v.begin(), v.end());
v.erase(last, v.end());

// Fill
fill(v.begin(), v.end(), 0);

// Count
int cnt = count(v.begin(), v.end(), x);

// Find
auto it = find(v.begin(), v.end(), x);