Here's a concise yet comprehensive C++ cheatsheet optimized for LeetCode challenges:

Basic Syntax

#include <iostream>
using namespace std;

int main() {
    // Variables
    int x = 5;
    double y = 3.14;
    string s = "Hello";

    // Input/Output
    cin >> x;           // Reads input
    cout << x << endl;  // Prints output with newline

    // Conditional
    if (x > 0) { /* ... */ } // Executes if condition is true

    // Loops
    for (int i = 0; i < 10; i++) { /* ... */ } // Iterates 10 times
    while (x--) { /* ... */ } // Executes while condition is true
    do { /* ... */ } while (x > 0); // Executes at least once

    return 0;
}

STL Containers

Vector (#include <vector>)

vector<int> v = {1, 2, 3};
v.push_back(4);       // Adds element to the end (O(1) amortized)
v.pop_back();         // Removes last element (O(1))
v.size();             // Returns number of elements (O(1))
v.empty();            // Checks if vector is empty (O(1))
v.front();            // Returns first element (O(1))
v.back();             // Returns last element (O(1))
v.begin();            // Returns iterator to the beginning (O(1))
v.end();              // Returns iterator to the end (O(1))
v.erase(v.begin()+1); // Removes element at index 1 (O(n))
v.insert(v.begin()+1, 10); // Inserts 10 at index 1 (O(n))
sort(v.begin(), v.end()); // Sorts the vector (O(n log n))
reverse(v.begin(), v.end()); // Reverses the vector (O(n))

String (#include <string>)

string s = "abc";
s += "def";            // Concatenates strings (O(1) amortized)
s.substr(1, 2);        // Returns substring "bc" (start, length) (O(n))
s.find("bc");          // Returns index of first occurrence or string::npos (O(n))
s.replace(1, 2, "xy"); // Replaces 2 chars starting at index 1 with "xy" (O(n))
s.erase(1, 2);         // Removes 2 chars starting at index 1 (O(n))
s.insert(1, "xy");     // Inserts "xy" at index 1 (O(n))
s.size();              // Returns length of string (O(1))
s.empty();             // Checks if string is empty (O(1))
s.clear();             // Clears the string (O(1))
reverse(s.begin(), s.end()); // Reverses the string (O(n))

Queue (#include <queue>)

queue<int> q;
q.push(10);            // Adds element to the end (O(1))
q.pop();               // Removes first element (O(1))
q.front();             // Returns first element (O(1))
q.back();              // Returns last element (O(1))
q.size();              // Returns number of elements (O(1))
q.empty();             // Checks if queue is empty (O(1))

Stack (#include <stack>)

stack<int> stk;
stk.push(10);          // Adds element to the top (O(1))
stk.pop();             // Removes top element (O(1))
stk.top();             // Returns top element (O(1))
stk.size();            // Returns number of elements (O(1))
stk.empty();           // Checks if stack is empty (O(1))

Priority Queue (Heap, #include <queue>)

priority_queue<int> max_heap; // Max-heap by default
priority_queue<int, vector<int>, greater<int>> min_heap; // Min-heap
pq.push(3);            // Adds element (O(log n))
pq.pop();              // Removes top element (O(log n))
pq.top();              // Returns top element (O(1))
pq.size();             // Returns number of elements (O(1))
pq.empty();            // Checks if priority queue is empty (O(1))

Unordered Set/Map (Hash Tables, #include <unordered_set>/<unordered_map>)

unordered_set<int> s;
s.insert(10);          // Adds element (O(1) average)
s.erase(10);           // Removes element (O(1) average)
s.count(10);           // Returns 1 if element exists, else 0 (O(1) average)
s.find(10);            // Returns iterator to element or s.end() (O(1) average)
s.size();              // Returns number of elements (O(1))
s.empty();             // Checks if set is empty (O(1))

unordered_map<string, int> m;
m["key"] = 5;          // Inserts or updates value (O(1) average)
m.erase("key");        // Removes key-value pair (O(1) average)
m.count("key");        // Returns 1 if key exists, else 0 (O(1) average)
m.find("key");         // Returns iterator to key-value pair or m.end() (O(1) average)
m.size();              // Returns number of key-value pairs (O(1))
m.empty();             // Checks if map is empty (O(1))

Ordered Set/Map (Balanced BST, #include <set>/<map>)