Power up C++ with STL: Part II (string, set, map)

See Power up C++ with STL: Part I (introduction && vector)

String
There is a special container to manipulate with strings. The string container has a few differences from vector<char>. Most of the differences come down to string manipulation functions and memory management policy.

String has a substring function without iterators, just indices:

string s = "hello";


string


s1 = s.substr(0, 3), // "hel"


s2 = s.substr(1, 3), // "ell"


s3 = s.substr(0, s.length()-1), "hell"


s4 = s.substr(1); // "ello"

Beware of (s.length()-1) on empty string because s.length() is unsigned and unsigned(0) – 1 is definitely not what you are expecting!

Set
It’s always hard to decide which kind of container to describe first – set or map. My opinion is that, if the reader has a basic knowledge of algorithms, beginning from 'set' should be easier to understand.

Consider we need a container with the following features:

add an element, but do not allow duples [duplicates?]

remove elements

get count of elements (distinct elements)

check whether elements are present in set

This is quite a frequently used task. STL provides the special container for it – set. Set can add, remove and check the presence of particular element in O(log N), where N is the count of objects in the set. While adding elements to set, the duples [duplicates?] are discarded. A count of the elements in the set, N, is returned in O(1). We will speak of the algorithmic implementation of set and map later -- for now, let’s investigate its interface:

set<int> s;






for(int i = 1; i <= 100; i++) ...{


s.insert(i); // Insert 100 elements, [1..100]


}




s.insert(42); // does nothing, 42 already exists in set






for(int i = 2; i <= 100; i += 2) ...{


s.erase(i); // Erase even values


}




int n = int(s.size()); // n will be 50

The push_back() member may not be used with set. It make sense: since the order of elements in set does not matter, push_back() is not applicable here.

Since set is not a linear container, it’s impossible to take the element in set by index. Therefore, the only way to traverse the elements of set is to use iterators.

// Calculate the sum of elements in set


set<int> S;


// ...


int r = 0;




for(set<int>::const_iterator it = S.begin(); it != S.end(); it++) ...{


r += *it;


}

It's more elegant to use traversing macros here. Why? Imagine you have a set< pair<string, pair< int, vector<int> > >. How to traverse it? Write down the iterator type name? Oh, no. Use our traverse macros instead.

set< pair<string, pair< int, vector<int> > > SS;


int total = 0;




tr(SS, it) ...{


total += it->second.first;


}

Notice the 'it->second.first' syntax. Since 'it' is an iterator, we need to take an object from 'it' before operating. So, the correct syntax would be '(*it).second.first'. However, it’s easier to write 'something->' than '(*something)'. The full explanation will be quite long –just remember that, for iterators, both syntaxes are allowed.

To determine whether some element is present in set use 'find()' member function. Don’t be confused, though: there are several 'find()' ’s in STL. There is a global algorithm 'find()', which takes two iterators, element, and works for O(N). It is possible to use it for searching for element in set, but why use an O(N) algorithm while there exists an O(log N) one? While searching in set and map (and also in multiset/multimap, hash_map/hash_set, etc.) do not use global find – instead, use member function 'set::find()'. As 'ordinal' find, set::find will return an iterator, either to the element found, or to 'end()'. So, the element presence check looks like this:

set<int> s;


// ...




if(s.find(42) != s.end()) ...{


// 42 presents in set


}




else ...{


// 42 not presents in set


}

Another algorithm that works for O(log N) while called as member function is count. Some people think that

if(s.count(42) != 0) ...{


// …


}

or even

if(s.count(42)) ...{


// …


}

is easier to write. Personally, I don’t think so. Using count() in set/map is nonsense: the element either presents or not. As for me, I prefer to use the following two macros:


#define present(container, element) (container.find(element) != container.end())


#define cpresent(container, element) (find(all(container),element) != container.end())

(Remember that all(c) stands for “c.begin(), c.end()”)

Here, 'present()' returns whether the element presents in the container with member function 'find()' (i.e. set/map, etc.) while 'cpresent' is for vector.

To erase an element from set use the erase() function.

set<int> s;


// …


s.insert(54);


s.erase(29);

The erase() function also has the interval form:


set<int> s;


// ..




set<int>::iterator it1, it2;


it1 = s.find(10);


it2 = s.find(100);


// Will work if it1 and it2 are valid iterators, i.e. values 10 and 100 present in set.


s.erase(it1, it2); // Note that 10 will be deleted, but 100 will remain in the container

Set has an interval constructor:

int data[5] = ...{ 5, 1, 4, 2, 3 };


set<int> S(data, data+5);

It gives us a simple way to get rid of duplicates in vector, and sort it:

vector<int> v;


// …


set<int> s(all(v));


vector<int> v2(all(s));

Here 'v2' will contain the same elements as 'v' but sorted in ascending order and with duplicates removed.

Any comparable elements can be stored in set. This will be described later.

Map
There are two explanation of map. The simple explanation is the following:

map<string, int> M;


M["Top"] = 1;


M["Coder"] = 2;


M["SRM"] = 10;




int x = M["Top"] + M["Coder"];






if(M.find("SRM") != M.end()) ...{


M.erase(M.find("SRM")); // or even M.erase("SRM")


}

Very simple, isn’t it?

Actually map is very much like set, except it contains not just values but pairs <key, value>. Map ensures that at most one pair with specific key exists. Another quite pleasant thing is that map has operator [] defined.

Traversing map is easy with our 'tr()' macros. Notice that iterator will be an std::pair of key and value. So, to get the value use it->second. The example follows:

map<string, int> M;


// …


int r = 0;




tr(M, it) ...{


r += it->second;


}

Don’t change the key of map element by iterator, because it may break the integrity of map internal data structure (see below).

There is one important difference between map::find() and map::operator []. While map::find() will never change the contents of map, operator [] will create an element if it does not exist. In some cases this could be very convenient, but it's definitly a bad idea to use operator [] many times in a loop, when you do not want to add new elements. That’s why operator [] may not be used if map is passed as a const reference parameter to some function:




void f(const map<string, int>& M) ......{




if(M["the meaning"] == 42) ......{ // Error! Cannot use [] on const map objects!


}


if(M.find("the meaning") != M.end()




&& M.find("the meaning")->second == 42) ......{ // Correct


cout << "Don't Panic!" << endl;


}


}

Notice on Map and Set
Internally map and set are almost always stored as red-black trees. We do not need to worry about the internal structure, the thing to remember is that the elements of map and set are always sorted in ascending order while traversing these containers. And that’s why it’s strongly not recommended to change the key value while traversing map or set: If you make the modification that breaks the order, it will lead to improper functionality of container's algorithms, at least.

But the fact that the elements of map and set are always ordered can be practically used while solving TopCoder problems.

Another important thing is that operators ++ and -- are defined on iterators in map and set. Thus, if the value 42 presents in set, and it's not the first and the last one, than the following code will work:

set<int> S;


// ...


set<int>::iterator it = S.find(42);


set<int>::iterator it1 = it, it2 = it;


it1--;


it2++;


int a = *it1, b = *it2;

Here 'a' will contain the first neighbor of 42 to the left and 'b' the first one to the right.

More on algorithms
It’s time to speak about algorithms a bit more deeply. Most algorithms are declared in the #include <algorithm> standard header. At first, STL provides three very simple algorithms: min(a,b), max(a,b), swap(a,b). Here min(a,b) and max(a,b) returns the minimum and maximum of two elements, while swap(a,b) swaps two elements.

Algorithm sort() is also widely used. The call to sort(begin, end) sorts an interval in ascending order. Notice that sort() requires random access iterators, so it will not work on all containers. However, you probably won't ever call sort() on set, which is already ordered.

You’ve already heard of algorithm find(). The call to find(begin, end, element) returns the iterator where ‘element’ first occurs, or end if the element is not found. Instead of find(...), count(begin, end, element) returns the number of occurrences of an element in a container or a part of a container. Remember that set and map have the member functions find() and count(), which works in O(log N), while std::find() and std::count() take O(N).

Other useful algorithms are next_permutation() and prev_permutation(). Let’s speak about next_permutation. The call to next_permutation(begin, end) makes the interval [begin, end) hold the next permutation of the same elements, or returns false if the current permutation is the last one. Accordingly, next_permutation makes many tasks quite easy. If you want to check all permutations, just write:

vector<int> v;






for(int i = 0; i < 10; i++) ...{


v.push_back(i);


}






do ...{


Solve(..., v);


} while(next_permutation(all(v));

Don’t forget to ensure that the elements in a container are sorted before your first call to next_permutation(...). Their initial state should form the very first permutation; otherwise, some permutations will not be checked.

String Streams
You often need to do some string processing/input/output. C++ provides two interesting objects for it: 'istringstream' and 'ostringstream'. They are both declared in #include <sstream>.

Object istringstream allows you to read from a string like you do from a standard input. It's better to view source:

void f(const string& s) ...{




// Construct an object to parse strings


istringstream is(s);




// Vector to store data


vector<int> v;




// Read integer while possible and add it to the vector


int tmp;




while(is >> tmp) ...{


v.push_back(tmp);


}


}

The ostringstream object is used to do formatting output. Here is the code:

string f(const vector<int>& v) ...{




// Constucvt an object to do formatted output


ostringstream os;




// Copy all elements from vector<int> to string stream as text




tr(v, it) ...{


os << ' ' << *it;


}




// Get string from string stream


string s = os.str();




// Remove first space character




if(!s.empty()) ...{ // Beware of empty string here


s = s.substr(1);


}




return s;


}

Summary
To go on with STL, I would like to summarize the list of templates to be used. This will simplify the reading of code samples and, I hope, improve your TopCoder skills. The short list of templates and macros follows:

typedef vector<int> vi;


typedef vector<vi> vvi;


typedef pair<int,int> ii;


#define sz(a) int((a).size())


#define pb push_back


#defile all(c) (c).begin(),(c).end()


#define tr(c,i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)


#define present(c,x) ((c).find(x) != (c).end())


#define cpresent(c,x) (find(all(c),x) != (c).end())

The container vector<int> is here because it's really very popular. Actually, I found it convenient to have short aliases to many containers (especially for vector<string>, vector<ii>, vector< pair<double, ii> >). But this list only includes the macros that are required to understand the following text.

Another note to keep in mind: When a token from the left-hand side of #define appears in the right-hand side, it should be placed in braces to avoid many nontrivial problems.