CareerCup

Very embarrassed for duplicate submission, because just happened a problem when submitting, but I do not know how to delete.....

the template definition for hash_map is : template <
class Key,
class Value,
class HashKey = Self<Key>,
class EqualKey = EqualTo<Key>,
class LessKey = Less<Key>,
class Alloc = DefaultAllocator<Pair<const Key, Value>
for HashKey, that is for converting Key into bucket index. EqualKey is try to compare to key to check whether occur collision. But for LessKey I guess for some implementation such as Red-Black tree or AVL, it is useful.

the template definition for hash_map is : template <
class Key,
class Value,
class HashKey = Self<Key>,
class EqualKey = EqualTo<Key>,
class LessKey = Less<Key>,
class Alloc = DefaultAllocator<Pair<const Key, Value>
for HashKey, that is for converting Key into bucket index. EqualKey is try to compare to key to check whether occur collision. But for LessKey I guess for some implementation such as Red-Black tree or AVL, it is useful.

the template definition for hash_map is : template <
class Key,
class Value,
class HashKey = Self<Key>,
class EqualKey = EqualTo<Key>,
class LessKey = Less<Key>,
class Alloc = DefaultAllocator<Pair<const Key, Value>
for HashKey, that is for converting Key into bucket index. EqualKey is try to compare to key to check whether occur collision. But for LessKey I guess for some implementation such as Red-Black tree or AVL, it is useful.

the template definition for hash_map is : template <
class Key,
class Value,
class HashKey = Self<Key>,
class EqualKey = EqualTo<Key>,
class LessKey = Less<Key>,
class Alloc = DefaultAllocator<Pair<const Key, Value>
for HashKey, that is for converting Key into bucket index. EqualKey is try to compare to key to check whether occur collision. But for LessKey I guess for some implementation such as Red-Black tree or AVL, it is useful.

the template definition for hash_map is : template <
class Key,
class Value,
class HashKey = Self<Key>,
class EqualKey = EqualTo<Key>,
class LessKey = Less<Key>,
class Alloc = DefaultAllocator<Pair<const Key, Value>
for HashKey, that is for converting Key into bucket index. EqualKey is try to compare to key to check whether occur collision. But for LessKey I guess for some implementation such as Red-Black tree or AVL, it is useful.

the template definition for hash_map is : template <
class Key,
class Value,
class HashKey = Self<Key>,
class EqualKey = EqualTo<Key>,
class LessKey = Less<Key>,
class Alloc = DefaultAllocator<Pair<const Key, Value>
for HashKey, that is for converting Key into bucket index. EqualKey is try to compare to key to check whether occur collision. But for LessKey I guess for some implementation such as Red-Black tree or AVL, it is useful.

the template definition for hash_map is : template <
class Key,
class Value,
class HashKey = Self<Key>,
class EqualKey = EqualTo<Key>,
class LessKey = Less<Key>,
class Alloc = DefaultAllocator<Pair<const Key, Value>
for HashKey, that is for converting Key into bucket index. EqualKey is try to compare to key to check whether occur collision. But for LessKey I guess for some implementation such as Red-Black tree or AVL, it is useful.

It realy depend what kind of data will be reserved.Generally speaking, BST will have less memory comparied with HashTable

I would think that HashTable is much easier to support concurrency in many readers but only one writer, because we could lock or no lock the key-value pair when insertion or update(lock-free means we can delay-delete the node).Also for BST, I also think it's ok for insertion or delete, but for Red-Black tree or AVL tree, it is another matter for the rotations.

I think we can do it by using double linked-list, which is hold pointers pointing a fix-size of buffer. Insertion\Delete\Edit may have O(1) complexity(),also could add hash_map whose key is line number and value is pointers belong to the linked-list.
About search forward or backwards, firstly we must locate the current position and using KMP to finishing searching, and the complexcity is O(L*N), L is line size and N is charcter number average.

I think a double linked-list and a hash table is enough.

two solution, one is recuison 1) matrix block, the matrix can be divided into 4 block 2) from the left-down position, an example :
1 2 3 4
5 6 7 8
9 10 11 12 where k is 7.
9 > 7, so delete the last line, and go up, 5 < 7, the delete the first line, will find 6 .....matrix will be smaller and smaller, and finally get the destinetion

I think it is great solution~

the additional space is not O(height).Your solution will be work in just array