Add files via upload

Author: MathProgrammer

2020/Div 2/620 Div 2/Explanations/1-Trees and Queries Explanation.txt

@@ -0,0 +1,82 @@
+There is a crucial insight that we can make here.
+We can make a 'waiting' move.
+
+After we travel from a -> b, we can keep going back and forth on the same edge.
+b-> c -> b
+
+We can keep going back and forth to one of the neighbours of b.
+This way, we can make an unlimited number of moves !
+
+----
+
+Suppose we have a path of length L.
+There is a path of length (L + 2X) for every integer X.
+
+----
+
+Now, there are 3 Simple Paths from (a, b)
+
+1. a -> b
+2. a -> x -> y -> b
+3. a -> y -> x -> b
+
+----
+
+If any of these path lengths <= k and have the same parity as k,
+then we can use the required number of waiting moves to go from (a, b) and
+use exactly k moves.
+
+----
+
+We can use LCA to calculate the distance between 2 vertices.
+We can do O(N Log N) precompute and answer each query in O(Log N) time.
+
+-----
+
+int main()
+{
+    int no_of_vertices;
+    cin >> no_of_vertices;
+
+    int no_of_edges = no_of_vertices - 1;
+    for(int i = 1; i <= no_of_edges; i++)
+    {
+        int u, v;
+        cin >> u >> v;
+
+        tree[u].push_back(v);
+        tree[v].push_back(u);
+    }
+
+    depth[0] = 0;
+
+    dfs(1, 0);
+
+    precompute_parents(no_of_vertices);
+
+    int no_of_queries;
+    cin >> no_of_queries;
+
+    for(int i = 1; i <= no_of_queries; i++)
+    {
+        int x, y, a, b, k;
+        cin >> x >> y >> a >> b >> k;
+
+        int path_1 = distance(a, b);
+        int path_2 = distance(a, x) + distance(b, y) + 1;
+        int path_3 = distance(a, y) + distance(b, x) + 1;
+
+        if( (path_1 <= k && path_1%2 == k%2) ||
+            (path_2 <= k && path_2%2 == k%2) ||
+            (path_3 <= k && path_3%2 == k%2) )
+        {
+            cout << "YES\n";
+        }
+        else
+        {
+            cout << "NO\n";
+        }
+    }
+
+    return 0;
+}

2020/Div 2/620 Div 2/Explanations/Air Conditioner Explanation.txt

@@ -0,0 +1,88 @@
+We can interpret this problem geometrically and it would help greatly.
+
+Let us visualise the time on the y-axis and the temperature on the x axis.
+We are given a set of segments and we must determine if it is possible to draw
+a line that passes through each of them.
+
+Instead of keeping track of a line, we will keep track of the possible range of the line.
+Let the line always lie between [A, B] on the x axis.
+
+In the time between two events, the minimum can reduce by at most (T[i] - T[i - 1])
+and the maximum can reduce by at most (T[i] - T[i - 1])
+
+However, we have to be careful of one thing.
+
+The minimum range of the line cannot be lesser than the Left boundary of any event.
+The maximum range of the line cannot be greater than the Right boundary of any event.
+
+So at every point, we just have to update the minimum and maximum range of the line.
+We are keeping the range as large as possible at every step.
+If a line exists, it has to do so within this range.
+
+The beauty of this approach is that we don't have to find the actual line. Just knowing it's range is enough. :)
+
+-----
+
+struct customer
+{
+    int time, left, right;
+
+    customer(){}
+
+    customer(int T, int L, int R)
+    {
+        time = T; left = L; right = R;
+    }
+};
+
+int sort_by_time(customer &A, customer &B)
+{
+    if(A.time == B.time)
+    {
+        return (A.left < B.left);
+    }
+
+    return (A.time < B.time);
+}
+
+void solve()
+{
+    int no_of_customers, starting;
+    cin >> no_of_customers >> starting;
+
+    vector <customer> C(no_of_customers, customer(0, 0, 0));
+    for(int i = 0; i < no_of_customers; i++)
+    {
+        cin >> C[i].time >> C[i].left >> C[i].right;
+    }
+
+    sort(all(C), sort_by_time);
+
+    int minimum = starting, maximum = starting;
+    int possible = true;
+
+    for(int i = 0; i < no_of_customers && possible; i++)
+    {
+        if(i == 0)
+        {
+            minimum = starting - C[i].time;
+            maximum = starting + C[i].time;
+        }
+        else
+        {
+            minimum = minimum - (C[i].time - C[i - 1].time);
+            maximum = maximum + (C[i].time - C[i - 1].time);
+        }
+
+        if(minimum > C[i].right || maximum < C[i].left)
+        {
+            possible = false;
+            break;
+        }
+
+        minimum = max(minimum, C[i].left);
+        maximum = min(maximum, C[i].right);
+    }
+
+    cout << (possible ? "YES\n" : "NO\n");
+}

2020/Div 2/620 Div 2/Explanations/Longest Palindrome Explanation.txt

@@ -0,0 +1,78 @@
+Let R[S] be the reverse of string S
+
+The final palindrome looks like this
+
+S1 S2 S3 ... Sm (M)R[Sm] ... R[S3]R[S2]R[S1]
+And M is a palindrome that can be placed in the middle.
+
+The constraints are small enough that we can check every pair of strings.
+For each string S[i], we will check if it's reverse R(S[i]) is also present in the array.
+We will store all the strings in one vector and all their reverses in another vector.
+
+Suppose S[i] is the 3rd string in the list of strings we will print,
+then R(S[i]) is the 3rd last string that we need to print.
+
+Lastly, we can have at most 1 palindromic string in the middle.
+We will check if any of the strings are palindromes.
+If they are, we will use one in the middle.
+
+-----
+
+int main()
+{
+    int no_of_strings, length;
+    cin >> no_of_strings >> length;
+
+    vector <string> S(no_of_strings + 1);
+    for(int i = 1; i <= no_of_strings; i++)
+    {
+        cin >> S[i];
+    }
+
+    vector <int> strings_index;
+    vector <int> reverse_strings_index;
+    for(int i = 1; i <= no_of_strings; i++)
+    {
+        for(int j = i + 1; j <= no_of_strings; j++)
+        {
+            if(is_palindrome(S[i] + S[j]))
+            {
+                strings_index.push_back(i);
+                reverse_strings_index.push_back(j);
+            }
+        }
+    }
+
+    string middle;
+    for(int i = 1; i <= no_of_strings; i++)
+    {
+        if(is_palindrome(S[i]))
+        {
+            middle = S[i];
+        }
+    }
+
+    int final_length = strings_index.size() + (middle.size() != 0) + reverse_strings_index.size();
+
+    final_length *= length;
+
+    cout << final_length << "\n";
+
+    for(int i = 0; i < strings_index.size(); i++)
+    {
+        cout << S[strings_index[i]];
+    }
+
+    if(middle.size() != 0)
+    {
+        cout << middle;
+    }
+
+    for(int i = reverse_strings_index.size() - 1; i >= 0; i--)
+    {
+        cout << S[reverse_strings_index[i]];
+    }
+
+    cout << "\n";
+    return 0;
+}