Question

Please solve using Java and comment your code for clarity.

Sample 3. Input: 4 1 231 Output: 0 This sequence also does not have a majority element (note that the element 1 appears twice and hence is not a majority element). Problem Introduction Majority rule is a decision rule that selects the alternative which has a majority, that is, more than half the votes. Given a sequence of elements (1.02....,On, you would like to check whether it contains an element that appears more than n/2 times. A naive way to do this is the following: MAJORITY ELEMENT(01.09....,an): for i from I to n: current Elemento; count=0 for j from 1 to n: if ; = current Element: count + count +1 if count > n/2: return a; return ''no majority element" What To Do As you might have already guessed, this problem can be solved by the divide-and-conquer algorithm in time O(n log n). Indeed, iſ a sequence of length n contains a majority element, then the same element is also a majority clement for one of its halves. Thus, to solve this problem you first split a given sequence into halves and make two recursive calls. Do you see how to combine the results of two recursive calls? It is interesting to note that this problem can also be solved in O(n) time by a more advanced (non-divide and conquer) algorithm that just scans the given sequence twice. The running time of this algorithm is quadratic. Your goal is to use the divide-and-conquer technique to design an O(n log n) algorithm. Problem Description Task. The goal in this code problem is to check whether an input sequence contains a majority element. Input Format. The first line contains an integer 12, the next one contains a sequence of n non-negative integers di), 01, ...,On-l. Constraints. 1 <n< 10%; 0 C0 <10for all 0 <i<n. Output Format. Output 1 if the sequence contains an element that appears strictly more than n/2 times, and 0 otherwise Sample 1. Input: 5 239 22 Output: 1 2 is the majority element. Sample 2. Input: 4. 1 2 3 4 Output: 0 There is no majority element in this sequence.

Answer 1

Once we find majority element we check again isMajority or not using isMajority() function

import java.util.*;
class Solution {
    public static int count(int[] a, int num, int lo, int hi) {
        int frequency = 0;
        for (int i = lo; i <= hi; i++) {
            if (a[i] == num) {
                frequency++;
            }
        }
        return frequency;
    }

    public static int majorityElementRec(int[] a, int lo, int hi) {
        // base case; the only element in an array of size 1 is the majority
        // element.
        if (lo == hi) {
            return a[lo];
        }

        // recurse on left and right halves of this slice.
        int mid = (hi-lo)/2 + lo;
        int left = majorityElementRec(a, lo, mid);
        int right = majorityElementRec(a, mid+1, hi);

        // if the two halves agree on the majority element, return it.
        if (left == right) {
            return left;
        }

        // otherwise, count each element and return the "winner".
        int leftCount = count(a, left, lo, hi);
        int rightCount = count(a, right, lo, hi);

       if(leftCount>rightCount){
           return left;
       }
       return right;
    }
  
  
   public static boolean isMajority(int a[], int size, int cand)
    {
        int i, frequency = 0;
        for (i = 0; i < size; i++)
        {
            if (a[i] == cand)
                frequency++;
        }
        if (frequency > size / 2) {
            return true;
        }
        else{
            return false;
        }
    }
  
    public static int majorityElement1(int[] a) {
        if(isMajority(a,a.length,majorityElementRec(a, 0, a.length-1))){
           return 1;
        }else{
           return 0;
        }
    }
  
    public static int majorityElement2(int[] a) {
        int count = 0;
        int ans = -1;

        for (int num : a) {
            if (count == 0) {
                ans = num;
            }
            count += (num == ans) ? 1 : -1;
        }
       if(isMajority(a,a.length,ans)==false){
           ans=0;
       }else{
           ans=1;
       }
        return ans;
    }
    public static void main(String []args){
       Scanner sc=new Scanner(System.in);
      
       int n=sc.nextInt();
       int a[]=new int[n];
       for(int i=0;i<n;i++){
           a[i]=sc.nextInt();
       }
       /*
       We split the array A into 2 subarraysA1andA2of half the size.
       We choose the majority element ofA1andA2.
       After that we do a linear time equality operation to decide whether it is possible to find a majorityelement.
       The recurrence therefore is given by
       T(n) = 2T(n2) +O(n)
      
       So The complexity of algorithm is O(nlogn)
      
       */
       int ans=0;
       int maj=majorityElement1(a);
       System.out.println("Using O(nlogn) solution :"+ans);
       /*
      
       Idea of the algorithm is that if each occurrence of an element e
       can be cancelled with all the other elements that are different from e
       then e will exist till end if it is a majority element
      
       */
       int maj1=majorityElement2(a);
       System.out.println("Using O(n) solution :"+" "+maj1);
      
    }
}