Problem:
Score : 1100 points

Problem Statement

Snuke got positive integers s_1,...,s_N from his mother, as a birthday present. There may be duplicate elements.

He will circle some of these N integers. Since he dislikes cubic numbers, he wants to ensure that if both s_i and s_j (i ≠ j) are circled, the product s_is_j is not cubic. For example, when s_1=1,s_2=1,s_3=2,s_4=4, it is not possible to circle both s_1 and s_2 at the same time. It is not possible to circle both s_3 and s_4 at the same time, either.

Find the maximum number of integers that Snuke can circle.

Constraints

1 ≦ N ≦ 10^5

1 ≦ s_i ≦ 10^{10}

All input values are integers.

Input

The input is given from Standard Input in the following format:

N
s_1
:
s_N

Output

Print the maximum number of integers that Snuke can circle.

Sample Input 1

8
1
2
3
4
5
6
7
8

Sample Output 1

6

Snuke can circle 1,2,3,5,6,7.

Sample Input 2

6
2
4
8
16
32
64

Sample Output 2

3

Sample Input 3

10
1
10
100
1000000007
10000000000
1000000009
999999999
999
999
999

Sample Output 3

9

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

(eval-when (:compile-toplevel :load-toplevel :execute)
  (sb-int:defconstant-eqx OPT
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0))
    #'equal)
  #+swank (ql:quickload '(:cl-debug-print :fiveam) :silent t)
  #-swank (set-dispatch-macro-character
           ;; enclose the form with VALUES to avoid being captured by LOOP macro
           #\# #\> (lambda (s c p) (declare (ignore c p)) `(values ,(read s nil nil t)))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)
#-swank (disable-debugger) ; for CS Academy

;; BEGIN_INSERTED_CONTENTS
(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  "NOTE: cannot read -2^62"
  (declare #.OPT)
  (macrolet ((%read-byte ()
               `(the (unsigned-byte 8)
                     #+swank (char-code (read-char in nil #\Nul))
                     #-swank (sb-impl::ansi-stream-read-byte in nil #.(char-code #\Nul) nil))))
    (let* ((minus nil)
           (result (loop (let ((byte (%read-byte)))
                           (cond ((<= 48 byte 57)
                                  (return (- byte 48)))
                                 ((zerop byte) ; #\Nul
                                  (error "Read EOF or #\Nul."))
                                 ((= byte #.(char-code #\-))
                                  (setq minus t)))))))
      (declare ((integer 0 #.most-positive-fixnum) result))
      (loop
        (let* ((byte (%read-byte)))
          (if (<= 48 byte 57)
              (setq result (+ (- byte 48)
                              (* 10 (the (integer 0 #.(floor most-positive-fixnum 10))
                                         result))))
              (return (if minus (- result) result))))))))

(declaim (ftype (function * (values simple-bit-vector &optional)) make-prime-table))
(defun make-prime-table (sup)
  "Returns a simple-bit-vector of length SUP, whose (0-based) i-th bit is 1 if i
is prime and 0 otherwise.

Example: (make-prime-table 10) => #*0011010100"
  (declare (optimize (speed 3) (safety 0)))
  (check-type sup (integer 2 (#.array-total-size-limit)))
  (let ((table (make-array sup :element-type 'bit :initial-element 0))
        (sup/64 (ceiling sup 64)))
    ;; special treatment for p = 2
    (dotimes (i sup/64)
      (setf (sb-kernel:%vector-raw-bits table i) #xAAAAAAAAAAAAAAAA))
    (setf (sbit table 1) 0
          (sbit table 2) 1)
    ;; p >= 3
    (loop for p from 3 to (+ 1 (isqrt (- sup 1))) by 2
          when (= 1 (sbit table p))
          do (loop for composite from (* p p) below sup by p
                   do (setf (sbit table composite) 0)))
    table))

;; FIXME: Currently the element type of the resultant vector is (UNSIGNED-BYTE 62).
(declaim (ftype (function * (values (simple-array (integer 0 #.most-positive-fixnum) (*))
                                    simple-bit-vector
                                    &optional))
                make-prime-sequence))
(defun make-prime-sequence (sup)
  "Returns the ascending sequence of primes smaller than SUP."
  (declare (optimize (speed 3) (safety 0)))
  (check-type sup (integer 2 (#.array-total-size-limit)))
  (let ((table (make-prime-table sup)))
    (let* ((length (count 1 table))
           (result (make-array length :element-type '(integer 0 #.most-positive-fixnum)))
           (index 0))
      (declare ((integer 0 #.most-positive-fixnum) length))
      (loop for x below sup
            when (= 1 (sbit table x))
            do (setf (aref result index) x)
               (incf index))
      (values result table))))

(defstruct (prime-data (:constructor %make-prime-data (seq table)))
  (seq nil :type (simple-array (integer 0 #.most-positive-fixnum) (*)))
  (table nil :type simple-bit-vector))

(defun make-prime-data (sup)
  (multiple-value-call #'%make-prime-data (make-prime-sequence sup)))

(declaim (inline factorize)
         (ftype (function * (values list &optional)) factorize))
(defun factorize (x prime-data)
  "Returns the associative list of prime factors of X, which is composed
of (<prime> . <exponent>). E.g. (factorize 40 <prime-table>) => '((2 . 3) (5
. 1)).

- Any numbers beyond the range of PRIME-DATA are regarded as prime.
- The returned list is in descending order w.r.t. prime factors."
  (declare (integer x))
  (setq x (abs x))
  (when (<= x 1)
    (return-from factorize nil))
  (let ((prime-seq (prime-data-seq prime-data))
        result)
    (loop for prime of-type unsigned-byte across prime-seq
          do (when (= x 1)
               (return-from factorize result))
             (loop for exponent of-type (integer 0 #.most-positive-fixnum) from 0
                   do (multiple-value-bind (quot rem) (floor x prime)
                        (if (zerop rem)
                            (setf x quot)
                            (progn
                              (when (> exponent 0)
                                (push (cons prime exponent) result))
                              (loop-finish))))))
    (if (= x 1)
        result
        (cons (cons x 1) result))))

(defmacro dbg (&rest forms)
  #+swank
  (if (= (length forms) 1)
      `(format *error-output* "~A => ~A~%" ',(car forms) ,(car forms))
      `(format *error-output* "~A => ~A~%" ',forms `(,,@forms)))
  #-swank (declare (ignore forms)))

(defmacro define-int-types (&rest bits)
  `(progn
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "UINT~A" b)) () '(unsigned-byte ,b))) bits)
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "INT~A" b)) () '(signed-byte ,b))) bits)))
(define-int-types 2 4 7 8 15 16 31 32 62 63 64)

(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
  (let ((*read-default-float-format* 'double-float))
    (prog1 (princ obj stream) (terpri stream))))

(defconstant +mod+ 1000000007)

;;;
;;; Body
;;;

;; TODO: more efficient handling when modulus is (unsigned-byte 31) or
;; (unsigned-byte 32)
(declaim (inline mod-power))
(defun mod-power (base power modulus)
  "BASE := integer
POWER, MODULUS := non-negative fixnum"
  (declare ((integer 0 #.most-positive-fixnum) modulus power)
           (integer base))
  (if (= modulus 1)
      0
      (labels ((recur (x p)
                 (declare ((integer 0 #.most-positive-fixnum) x p)
                          #+sbcl (values (integer 0 #.most-positive-fixnum)))
                 (cond ((zerop p) 1)
                       ((evenp p) (recur (mod (* x x) modulus) (ash p -1)))
                       (t (mod (* x (recur x (- p 1))) modulus)))))
        (recur (mod base modulus) power))))

(defun %strong-probable-prime-p (n base)
  (declare (optimize (speed 3))
           ((unsigned-byte 62) n base))
  (or (= n base) ; KLUDGE: is it really approriate to put this form here?
      (let ((d (floor (- n 1) (logand (- n 1) (- 1 n)))))
        (labels ((mod-power (base power)
                   (declare ((unsigned-byte 62) base power)
                            #+sbcl (values (unsigned-byte 62) &optional))
                   (cond ((zerop power) 1)
                         ((evenp power)
                          (mod-power (mod (* base base) n) (ash power -1)))
                         (t (mod (* base (mod-power base (- power 1))) n)))))
          (let ((y (mod-power base d)))
            (declare ((unsigned-byte 62) y))
            (or (= y 1)
                (= y (- n 1))
                (let ((s (- (integer-length (logand (- n 1) (- 1 n))) 1)))
                  (loop repeat (- s 1)
                        do (setq y (mod (* y y) n))
                           (when (<= y 1) (return nil))
                           (when (= y (- n 1)) (return t))))))))))

;; https://primes.utm.edu/prove/prove2_3.html
;; TODO: more efficient SPRP
(defun prime-p (n)
  (cond ((<= n 1) nil)
        ((evenp n) (= n 2))
        ((< n 4759123141)
         (loop for base in '(2 7 61)
               always (%strong-probable-prime-p n base)))
        ((< n 341550071728321)
         (loop for base in '(2 3 5 7 11 13 17)
               always (%strong-probable-prime-p n base)))
        (t
         (loop for base in '(2 3 5 7 11 13 17 19 23 29)
               always (%strong-probable-prime-p n base)))))

(defun rho (n)
  (declare #.OPT
           (uint62 n))
  (let ((m (ash 1 (integer-length n))))
    (macrolet ((f (x) `(let ((xx ,x)) (mod (+ c (* xx xx)) n))))
      (loop for c from 1 below 99
            for y of-type uint62 = 2
            for r of-type uint62 = 1
            for q of-type uint62 = 1
            for g of-type uint62 = 1
            for ys of-type uint62 = y
            for x of-type uint62 = y
            do (loop while (= g 1)
                     do (setq x y)
                        (dotimes (_ r)
                          (setq y (f y)))
                        (let ((k 0))
                          (declare (uint62 k))
                          (loop while (and (< k r) (= g 1))
                                do (setq ys y)
                                   (dotimes (_ (min m (- r k)))
                                     (setq y (f y)
                                           q (mod (* q (abs (- x y))) n)))
                                   (setq g (gcd q n))
                                   (incf k m)))
                        (setq r (ash r 1)))
               (when (= g n)
                 (loop while (= g 1)
                       do (setq ys (f ys)
                                g (gcd (abs (- x ys)) n))))
               (when (< g n)
                 (return g))))))

(defconstant +max+ 2500)
(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (pdata (make-prime-data +max+))
         (table (make-hash-table :test #'equal))
         (null-count 0))
    (declare (uint32 n null-count))
    (labels
        ((%factorize (s)
           (let ((factors (factorize s pdata)))
             (if (null factors)
                 nil
                 (let ((largest (caar factors)))
                   (declare (uint62 largest))
                   (cond ((< largest +max+) factors)
                         ((prime-p largest) factors)
                         (t
                          (let* ((p1 (rho largest))
                                 (p2 (floor largest p1)))
                            (cond ((> p1 p2)
                                   (cons (cons p1 1) (cons (cons p2 1) (cdr factors))))
                                  ((< p1 p2)
                                   (cons (cons p2 1) (cons (cons p1 1) (cdr factors))))
                                  (t
                                   (cons (cons p1 2) (cdr factors)))))))))))
         (add (factors)
           (cond ((null factors)
                  (incf null-count))
                 ((= 1 (cdar factors))
                  (if (gethash factors table)
                      (incf (car (gethash factors table)))
                      (setf (gethash factors table) (cons 1 0))))
                 (t
                  (let ((factors (loop for (p . exp) of-type (uint62 . uint62) in factors
                                       collect (cons p (- 3 exp)))))
                    (if (gethash factors table)
                        (incf (cdr (gethash factors table)))
                        (setf (gethash factors table) (cons 0 1))))))))
      (dotimes (i n)
        (let* ((s (read-fixnum))
               (factors (loop for (p . exp) of-type (uint62 . uint62) in (%factorize s)
                              unless (zerop (mod exp 3))
                              collect (cons p (mod exp 3)))))
          (add factors)))
      (println
       (+ (min null-count 1)
          (loop for (count1 . count2) being each hash-value of table
                sum (max count1 count2)))))))

#-swank (main)

;;;
;;; Test and benchmark
;;;

#+swank
(defun io-equal (in-string out-string &key (function #'main) (test #'equal))
  "Passes IN-STRING to *STANDARD-INPUT*, executes FUNCTION, and returns true if
the string output to *STANDARD-OUTPUT* is equal to OUT-STRING."
  (labels ((ensure-last-lf (s)
             (if (eql (uiop:last-char s) #\Linefeed)
                 s
                 (uiop:strcat s uiop:+lf+))))
    (funcall test
             (ensure-last-lf out-string)
             (with-output-to-string (out)
               (let ((*standard-output* out))
                 (with-input-from-string (*standard-input* (ensure-last-lf in-string))
                   (funcall function)))))))

#+swank
(defun get-clipbrd ()
  (with-output-to-string (out)
    (run-program "powershell.exe" '("-Command" "Get-Clipboard") :output out :search t)))

#+swank (defparameter *this-pathname* (uiop:current-lisp-file-pathname))
#+swank (defparameter *dat-pathname* (uiop:merge-pathnames* "test.dat" *this-pathname*))

#+swank
(defun run (&optional thing (out *standard-output*))
  "THING := null | string | symbol | pathname

null: run #'MAIN using the text on clipboard as input.
string: run #'MAIN using the string as input.
symbol: alias of FIVEAM:RUN!.
pathname: run #'MAIN using the text file as input."
  (let ((*standard-output* out))
    (etypecase thing
      (null
       (with-input-from-string (*standard-input* (delete #\Return (get-clipbrd)))
         (main)))
      (string
       (with-input-from-string (*standard-input* (delete #\Return thing))
         (main)))
      (symbol (5am:run! thing))
      (pathname
       (with-open-file (*standard-input* thing)
         (main))))))

#+swank
(defun gen-dat ()
  (uiop:with-output-file (out *dat-pathname* :if-exists :supersede)
    (format out "")))

#+swank
(defun bench (&optional (out (make-broadcast-stream)))
  (time (run *dat-pathname* out)))

;; To run: (5am:run! :sample)
#+swank
(it.bese.fiveam:test :sample
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "8
1
2
3
4
5
6
7
8
"
    "6
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "6
2
4
8
16
32
64
"
    "3
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "10
1
10
100
1000000007
10000000000
1000000009
999999999
999
999
999
"
    "9
")))