Merge branch 'opencodeiiita:main' into DoonMad

Author: DoonMad

Problems/Data-structures/Day-04/Resources.md

@@ -1,4 +1,20 @@
+Recommended for freshers. (Only how to use them, implementation will be covered in your dsa course)
+
+COMPLETE STL
+
+video: [https://www.youtube.com/watch?v=RRVYpIET_RU]
+
+1. STACK
+
 [https://www.programiz.com/cpp-programming/stack]
+
 [https://www.youtube.com/watch?v=WK97Pj0wa7A&list=PL1w8k37X_6L9NXrP1D31hDTKcdAPIL0cG&index=10]
 
-Recommended for freshers.
+2. HEAP
+
+[https://www.programiz.com/cpp-programming/priority-queue]
+
+[https://www.youtube.com/watch?v=WhIcVlkZ19s&list=PL1w8k37X_6L9NXrP1D31hDTKcdAPIL0cG&index=12]
+
+
+

Problems/Data-structures/Day-04/sol/Aiyaan_Mahajan/Q1sol.cpp

@@ -0,0 +1,72 @@
+/*
+DAY 4
+Q1 Even Positions
+.*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+long long solve_case(string s) {
+    int n = s.size();
+
+    int fixedOpen = 0, fixedClose = 0;
+    for (char c : s) {
+        if (c == '(') fixedOpen++;
+        if (c == ')') fixedClose++;
+    }
+
+    int needOpen = n / 2 - fixedOpen;
+    int needClose = n / 2 - fixedClose;
+
+    int balance = 0;
+
+    // restore the string
+    for (int i = 0; i < n; ++i) {
+        if (s[i] == '(') balance++;
+        else if (s[i] == ')') balance--;
+        else {
+            // underscore -> choose bracket
+            if (needClose > 0 && balance > 0) {
+                s[i] = ')';
+                needClose--;
+                balance--;
+            } else {
+                s[i] = '(';
+                needOpen--;
+                balance++;
+            }
+        }
+    }
+
+    // compute cost
+    long long cost = 0;
+    stack<int> st;
+
+    for (int i = 0; i < n; ++i) {
+        if (s[i] == '(') st.push(i + 1);
+        else {
+            int openIdx = st.top(); st.pop();
+            cost += (i + 1) - openIdx;
+        }
+    }
+
+    return cost;
+}
+
+int main() {
+
+    int t; 
+    cin >> t;
+    while (t--) {
+        int n;
+        string s;
+        cin >> n >> s;
+        cout << solve_case(s) << "\n";
+    }
+    return 0;
+}
+
+//TC =O(n) and SC = O(n)
+/*
+My submission : https://codeforces.com/contest/1997/submission/355669016
+*/

Problems/Data-structures/Day-04/sol/Aiyaan_Mahajan/Q2sol.cpp

@@ -0,0 +1,100 @@
+/*
+DAY 4
+Q2 Accumulator Apex
+.*/
+/*
+We can only take elements from the left of each list, so every valid move is some prefix of a list.
+
+For each prefix we know:
+
+pref = sum of the prefix
+
+mn = minimum prefix sum while walking through it
+
+A prefix is usable only if:
+
+x + mn >= 0
+
+
+If we take it, we end with:
+
+x += pref
+
+
+We consider all prefixes from all lists and always pick the one that safely gives the most benefit.
+For each list we only keep the best prefix we have already used.
+
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Item {
+    long long pref;
+    long long minPref;
+    int idx;
+};
+
+struct Cmp {
+    bool operator()(const Item& a, const Item& b) const {
+        if (a.minPref != b.minPref) return a.minPref < b.minPref;
+        return a.pref < b.pref;
+    }
+};
+
+int main() {
+ 
+
+    long long x;
+    int k;
+    cin >> x >> k;
+
+    vector<vector<long long>> lists(k);
+    for (int i = 0; i < k; ++i) {
+        int len;
+        cin >> len;
+        lists[i].resize(len);
+        for (int j = 0; j < len; ++j) cin >> lists[i][j];
+    }
+
+    priority_queue<Item, vector<Item>, Cmp> pq;
+    vector<vector<long long>> pref(k);
+
+    for (int i = 0; i < k; ++i) {
+        long long s = 0, mn = 0;
+        pref[i].push_back(0);
+        for (auto v : lists[i]) {
+            s += v;
+            mn = min(mn, s);
+            pref[i].push_back(s);
+            pq.push({s, mn, i});
+        }
+    }
+
+    long long best = x;
+    vector<long long> taken(k, 0);
+
+    while (!pq.empty()) {
+        auto cur = pq.top();
+        pq.pop();
+
+        if (best + cur.minPref < 0) break;
+
+        if (cur.pref > taken[cur.idx]) {
+            best -= taken[cur.idx];
+            best += cur.pref;
+            taken[cur.idx] = cur.pref;
+        }
+    }
+
+    cout << best << "\n";
+    return 0;
+}
+
+
+
+
+//TC =O(Nlog(N)) and SC = O(N)
+/*
+My submission : https://codeforces.com/contest/1912/submission/355690272
+*/

Problems/Data-structures/Day-04/sol/Apoorv012/Solution1.cpp

@@ -0,0 +1,68 @@
+/*
+
+We have to find the minimum cost that we could acheive by placing ( and ) in the blank spaces. We have to make sure that () are valid.
+
+I saw the pattern, that we can set the blank to ) as long as there is atleast one open (.
+
+Time: O(n);
+Space: O(n);
+
+Submission Link: https://codeforces.com/contest/1997/submission/355679346
+
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+using ll = long long;
+
+void solve() {
+    ll n;
+    cin >> n;
+    string s;
+    cin >> s;
+
+    // cout << "n, s: " << n << " " << s << endl;
+
+    ll ans = 0;
+    stack<ll> st;
+    for (ll i = 0; i < n; i++) {
+        if (s[i] == '(') {
+            st.push(i);
+            // cout << i << " pushed (\n";
+        }
+        else if (s[i] == ')') {
+            if (st.empty()) {
+                cout << -1 << endl;
+                return;
+            }
+            ll start = st.top();
+            st.pop();
+            ans += i - start;
+            // cout << i << " poped )\n";
+        }
+        else {
+            if (st.empty()) {
+                st.push(i);
+                // cout << i << " pushed _\n";
+            }
+            else {
+                ll start = st.top();
+                st.pop();
+                ans += i - start;
+                // cout << i << " popped _\n";
+            }
+        }
+    }
+
+    cout << ans << endl;
+}
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        solve();
+        // cout << t << " done\n";
+    }
+}

Problems/Data-structures/Day-04/sol/BEESA_MANISH/Solution1.cpp

@@ -0,0 +1,41 @@
+
+//TC  - O(n) and SC - O(n)
+//Submission Link - https://codeforces.com/contest/1997/submission/355786129
+
+#include <iostream>
+#include <string>
+#include <vector>
+using namespace std;
+void solve() {
+    int n;
+    cin >> n;
+    string s;
+    cin >> s;
+    long long total_cost = 0;
+    long long current_balance = 0;
+    for (int i = 0; i < n; ++i) {
+        if (s[i] == '_') {
+            if (current_balance == 0) {
+                current_balance++;
+            } else {
+                current_balance--;
+            }
+        } else if (s[i] == '(') {
+            current_balance++;
+        } else { 
+            current_balance--;
+        }
+        total_cost += current_balance;
+    }
+
+    cout << total_cost << "\n";
+}
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        solve();
+    }
+    return 0;
+}

Problems/Data-structures/Day-04/sol/Samarth/sol1.cpp

@@ -0,0 +1,84 @@
+
+#include <bits/stdc++.h>
+#define endl '\n'
+typedef long long ll;
+
+using namespace std;
+
+/*
+PROLBLEM STATEMENT:
+Monocarp had a regular bracket sequence s of length n (n
+
+is even). He even came up with his own way to calculate its cost.
+
+He knows that in a regular bracket sequence (RBS), each opening bracket is paired up with the corresponding closing bracket. So he decided to calculate the cost of RBS as the sum of distances between pairs of corresponding bracket pairs.
+
+For example, let's look at RBS (())(). It has three pairs of brackets:
+
+    (__)__: the distance between brackets at position 1
+
+and at 4 is 4−1=3
+;
+_()___: the distance is 3−2=1
+;
+____(): the distance is 6−5=1
+
+    . 
+
+So the cost of (())() is 3+1+1=5.
+
+Unfortunately, due to data corruption, Monocarp lost all characters on odd positions s1,s3,…,sn−1
+. Only characters on even positions (s2,s4,…,sn
+
+) remain. For example, (())() turned to _(_)_).
+
+Monocarp wants to restore his RBS by placing brackets on the odd positions. But since the restored RBS may not be unique, he wants to choose one with minimum cost. It's too hard to do for Monocarp alone, so can you help him?
+
+Reminder: A regular bracket sequence is a string consisting of only brackets, such that this sequence, when inserted 1-s and +-s, gives a valid mathematical expression. For example, (), (()) or (()())() are RBS, while ), ()( or ())(() are not.
+
+
+APPROACH:
+my first thought was to just fill in the blanks not to calculate the cost so i did trial & error with few test cases and found that
+if(s[i-1]=')')then s[i]must be '(' and vice versa for min cost;
+then to calculate the cost i also found a pattern where iterating over odd indices (0 indexing) if s[i]='(' you will add 1 to ans and also increase cost of prev bracket by 2
+until you encounter '(' then you will pour the value of keeper into ans and reset value of keeper to 1;
+
+
+Time Compx:O(n);
+Space Compx:O(n);
+
+
+
+SUBMISSION LINK:
+https://codeforces.com/contest/1997/submission/355680953
+
+
+*/
+
+
+
+void solve(){
+	int n;cin>>n;string s;cin>>s;
+	ll keeper=1,sum=0;
+	for(int i=1;i<n;i+=2){
+		if(s[i]==')'){
+			sum+=keeper;
+			keeper=1;
+		}
+		else {
+			sum+=1;
+			keeper+=2;
+		}
+	}
+	cout<<sum<<endl;
+
+
+}
+
+int main(){
+    ios::sync_with_stdio(0); cin.tie(0);
+	int t;cin>>t;
+	while(t--)
+		solve();
+	
+}