Merge pull request #282 from verifiedHuman18/day2-q002

Added solution to Math/day2/q002

Author: zonedoutdg

Problems/Mathematics/Day-01/sol/Ayush_Saha/Solution2.class

@@ -0,0 +1,79 @@
+// Link to Submission: https://codeforces.com/contest/1225/submission/355410192
+
+/*
+Problem Statement:
+You are given n positive integers a1, …, an, and an integer k ≥ 2.
+Count the number of pairs i, j such that 1 ≤ i < j ≤ n, and there exists an integer x such that ai ⋅ aj = x^k.
+*/
+
+/*
+Brief Explanation:
+To avoid TLE we avoid comparing each combination of elements, rather we calculate the reduced form of each element in the array.
+The reduced form of an element can be calculated as -> A = q^x * p^y... ~ q^(x % k) * p^(y %k)...
+We then get the complement i.e. Ac ~ q^((k - (x % k)) % k) * p^((k - (y % k)) % k)
+While iterating through the array, we maintain a frequency map of reduced forms.
+For each element, we count how many previously seen reduced forms equal its complement and add that to the pair count.
+*/
+
+import java.util.*;
+
+public class Solution2 {
+    static long[] reducedAndComplement(long x, int k) {
+        long rf = 1;
+        long comp = 1;
+
+        for (long p = 2; p * p <= x; p++) {
+            int count = 0;
+
+            while (x % p == 0) {
+                x /= p;
+                count++;
+            }
+
+            count %= k;
+
+            for (int i = 0; i < count; i++)
+                rf *= p;
+
+            int req = (k - count) % k;
+            for (int i = 0; i < req; i++)
+                comp *= p;
+        }
+
+        if (x > 1) {
+            rf *= x;
+            int req = (k - 1) % k;
+            for (int i = 0; i < req; i++)
+                comp *= x;
+        }
+
+        return new long[]{rf, comp};
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        HashMap<Long, Integer> freq = new HashMap<>();
+        int n = sc.nextInt();
+        int k = sc.nextInt();
+        
+        long fc = 0;
+
+        for (int i = 0; i < n; i++) {
+            long a = sc.nextLong();
+            long[] rc = reducedAndComplement(a, k);
+            long r = rc[0];
+            long c = rc[1];
+
+            fc += freq.getOrDefault(c, 0);
+
+            freq.put(r, freq.getOrDefault(r, 0) + 1);
+        }
+
+        System.out.println(fc);
+
+        sc.close();
+    }
+}
+
+// Time Complexity: O(n * sqr.root(A))
+// Space Complexity: O(n)

Problems/Mathematics/Day-01/sol/Ayush_Saha/Solution2.java

@@ -0,0 +1,61 @@
+// Link to submission: https://codeforces.com/contest/1771/submission/355440128
+
+/*
+PROBLEM STATEMENT: 
+Hossam woke up bored, so he decided to create an interesting array with his friend Hazem.
+Now, they have an array a of n positive integers, Hossam will choose a number ai and Hazem will choose a number aj.
+Count the number of interesting pairs (ai, aj) that meet all the following conditions:
+-> 1 ≤ i, j ≤ n
+-> i ≠ j
+-> The absolute difference |ai − aj| must be equal to the maximum absolute difference over all the pairs in the array.
+    More formally, |ai − aj| = max|ap − aq|, 1 ≤ p, q≤ n.
+*/
+
+/*
+Brief Explanation:
+We find the minimum and the maximum element in the entire array and count the number of ordered pairs of min and max in the array.
+We count the frequency of miminum and maximum elements and use the formula of combinatorics to compute number of pairs.
+if min != max, we have count = freqMin C 1 * freqMax C 1 * 2
+if min == max, we have count = freqMax P 2
+*/
+
+import java.util.*;
+
+public class Solution1 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner (System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            long min = 100000;
+            long max = 0;
+            long freqMin = 0;
+            long freqMax = 0;
+            int n = sc.nextInt();
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = sc.nextLong();
+                if (arr[i] < min)
+                    min = arr[i];
+                if (arr[i] > max)
+                    max = arr[i];
+            }
+            for (int i = 0; i < n; i++) {
+                if (arr[i] == min)
+                    freqMin++;
+                if (arr[i] == max)
+                    freqMax++;
+            }
+
+            long count = 0;
+            if (min == max)
+                count = freqMax * (freqMax - 1);
+            else
+                count = freqMin * freqMax * 2;
+            System.out.println(count);
+        }
+        sc.close();
+    }
+}
+
+// Time Complexity: O(n)
+// Space Complexity: O(n)

Problems/Mathematics/Day-02/sol/Ayush_Saha/Solution1.class

@@ -0,0 +1,78 @@
+// SUBMISSION LINK: https://codeforces.com/contest/1475/submission/355447020
+
+/*
+PROBLEM STATEMENT:
+Masha works in an advertising agency. In order to promote the new brand, she wants to conclude contracts with some bloggers.
+In total, Masha has connections of n different bloggers. Blogger numbered i has ai followers.
+Since Masha has a limited budget, she can only sign a contract with k different bloggers.
+Of course, Masha wants her ad to be seen by as many people as possible.
+Therefore, she must hire bloggers with the maximum total number of followers.
+Help her, find the number of ways to select k
+bloggers so that the total number of their followers is maximum possible.
+Two ways are considered different if there is at least one blogger in the first way, which is not in the second way.
+Masha believes that all bloggers have different followers (that is, there is no follower who would follow two different bloggers).
+*/
+
+/*
+Brief Explanation:
+We sort the array into descending order. We only need the first k elements.
+However there may be multiple bloggers with the least followers (in the top k), thus giving us multiple possibilities.
+We need to find combinations containing different bloggers in each case.
+Total number of bloggers with the least followers in the top k = count
+Total number of bloggers with the least followers needed to fill k = topC.
+Number of combinations = C(count, topC)
+*/
+
+import java.util.*;
+
+public class Solution2 {
+    static final int MAX = 1000;
+    static final long MOD = 1000000007;
+
+    static long[][] C = new long[MAX + 1][MAX + 1];
+
+    static void combinations() {
+        for (int i = 0; i <= MAX; i++) {
+            C[i][0] = C[i][i] = 1;
+            for (int j = 1; j < i; j++) {
+                C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
+            }
+        }
+    }
+    public static void main(String[] args) {
+        Scanner sc = new Scanner (System.in);
+        combinations();
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            int k = sc.nextInt();
+            long[] arr = new long[n];
+            int count = 0;
+            int topC = 0;
+
+            for (int i = 0; i < n; i++) {
+                arr[i] = sc.nextLong();
+            }
+
+            Arrays.sort(arr);
+
+            long mark = arr[n - k];
+
+            for (int i = n - 1; i >= 0; i--)
+            {
+                if (arr[i] == mark) {
+                    count++;
+                    if (i > n - k - 1)
+                        topC++;
+                }
+            }
+
+            System.out.println(C[count][topC]);
+        }
+        sc.close();
+    }
+}
+
+// Time Complexity = O(n log n)
+// precomputing combinations will have time complexity = O(MAX^2)
+// Space Complexity = O(MAX^2)