1|Duta Wacana Christi an University Cheat Sheet 2015

Genes ........................................................................................................................ 7

Duta Wacana Christian University

Cheat Sheet 2015
Icpc Asia Regional Jakarta

Large KnapSack .................................................................................................... 7

Luggage (Dynamic Programming) ................................................................... 7
Luggage (Brute Force) ..................................................................................... 8
Median (Priority_Queue) ................................................................................ 9

PedWaY

Potentiometer (Fenwick Tree) ..................................................................... 9

Yosia Wawan Pedro

Square (Dynamic Programming) ................................................................... 10

A Node To Far .................................................................................................... 10

Contents
Union Find ............................................................................................................. 3
Fenwick Tree ........................................................................................................ 3
Depth First Search ........................................................................................... 3
Breadth First Search ....................................................................................... 3
Shortest Path (Dijkstra) .............................................................................. 3
Bellman Ford ........................................................................................................ 3
Topological Sort ................................................................................................ 3
Kosaraju ................................................................................................................. 4
Tarjan...................................................................................................................... 4
Kruskal ................................................................................................................... 4
Longest Increasing / Decreasing Subsequence .................................... 4
GCD & LCM ............................................................................................................... 4
Library & Others ................................................................................................ 5
Bytelandian Coins (Dynamic Programming) ............................................. 5
Defense (Longest Increasing Subsequence) ........................................... 5
Freckles ................................................................................................................. 6

Come And Go (Kosaraju) ................................................................................ 10

Max Subsequence Multiplication ............................................................... 11
Min SegmentTree Query ................................................................................... 11
Range Min Segtree ........................................................................................... 12
Segment Tree (Contoh GSS3) ........................................................................ 12
Segment Tree (Contoh BRCKTS) ................................................................... 12
Orderset ............................................................................................................... 12
General Merge Up.............................................................................................. 13
Segment Tree (Horrible) .............................................................................. 13
DP Bitmask ........................................................................................................... 14
Sieve Of Erastothenes ................................................................................... 14
Chained Matrix Multiplication ................................................................. 15
Floyd Warshall .................................................................................................. 15
Java Big Integer.............................................................................................. 16
Sieve : Generate Prime ................................................................................ 17
Prime Factor ...................................................................................................... 17
Count Number Divisors ................................................................................... 17

2|Duta Wacana Christi an University Cheat Sheet 2015

Sum Divisors ...................................................................................................... 17

Catalan Number .................................................................................................. 18
Extended Euler Phi ......................................................................................... 19
EXTENDED EULCID FOR ax + by = c ............................................................. 19
UVA 10036 Divisibility ............................................................................ 19
Exponentiation - The Russian Peasant Algorithm .................... 20
Fibonacci Number .............................................................................................. 20
Floyd Cycle Finding Algorithm ................................................................. 20

3|Duta Wacana Christi an University Cheat Sheet 2015

Union Find
class UnionFind {
private:
vi p, rank, setSize;
int numSets;
public:
UnionFind(int N) {
setSize.assign(N, 1); numSets = N; rank.assign(N, 0);
p.assign(N, 0); for (int i = 0; i < N; i++) p[i] = i; }
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) { numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) { p[y] = x; setSize[x] += setSize[y]; }
else
{ p[x] = y; setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++; } } }
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};

Fenwick Tree
class FenwickTree{
private:
vi ft;
public:
FenwickTree(int n) { ft.assign(n+1, 0); }
int rsq(int b) { int sum=0; for(; b; b -= LSOne(b)) sum += ft[b]; return sum; }
int rsq(int a, int b) { return rsq(b) (a == 1 ? 0 : rsq(a-1)); }
void adjust(int k, int v) { for(; k<(int)ft.size(); k+=LSOne(k)) ft[k]+=v; } };

Depth First Search

vi dfs_num;
void dfs(int u) {
dfs_num[u] = VISITED;
for(int j = 0; j < (int)AdjList[u].size(); j++) {
ii v = AdjList[u][j];
if(dfs_num[v.first] == UNVISITED) dfs(v.first); } }

Breadth First Search

vi d(V, INF); d[s]=0;
queue<int> q; q.push(s);

while(!q.empty()) {
int u=q.front(); q.pop();
for(int j = 0; j < (int)AdjList[u].size(); j++){
ii v=AdjList[u][j];
if(d[v.first] == INF) { d[v.first] = d[u] + 1; q.push(v.first); } } }

Shortest Path (Dijkstra)

int edgeTo[11];
void printPath(int s, int t) {
if(s == t) { printf("%d", s); return; }
printPath(s, edgeTo[t]); printf(" %d", t);
}
vector<vii> AdjList;
AdjList.assign(n + 1, vii());
AdjList[a-1].push_back(ii(b-1,w));
vi dist(NI+1, INF); dist[s] = 0; memset(edgeTo, -1, sizeof edgeTo);
edgeTo[s] = s; priority_queue< ii, vector<ii>, greater<ii> > pq;
pq.push(ii(0, s));
while (!pq.empty()) {
ii front = pq.top();pq.pop(); int d = front.first, u = front.second;
if (d > dist[u]) continue;
for (int j = 0; j < (int)AdjList[u].size(); j++) {
ii v = AdjList[u][j];
if (dist[u] + v.second < dist[v.first]) {
dist[v.first] = dist[u] + v.second; edgeTo[v.first] = u;
pq.push(ii(dist[v.first], v.first)); } } }

Bellman Ford
int s = 1;
vi dist(N+1, INF); dist[s]=0;
for(int i = 1; i < N; i++) for(int u = 1; u < N+1; u++)
for(int j = 0; j < (int)AdjList[u].size(); j++){
ii v = AdjList[u][j];
dist[v.first] = min(dist[v.first], dist[u] + v.second); }
bool hasNegativeCycle = false;
for(int u = 1; u < N+1; u++)
for(int j = 0; j < (int)AdjList[u].size(); j++){
ii v = AdjList[u][j]; if(dist[v.first] > dist[u] + v.second)
hasNegativeCycle = true; } printf();

Topological Sort
vi ts;
void dfs2(int u){

4|Duta Wacana Christi an University Cheat Sheet 2015

dfs_num[u] = VISITED;
for(int j = 0; j < (int)AdjList[u].size(); j++){
ii v = AdjList[u][j];
if(dfs_num[v.first] == UNVISITED)
dfs2(v.first);
}
ts.push_back(u);
}
----------------------------------------------------------------------------------int i, j, N, M, V, W, P, dfsNumberCounter, numSCC;
vector<vii> AdjList, AdjListT;
vi dfs_num, dfs_low, S, S_copy, visited;

Kruskal
vector< pair<int, ii> > EdgeList;
sort(EdgeList.begin(), EdgeList.end());
mstnew=0; UnionFind UF(N);
for(int I = 0; i < M+K; i++) {
pair<int, ii> nextEdge = EdgeList[i];
if(!UF.isSameSet(nextEdge.second.first, nextEdge.second.second)) {
mstnew += nextEdg.1st;
UF.unionSet(nextEdge.second.first, nextEdge.second.first); } }
-----------------------------------------------------------------------------------

Longest Increasing / Decreasing Subsequence

unsigned long LDS[2005], LIS[2005];

Kosaraju
void Kosaraju(int u, int pass) {
dfs_num[u] = 1; vii neighbor;
if(pass==1) neighbor = AdjList[u];
else neighbor = AdjListT[u];
for(int j = 0; j < (int)neighbor.size(); j++) {
ii v = neighbor[j];
if(dfs_num[v.first] == DFS_WHITE) Kosaraju(v.first, pass);
}
S.push_back(u); }

void doLIS() {
LIS[0] = 1;
for(int i = n - 1; i >= 0; i--){ ul tmp = 1; for(int j = i + 1; j < n; j++) {
if(v[i] < v[j]){ tmp = max(tmp, LIS[j] + 1); } } LIS[i] = tmp; } }
void doLDS() {
LDS[0] = 1;
for(int i = n - 1; i >= 0; i--){ ul tmp = 1; for(int j = i + 1; j < n; j++) {
if(v[i] > v[j]){ tmp = max(tmp, LDS[j] + 1); } } LDS[i] = tmp; } }

GCD & LCM

Tarjan
void tarjanSCC(int u) {
dfs_low[u] = dfs_num[u] = dfsNumberCounter++; S.push_back(u);
visited[u] = 1; for(int j = 0; j < (int)AdjList[u].size(); j++){
ii v= AdjList[u][j];
if(dfs_num[v.first] == DFS_WHITE) tarjanSCC(v.first);
if(visited[v.first]) dfs_low[u] = min(dfs_low[u], dfs_low[v.first]); }
if(dfs_low[u] == dfs_num[u]) {
++numSCC;
while(1) { int v=S.back(); S.pop_back(); visited[v]=0; if(u==v) break; }
} }
-----------------------------------------------------------------------------------

int gcd(int a, int b){return b == 0 ? a : gcd(b,a%b);}

int lcm(int a, int b){return a*(b/ gcd(a,b));}

5|Duta Wacana Christi an University Cheat Sheet 2015

typedef vector<ii> vii;

Library & Others

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define
#define
#define
#define
#define
#define
#define
#define
#define

<vector>
<list>
<map>
<set>
<queue>
<deque>
<stack>
<bitset>
<algorithm>
<functional>
<numeric>
<utility>
<sstream>
<iostream>
<iomanip>
<cstdio>
<cmath>
<cstdlib>
<ctime>
<cstring>
<string>

REP(X, Y) for (int (X) = 0; (X) < (Y); ++(X))

FOR(X, Y, Z) for (int (X) = (Y); (X) <= (Z); ++(X))
RESET(C, V) memset(C, V, sizeof(C))
isOn(S, j) (S & (1 << j))
setBit(S, j) (S |= (1 << j))
clearBit(S, j) (S &= ~(1 << j))
toggleBit(S, j) (S ^= (1 << j))
lowBit(S) (S & (-S))
setAll(S, n) (S = (1 << n) - 1)

#define modulo(S, N) ((S) & (N - 1))

// returns S % N, where N is a power of 2
#define isPowerOfTwo(S) (!(S & (S - 1)))
#define nearestPowerOfTwo(S) ((int)pow(2.0, (int)((log((double)S) / log(2.0)) + 0.5)))
#define turnOffLastBit(S) ((S) & (S - 1))
#define turnOnLastZero(S) ((S) | (S + 1))
#define turnOffLastConsecutiveBits(S) ((S) & (S + 1))
#define turnOnLastConsecutiveZeroes(S) ((S) | (S - 1))
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> ii;

Bytelandian Coins (Dynamic Programming)

map<int, ll> memo;
ll exchangeornot(int n){
if(n < 12) return n;
if(memo[n] != 0) return memo[n];
if(!(n % 2 == 0 || n % 3 == 0 || n % 4 == 0)){
memo[n] = exchangeornot(n-1);
}
else{
memo[n] = max(ll(n), exchangeornot(n/2) + exchangeornot(n/3) +
exchangeornot(n/4));
}
return memo[n];
}
int main(){
ll input;
while(scanf("%d", &input) == 1){
cout << exchangeornot(input) << endl;
}
return 0;
}

Defense (Longest Increasing Subsequence)

int main(){
int tc;
int line = 0;
string s;
cin >> tc;
//untuk mengabaikan input blank line
getchar();
getline(cin, s);
while(tc--){
if(line != 0) cout << endl;
line = 1;
vector<int> height;
while(getline(cin, s)){

6|Duta Wacana Christi an University Cheat Sheet 2015

if(s.size() == 0) break;
height.push_back(atoi(s.c_str()));

}
while(!urutan.empty()){
printf("%d\n", urutan.top());
urutan.pop();
}

}
//hitung jumlah input
int n = height.size();
//jika tidak ada input
if(n == 0){
printf("Max hits: 0\n");
continue;
}
//bagian dynamic programming-nya
//bisa dijadikan fungsi
vector<int> lis;
lis.push_back(1);
for(int i = 1; i < n; i++){
//nilai lis untuk nilai yang terkecil dari 0 s/d i adalah 1
int temp = 1;
//cek nilai sebelumnya
for(int j = i-1; j >= 0; j--){
//jika nilai sebelumnya lebih besar dari nilai ke i
if(height[i] > height[j]){
//ubah nilai lis
temp = max(temp, lis[j]+1);
}
}
//setelah dapat yang maksimal, tampung hasilnya
lis.push_back(temp);
}
//akhir bagian dynamic programming-nya
int max = 0;
int index = 0;
//mencari nilai lis maksimum dan indeksnya
for(int i = 0; i < n; i++){
if(lis[i] > max){
max = lis[i];
index = i;
}
}
printf("Max hits: %d\n", max);
stack<int> urutan;
urutan.push(height[index]);
max--;
for(int i = index-1; i >= 0; i--){
if(lis[i] == max){
urutan.push(height[i]);
max--;
if(max == 0) break;
}

}
// cin >> tc;
return 0;
}

Freckles
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef pair<double, double> dd;
const int INF = 999999999;
// Union Find Class
int main(){
int tc, point;
double x, y, mst_cost;
vector<dd> v;
vector<pair<double, ii> > EdgeList;
string buang;
scanf("%d", &tc);
while(tc--){
v.clear();
EdgeList.clear();
mst_cost = 0;
getline(cin, buang);
getline(cin, buang);
scanf("%d", &point);
while(point--){
cin >> x >> y;
v.push_back(dd(x, y));
}
for(int i = 0; i < v.size(); i++){
for(int j = i+1; j < v.size(); j++){
double w = sqrt((v[i].firstv[j].first)*(v[i].first-v[j].first) + (v[i].second-v[j].second)*(v[i].secondv[j].second));
EdgeList.push_back(make_pair(w, ii(i+1, j+1)));
}
}
sort(EdgeList.begin(), EdgeList.end());
UnionFind UF(v.size());
for(int i = 0; i < EdgeList.size(); i++){
pair<double, ii> front = EdgeList[i];

7|Duta Wacana Christi an University Cheat Sheet 2015

if(!UF.isSameSet(front.second.first, front.second.second)){
mst_cost += front.first;
UF.unionSet(front.second.first,
front.second.second);
}
}
printf("%.2f\n", mst_cost);
} }

Genes
typedef pair<string, string> ss;
map<string, string> gen;
map<string, ss> parent;
set<string> name;
set<string> childlist;
set<string>::iterator iterset;
string findParent(string child){
if(gen[child] != "") return gen[child];
string p1 = findParent(parent[child].first);
string p2 = findParent(parent[child].second);
if(p1 == "dominant" && p2 == "dominant") return "dominant";
if(p1 == "dominant" && p2 == "recessive") return "dominant";
if(p1 == "dominant" && p2 == "non-existent") return "recessive";
if(p1 == "recessive" && p2 == "dominant") return "dominant";
if(p1 == "recessive" && p2 == "recessive") return "recessive";
if(p1 == "recessive" && p2 == "non-existent") return "non-existent";
if(p1 == "non-existent" && p2 == "dominant") return "recessive";
if(p1 == "non-existent" && p2 == "recessive") return "non-existent";
if(p1 == "non-existent" && p2 == "non-existent") return "non-existent";
}
int main(){
int line;
string str1, str2;
cin >> line;
while(line--){
cin >> str1 >> str2;
if(str2 == "dominant" || str2 == "recessive" || str2 == "non-existent"){
gen[str1] = str2;
name.insert(str1);
}
else{
if(parent[str2].first == "") parent[str2].first = str1;
else parent[str2].second = str1;
childlist.insert(str2);
name.insert(str2);
}

}
iterset = childlist.begin();
for( ; iterset != childlist.end(); iterset++){
gen[*iterset] = findParent(*iterset);
}
iterset = name.begin();
for( ; iterset != name.end(); iterset++){
cout << *iterset << " " << gen[*iterset] << endl;
}
return 0; }

Large KnapSack
using namespace std;
int dp[2][2000001] = {0};
int main(){
int k, n, v[505], w[505], index, prev;
scanf("%d %d", &k, &n);
for(int i = 1; i <= n; i++){
scanf("%d %d", &v[i], &w[i]);
}
for(int i = 1; i <= n; i++){
index = i % 2;
prev = (i - 1) % 2;
for(int j = 0; j <= k; j++){
if(j >= w[i]){
dp[index][j] = max(dp[prev][j], v[i] + dp[prev][j-w[i]]);
}
else dp[index][j] = dp[prev][j];
}
/* for(int j = 0; j <= k; j++) printf("%d ", dp[0][j]);
printf("\n");
for(int j = 0; j <= k; j++) printf("%d ", dp[1][j]);
printf("\n");
system("pause"); */
}
printf("%d\n", dp[n%2][k]);
return 0;
}

Luggage (Dynamic Programming)

int dp[21][201];
int suits[21];
int total, n;
int knapsack(int suit, int take){
if(dp[suit][take] != -1) return dp[suit][take];

8|Duta Wacana Christi an University Cheat Sheet 2015

//kalau jumlah suit = jumlah semua suit, return selisih antara take dan ignore
(ignore = total - take)
//abs(take - (total - take) = abs(take - total + take) = abs(2*take - total)
if(suit == n - 1) return dp[suit][take] = abs(total - 2*take);
//recursive case
return dp[suit][take] = min(knapsack(suit+1, take+suits[suit]), knapsack(suit+1,
take));
}

Luggage (Cont.)
int main(){
int tc, suit, half, flag;
string input;
cin >> tc;
getline(cin, input);
while(tc--){
memset(dp, -1, sizeof(dp));
total = 0;
n = 0;
getline(cin, input);
istringstream iss(input);
while(iss >> suits[n]){
total += suits[n];
n++;
}
if(total % 2 == 1){
cout << "NO" << endl;
continue;
}
if(knapsack(0,0) == 0) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
}

Luggage (Brute Force)

int bruteforce[1048576];
int main(){
int tc, suit, total, half, size, flag, possibility, part, take;
string input;
cin >> tc;

getline(cin, input);
while(tc--){
vector<int> v;
total = 0;
getline(cin, input);
istringstream iss(input);
while(iss >> suit){
v.push_back(suit);
total += suit;
}
if(total % 2 == 1){
cout << "NO" << endl;
continue;
}
size = v.size();
possibility = pow(2, size);
sort(v.begin(), v.end());
half = total / 2;
// jika koper terberat lebih besar half, langsung "NO"
if(v[size-1] > half){
cout << "NO" << endl;
continue;
}
// jika koper terberat sama dengan half, langsung "YES"
if(v[size-1] == half){
cout << "YES" << endl;
continue;
}
// jika koper terberat lebih kecil half tapi ditambah koper
terkecil jadi
// lebih besar half, langsung "NO"
if(v[size-1] + v[0] > half){
cout << "NO" << endl;
continue;
}
// array tidak hanya di-set menjadi half semua, tapi langsung
mempertimbangkan koper terberat
// setengah depan untuk "jika tidak ambil"
for(int i = 0; i <= possibility/2; i++) bruteforce[i] = half;
// setengah belakang untuk "jika ambil"
half -= v[size-1];
for(int i = possibility/2; i < possibility; i++) bruteforce[i] =
half;
/* untuk lihat isi array setelah ambil koper terberat *
for(int j = 0; j < possibility; j++) cout << bruteforce[j] << " ";
cout << endl;
//*/
part = pow(2, size-2);
flag = 0;

9|Duta Wacana Christi an University Cheat Sheet 2015

for(int i = size-2; i >= 0; i--){

take = 1;
for(int j = 0; j < possibility; j++){
if(take % 2 == 0 && bruteforce[j] >= v[i])
bruteforce[j] -= v[i];
if(bruteforce[j] == 0){
flag = 1;
break;
}
if(j % part == part-1){
take++;
}
}
/* untuk lihat isi array setelah mempertimbangkan koper *
for(int j = 0; j < possibility; j++) cout << bruteforce[j]
<< " ";
cout << endl;
//*/
if(flag == 1) break;
part /= 2;
}
if(flag == 1) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
}

Median (Priority_Queue)
int main(){
int in, size = 0;
priority_queue<int> maxpq;
priority_queue<int, vector<int>, greater<int> > minpq;
scanf("%d", &in);
maxpq.push(in);
size++;
printf("%d\n", in);
while(scanf("%d", &in) == 1){
maxpq.push(in);
size++;
if(size % 2 == 0){
minpq.push(maxpq.top());
maxpq.pop();
}

if(minpq.top() < maxpq.top()){

minpq.push(maxpq.top());
maxpq.pop();
maxpq.push(minpq.top());
minpq.pop();
}
if(size % 2 == 1) printf("%d\n", maxpq.top());
else printf("%d\n", (maxpq.top() + minpq.top()) / 2);
}
}

Potentiometer (Fenwick Tree)

typedef vector<int> vi;
#define LSOne(S) (S & (-S))
class FenwickTree {
private: vi ft;
public:
FenwickTree(int n){ ft.assign(n
int rsq(int b){
int sum = 0;
for(; b; b -= LSOne(b)) sum
return sum;
}
int rsq(int a, int b){
return rsq(b) - (a == 1 ? 0
}
void adjust(int k, int v){
for(; k < (int)ft.size(); k
}
};

+ 1, 0); }
+= ft[b];

: rsq(a - 1));
+= LSOne(k)) ft[k] += v;

int main(){
int N, add, x, y, r, cases = 0;
char command[10];
while(scanf("%d", &N) && (N!=0)){
FenwickTree ft(N);
if(cases != 0) printf("\n");
printf("Case %d:\n", ++cases);
for(int i = 1; i <= N; i++){
scanf("%d", &add);
ft.adjust(i, add);
}
while(scanf("%s", &command) && !((command[0] == 'E') && (command[1] == 'N')
&& (command[2] == 'D'))){

10 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

if(command[0] == 'S'){
cin >> x >> r;
int old = ft.rsq(x, x);
ft.adjust(x, r-old);
}
else if(command[0] == 'M'){
cin >> x >> y;
printf("%d\n", ft.rsq(x, y));
}

map<int, int> name;

v = 0;
for(int i = 0; i < e; i++){
cin >> a >> b;
if(name.find(a) == name.end()) name[a] = v++;
if(name.find(b) == name.end()) name[b] = v++;
AdjList[name[a]].push_back(ii(name[b], 0));
AdjList[name[b]].push_back(ii(name[a], 0));
}
while(cin >> start >> ttl, start||ttl){
//if(start == 0 && ttl == 0) break;
int s = name[start];
queue<int> q;
q.push(s);
map<int, int> dist;
dist[s] = 0;
reach = 1;
while(!q.empty()){
s = q.front();
q.pop();
for(int i = 0; i < (int)AdjList[s].size(); i++){
ii d = AdjList[s][i];
if(dist.find(d.first) == dist.end()){
dist[d.first] = dist[s] + 1;
if(dist[d.first] > ttl){
break;
}
q.push(d.first);
reach++;
}
}
}

}
}
return 0; }

Square (Dynamic Programming)

int memo[10005];
int dp(int n){
if(memo[n] != -1) return memo[n];
if(n <= 0) return 0;
int minimum = 10010;
for(int i = 1; i*i <= n; i++){
minimum = min(minimum, dp(n-i*i)+1);
}
return memo[n] = minimum;
}
int main(){
memset(memo, -1, sizeof (memo));
int tc, n;
scanf("%d", &tc);
while(tc--){
scanf("%d", &n);
printf("%d\n", dp(n));
}
return 0;
}

cout << "Case " << cases++ << ": " << v - reach << " nodes
not reacheable from node "
<< start << " with TTL = " << ttl << ".\n";
}
}
return 0;
}

A Node To Far
Come And Go (Kosaraju)
typedef pair<int, int> ii;
typedef vector<ii> vii;
int main(){
int maxv = 30, e, a, b, v, start, ttl, reach, cases = 1;
vector<vii> AdjList;
while(cin >> e, e){
AdjList.clear();
AdjList.assign(maxv, vii());

typedef
typedef
typedef
#define

pair<int, int> ii;

vector<int> vi;
vector<ii> vii;
DFS_WHITE -1

int i, j, N, M, V, W, P, numSCC;
vector<vii> AdjList, AdjListT;
vi dfs_num, S;

11 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

vector<int> sequence;
while(cin >> in){
if(in == -999999){
maxstreak = -999999;
for(int i = 0; i < sequence.size(); i++){
streak = 1;
for(int j = i; j < sequence.size(); j++){
if(sequence[j] == 0){
streak = 1;
if(maxstreak < 0) maxstreak = 0;
} else {
streak *= sequence[j];
if(streak > maxstreak) maxstreak = streak;
}
}
}
printf("%lld\n", maxstreak);
sequence.clear();
} else {
sequence.push_back(in);
}
}
return 0;

void Kosaraju(int u, int pass){ dfs_num[u] = 1; vii neighbor;

if(pass==1) neighbor = AdjList[u];
else neighbor = AdjListT[u];
for(int j=0;j<(int)neighbor.size();j++){
ii v=neighbor[j];
if(dfs_num[v.first] == DFS_WHITE) Kosaraju(v.first, pass);
} S.push_back(u); }
int main() {
while (scanf("%d %d", &N, &M), (N || M)) {
AdjList.assign(N, vii());
AdjListT.assign(N, vii());
for (i = 0; i < M; i++) {
scanf("%d %d %d", &V, &W, &P);
//agar berubah jadi index, dikurangi 1
V--; W--;
//karena unweighted, semua weight 1
AdjList[V].push_back(ii(W, 1));
AdjListT[W].push_back(ii(V, 1));
if (P == 2) {
AdjList[W].push_back(ii(V, 1));
AdjListT[V].push_back(ii(W, 1));
}
}
//S adalah vector yang berfungsi sebagai stack penampung post order
S.clear(); // first pass
dfs_num.assign(N, DFS_WHITE);
for (i = 0; i < N; i++)
if (dfs_num[i] == DFS_WHITE)
Kosaraju(i, 1);
numSCC = 0; // second pass
dfs_num.assign(N, DFS_WHITE);
//perulangan harus dari belakang agar sesuai reverse post order
for (i = N-1; i >= 0; i--)
if (dfs_num[S[i]] == DFS_WHITE) {
numSCC++;
Kosaraju(S[i], 2);
}
printf("%d\n", numSCC == 1 ? 1 : 0);
}
return 0;
}

Max Subsequence Multiplication

int main(){
long long in, streak, maxstreak;

Min SegmentTree Query

struct Node{
int val;
void split(Node& l, Node& r){}
void merge(Node& a, Node& b){
val = min(a.val, b.val);
}
}tree[1<<(n+1)];
Node range_query(int root, int left_most_leaf, int right_most_left, int u, int v){
if(u<=left_most_leaf && right_most_left<=v){
return tree[root];
}
int mid = (left_most_leaf + right_most_left)/2;
int left_child = root*2;
int right_child = left_child + 1;
tree[root].split(tree[left_child], tree[right_child]);
Node l = identity, r = identity;
if(u < mid) l = range_query(left_child, left_most_leaf, mid, u, v);
if(v > mid) r = range_query(right_child, mid, right_most_left, u, v);
tree[root].merge(tree[left_child], tree[right_child]);
Node n;
n.merge(l,r);
return n;
}
void mergeup(int postn){

12 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

postn >>= 1;
while(postn > 0){
tree[postn].merge(tree[postn*2], tree[postn*2+1]);
postn >>= 1;
}

Node n;
n.segmentSum = n.bestPrefix = n.bestSuffix = n.bestSum = val;
return n;
}

}
void update(int post, Node new_val){
pos += (1 << n);
tree[pos] = new_val;
mergeup(pos);
}

Range Min Segtree

void update_single_node(Node& n, int new_val){
n.val = new_val;
}
void range_update(int root, int left_most_leaf, int right_most_leaf, int u, int v,
int new_val){
if(u <= left_most_leaf && right_most_leaf <= v){
return update_single_node(tree[root], new_val);
}
int mid = (left_most_leaf + right_most_leaf);
int left_child = root * 2;
int right_child = left_child + 1;
tree[root].split(tree[left_child], tree[right_child]);
if(u < mid) range_update(left_child, left_most_leaf, mid, u, v, new_val);
if(v > mid) range_update(right_child, mid, right_most_leaf, u, v, new_val);
tree[root].merge(tree[left_child], tree[right_child]);
}
void update(int pos, int new_val){
return range_update(1, 1<<n, 1<<(n+1), pos+(1<<n), pos+1+(1<<n), new_val);
}

Segment Tree (Contoh BRCKTS)

//range_query, update and range_update remain same
struct Node{
int min, add;
split(const Node& a,const Node& b){
a.add += add, a.min += add;
b.add += add, b.min += add;
add = 0;
}
void merge(Node a, Node b){
min = min(a.min, b.min);
add = 0;
}
};
void update_single_node(Node& n, int add){
n.add += add;
n.min += add;
}

Orderset
Segment Tree (Contoh GSS3)
//range_query and update function remain same as that for last problem
struct Node{
int segmentSum, bestPrefix, bestSuffix, bestSum;
Node split(Node& l, Node& r){}
Node merge(Node& l, Node& r){
segmentSum = l.segmentSum + r.segmentSum;
bestPrefix = max(l.segmentSum + r.bestPrefix, l.bestPrefix);
bestSuffix = max(r.segmentSum + l.bestSuffix, r.bestSuffix);
bestSum
= max(max(l.bestSum, r.bestSum), l.bestSuffix + r.bestPrefix);
}
};
Node createLeaf(int val){

struct Node{
int num_active_leaves;
void split(Node& l, Node& r){}
void merge(Node& l, Node& r){
num_active_leaves = l.num_active_leaves + r.num_active_leaves;
}
bool operator < (const Node& n) const{
return num_active_leaves < n.num_active_leaves;
}
};
int binary_search(Node k){
int root = l;
Node n = identity;
assert(!(k<identity));
while(!isleaf(root)){

13 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

int left_child = root << 1, right_child = left_child;

tree[root].split(tree[left_child], tree[right_child]);
Node m;
m.merge(n, tree[left_child]);
if(m < k){
n = m;
root = right_child;
}
else root = left_child;
}
Node m;
m.merge(n, tree[root]);
mergeup(root);
if(m < k) return root - leftmost_leaf;
else return root - 1 - leftmost_leaf; }

General Merge Up
void splitdown(int postn){
if(postn > 1) splitdown(postn >> 1);
tree[postn].split(tree[2 * postn], tree[2 * postn + 1]);
}
void update(int postn, Node nd){
postn += 1 << n;
splitdown(postn >> 1);
tree[postn] = nd;
mergeup(postn);
}

Segment Tree (Horrible)

struct Node{
ll sum, leaves, lazy;
void split(Node& left, Node& right){
left.lazy += lazy; left.sum += lazy;
right.lazy += lazy; right.sum += lazy;
lazy = 0;
}
void merge(Node& left, Node& right){
leaves = left.leaves + right.leaves;
lazy = 0;
sum = left.sum + right.sum;
}
}tree[44444], dummy;
left(root) -> root << 1
right(root) ->root << 1 + 1
Node build(ll root, ll L, ll R){
if(L > R) return dummy;
if(L == R){
tree[root].sum = 0;

tree[root].lazy = 0;
tree[root].leaves = 1;
return tree[root];
}
Node l = build(left(root), L, (L+R)/2);
Node r = build(right(root), (L+R)/2+1, R);
tree[root].merge(l, r);
return tree[root];
}
void update_single_subtree(Node& n, ll inc){
n.lazy += inc;
n.sum += inc * n.leaves;
}
void update(ll root, ll L, ll R, ll i, ll j, ll val){
if(L > j || R < i){
return;
}
if(L >= i && R <= j){
return update_single_subtree(tree[root], val);
}
tree[root].split(tree[left(root)], tree[right(root)]);
update(left(root), L, (L+R)/2, i, j, val);
update(right(root), (L+R)/2+1, R, i, j, val);
tree[root].merge(tree[left(root)], tree[right(root)]);
}
Node query(int root, int L, int R, int i, int j){
if(L > R || L > j || R < i) return dummy;
if(L >= i && R <= j){
return tree[root];
}
tree[root].split(tree[left(root)], tree[right(root)]);
Node l = dummy, r = dummy;
l = query(left(root), L, (L+R)/2, i, j);
r = query(right(root), (L+R)/2+1, R, i, j);
tree[root].merge(tree[left(root)], tree[right(root)]);
Node res;
res.merge(l,r);
return res;
}
int main(){
dummy.sum = dummy.lazy = dummy.leaves = 0;
ll tc;
ll n, c, cmd, p, q, v;
cin >> tc;
while(tc--){
cin >> n >> c;
build(1, 0, n-1);
REP(i, c){
cin >> cmd;
if(cmd == 1){
cin >> p >> q;
cout << query(1, 0, n-1, --p, --q).sum << endl;

14 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

}
else{
cin >> p >> q >> v;
update(1, 0, n-1, --p, --q, v);
}

int cost, subj;

string input;
getline(cin, input);
if(input.size() == 0) getline(cin, input);
istringstream is; is.str(input);
is >> cost;
totalCost += cost;
while(is >> subj){
subMask |= (1 << (subj-1));
}
slot2 |= (slot1 & subMask);
slot1 |= subMask;

}
}
}

}
for(int i=0; i<n; i++){
int cost, subj;
string input;
getline(cin, input);
if(input.size() == 0) getline(cin, input);
istringstream is; is.str(input);
is >> cost; teacherCost[i] = cost;

DP Bitmask
int
int
int
int
int

s, n, m;
dp[110][110][8];
teacherCost[110];
teacherMask[110];
go(int slot1, int slot2, int i){
if(slot1 == (i << s) -1 && slot2 == (i << s) - 1){
return 0;
}
else if(i >= n){
return 1000000000;
}
else if(dp[slot1][slot2][i] != -1){
return dp[slot1][slot2][i];
}
else{
return dp[slot1][slot2][i] = min(go(slot1, slot2, i+1), teacherCost[i] +
go(slot1 | teacherMask[i], slot2 | (slot1 & teacherMask[i]), i+1));
}
}
int main(){
while(cin >> s >> m >> n){
if(!s) break;
for(int i=0; i<(1 << s); i++){
for(int j=0; j<(1 << s); j++){
for(int k=0; k<n; k++){
dp[i][j][k] = -1;
}
}
}
int slot1 = 0, slot2 = 0;
int subMask = 0;
int totalCost = 0;
for(int i=0; i<m; i++){

while(is >> subj){

teacherMask[i] |= (1 << (subj - 1));
}
}
totalCost += go(slot1, slot2, 0);
cout << totalCost << endl;
}
return 0;
}

Sieve Of Erastothenes
int main()
{
bool is_prime;
uInt count = 1;
uInt my_prime = 2; //set to first prime
for(uInt i = 3; count < 10001; i += 2) { //skip ALL even numbers, find
10001st prime
is_prime = true;
for(uInt j = 3; j * j <= i && is_prime; j += 2) //again, skipping
all even numbers
if(i % j == 0) is_prime = false;

15 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

if(is_prime) {
++count;
my_prime = i;
}

printf("Case %d: %s\n", ++tc, printmul(0, N-1).c_str());

}
return 0;
}

}
cout << my_prime;
//cin.get();
}

Chained Matrix Multiplication

using namespace std;
#define MAX 10
int a[MAX], b[MAX];
int memo[MAX][MAX];
int parent[MAX][MAX];
int mul(int x, int y){
if(memo[x][y] || x == y) return memo[x][y];
int min = 0xFFFFFFF;
for(int i = x; i < y; i++){
int m = a[x] * b[i] * b[y] + mul(x, i) + mul(i+1, y);
if(m < min) min = m, parent[x][y] = i;
}
return memo[x][y] = min;
}
string printmul(int x, int y){
char mat[2];
if(x == y) return sprintf(mat, "A%d", x+1), mat;
return "(" + printmul(x, parent[x][y]) + " x " + printmul(parent[x][y]+1, y) +
")";
}
int main(){
int tc = 0, N;
while(scanf("%d", &N) && N){
memset(memo, 0, sizeof memo);
for(int i = 0; i< N; i++){
scanf("%d %d", &a[i], &b[i]);
}
mul(0, N-1);

Floyd Warshall
#include<stdio.h>
// Number of vertices in the graph
#define V 4
/* Define Infinite as a large enough value. This value will be used
for vertices not connected to each other */
#define INF 99999
// A function to print the solution matrix
void printSolution(int dist[][V]);
// Solves the all-pairs shortest path problem using Floyd Warshall algorithm
void floydWarshell (int graph[][V])
{
/* dist[][] will be the output matrix that will finally have the shortest
distances between every pair of vertices */
int dist[V][V], i, j, k;
/* Initialize the solution matrix same as input graph matrix. Or
we can say the initial values of shortest distances are based
on shortest paths considering no intermediate vertex. */
for (i = 0; i < V; i++)
for (j = 0; j < V; j++)
dist[i][j] = graph[i][j];
/* Add all vertices one by one to the set of intermediate vertices.
---> Before start of a iteration, we have shortest distances between all
pairs of vertices such that the shortest distances consider only the
vertices in set {0, 1, 2, .. k-1} as intermediate vertices.
----> After the end of a iteration, vertex no. k is added to the set of
intermediate vertices and the set becomes {0, 1, 2, .. k} */
for (k = 0; k < V; k++)
{
// Pick all vertices as source one by one
for (i = 0; i < V; i++)

16 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

{
// Pick all vertices as destination for the
// above picked source
for (j = 0; j < V; j++)
{
// If vertex k is on the shortest path from
// i to j, then update the value of dist[i][j]
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
}

// Print the solution

floydWarshell(graph);
return 0;
}

}
}
// Print the shortest distance matrix
printSolution(dist);
}
/* A utility function to print solution */
void printSolution(int dist[][V])
{
printf ("Following matrix shows the shortest distances"
" between every pair of vertices \n");
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
{
if (dist[i][j] == INF)
printf("%7s", "INF");
else
printf ("%7d", dist[i][j]);
}
printf("\n");
}
}
// driver program to test above function
int main()
{
/* Let us create the following weighted graph
10
(0)------->(3)
|
/|\
5 |
|
|
| 1
\|/
|
(1)------->(2)
3
*/
int graph[V][V] = { {0,
5, INF, 10},
{INF, 0,
3, INF},
{INF, INF, 0,
1},
{INF, INF, INF, 0}
};

Java Big Integer

import java.math.BigInteger;
import java.util.Scanner;
publicclass JavaBigInteger {
publicstaticvoid main(String args[])
{
Scanner sc = new Scanner(System.in);
BigInteger V = sc.nextBigInteger();
BigInteger sum = BigInteger.ZERO;
sum = sum.add(V);
int b = sc.nextInt(); // bigInteger base of b
BigInteger p = new BigInteger(sc.next(), b);
BigInteger m = new BigInteger(sc.next(), b);
p.mod(m).toString(b);
// konversi int > BI
BigInteger bI = BigInteger.valueOf(b);
bI.isProbablePrime(10); // 10 is certainty
p.gcd(m); //gcd of p and m
// modulo arithmatic x ^ y mod n
BigInteger x = BigInteger.valueOf(sc.nextInt());
BigInteger y = BigInteger.valueOf(sc.nextInt());
BigInteger n = BigInteger.valueOf(sc.nextInt());
x.modPow(y, n);
}
}

17 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

vi primeFactors(ll N)
{
vi factors;
ll PF_idx = 0, PF = primes[PF_idx];
while(PF*PF <= N)
{
while(N%PF == 0) {N /= PF; factors.push_back(PF);}
PF = primes[++PF_idx];
}
if(N!=1) factors.push_back(N);
return factors;
}

Sieve : Generate Prime

#include<bitset>
ll _sieve_size;
bitset<10000010> bs;
vi primes;
void sieve(ll upperbound)
{
_sieve_size = upperbound + 1;
bs.set();
bs[0] = bs[1] = 0;
for(ll i = 2; i <= _sieve_size; i++)
if(bs[i]){
for(ll j = i*i; j <= _sieve_size; j += i) bs[j] = 0;
primes.push_back((int)i);
}
}
bool isPrime(ll N)
{
if(N <= _sieve_size) return bs[N];
for(int i=0; i<(int) primes.size(); i++)
if(N % primes[i] == 0) returnfalse;
returntrue;
}

Prime Factor

Count Number Divisors

vi numDiv(ll N)
{
ll PF_idx = 0, PF = primes[PF_idx], ans = 1;
while(PF*PF <= N)
{
ll power = 0;
while(N%PF == 0) {N /= PF; power++;}
ans *= (power+1);
PF = primes[++PF_idx];
}
if(N!=1) ans *= 2;
returnans;
}

Sum Divisors
vi numDiv(ll N)
{
ll PF_idx = 0, PF = primes[PF_idx], ans = 1;
while(PF*PF <= N)
{
ll power = 0;
while(N%PF == 0) {N /= PF; power++;}
ans *= ((ll)pow((double)PF, power+1.0)-1)/(PF-1);
PF = primes[++PF_idx];
}
if(N!=1) ans *= ((ll)pow((double)PF, 2.0)-1)/(N-1);
returnans;

18 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

Catalan Number
Cat(n) = (2n C n) / (n+1)
Cat(0) = 1
Cat(n+1) = (2n+2)(2n+1)/(n+2)(n+1) x Cat(n)
Ex: n = 3, Cat(3) = 5
distinct binary tress vertices of 3
/br/, /br\, /\, \br/, \br\

19 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

Euler Phi
ll EulerPhi(ll N)
{
ll PF_idx = 0, PF = primes[PF_idx], ans = N;
while(PF*PF <= N)
{
if (N % PF == 0) ans -= ans / PF;
while(N%PF == 0) N /= PF;
PF = primes[++PF_idx];
}
if(N!=1) ans -= ans / N;
return factors;
}
// find different x, x < N, x is relatively prime with N
// 36 = 3^2 * 2^2
// there is 36 * (1-1/2) (1-1/3) = 12 different x
// {1, 3, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35}
// if N is prime , { 1 ... N-1 } is relatively prime

{
long x1,y1;
long g;

/* previous coefficients */
/* value of gcd(p,q) */

if (q > p) return(gcd(q,p,y,x));
if (q == 0) {
*x = 1;
*y = 0;
return(p);
}
g = gcd(q, p%q, &x1, &y1);
*x = y1;
*y = (x1 - floor(p/q)*y1);
return(g);
}

Extended Euler Phi

UVA 10036 Divisibility

for(int i = 1; i <= 1000000; i++) EulerPhi[i] = i;

for(int i = 2; i <= 1000000; i++)
if(EulerPhi[i] == i) // i is prime
for(int j = i; j <= 1000000; j += i)
EulerPhi[j] = EulerPhi[j]/i * (i-1);

#include <stdio.h>
#include <cmath>
int n, k;
int in[10010];
int memo[110][10010];
int max(int a,int b){return (b>a) ? b:a;}

EXTENDED EULCID FOR ax + by = c

int x0, y0, d;
void extendedEuclid(int a, int b)
{
if ( b==0 ) { x = 1; y = 0; d = a; return; }
extendedEuclid(b, a%b);
int x1 = y;
int y1 = x - (a/b) * y;
x0 = x1;
y0 = y1;
}
// ax + by = c, use d = gcd(a,b) | c to proof the validity
// (x0, y0) found by extendedEuclid
// x = x0 + (b/d) n, y = y0 + (a/d) n
// thus, find n that completes the ax + by = c
GCD
int gcd(int a, int b){ return b == 0 ? a: gcd(b,a%b); }
int lcm(int a, int b){ return a * (b / gcd(a,b)); }
// Find the gcd(p,q) and x,y such that p*x + q*y = gcd(p,q)
long gcd(long p, long q, long *x, long *y)

int mod(int x,int y){return ((x%y)+y)%y;}

int dp(int num,int i)
{
if(i==n)
{
if(mod(num,k)==0)
return 1;
else
return 0;
}
if(memo[mod(num,k)][i] != -1)
return memo[mod(num,k)][i];
return memo[mod(num,k)][i] =
max(dp(num-in[i],i+1),
dp(num+in[i],i+1)
);
}
int main()

20 | D u t a W a c a n a C h r i s t i a n U n i v e r s i t y C h e a t S h e e t 2 0 1 5

{
int tc;
scanf("%d",&tc);
while(tc--)
{
scanf("%d %d",&n,&k);
for(int i=0;i<n;i++)
{
scanf("%d",&in[i]);
if(in[i]%k == 0)
{
i--;
n--;
}
}
for(int i=0;i<110;i++)
for(int j=0;j<10010;j++)
memo[i][j]=-1;
int res = dp(0,0);
if(res!=0)
printf("Divisible\n");
else
printf("Not divisible\n");
}
return 0;
}
Exponentiation - The Russian Peasant Algorithm
When computing a power of a number with a finite modulus there are efficient ways to
do it and inefficient ways to do it. In this section we will outline a commonly used
efficient method which has the curious name "the Russian Peasant algorithm".
The most obvious way to compute 1210 (mod 23) is to multiply 12 a total of nine
times, reducing the result mod 23 at each step. A more efficient method which takes
only four multiplications is accomplished by first noting that:
122=6 (mod 23)
124=62=13 (mod 23)
128=132=8 (mod 23)
We have now performed three squarings and, by noting that the exponent breaks into
powers of 2 as 10=8+2, we can rewrite our computation:
1210=12(8+2)
=128*122
=8*6=2(mod 23)
So our algorithm consists of writing the exponent as powers of two. (This can be
done by writing it as a number base 2 and reading off successive digits - eg
1010=10102.) Now we multiply successive squares of the base number for each digit of
the exponent which is a "1".
The following short program will allow you to compute examples of the Russian
Peasant method for exponentiation:

2 ^ 53 mod 123 = 74
binary
1
0
1
0
1
1

power=2
2
4
16
10
100
37

x=1
2
2
32
32
2
74

// power = power ^ 2 mod 123

// if 0 keep x, if 1 x = x * power mod 123

The (slightly cryptic) output of this program can be read as:

1. The base two digits of the exponent
2. The successive squarings of the base (ie b2, b4, b8, ...)
3. The product of the appropriate squares

Fibonacci Number
fib(n) = ( o^n (-o)^-n ) / sqrt(5);
// o = (1+sqrt(5)/2)
// test n first, some n may results incorrectly

Floyd Cycle Finding Algorithm

THEORY
f(x) = ( Z.x+I)%M with x0 = L
ex: Z = 7, I = 5, M = 12, L = 4
so: f(x) = ( 7x+5)%12, x0 = 4
{ 4, 9, 8, 1, 0, 5, 4, 9, 8, 1, 0, 5, }
cycle length = 6
start of cycle = 0
// function int f(x) is defined earlier
ii floydCycleFinding(int x0){
// 1st part: find k * mu, hares speed 2x tortoises
int tortoise = f(x0), hare = f(f(x0)); // f(x0) node next to x0
while(tortoise != hare) { tortoise = f(tortoise); hare = f(f(hare)); }
// 2nd part: finding mu, hare and tortoise move at the same speed
int mu = 0; hare = x0;
while(tortoise != hare){
tortoise = f(tortoise); hare = f(hare); mu++; }
// 3rd part: finding lambda, hare moves, tortoise stays
int lamba = 1; hare = f(tortoise);
while(tortoise != hare) { hare = f(hare); lamba++; }
return ii(mu, lamba);
}