CheatSheet Ukdw PedWay

1 | 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

Duta Wacana Christian University

Cheat Sheet 2015

Icpc Asia Regional – Jakarta

PedWaY

Yosia – Wawan – Pedro

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

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

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

Luggage (Dynamic Programming) ................................................................... 7

Luggage (Brute Force) ..................................................................................... 8

Median (Priority_Queue) ................................................................................ 9

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

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

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

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


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


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){


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;

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); }

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; } } }

-----------------------------------------------------------------------------------

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]; 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

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));}


Library & Others #include <vector> #include <list> #include <map> #include <set> #include <queue> #include <deque> #include <stack> #include <bitset> #include <algorithm> #include <functional> #include <numeric> #include <utility> #include <sstream> #include <iostream> #include <iomanip> #include <cstdio> #include <cmath> #include <cstdlib> #include <ctime> #include <cstring> #include <string> #define REP(X, Y) for (int (X) = 0; (X) < (Y); ++(X)) #define FOR(X, Y, Z) for (int (X) = (Y); (X) <= (Z); ++(X)) #define RESET(C, V) memset(C, V, sizeof(C)) #define isOn(S, j) (S & (1 << j)) #define setBit(S, j) (S |= (1 << j)) #define clearBit(S, j) (S &= ~(1 << j)) #define toggleBit(S, j) (S ^= (1 << j)) #define lowBit(S) (S & (-S)) #define 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;

typedef vector<ii> vii;

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)){


if(s.size() == 0) break; height.push_back(atoi(s.c_str())); } //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; }

} while(!urutan.empty()){ printf("%d\n", urutan.top()); urutan.pop(); } } // 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].first-v[j].first)*(v[i].first-v[j].first) + (v[i].second-v[j].second)*(v[i].second-v[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];


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];


//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;


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 + 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; } }; 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'))){


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)); } } } 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; }

A Node To Far 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());

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

Come And Go (Kosaraju) typedef pair<int, int> ii; typedef vector<int> vi; typedef vector<ii> vii; #define DFS_WHITE -1 int i, j, N, M, V, W, P, numSCC; vector<vii> AdjList, AdjListT; vi dfs_num, S;


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;

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; }

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){


postn >>= 1; while(postn > 0){ tree[postn].merge(tree[postn*2], tree[postn*2+1]); postn >>= 1; } } 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 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){

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

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 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)){


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;


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

DP Bitmask

int s, n, m; int dp[110][110][8]; int teacherCost[110]; int teacherMask[110]; int 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++){

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; 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;


if(is_prime) { ++count; my_prime = i; } } 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);

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

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++)


{ // 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 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} };

// Print the solution floydWarshell(graph); return 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); } }


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

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; }

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;


}

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\


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

Extended Euler Phi 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);

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)

{ long x1,y1; /* previous coefficients */ long g; /* 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); }

UVA 10036 – Divisibility #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;} 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()


{ 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 power=2 x=1 1 2 2 // power = power ^ 2 mod 123 0 4 2 // if 0 keep x, if 1 x = x * power mod 123 1 16 32 0 10 32 1 100 2 1 37 74 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, hare’s speed 2x tortoise’s 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);

}

CheatSheet Ukdw PedWay

Documents