Add files via upload

Author: MathProgrammer

2021/Div 2/727/Explanations/Love Song Explanation.txt.txt

@@ -0,0 +1,40 @@
+Find the frequency of each alphabet in each range. 
+The i-th alphabet contributes i x sum(i) to the whole answer
+
+-----
+
+int main()
+{
+    int length, no_of_queries;
+    string S;
+    cin >> length >> no_of_queries >> S;
+
+    const int NO_OF_ALPHABETS = 26;
+    vector <vector <int> > frequency(NO_OF_ALPHABETS, vector <int> (length + 1, 0));
+    for(int i = 1; i <= length; i++)
+    {
+        for(int alpha = 0; alpha < NO_OF_ALPHABETS; alpha++)
+        {
+            frequency[alpha][i] = frequency[alpha][i - 1];
+        }
+        frequency[S[i - 1] - 'a'][i]++;
+    }
+
+    for(int i = 1; i <= no_of_queries; i++)
+    {
+        int left, right;
+        cin >> left >> right;
+
+        long long length = 0;
+        for(int alpha = 0; alpha < NO_OF_ALPHABETS; alpha++)
+        {
+            long long frequency_here = frequency[alpha][right] - frequency[alpha][left - 1];
+
+            length += (alpha + 1)*frequency_here;
+        }
+
+        cout << length << "\n";
+    }
+
+    return 0;
+}

2021/Div 2/727/Explanations/Price Fixed Explanation.txt.txt

@@ -0,0 +1,75 @@
+Sort the items in descending order of B. 
+Each item costs the same so we want to buy as many items for cost 1 as possible. 
+
+Go through the items one by one. 
+
+Have 2 pointers L and R 
+L points to the first available element in the prefix and R to the suffix. 
+
+At each point, check if 
+
+1. We have bought enough items to avail the discount at R and buy item R at a discount
+2. If not, is it possible to partially buy the items at L and then use the discount for R 
+3. If not, buy L completely and increment L 
+
+-----
+
+int sort_by_second(pair <long long, long long> &P, pair <long long, long long> &Q)
+{
+    if(P.second == Q.second)
+    {
+        return (P.first > Q.first);
+    }
+
+    return (P.second > Q.second);
+}
+
+int main()
+{
+    int no_of_elements;
+    cin >> no_of_elements;
+
+    vector <pair <long long, long long> > A(no_of_elements + 1);
+    for(int i = 1; i <= no_of_elements; i++)
+    {
+        cin >> A[i].first >> A[i].second;
+    }
+
+    sort(A.begin() + 1, A.end(), sort_by_second);
+    /*for(int i = 1; i <= no_of_elements; i++)
+    {
+        cout << A[i].first << " " << A[i].second << "\n";
+    }*/
+
+    long long total = 0, cost = 0;
+    for(int left = 1, right = no_of_elements; left <= right; )
+    {
+        if(total >= A[right].second)
+        {
+            cost += A[right].first;
+            total += A[right].first; //cout << "Buying R = " << right << " Cost = " << cost << " Total = " << total << "\n";
+
+            right--;
+            continue;
+        }
+
+        if(total + A[left].first < A[right].second)
+        {
+            cost += 2*A[left].first;
+            total += A[left].first; //cout << "Buying L = " << left << " Cost = " << cost << " Total = " << total << "\n";
+
+            left++;
+            continue;
+        }
+
+        long long remaining_2 = A[right].second - total;
+
+        cost += 2*remaining_2;
+        total += remaining_2; //cout << "Buying L = " << left << " Cost = " << cost << " Total = " << total;
+
+        A[left].first -= remaining_2; //cout << " New Left = " << A[left].first << "\n";
+    }
+
+    cout << cost << "\n";
+    return 0;
+}

2021/Div 2/727/Explanations/Stable Groups Explanation.txt.txt

@@ -0,0 +1,60 @@
+Keep track of all differences that are > x 
+
+Put them in a priority queue and work on the smallest difference at each time. 
+
+In order to split an integer N into parts such that each of them is <= x, we need N/x - 1 cuts
+
+Check if there are enough operations to cut the current part and then cut them accordingly.
+
+It is similar to the problem Carrots for Rabbits
+-----
+
+long long ceil(long long numerator, long long denominator)
+{
+    return (numerator/denominator) + (numerator%denominator != 0);
+}
+
+int main()
+{
+    int no_of_elements;
+    long long new_additions, difference;
+    cin >> no_of_elements >> new_additions >> difference;
+
+    vector <long long> A(no_of_elements + 1);
+    for(int i = 1; i <= no_of_elements; i++)
+    {
+        cin >> A[i];
+    }
+
+    sort(all(A));
+
+    priority_queue <long long, vector <long long>, greater <long long> > PQ;
+    for(int i = 2; i <= no_of_elements; i++)
+    {
+        if(A[i] - A[i - 1] > difference)
+        {
+            PQ.push(A[i] - A[i - 1]);
+        }
+    }
+
+    while(new_additions > 0 && PQ.size() > 0)
+    {
+        long long current = PQ.top(); //cout << "Current = " << current << "\n";
+
+        long long required_new_additions = ceil(current,difference) - 1;
+
+        long long possible_additions = min(required_new_additions, new_additions);
+
+        if(possible_additions >= required_new_additions)
+        {
+            PQ.pop();
+        }
+
+        new_additions -= possible_additions; //cout << "Operations = " << new_additions << "\n";
+    }
+
+    int groups = PQ.size() + 1;
+    cout << groups << "\n";
+
+    return 0;
+}