Solving Problem P1920: Binary Search

Problem Description

You are given an integer N and an array A of N integers. Then you receive an integer M and M queries, each query being a target integer. For each target, output 1 if it exists in A, or 0 if it does not.

Constraints

• 1 ≤ N ≤ 100,000 (Number of elements in the array)
• 1 ≤ M ≤ 100,000 (Number of queries)
• Array elements and search targets can be in the range of a 32-bit integer (−2,147,483,648 to 2,147,483,647)

Input Format

1. The first line contains an integer N, the size of the array.
2. The second line contains N integers (the elements of A).
3. The third line contains an integer M, the number of queries.
4. The next line contains M integers (each one is a target to search for in A).

Output Format

• For each of the M targets, print 1 if the target exists in the array A, otherwise print 0.

Example Input and Output

Example

Input:

5
4 1 5 2 3
5
1 3 7 9 5

Output:

1
1
0
0
1

Explanation:

• 1 is in the array → output 1
• 3 is in the array → output 1
• 7 is not in the array → output 0
• 9 is not in the array → output 0
• 5 is in the array → output 1

Concept of Binary Search

Binary search is an efficient algorithm for finding a target value within a sorted array. It repeatedly divides the search interval in half:

• Start with the entire array as the search interval.
• Compare the middle element with the target.
• If the target equals the middle element, the search is successful.
• If the target is smaller, narrow the interval to the left half.
• If the target is larger, narrow the interval to the right half.

Time Complexity

• Sorting the array: O(N log N)
• Binary search for each query: O(log N)
• Total for M queries: O(M log N)
• Overall complexity: O(N log N + M log N)

Space Complexity

• O(N): Space for the array and auxiliary data.

Approach

1. Sort the array of size N to enable binary search.
2. For each target in the M queries:
   • Use binary search to determine whether the target exists.
   • Print 1 if found, otherwise 0.

Pseudocode

BEGIN
  READ N, the size of the array
  READ array A of size N
  SORT array A

  READ M, the number of queries
  FOR each query target in M:
    SET start = 0, end = N - 1, found = false

    WHILE start <= end:
      SET mid = (start + end) / 2
      IF A[mid] == target:
        found = true
        BREAK
      ELSE IF A[mid] < target:
        start = mid + 1
      ELSE:
        end = mid - 1

    PRINT 1 if found, otherwise 0
END

Java Implementation

package search;

import java.util.*;

public class P1920 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 1. Read N and the array A
        int N = sc.nextInt();
        int[] A = new int[N];
        for(int i = 0; i < N; i++) {
            A[i] = sc.nextInt();
        }

        // 2. Sort the array for efficient binary search
        Arrays.sort(A);

        // 3. Read M and process each query
        int M = sc.nextInt();
        for(int i = 0; i < M; i++) {
            int target = sc.nextInt();
            boolean found = false;
            int start = 0;
            int end = N - 1;

            // 4. Perform binary search
            while(start <= end) {
                int mid = (start + end) / 2;
                if(A[mid] == target) {
                    found = true;
                    break;
                }
                if(A[mid] < target) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }

            // 5. Print result for this query
            System.out.println(found ? 1 : 0);
        }

        sc.close();
    }
}

Explanation of the Code

1. Reading Input:
   • The size of the array (N) and its elements are read into an integer array A.
   • The size of the query set (M) is read, followed by the (M) target values.
2. Sorting the Array:
   • Sorting ensures that binary search can be applied. This step takes O(N log N).
3. Binary Search for Each Query:
   • For each target, the algorithm performs binary search over A.
   • A start pointer begins at the first element, and an end pointer begins at the last element.
   • The midpoint mid is calculated, and its value is compared to the target.
   • Depending on the comparison, the search interval is halved until the target is found or the interval is empty.
4. Output Results:
   • If the target is found, 1 is printed.
   • Otherwise, 0 is printed.

Example Walkthrough

Input:

5
4 1 5 2 3
5
1 3 7 9 5

Execution:

1. Sorting the Array:
   • Input array: [4, 1, 5, 2, 3]
   • Sorted array: [1, 2, 3, 4, 5]
2. Binary Search for Each Query:
   • Query 1: Target = 1 → Found → Print 1
   • Query 2: Target = 3 → Found → Print 1
   • Query 3: Target = 7 → Not Found → Print 0
   • Query 4: Target = 9 → Not Found → Print 0
   • Query 5: Target = 5 → Found → Print 1

Output:

1
1
0
0
1

Links

• Problem Link: Baekjoon P1920
• Graph Traversal Reference: Wikipedia

Solving Problem P11724: Search! Counting Connected Components in an Undirected Graph

Problem Description

Given an undirected graph with N vertices and M edges, the task is to calculate the number of connected components in the graph. A connected component is a subset of vertices such that there is a path between any two vertices within the subset, and the subset is not connected to any other vertices outside of it.

Constraints

• 1 ≤ N ≤ 1,000
• 0 ≤ M ≤ N × (N - 1) / 2
• Each edge is given as two integers, representing vertices u and v.

Input Format

1. The first line contains two integers N (number of vertices) and M (number of edges).
2. The next M lines contain two integers u and v, representing an undirected edge between vertices u and v.

Output Format

Print a single integer, the number of connected components in the graph.

Example Input and Output

Example 1

Input

6 5
1 2
2 5
5 1
3 4
4 6

Output

2

Explanation

• There are two connected components
  • Component 1: {1, 2, 5}
  • Component 2: {3, 4, 6}

Example 2

Input

6 8
1 2
2 5
5 1
3 4
4 6
5 4
2 4
2 3

Output

1

Explanation

• There is one connected component containing all vertices: {1, 2, 3, 4, 5, 6}.

Approach: Depth-First Search (DFS)

To solve the problem, we use Depth-First Search (DFS) to traverse each connected component in the graph. The idea is to start at an unvisited vertex, traverse all reachable vertices, and count the number of times we initiate a new traversal.

Key Idea

1. Use an adjacency list to represent the graph.
2. Maintain a visited array to keep track of visited vertices.
3. For each vertex, if it has not been visited, initiate a DFS traversal and increment the connected components count.

Complexity

• Time Complexity: ( O(N + M) )
  • Traversing all vertices and edges in the graph.
• Space Complexity: ( O(N + M) )
  • Storing the adjacency list and visited array.

Java Implementation

package search;

import java.io.*;
import java.util.*;

public class P11724 {
    static ArrayList<Integer>[] A;
    static boolean visited[];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        // Initialize adjacency list and visited array
        A = new ArrayList[n + 1];
        visited = new boolean[n + 1];
        for (int i = 1; i <= n; i++) {
            A[i] = new ArrayList<>();
        }

        // Read edges and populate adjacency list
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int s = Integer.parseInt(st.nextToken());
            int e = Integer.parseInt(st.nextToken());
            A[s].add(e);
            A[e].add(s); // Undirected graph
        }

        int count = 0;

        // Perform DFS for each unvisited vertex
        for (int i = 1; i <= n; i++) {
            if (!visited[i]) {
                count++;
                DFS(i);
            }
        }

        System.out.println(count);
    }

    static void DFS(int v) {
        if (visited[v]) {
            return;
        }
        visited[v] = true;
        for (int i : A[v]) {
            if (!visited[i]) {
                DFS(i);
            }
        }
    }
}

Pseudocode

BEGIN
    READ n, m (number of vertices and edges)

    CREATE adjacency list A of size n + 1
    CREATE visited array of size n + 1, initialized to false

    FOR i FROM 1 TO n DO
        A[i] = new empty list
    END FOR

    FOR i FROM 0 TO m DO
        READ edge (s, e)
        ADD e to A[s]
        ADD s to A[e] (undirected graph)
    END FOR

    SET count = 0

    FOR i FROM 1 TO n DO
        IF visited[i] IS false THEN
            INCREMENT count
            CALL DFS(i)
        END IF
    END FOR

    PRINT count
END

FUNCTION DFS(v):
    IF visited[v] IS true THEN
        RETURN
    END IF

    SET visited[v] = true

    FOR each neighbor i in A[v]:
        IF visited[i] IS false THEN
            CALL DFS(i)
        END IF
    END FOR
END FUNCTION

Explanation of the Code

1. Graph Representation
   • The graph is represented using an adjacency list, which is memory-efficient compared to an adjacency matrix for sparse graphs.
2. DFS Traversal
   • The DFS function recursively visits all vertices in the current connected component.
   • The visited array ensures that each vertex is visited only once.
3. Counting Connected Components
   • For each unvisited vertex, we initiate a DFS traversal and increment the connected components count.
4. Output
   • The final count of connected components is printed.

Walkthrough with Example

Input:

6 5
1 2
2 5
5 1
3 4
4 6

Steps:

1. Build adjacency list
   • Vertex 1: [2, 5]
   • Vertex 2: [1, 5]
   • Vertex 3: [4]
   • Vertex 4: [3, 6]
   • Vertex 5: [1, 2]
   • Vertex 6: [4]
2. Perform DFS
   • Start at vertex 1, traverse {1, 2, 5} (Component 1).
   • Move to vertex 3, traverse {3, 4, 6} (Component 2).
3. Count = 2.

Output:

2

Complexity Analysis

• Time Complexity: ( O(N + M) )
  • DFS visits each vertex and edge once.
• Space Complexity: ( O(N + M) )
  • For the adjacency list and visited array.

Links

• Problem Link: Baekjoon P11724
• Graph Theory Reference: Wikipedia

Solving Problem P1260: DFS and BFS Traversal of a Graph

Problem Description

Given an undirected graph with N vertices and M edges, perform:

1. Depth-First Search (DFS) starting from a given vertex.
2. Breadth-First Search (BFS) starting from the same vertex.

For both traversals, visit vertices in ascending numerical order when multiple vertices are reachable.

Constraints

• 1 ≤ N ≤ 1,000 (Number of vertices)
• 1 ≤ M ≤ 10,000 (Number of edges)

Input Format

1. The first line contains three integers N (number of vertices), M (number of edges), and V (starting vertex).
2. The next M lines contain two integers u and v, representing an undirected edge between vertices u and v.

Output Format

1. Print the order of vertices visited by DFS on the first line.
2. Print the order of vertices visited by BFS on the second line.

Example Input and Output

Example 1

Input:

4 5 1
1 2
1 3
1 4
2 4
3 4

Output:

1 2 4 3
1 2 3 4

Example 2

Input:

5 5 3
5 4
5 2
1 2
3 4
3 1

Output:

3 1 2 5 4
3 1 4 2 5

Example 3

Input:

1000 1 1000
999 1000

Output:

1000 999
1000 999

Approach: Graph Traversal with DFS and BFS

To solve the problem, we use DFS and BFS traversal algorithms. Both algorithms rely on the adjacency list representation of the graph to efficiently manage edges.

Depth-First Search (DFS)

• DFS uses recursion or a stack to explore as deep as possible along each branch before backtracking.
• It is implemented here using recursion.

Breadth-First Search (BFS)

• BFS uses a queue to explore all neighbors of a vertex before moving to the next level.
• This ensures that vertices are visited in increasing order of distance from the starting vertex.

Complexity

• Time Complexity: ( O(N + M) )
  • Traverses all vertices and edges.
• Space Complexity: ( O(N + M) )
  • Adjacency list and visited array.

Java Implementation

package search;

import java.util.*;

public class P1260 {
    static boolean visited[];
    static ArrayList<Integer>[] A;

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        int M = scan.nextInt();
        int Start = scan.nextInt();

        A = new ArrayList[N + 1];
        for (int i = 1; i <= N; i++) {
            A[i] = new ArrayList<Integer>();
        }

        // Read edges and populate adjacency list
        for (int i = 0; i < M; i++) {
            int S = scan.nextInt();
            int E = scan.nextInt();
            A[S].add(E);
            A[E].add(S); // Undirected graph
        }

        // Sort adjacency list for consistent traversal order
        for (int i = 1; i <= N; i++) {
            Collections.sort(A[i]);
        }

        // DFS traversal
        visited = new boolean[N + 1];
        DFS(Start);
        System.out.println();

        // BFS traversal
        visited = new boolean[N + 1];
        BFS(Start);
        System.out.println();
    }

    public static void DFS(int Node) {
        System.out.print(Node + " ");
        visited[Node] = true;
        for (int i : A[Node]) {
            if (!visited[i]) {
                DFS(i);
            }
        }
    }

    private static void BFS(int Node) {
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.add(Node);
        visited[Node] = true;

        while (!queue.isEmpty()) {
            int now_Node = queue.poll();
            System.out.print(now_Node + " ");
            for (int i : A[now_Node]) {
                if (!visited[i]) {
                    visited[i] = true;
                    queue.add(i);
                }
            }
        }
    }
}

Pseudocode

BEGIN
    READ N, M, V (number of vertices, edges, starting vertex)
    INITIALIZE adjacency list A[N+1] and visited array

    FOR each edge (S, E):
        ADD E to A[S]
        ADD S to A[E] (undirected graph)
    END FOR

    FOR each adjacency list A[i]:
        SORT A[i]
    END FOR

    INITIALIZE visited array to false
    CALL DFS(V)
    PRINT DFS order

    INITIALIZE visited array to false
    CALL BFS(V)
    PRINT BFS order
END

FUNCTION DFS(Node):
    PRINT Node
    SET visited[Node] = true
    FOR each neighbor i in A[Node]:
        IF visited[i] IS false THEN
            CALL DFS(i)
        END IF
    END FOR
END FUNCTION

FUNCTION BFS(Node):
    INITIALIZE queue
    ENQUEUE Node
    SET visited[Node] = true

    WHILE queue IS NOT EMPTY:
        DEQUEUE current_Node
        PRINT current_Node
        FOR each neighbor i in A[current_Node]:
            IF visited[i] IS false THEN
                ENQUEUE i
                SET visited[i] = true
            END IF
        END FOR
    END WHILE
END FUNCTION

Explanation of the Code

1. Graph Representation:
   • The graph is represented using an adjacency list to store all edges efficiently.
2. DFS Traversal:
   • Recursive DFS is used to visit each vertex and its neighbors in depth-first order.
   • The visited array ensures that each vertex is visited only once.
3. BFS Traversal:
   • Iterative BFS uses a queue to process vertices level by level.
   • The visited array ensures that each vertex is added to the queue only once.
4. Sorting:
   • Sorting the adjacency list ensures that vertices are visited in ascending order when multiple options are available.

Walkthrough with Example

Input:

4 5 1
1 2
1 3
1 4
2 4
3 4

Steps:

1. Build adjacency list:
   • Vertex 1: [2, 3, 4]
   • Vertex 2: [1, 4]
   • Vertex 3: [1, 4]
   • Vertex 4: [1, 2, 3]
2. Perform DFS:
   • Start at vertex 1 → Visit: 1 → 2 → 4 → 3.
3. Perform BFS:
   • Start at vertex 1 → Visit: 1 → 2 → 3 → 4.

Output:

1 2 4 3
1 2 3 4

Complexity Analysis

• Time Complexity: ( O(N + M) )
  • Traverses all vertices and edges.
• Space Complexity: ( O(N + M) )
  • Adjacency list and visited array.

Links

• Problem Link: Baekjoon P1260
• Graph Traversal Reference: Wikipedia

Solving Sorting Problems with Bubble Sort in Java

Problem Description

Given an array of N integers, the task is to sort the array in ascending order using the Bubble Sort Algorithm.

Bubble sort is a simple comparison-based sorting technique where adjacent elements are compared and swapped to place them in the correct order.

Input Format

1. An integer N, the number of elements in the array.
2. N integers, representing the array elements.

Output Format

The sorted array, where each element is printed on a new line.

Example Input and Output

Example 1

Input:

5
4 2 5 1 3

Output:

1
2
3
4
5

Explanation

• Initial Array: [4, 2, 5, 1, 3]
• After sorting using Bubble Sort:
  • [1, 2, 3, 4, 5]
• Each element is printed on a new line in ascending order.

Approach: Bubble Sort Algorithm

The Bubble Sort Algorithm works by repeatedly comparing adjacent elements in the array and swapping them if they are in the wrong order. This process is repeated until the array is fully sorted.

Key Idea

1. During each iteration, the largest unsorted element “bubbles up” to its correct position at the end of the array.
2. The process continues for all elements until the entire array is sorted.

Steps

1. Compare Adjacent Elements:
   • If the current element is greater than the next element, swap them.
2. Repeat the process for all elements, reducing the effective size of the unsorted part of the array after each iteration.
3. Stop when no swaps are needed in a full iteration, indicating the array is sorted.

Complexity

• Time Complexity:
  • Worst Case: ( O(N^2) ) (when the array is sorted in reverse order)
  • Best Case: ( O(N) ) (when the array is already sorted, with optimization)
• Space Complexity: ( O(1) ) (no additional memory required apart from the input array)

Java Implementation

import java.util.Scanner;

public class BubbleSort {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // Input the size of the array
        int N = sc.nextInt();
        int[] arr = new int[N];

        // Input array elements
        for (int i = 0; i < N; i++) {
            arr[i] = sc.nextInt();
        }

        // Perform Bubble Sort
        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Swap elements
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        // Output the sorted array
        for (int i = 0; i < N; i++) {
            System.out.println(arr[i]);
        }

        sc.close();
    }
}

Pseudocode

Here is the pseudocode for the Bubble Sort Algorithm:

BEGIN
    CREATE Scanner object to read input
    READ N (number of elements in the array)
    CREATE integer array of size N

    FOR i FROM 0 TO N-1 DO
        READ arr[i] (fill the array with input numbers)
    END FOR

    // Bubble sort algorithm
    FOR i FROM 0 TO N-2 DO
        FOR j FROM 0 TO N-2 DO
            IF arr[j] > arr[j+1] THEN
                SWAP arr[j] AND arr[j+1]
            END IF
        END FOR
    END FOR

    // Print sorted array
    FOR i FROM 0 TO N-1 DO
        PRINT arr[i]
    END FOR

    CLOSE Scanner
END

Explanation of the Code

1. Input Handling:
   • The program reads the size of the array ( N ) and the array elements from the user.
   • The array is filled using a loop.
2. Sorting (Bubble Sort):
   • Two nested loops are used to perform the sorting:
     • The outer loop controls the number of passes (( N-1 )).
     • The inner loop compares adjacent elements and swaps them if they are in the wrong order.
   • After each outer loop iteration, the largest element is guaranteed to be in its correct position.
3. Output:
   • The sorted array is printed line by line using a loop.

Walkthrough with Example

Input:

5
4 2 5 1 3

Steps:

1. Initial Array: [4, 2, 5, 1, 3]

2. Pass 1:
   • Compare 4 and 2: Swap → [2, 4, 5, 1, 3]
   • Compare 4 and 5: No swap
   • Compare 5 and 1: Swap → [2, 4, 1, 5, 3]
   • Compare 5 and 3: Swap → [2, 4, 1, 3, 5]
3. Pass 2:
   • Compare 2 and 4: No swap
   • Compare 4 and 1: Swap → [2, 1, 4, 3, 5]
   • Compare 4 and 3: Swap → [2, 1, 3, 4, 5]
4. Pass 3:
   • Compare 2 and 1: Swap → [1, 2, 3, 4, 5]
5. Sorted Array: [1, 2, 3, 4, 5]

Output:

1
2
3
4
5

Advantages and Disadvantages

Advantages:

• Simple and easy to understand.
• Suitable for small datasets.

Disadvantages:

• Inefficient for large datasets due to its ( O(N^2) ) time complexity.
• Performs unnecessary iterations even if the array is already sorted.

Optimizations and Alternatives

1. Optimization:
   • Add a flag to check if any swaps were made in an iteration.
   • If no swaps are made, terminate the loop early.
2. Better Algorithms:
   • Quick Sort or Merge Sort can handle large datasets efficiently with ( O(N \log N) ) time complexity.

Links

• Bubble Sort Explanation: Wikipedia
• Source Code Repository: GitHub

Solving Problem P11003: Sliding Window Minimum Using Deque

Problem Description

Given N numbers ( A_1, A_2, \dots, A_N ) and an integer ( L ), the goal is to calculate the minimum value in each sliding window of size ( L ). Specifically, for each ( i ):

[ D_i = \min(A_{i-L+1}, \dots, A_i) ]

When ( i - L + 1 \leq 0 ), ignore indices ( \leq 0 ) while calculating the minimum.

Constraints

• 1 ( \leq ) L ( \leq ) N ( \leq ) 5,000,000
• (-10^9 \leq A_i \leq 10^9)

Input Format

1. The first line contains two integers N (number of elements) and L (window size).
2. The second line contains N integers ( A_1, A_2, \dots, A_N ).

Output Format

Output the sliding window minimum values ( D_i ), separated by spaces.

Example Input and Output

Example 1

Input:

12 3
1 5 2 3 6 2 3 7 3 5 2 6

Output:

1 1 1 2 2 2 2 2 3 3 2 2

Explanation

• For each window of size ( L = 3 ):
  • Window [1, 5, 2]: Minimum = 1
  • Window [5, 2, 3]: Minimum = 1
  • Window [2, 3, 6]: Minimum = 2
  • Continue similarly…

Approach: Sliding Window with Deque

The problem can be efficiently solved using a deque (double-ended queue), which helps maintain the minimum value of the current sliding window.

Key Idea

• Use the deque to store indices of array elements. The deque will always maintain elements in increasing order of value.
• Ensure the deque only contains indices that fall within the current sliding window.

Steps

1. Initialize a deque to store elements’ indices. This deque will always maintain indices in increasing order of values.
2. Iterate through the array elements:
   • Remove elements from the back of the deque if they are greater than the current element. These elements will never be the minimum in the future.
   • Add the current element’s index to the deque.
   • Remove the front of the deque if it is outside the current sliding window.
   • The element at the front of the deque is the minimum for the current sliding window.
3. Append the minimum to the result for each step.

Complexity

• Time Complexity: ( O(N) )
  • Each element is added and removed from the deque exactly once.
• Space Complexity: ( O(L) ), where ( L ) is the maximum size of the deque.

Java Implementation

package datastruc.R1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Deque;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class P11003 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        int N = Integer.parseInt(st.nextToken());
        int L = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(br.readLine());

        Deque<Node> mydeque = new LinkedList<>();
        for (int i = 0; i < N; i++) {
            int now = Integer.parseInt(st.nextToken());

            // Remove elements from back that are greater than the current value
            while (!mydeque.isEmpty() && mydeque.getLast().value > now) {
                mydeque.removeLast();
            }

            // Add the current element
            mydeque.addLast(new Node(now, i));

            // Remove elements from front that are out of window
            if (mydeque.getFirst().index <= i - L) {
                mydeque.removeFirst();
            }

            // Write the minimum value for the current window
            bw.write(mydeque.getFirst().value + " ");
        }

        bw.flush();
        bw.close();
    }

    static class Node {
        public int value;
        public int index;

        Node(int value, int index) {
            this.value = value;
            this.index = index;
        }
    }
}

Pseudocode

Here is the pseudocode for the sliding window minimum algorithm:

BEGIN
  READ N, L
  DECLARE deque as empty

  FOR i FROM 0 TO N - 1 DO
    READ current_element

    // Remove elements from the back of deque if they are greater than the current element
    WHILE deque IS NOT EMPTY AND deque.back.value > current_element DO
      deque.pop_back()
    END WHILE

    // Add current element's index to the deque
    deque.push_back(current_element, index)

    // Remove elements from the front if they are outside the current sliding window
    IF deque.front.index <= i - L THEN
      deque.pop_front()
    END IF

    // Append the minimum (deque.front.value) to the result
    WRITE deque.front.value + " "
  END FOR
END

Explanation of the Code

1. Input Handling:
   • The program reads the number of elements ( N ) and the sliding window size ( L ).
   • It also reads the ( N ) integers into a deque for processing.
2. Deque Operations:
   • Remove elements from the back of the deque if their value is greater than the current element. These elements will never be the minimum in future windows.
   • Remove elements from the front of the deque if they fall outside the sliding window range ([i-L+1, i]).
   • The element at the front of the deque is guaranteed to be the minimum for the current window.
3. Output the Result:
   • For each window, the value at the front of the deque is written as the minimum value.

Complexity Analysis

• Time Complexity: ( O(N) )
  • Each element is added and removed from the deque exactly once, resulting in linear time.
• Space Complexity: ( O(L) )
  • The deque contains at most ( L ) elements at any time, where ( L ) is the window size.

Links

• Problem Link: Baekjoon P11003
• Source Code: GitHub Repository

Solving Problem P1253: Counting Good Numbers with Two-Pointer Technique

Problem Description

Given a sequence of N integers, the task is to count how many of these numbers can be expressed as the sum of two distinct numbers from the array. A number cannot be used to form itself, but duplicate values are considered distinct if they are at different positions.

Constraints

• 1 ≤ N ≤ 2000
• A[i] ≤ 1,000,000,000

Input Format

1. The first line contains an integer N, the number of elements in the array.
2. The second line contains N numbers separated by spaces.

Output Format

Output a single integer, the count of “good numbers” in the array.

Example Input and Output

Example 1

Input

5
1 2 3 4 5

Output

3

Explanation

• 3 = 1 + 2
• 4 = 1 + 3
• 5 = 2 + 3
• Thus, there are 3 “good numbers”.

Example 2

Input:

4
0 0 0 0

Output:

4

Explanation

• Each 0 can be expressed as the sum of two other 0s from different positions.
• Thus, all 4 numbers are “good numbers”.

Approach: Two-Pointer Technique

To efficiently count the “good numbers” in the array, we can utilize the two-pointer technique. Here’s a step-by-step approach:

Steps:

1. Sort the Array:
   • First, sort the array in ascending order. Sorting helps in efficiently finding pairs that sum up to a target value using two pointers.
2. Iterate Through Each Number:
   • For each number in the array, consider it as the target sum and use two pointers to find if there exists a pair that sums up to this target.
3. Initialize Two Pointers:
   • Initialize one pointer at the start (i = 0) and another at the end (j = N-1) of the array.
   • If either pointer points to the current target index, move the pointer accordingly to avoid using the number itself.
4. Check Sum:
   • Calculate the sum of the numbers at the two pointers.
   • If the sum equals the target, increment the count of “good numbers” and move to the next target.
   • If the sum is less than the target, move the left pointer to the right to increase the sum.
   • If the sum is greater than the target, move the right pointer to the left to decrease the sum.
5. Avoid Counting Duplicates:
   • Ensure that the same pair isn’t counted multiple times by breaking out of the loop once a valid pair is found.

Java Implementation

package datastruc.R1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class P1253 {

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(bf.readLine());
        int Result = 0;
        long A[] = new long[N];
        StringTokenizer st = new StringTokenizer(bf.readLine());
        for(int i = 0; i < N; i++){
            A[i] = Long.parseLong(st.nextToken());
        }
        Arrays.sort(A); // Sort the array in ascending order

        for(int k = 0; k < N; k++){ // Iterate through each number as the target
            long find = A[k];
            int i = 0;
            int j = N - 1; // Initialize two pointers
            while(i < j){
                if(A[i] + A[j] == find){
                    if(i != k && j != k){
                        Result++;
                        break;
                    } else if(i == k){
                        i++;
                    } else if(j == k){
                        j--;
                    }     
                }
                else if (A[i] + A[j] < find){
                    i++;
                } else{
                    j--;
                }
            }
        }
        System.out.println(Result);
        bf.close();
    }
}

Explanation of the Code

1. Input Handling:
   • The program reads the number of elements N and the array A from the standard input using BufferedReader and StringTokenizer for efficient input processing.
2. Sorting:
   • The array A is sorted in ascending order using Arrays.sort(A). Sorting is crucial for the two-pointer technique to work efficiently.
3. Counting Good Numbers:
   • The outer loop iterates through each element in the sorted array, treating each as the target sum (find).
   • For each target, two pointers i and j are initialized at the start and end of the array, respectively.
   • The inner loop moves the pointers based on the sum of A[i] + A[j] compared to the target:
     • If the sum equals the target and neither pointer is pointing to the target index (k), it’s a “good number”, and Result is incremented.
     • If either pointer points to the target index, the pointer is moved to avoid using the number itself.
     • If the sum is less than the target, the left pointer i is moved to the right to increase the sum.
     • If the sum is greater than the target, the right pointer j is moved to the left to decrease the sum.
   • The loop breaks once a valid pair is found for the current target.
4. Output:
   • After processing all elements, the total count of “good numbers” is printed.

Complexity Analysis

• Sorting: (O(N \log N))
• Counting Good Numbers: (O(N^2))
  • Outer loop runs (N) times.
  • Inner loop (two-pointer search) runs (O(N)) for each target.
• Total Complexity: (O(N^2))

Links

• Problem Link: Baekjoon P1253
• Source Code: GitHub Repository

Solving Problem 11659: Prefix Sum for Range Queries

Problem Description

Given N numbers, the task is to efficiently calculate the sum of numbers from the (i^th) to the (j^th) index for multiple queries.

Constraints

• 1 ≤ N ≤ 100,000
• 1 ≤ M ≤ 100,000
• 1 ≤ i ≤ j ≤ N
• The numbers are natural numbers (≤ 1000).

Input Format

1. The first line contains two integers, N (number of numbers) and M (number of queries).
2. The second line contains N numbers separated by spaces.
3. Each of the next M lines contains two integers i and j, representing the range for which the sum needs to be calculated.

Output Format

For each query, output the sum of numbers from the (i^th) to the (j^th) index.

Example Input and Output

Example 1

Input:

5 3
5 4 3 2 1
1 3
2 4
5 5

Output:

12
9
1

Explanation

1. Query 1: Sum of elements from index 1 to 3 = 5 + 4 + 3 = 12.
2. Query 2: Sum of elements from index 2 to 4 = 4 + 3 + 2 = 9.
3. Query 3: Sum of elements from index 5 to 5 = 1.

Approach: Prefix Sum Technique

To efficiently calculate the sum of any range (i) to (j), we use the prefix sum array technique.

Prefix Sum Formula:

Let (S[k]) be the sum of the first (k) elements of the array.

• (S[k] = S[k-1] + A[k])

To calculate the sum of elements from index (i) to (j):

• ( ext{Range Sum} = S[j] - S[i-1])

Steps:

1. Precompute the prefix sum array (S) such that (S[k]) contains the sum of the first (k) elements.
2. For each query, use the formula (S[j] - S[i-1]) to calculate the sum in constant time (O(1)).

Complexity:

• Prefix Sum Construction: (O(N))
• Query Handling: (O(1)) per query
• Total Complexity: (O(N + M))

Java Implementation

package datastruc.R1;
import java.io.*;
import java.util.*;

public class P11659 {
    public static void main(String[] args) throws IOException {
        BufferedReader bR = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer sT = new StringTokenizer(bR.readLine());
        int arrNum = Integer.parseInt(sT.nextToken());
        int queryNum = Integer.parseInt(sT.nextToken());
        long S[] = new long[arrNum + 1];

        // Construct prefix sum array
        sT = new StringTokenizer(bR.readLine());
        for (int i = 1; i <= arrNum; i++) {
            S[i] = S[i - 1] + Integer.parseInt(sT.nextToken());
        }

        // Handle queries
        for (int l = 0; l < queryNum; l++) {
            sT = new StringTokenizer(bR.readLine());
            int i = Integer.parseInt(sT.nextToken());
            int j = Integer.parseInt(sT.nextToken());
            System.out.println(S[j] - S[i - 1]);
        }
    }
}

Explanation of the Code

1. Input Handling:
   • Read (N) (number of elements) and (M) (number of queries).
   • Read the (N) numbers into a prefix sum array.
2. Prefix Sum Array Construction:
   • (S[i] = S[i-1] + A[i]), where (A[i]) is the (i^{th}) element of the input.
3. Query Processing:
   • For each query (i, j), calculate (S[j] - S[i-1]) to get the sum of elements from index (i) to (j).
4. Output:
   • Print the result for each query.

Advantages of Prefix Sum

1. Efficient Query Handling: Each query is handled in (O(1)) time, making it suitable for large inputs.
2. Precomputation: Although we spend (O(N)) to construct the prefix sum array, this is a one-time cost that significantly speeds up query handling.

Links

• Problem Link: Baekjoon 11659
• Source Code: GitHub Repository

Summary

This solution efficiently calculates the sum of any range (i) to (j) using the prefix sum technique. With a time complexity of (O(N + M)), it is well-suited for large inputs and multiple queries.

Solving Problem 11720: Sum of Numbers

Problem Description

You are given N numbers written consecutively without spaces. Write a program to calculate and print the sum of these numbers.

Constraints

• 1 <= N <= 100
• The input numbers are provided without spaces.

Input Format

1. The first line contains an integer N, the number of digits.
2. The second line contains N consecutive digits without spaces.

Output Format

• Print the sum of the given digits.

Examples

Example 1

Input:

1
1

Output:

1

Example 2

Input:

5
54321

Output:

15

Example 3

Input:

25
7000000000000000000000000

Output:

7

Example 4

Input:

11
10987654321

Output:

46

Approach

This problem is solved by iterating through each digit of the input string, converting it to an integer, and adding it to a running sum. The approach is straightforward and efficient given the constraint.

Steps to Solve:

1. Read the input values.
2. Convert the string of numbers into a character array.
3. Loop through each character, convert it to its numeric value, and add it to the sum.
4. Print the total sum.

Java Implementation

package datastruc.R1;

import java.util.*;

public class P11720 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        String sNum = sc.next();

        // Convert string to char array
        char cNum[] = sNum.toCharArray();
        int sum = 0;

        // Sum each digit
        for (int i = 0; i < N; i++) {
            sum += cNum[i] - '0'; // Convert char to int by subtracting '0'
        }

        System.out.println(sum);
        sc.close();
    }
}

Explanation of the Code

1. Input Handling:
   • Scanner is used to read input.
   • nextInt() reads the number of digits ( N ).
   • next() reads the string of ( N ) digits.
2. Character Array Conversion:
   • The toCharArray() method converts the string into an array of characters, where each character represents a single digit.
3. Summation Loop:
   • Iterate through each character in the array.
   • Convert the character to its integer value by subtracting '0' (ASCII adjustment).
   • Add the integer value to the running total.
4. Output:
   • Print the total sum.

Links

• Problem Link: Baekjoon 11720
• Source Code: GitHub Repository

Summary

This solution effectively handles the constraints and uses basic string and array manipulation techniques in Java to solve the problem. The time complexity is ( O(N) ), making it efficient given the problem’s limits.

Printing a String in Java

Problem Description

In this post, we’ll explore how to take a string as input and print it in Java. This is a fundamental exercise in understanding basic input/output operations in Java programming.

Problem Statement

Given a string str, write a program that reads the string and prints it.

Constraints

• The length of str is between 1 and 1,000,000 characters.
• The string str contains no spaces and is provided in a single line.

Example Input and Output

Example Input

Input #1:

HelloWorld!

Example Output

Output #1:

HelloWorld!

Java Code Implementation

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); // Step 1: Create a Scanner object to read input
        String a = sc.next();               // Step 2: Read a single word (without spaces) from the input
        System.out.println(a);              // Step 3: Print the input string
    }
}

Code Explanation

Concept Summary

• Scanner Class

The Scanner class in Java is a utility that allows for simple input reading from different input streams, like the keyboard. It’s part of the java.util package, which must be imported to use the class.

• Main Method

The main method serves as the entry point for any Java program. When the program is run, execution begins here.

• Reading Input

The next() method of the Scanner object reads the next token from the input until it encounters a space. It’s used to read a single word or a string without spaces.

• Printing Output

The System.out.println() method is used to print the output to the console, followed by a newline.

This program demonstrates a basic input/output operation in Java. It reads a single string from the user and prints it back, showcasing how to handle simple input and output in a Java program.

This example is a foundational exercise in Java programming, highlighting how to work with basic input and output. Understanding these concepts is crucial as they form the basis for more complex operations and interactions in Java applications. This program can be run in any standard Java environment and is a great starting point for beginners.

Print a and b

Problem Description

You are given two integers, a and b. Write a code to take these numbers as input and print them in the format shown in the example.

Constraints

• 100,000 ≤ a, b ≤ 100,000

Input/Output Example

Input #1

4 5

Output #1

a = 4
b = 5

Solution.java

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();

        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

Explanation and Concept Overview

Concept Overview

• Basic Input/Output

  This problem emphasizes understanding how to take input from the user and how to output the data in a specific format. It’s fundamental for beginners to grasp how input and output work in Java.

• String Concatenation

  The problem also involves string concatenation, where you combine strings and variables to create a desired output format.

• Using the Scanner Class:

  The Scanner class is a part of the java.util package, and it is widely used for taking input in Java. This problem introduces or reinforces the use of Scanner to read integers from standard input.

This problem is a basic exercise in handling input and output in Java, useful for beginners to get accustomed to reading input and printing formatted output.

Toggle Case and Print

Problem Description

You are given a string str composed of English alphabets. Write a code to convert each alphabet in the string to its opposite case (uppercase to lowercase, and lowercase to uppercase) and then print the result.

Constraints

• The length of str is between 1 and 20 inclusive.
• str consists of alphabetic characters only.

Input/Output Example

Input #1

aBcDeFg

Output #1

AbCdEfG

※ The constraints were updated on May 3, 2023.

Solution

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        // Create a Scanner object to read input
        Scanner sc = new Scanner(System.in);
        
        // Read the input string
        String a = sc.next();
        
        // Create a variable to store the result
        String answer = "";
        
        // Variable to store each character
        char c;
        
        // Loop through each character in the input string
        for(int i = 0; i < a.length(); i++) {
            // Get the character at the current position in the string
            c = a.charAt(i);
            
            // Check if the character is uppercase
            if(Character.isUpperCase(c)) {
                // Convert to lowercase and append to the result
                answer += Character.toLowerCase(c); 
            } else {
                // Convert to uppercase and append to the result
                answer += Character.toUpperCase(c);
            }
        }
        
        // Print the final result
        System.out.println(answer);        
    }
}

Conceptual Explanation

1. Input Handling
   • The code begins by creating a Scanner object to read the input string from the user. The sc.next() function reads the next token of input (in this case, a string) and stores it in the variable a.
2. Variable Initialization
   • The variable answer is initialized as an empty string. This variable will be used to store the final output after converting each character to its opposite case.
   • The variable c is declared to temporarily store each character from the string during the loop.
3. Looping through the String
   • A for loop iterates over each character in the string a. The loop runs from index 0 to the length of the string minus one.
4. Character Case Conversion
   • Inside the loop, the charAt(i) method is used to get the character at the current index i of the string.
   • The Character.isUpperCase(c) method checks if the character c is uppercase.
     • If c is uppercase, it is converted to lowercase using Character.toLowerCase(c), and the result is appended to the answer string.
     • If c is lowercase, it is converted to uppercase using Character.toUpperCase(c), and the result is appended to the answer string.

https://docs.oracle.com/javase/8/docs/api/

• toLowerCaseConverts the character (Unicode code point) argument to lowercase using case mapping information from the UnicodeData file.

    public static int toLowerCase(int codePoint)
  

  Note that Character.isLowerCase(Character.toLowerCase(codePoint)) does not always return true for some ranges of characters, particularly those that are symbols or ideographs.

  In general, String.toLowerCase() should be used to map characters to lowercase. String case mapping methods have several benefits over Character case mapping methods. String case mapping methods can perform locale-sensitive mappings, context-sensitive mappings, and 1:M character mappings, whereas the Character case mapping methods cannot.

  Parameters:codePoint - the character (Unicode code point) to be converted.Returns:the lowercase equivalent of the character (Unicode code point), if any; otherwise, the character itself.Since:1.5See Also:isLowerCase(int), String.toLowerCase()

public static char toUpperCase(char ch)

Converts the character argument to uppercase using case mapping information from the UnicodeData file.

Note that Character.isUpperCase(Character.toUpperCase(ch)) does not always return true for some ranges of characters, particularly those that are symbols or ideographs.

In general, String.toUpperCase() should be used to map characters to uppercase. String case mapping methods have several benefits over Character case mapping methods. String case mapping methods can perform locale-sensitive mappings, context-sensitive mappings, and 1:M character mappings, whereas the Character case mapping methods cannot.

Note: This method cannot handle supplementary characters. To support all Unicode characters, including supplementary characters, use the toUpperCase(int) method.

Parameters:ch - the character to be converted.Returns:the uppercase equivalent of the character, if any; otherwise, the character itself.See Also:isUpperCase(char), String.toUpperCase()

Breif

• print

Outputs data as-is, stays on the same line.

• println

Outputs data as-is, then moves to a new line.

• printf

Formats and outputs data according to a specified format, stays on the same line unless explicitly told to move to the next line.

Summary

This code efficiently toggles the case of each character in a string provided by the user. It demonstrates the use of loops, conditionals, and basic string operations in Java. The approach ensures that every character is checked and converted appropriately, resulting in the desired output.

Understanding Asynchronous Transfer Mode (ATM) and Asynchronous Time-Division Multiplexing (ATDM)

Quiz Question

Question: Which of the following statements is true regarding Asynchronous Transfer Mode (ATM) and Asynchronous Time-Division Multiplexing (ATDM)?

A. ATM uses variable-length packets for data transmission, while ATDM uses fixed-length cells.

B. ATDM is a specific protocol, whereas ATM is a general multiplexing technique.

C. ATM is connection-oriented and uses fixed-length 53-byte cells, while ATDM dynamically allocates time slots based on demand.

D. In ATM, each type of data is assigned a specific time slot in a repeating cycle, similar to Time-Division Multiplexing (TDM).

Answer: C. ATM is connection-oriented and uses fixed-length 53-byte cells, while ATDM dynamically allocates time slots based on demand.

Explanation

• Option A is incorrect because ATM uses fixed-length cells (53 bytes), not variable-length packets.
• Option B is incorrect because ATDM is a general multiplexing technique, while ATM is a specific protocol that uses ATDM principles.
• Option D is incorrect because ATM does not use fixed time slots in a repeating cycle; it dynamically allocates bandwidth as needed.
• Option C is correct as it accurately describes the characteristics of both ATM and ATDM.

In the world of network technologies, two important concepts often come up: Asynchronous Transfer Mode (ATM) and Asynchronous Time-Division Multiplexing (ATDM). While these terms are closely related, they have distinct characteristics and applications. Let’s dive deeper into these technologies to understand their similarities, differences, and how they work together.

What is Asynchronous Transfer Mode (ATM)?

ATM is a high-speed networking standard designed for transmitting all types of data (such as voice, video, and data traffic) across a network. It is a packet-oriented transmission technology that uses fixed-size cells for data transfer. Each ATM cell is 53 bytes in length, consisting of a 5-byte header and a 48-byte payload.

Key Features of ATM

1. Fixed-Length Cells: Unlike other networking protocols that use variable-length packets, ATM uses fixed-length cells of 53 bytes. This standardization simplifies hardware processing and helps maintain consistent transmission delays.

2. Asynchronous Time-Division Multiplexing (ATDM): ATM leverages the concept of ATDM, which means that data cells are transmitted asynchronously. Instead of using fixed time slots, each data stream dynamically receives time slots as needed, making efficient use of network resources.

3. Connection-Oriented: ATM is a connection-oriented protocol. Before data transmission begins, a virtual circuit is established, specifying the path that data will follow through the network. This ensures reliable and consistent data delivery.

4. Quality of Service (QoS): ATM supports various levels of Quality of Service (QoS), making it suitable for applications with different performance requirements. It can handle diverse types of traffic, including real-time voice and video, as well as non-real-time data.

What is Asynchronous Time-Division Multiplexing (ATDM)?

ATDM is a general multiplexing technique where multiple data streams share the same communication channel by being assigned time slots based on demand. Unlike synchronous time-division multiplexing (TDM), where time slots are fixed, ATDM dynamically allocates time slots to data streams as needed.

Key Features of ATDM

1. Dynamic Time Slot Allocation: ATDM allocates time slots to data streams on an as-needed basis. This means that the channel’s time slots are not fixed and can be used more efficiently by only assigning them when there is data to be transmitted.

2. Efficient Bandwidth Utilization: By dynamically allocating time slots, ATDM makes better use of the available bandwidth, minimizing idle periods and improving overall transmission efficiency.

3. Flexibility: ATDM is not tied to a specific protocol and can be implemented in various systems and networks to accommodate different types of traffic and transmission requirements.

How ATM and ATDM Work Together

ATM uses ATDM as its underlying multiplexing technique. Here’s how they integrate:

• Packet-Oriented Transmission: ATM’s use of fixed-length 53-byte cells ensures predictable performance and simplifies hardware design.
• Efficient Use of Network Resources: By employing ATDM, ATM can dynamically allocate time slots for transmitting cells, maximizing the efficiency of the network.
• Connection-Oriented Communication: ATM sets up a virtual circuit before data transmission, ensuring a reliable and continuous data stream. This connection-oriented nature, combined with ATDM’s efficient time slot allocation, makes ATM suitable for a wide range of applications with varying QoS requirements.

Diagram Explanation

This diagram illustrates the concept of ATM and its comparison with TDM. Let’s break down the components and what they represent.

Diagram Breakdown

1. Sources of Data
   • Voice: Represented by gray blocks.
   • Data Packets: Represented by black blocks.
   • Images: Represented by light gray blocks.
2. Multiplexer (MUX)
   • The MUX is responsible for combining multiple streams of data (voice, data packets, and images) into a single stream for transmission. It acts as a central point where different types of data are synchronized and sent out over the network.
3. TDM (Time-Division Multiplexing)
   • In TDM, each type of data is assigned a specific time slot in a repeating cycle. For example, voice data might be sent in slot 1, data packets in slot 2, and images in slot 3, and so on.
   • Wasted Bandwidth: TDM can lead to inefficiencies. If a particular time slot has no data to send (e.g., no voice data during a given cycle), that slot is left empty, resulting in wasted bandwidth.
4. ATM (Asynchronous Transfer Mode)
   • In ATM, data is sent in small, fixed-size cells (53 bytes). Each cell can carry different types of data depending on availability and demand.
   • Unlike TDM, ATM does not use fixed time slots. Instead, it dynamically allocates bandwidth as needed. This means there are no empty slots, and bandwidth is used more efficiently.

In summary, Asynchronous Transfer Mode (ATM) is a sophisticated network technology that combines the principles of Asynchronous Time-Division Multiplexing (ATDM) with fixed-length cells to achieve efficient, reliable, and high-speed data transmission. Understanding the interplay between ATM and ATDM helps in appreciating how modern networks manage diverse types of traffic, ensuring seamless communication and optimal resource utilization. Whether for voice, video, or data, ATM remains a powerful solution for meeting the demands of contemporary networking.