Major Number

1. Given an array of integers, find a contiguous subarray which has the largest sum.

hint: 

　　Go through the array with 2 variable -- cur and count. cur is to mark the current major element.

　　When we might an element equals to cur, count++; else count--;

　　If count == 0, we remark cur as the next element.

class Sol {
    boolean found;
    int res;
}
public class Solution {
    public int majorityElement(int[] num) {
        Sol sol = helper(num, 0, num.length-1);
        return sol.res;
    }
    public Sol helper(int[] num, int l, int r) {
        Sol sol = new Sol();
        if (l == r) {
            sol.found = true;
            sol.res = num[l];
            return sol;
        }
        int mid = (r - l) / 2 + l;
        boolean foundl = false, foundr = false;
        Sol soll = helper(num, l, mid);
        Sol solr = helper(num, mid+1, r);
        if (soll.found && solr.found && soll.res == solr.res) {
            sol.found = true;
            sol.res = soll.res;
            return sol;
        }
        int half = (r - l + 1) / 2;
        if (soll.found && frequent(num, l, r, soll.res) > half) {
            sol.found = true;
            sol.res = soll.res;
            return sol;
        }
        if (solr.found && frequent(num, l, r, solr.res) > half) {
            sol.found = true;
            sol.res = solr.res;
            return sol;
        }
        else {
            sol.found = false;
            return sol;
        }
    }
    public int frequent(int[] num, int left, int right, int target) {
        int n = 0;
        for (int i = left; i <= right; i++) {
            if (num[i] == target) {
                n++;
            }
        }
        return n;
    }
}

2. Given an array of integers and a number k, the majority number is the number that occurs more than  1/k  of the size of the array.

hint:

　　定义出现频率大于 1/k 的数为频繁项，这样的频繁项最多有 (k-1) 个。

public class MajorNumber {
    public static void main(String[] args) {
        MajorNumber mn = new MajorNumber();
        int[] A = {7,3,3,7,4,3,4,7,3,4,3,4,7,3,4}; // 3-6; 4-5; 7-4;
        int m = 3;
        mn.major(A, m);
    }
    
    public void major(int[] A, int m) {
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        int size = A.length / m;
        System.out.println("size: "+size);
        for (int i = 0; i < A.length; i++) {
            if (map.containsKey(A[i])) {
                int count = map.get(A[i]) + 1;
                map.put(A[i], count);
            } else {
                map.put(A[i], 1);
                if (map.size() >= m) {
                    List<Integer> list = new ArrayList<Integer>();
                    for (Integer key : map.keySet()) {
                        int count = map.get(key) - 1;
                        if (count == 0) {
                            list.add(key);
                        }
                        map.put(key, count);
                    }
                    for (Integer key : list) {
                        map.remove(key);
                    }
                }
            }
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (Integer key : map.keySet()) {
            map.put(key,  0);
        }
        for (int i = 0; i < A.length; i++) {
            if (map.containsKey(A[i])) {
                int count = map.get(A[i]) + 1;
                map.put(A[i], count);
            }
        }
        
        for (Integer key : map.keySet()) {
            if (map.get(key) > size) {
                System.out.println(key);
            }
        }
        return;
    }
}