Data Structures :: Needed For ICPC-2016 ?

Here Are Some Data Structures That One Should Learn In Order To crack ICPC :smiley:

6 Likes

Every Talks About Algorithm :smiley:
DS is also Important…

Most Important is ->
Suffix array

Suffix array is a data structure that helps you sort all the suffixes in lexicography order.

This array consists of integers, the beginning of suffixes.

There are two ways to achieve this goal :

One) Non-deterministic algorithm : Use Robin-Carp and for check if a suffix is lexicographically less than another one, find their LCP using binary search + hash and then check the next character after their LCP.

Code :

namespace HashSuffixArray
{
const int
MAXN = 1 << 21;

typedef unsigned long long hash;

const hash BASE = 137;

int N;
char * S;
int sa[MAXN];
hash h[MAXN], hPow[MAXN];

#define getHash(lo, size) (h[lo] - h[(lo) + (size)] * hPow[size])

inline bool sufCmp(int i, int j)
{
	int lo = 1, hi = min(N - i, N - j);
	while (lo <= hi)
	{
		int mid = (lo + hi) >> 1;
		if (getHash(i, mid) == getHash(j, mid))
			lo = mid + 1;
		else
			hi = mid - 1;
	}
	return S[i + hi] < S[j + hi];
}

void buildSA()
{
	N = strlen(S);
	hPow[0] = 1;
	for (int i = 1; i <= N; ++i)
		hPow[i] = hPow[i - 1] * BASE;
	h[N] = 0;
	for (int i = N - 1; i >= 0; --i)
		h[i] = h[i + 1] * BASE + S[i], sa[i] = i;

	stable_sort(sa, sa + N, sufCmp);
}

} // end namespace HashSuffixArray
Two) Deterministic algorithm : We sort them log(MaxLength) steps, in the i - th step (counting from 0), we sort them according to their first 2i characters and put the suffixes whit the same prefix with 2i characters in the same buckets.

Code :

/*
Suffix array O(n lg^2 n)
LCP table O(n)
*/
#include
#include
#include

using namespace std;

#define REP(i, n) for (int i = 0; i < (int)(n); ++i)

namespace SuffixArray
{
const int MAXN = 1 << 21;
char * S;
int N, gap;
int sa[MAXN], pos[MAXN], tmp[MAXN], lcp[MAXN];

bool sufCmp(int i, int j)
{
	if (pos[i] != pos[j])
		return pos[i] < pos[j];
	i += gap;
	j += gap;
	return (i < N && j < N) ? pos[i] < pos[j] : i > j;
}

void buildSA()
{
	N = strlen(S);
	REP(i, N) sa[i] = i, pos[i] = S[i];
	for (gap = 1;; gap *= 2)
	{
		sort(sa, sa + N, sufCmp);
		REP(i, N - 1) tmp[i + 1] = tmp[i] + sufCmp(sa[i], sa[i + 1]);
		REP(i, N) pos[sa[i]] = tmp[i];
		if (tmp[N - 1] == N - 1) break;
	}
}

void buildLCP()
{
	for (int i = 0, k = 0; i < N; ++i) if (pos[i] != N - 1)
	{
		for (int j = sa[pos[i] + 1]; S[i + k] == S[j + k];)
		++k;
		lcp[pos[i]] = k;
		if (k)--k;
	}
}

} // end namespace SuffixArray

Here Are Some Good DS like BST,Seg-Tree and tries Etc.

TRIES

Tries are some kind of rooted trees in which each edge has a character on it. Actually, trie is some kind of DFA (Determining Finite Automata). For a bunch of strings, their trie is the smallest rooted tree with a character on each edge and each of these strings can be build by writing down the characters in the path from the root to some node.

It’s advantage is, LCP (Longest Common Prefix) of two of these strings is the LCA (Lowest Common Ancestor) of their nodes in the trie(a node that we can build the string by writing down the characters in the path from the root to that node).

Generating the trie :

Root is vertex number 0 (C++)

int x[MAX_NUMBER_OF_NODES][MAX_ASCII_CODE], next = 1; //initially all numbers in x are -1
void build(string s){
int i = 0, v = 0;
while(i < s.size()){
if(x[v][s[i]] == -1)
v = x[v][s[i++]] = next ++;
else
v = x[v][s[i++]];
}
}

and LASTLY
-> segment TREE

10 Likes

Could you please re-format your post…the code looks distorted.

1 Like

CODE is only for understanding not copy pasting

4 Likes

https://www.quora.com/What-are-the-most-important-data-structures-needed-to-reach-the-ACM-ICPC-World-Finals

https://www.quora.com/What-are-some-algorithms-and-data-structures-which-should-definitely-be-included-in-ones-ACM-ICPC-team-notebook

https://www.quora.com/Which-data-structures-are-used-commonly-in-programming-competitions-e-g-ACM-ICPC-in-Java

1 Like

thanks a lot for links :smiley:

1 Like
//