Add files via upload

Author: MathProgrammer

2022/Contests/Div 2/792/Explanations/Rooks Defenders Explanation.txt.txt

@@ -0,0 +1,145 @@
+When a rook is placed on cell (x, y) it covers the whole row x and column y. 
+
+For every cell (x, y) in X1 < x < X and Y1 < y < Y2 to be covered, either 
+1. All the rows should be covered. 
+2. All the columns should be covered. 
+
+Suppose both these conditions are not true, then there is at least one cell (x, y) 
+such that row x and column c are not covered. 
+
+-----
+
+Maintain 2 Arrays of length N representing - 
+
+1. R[i] - Is row i covered 
+2. C[j] - Is column j covered
+
+We will update and find the sums of these ranges using segment trees. 
+
+Each query is answers in O(log n) time. 
+
+----
+
+void update(int n, int left, int right, int index, int value, int tree_index)
+{
+    if(index < left || right < index)
+    {
+        return;
+    }
+
+    if(left == right)
+    {
+        sum_tree[n][tree_index] = value;
+        //cout << (tree_index == 0 ? "Row" : "Column") << " Sum Tree [" << left << "," << right << "] = " << sum_tree[n][tree_index] << "\n";
+        return;
+    }
+
+    int mid = (left + right)/2;
+    update(LEFT(n), left, mid, index, value, tree_index);
+    update(RIGHT(n), mid + 1, right, index, value, tree_index);
+
+    sum_tree[n][tree_index] = sum_tree[LEFT(n)][tree_index] + sum_tree[RIGHT(n)][tree_index];
+    //cout << (tree_index == 0 ? "Row" : "Column") << " Sum Tree [" << left << "," << right << "] = " << sum_tree[n][tree_index] << "\n";
+}
+
+int get_sum(int n, int left, int right, int query_left, int query_right, int tree_index)
+{
+    if(query_right < left || right < query_left)
+    {
+        return 0;
+    }
+
+    if(query_left <= left && right <= query_right)
+    {
+        return sum_tree[n][tree_index];
+    }
+
+    int mid = (left + right)/2;
+    int left_sum = get_sum(LEFT(n), left, mid, query_left, query_right, tree_index);
+    int right_sum = get_sum(RIGHT(n), mid + 1, right, query_left, query_right, tree_index);
+
+    return (left_sum + right_sum);
+}
+
+int main()
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int n, no_of_queries;
+    cin >> n >> no_of_queries;
+
+    memset(sum_tree, 0, sizeof(sum_tree));
+
+    const int ROW = 0, COLUMN = 1;
+    vector <int> row_attackers(n + 1, 0), column_attackers(n + 1, 0);
+    for(int i = 1; i <= no_of_queries; i++)
+    {
+        const int ADD = 1, REMOVE = 2, RECTANGLE = 3;
+        int query;
+        cin >> query;
+
+        switch(query)
+        {
+            case ADD: {
+                            int x, y;
+                            cin >> x >> y;
+
+                            row_attackers[x]++;
+                            if(row_attackers[x] == 1)
+                            {
+                                update(1, 1, n, x, 1, ROW);
+                            }
+
+                            column_attackers[y]++;
+                            if(column_attackers[y] == 1)
+                            {
+                                update(1, 1, n, y, 1, COLUMN);
+                            }
+                      }
+                      break;
+
+            case REMOVE : {
+                                int x, y;
+                                cin >> x >> y;
+
+                                row_attackers[x]--;
+                                if(row_attackers[x] == 0)
+                                {
+                                    update(1, 1, n, x, 0, ROW);
+                                }
+
+                                column_attackers[y]--;
+                                if(column_attackers[y] == 0)
+                                {
+                                    update(1, 1, n, y, 0, COLUMN);
+                                }
+                          }
+                          break;
+
+            case RECTANGLE :{
+                                int x1, y1, x2, y2;
+                                cin >> x1 >> y1 >> x2 >> y2;
+
+                                if(x1 > x2)
+                                {
+                                    swap(x1, x2);
+                                }
+
+                                if(y1 > y2)
+                                {
+                                    swap(y1, y2);
+                                }
+
+                                int attacked_rows = get_sum(1, 1, n, x1, x2, ROW);
+                                int attacked_columns = get_sum(1, 1, n, y1, y2, COLUMN);
+                                //cout << "Rows attacked = " << attacked_rows << " Columns attacked = " << attacked_columns << "\n";
+
+                                int every_cell_attacked = ( (attacked_rows == x2 - x1 + 1) || (attacked_columns == y2 - y1 + 1) );
+                                cout << (every_cell_attacked ? "Yes" : "No") << "\n";
+                          }
+        }
+    }
+
+    return 0;
+}

2022/Contests/Div 2/792/Explanations/Stone Age Problem Explanation.txt.txt

@@ -0,0 +1,70 @@
+The trick to this problem is to keep track of time. 
+
+Keep an array T, 
+recording the time that an element was touched. 
+
+Also keep track of the last bulk update. 
+
+When doing a point update, check whether - 
+1. T[i] > last_bulk_update_time 
+
+	If yes, then the value at A[i], is A[i] 
+
+2. Else, the value at A[i] is the last bulk_update_value
+
+-----
+
+int main()
+{
+    int no_of_elements, no_of_queries;
+    cin >> no_of_elements >> no_of_queries;
+
+    vector <int> A(no_of_elements + 1);
+    for(int i = 1; i <= no_of_elements; i++)
+    {
+        cin >> A[i];
+    }
+
+    long long sum = 0;
+    for(int i = 1; i <= no_of_elements; i++)
+    {
+        sum += A[i];
+    }
+
+    int last_replace_all_time = -1, last_replace_all_value = 0;
+    vector <int> last_touched(no_of_elements + 1, 0);
+    for(int i = 1; i <= no_of_queries; i++)
+    {
+        const int REPLACE_ONE = 1, REPLACE_ALL = 2;
+        int query, index, value;
+        cin >> query;
+
+        switch(query)
+        {
+            case REPLACE_ONE: cin >> index >> value;
+                              if(last_touched[index] > last_replace_all_time)
+                              {
+                                  sum += (value - A[index]);
+                              }
+                              else
+                              {
+                                  sum += (value - last_replace_all_value);
+                              }
+
+                              A[index] = value;
+                              last_touched[index] = i;
+                              break;
+
+            case REPLACE_ALL: cin >> value;
+
+                              sum = no_of_elements*1LL*value;
+
+                              last_replace_all_value = value;
+                              last_replace_all_time = i;
+        }
+
+        cout << sum << "\n";
+    }
+
+    return 0;
+}