Problem:
Score : 400 points

Problem Statement

Given is a number sequence A of length N.

Find the number of integers i \left(1 \leq i \leq N\right) with the following property:

For every integer j \left(1 \leq j \leq N\right) such that i \neq j , A_j does not divide A_i.

Constraints

All values in input are integers.

1 \leq N \leq 2 \times 10^5

1 \leq A_i \leq 10^6

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \cdots A_N

Output

Print the answer.

Sample Input 1

5
24 11 8 3 16

Sample Output 1

3

The integers with the property are 2, 3, and 4.

Sample Input 2

4
5 5 5 5

Sample Output 2

0

Note that there can be multiple equal numbers.

Sample Input 3

10
33 18 45 28 8 19 89 86 2 4

Sample Output 3

5

Solution in Rust (1.42.0) (judge verdict: Time Limit Exceeded)

#![allow(non_snake_case)]
#![allow(unused_imports)]

use proconio::{input, fastout};
use proconio::marker::*;
use whiteread::parse_line;
use std::collections::*;
use num::*;

use itertools::Itertools;
use itertools_num::ItertoolsNum;

pub fn enum_divisors(n: usize) -> Vec<usize> {
    let mut res: Vec<usize> = Vec::new();

    let mut i: usize = 1;

    while i * i <= n {
        if n % i == 0 {
            res.push(i);
            if n / i != i { res.push(n / i) }
        }
        i += 1;
    }
    res.sort();
    res
}

#[fastout]
fn main() {
    input!{
        n: usize,
        mut a_vec: [usize; n],
    }

    a_vec.sort();
    let a_set = a_vec.iter().map(|x| *x).collect::<HashSet<usize>>();
    // dbg!(&a_vec);
    let mut map: HashMap<usize, usize> = HashMap::new();
    for a in a_vec.iter() {
        *map.entry(*a).or_insert(0) += 1;
    }

    let duplicated = map.iter().filter(|&(_, y)| *y > 1).map(|(x, _)| *x).collect::<HashSet<usize>>();
    // dbg!(&duplicated);   
    let mut ans = 0;

    for i in 0..n {
        if duplicated.clone().contains(&a_vec[i]) { continue }
        // if i == n-1 && n-1 != 0 && a_vec[i] == a_vec[i-1] {
        //     continue
        // }
        let divisors: HashSet<usize> = enum_divisors(a_vec[i]).into_iter().collect();
        // dbg!(&divisors);
        let set = divisors.intersection(&a_set).collect::<HashSet<_>>();
        // dbg!(&a_vec[i], &set);
        if set.len() == 1 && set.contains(&&a_vec[i]) {
            ans += 1;
        }
    }

    println!("{}", ans);
}