Java Generics to Code Efficiently in Competitive Programming

Java Generics is a concept which can be used effectively in competitive programming for writing optimal and reusable code. Generics enable you to declare classes or interfaces, as well as methods with parameters of the type that can be then substituted with concrete types during the instantiation or invoking.

Commonly used functions in Competitive Programming

1. Pairs in Java

A pair is common data type used while programming that simply contains two values connected together. In Java, although there is no inbuilt Pair class in the standard library despite Java being an object oriented language, making and using the pairs is easy and very handy in competitive programming.

Filename: Pairs.java

import java.util.*;
// Generic Pair class
class Pair<K, V> {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    public K getKey() {
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
    @Override
    public String toString() {
        return "(" + key + ", " + value + ")";
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Pair<?, ?> pair = (Pair<?, ?>) o;
        if (!key.equals(pair.key)) return false;
        return value.equals(pair.value);
    }
    @Override
    public int hashCode() {
        int result = key.hashCode();
        result = 31 * result + value.hashCode();
        return result;
    }
}
public class Pairs {
    public static void main(String[] args) {
        // List to store pairs of String and Integer
        List<Pair<String, Integer>> list = new ArrayList<>();
        list.add(new Pair<>("Apple", 3));
        list.add(new Pair<>("Banana", 2));
        list.add(new Pair<>("Cherry", 1));
        // Sort the list by the integer value in the pairs
        Collections.sort(list, Comparator.comparing(Pair::getValue));
        // Print the sorted list
        for (Pair<String, Integer> pair : list) {
            System.out.println(pair);
        }
    }
}

Output:

(Cherry, 1)
(Banana, 2)
(Apple, 3)

2. Fast Exponential using Modulo

Direct computation of large powers can lead to overflow and is computationally expensive. Fast exponentiation (also known as exponentiation by squaring) is a method to compute powers quickly with a time complexity of O(logn). When combined with modulo operation, it becomes particularly useful for problems involving large numbers.

Filename: FastExponentiation.java

public class FastExponentiation {
    // Function to perform fast exponentiation with modulo
    public static long powerMod(long base, long exp, long mod) {
        if (mod == 1) return 0; // Since anything mod 1 is 0
        long result = 1;
        base = base % mod; // Handle the initial base case
        while (exp > 0) {
            // If exp is odd, multiply the base with result
            if ((exp % 2) == 1) {
                result = (result * base) % mod;
            }
            // Now exp must be even, so we halve it
            exp = exp >> 1; // Equivalent to exp /= 2
            base = (base * base) % mod; // Square the base
        }
        return result;
    }
    public static void main(String[] args) {
        long base1 = 2;
        long exp1 = 10;
        long mod1 = 1000000007; // A large prime commonly used in competitive programming
        long base2 = 5;
        long exp2 = 20;
        long mod2 = 1000000007;
        long base3 = 7;
        long exp3 = 13;
        long mod3 = 1000000007;
        System.out.println("Result 1: " + powerMod(base1, exp1, mod1)); // Expected: 1024
        System.out.println("Result 2: " + powerMod(base2, exp2, mod2)); // Expected: 953674316
        System.out.println("Result 3: " + powerMod(base3, exp3, mod3)); // Expected: 968890104
    }
}

Output:

Result 1: 1024
Result 2: 430973056
Result 3: 889009735

3. Calculating nCr Using Fermat's Little Theorem

In competitive programming, computing combinations (nCr) efficiently is crucial, especially when dealing with large numbers and modulo operations. Fermat's Little Theorem provides an elegant way to handle this efficiently.

Filename: CombinationsUsingFermat.java

public class CombinationsUsingFermat {
    static final int MOD = 1000000007;
    // Function to compute x^y under modulo MOD
    static long power(long x, long y, long p) {
        long result = 1;
        x = x % p;
        while (y > 0) {
            if ((y & 1) == 1)
                result = (result * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return result;
    }
    // Function to compute nCr % p using Fermat's Little Theorem
    static long nCrModP(int n, int r, int p) {
        if (r == 0 || r == n)
            return 1;
        long[] fact = new long[n + 1];
        fact[0] = 1;
        for (int i = 1; i <= n; i++)
            fact[i] = fact[i - 1] * i % p;
        long numerator = fact[n];
        long denominator = (fact[r] * fact[n - r]) % p;
        return (numerator * power(denominator, p - 2, p) % p) % p;
    }
    public static void main(String[] args) {
        int n = 10;
        int r = 2;
        System.out.println("Result 1: " + nCrModP(n, r, MOD));
        n = 20;
        r = 4;
        System.out.println("Result 2: " + nCrModP(n, r, MOD));
    }
}

Output:

Result 1: 45
Result 2: 4845

4. Binomial Coefficient (Iterative)

The binomial coefficient, represents the number of ways to choose k elements from a set of n elements without regard to the order of selection. It is a fundamental concept in combinatorics and has applications in probability, statistics, and various fields of mathematics.

Filename: BinomialCoefficient.java

public class BinomialCoefficient {
    // Function to compute nCr using an iterative approach
    public static long binomialCoefficient(int n, int k) {
        if (k > n - k) {
            k = n - k; // Since C(n, k) = C(n, n-k)
        }
        long result = 1;
        for (int i = 0; i < k; i++) {
            result *= (n - i);
            result /= (i + 1);
        }
        return result;
    }
    public static void main(String[] args) {
        // Test cases
        int n1 = 5, k1 = 2;
        System.out.println("Binomial Coefficient C(" + n1 + ", " + k1 + ") = " + binomialCoefficient(n1, k1));
        int n2 = 10, k2 = 3;
        System.out.println("Binomial Coefficient C(" + n2 + ", " + k2 + ") = " + binomialCoefficient(n2, k2));
        int n3 = 50, k3 = 25;
        System.out.println("Binomial Coefficient C(" + n3 + ", " + k3 + ") = " + binomialCoefficient(n3, k3));
    }
}

Output:

Binomial Coefficient C(5, 2) = 10
Binomial Coefficient C(10, 3) = 120
Binomial Coefficient C(50, 25) = 126410606437752

5. Modular Arithmetic

Modular arithmetic is a system of arithmetic for integers, where numbers "wrap around" upon reaching a certain value called the modulus. Given a positive integer n, called the modulus, two integers a and b are said to be congruent modulo n if their difference a-b is an integer multiple of n. The relationship is written as: a≡b(modn). It means that when a is divided by n, it leaves the same remainder as when b is divided by n.

Filename: ModularArithmetic.java

public class ModularArithmetic {
    // Function for modular addition
    public static int modAdd(int a, int b, int mod) {
        return (a % mod + b % mod) % mod;
    }
    // Function for modular subtraction
    public static int modSubtract(int a, int b, int mod) {
        return (a % mod - b % mod + mod) % mod;
    }
    // Function for modular multiplication
    public static int modMultiply(int a, int b, int mod) {
        return (int)((long)a * b % mod);
    }
    // Function for modular exponentiation using exponentiation by squaring
    public static long modExponentiation(long base, long exp, long mod) {
        long result = 1;
        base = base % mod;
        while (exp > 0) {
            if ((exp & 1) == 1) {
                result = (result * base) % mod;
            }
            exp = exp >> 1;
            base = (base * base) % mod;
        }
        return result;
    }
    // Function for modular inverse using Fermat's Little Theorem
    public static long modInverse(long a, long mod) {
        return modExponentiation(a, mod - 2, mod);
    }
    public static void main(String[] args) {
        int a = 1000000000;
        int b = 1000000000;
        int mod = 1000000007;
        // Demonstrate modular addition
        System.out.println("Modular Addition: " + modAdd(a, b, mod)); // Output: 999999993
        // Demonstrate modular subtraction
        System.out.println("Modular Subtraction: " + modSubtract(a, b, mod)); // Output: 0
        // Demonstrate modular multiplication
        System.out.println("Modular Multiplication: " + modMultiply(a, b, mod)); // Output: 49
        // Demonstrate modular exponentiation
        long base = 2;
        long exp = 10;
        System.out.println("Modular Exponentiation: " + modExponentiation(base, exp, mod)); // Output: 1024
        // Demonstrate modular inverse
        long c = 3;
        System.out.println("Modular Inverse: " + modInverse(c, mod)); // Output: 333333336
    }
}

Output:

Modular Addition: 999999993
Modular Subtraction: 0
Modular Multiplication: 49
Modular Exponentiation: 1024
Modular Inverse: 333333336

6. Sorting an Array

Sorting is a fundamental operation in computer science, widely used to arrange elements in a specific order, such as ascending or descending. Java provides built-in methods to sort arrays and collections efficiently. The primary methods are Arrays.sort() for arrays and Collections.sort() for collections.

Filename: SortExample.java

import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortExample {
    public static void main(String[] args) {
        // Example of Arrays.sort() with primitive types
        int[] numbers = {5, 3, 8, 1, 2, 7};
        Arrays.sort(numbers);
        System.out.println("Sorted array (primitive types): " + Arrays.toString(numbers));
        // Example of Arrays.sort() with objects
        String[] names = {"Charlie", "Alice", "Bob"};
        Arrays.sort(names);
        System.out.println("Sorted array (objects): " + Arrays.toString(names));
        // Example of Arrays.sort() with custom Comparator (sorting strings by length)
        String[] customSortedNames = {"Charlie", "Alice", "Bob"};
        Arrays.sort(customSortedNames, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return Integer.compare(s1.length(), s2.length());
            }
        });
        System.out.println("Custom sorted array by length: " + Arrays.toString(customSortedNames));
        // Example of Collections.sort() with lists
        List<Integer> numberList = new ArrayList<>();
        numberList.add(5);
        numberList.add(3);
        numberList.add(8);
        numberList.add(1);
        numberList.add(2);
        numberList.add(7);
        Collections.sort(numberList);
        System.out.println("Sorted list (primitive types): " + numberList);
        // Example of Collections.sort() with custom Comparator (sorting strings by length)
        List<String> nameList = new ArrayList<>();
        nameList.add("Charlie");
        nameList.add("Alice");
        nameList.add("Bob");
        Collections.sort(nameList, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return Integer.compare(s1.length(), s2.length());
            }
        });
        System.out.println("Custom sorted list by length: " + nameList);
    }
}

Output:

Sorted array (primitive types): [1, 2, 3, 5, 7, 8]
Sorted array (objects): [Alice, Bob, Charlie]
Custom sorted array by length: [Bob, Alice, Charlie]
Sorted list (primitive types): [1, 2, 3, 5, 7, 8]
Custom sorted list by length: [Bob, Alice, Charlie]

7. GCD and LCM

The Greatest Common Divisor (GCD) of two integers is the largest positive integer that divides both numbers without leaving a remainder. The Least Common Multiple (LCM) of two integers is the smallest positive integer that is divisible by both numbers. The product of two numbers is equal to the product of their GCD and LCM: LCM(a,b)×GCD(a,b)=a×b.

Filename: GcdLcmExample.java

public class GcdLcmExample {
    public static void main(String[] args) {
        int a = 24;
        int b = 36;
        System.out.println("GCD of " + a + " and " + b + " is: " + gcd(a, b));
        System.out.println("LCM of " + a + " and " + b + " is: " + lcm(a, b));
    }
    // Method to compute GCD (Greatest Common Divisor) using Euclidean algorithm
    private static long gcd(long a, long b) {
        // Base case: if b is 0, return a as the GCD
        if (b == 0) {
            return a;
        }
        // Recursive call: replace a with b, and b with a % b
        return gcd(b, a % b);
    }
    // Method to compute LCM (Least Common Multiple) using GCD
    static long lcm(int a, int b) {
        // LCM is calculated using the relationship: lcm(a, b) = (a / gcd(a, b)) * b
        return (a / gcd(a, b)) * b;
    }
}

Output:

GCD of 24 and 36 is: 12
LCM of 24 and 36 is: 72

8. Optimizing Nested Loops

Nested loops are common in competitive programming, especially when searching for combinations or pairs that satisfy certain conditions, such as finding pairs in an array that sum up to a specific value.

Filename: PairSumOptimized.java

import java.util.HashSet;
public class PairSumOptimized {
    public static void main(String[] args) {
        int[] array = {1, 4, 45, 6, 10, 8};
        int targetSum = 16;
        System.out.println("Pairs with sum " + targetSum + ":");
        findPairsWithSum(array, targetSum);
    }
    // Method to find pairs with sum using HashSet
    public static void findPairsWithSum(int[] array, int targetSum) {
        // HashSet to store elements as we iterate through the array
        HashSet<Integer> set = new HashSet<>();
        // Iterate through each element in the array
        for (int num : array) {
            int complement = targetSum - num;
            // Check if the complement (targetSum - num) exists in the HashSet
            if (set.contains(complement)) {
                System.out.println("(" + num + ", " + complement + ")");
            }
            // Add the current number to the HashSet
            set.add(num);
        }
    }
}

Output:

Pairs with sum 16: (10, 6

Benefits of Using Generics

1. Faster Execution

Efficient algorithms and data structures often lead to faster execution times, crucial in competitive programming where speed can determine rankings.

2. Problem-solving Flexibility

Tricks and optimizations provide multiple approaches to solve a problem, giving flexibility to choose the most suitable method based on constraints or requirements.

3. Competitive Advantage

In competitive programming, where time and correctness are crucial, using efficient tricks can give an edge over competitors by solving problems faster or handling edge cases effectively.

Next TopicJava-program-to-extract-content-from-a-pdf

← prev next →