Merge branch 'opencodeiiita:main' into BEESA-MANISH

Author: MANISH-BEESA

.DS_Store

@@ -0,0 +1 @@
+.vscode/ 

.gitignore

@@ -0,0 +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]
+
+2. HEAP
+
+[https://www.programiz.com/cpp-programming/priority-queue]
+
+[https://www.youtube.com/watch?v=WhIcVlkZ19s&list=PL1w8k37X_6L9NXrP1D31hDTKcdAPIL0cG&index=12]
+
+
+

Problems/.DS_Store

@@ -0,0 +1,61 @@
+# PROBLEM 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**.
+
+In a regular bracket sequence (RBS), each opening bracket is paired with the corresponding closing bracket.  
+The **cost** of an RBS is defined as the **sum of distances** between all corresponding bracket pairs.
+
+For example, consider the RBS **(())()**. It has three bracket pairs:
+
+- Brackets at positions **1** and **4** → distance = **4 − 1 = 3**
+- Brackets at positions **2** and **3** → distance = **3 − 2 = 1**
+- Brackets at positions **5** and **6** → distance = **6 − 5 = 1**
+
+So, the total cost is **3 + 1 + 1 = 5**.
+
+---
+
+Unfortunately, due to data corruption, Monocarp lost all characters on **odd positions**  
+(**s₁, s₃, …, sₙ₋₁**). Only characters on **even positions** remain.
+
+For example:
+(())() → _(_)_)
+
+
+Monocarp wants to restore the string by placing brackets on odd positions such that:
+
+- The resulting string is a **valid regular bracket sequence**
+- The **total cost is minimized**
+
+It is guaranteed that at least one valid restoration exists.
+
+---
+
+## Input
+
+The first line contains a single integer **t**  
+(**1 ≤ t ≤ 5000**) — the number of test cases.
+
+For each test case:
+
+- The first line contains an even integer **n**  
+  (**2 ≤ n ≤ 2 · 10⁵**) — the length of the string.
+- The second line contains a string **s** of length **n**, where:
+  - Characters at **odd positions** are `'_'`
+  - Characters at **even positions** are `'('` or `')'`
+
+Additional constraints:
+
+- The sum of **n** over all test cases does not exceed **2 · 10⁵**
+- The string can always be restored to at least one valid RBS
+
+---
+
+## Output
+
+For each test case, print a single integer —  
+the **minimum possible cost** of a regular bracket sequence that can be obtained.
+
+
+[PROBLEM LINK](https://codeforces.com/problemset/problem/1997/C)

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

@@ -0,0 +1,88 @@
+# 🧮 Accumulator Apex
+
+**Problem Link:**  
+🔗 https://codeforces.com/problemset/problem/1912/A
+
+**Time Limit:** 3 seconds  
+**Memory Limit:** 1024 MB
+
+---
+
+## 📘 Problem Statement
+
+Allyn is playing a new strategy game called **Accumulator Apex**.
+
+In this game:
+
+- Allyn is given an initial integer value **x**, called the **accumulator**.
+- There are **k** lists of integers.
+- Allyn can make multiple turns.
+
+### 🔁 Game Rules
+
+On each turn, Allyn can:
+
+- Choose **any non-empty list**
+- Withdraw the **leftmost element** from that list
+- Add it to the accumulator **x**, **only if** the resulting value of **x** is **non-negative**
+
+Allyn may **end the game at any moment**.
+
+---
+
+## 🎯 Objective
+
+Find the **maximum possible value** of the accumulator **x** that Allyn can achieve.
+
+---
+
+### 📥 Input Format
+
+The first line contains two integers **x** and **k**:
+
+- $0 \le x \le 10^9$
+- $1 \le k \le 10^5$
+
+The next **k** lines describe the lists:
+
+- Each line starts with an integer **lᵢ** $(lᵢ \ge 1)$
+- Followed by **lᵢ** integers representing the list elements (from left to right)
+
+---
+
+### 🔢 Constraints
+
+- Each element in the lists satisfies:  
+  $|a_{ij}| \le 10^9$
+
+- The total number of elements across all lists does not exceed:  
+  $10^5$
+
+---
+
+## 📤 Output Format
+
+- Print a single integer — the **maximum possible value** of the accumulator **x**.
+
+---
+
+## 📝 Notes
+
+- Elements must be taken **from the left end** of a list.
+- You can switch between lists at any time.
+- You are **not required** to consume all elements.
+- The accumulator value must **never become negative**.
+
+---
+
+## ✅ Example (Conceptual)
+
+If at some point adding an element makes the accumulator negative, that move is **not allowed**.
+
+The optimal strategy may involve:
+- Taking positive elements early
+- Skipping lists that block progress due to large negative prefixes
+
+---
+
+## 🏁 End of Problem

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

@@ -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/q002.md

@@ -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
+*/