├── Graphs 2 ├── a.out ├── kruskalsAlgorithm.cpp ├── dijkstrasAlgorithm.cpp └── primsAlgorithm.cpp ├── Test 1 ├── a.out ├── nearVsMello.cpp ├── fredoAndTask.cpp ├── increasingNumbers.cpp ├── groupSum.cpp └── palindromeSubstrings.cpp ├── Test 2 ├── a.out ├── tetrahedron.cpp ├── superNumber.cpp ├── fishmonger.cpp └── freeDays.cpp ├── Fenwick Tree ├── a.out ├── helper.cpp ├── coderRatingProblem.cpp ├── distinctQueryProblem.cpp ├── output.txt ├── myOutput.txt ├── orderSet.cpp └── input.txt ├── Game Theory ├── a.out ├── calculateGrundyNumber.cpp └── optimalMoveInTicTacToe.cpp ├── Segment Tree ├── a.out ├── vasyaVsRehso.cpp ├── 2Vs3.cpp ├── maximumSumInSubarray.cpp ├── horribleQuery.cpp └── sumOfSquares.cpp ├── Advanced Graphs ├── a.out ├── newYearTransportation.cpp ├── monkAndTheIslands.cpp ├── kingdomOfMonkeys.cpp ├── dominos.cpp ├── permutationSwaps.cpp ├── connectedHorses.cpp ├── capitalCity.cpp └── spaceSmugglers.cpp ├── Greedy Techniques ├── a.out ├── minAbsoluteDifferenceInArray.cpp ├── nikunjAndDonuts.cpp ├── himaniAndStocks.cpp ├── activitySelection.cpp ├── fractionalKnapsack.cpp ├── weightedJobScheduling.cpp └── karanAtThePG.cpp ├── Computational Geometry ├── a.out ├── convexHull.cpp ├── surveyor.cpp ├── warehouse.cpp └── areaOfConvexPolygon.cpp ├── Dynamic Programming 1 ├── a.out ├── royAndCoinBoxes.cpp ├── angryChildren.cpp ├── numberOfRs.cpp ├── vanyaAndGCD.cpp ├── adjacentBitCounts.cpp ├── alyonaAndSpreadsheet.cpp └── jonSnowAndHisFavoriteNumber.cpp ├── Dynamic Programming 2 ├── a.out ├── test.cpp ├── distinctSubsequences.cpp ├── starSky.cpp ├── sumOfDigits.cpp ├── pussycatSonya.cpp ├── miserMan.cpp ├── charlieAndPilots.cpp ├── traderProfit.cpp ├── balikaVadhu.cpp └── squareBrackets.cpp └── Dynamic Programming 3 ├── a.out ├── dilemma.cpp ├── candy.cpp ├── ghostType.cpp └── mehtaAndBankRobbery.cpp /Graphs 2/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Graphs 2/a.out -------------------------------------------------------------------------------- /Test 1/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Test 1/a.out -------------------------------------------------------------------------------- /Test 2/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Test 2/a.out -------------------------------------------------------------------------------- /Fenwick Tree/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Fenwick Tree/a.out -------------------------------------------------------------------------------- /Game Theory/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Game Theory/a.out -------------------------------------------------------------------------------- /Segment Tree/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Segment Tree/a.out -------------------------------------------------------------------------------- /Advanced Graphs/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Advanced Graphs/a.out -------------------------------------------------------------------------------- /Greedy Techniques/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Greedy Techniques/a.out -------------------------------------------------------------------------------- /Computational Geometry/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Computational Geometry/a.out -------------------------------------------------------------------------------- /Dynamic Programming 1/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Dynamic Programming 1/a.out -------------------------------------------------------------------------------- /Dynamic Programming 2/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Dynamic Programming 2/a.out -------------------------------------------------------------------------------- /Dynamic Programming 3/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LavishGulati/Competitive-Programming-CodingNinjas/HEAD/Dynamic Programming 3/a.out -------------------------------------------------------------------------------- /Dynamic Programming 2/test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define pb push_back 5 | 6 | int main(){ 7 | $ 8 | } 9 | -------------------------------------------------------------------------------- /Fenwick Tree/helper.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | cout << 20000 << endl; 6 | for(int i = 1; i <= 20000; i++){ 7 | cout << "I " << i << endl; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /Greedy Techniques/minAbsoluteDifferenceInArray.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int minAbsoluteDiff(int *arr, int n) { 4 | std::sort(arr, arr+n); 5 | 6 | int min = INT_MAX; 7 | 8 | for(int i = 0; i < n; i++){ 9 | int element = arr[i+1] > arr[i] ? arr[i+1]-arr[i] : arr[i]-arr[i+1]; 10 | 11 | if(min > element) min = element; 12 | } 13 | 14 | return min; 15 | } 16 | -------------------------------------------------------------------------------- /Test 1/nearVsMello.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | int n; 6 | cin >> n; 7 | 8 | int *h = new int[n]; 9 | for(int i = 0; i < n; i++) cin >> h[i]; 10 | 11 | sort(h, h+n); 12 | int total = 0; 13 | for(int i = 0; i < n-2; i++){ 14 | total += h[n-2]-h[i]; 15 | } 16 | 17 | cout << total << endl; 18 | } 19 | -------------------------------------------------------------------------------- /Game Theory/calculateGrundyNumber.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int grundy(int n){ 5 | if(n == 0) return 0; 6 | 7 | int a = grundy(n/2); 8 | int b = grundy(n/3); 9 | int c = grundy(n/6); 10 | 11 | for(int i = 0; ; i++){ 12 | if(i != a && i != b && i != c) return i; 13 | } 14 | } 15 | 16 | int main(){ 17 | int n; 18 | cin >> n; 19 | cout << grundy(n) << endl; 20 | } 21 | -------------------------------------------------------------------------------- /Greedy Techniques/nikunjAndDonuts.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int main(){ 6 | ll n; 7 | cin >> n; 8 | ll *calorie = new ll[n]; 9 | for(ll i = 0; i < n; i++) cin >> calorie[i]; 10 | 11 | sort(calorie, calorie+n); 12 | 13 | ll multiplier = 1; 14 | ll distance = 0; 15 | for(ll i = n-1; i >= 0; i--){ 16 | distance += multiplier*calorie[i]; 17 | multiplier *= 2; 18 | } 19 | 20 | cout << distance << endl; 21 | } 22 | -------------------------------------------------------------------------------- /Test 2/tetrahedron.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define MOD 1000000007 5 | 6 | long long solve(int n){ 7 | if(n == 1) return 0; 8 | 9 | ll *power = new ll[n]; 10 | power[0] = 1; 11 | for(ll i = 1; i < n; i++) power[i] = (3*power[i-1])%MOD; 12 | 13 | ll answer = power[n-1]; 14 | bool add = false; 15 | for(ll i = n-2; i >= 1; i--){ 16 | if(add) answer = (answer+power[i])%MOD; 17 | else answer = (answer-power[i])%MOD; 18 | 19 | add = !add; 20 | } 21 | 22 | return (answer+MOD)%MOD; 23 | } 24 | 25 | int main() 26 | { 27 | int n; 28 | cin>>n; 29 | cout< 2 | using namespace std; 3 | typedef long long ll; 4 | #define MOD 4294967296 5 | 6 | int main(){ 7 | ll n, M, a, b; 8 | cin >> n >> M >> a >> b; 9 | 10 | ll *profit = new ll[n+1]; 11 | ll x = 0; 12 | profit[0] = 0; 13 | 14 | for(ll i = 1; i <= n; i++){ 15 | x = ((x%M)*a+b)%MOD; 16 | profit[i] = x>>8; 17 | } 18 | 19 | ll maxProfit = 0-profit[1]; 20 | for(ll i = 2; i <= n; i++){ 21 | if(profit[i] < profit[i-1]){ 22 | maxProfit = maxProfit+profit[i-1]-profit[i]; 23 | } 24 | } 25 | 26 | maxProfit += profit[n]; 27 | cout << maxProfit << endl; 28 | } 29 | -------------------------------------------------------------------------------- /Test 1/fredoAndTask.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define MAX 10000000000 5 | 6 | int main(){ 7 | ll n; 8 | cin >> n; 9 | 10 | double total = 0; 11 | ll x; 12 | for(ll i = 0; i < n; i++){ 13 | cin >> x; 14 | total += log(x); 15 | } 16 | 17 | ll start = 1; 18 | ll end = MAX; 19 | ll answer, mid; 20 | while(start <= end){ 21 | mid = (start+end)/2; 22 | 23 | if(n*log(mid) > total){ 24 | end = mid-1; 25 | answer = mid; 26 | } 27 | else{ 28 | start = mid+1; 29 | } 30 | } 31 | 32 | cout << answer << endl; 33 | } 34 | -------------------------------------------------------------------------------- /Advanced Graphs/newYearTransportation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | int n, t; 6 | cin >> n >> t; 7 | 8 | // int **graph = new int*[n]; 9 | // for(int i = 0; i < n; i++){ 10 | // graph[i] = new int[n]; 11 | // for(int j = 0; j < n; j++) graph[i][j] = 0; 12 | // } 13 | 14 | int position = 0; 15 | 16 | for(int i = 0; i < n-1; i++){ 17 | if(position == t-1){ 18 | cout << "YES" << endl; 19 | return 0; 20 | } 21 | int a; 22 | cin >> a; 23 | // graph[i][i+a] = 1; 24 | if(i == position) position += a; 25 | } 26 | 27 | cout << "NO" << endl; 28 | } 29 | -------------------------------------------------------------------------------- /Dynamic Programming 2/distinctSubsequences.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MOD 1000000007 4 | 5 | int main(){ 6 | int t; 7 | cin >> t; 8 | while(t--){ 9 | string s; 10 | cin >> s; 11 | int n = s.length(); 12 | 13 | int *occurence = new int[256]; 14 | for(int i = 0; i < 256; i++) occurence[i] = -1; 15 | 16 | int *dp = new int[n+1]; 17 | dp[0] = 1; 18 | for(int i = 1; i <= n; i++){ 19 | dp[i] = (2*dp[i-1])%MOD; 20 | if(occurence[s[i-1]] != -1){ 21 | dp[i] = (dp[i]-dp[occurence[s[i-1]]]+MOD)%MOD; 22 | } 23 | occurence[s[i-1]] = i-1; 24 | } 25 | 26 | cout << dp[n] << endl; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Test 1/increasingNumbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void printIncreasingNumbers(int n, string s){ 5 | if(n <= 0){ 6 | cout << s << " "; 7 | return; 8 | } 9 | 10 | if(s.length() == 0){ 11 | for(int i = 1; i <= 9; i++){ 12 | char x = '0'+i; 13 | printIncreasingNumbers(n-1, s+x); 14 | } 15 | } 16 | else{ 17 | for(int i = s[s.length()-1]-'0'+1; i <= 9; i++){ 18 | char x = '0'+i; 19 | printIncreasingNumbers(n-1, s+x); 20 | } 21 | } 22 | } 23 | 24 | void printIncreasingNumbers(int n) { 25 | printIncreasingNumbers(n, ""); 26 | cout << endl; 27 | } 28 | 29 | int main() 30 | { 31 | int n; 32 | cin>>n; 33 | printIncreasingNumbers(n); 34 | } 35 | -------------------------------------------------------------------------------- /Dynamic Programming 3/dilemma.cpp: -------------------------------------------------------------------------------- 1 | int dp[105][1<<12]; 2 | 3 | int findTouches(int pos, int mask, vector &v){ 4 | if(!(mask&(mask-1)) && mask) return 0; 5 | 6 | if(pos == -1 || mask == 0) return 100000; 7 | 8 | if(dp[pos][mask]) return dp[pos][mask]; 9 | 10 | int newMask1 = 0, newMask2 = 0, touches = 0; 11 | for(int i = 0; i < v.size(); i++){ 12 | if((mask>>i)&1){ 13 | touches++; 14 | if(v[i][pos] == '0') newMask1 |= (1< v){ 23 | return findTouches(v[0].size()-1, (1< 2 | using namespace std; 3 | typedef pair pii; 4 | 5 | bool compare(pii a, pii b){ 6 | return a.first < b.first; 7 | } 8 | 9 | int main(){ 10 | int n, total, finishTime, i; 11 | cin >> n; 12 | 13 | pair *activityTime = new pair[n]; 14 | for(i = 0; i < n; i++){ 15 | cin >> activityTime[i].second; 16 | cin >> activityTime[i].first; 17 | } 18 | 19 | sort(activityTime, activityTime+n, compare); 20 | 21 | total = 1; 22 | finishTime = activityTime[0].first; 23 | for(i = 1; i < n; i++){ 24 | if(activityTime[i].second >= finishTime){ 25 | total++; 26 | finishTime = activityTime[i].first; 27 | } 28 | } 29 | 30 | cout << total << endl; 31 | } 32 | -------------------------------------------------------------------------------- /Dynamic Programming 3/candy.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAXN 16 4 | 5 | typedef long long ll; 6 | 7 | long long solve(int like[][MAXN],int n){ 8 | ll *dp = new ll[(1<= 0; mask--){ 12 | ll temp = mask; 13 | ll person = 0; 14 | while(temp > 0){ 15 | person += temp&1; 16 | temp /= 2; 17 | } 18 | 19 | for(ll i = 0; i < n; i++){ 20 | if(like[person][i] && !(mask&(1<>n; 33 | for(int i = 0; i < n ; i++){ 34 | for(int j = 0; j < n; j++){ 35 | cin>>like[i][j]; 36 | } 37 | } 38 | cout< 2 | using namespace std; 3 | 4 | class point{ 5 | public: 6 | int x, y; 7 | 8 | point(){ 9 | 10 | } 11 | 12 | point(int x, int y){ 13 | this->x = x; 14 | this->y = y; 15 | } 16 | }; 17 | 18 | int main(){ 19 | int n, q, c; 20 | cin >> n >> q >> c; 21 | 22 | point *star = new point[n]; 23 | int *brightness = new int[n]; 24 | for(int i = 0; i < n; i++){ 25 | cin >> star[i].x >> star[i].y >> brightness[i]; 26 | } 27 | 28 | while(q--){ 29 | int t, x1, y1, x2, y2; 30 | cin >> t >> x1 >> y1 >> x2 >> y2; 31 | 32 | int total = 0; 33 | for(int i = 0; i < n; i++){ 34 | if(star[i].x >= min(x1, x2) && star[i].x <= max(x1, x2) && star[i].y >= min(y1, y2) && star[i].y <= max(y1, y2)){ 35 | total += (brightness[i]+t)%(c+1); 36 | } 37 | } 38 | 39 | cout << total << endl; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /Test 1/groupSum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool subsetSumToKIdentical(int input[], int n, int k, int id){ 5 | if(k < 0) return false; 6 | if(k == 0) return true; 7 | if(id == n) return false; 8 | 9 | int i = id; 10 | while(input[i+1] == input[i]) i++; 11 | if(subsetSumToKIdentical(input, n, k, i+1)) return true; 12 | 13 | int total = input[i]; 14 | i = id; 15 | while(input[i+1] == input[i]){ 16 | i++; 17 | total += input[i]; 18 | } 19 | if(subsetSumToKIdentical(input, n, k-total, i+1)) return true; 20 | 21 | return false; 22 | } 23 | 24 | bool subsetSumToKIdentical(int input[], int n, int k){ 25 | return subsetSumToKIdentical(input, n, k, 0); 26 | } 27 | 28 | int main() 29 | { 30 | int n; 31 | cin>>n; 32 | int arr[1000]; 33 | for(int i = 0;i < n;i++) 34 | cin>>arr[i]; 35 | int k; 36 | cin>>k; 37 | if(subsetSumToKIdentical(arr,n,k)) 38 | cout<<"true"; 39 | else cout<<"false"; 40 | } 41 | -------------------------------------------------------------------------------- /Dynamic Programming 1/royAndCoinBoxes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAX 1000001 4 | 5 | int main(){ 6 | int n, m; 7 | cin >> n >> m; 8 | 9 | int *dp = new int[MAX]; 10 | for(int i = 0; i < MAX; i++) dp[i] = 0; 11 | 12 | int l, r; 13 | for(int i = 0; i < m; i++){ 14 | cin >> l >> r; 15 | dp[r-1]++; 16 | if(l > 1) dp[l-2]--; 17 | } 18 | 19 | int *coin = new int[n]; 20 | coin[n-1] = dp[n-1]; 21 | for(int i = n-2; i >= 0; i--){ 22 | coin[i] = dp[i]+coin[i+1]; 23 | } 24 | 25 | for(int i = 0; i < MAX; i++) dp[i] = 0; 26 | for(int i = 0; i < n; i++){ 27 | dp[coin[i]]++; 28 | } 29 | 30 | int *query = new int[MAX]; 31 | query[MAX-1] = dp[MAX-1]; 32 | for(int i = MAX-2; i >= 0; i--){ 33 | query[i] = dp[i]+query[i+1]; 34 | } 35 | 36 | int q; 37 | cin >> q; 38 | int x; 39 | for(int i = 0; i < q; i++){ 40 | cin >> x; 41 | cout << query[x] << endl; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /Dynamic Programming 1/angryChildren.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int main(){ 6 | ll n, k; 7 | cin >> n >> k; 8 | 9 | ll *input = new ll[n]; 10 | for(ll i = 0; i < n; i++) cin >> input[i]; 11 | 12 | sort(input, input+n); 13 | 14 | 15 | ll *sum = new ll[n]; 16 | sum[0] = input[0]; 17 | for(int i = 1; i < n; i++) sum[i] = sum[i-1]+input[i]; 18 | 19 | ll minUnfairness = 0; 20 | int i = 0; 21 | int j = k-1; 22 | for(int a = 1; a <= j; a++){ 23 | minUnfairness += a*input[a]-sum[a-1]; 24 | } 25 | 26 | ll currUnfairness = minUnfairness; 27 | i++; j++; 28 | while(j < n){ 29 | currUnfairness += (j-i)*input[j]-sum[j-1]+sum[i-1]; 30 | currUnfairness -= sum[j-1]-sum[i-1]-(j-i)*input[i-1]; 31 | 32 | if(currUnfairness < minUnfairness){ 33 | minUnfairness = currUnfairness; 34 | } 35 | 36 | i++; 37 | j++; 38 | } 39 | 40 | cout << minUnfairness << endl; 41 | } 42 | -------------------------------------------------------------------------------- /Test 2/superNumber.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | 14 | #define it iterator 15 | #define mp make_pair 16 | #define pb push_back 17 | #define all(x) (x).begin(), (x).end() 18 | 19 | int main(){ 20 | ll t, m, n, d, answer, si, ei, lcm, mid; 21 | cin >> t; 22 | while(t--){ 23 | cin >> m >> n >> d; 24 | 25 | si = 1; 26 | ei = 100000000000000000LL; 27 | lcm = (m*n)/(__gcd(m, n)); 28 | while(si <= ei){ 29 | mid = (si+ei)/2; 30 | if(mid/m + mid/n - mid/lcm >= d){ 31 | answer = mid; 32 | ei = mid-1; 33 | } 34 | else si = mid+1; 35 | } 36 | 37 | cout << answer << endl; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /Dynamic Programming 2/sumOfDigits.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAX 10000001 4 | typedef long long ll; 5 | 6 | ll numDigits(ll x){ 7 | ll num = 0; 8 | while(x != 0){ 9 | num++; 10 | x /= 10; 11 | } 12 | return num-1; 13 | } 14 | 15 | ll sumOfDigits(ll x, unordered_map &m){ 16 | if(m.find(x) != m.end()) return m[x]; 17 | 18 | ll n = numDigits(x); 19 | ll p = pow(10, n); 20 | ll a = x/p; 21 | ll sum = p*a*(a-1)/2 + a*((x%p)+1) + sumOfDigits(x%p, m) + a*sumOfDigits(p-1, m); 22 | m[x] = sum; 23 | return sum; 24 | } 25 | 26 | int main(){ 27 | unordered_map m; 28 | m[0] = 0; 29 | m[1] = 1; 30 | m[2] = 3; 31 | m[3] = 6; 32 | m[4] = 10; 33 | m[5] = 15; 34 | m[6] = 21; 35 | m[7] = 28; 36 | m[8] = 36; 37 | m[9] = 45; 38 | 39 | ll a, b; 40 | while(1){ 41 | cin >> a >> b; 42 | if(a == -1 && b == -1) break; 43 | 44 | if(b == 0) b = 1; 45 | if(a == 0) a = 1; 46 | 47 | cout << sumOfDigits(b, m)-sumOfDigits(a-1, m) << endl; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /Test 1/palindromeSubstrings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int length(char s[]){ 5 | int i; 6 | for(i = 0; s[i] != '\0'; i++); 7 | return i; 8 | } 9 | 10 | int countPalindromeSubstrings(char s[]) { 11 | int count = 0; 12 | int n = length(s); 13 | 14 | for(int i = 0; i < n; i++){ 15 | count++; 16 | 17 | int j = i-1; 18 | int k = i+1; 19 | while(j >= 0 && k < n){ 20 | if(s[j] == s[k]) count++; 21 | else break; 22 | 23 | j--; 24 | k++; 25 | } 26 | } 27 | 28 | for(int i = 0; i < n-1; i++){ 29 | if(s[i] == s[i+1]){ 30 | count++; 31 | 32 | int j = i-1; 33 | int k = i+2; 34 | while(j >= 0 && k < n){ 35 | if(s[j] == s[k]) count++; 36 | else break; 37 | 38 | j--; 39 | k++; 40 | } 41 | } 42 | } 43 | 44 | return count; 45 | } 46 | 47 | int main() { 48 | char input[10000]; 49 | cin >> input; 50 | cout << countPalindromeSubstrings(input) << endl; 51 | } 52 | -------------------------------------------------------------------------------- /Dynamic Programming 1/numberOfRs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | int t; 6 | cin >> t; 7 | while(t--){ 8 | string s; 9 | cin >> s; 10 | int n = s.length(); 11 | 12 | int countR = 0, countK = 0; 13 | int totalR = 0, totalK = 0, maxR; 14 | int i, j; 15 | for(i = 0; i < n; i++){ 16 | if(s[i] == 'R') totalR++; 17 | else totalK++; 18 | } 19 | 20 | if(totalK == 0){ 21 | cout << totalR-1 << endl; 22 | continue; 23 | } 24 | 25 | maxR = totalR; i = 0; j = 0; 26 | 27 | while(i < n){ 28 | while(j < n && countK-countR >= 0){ 29 | if(s[j] == 'K') countK++; 30 | else countR++; 31 | 32 | if(totalR-countR+countK > maxR){ 33 | maxR = totalR-countR+countK; 34 | } 35 | 36 | j++; 37 | } 38 | 39 | if(s[i] == 'K') countK--; 40 | else countR--; 41 | 42 | i++; 43 | } 44 | 45 | cout << maxR << endl; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Computational Geometry/convexHull.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class point{ 5 | public: 6 | int x, y; 7 | }; 8 | 9 | bool toChange(point p, point q, point r){ 10 | int x1 = q.x-p.x; 11 | int y1 = q.y-p.y; 12 | int x2 = r.x-q.x; 13 | int y2 = r.y-q.y; 14 | 15 | int value = x1*y2-y1*x2; 16 | return value < 0; 17 | } 18 | 19 | void convexHull(point *polygon, int n){ 20 | int leftMost = 0; 21 | for(int i = 1; i < n; i++){ 22 | if(polygon[leftMost].x > polygon[i].x) leftMost = i; 23 | } 24 | 25 | int p = leftMost; 26 | do{ 27 | cout << polygon[p].x << " " << polygon[p].y << endl; 28 | int q = (p+1)%n; 29 | 30 | for(int i = 0; i < n; i++){ 31 | if(toChange(polygon[p], polygon[q], polygon[i])){ 32 | q = i; 33 | } 34 | } 35 | 36 | p = q; 37 | } while(p != leftMost); 38 | } 39 | 40 | int main(){ 41 | int n; 42 | cin >> n; 43 | 44 | point *polygon = new point[n]; 45 | for(int i = 0; i < n; i++) cin >> polygon[i].x; 46 | for(int i = 0; i < n; i++) cin >> polygon[i].y; 47 | 48 | convexHull(polygon, n); 49 | } 50 | -------------------------------------------------------------------------------- /Dynamic Programming 2/pussycatSonya.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define pb push_back 5 | #define MAX 100001 6 | 7 | ll A[MAX], dp[105][1005], prefix[MAX], best[1001]; 8 | int main(){ 9 | ll n, m, length, i, j, k; 10 | cin >> n >> m; 11 | 12 | for(i = 0; i <= n; i++){ 13 | for(j = 0; j <= m; j++) dp[i][j] = 0; 14 | } 15 | 16 | for(k = 1; k <= n; k++){ 17 | cin >> length; 18 | for(i = 0; i < length; i++) cin >> A[i]; 19 | prefix[0] = 0; 20 | 21 | for(i = 0; i < length; i++){ 22 | prefix[i+1] = prefix[i]+A[i]; 23 | } 24 | for(i = 1; i <= m; i++) best[i] = INT_MIN; 25 | best[0] = 0; 26 | for(i = 1; i <= length; i++){ 27 | for(j = i; j < i+m && j <= length; j++){ 28 | best[j-i+1] = max(best[j-i+1], prefix[j]-prefix[i-1]); 29 | } 30 | } 31 | 32 | for(j = 0; j <= m; j++){ 33 | for(ll take = 0; j+take <= m; take++){ 34 | dp[k][j+take] = max(dp[k][j+take], dp[k-1][j]+best[take]); 35 | } 36 | } 37 | } 38 | 39 | cout << dp[n][m] << endl; 40 | } 41 | -------------------------------------------------------------------------------- /Dynamic Programming 1/vanyaAndGCD.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define MOD 1000000007 5 | 6 | int main(){ 7 | ll n; 8 | cin >> n; 9 | 10 | ll maxElement = 0; 11 | ll *input = new ll[n]; 12 | for(ll i = 0; i < n; i++){ 13 | cin >> input[i]; 14 | if(input[i] > maxElement) maxElement = input[i]; 15 | } 16 | 17 | ll **dp = new ll *[n]; 18 | for(ll i = 0; i < n; i++){ 19 | dp[i] = new ll[maxElement+1]; 20 | for(ll j = 0; j <= maxElement; j++) dp[i][j] = 0; 21 | } 22 | 23 | for(ll i = 0; i < n; i++){ 24 | ll x = input[i]; 25 | dp[i][x] = ((dp[i][x]%MOD)+1)%MOD; 26 | 27 | for(ll j = i-1; j >= 0; j--){ 28 | if(input[j] >= input[i]) continue; 29 | 30 | for(ll k = 1; k <= maxElement; k++){ 31 | if(dp[j][k] > 0){ 32 | dp[i][__gcd(k, input[i])] = ((dp[i][__gcd(k, input[i])]%MOD)+(dp[j][k]%MOD))%MOD; 33 | } 34 | } 35 | } 36 | } 37 | 38 | ll total = 0; 39 | for(ll i = 0; i < n; i++){ 40 | total = ((total%MOD)+(dp[i][1]%MOD))%MOD; 41 | } 42 | 43 | cout << total << endl; 44 | } 45 | -------------------------------------------------------------------------------- /Advanced Graphs/monkAndTheIslands.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int findMinBridge(vector *graph, int n){ 5 | queue< pair > q; 6 | 7 | q.push({0, 0}); 8 | 9 | bool *isVisited = new bool[n]; 10 | for(int i = 0; i < n; i++) isVisited[i] = false; 11 | 12 | while(!q.empty()){ 13 | int currVertex = q.front().first; 14 | int depth = q.front().second; 15 | isVisited[currVertex] = true; 16 | q.pop(); 17 | 18 | for(int i = 0; i < graph[currVertex].size(); i++){ 19 | int x = graph[currVertex][i]; 20 | 21 | if(!isVisited[x]){ 22 | if(x == n-1) return depth+1; 23 | else q.push({x, depth+1}); 24 | } 25 | } 26 | } 27 | } 28 | 29 | int main(){ 30 | int t; 31 | cin >> t; 32 | while(t--){ 33 | int n, m; 34 | cin >> n >> m; 35 | 36 | vector *graph = new vector[n]; 37 | 38 | for(int i = 0; i < m; i++){ 39 | int x, y; 40 | cin >> x >> y; 41 | graph[x-1].push_back(y-1); 42 | graph[y-1].push_back(x-1); 43 | } 44 | 45 | cout << findMinBridge(graph, n) << endl; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Dynamic Programming 1/adjacentBitCounts.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define MOD 1000000007 5 | typedef pair pll; 6 | 7 | int main(){ 8 | ll p; 9 | cin >> p; 10 | while(p--){ 11 | ll number, n, k; 12 | cin >> number >> n >> k; 13 | 14 | pll **dp = new pll *[n+1]; 15 | for(int i = 0; i <= n; i++) dp[i] = new pll[k+1]; 16 | 17 | dp[1][0].first = 1; 18 | dp[1][0].second = 1; 19 | for(ll j = 1; j <= k; j++){ 20 | dp[1][k].first = 0; 21 | dp[1][k].second = 0; 22 | } 23 | 24 | for(ll i = 2; i <= n; i++){ 25 | dp[i][0].first = ((dp[i-1][0].first%MOD)+(dp[i-1][0].second%MOD))%MOD; 26 | dp[i][0].second = dp[i-1][0].first%MOD; 27 | } 28 | 29 | for(ll i = 2; i <= n; i++){ 30 | for(ll j = 1; j <= k; j++){ 31 | dp[i][j].first = ((dp[i-1][j].first%MOD)+(dp[i-1][j].second%MOD))%MOD; 32 | dp[i][j].second = ((dp[i-1][j].first%MOD)+(dp[i-1][j-1].second%MOD))%MOD; 33 | } 34 | } 35 | 36 | cout << number << " " << ((dp[n][k].first%MOD)+(dp[n][k].second%MOD))%MOD << endl; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /Graphs 2/kruskalsAlgorithm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int findParent(int *parent, int id){ 5 | while(parent[id] != id){ 6 | id = parent[id]; 7 | } 8 | return id; 9 | } 10 | 11 | int main(){ 12 | int v, e; 13 | cin >> v >> e; 14 | pair< int, pair > *input = new pair< int, pair >[e]; 15 | for(int i = 0; i < e; i++){ 16 | int ei, ej, wi; 17 | cin >> ei >> ej >> wi; 18 | input[i] = { wi, {ei, ej} }; 19 | } 20 | 21 | sort(input, input+e); 22 | 23 | int *parent = new int[v]; 24 | for(int i = 0; i < v; i++) parent[i] = i; 25 | 26 | int count = 0; 27 | int i = 0; 28 | while(count < v-1){ 29 | int ei, ej, wi; 30 | ei = input[i].second.first; 31 | ej = input[i].second.second; 32 | wi = input[i].first; 33 | 34 | int parent1 = findParent(parent, ei); 35 | int parent2 = findParent(parent, ej); 36 | 37 | if(parent1 != parent2){ 38 | if(ei <= ej) cout << ei << " " << ej << " " << wi << endl; 39 | else cout << ej << " " << ei << " " << wi << endl; 40 | 41 | parent[parent1] = parent2; 42 | count++; 43 | } 44 | i++; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /Dynamic Programming 2/miserMan.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int findFare(int **input, int n, int m, int row, int col, int **dp){ 5 | if(row == n) return 0; 6 | 7 | if(dp[row][col] != -1) return dp[row][col]; 8 | 9 | int a = INT_MAX, b = INT_MAX, c = INT_MAX; 10 | if(col-1 >= 0) a = input[row][col]+findFare(input, n, m, row+1, col-1, dp); 11 | b = input[row][col]+findFare(input, n, m, row+1, col, dp); 12 | if(col+1 < m) c = input[row][col]+findFare(input, n, m, row+1, col+1, dp); 13 | 14 | dp[row][col] = min(a, min(b, c)); 15 | return min(a, min(b, c)); 16 | } 17 | 18 | int main(){ 19 | int n, m; 20 | cin >> n >> m; 21 | 22 | int **input = new int *[n]; 23 | for(int i = 0; i < n; i++){ 24 | input[i] = new int[m]; 25 | for(int j = 0; j < m; j++) cin >> input[i][j]; 26 | } 27 | 28 | int **dp = new int *[n]; 29 | for(int i = 0; i < n; i++) dp[i] = new int[m]; 30 | 31 | int minFare = INT_MAX; 32 | for(int i = 0; i < m; i++){ 33 | for(int j = 0; j < n; j++){ 34 | for(int k = 0; k < m; k++) dp[j][k] = -1; 35 | } 36 | 37 | minFare = min(minFare, findFare(input, n, m, 0, i, dp)); 38 | } 39 | 40 | cout << minFare << endl; 41 | } 42 | -------------------------------------------------------------------------------- /Dynamic Programming 1/alyonaAndSpreadsheet.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | int n, m; 6 | cin >> n >> m; 7 | 8 | int **input = new int *[n]; 9 | for(int i = 0; i < n; i++){ 10 | input[i] = new int[m]; 11 | for(int j = 0; j < m; j++) cin >> input[i][j]; 12 | } 13 | 14 | bool dp[n][n][m]; 15 | 16 | for(int i = 0; i < n; i++){ 17 | for(int j = 0; j < m; j++){ 18 | dp[i][i][j] = true; 19 | } 20 | } 21 | 22 | int i = 0, j = 0, col = 1; 23 | while(col < n){ 24 | j = col; 25 | i = 0; 26 | 27 | while(j < n){ 28 | for(int k = 0; k < m; k++){ 29 | dp[i][j][k] = dp[i][(i+j)/2][k] && dp[((i+j)/2)+1][j][k] && (input[((i+j)/2)+1][k] >= input[(i+j)/2][k]); 30 | } 31 | i++; 32 | j++; 33 | } 34 | col++; 35 | } 36 | 37 | int q; 38 | cin >> q; 39 | int x, y; 40 | while(q--){ 41 | cin >> x >> y; 42 | int k; 43 | for(k = 0; k < m; k++){ 44 | if(dp[x-1][y-1][k]){ 45 | cout << "Yes" << endl; 46 | break; 47 | } 48 | } 49 | if(k == m) cout << "No" << endl; 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /Greedy Techniques/fractionalKnapsack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | struct worker{ 6 | int t, x, y; 7 | 8 | worker(int _t, int _x, int _y){ 9 | t = _t; 10 | x = _x; 11 | y = _y; 12 | } 13 | }; 14 | 15 | vector input; 16 | 17 | bool way(worker a, worker b){ 18 | if(a.t == b.t){ 19 | if(a.y == b.y){ 20 | return a.x < b.x; 21 | } 22 | return a.y > b.y; 23 | } 24 | return a.t < b.t; 25 | } 26 | 27 | int main(){ 28 | int n, x, y, t; 29 | ll d; 30 | cin >> n; 31 | cin >> d; 32 | 33 | for(int i = 0; i < n; i++){ 34 | cin >> t >> x >> y; 35 | input.push_back(worker(t, x, y)); 36 | } 37 | 38 | sort(input.begin(), input.end(), way); 39 | 40 | ll area = 0; 41 | ll bestSpeed = 0, cost = 0, lasTime = input[0].t; 42 | 43 | for(int i = 0; i < n; i++){ 44 | ll additional = bestSpeed * 1LL * (input[i].t - lasTime); 45 | area += additional; 46 | if(area >= d) break; 47 | if(input[i].y > bestSpeed){ 48 | bestSpeed = input[i].y; 49 | cost += input[i].x; 50 | } 51 | lasTime = input[i].t; 52 | } 53 | 54 | cout << cost << endl; 55 | } 56 | -------------------------------------------------------------------------------- /Dynamic Programming 2/charlieAndPilots.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int minSalary(int *assistant, int *captain, int n, int x, int **memo){ 5 | if(n == 0) return 0; 6 | 7 | if(memo[n][x] != -1) return memo[n][x]; 8 | 9 | if(x == 0){ 10 | int answer = assistant[0]+minSalary(assistant+1, captain+1, n-1, x+1, memo); 11 | memo[n][x] = answer; 12 | return answer; 13 | } 14 | else if(x == n){ 15 | int answer = captain[0]+minSalary(assistant+1, captain+1, n-1, x-1, memo); 16 | memo[n][x] = answer; 17 | return answer; 18 | } 19 | else{ 20 | int a = assistant[0]+minSalary(assistant+1, captain+1, n-1, x+1, memo); 21 | int b = captain[0]+minSalary(assistant+1, captain+1, n-1, x-1, memo); 22 | int answer = min(a, b); 23 | memo[n][x] = answer; 24 | return answer; 25 | } 26 | } 27 | 28 | int main(){ 29 | int n; 30 | cin >> n; 31 | 32 | int *captain = new int[n]; 33 | int *assistant = new int[n]; 34 | for(int i = 0; i < n; i++){ 35 | cin >> captain[i] >> assistant[i]; 36 | } 37 | 38 | int **memo = new int *[n+1]; 39 | for(int i = 0; i <= n; i++){ 40 | memo[i] = new int[(n/2)+1]; 41 | for(int j = 0; j <= n/2; j++) memo[i][j] = -1; 42 | } 43 | 44 | cout << minSalary(assistant, captain, n, 0, memo) << endl; 45 | } 46 | -------------------------------------------------------------------------------- /Dynamic Programming 1/jonSnowAndHisFavoriteNumber.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define MAX 1024 5 | 6 | int main(){ 7 | int n, k, x; 8 | cin >> n >> k >> x; 9 | 10 | int *input = new int[MAX]; 11 | for(int i = 0; i < MAX; i++) input[i] = 0; 12 | 13 | int a; 14 | for(int i = 0; i < n; i++){ 15 | cin >> a; 16 | input[a]++; 17 | } 18 | 19 | int *helper = new int[MAX]; 20 | int count; 21 | while(k--){ 22 | for(int i = 0; i < MAX; i++) helper[i] = 0; 23 | count = 0; 24 | 25 | for(int i = 0; i < MAX; i++){ 26 | if(count%2 == 0){ 27 | count += input[i]; 28 | helper[x^i] += (input[i]+1)/2; 29 | input[i] -= (input[i]+1)/2; 30 | helper[i] += input[i]; 31 | } 32 | else{ 33 | count += input[i]; 34 | helper[x^i] += input[i]/2; 35 | input[i] -= input[i]/2; 36 | helper[i] += input[i]; 37 | } 38 | } 39 | 40 | for(int i = 0; i < MAX; i++) input[i] = helper[i]; 41 | } 42 | 43 | for(int i = MAX-1; i >= 0; i--){ 44 | if(input[i] > 0){ 45 | cout << i << " "; 46 | break; 47 | } 48 | } 49 | for(int i = 0; i < MAX; i++){ 50 | if(input[i] > 0){ 51 | cout << i << endl; 52 | break; 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /Dynamic Programming 2/traderProfit.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | #define f first 5 | #define s second 6 | 7 | int maxProfit(int *input, int id, int n, int k, bool buy, pii **memo){ 8 | if(k == 0 || id == n) return 0; 9 | 10 | if(buy){ 11 | if(memo[id][k].f != -1) return memo[id][k].f; 12 | } 13 | else{ 14 | if(memo[id][k].s != -1) return memo[id][k].s; 15 | } 16 | 17 | if(buy){ 18 | int a = maxProfit(input, id+1, n, k, false, memo)-input[id]; 19 | int b = maxProfit(input, id+1, n, k, true, memo); 20 | memo[id][k].f = max(a, b); 21 | return max(a, b); 22 | } 23 | else{ 24 | int a = input[id]+maxProfit(input, id+1, n, k-1, true, memo); 25 | int b = maxProfit(input, id+1, n, k, false, memo); 26 | memo[id][k].s = max(a, b); 27 | return max(a, b); 28 | } 29 | } 30 | 31 | int main(){ 32 | int q; 33 | cin >> q; 34 | while(q--){ 35 | int k, n; 36 | cin >> k >> n; 37 | 38 | int *input = new int[n]; 39 | for(int i = 0; i < n; i++) cin >> input[i]; 40 | 41 | pii **memo = new pii *[n+1]; 42 | for(int i = 0; i <= n; i++){ 43 | memo[i] = new pii[k+1]; 44 | for(int j = 0; j <= k; j++){ 45 | memo[i][j].f = -1; 46 | memo[i][j].s = -1; 47 | } 48 | } 49 | 50 | cout << maxProfit(input, 0, n, k, true, memo) << endl; 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /Dynamic Programming 2/balikaVadhu.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define pb push_back 5 | 6 | int main(){ 7 | int t; 8 | cin >> t; 9 | while(t--){ 10 | string b1, b2; 11 | int l; 12 | cin >> b1 >> b2 >> l; 13 | 14 | int n = b1.length(); 15 | int m = b2.length(); 16 | 17 | int dp[n+1][m+1][l+1]; 18 | for(int i = 0; i <= n; i++){ 19 | dp[i][0][0] = 0; 20 | for(int k = 1; k <= l; k++) dp[i][0][k] = INT_MIN; 21 | } 22 | for(int j = 0; j <= m; j++){ 23 | dp[0][j][0] = 0; 24 | for(int k = 1; k <= l; k++) dp[0][j][k] = INT_MIN; 25 | } 26 | 27 | for(int i = 1; i <= n; i++){ 28 | for(int j = 1; j <= m; j++){ 29 | dp[i][j][0] = 0; 30 | if(b1[i-1] == b2[j-1]){ 31 | for(int k = 1; k <= l; k++){ 32 | dp[i][j][k] = max(dp[i-1][j-1][k-1]+b1[i-1], max(dp[i-1][j][k], dp[i][j-1][k])); 33 | } 34 | } 35 | else{ 36 | for(int k = 1; k <= l; k++){ 37 | dp[i][j][k] = max(dp[i-1][j][k], dp[i][j-1][k]); 38 | } 39 | } 40 | // cout << i << " " << j << " " << dp[i][j][l-1] << " " << dp[i][j][l] << endl; 41 | } 42 | // cout << endl; 43 | } 44 | 45 | if(dp[n][m][l] < 0) cout << 0 << endl; 46 | else cout << dp[n][m][l] << endl; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /Fenwick Tree/coderRatingProblem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAX 100001 4 | 5 | class coder{ 6 | public: 7 | int index, x, y; 8 | }; 9 | 10 | bool compare(coder c1, coder c2){ 11 | if(c1.x == c2.x) return c1.y < c2.y; 12 | 13 | return c1.x < c2.x; 14 | } 15 | 16 | void update(int y, int *fenwick){ 17 | for(; y < MAX; y += y&(-y)){ 18 | fenwick[y]++; 19 | } 20 | } 21 | 22 | int query(int y, int *fenwick){ 23 | int value = 0; 24 | for(; y > 0; y -= y&(-y)){ 25 | value += fenwick[y]; 26 | } 27 | return value; 28 | } 29 | 30 | int main(){ 31 | int n; 32 | cin >> n; 33 | 34 | coder *input = new coder[n]; 35 | for(int i = 0; i < n; i++){ 36 | cin >> input[i].x >> input[i].y; 37 | input[i].index = i; 38 | } 39 | 40 | sort(input, input+n, compare); 41 | 42 | int *solution = new int[n]; 43 | 44 | int *fenwick = new int[MAX]; 45 | for(int i = 0; i < MAX; i++) fenwick[i] = 0; 46 | 47 | for(int i = 0; i < n;){ 48 | int endIndex = i; 49 | while(endIndex < n && input[i].x == input[endIndex].x && input[i].y == input[endIndex].y){ 50 | endIndex++; 51 | } 52 | 53 | for(int j = i; j < endIndex; j++){ 54 | solution[input[j].index] = query(input[j].y, fenwick); 55 | } 56 | 57 | for(int j = i; j < endIndex; j++){ 58 | update(input[j].y, fenwick); 59 | } 60 | 61 | i = endIndex; 62 | } 63 | 64 | for(int i = 0; i < n; i++) cout << solution[i] << endl; 65 | } 66 | -------------------------------------------------------------------------------- /Dynamic Programming 3/ghostType.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | 14 | #define it iterator 15 | #define mp make_pair 16 | #define pb push_back 17 | #define all(x) (x).begin(), (x).end() 18 | #define MOD 1000000007 19 | 20 | int main(){ 21 | ll n; 22 | cin >> n; 23 | bool flag; 24 | 25 | if(n == 1){ 26 | cout << 1 << endl; 27 | return 0; 28 | } 29 | 30 | ll *dp = new ll[(1< 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | class point{ 6 | public: 7 | ll x, y; 8 | }; 9 | 10 | ll areaTriangle(point a, point b, point c){ 11 | ll x1 = b.x-a.x; 12 | ll y1 = b.y-a.y; 13 | ll x2 = c.x-a.x; 14 | ll y2 = c.y-a.y; 15 | 16 | return x1*y2-x2*y1; 17 | } 18 | 19 | int main(){ 20 | string direction; 21 | cin >> direction; 22 | 23 | int n = direction.length(); 24 | ll *length = new ll[n]; 25 | for(int i = 0; i < n; i++) cin >> length[i]; 26 | 27 | point *polygon = new point[n]; 28 | polygon[0].x = 0; polygon[0].y = 0; 29 | for(int i = 0; i < n-1; i++){ 30 | if(direction[i] == 'N'){ 31 | polygon[i+1].x = polygon[i].x; 32 | polygon[i+1].y = polygon[i].y + length[i]; 33 | } 34 | else if(direction[i] == 'S'){ 35 | polygon[i+1].x = polygon[i].x; 36 | polygon[i+1].y = polygon[i].y - length[i]; 37 | } 38 | else if(direction[i] == 'E'){ 39 | polygon[i+1].x = polygon[i].x + length[i]; 40 | polygon[i+1].y = polygon[i].y; 41 | } 42 | else{ 43 | polygon[i+1].x = polygon[i].x - length[i]; 44 | polygon[i+1].y = polygon[i].y; 45 | } 46 | } 47 | 48 | // for(int i = 0; i < n; i++){ 49 | // cout << polygon[i].x << " " << polygon[i].y << endl; 50 | // } 51 | 52 | ll area = 0; 53 | for(ll i = 1; i < n-1; i++){ 54 | area += areaTriangle(polygon[0], polygon[i], polygon[i+1]); 55 | } 56 | area = abs(area)/2; 57 | cout << area << endl; 58 | } 59 | -------------------------------------------------------------------------------- /Fenwick Tree/distinctQueryProblem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class query{ 5 | public: 6 | int start, end, index; 7 | }; 8 | 9 | bool operator< (query a, query b){ 10 | return a.end < b.end; 11 | } 12 | 13 | void update(int *bit, int id, int value, int n){ 14 | for(; id <= n; id += id&(-id)){ 15 | bit[id] += value; 16 | } 17 | } 18 | 19 | int value(int *bit, int id){ 20 | int answer = 0; 21 | for(; id > 0; id -= id&(-id)){ 22 | answer += bit[id]; 23 | } 24 | return answer; 25 | } 26 | 27 | int main(){ 28 | int n, i; 29 | cin >> n; 30 | 31 | int *input = new int[n+1]; 32 | for(i = 1; i <= n; i++) cin >> input[i]; 33 | 34 | int q; 35 | cin >> q; 36 | 37 | query *queries = new query[q]; 38 | for(i = 0; i < q; i++){ 39 | cin >> queries[i].start >> queries[i].end; 40 | queries[i].index = i; 41 | } 42 | 43 | sort(queries, queries+q); 44 | int *distinct = new int[1000001]; 45 | for(i = 0; i < 1000001; i++) distinct[i] = -1; 46 | 47 | int *bit = new int[n+1]; 48 | for(i = 0; i <= n; i++) bit[i] = 0; 49 | int total = 0, k = 0; 50 | int *answer = new int[q]; 51 | 52 | for(i = 1; i <= n; i++){ 53 | if(distinct[input[i]] != -1){ 54 | update(bit, distinct[input[i]], -1, n); 55 | } 56 | else total++; 57 | 58 | update(bit, i, 1, n); 59 | distinct[input[i]] = i; 60 | 61 | while(k < q && queries[k].end == i){ 62 | answer[ queries[k].index ] = total - value(bit, queries[k].start - 1); 63 | k++; 64 | } 65 | } 66 | 67 | for(i = 0; i < q; i++) cout << answer[i] << endl; 68 | } 69 | -------------------------------------------------------------------------------- /Graphs 2/dijkstrasAlgorithm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int findMinVertex(int *weight, bool *isVisited, int n){ 5 | int minIndex = -1; 6 | for(int i = 0; i < n; i++){ 7 | if(!isVisited[i] && (minIndex == -1 || weight[i] < weight[minIndex])){ 8 | minIndex = i; 9 | } 10 | } 11 | 12 | return minIndex; 13 | } 14 | 15 | int main(){ 16 | int v, e; 17 | cin >> v >> e; 18 | 19 | int **input = new int*[v]; 20 | for(int i = 0; i < v; i++){ 21 | input[i] = new int[v]; 22 | for(int j = 0; j < v; j++) input[i][j] = 0; 23 | } 24 | 25 | for(int i = 0; i < e; i++){ 26 | int ei, ej, w; 27 | cin >> ei >> ej >> w; 28 | input[ei][ej] = w; 29 | input[ej][ei] = w; 30 | } 31 | 32 | int *weight = new int[v]; 33 | bool *isVisited = new bool[v]; 34 | for(int i = 0; i < v; i++){ 35 | weight[i] = INT_MAX; 36 | isVisited[i] = false; 37 | } 38 | 39 | weight[0] = 0; 40 | 41 | for(int i = 0; i < v-1; i++){ 42 | int currentVertex = findMinVertex(weight, isVisited, v); 43 | // cout << currentVertex << endl; 44 | isVisited[currentVertex] = true; 45 | 46 | for(int j = 0; j < v; j++){ 47 | if(input[currentVertex][j] > 0 && !isVisited[j]){ 48 | if(input[currentVertex][j]+weight[currentVertex] < weight[j]){ 49 | // cout << currentVertex << " " << j << endl; 50 | weight[j] = input[currentVertex][j]+weight[currentVertex]; 51 | } 52 | } 53 | } 54 | } 55 | 56 | for(int i = 0; i < v; i++){ 57 | cout << i << " " << weight[i] << endl; 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /Dynamic Programming 3/mehtaAndBankRobbery.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | typedef pair pll; 14 | 15 | #define it iterator 16 | #define mp make_pair 17 | #define pb push_back 18 | #define all(x) (x).begin(), (x).end() 19 | #define f first 20 | #define s second 21 | #define MOD 1000000007 22 | 23 | int main(){ 24 | ll n, w; 25 | cin >> n >> w; 26 | 27 | ll primes[10] = {2,3,5,7,11,13,17,19,23,29}; 28 | 29 | pll *input = new pll[n]; 30 | for(ll i = 0; i < n; i++) cin >> input[i].f >> input[i].s; 31 | 32 | sort(input, input+n); 33 | 34 | ll dp[11][2][w+1]; 35 | for(ll p = 0; p <= 10; p++){ 36 | for(ll j = 0; j <= w; j++){ 37 | dp[p][0][j] = 0; 38 | dp[p][1][j] = 0; 39 | } 40 | } 41 | 42 | ll id = 1; 43 | for(ll i = 1; i <= n; i++){ 44 | for(ll p = 0; p <= 10; p++){ 45 | for(ll j = 0; j <= w; j++){ 46 | dp[p][id][j] = dp[p][1^id][j]; 47 | if(j >= input[i-1].s){ 48 | dp[p][id][j] = max(dp[p][id][j], dp[p][1^id][j-input[i-1].s] + input[i-1].f); 49 | if(p >= 1) dp[p][id][j] = max(dp[p][id][j], dp[p-1][1^id][j-input[i-1].s] + primes[p-1]*(input[i-1].f)); 50 | } 51 | } 52 | } 53 | 54 | id = 1^id; 55 | } 56 | 57 | cout << dp[10][1^id][w] << endl; 58 | } 59 | -------------------------------------------------------------------------------- /Greedy Techniques/weightedJobScheduling.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | struct job{ 6 | ll start, finish, profit; 7 | 8 | job(ll s, ll f, ll p){ 9 | start = s; 10 | finish = f; 11 | profit = p; 12 | } 13 | }; 14 | 15 | bool compare(job a, job b){ 16 | return a.finish < b.finish; 17 | } 18 | 19 | ll search(vector *input, ll limit, ll si, ll ei){ 20 | if(si > ei) return -1; 21 | 22 | if(si == ei){ 23 | if((input->at(si)).finish <= limit) return si; 24 | else return -1; 25 | } 26 | 27 | ll mid = (si+ei)/2; 28 | if((input->at(mid)).finish <= limit){ 29 | ll answer = search(input, limit, mid+1, ei); 30 | if(answer == -1) return mid; 31 | else return answer; 32 | } 33 | else return search(input, limit, si, mid-1); 34 | } 35 | 36 | int main(){ 37 | ll n; 38 | cin >> n; 39 | 40 | vector input; 41 | for(ll i = 0; i < n; i++){ 42 | ll s, f, p; 43 | cin >> s >> f >> p; 44 | input.push_back(job(s, f, p)); 45 | } 46 | 47 | sort(input.begin(), input.end(), compare); 48 | 49 | ll *dp = new ll[n]; 50 | dp[0] = input[0].profit; 51 | for(ll i = 1; i < n; i++){ 52 | ll include = input[i].profit; 53 | 54 | ll id = -1; 55 | id = search(&input, input[i].start, 0, i-1); 56 | // for(ll j = i-1; j >= 0; j--){ 57 | // if(input[j].finish <= input[i].start){ 58 | // id = j; 59 | // break; 60 | // } 61 | // } 62 | 63 | if(id != -1){ 64 | include += dp[id]; 65 | } 66 | 67 | dp[i] = max(dp[i-1], include); 68 | } 69 | 70 | cout << dp[n-1] << endl; 71 | } 72 | -------------------------------------------------------------------------------- /Computational Geometry/warehouse.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class point{ 5 | public: 6 | double x, y; 7 | }; 8 | 9 | double distance(point a, point b){ 10 | return sqrt((b.x-a.x)*(b.x-a.x) + (b.y-a.y)*(b.y-a.y)); 11 | } 12 | 13 | double findWidth(point a, point b){ 14 | if(a.x == b.x) return abs(a.y - b.y); 15 | 16 | double x1 = a.x; double y1 = a.y; 17 | double x2 = b.x; double y2 = b.y; 18 | double p1 = ((y2-y1)*y1)/(x2-x1) + x1; 19 | double p2 = ((y2-y1)*y2)/(x2-x1) + x2; 20 | double slope = (y2-y1)/(x2-x1); 21 | 22 | double width = 0; 23 | if(slope > 0){ 24 | width += y1-y2; 25 | width += y1*x2/(x1-200); 26 | width -= y1*x1/(x1-200); 27 | width = abs(width); 28 | width /= sqrt(1 + (y1/(x1-200))*(y1/(x1-200))); 29 | return width; 30 | } 31 | else{ 32 | width += y2-y1; 33 | width += ((y2-200)*x1)/(x2-200); 34 | width -= ((y2-200)*x2)/(x2-200); 35 | width = abs(width); 36 | width /= sqrt(1 + ((y2-200)*(y2-200))/((x2-200)*(x2-200))); 37 | return width; 38 | } 39 | 40 | return distance(a, b); 41 | } 42 | 43 | int main(){ 44 | int n; 45 | cin >> n; 46 | point *polygon = new point[n]; 47 | for(int i = 0; i < n; i++) cin >> polygon[i].x; 48 | for(int i = 0; i < n; i++) cin >> polygon[i].y; 49 | 50 | double maxWidth = 0; 51 | for(int i = 0; i < n; i++){ 52 | for(int j = i+1; j < n; j++){ 53 | double possibleWidth = findWidth(polygon[i], polygon[j]); 54 | cout << possibleWidth << endl; 55 | if(possibleWidth > maxWidth) maxWidth = possibleWidth; 56 | } 57 | } 58 | 59 | if(floor(maxWidth) == maxWidth) maxWidth -= 1; 60 | cout << floor(maxWidth) << endl; 61 | } 62 | -------------------------------------------------------------------------------- /Graphs 2/primsAlgorithm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int findMinVertex(int *weight, bool *isVisited, int n){ 5 | int minVertex = -1; 6 | for(int i = 0; i < n; i++){ 7 | if(!isVisited[i] && (minVertex == -1 || weight[i] < weight[minVertex])){ 8 | minVertex = i; 9 | } 10 | } 11 | 12 | return minVertex; 13 | } 14 | 15 | int main(){ 16 | int n, e; 17 | cin >> n >> e; 18 | 19 | int **input = new int*[n]; 20 | for(int i = 0; i < n; i++){ 21 | input[i] = new int[n]; 22 | for(int j = 0; j < n; j++) input[i][j] = -1; 23 | } 24 | 25 | for(int i = 0; i < e; i++){ 26 | int ei, ej, w; 27 | cin >> ei >> ej >> w; 28 | input[ei][ej] = w; 29 | input[ej][ei] = w; 30 | } 31 | 32 | int *parent = new int[n]; 33 | int *weight = new int[n]; 34 | bool *isVisited = new bool[n]; 35 | for(int i = 0; i < n; i++){ 36 | weight[i] = INT_MAX; 37 | isVisited[i] = false; 38 | } 39 | 40 | parent[0] = -1; 41 | weight[0] = 0; 42 | 43 | for(int i = 0; i < n; i++){ 44 | int minVertex = findMinVertex(weight, isVisited, n); 45 | isVisited[minVertex] = true; 46 | 47 | for(int j = 0; j < n; j++){ 48 | if(input[minVertex][j] > 0 && !isVisited[j]){ 49 | if(input[minVertex][j] < weight[j]){ 50 | weight[j] = input[minVertex][j]; 51 | parent[j] = minVertex; 52 | } 53 | } 54 | } 55 | } 56 | 57 | for(int i = 1; i < n; i++){ 58 | int ei = i; 59 | int ej = parent[i]; 60 | int w = weight[i]; 61 | if(ei < ej) cout << ei << " " << ej << " " << w << endl; 62 | else cout << ej << " " << ei << " " << w << endl; 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /Dynamic Programming 2/squareBrackets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int squareBrackets(int id, int numOpen, int *input, int n, int **dp){ 5 | int numClose = id-numOpen; 6 | 7 | if(id == n){ 8 | if(numOpen == numClose) return 1; 9 | else return 0; 10 | } 11 | 12 | if(dp[id][numOpen] != -1) return dp[id][numOpen]; 13 | 14 | if(numOpen-numClose > n-id) return 0; 15 | if(numClose > numOpen) return 0; 16 | 17 | if(id == input[0]){ 18 | int answer = squareBrackets(id+1, numOpen+1, input+1, n, dp); 19 | dp[id][numOpen] = answer; 20 | return answer; 21 | } 22 | 23 | if(numOpen == numClose){ 24 | int answer = squareBrackets(id+1, numOpen+1, input, n, dp); 25 | dp[id][numOpen] = answer; 26 | return answer; 27 | } 28 | 29 | if(numOpen-numClose == n-id){ 30 | int answer = squareBrackets(id+1, numOpen, input, n, dp); 31 | dp[id][numOpen] = answer; 32 | return answer; 33 | } 34 | 35 | int a = squareBrackets(id+1, numOpen+1, input, n, dp); 36 | int b = squareBrackets(id+1, numOpen, input, n, dp); 37 | dp[id][numOpen] = a+b; 38 | return a+b; 39 | } 40 | 41 | int main(){ 42 | int d; 43 | cin >> d; 44 | while(d--){ 45 | int n, k; 46 | cin >> n >> k; 47 | 48 | int *input = new int[k]; 49 | int x; 50 | for(int i = 0; i < k; i++){ 51 | cin >> x; 52 | input[i] = x-1; 53 | } 54 | 55 | sort(input, input+k); 56 | int **dp = new int *[2*n+1]; 57 | for(int i = 0; i <= 2*n; i++){ 58 | dp[i] = new int[2*n+1]; 59 | for(int j = 0; j <= 2*n; j++) dp[i][j] = -1; 60 | } 61 | 62 | if(input[0] < 0 || input[k-1] >= 2*n){ 63 | cout << 0 << endl; 64 | continue; 65 | } 66 | 67 | cout << squareBrackets(0, 0, input, 2*n, dp) << endl; 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /Computational Geometry/areaOfConvexPolygon.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class point{ 5 | public: 6 | double x, y; 7 | }; 8 | 9 | point p0; 10 | 11 | double distance(point a, point b){ 12 | return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); 13 | } 14 | 15 | void findMinPoint(point *polygon, int n){ 16 | int minId = 0; 17 | for(int i = 1; i < n; i++){ 18 | if(polygon[i].y < polygon[minId].y) minId = i; 19 | else if(polygon[i].y == polygon[minId].y && polygon[i].x < polygon[minId].x){ 20 | minId = i; 21 | } 22 | } 23 | 24 | point temp = polygon[minId]; 25 | polygon[minId] = polygon[0]; 26 | polygon[0] = temp; 27 | } 28 | 29 | int orientation(point p, point q, point r){ 30 | double val = (q.y-p.y)*(r.x-q.x) - (q.x-p.x)*(r.y-q.y); 31 | if(val == 0) return 0; 32 | return val > 0 ? 1 : 2; 33 | } 34 | 35 | int compare(const void *ap, const void *bp){ 36 | point *a = (point *)ap; 37 | point *b = (point *)bp; 38 | 39 | int o = orientation(p0, *a, *b); 40 | 41 | if(o == 0) return distance(p0, *b) >= distance(p0, *a) ? -1 : 1; 42 | 43 | return o == 2 ? -1 : 1; 44 | } 45 | 46 | void sort(point *polygon, int n){ 47 | findMinPoint(polygon, n); 48 | p0 = polygon[0]; 49 | 50 | qsort(&polygon[1], n-1, sizeof(point), compare); 51 | 52 | } 53 | 54 | int main(){ 55 | int n; 56 | cin >> n; 57 | 58 | point *polygon = new point[n]; 59 | for(int i = 0; i < n; i++){ 60 | cin >> polygon[i].x; 61 | } 62 | for(int i = 0; i < n; i++){ 63 | cin >> polygon[i].y; 64 | } 65 | 66 | sort(polygon, n); 67 | 68 | double area = 0; 69 | for(int i = 0; i < n-1; i++){ 70 | area += (polygon[i].x * polygon[i+1].y) - (polygon[i].y * polygon[i+1].x); 71 | } 72 | area += (polygon[n-1].x * polygon[0].y) - (polygon[0].x * polygon[n-1].y); 73 | 74 | area = abs(area)/2; 75 | printf("%.9g\n", area); 76 | } 77 | -------------------------------------------------------------------------------- /Segment Tree/vasyaVsRehso.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define pb push_back 5 | 6 | class node{ 7 | public: 8 | int a, b; 9 | 10 | node(){ 11 | 12 | } 13 | 14 | node(int a, int b){ 15 | this->a = a; 16 | this->b = b; 17 | } 18 | }; 19 | 20 | void buildTree(int *tree, node *input, int si, int ei, int id){ 21 | if(si == ei){ 22 | tree[id] = si; 23 | return; 24 | } 25 | 26 | int mid = (si+ei)/2; 27 | buildTree(tree, input, si, mid, 2*id); 28 | buildTree(tree, input, mid+1, ei, 2*id+1); 29 | 30 | if(input[tree[2*id]].a > input[tree[2*id+1]].a) tree[id] = tree[2*id]; 31 | else if(input[tree[2*id]].a < input[tree[2*id+1]].a) tree[id] = tree[2*id+1]; 32 | else{ 33 | if(input[tree[2*id]].b < input[tree[2*id+1]].b) tree[id] = tree[2*id]; 34 | else if(input[tree[2*id]].b > input[tree[2*id+1]].b) tree[id] = tree[2*id+1]; 35 | else tree[id] = min(tree[2*id], tree[2*id+1]); 36 | } 37 | } 38 | 39 | int query(int *tree, node *input, int si, int ei, int id, int left, int right){ 40 | if(si > right || ei < left) return left; 41 | 42 | if(si >= left && ei <= right) return tree[id]; 43 | 44 | int mid = (si+ei)/2; 45 | int x = query(tree, input, si, mid, 2*id, left, right); 46 | int y = query(tree, input, mid+1, ei, 2*id+1, left, right); 47 | 48 | if(input[x].a > input[y].a) return x; 49 | else if(input[x].a < input[y].a) return y; 50 | else{ 51 | if(input[x].b < input[y].b) return x; 52 | else if(input[x].b > input[y].b) return y; 53 | else return min(x, y); 54 | } 55 | } 56 | 57 | int main(){ 58 | int n; 59 | cin >> n; 60 | 61 | node *input = new node[n]; 62 | for(int i = 0; i < n; i++) cin >> input[i].a; 63 | for(int i = 0; i < n; i++) cin >> input[i].b; 64 | 65 | int *tree = new int[4*n]; 66 | buildTree(tree, input, 0, n-1, 1); 67 | 68 | int q; 69 | cin >> q; 70 | int x, y; 71 | while(q--){ 72 | cin >> x >> y; 73 | cout << query(tree, input, 0, n-1, 1, x-1, y-1)+1 << endl; 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /Test 2/fishmonger.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | 14 | #define it iterator 15 | #define mp make_pair 16 | #define pb push_back 17 | #define all(x) (x).begin(), (x).end() 18 | 19 | int memo[101][1001]; 20 | 21 | ll calculateMinToll(ll **time1, ll **toll, bool *isVisited, ll n, ll currCity, ll t){ 22 | if(memo[currCity][t] != -1) return memo[currCity][t]; 23 | 24 | if(t < 0){ 25 | memo[currCity][t] = INT_MAX; 26 | return INT_MAX; 27 | } 28 | 29 | if(currCity == n-1){ 30 | memo[currCity][t] = 0; 31 | return 0; 32 | } 33 | 34 | isVisited[currCity] = true; 35 | ll minToll = INT_MAX; 36 | for(ll i = 0; i < n; i++){ 37 | if(i == currCity) continue; 38 | if(!isVisited[i]){ 39 | ll x = calculateMinToll(time1, toll, isVisited, n, i, t-time1[currCity][i]); 40 | x += toll[currCity][i]; 41 | minToll = min(x, minToll); 42 | } 43 | } 44 | 45 | isVisited[currCity] = false; 46 | memo[currCity][t] = minToll; 47 | return minToll; 48 | } 49 | 50 | int main(){ 51 | ll n, t; 52 | cin >> n >> t; 53 | 54 | ll **time1 = new ll *[n]; 55 | for(ll i = 0; i < n; i++){ 56 | time1[i] = new ll[n]; 57 | for(ll j = 0; j < n; j++) cin >> time1[i][j]; 58 | } 59 | 60 | ll **toll = new ll *[n]; 61 | for(ll i = 0; i < n; i++){ 62 | toll[i] = new ll[n]; 63 | for(ll j = 0; j < n; j++) cin >> toll[i][j]; 64 | } 65 | 66 | bool *isVisited = new bool[n]; 67 | for(ll i = 0; i < n; i++) isVisited[i] = false; 68 | 69 | for(int i = 0; i < 101; i++){ 70 | for(int j = 0; j < 1001; j++) memo[i][j] = -1; 71 | } 72 | 73 | cout << calculateMinToll(time1, toll, isVisited, n, 0, t) << endl; 74 | } 75 | -------------------------------------------------------------------------------- /Segment Tree/2Vs3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define pb push_back 5 | 6 | int power[100001]; 7 | 8 | void buildPower(){ 9 | power[0] = 1; 10 | for(int i = 1; i < 100001; i++) power[i] = (power[i-1]*2)%3; 11 | } 12 | 13 | void buildTree(int *tree, int *input, int si, int ei, int id){ 14 | if(si == ei) tree[id] = input[si]; 15 | else{ 16 | int mid = (si+ei)/2; 17 | buildTree(tree, input, si, mid, 2*id); 18 | buildTree(tree, input, mid+1, ei, 2*id+1); 19 | 20 | tree[id] = (power[ei-mid]*tree[2*id] + tree[2*id+1])%3; 21 | } 22 | } 23 | 24 | int query(int *tree, int si, int ei, int id, int left, int right){ 25 | if(si > right || ei < left) return 0; 26 | else if(si >= left && ei <= right) return (tree[id]*power[right-ei])%3; 27 | 28 | int mid = (si+ei)/2; 29 | 30 | int x = query(tree, si, mid, 2*id, left, right); 31 | int y = query(tree, mid+1, ei, 2*id+1, left, right); 32 | return (x+y)%3; 33 | } 34 | 35 | void update(int *tree, int *input, int si, int ei, int id, int key){ 36 | if(si == ei){ 37 | input[key] = 1; 38 | tree[id] = 1; 39 | } 40 | else{ 41 | int mid = (si+ei)/2; 42 | if(si <= key && mid >= key) update(tree, input, si, mid, 2*id, key); 43 | else update(tree, input, mid+1, ei, 2*id+1, key); 44 | 45 | tree[id] = (power[ei-mid]*tree[2*id] + tree[2*id+1])%3; 46 | } 47 | } 48 | 49 | int main(){ 50 | buildPower(); 51 | 52 | int n; 53 | scanf("%d", &n); 54 | 55 | string s; 56 | cin >> s; 57 | int *input = new int[n]; 58 | for(int i = 0; i < n; i++) input[i] = s[i]-'0'; 59 | 60 | int *tree = new int[4*n]; 61 | buildTree(tree, input, 0, n-1, 1); 62 | 63 | int q, type, key, left, right; 64 | scanf("%d", &q); 65 | while(q--){ 66 | scanf("%d", &type); 67 | if(type == 0){ 68 | scanf("%d%d", &left, &right); 69 | printf("%d\n", query(tree, 0, n-1, 1, left, right)); 70 | } 71 | else{ 72 | scanf("%d", &key); 73 | if(input[key] == 0) update(tree, input, 0, n-1, 1, key); 74 | } 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /Advanced Graphs/kingdomOfMonkeys.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | void dfs(vector *graph, bool *isVisited, ll i, unordered_set *component){ 6 | isVisited[i] = true; 7 | component->insert(i); 8 | 9 | for(ll j = 0; j < graph[i].size(); j++){ 10 | ll next = graph[i][j]; 11 | if(!isVisited[next]){ 12 | dfs(graph, isVisited, next, component); 13 | } 14 | } 15 | } 16 | 17 | unordered_set< unordered_set * > *connectComponents(vector *graph, ll n){ 18 | unordered_set< unordered_set * > *output = new unordered_set< unordered_set * >(); 19 | 20 | bool *isVisited = new bool[n]; 21 | for(ll i = 0; i < n; i++) isVisited[i] = false; 22 | 23 | for(ll i = 0; i < n; i++){ 24 | if(!isVisited[i]){ 25 | unordered_set *component = new unordered_set(); 26 | dfs(graph, isVisited, i, component); 27 | output->insert(component); 28 | } 29 | } 30 | 31 | return output; 32 | } 33 | 34 | int main(){ 35 | ll t; 36 | cin >> t; 37 | while(t--){ 38 | ll n, m; 39 | cin >> n >> m; 40 | 41 | vector *graph = new vector[n]; 42 | 43 | for(ll i = 0; i < m; i++){ 44 | // cout << i << endl; 45 | ll x, y; 46 | cin >> x >> y; 47 | graph[x-1].push_back(y-1); 48 | graph[y-1].push_back(x-1); 49 | } 50 | 51 | ll *reward = new ll[n]; 52 | for(ll i = 0; i < n; i++){ 53 | // cout << "Reward inputting" << endl; 54 | cin >> reward[i]; 55 | } 56 | 57 | unordered_set< unordered_set * > *output = connectComponents(graph, n); 58 | 59 | ll max = 0; 60 | unordered_set< unordered_set * >::iterator i = output->begin(); 61 | while(i != output->end()){ 62 | unordered_set *component = *i; 63 | ll total = 0; 64 | unordered_set::iterator j = component->begin(); 65 | while(j != component->end()){ 66 | total += reward[*j]; 67 | j++; 68 | } 69 | 70 | if(max < total) max = total; 71 | 72 | i++; 73 | } 74 | 75 | cout << max << endl; 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /Segment Tree/maximumSumInSubarray.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define pb push_back 5 | 6 | class node{ 7 | public: 8 | ll maxSum, sum, preSum, sufSum; 9 | 10 | node(){ 11 | 12 | } 13 | 14 | node(ll ms, ll s, ll ps, ll ss){ 15 | maxSum = ms; 16 | sum = s; 17 | preSum = ps; 18 | sufSum = ss; 19 | } 20 | }; 21 | 22 | ll max(ll a, ll b, ll c, ll d, ll e){ 23 | return std::max(a, std::max(b, std::max(c, std::max(d, e)))); 24 | } 25 | 26 | void buildTree(node *tree, ll *input, ll si, ll ei, ll id){ 27 | if(si == ei){ 28 | tree[id] = node(input[si], input[si], input[si], input[si]); 29 | return; 30 | } 31 | 32 | ll mid = (si+ei)/2; 33 | buildTree(tree, input, si, mid, 2*id); 34 | buildTree(tree, input, mid+1, ei, 2*id+1); 35 | 36 | tree[id].sum = tree[2*id].sum + tree[2*id+1].sum; 37 | tree[id].preSum = std::max(tree[2*id].preSum, tree[2*id].sum + tree[2*id+1].preSum); 38 | tree[id].sufSum = std::max(tree[2*id+1].sufSum, tree[2*id+1].sum + tree[2*id].sufSum); 39 | tree[id].maxSum = max(tree[2*id].maxSum, tree[2*id+1].maxSum, tree[2*id].sum + tree[2*id+1].preSum, tree[2*id+1].sum + tree[2*id].sufSum, tree[2*id].sufSum + tree[2*id+1].preSum); 40 | } 41 | 42 | node query(node *tree, ll si, ll ei, ll id, ll left, ll right){ 43 | if(si > right || ei < left){ 44 | return node(INT_MIN, INT_MIN, INT_MIN, INT_MIN); 45 | } 46 | else if(si >= left && ei <= right){ 47 | return tree[id]; 48 | } 49 | 50 | ll mid = (si+ei)/2; 51 | node a = query(tree, si, mid, 2*id, left, right); 52 | node b = query(tree, mid+1, ei, 2*id+1, left, right); 53 | node answer; 54 | answer.sum = a.sum + b.sum; 55 | answer.preSum = std::max(a.preSum, a.sum + b.preSum); 56 | answer.sufSum = std::max(b.sufSum, b.sum + a.sufSum); 57 | answer.maxSum = max(a.maxSum, b.maxSum, a.sum + b.preSum, b.sum + a.sufSum, a.sufSum + b.preSum); 58 | return answer; 59 | } 60 | 61 | int main(){ 62 | ll n; 63 | scanf("%lld", &n); 64 | 65 | ll *input = new ll[n]; 66 | for(ll i = 0; i < n; i++) scanf("%lld", input+i); 67 | 68 | node *tree = new node[4*n]; 69 | buildTree(tree, input, 0, n-1, 1); 70 | 71 | ll q; 72 | scanf("%lld", &q); 73 | ll x, y; 74 | while(q--){ 75 | scanf("%lld%lld", &x, &y); 76 | printf("%lld\n", query(tree, 0, n-1, 1, x-1, y-1).maxSum); 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /Advanced Graphs/dominos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | typedef pair pll; 14 | typedef unordered_set useti; 15 | 16 | #define uset unordered_set 17 | #define it iterator 18 | #define mp make_pair 19 | #define pb push_back 20 | #define all(x) (x).begin(), (x).end() 21 | #define f first 22 | #define s second 23 | #define MOD 1000000007 24 | 25 | void dfs(vector **graph, int source, bool *isVisited, stack &s){ 26 | isVisited[source] = true; 27 | for(int i = 0; i < graph[source]->size(); i++){ 28 | int v = graph[source]->at(i); 29 | if(!isVisited[v]){ 30 | dfs(graph, v, isVisited, s); 31 | } 32 | } 33 | 34 | s.push(source); 35 | } 36 | 37 | void dfs2(vector **graph, int source, bool *isVisited){ 38 | isVisited[source] = true; 39 | 40 | for(int i = 0; i < graph[source]->size(); i++){ 41 | int v = graph[source]->at(i); 42 | if(!isVisited[v]){ 43 | dfs2(graph, v, isVisited); 44 | } 45 | } 46 | } 47 | 48 | void kosaraju(vector **graph, int n){ 49 | bool *isVisited = new bool[n]; 50 | for(int i = 0; i < n; i++) isVisited[i] = false; 51 | 52 | stack s; 53 | for(int i = 0; i < n; i++){ 54 | if(!isVisited[i]){ 55 | dfs(graph, i, isVisited, s); 56 | } 57 | } 58 | 59 | int count = 0; 60 | for(int i = 0; i < n; i++) isVisited[i] = false; 61 | while(!s.empty()){ 62 | int v = s.top(); 63 | s.pop(); 64 | if(!isVisited[v]){ 65 | count++; 66 | dfs2(graph, v, isVisited); 67 | } 68 | } 69 | 70 | cout << count << endl; 71 | } 72 | 73 | int main(){ 74 | ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); 75 | 76 | int t; 77 | cin >> t; 78 | int n, m; 79 | while(t--){ 80 | cin >> n >> m; 81 | 82 | vector **graph = new vector *[n]; 83 | for(int i = 0; i < n; i++) graph[i] = new vector; 84 | 85 | int u, v; 86 | for(int i = 0; i < m; i++){ 87 | cin >> u >> v; 88 | graph[u-1]->pb(v-1); 89 | } 90 | 91 | kosaraju(graph, n); 92 | } 93 | } 94 | -------------------------------------------------------------------------------- /Test 2/freeDays.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | 14 | #define it iterator 15 | #define mp make_pair 16 | #define pb push_back 17 | #define all(x) (x).begin(), (x).end() 18 | 19 | // 0 means rest 20 | // 1 means sports complex 21 | // 2 means contest 22 | int main(){ 23 | int n; 24 | cin >> n; 25 | 26 | int *input = new int [n]; 27 | for(int i = 0; i < n; i++) cin >> input[i]; 28 | 29 | int **dp = new int *[n]; 30 | for(int i = 0; i < n; i++){ 31 | dp[i] = new int[3]; 32 | for(int j = 0; j < 3; j++) dp[i][j] = 101; 33 | } 34 | 35 | if(input[0] == 0){ 36 | dp[0][0] = 1; 37 | } 38 | else if(input[0] == 1){ 39 | dp[0][0] = 1; 40 | dp[0][2] = 0; 41 | } 42 | else if(input[0] == 2){ 43 | dp[0][0] = 1; 44 | dp[0][1] = 0; 45 | } 46 | else{ 47 | dp[0][0] = 1; 48 | dp[0][1] = 0; 49 | dp[0][2] = 0; 50 | } 51 | 52 | for(int i = 1; i < n; i++){ 53 | if(input[i] == 0){ 54 | for(int j = 0; j < 3; j++) dp[i][0] = min(dp[i-1][j]+1, dp[i][0]); 55 | } 56 | else if(input[i] == 1){ 57 | for(int j = 0; j < 3; j++) dp[i][0] = min(dp[i-1][j]+1, dp[i][0]); 58 | for(int j = 0; j < 3; j++){ 59 | if(j == 2) continue; 60 | dp[i][2] = min(dp[i][2], dp[i-1][j]); 61 | } 62 | } 63 | else if(input[i] == 2){ 64 | for(int j = 0; j < 3; j++) dp[i][0] = min(dp[i-1][j]+1, dp[i][0]); 65 | for(int j = 0; j < 3; j++){ 66 | if(j == 1) continue; 67 | dp[i][1] = min(dp[i][1], dp[i-1][j]); 68 | } 69 | } 70 | else{ 71 | for(int j = 0; j < 3; j++) dp[i][0] = min(dp[i-1][j]+1, dp[i][0]); 72 | for(int j = 0; j < 3; j++){ 73 | if(j == 2) continue; 74 | dp[i][2] = min(dp[i][2], dp[i-1][j]); 75 | } 76 | for(int j = 0; j < 3; j++){ 77 | if(j == 1) continue; 78 | dp[i][1] = min(dp[i][1], dp[i-1][j]); 79 | } 80 | } 81 | } 82 | 83 | int minRest = 101; 84 | for(int i = 0; i < 3; i++) minRest = min(minRest, dp[n-1][i]); 85 | cout << minRest << endl; 86 | } 87 | -------------------------------------------------------------------------------- /Advanced Graphs/permutationSwaps.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void dfs(vector *graph, int start, bool *isVisited, unordered_set *part){ 5 | isVisited[start] = true; 6 | part->insert(start); 7 | 8 | for(int i = 0; i < graph[start].size(); i++){ 9 | int next = graph[start][i]; 10 | if(!isVisited[next]){ 11 | dfs(graph, next, isVisited, part); 12 | } 13 | } 14 | } 15 | 16 | unordered_set< unordered_set *> *getComponent(vector *graph, int n){ 17 | bool *isVisited = new bool[n]; 18 | for(int i = 0; i < n; i++) isVisited[i] = false; 19 | 20 | unordered_set< unordered_set * > *component = new unordered_set< unordered_set * >(); 21 | for(int i = 0; i < n; i++){ 22 | if(!isVisited[i]){ 23 | unordered_set *part = new unordered_set(); 24 | dfs(graph, i, isVisited, part); 25 | component->insert(part); 26 | } 27 | } 28 | 29 | return component; 30 | } 31 | 32 | int main(){ 33 | int flag; 34 | int t; 35 | cin >> t; 36 | while(t--){ 37 | flag = 1; 38 | int n, m; 39 | cin >> n >> m; 40 | 41 | int *p = new int[n]; 42 | for(int i = 0; i < n; i++){ 43 | int x; 44 | cin >> x; 45 | p[i] = x-1; 46 | } 47 | 48 | int *q = new int[n+1]; 49 | for(int i = 0; i < n; i++){ 50 | int x; 51 | cin >> x; 52 | q[i] = x-1; 53 | } 54 | 55 | vector *graph = new vector[n]; 56 | for(int i = 0; i < m; i++){ 57 | int a, b; 58 | cin >> a >> b; 59 | graph[a-1].push_back(b-1); 60 | graph[b-1].push_back(a-1); 61 | } 62 | 63 | unordered_set< unordered_set * > *component = getComponent(graph, n); 64 | 65 | // for(unordered_set< unordered_set * >::iterator i = component->begin(); i != component->end(); i++){ 66 | // for(unordered_set::iterator j = (*i)->begin(); j != (*i)->end(); j++){ 67 | // cout << (*j)+1 << " "; 68 | // } 69 | // cout << endl; 70 | // } 71 | 72 | for(unordered_set< unordered_set * >::iterator i = component->begin(); i != component->end(); i++){ 73 | set setA; 74 | set setB; 75 | for(unordered_set::iterator j = (*i)->begin(); j != (*i)->end(); j++){ 76 | setA.insert(p[*j]); 77 | setB.insert(q[*j]); 78 | } 79 | 80 | if(setA != setB){ 81 | flag = 0; 82 | cout << "NO" << endl; 83 | break; 84 | } 85 | } 86 | 87 | if(flag) cout << "YES" << endl; 88 | } 89 | } 90 | -------------------------------------------------------------------------------- /Fenwick Tree/output.txt: -------------------------------------------------------------------------------- 1 | invalid 2 | 4220 3 | invalid 4 | invalid 5 | 14 6 | 0 7 | invalid 8 | 4 9 | 3 10 | 26 11 | invalid 12 | 0 13 | 20 14 | 0 15 | 8 16 | 4 17 | 3 18 | invalid 19 | 0 20 | 20 21 | invalid 22 | 207 23 | 31 24 | 25 25 | invalid 26 | 20 27 | invalid 28 | invalid 29 | 39 30 | 10791 31 | 8 32 | 12 33 | 1 34 | 4 35 | 39 36 | 8 37 | invalid 38 | invalid 39 | 71 40 | 48 41 | 5 42 | 50 43 | 10 44 | 4 45 | 31 46 | 0 47 | 8 48 | 2 49 | 24 50 | 7 51 | 74 52 | invalid 53 | 15 54 | 19 55 | invalid 56 | 1241 57 | 2 58 | 143 59 | 61 60 | 47 61 | 78 62 | invalid 63 | invalid 64 | invalid 65 | invalid 66 | 87 67 | 2 68 | 14 69 | 8 70 | 3 71 | invalid 72 | invalid 73 | 2 74 | 17 75 | 0 76 | invalid 77 | 70 78 | 0 79 | invalid 80 | 0 81 | 5 82 | 11 83 | 101 84 | 27 85 | 38 86 | invalid 87 | 84 88 | 63 89 | 1 90 | 80 91 | invalid 92 | 97 93 | invalid 94 | 0 95 | invalid 96 | invalid 97 | 20 98 | 99 99 | 819719976 100 | 22 101 | 1 102 | 5 103 | 7 104 | 41 105 | 3 106 | 0 107 | invalid 108 | 5 109 | 3 110 | 48 111 | 1 112 | invalid 113 | invalid 114 | invalid 115 | 1 116 | 10 117 | 4 118 | 32 119 | 5 120 | 1 121 | invalid 122 | 8 123 | 0 124 | 31 125 | 0 126 | 45 127 | 5 128 | 120 129 | 42268 130 | 7 131 | 5 132 | 26 133 | 48 134 | 3 135 | 5 136 | invalid 137 | invalid 138 | 2 139 | invalid 140 | invalid 141 | 3 142 | 1 143 | invalid 144 | 3 145 | 5 146 | 25 147 | 5 148 | 67 149 | 4 150 | 3 151 | 3 152 | 335 153 | 27 154 | 96 155 | invalid 156 | 76 157 | 83 158 | 757242 159 | 3 160 | 17 161 | 1 162 | 105 163 | 710297 164 | 0 165 | 168 166 | 84 167 | invalid 168 | 3 169 | 28 170 | 171 171 | 175 172 | invalid 173 | 1 174 | 180 175 | invalid 176 | invalid 177 | 109 178 | 43 179 | 6 180 | 4 181 | 132 182 | 3 183 | 1 184 | invalid 185 | 31 186 | 1 187 | 1 188 | invalid 189 | invalid 190 | 0 191 | 195 192 | 117 193 | 97 194 | invalid 195 | 85 196 | 3 197 | invalid 198 | 73 199 | 1 200 | 0 201 | 8 202 | 116 203 | 604 204 | 32211 205 | invalid 206 | 39 207 | 3 208 | invalid 209 | 97 210 | invalid 211 | invalid 212 | invalid 213 | 2 214 | 195 215 | 212 216 | invalid 217 | 22 218 | 34 219 | 12 220 | invalid 221 | 4493003 222 | invalid 223 | 7 224 | 29 225 | 136 226 | invalid 227 | 1 228 | invalid 229 | invalid 230 | 6 231 | invalid 232 | 3 233 | 64 234 | 2 235 | 33 236 | invalid 237 | invalid 238 | 5 239 | 2 240 | invalid 241 | 122 242 | 91 243 | 29 244 | invalid 245 | 13 246 | invalid 247 | 85 248 | invalid 249 | invalid 250 | 1 251 | 1 252 | invalid 253 | 0 254 | invalid 255 | 54 256 | 8 257 | 4 258 | 38 259 | 4 260 | invalid 261 | invalid 262 | 22691043 263 | 1 264 | invalid 265 | 5 266 | 6 267 | 28 268 | 93 269 | 4 270 | 1 271 | 223 272 | 3 273 | 3 274 | 1 275 | 10 276 | 34 277 | 87 278 | invalid 279 | 4 280 | invalid 281 | 193 282 | invalid 283 | 5 284 | 3 285 | 275 286 | invalid 287 | invalid 288 | 216 289 | 36 290 | invalid 291 | 243 292 | 139 293 | invalid 294 | 4 295 | 32 296 | 140 297 | 88 298 | 202 299 | 196 300 | -------------------------------------------------------------------------------- /Fenwick Tree/myOutput.txt: -------------------------------------------------------------------------------- 1 | invalid 2 | 4220 3 | invalid 4 | invalid 5 | 14 6 | 0 7 | invalid 8 | 4 9 | 3 10 | 26 11 | invalid 12 | 0 13 | 20 14 | 0 15 | 8 16 | 4 17 | 3 18 | invalid 19 | 0 20 | 20 21 | invalid 22 | 207 23 | 31 24 | 25 25 | invalid 26 | 20 27 | invalid 28 | invalid 29 | 39 30 | 10791 31 | 8 32 | 12 33 | 1 34 | 4 35 | 39 36 | 8 37 | invalid 38 | invalid 39 | 71 40 | 48 41 | 5 42 | 50 43 | 10 44 | 4 45 | 31 46 | 0 47 | 8 48 | 2 49 | 24 50 | 7 51 | 74 52 | invalid 53 | 15 54 | 19 55 | invalid 56 | 1241 57 | 2 58 | 143 59 | 61 60 | 47 61 | 78 62 | invalid 63 | invalid 64 | invalid 65 | invalid 66 | 87 67 | 2 68 | 14 69 | 8 70 | 3 71 | invalid 72 | invalid 73 | 2 74 | 17 75 | 0 76 | invalid 77 | 70 78 | 0 79 | invalid 80 | 0 81 | 5 82 | 11 83 | 101 84 | 27 85 | 38 86 | invalid 87 | 84 88 | 63 89 | 1 90 | 80 91 | invalid 92 | 97 93 | invalid 94 | 0 95 | invalid 96 | invalid 97 | 20 98 | 99 99 | 819719976 100 | 22 101 | 1 102 | 5 103 | 7 104 | 41 105 | 3 106 | 0 107 | invalid 108 | 5 109 | 3 110 | 48 111 | 1 112 | invalid 113 | invalid 114 | invalid 115 | 1 116 | 10 117 | 4 118 | 32 119 | 5 120 | 1 121 | invalid 122 | 8 123 | 0 124 | 31 125 | 0 126 | 45 127 | 5 128 | 120 129 | 42268 130 | 7 131 | 5 132 | 26 133 | 48 134 | 3 135 | 5 136 | invalid 137 | invalid 138 | 2 139 | invalid 140 | invalid 141 | 3 142 | 1 143 | invalid 144 | 3 145 | 5 146 | 25 147 | 5 148 | 67 149 | 4 150 | 3 151 | 3 152 | 335 153 | 27 154 | 96 155 | invalid 156 | 76 157 | 83 158 | 757242 159 | 3 160 | 17 161 | 1 162 | 105 163 | 710297 164 | 0 165 | 168 166 | 84 167 | invalid 168 | 3 169 | 28 170 | 171 171 | 175 172 | invalid 173 | 1 174 | 180 175 | invalid 176 | invalid 177 | 109 178 | 43 179 | 6 180 | 4 181 | 132 182 | 3 183 | 1 184 | invalid 185 | 31 186 | 1 187 | 1 188 | invalid 189 | invalid 190 | 0 191 | 195 192 | 117 193 | 97 194 | invalid 195 | 85 196 | 3 197 | invalid 198 | 73 199 | 1 200 | 0 201 | 8 202 | 116 203 | 604 204 | 32211 205 | invalid 206 | 39 207 | 3 208 | invalid 209 | 97 210 | invalid 211 | invalid 212 | invalid 213 | 2 214 | 195 215 | 212 216 | invalid 217 | 22 218 | 34 219 | 12 220 | invalid 221 | 4493003 222 | invalid 223 | 7 224 | 29 225 | 136 226 | invalid 227 | 1 228 | invalid 229 | invalid 230 | 6 231 | invalid 232 | 3 233 | 64 234 | 2 235 | 33 236 | invalid 237 | invalid 238 | 5 239 | 2 240 | invalid 241 | 122 242 | 91 243 | 29 244 | invalid 245 | 13 246 | invalid 247 | 85 248 | invalid 249 | invalid 250 | 1 251 | 1 252 | invalid 253 | 0 254 | invalid 255 | 54 256 | 8 257 | 4 258 | 38 259 | 4 260 | invalid 261 | invalid 262 | 22691043 263 | 1 264 | invalid 265 | 5 266 | 6 267 | 28 268 | 93 269 | 4 270 | 1 271 | 223 272 | 3 273 | 3 274 | 1 275 | 10 276 | 34 277 | 87 278 | invalid 279 | 4 280 | invalid 281 | 193 282 | invalid 283 | 5 284 | 3 285 | 275 286 | invalid 287 | invalid 288 | 216 289 | 36 290 | invalid 291 | 243 292 | 139 293 | invalid 294 | 4 295 | 32 296 | 140 297 | 88 298 | 202 299 | 196 300 | -------------------------------------------------------------------------------- /Advanced Graphs/connectedHorses.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MOD 1000000007 4 | typedef long long ll; 5 | 6 | ll moveX[8] = {-2, -2, -1, 1, 2, 2, 1, -1}; 7 | ll moveY[8] = {1, -1, -2, -2, -1, 1, 2, 2}; 8 | 9 | ll dfs(ll i, ll j, vector< pair > **graph, bool **isVisited){ 10 | isVisited[i][j] = true; 11 | 12 | ll answer = 1; 13 | for(ll k = 0; k < graph[i][j].size(); k++){ 14 | ll x = graph[i][j][k].first; 15 | ll y = graph[i][j][k].second; 16 | if(!isVisited[x][y]){ 17 | answer = (answer+dfs(x, y, graph, isVisited))%MOD; 18 | } 19 | } 20 | 21 | return answer; 22 | } 23 | 24 | int main(){ 25 | ll *factorial = new ll[1000000]; 26 | factorial[1] = 1; 27 | for(ll i = 2; i < 1000000; i++) factorial[i] = (factorial[i-1]*i)%MOD; 28 | ll t; 29 | cin >> t; 30 | while(t--){ 31 | ll n, m, q; 32 | cin >> n >> m >> q; 33 | 34 | vector< pair > **graph = new vector< pair >*[n]; 35 | for(ll i = 0; i < n; i++){ 36 | graph[i] = new vector< pair >[m]; 37 | } 38 | 39 | ll **board = new ll*[n]; 40 | for(ll i = 0; i < n; i++){ 41 | board[i] = new ll[m]; 42 | for(ll j = 0; j < m; j++) board[i][j] = 0; 43 | } 44 | 45 | for(ll i = 0; i < q; i++){ 46 | ll x, y; 47 | cin >> x >> y; 48 | board[x-1][y-1] = 1; 49 | } 50 | 51 | for(ll i = 0; i < n; i++){ 52 | for(ll j = 0; j < m; j++){ 53 | // cout << i << " " << j << ": "; 54 | if(board[i][j] > 0){ 55 | // cout << i << " " << j << ": "; 56 | for(ll k = 0; k < 8; k++){ 57 | ll nextX = i+moveX[k]; 58 | ll nextY = j+moveY[k]; 59 | if(nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && board[nextX][nextY] > 0){ 60 | // cout << nextX << " " << nextY << ", "; 61 | graph[i][j].push_back({nextX, nextY}); 62 | } 63 | } 64 | // cout << endl; 65 | } 66 | // cout << endl; 67 | } 68 | } 69 | 70 | bool **isVisited = new bool*[n]; 71 | for(ll i = 0; i < n; i++){ 72 | isVisited[i] = new bool[m]; 73 | for(ll j = 0; j < m; j++) isVisited[i][j] = false; 74 | } 75 | 76 | ll product = 1; 77 | for(ll i = 0; i < n; i++){ 78 | for(ll j = 0; j < m; j++){ 79 | if(board[i][j] > 0 && !isVisited[i][j]){ 80 | ll comp = dfs(i, j, graph, isVisited); 81 | // cout << i << " " << j << " " << comp << endl; 82 | product = (product*factorial[comp])%MOD; 83 | } 84 | } 85 | } 86 | 87 | cout << product << endl; 88 | } 89 | } 90 | -------------------------------------------------------------------------------- /Segment Tree/horribleQuery.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | 14 | #define it iterator 15 | #define mp make_pair 16 | #define pb push_back 17 | #define all(x) (x).begin(), (x).end() 18 | 19 | #define MAX 100001 20 | ll tree[4*MAX], lazy[4*MAX]; 21 | 22 | void update(ll si, ll ei, ll start, ll end, ll id, ll key){ 23 | if(si > ei) return; 24 | 25 | if(lazy[id] != 0){ 26 | tree[id] += lazy[id]*(ei-si+1); 27 | 28 | if(si != ei){ 29 | lazy[2*id] += lazy[id]; 30 | lazy[2*id+1] += lazy[id]; 31 | } 32 | 33 | lazy[id] = 0; 34 | } 35 | 36 | if(start > ei || end < si) return; 37 | else if(start <= si && ei <= end){ 38 | tree[id] += key*(ei-si+1); 39 | if(si != ei){ 40 | lazy[2*id] += key; 41 | lazy[2*id+1] += key; 42 | } 43 | return; 44 | } 45 | 46 | ll mid = (si+ei)/2; 47 | update(si, mid, start, end, 2*id, key); 48 | update(mid+1, ei, start, end, 2*id+1, key); 49 | tree[id] = tree[2*id] + tree[2*id+1]; 50 | } 51 | 52 | ll query(ll si, ll ei, ll start, ll end, ll id){ 53 | if(si > ei) return 0; 54 | 55 | if(lazy[id] != 0){ 56 | tree[id] += lazy[id]*(ei-si+1); 57 | 58 | if(si != ei){ 59 | lazy[2*id] += lazy[id]; 60 | lazy[2*id+1] += lazy[id]; 61 | } 62 | 63 | lazy[id] = 0; 64 | } 65 | 66 | if(start > ei || end < si) return 0; 67 | else if(start <= si && ei <= end) return tree[id]; 68 | 69 | ll mid = (si+ei)/2; 70 | ll x = query(si, mid, start, end, 2*id); 71 | ll y = query(mid+1, ei, start, end, 2*id+1); 72 | return x+y; 73 | } 74 | 75 | void printTree(ll n){ 76 | for(ll i = 1; i < 4*n; i++) cout << tree[i] << " "; 77 | cout << endl; 78 | } 79 | 80 | void printLazy(ll n){ 81 | for(ll i = 1; i < 4*n; i++) cout << lazy[i] << " "; 82 | cout << endl; 83 | } 84 | 85 | int main(){ 86 | ll t; 87 | cin >> t; 88 | while(t--){ 89 | ll n, c; 90 | cin >> n >> c; 91 | 92 | for(ll i = 0; i < 4*MAX; i++){ 93 | tree[i] = 0; 94 | lazy[i] = 0; 95 | } 96 | 97 | ll type, start, end, key; 98 | while(c--){ 99 | cin >> type; 100 | if(type == 0){ 101 | cin >> start >> end >> key; 102 | update(0, n-1, start-1, end-1, 1, key); 103 | // printTree(n); 104 | // printLazy(n); 105 | } 106 | else{ 107 | cin >> start >> end; 108 | cout << query(0, n-1, start-1, end-1, 1) << endl; 109 | // printTree(n); 110 | // printLazy(n); 111 | } 112 | } 113 | } 114 | } 115 | -------------------------------------------------------------------------------- /Game Theory/optimalMoveInTicTacToe.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool isMovesLeft(char **board){ 5 | for(int i = 0; i < 3; i++){ 6 | for(int j = 0; j < 3; j++){ 7 | if(board[i][j] == '_') return true; 8 | } 9 | } 10 | 11 | return false; 12 | } 13 | 14 | int evaluate(char **board){ 15 | for(int i = 0; i < 3; i++){ 16 | if(board[i][0] == board[i][1] && board[i][1] == board[i][2]){ 17 | if(board[i][0] == 'x') return 10; 18 | else if(board[i][0] == 'o') return -10; 19 | } 20 | } 21 | 22 | for(int j = 0; j < 3; j++){ 23 | if(board[0][j] == board[1][j] && board[1][j] == board[2][j]){ 24 | if(board[0][j] == 'x') return 10; 25 | else if(board[0][j] == 'o') return -10; 26 | } 27 | } 28 | 29 | if(board[0][0] == board[1][1] && board[1][1] == board[2][2]){ 30 | if(board[0][0] == 'x') return 10; 31 | else if(board[0][0] == 'o') return -10; 32 | } 33 | 34 | if(board[0][2] == board[1][1] && board[1][1] == board[2][0]){ 35 | if(board[1][1] == 'x') return 10; 36 | else if(board[1][1] == 'o') return -10; 37 | } 38 | 39 | return 0; 40 | } 41 | 42 | int minimax(char **board, int depth, bool isMax){ 43 | int score = evaluate(board); 44 | 45 | if(score == 10) return score; 46 | else if(score == -10) return score; 47 | 48 | if(!isMovesLeft(board)) return 0; 49 | 50 | if(isMax){ 51 | int maxScore = INT_MIN; 52 | 53 | for(int i = 0; i < 3; i++){ 54 | for(int j = 0; j < 3; j++){ 55 | if(board[i][j] == '_'){ 56 | board[i][j] = 'x'; 57 | maxScore = max(maxScore, minimax(board, depth+1, !isMax)); 58 | board[i][j] = '_'; 59 | } 60 | } 61 | } 62 | 63 | return maxScore; 64 | } 65 | else{ 66 | int minScore = INT_MAX; 67 | 68 | for(int i = 0; i < 3; i++){ 69 | for(int j = 0; j < 3; j++){ 70 | if(board[i][j] == '_'){ 71 | board[i][j] = 'o'; 72 | minScore = min(minScore, minimax(board, depth+1, !isMax)); 73 | board[i][j] = '_'; 74 | } 75 | } 76 | } 77 | 78 | return minScore; 79 | } 80 | } 81 | 82 | void findBestMove(char **board){ 83 | int maxScore = INT_MIN; 84 | int row = -1; 85 | int col = -1; 86 | 87 | for(int i = 0; i < 3; i++){ 88 | for(int j = 0; j < 3; j++){ 89 | if(board[i][j] == '_'){ 90 | board[i][j] = 'x'; 91 | int moveScore = minimax(board, 0, false); 92 | board[i][j] = '_'; 93 | 94 | if(moveScore > maxScore){ 95 | row = i; 96 | col = j; 97 | maxScore = moveScore; 98 | } 99 | } 100 | } 101 | } 102 | 103 | // cout << row << " " << col << endl; 104 | cout << maxScore << " row: " << row << " col: " << col << endl; 105 | } 106 | 107 | int main(){ 108 | int t; 109 | cin >> t; 110 | while(t--){ 111 | char **board = new char *[3]; 112 | for(int i = 0; i < 3; i++){ 113 | board[i] = new char[3]; 114 | for(int j = 0; j < 3; j++) cin >> board[i][j]; 115 | } 116 | 117 | findBestMove(board); 118 | } 119 | } 120 | -------------------------------------------------------------------------------- /Greedy Techniques/karanAtThePG.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct friends{ 5 | int start, finish, index; 6 | 7 | friends(int s, int f, int i){ 8 | start = s; 9 | finish = f; 10 | index = i; 11 | } 12 | }; 13 | 14 | bool compare(friends a, friends b){ 15 | return a.finish < b.finish; 16 | } 17 | 18 | int main(){ 19 | int t; 20 | cin >> t; 21 | int T = t; 22 | char c; 23 | int flag; 24 | 25 | while(t--){ 26 | flag = 0; 27 | int n; 28 | cin >> n; 29 | 30 | int x, y; 31 | cin >> x >> c >> y; 32 | int inTime = 60*x+y; 33 | 34 | cin >> x >> c >> y; 35 | int wakeTime = 60*x+y; 36 | 37 | cin >> x >> c >> y; 38 | int openTime = 60*x+y; 39 | 40 | int r, s; 41 | cin >> r >> s; 42 | 43 | vector input; 44 | for(int i = 0; i < n; i++){ 45 | int h1, m1, h2, m2; 46 | cin >> h1 >> c >> m1 >> h2 >> c >> m2; 47 | input.push_back(friends(60*h1+m1, 60*h2+m2, i+1)); 48 | } 49 | 50 | int minTime = INT_MAX; 51 | int minId = -1; 52 | 53 | if(wakeTime >= openTime || openTime-wakeTime < r){ 54 | 55 | for(int i = 0; i < n; i++){ 56 | 57 | if(wakeTime+2*r+s < input[i].start){ 58 | if(wakeTime+2*r+s < inTime && wakeTime+2*r+s < minTime){ 59 | minTime = wakeTime+2*r+s; 60 | minId = i+1; 61 | } 62 | } 63 | else if(wakeTime <= input[i].finish){ 64 | if((input[i].finish)+2*r+s < inTime && (input[i].finish)+2*r+s < minTime){ 65 | minTime = (input[i].finish)+2*r+s; 66 | minId = i+1; 67 | } 68 | } 69 | else if(wakeTime+2*r+s < inTime){ 70 | if(wakeTime+2*r+s < minTime){ 71 | minTime = wakeTime+2*r+s; 72 | minId = i+1; 73 | } 74 | } 75 | 76 | } 77 | 78 | } 79 | 80 | else{ 81 | 82 | for(int i = 0; i < n; i++){ 83 | 84 | if(openTime+r+s < input[i].start){ 85 | if(openTime+r+s < inTime && openTime+r+s < minTime){ 86 | minTime = openTime+r+s; 87 | minId = i+1; 88 | } 89 | } 90 | else if(wakeTime > input[i].finish){ 91 | if(openTime+r+s < inTime && openTime+r+s < minTime){ 92 | minTime = openTime+r+s; 93 | minId = i+1; 94 | } 95 | } 96 | else if(input[i].finish <= openTime-r){ 97 | if(openTime+r+s < inTime && openTime+r+s < minTime){ 98 | minTime = openTime+r+s; 99 | minId = i+1; 100 | } 101 | } 102 | else if((input[i].finish)+2*r+s < inTime){ 103 | if((input[i].finish)+2*r+s < minTime){ 104 | minTime = (input[i].finish)+2*r+s; 105 | minId = i+1; 106 | } 107 | } 108 | 109 | } 110 | 111 | 112 | 113 | } 114 | 115 | cout << "Case " << T-t << ": " << minId << endl; 116 | 117 | } 118 | } 119 | -------------------------------------------------------------------------------- /Advanced Graphs/capitalCity.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | typedef pair pll; 14 | typedef unordered_set useti; 15 | typedef set seti; 16 | 17 | #define uset unordered_set 18 | #define it iterator 19 | #define mp make_pair 20 | #define pb push_back 21 | #define all(x) (x).begin(), (x).end() 22 | #define f first 23 | #define sec second 24 | #define MOD 1000000007 25 | 26 | int compNum[100005]; 27 | 28 | void dfs(vector **graph, int source, bool *isVisited, stack &s){ 29 | isVisited[source] = true; 30 | for(int i = 0; i < graph[source]->size(); i++){ 31 | int v = graph[source]->at(i); 32 | if(!isVisited[v]){ 33 | dfs(graph, v, isVisited, s); 34 | } 35 | } 36 | 37 | s.push(source); 38 | } 39 | 40 | void revDFS(vector **graph, int source, int cycle, bool *isVisited){ 41 | isVisited[source] = true; 42 | compNum[source] = cycle; 43 | 44 | for(int i = 0; i < graph[source]->size(); i++){ 45 | int v = graph[source]->at(i); 46 | if(!isVisited[v]){ 47 | revDFS(graph, v, cycle, isVisited); 48 | } 49 | } 50 | } 51 | 52 | int kosaraju(vector **graph, vector **revGraph, int n){ 53 | bool *isVisited = new bool[n]; 54 | for(int i = 0; i < n; i++) isVisited[i] = false; 55 | 56 | stack s; 57 | for(int i = 0; i < n; i++){ 58 | if(!isVisited[i]){ 59 | dfs(graph, i, isVisited, s); 60 | } 61 | } 62 | 63 | int cycle = 0; 64 | for(int i = 0; i < n; i++) isVisited[i] = false; 65 | while(!s.empty()){ 66 | int vertex = s.top(); 67 | s.pop(); 68 | if(!isVisited[vertex]){ 69 | revDFS(revGraph, vertex, cycle, isVisited); 70 | cycle++; 71 | } 72 | } 73 | 74 | return cycle; 75 | } 76 | 77 | int main(){ 78 | ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); 79 | 80 | int n, m; 81 | cin >> n >> m; 82 | 83 | vector **graph = new vector *[n]; 84 | for(int i = 0; i < n; i++) graph[i] = new vector; 85 | 86 | vector **revGraph = new vector *[n]; 87 | for(int i = 0; i < n; i++) revGraph[i] = new vector; 88 | 89 | int u, v; 90 | for(int i = 0; i < m; i++){ 91 | cin >> u >> v; 92 | graph[u-1]->pb(v-1); 93 | revGraph[v-1]->pb(u-1); 94 | } 95 | 96 | int cycle = kosaraju(graph, revGraph, n); 97 | 98 | int *out = new int[n]; 99 | for(int i = 0; i < n; i++) out[i] = 0; 100 | 101 | for(int i = 0; i < n; i++){ 102 | for(int j = 0; j < graph[i]->size(); j++){ 103 | int v = graph[i]->at(j); 104 | if(compNum[i] != compNum[v]) out[compNum[i]]++; 105 | } 106 | } 107 | 108 | int count = 0; 109 | for(int i = 0; i < cycle; i++){ 110 | if(out[i] == 0) count++; 111 | } 112 | 113 | if(count > 1){ 114 | cout << 0 << endl; 115 | return 0; 116 | } 117 | 118 | vector output; 119 | for(int i = 0; i < n; i++){ 120 | if(out[compNum[i]] == 0) output.pb(i); 121 | } 122 | 123 | cout << output.size() << endl; 124 | for(int i = 0; i < output.size(); i++){ 125 | cout << output[i]+1 << " "; 126 | } 127 | cout << endl; 128 | } 129 | -------------------------------------------------------------------------------- /Fenwick Tree/orderSet.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define all(x) (x)->begin(), (x)->end() 4 | 5 | void update(int *bit, int id, int value, int n){ 6 | for(; id <= n; id += id&(-id)){ 7 | bit[id] += value; 8 | } 9 | } 10 | 11 | int query(int *bit, int id){ 12 | int total = 0; 13 | for(; id > 0; id -= id&(-id)){ 14 | total += bit[id]; 15 | } 16 | return total; 17 | } 18 | 19 | int findLowerBound(vector *insert, int x){ 20 | int answer = 0; 21 | int start = 0; 22 | int end = insert->size() - 1; 23 | int mid; 24 | 25 | // cout << end << " " << insert->at(start) << " " << insert->at(end) << endl; 26 | 27 | if(x > insert->at(end)) return end; 28 | if(x <= insert->at(start)) return 0; 29 | 30 | while(start <= end){ 31 | // cout << start << " "wrong << end << endl; 32 | 33 | mid = (start+end)/2; 34 | 35 | if(insert->at(mid) < x) start = mid+1; 36 | else{ 37 | answer = mid; 38 | end = mid-1; 39 | } 40 | 41 | } 42 | 43 | // cout << answer << endl; 44 | 45 | return answer; 46 | } 47 | 48 | int main(){ 49 | int q, i; 50 | scanf("%d", &q); 51 | 52 | char *token = new char[q]; 53 | int *input = new int[q]; 54 | vector *insert = new vector; 55 | for(i = 0; i < q; i++){ 56 | scanf(" %c %d", token+i, input+i); 57 | if(token[i] == 'I') insert->push_back(input[i]); 58 | } 59 | 60 | // cout << "No Error" << endl; 61 | 62 | int n = insert->size(); 63 | sort(all(insert)); 64 | 65 | unordered_map m; 66 | for(i = 1; i <= n; i++){ 67 | if(m.find(insert->at(i-1)) == m.end()){ 68 | m[ insert->at(i-1) ] = i; 69 | } 70 | } 71 | 72 | int *bit = new int[n+1]; 73 | for(int i = 0; i <= n; i++) bit[i] = 0; 74 | 75 | // cout << "Starting outputting queries" << endl; 76 | 77 | int answer, start, end, mid, x, id; 78 | char tok; 79 | 80 | for(i = 0; i < q; i++){ 81 | tok = token[i]; 82 | x = input[i]; 83 | 84 | if(tok == 'I'){ 85 | if(query(bit, m[x]) == query(bit, m[x]-1)){ 86 | update(bit, m[x], 1, n); 87 | } 88 | // cout << "Status of BIT array: "; 89 | // for(int i = 0; i <= n; i++) cout << bit[i] << " "; 90 | // cout << endl; 91 | } 92 | else if(tok == 'D'){ 93 | if(query(bit, m[x]) != query(bit, m[x]-1)){ 94 | update(bit, m[x], -1, n); 95 | } 96 | } 97 | else if(tok == 'K'){ 98 | // int answer = find_K_Smallest(bit, insert, x, m); 99 | 100 | answer = -1; 101 | start = 0; 102 | end = insert->size()-1; 103 | mid; 104 | 105 | if(!(x <= 0 || x > m.size())){ 106 | 107 | while(start <= end){ 108 | if(start < 0 || start >= n || end < 0 || end >= n) break; 109 | 110 | mid = (start+end)/2; 111 | int q = query(bit, m[ insert->at(mid) ]); 112 | if(q == x){ 113 | if(q != query(bit, m[insert->at(mid)]-1)){ 114 | answer = insert->at(mid); 115 | break; 116 | } 117 | else end = mid-1; 118 | } 119 | else if(q < x) start = mid+1; 120 | else end = mid-1; 121 | } 122 | 123 | } 124 | 125 | if(answer != -1) printf("%d\n", answer); 126 | else printf("invalid\n"); 127 | } 128 | else if(tok == 'C'){ 129 | id = findLowerBound(insert, x); 130 | // cout << "Lower Bound element is: " << insert->at(id) << endl; 131 | if(id == 0) printf("0\n"); 132 | else{ 133 | id--; 134 | printf("%d\n", query(bit, m[ insert->at(id) ])); 135 | } 136 | } 137 | } 138 | } 139 | -------------------------------------------------------------------------------- /Advanced Graphs/spaceSmugglers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | typedef pair pll; 14 | 15 | #define it iterator 16 | #define mp make_pair 17 | #define pb push_back 18 | #define all(x) (x).begin(), (x).end() 19 | #define f first 20 | #define s second 21 | #define MOD 1000000007 22 | 23 | struct node{ 24 | ll vertex; 25 | ll weight; 26 | node *next; 27 | }; 28 | 29 | struct adjList{ 30 | node *head; 31 | }; 32 | 33 | struct graph{ 34 | ll num; 35 | adjList *array; 36 | }; 37 | 38 | struct heapNode{ 39 | ll vertex; 40 | ll weight; 41 | }; 42 | 43 | struct heap{ 44 | ll size; 45 | ll capacity; 46 | ll *pos; 47 | heapNode **array; 48 | }; 49 | 50 | node *createNode(ll v, ll w){ 51 | node *newNode = new node; 52 | newNode->vertex = v; 53 | newNode->weight = w; 54 | newNode->next = NULL; 55 | return newNode; 56 | } 57 | 58 | graph *createGraph(ll n){ 59 | graph *newGraph = new graph; 60 | newGraph->num = n; 61 | newGraph->array = new adjList[n]; 62 | for(ll i = 0; i < n; i++){ 63 | newGraph->array[i].head = NULL; 64 | } 65 | 66 | return newGraph; 67 | } 68 | 69 | void addEdge(graph *newGraph, ll source, ll dest, ll weight){ 70 | node *newNode = createNode(dest, weight); 71 | newNode->next = newGraph->array[source].head; 72 | newGraph->array[source].head = newNode; 73 | } 74 | 75 | heapNode *createHeapNode(ll v, ll w){ 76 | heapNode *newNode = new heapNode; 77 | newNode->vertex = v; 78 | newNode->weight = w; 79 | return newNode; 80 | } 81 | 82 | heap *createHeap(ll c){ 83 | heap *newHeap = new heap; 84 | newHeap->pos = new ll[c]; 85 | newHeap->size = 0; 86 | newHeap->capacity = c; 87 | newHeap->array = new heapNode *[c]; 88 | return newHeap; 89 | } 90 | 91 | void swapHeapNode(heapNode **a, heapNode **b){ 92 | heapNode *temp = *a; 93 | *a = *b; 94 | *b = temp; 95 | } 96 | 97 | void minHeapify(heap *minHeap, ll id){ 98 | ll smallest, left, right; 99 | smallest = id; 100 | left = 2*id+1; 101 | right = 2*id+2; 102 | 103 | if(left < minHeap->size && minHeap->array[left]->weight < minHeap->array[smallest]->weight){ 104 | smallest = left; 105 | } 106 | 107 | if(right < minHeap->size && minHeap->array[right]->weight < minHeap->array[smallest]->weight){ 108 | smallest = right; 109 | } 110 | 111 | if(smallest != id){ 112 | heapNode *smallestNode = minHeap->array[smallest]; 113 | heapNode *idNode = minHeap->array[id]; 114 | 115 | minHeap->pos[smallestNode->vertex] = id; 116 | minHeap->pos[idNode->vertex] = smallest; 117 | 118 | swapHeapNode(&minHeap->array[smallest], &minHeap->array[id]); 119 | minHeapify(minHeap, smallest); 120 | } 121 | } 122 | 123 | bool isEmpty(heap *newHeap){ 124 | return newHeap->size == 0; 125 | } 126 | 127 | heapNode *extractMin(heap *minHeap){ 128 | if(isEmpty(minHeap)) return NULL; 129 | 130 | heapNode *root = minHeap->array[0]; 131 | heapNode *lastNode = minHeap->array[minHeap->size - 1]; 132 | minHeap->array[0] = lastNode; 133 | 134 | minHeap->pos[root->vertex] = minHeap->size - 1; 135 | minHeap->pos[lastNode->vertex] = 0; 136 | 137 | --minHeap->size; 138 | minHeapify(minHeap, 0); 139 | 140 | return root; 141 | } 142 | 143 | void decreaseKey(heap *minHeap, ll v, ll w){ 144 | ll i = minHeap->pos[v]; 145 | minHeap->array[i]->weight = w; 146 | 147 | while(i && minHeap->array[i]->weight < minHeap->array[(i-1)/2]->weight){ 148 | minHeap->pos[minHeap->array[i]->vertex] = (i-1)/2; 149 | minHeap->pos[minHeap->array[(i-1)/2]->vertex] = i; 150 | swapHeapNode(&minHeap->array[i], &minHeap->array[(i-1)/2]); 151 | 152 | i = (i-1)/2; 153 | } 154 | } 155 | 156 | bool isInMinHeap(heap *minHeap, ll v){ 157 | if(minHeap->pos[v] < minHeap->size) return true; 158 | else return false; 159 | } 160 | 161 | ll *djikstra(graph *newGraph, ll source){ 162 | ll n = newGraph->num; 163 | ll *distance = new ll[n]; 164 | 165 | heap *minHeap = createHeap(n); 166 | for(ll v = 0; v < n; v++){ 167 | distance[v] = INT_MAX; 168 | minHeap->array[v] = createHeapNode(v, distance[v]); 169 | minHeap->pos[v] = v; 170 | } 171 | 172 | minHeap->array[source] = createHeapNode(source, distance[source]); 173 | minHeap->pos[source] = source; 174 | distance[source] = 0; 175 | decreaseKey(minHeap, source, distance[source]); 176 | 177 | minHeap->size = n; 178 | 179 | while(!isEmpty(minHeap)){ 180 | heapNode *minHeapNode = extractMin(minHeap); 181 | ll u = minHeapNode->vertex; 182 | 183 | node *temp = newGraph->array[u].head; 184 | while(temp != NULL){ 185 | ll v = temp->vertex; 186 | if(isInMinHeap(minHeap, v) && distance[u] != INT_MAX && temp->weight + distance[u] < distance[v]){ 187 | distance[v] = temp->weight + distance[u]; 188 | decreaseKey(minHeap, v, distance[v]); 189 | } 190 | temp = temp->next; 191 | } 192 | } 193 | 194 | return distance; 195 | } 196 | 197 | int main(){ 198 | ll n, m, s, t, i, w; 199 | scanf("%lld%lld%lld%lld", &n, &m, &s, &t); 200 | s--; 201 | t--; 202 | 203 | graph *newGraph = createGraph(n); 204 | graph *revGraph = createGraph(n); 205 | 206 | ll u, v, g; 207 | for(i = 0; i < m; i++){ 208 | scanf("%lld%lld%lld", &u, &v, &g); 209 | addEdge(newGraph, u-1, v-1, g); 210 | addEdge(revGraph, v-1, u-1, g); 211 | } 212 | 213 | ll *sToV = djikstra(newGraph, s); 214 | ll *vToS = djikstra(revGraph, s); 215 | ll *vToT = djikstra(revGraph, t); 216 | ll *tToV = djikstra(newGraph, t); 217 | 218 | ll minTime = INT_MAX; 219 | for(w = 0; w < n; w++){ 220 | if(w == s || w == t) continue; 221 | if(sToV[w]+vToT[w]+tToV[w]+vToS[w] < minTime){ 222 | minTime = sToV[w]+vToT[w]+tToV[w]+vToS[w]; 223 | } 224 | } 225 | 226 | if(minTime == INT_MAX) cout << -1 << endl; 227 | else cout << minTime << endl; 228 | } 229 | -------------------------------------------------------------------------------- /Segment Tree/sumOfSquares.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef unordered_map umapii; 6 | typedef unordered_map umapib; 7 | typedef unordered_map umapsi; 8 | typedef unordered_map umapss; 9 | typedef map mapsi; 10 | typedef map, int> mappiii; 11 | typedef map mapii; 12 | typedef pair pii; 13 | 14 | #define it iterator 15 | #define mp make_pair 16 | #define pb push_back 17 | #define all(x) (x).begin(), (x).end() 18 | 19 | #define MAX 100001 20 | 21 | struct node{ 22 | ll sumSquares, sum; 23 | }; 24 | 25 | // Type 1 for increment 26 | // Type 2 for change 27 | struct lazyNode{ 28 | ll key, type; 29 | }; 30 | 31 | node tree[4*MAX]; 32 | lazyNode lazy[4*MAX]; 33 | 34 | void update(ll si, ll ei, ll start, ll end, ll id, ll val, ll choice){ 35 | if(si > ei) return; 36 | 37 | if(lazy[id].type != 0){ 38 | if(lazy[id].type == 1){ 39 | tree[id].sumSquares += 2*(lazy[id].key)*(tree[id].sum); 40 | tree[id].sumSquares += (lazy[id].key)*(lazy[id].key)*(ei-si+1); 41 | tree[id].sum += (lazy[id].key)*(ei-si+1); 42 | 43 | if(si != ei){ 44 | lazy[2*id].type = lazy[2*id].type == 2 ? 2 : 1; 45 | lazy[2*id].key += lazy[id].key; 46 | lazy[2*id+1].type = lazy[2*id].type == 2 ? 2 : 1; 47 | lazy[2*id+1].key += lazy[id].key; 48 | } 49 | } 50 | else if(lazy[id].type == 2){ 51 | tree[id].sumSquares = (lazy[id].key)*(lazy[id].key)*(ei-si+1); 52 | tree[id].sum = (lazy[id].key)*(ei-si+1); 53 | 54 | if(si != ei){ 55 | lazy[2*id].type = 2; 56 | lazy[2*id].key = lazy[id].key; 57 | lazy[2*id+1].type = 2; 58 | lazy[2*id+1].key = lazy[id].key; 59 | } 60 | } 61 | 62 | lazy[id].key = 0; 63 | lazy[id].type = 0; 64 | } 65 | 66 | if(start > ei || end < si) return; 67 | else if(start <= si && ei <= end){ 68 | if(choice == 1){ 69 | tree[id].sumSquares += 2*val*(tree[id].sum); 70 | tree[id].sumSquares += val*val*(ei-si+1); 71 | tree[id].sum += val*(ei-si+1); 72 | 73 | if(si != ei){ 74 | lazy[2*id].type = lazy[2*id].type == 2 ? 2 : 1; 75 | lazy[2*id].key += val; 76 | lazy[2*id+1].type = lazy[2*id].type == 2 ? 2 : 1; 77 | lazy[2*id+1].key += val; 78 | } 79 | } 80 | else if(choice == 2){ 81 | tree[id].sumSquares = val*val*(ei-si+1); 82 | tree[id].sum = val*(ei-si+1); 83 | 84 | if(si != ei){ 85 | lazy[2*id].type = 2; 86 | lazy[2*id].key = val; 87 | lazy[2*id+1].type = 2; 88 | lazy[2*id+1].key = val; 89 | } 90 | } 91 | 92 | return; 93 | } 94 | 95 | ll mid = (si+ei)/2; 96 | update(si, mid, start, end, 2*id, val, choice); 97 | update(mid+1, ei, start, end, 2*id+1, val, choice); 98 | tree[id].sumSquares = tree[2*id].sumSquares + tree[2*id+1].sumSquares; 99 | tree[id].sum = tree[2*id].sum + tree[2*id+1].sum; 100 | } 101 | 102 | ll query(ll si, ll ei, ll start, ll end, ll id){ 103 | if(si > ei) return 0; 104 | 105 | if(lazy[id].type != 0){ 106 | if(lazy[id].type == 1){ 107 | tree[id].sumSquares += 2*(lazy[id].key)*(tree[id].sum); 108 | tree[id].sumSquares += (lazy[id].key)*(lazy[id].key)*(ei-si+1); 109 | tree[id].sum += (lazy[id].key)*(ei-si+1); 110 | 111 | if(si != ei){ 112 | lazy[2*id].type = lazy[2*id].type == 2 ? 2 : 1; 113 | lazy[2*id].key += lazy[id].key; 114 | lazy[2*id+1].type = lazy[2*id].type == 2 ? 2 : 1; 115 | lazy[2*id+1].key += lazy[id].key; 116 | } 117 | } 118 | else if(lazy[id].type == 2){ 119 | tree[id].sumSquares = (lazy[id].key)*(lazy[id].key)*(ei-si+1); 120 | tree[id].sum = (lazy[id].key)*(ei-si+1); 121 | 122 | if(si != ei){ 123 | lazy[2*id].type = 2; 124 | lazy[2*id].key = lazy[id].key; 125 | lazy[2*id+1].type = 2; 126 | lazy[2*id+1].key = lazy[id].key; 127 | } 128 | } 129 | 130 | lazy[id].key = 0; 131 | lazy[id].type = 0; 132 | } 133 | 134 | if(start > ei || end < si) return 0; 135 | else if(start <= si && ei <= end) return tree[id].sumSquares; 136 | 137 | ll mid = (si+ei)/2; 138 | ll x = query(si, mid, start, end, 2*id); 139 | ll y = query(mid+1, ei, start, end, 2*id+1); 140 | return x+y; 141 | } 142 | 143 | void printTree(ll n){ 144 | for(ll i = 0; i < 3*n; i++){ 145 | cout << tree[i].sumSquares << " " << tree[i].sum << ", "; 146 | } 147 | cout << endl; 148 | } 149 | 150 | void printLazy(ll n){ 151 | for(ll i = 0; i < 3*n; i++){ 152 | cout << lazy[i].key << " " << lazy[i].type << ", "; 153 | } 154 | cout << endl; 155 | } 156 | 157 | int main(){ 158 | ll t, n, q, val, choice, start, end; 159 | cin >> t; 160 | for(ll j = 0; j < t; j++){ 161 | cout << "Case " << j+1 << ":\n"; 162 | 163 | for(ll i = 0; i < 4*MAX; i++){ 164 | tree[i].sumSquares = 0; 165 | tree[i].sum = 0; 166 | lazy[i].key = 0; 167 | lazy[i].type = 0; 168 | } 169 | 170 | cin >> n >> q; 171 | for(ll i = 0; i < n; i++){ 172 | cin >> val; 173 | update(0, n-1, i, i, 1, val, 1); 174 | } 175 | 176 | while(q--){ 177 | cin >> choice; 178 | if(choice == 2){ 179 | cin >> start >> end; 180 | cout << query(0, n-1, start-1, end-1, 1) << endl; 181 | // printTree(n); 182 | // printLazy(n); 183 | } 184 | else if(choice == 0){ 185 | cin >> start >> end >> val; 186 | update(0, n-1, start-1, end-1, 1, val, 2); 187 | // printTree(n); 188 | // printLazy(n); 189 | } 190 | else if(choice == 1){ 191 | cin >> start >> end >> val; 192 | update(0, n-1, start-1, end-1, 1, val, 1); 193 | // printTree(n); 194 | // printLazy(n); 195 | } 196 | } 197 | } 198 | } 199 | -------------------------------------------------------------------------------- /Fenwick Tree/input.txt: -------------------------------------------------------------------------------- 1 | 1000 2 | I 4220 3 | I 42 4 | K 74419 5 | I 54 6 | I 1241 7 | I 1 8 | I 1 9 | I 3 10 | I 207 11 | I 170154 12 | K 7 13 | I 10791 14 | I 4 15 | I 32 16 | I 5463540 17 | I 235 18 | I 47 19 | I 8 20 | I 4 21 | K 248 22 | I 63794 23 | I 16 24 | K 19 25 | I 83 26 | D 5 27 | I 28 28 | I 88 29 | C 308 30 | I 0 31 | I 48 32 | K 1 33 | I 2183 34 | I 39 35 | I 28 36 | K 467159645 37 | I 0 38 | C 6 39 | I 20 40 | I 22 41 | C 4 42 | C 15217947 43 | I 546879 44 | I 710297 45 | I 1416 46 | I 888 47 | I 2 48 | I 1 49 | I 6 50 | I 7535 51 | D 4 52 | K 1664 53 | I 41 54 | I 5717764 55 | C 0 56 | D 1 57 | C 441 58 | I 335 59 | I 4493003 60 | I 1756 61 | K 1 62 | I 495861 63 | I 1 64 | I 29 65 | I 3 66 | D 6 67 | K 5 68 | C 5 69 | I 1 70 | I 2 71 | D 1691 72 | I 3170011 73 | I 16 74 | D 76 75 | D 2 76 | C 5 77 | K 41 78 | K 1 79 | I 427588 80 | I 170 81 | I 245 82 | I 1 83 | I 1 84 | I 1 85 | I 10606 86 | D 5204 87 | D 2 88 | I 3 89 | K 6 90 | K 28224 91 | I 171 92 | I 955 93 | D 1 94 | I 1 95 | K 21 96 | C 4662 97 | I 337 98 | I 5 99 | I 4 100 | D 96 101 | C 309 102 | K 860 103 | D 508256883 104 | I 717 105 | I 604 106 | C 117 107 | I 372126 108 | D 1 109 | I 4 110 | K 8036 111 | I 1 112 | K 326 113 | I 5 114 | C 56750 115 | I 3 116 | I 32211 117 | I 33 118 | I 83 119 | D 6 120 | I 403826 121 | K 40 122 | I 155 123 | I 18 124 | I 563118 125 | I 84 126 | I 0 127 | I 0 128 | I 24 129 | I 654222318 130 | D 169 131 | K 6 132 | C 29 133 | I 819719976 134 | C 1 135 | I 5 136 | K 4 137 | C 1786 138 | I 506523 139 | I 2 140 | D 23 141 | I 151 142 | I 3622 143 | K 7 144 | I 1428 145 | I 5336863 146 | I 16269 147 | K 1976 148 | I 41 149 | I 1301 150 | I 2384 151 | D 907 152 | D 4 153 | I 16026 154 | I 207610946 155 | I 2369 156 | I 5 157 | K 787107 158 | I 584602 159 | D 67 160 | I 733183 161 | C 224096095 162 | I 757242 163 | I 308 164 | C 6331 165 | K 5 166 | D 308393 167 | I 12769419 168 | C 10635 169 | C 23 170 | C 4 171 | C 272 172 | I 44070 173 | D 100676064 174 | I 2 175 | K 1 176 | D 2 177 | I 1 178 | I 28 179 | I 27 180 | D 2574705 181 | I 143 182 | I 2 183 | K 6 184 | C 2 185 | I 2021 186 | I 6 187 | I 199 188 | K 12 189 | D 133 190 | C 12 191 | I 202483 192 | C 1712983 193 | D 18 194 | I 277190 195 | K 1411 196 | I 11 197 | I 184644813 198 | I 307 199 | I 88430 200 | I 6 201 | C 31 202 | D 6 203 | C 44 204 | K 12509 205 | I 22 206 | K 43 207 | I 132190 208 | C 2 209 | D 23 210 | I 2 211 | K 26 212 | I 6 213 | C 55022 214 | C 1563 215 | I 21537332 216 | C 1376705 217 | D 1 218 | K 171 219 | D 5 220 | I 12 221 | I 3322 222 | I 169 223 | K 535250 224 | I 0 225 | D 16 226 | K 249 227 | K 1008 228 | I 2121 229 | I 32 230 | D 5 231 | D 3 232 | C 219412862 233 | I 58474 234 | C 6 235 | I 42 236 | C 34 237 | I 19 238 | D 6 239 | I 308 240 | I 5 241 | I 5 242 | I 8511 243 | I 495979 244 | I 72948 245 | I 2 246 | K 4 247 | D 209 248 | C 6 249 | D 7678 250 | D 1633 251 | K 159 252 | D 157 253 | K 202 254 | D 277 255 | I 9035 256 | I 4 257 | I 2 258 | I 14601 259 | I 14717131 260 | D 7410 261 | I 25 262 | C 3 263 | I 59022 264 | I 361 265 | C 34 266 | C 0 267 | K 46305 268 | I 20 269 | I 48 270 | I 327 271 | I 41 272 | I 16194 273 | D 1324 274 | C 55714 275 | K 1 276 | I 3 277 | K 1931 278 | D 786 279 | K 1 280 | I 591407346 281 | K 5 282 | I 39 283 | K 7 284 | I 78775 285 | I 0 286 | C 37283114 287 | I 6 288 | I 19055474 289 | I 2 290 | K 15 291 | C 289 292 | I 176222 293 | K 260965219 294 | K 27 295 | I 212 296 | C 8141 297 | I 3 298 | C 1 299 | I 19 300 | I 180 301 | C 91074 302 | I 62 303 | K 322 304 | D 33 305 | C 2331749 306 | K 114 307 | K 1 308 | K 37974 309 | I 517 310 | K 147 311 | K 11 312 | I 211 313 | C 813195 314 | I 1 315 | I 14336 316 | K 115 317 | C 44 318 | I 1 319 | I 74774351 320 | I 21 321 | C 1 322 | C 5 323 | C 7 324 | D 117 325 | I 247255079 326 | D 46757 327 | D 1 328 | I 43 329 | C 213 330 | C 4 331 | D 726380 332 | I 2108879 333 | C 0 334 | K 605736 335 | K 5 336 | K 3 337 | C 341 338 | D 101 339 | C 1 340 | I 13446 341 | I 1939 342 | I 5 343 | I 482 344 | I 15 345 | K 13797 346 | I 84564 347 | D 20 348 | I 2 349 | I 2531 350 | I 2469583 351 | I 2027 352 | I 42268 353 | I 2 354 | K 790662531 355 | I 44 356 | I 1548 357 | D 3 358 | I 14277379 359 | I 17 360 | I 5 361 | I 201 362 | K 156 363 | C 2 364 | I 2058 365 | C 19 366 | D 15 367 | C 6 368 | D 284 369 | D 2514057 370 | K 18 371 | K 4 372 | I 21 373 | C 1 374 | K 238 375 | I 3 376 | K 7 377 | D 37 378 | K 1 379 | C 136 380 | D 37 381 | K 1 382 | C 251 383 | I 3 384 | I 7 385 | D 41 386 | C 6 387 | I 31 388 | I 281999047 389 | I 26012 390 | I 2 391 | I 211 392 | I 1 393 | I 92 394 | I 6 395 | C 3271396 396 | K 92 397 | D 6 398 | K 7 399 | I 18 400 | I 1440359 401 | I 5 402 | I 3 403 | I 22 404 | C 5 405 | I 3 406 | D 15094 407 | D 803666 408 | I 0 409 | C 47 410 | C 251 411 | C 3 412 | I 7856 413 | I 3 414 | K 6 415 | I 184 416 | I 69 417 | K 645671 418 | I 0 419 | I 17517281 420 | I 340419 421 | I 182 422 | I 267 423 | K 112274 424 | K 3 425 | I 1789 426 | I 12 427 | I 12261 428 | I 3 429 | I 1094 430 | I 6 431 | I 3 432 | I 34 433 | D 23 434 | I 1 435 | I 10223 436 | K 439706 437 | K 611 438 | I 1 439 | K 4 440 | K 2 441 | K 64523 442 | D 260 443 | I 20 444 | C 3 445 | I 60038 446 | I 14 447 | I 13035 448 | I 2262 449 | C 5 450 | I 479774299 451 | I 5 452 | I 1334 453 | I 2 454 | I 230 455 | C 34 456 | I 307 457 | C 5 458 | C 788 459 | D 38 460 | I 4306604 461 | I 44 462 | I 97601 463 | I 6 464 | I 117 465 | K 5 466 | C 3 467 | I 99286 468 | I 2967356 469 | C 3 470 | I 3 471 | I 246712 472 | K 62 473 | I 35 474 | I 4 475 | I 134 476 | C 39 477 | I 2875 478 | I 2 479 | I 94 480 | C 6169 481 | I 194 482 | I 794590310 483 | K 5820 484 | D 5 485 | I 6 486 | I 4 487 | C 1316 488 | D 4 489 | I 296 490 | I 22 491 | C 1948 492 | I 8 493 | I 4 494 | I 1 495 | D 0 496 | K 144 497 | C 4 498 | I 1 499 | I 1884 500 | D 198260116 501 | I 4 502 | I 3 503 | I 77866875 504 | C 25 505 | C 2 506 | I 0 507 | D 0 508 | I 5 509 | I 4 510 | D 37 511 | C 10950 512 | I 3 513 | I 4 514 | K 144 515 | I 1025 516 | C 0 517 | I 276 518 | C 228568408 519 | K 37 520 | I 116 521 | I 5229468 522 | I 19 523 | I 1751573 524 | I 23341996 525 | I 0 526 | I 3 527 | K 44878 528 | D 13 529 | C 3 530 | I 2 531 | C 41 532 | C 135544817 533 | I 1449 534 | D 892 535 | C 279412471 536 | I 340 537 | I 301 538 | I 2 539 | I 2 540 | D 31 541 | I 4 542 | I 142 543 | D 299 544 | K 12895 545 | I 809 546 | K 2 547 | I 36 548 | I 21 549 | C 458803246 550 | K 10659 551 | I 165131059 552 | I 15 553 | I 30 554 | K 1257 555 | D 9 556 | I 539389430 557 | D 206804381 558 | I 4 559 | C 5638 560 | I 2 561 | D 21736 562 | I 2982 563 | I 3 564 | I 32 565 | K 32 566 | I 241 567 | I 11730 568 | I 11239 569 | I 38 570 | C 6 571 | I 22 572 | I 16 573 | K 5 574 | I 11 575 | C 40232 576 | I 245 577 | I 5513 578 | I 9451 579 | I 254 580 | I 11 581 | D 10501 582 | I 28 583 | I 190305 584 | I 2 585 | C 3 586 | I 41 587 | I 2981106 588 | I 25 589 | I 44 590 | C 1 591 | I 654043 592 | D 566 593 | D 129 594 | I 143014892 595 | I 6 596 | K 283 597 | C 39 598 | I 23 599 | I 5 600 | I 22691043 601 | K 2 602 | I 20 603 | I 4 604 | D 1 605 | I 0 606 | I 2 607 | D 4 608 | C 2 609 | I 3 610 | I 0 611 | D 6 612 | K 207000691 613 | I 749 614 | I 35 615 | K 45616 616 | D 16658931 617 | D 13 618 | C 0 619 | I 0 620 | C 230890156 621 | I 6 622 | D 2207 623 | I 15836 624 | D 232767599 625 | C 7670 626 | C 1631 627 | I 3 628 | K 6344 629 | C 767 630 | I 691762 631 | I 114734 632 | D 3687316 633 | I 234 634 | C 4 635 | I 13626 636 | I 112 637 | I 1919 638 | I 827870067 639 | I 238237751 640 | K 738 641 | C 285 642 | D 10 643 | I 1188 644 | D 47 645 | C 1 646 | I 11 647 | I 3 648 | I 45 649 | I 5 650 | I 244 651 | I 17 652 | I 48 653 | C 0 654 | K 7 655 | I 2 656 | I 60 657 | D 31 658 | I 2 659 | K 48 660 | K 87 661 | I 0 662 | K 144 663 | I 97121 664 | K 333 665 | K 31 666 | D 18 667 | I 122 668 | I 232 669 | I 160775 670 | I 231 671 | I 1 672 | C 3 673 | D 1 674 | I 2170435 675 | K 14729 676 | I 13198 677 | I 5489 678 | I 44 679 | D 0 680 | I 4 681 | I 24 682 | I 14311492 683 | D 11 684 | I 5 685 | I 1849 686 | D 6 687 | C 1320 688 | K 605971 689 | K 589 690 | I 313 691 | I 1690 692 | I 1 693 | D 360 694 | I 2 695 | I 43 696 | K 1139 697 | I 29697226 698 | I 6 699 | I 44 700 | C 3 701 | I 2772 702 | I 1647 703 | I 24 704 | C 2615573 705 | I 313 706 | D 1 707 | C 28689994 708 | I 806711 709 | K 2917907 710 | K 16 711 | I 300674 712 | I 2262 713 | C 48 714 | I 137 715 | C 19 716 | I 6 717 | K 1166 718 | I 720296506 719 | I 2 720 | I 7 721 | I 37 722 | I 26633583 723 | K 203 724 | K 3845 725 | D 4 726 | K 5 727 | I 2 728 | I 43446 729 | C 40 730 | I 0 731 | D 3 732 | I 5 733 | I 4 734 | I 151 735 | C 9590 736 | I 707328 737 | I 5 738 | D 100 739 | K 8707 740 | I 10 741 | C 2 742 | K 630 743 | I 52 744 | D 6 745 | K 798603 746 | I 29 747 | I 3 748 | I 2 749 | I 0 750 | D 0 751 | C 9 752 | I 30015037 753 | I 4 754 | K 9773 755 | K 2 756 | I 47196 757 | I 28 758 | C 201 759 | I 3997315 760 | C 4 761 | C 44 762 | D 30723 763 | I 4 764 | I 330660 765 | K 7516 766 | K 321 767 | K 4 768 | I 209 769 | I 285 770 | I 36 771 | K 1 772 | I 1021 773 | I 2274 774 | K 1907675 775 | C 2183 776 | C 441 777 | C 39 778 | I 920 779 | I 25 780 | K 1627 781 | I 6168 782 | C 20 783 | I 5510956 784 | I 429793640 785 | D 2 786 | K 1738 787 | I 1 788 | D 33 789 | C 309 790 | I 363 791 | D 309 792 | I 4729 793 | I 99910 794 | I 15172 795 | D 1177 796 | I 561895 797 | K 300 798 | D 28349960 799 | D 87 800 | K 4854 801 | I 5 802 | I 19 803 | I 934 804 | C 2 805 | I 2 806 | I 5 807 | I 1008 808 | C 2 809 | I 40 810 | I 5 811 | I 3 812 | I 2 813 | K 264 814 | D 628 815 | I 7361 816 | I 5 817 | I 5 818 | D 6 819 | C 0 820 | I 495 821 | I 35701612 822 | I 4 823 | I 41 824 | K 5863 825 | C 142 826 | I 16452 827 | I 3 828 | D 76 829 | D 2472222 830 | I 461445 831 | D 492497 832 | I 37 833 | I 274 834 | I 41 835 | I 14 836 | I 33198 837 | I 54811 838 | I 10613 839 | I 106761 840 | K 7 841 | I 767039 842 | D 3 843 | I 6 844 | K 3 845 | I 115402 846 | K 30 847 | I 0 848 | I 193 849 | I 46 850 | I 0 851 | I 19 852 | K 4 853 | I 0 854 | D 5 855 | I 124 856 | K 11783 857 | I 1387131 858 | I 4 859 | K 10954 860 | K 252 861 | I 11 862 | I 0 863 | C 1 864 | I 14 865 | K 837003941 866 | I 26 867 | I 12 868 | I 316 869 | D 6 870 | C 8 871 | I 27 872 | I 338 873 | I 4 874 | D 108 875 | D 101 876 | I 6 877 | I 8785 878 | I 5 879 | I 32 880 | I 817 881 | K 6 882 | I 1731 883 | I 6 884 | C 34 885 | I 18073744 886 | I 156 887 | D 1044 888 | I 0 889 | I 0 890 | C 306 891 | I 18158 892 | I 6 893 | K 4 894 | D 2601956 895 | K 2 896 | I 1 897 | I 1206 898 | I 84606 899 | I 14 900 | I 27 901 | D 4 902 | I 0 903 | C 491975 904 | I 1 905 | I 26 906 | I 27 907 | I 4 908 | C 3 909 | I 143553320 910 | C 4 911 | I 25 912 | I 11220 913 | K 2 914 | D 3 915 | I 52730 916 | C 12 917 | I 5 918 | I 2 919 | I 1555 920 | I 3711639 921 | I 1 922 | I 48 923 | I 9583 924 | I 0 925 | K 29 926 | C 263 927 | K 330 928 | I 37 929 | I 1967 930 | D 5 931 | I 3563333 932 | I 319 933 | D 2343 934 | I 4 935 | D 27 936 | I 3 937 | D 43 938 | I 2 939 | I 2268 940 | C 4 941 | K 342 942 | I 1292 943 | C 40456 944 | I 5 945 | K 286427 946 | C 5 947 | K 4 948 | I 229703142 949 | C 24892414 950 | I 1 951 | K 4162 952 | K 18699 953 | D 1 954 | I 43 955 | I 0 956 | D 1116 957 | I 14 958 | C 116958 959 | I 30 960 | I 268 961 | I 4 962 | I 31 963 | I 4 964 | C 42 965 | K 25395401 966 | I 876 967 | C 697378 968 | I 3 969 | I 23 970 | I 4 971 | I 49 972 | D 5001315 973 | I 732674 974 | I 87128656 975 | C 1774 976 | D 30 977 | I 172909172 978 | D 2127 979 | I 0 980 | D 111235 981 | D 3 982 | I 2 983 | I 100 984 | D 34 985 | I 1812851 986 | I 6 987 | K 270727585 988 | K 3 989 | K 26 990 | I 3832802 991 | C 1908 992 | D 5 993 | K 47 994 | I 26900390 995 | I 2223 996 | C 57550 997 | C 39938 998 | I 76 999 | I 10 1000 | I 11 1001 | I 10690 1002 | --------------------------------------------------------------------------------