Language: C++

#include <stdio.h>
#include <bits/stdc++.h>			
 
#define pb push_back
#define pf push_front
#define pp pop_back
#define sz(a) (int)(a.size())
#define mp make_pair
#define F first
#define S second
#define next _next
#define prev _prev
#define left _left
#define right _right
#define y1 _y1
#define all(x) x.begin(), x.end()
#define what_is(x) #x << " is " << (x)

#define int ll
 
using namespace std;
 
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
 
const int N = (int)1e6 + 123;
const ll INF = (ll)1e18 + 123;
const int inf = (int)1e9 + 123;
const int MOD = (int)1e9 + 7;
 
ll need[N], waste[N];
ll a[N];
int n;
vector<int> pr;
 
bool is_prime(int x) {
	for(int i = 2; 1ll * i * i <= x; i ++)
		if(x % i == 0)
			return 0;
	return 1;
}
 
map<ll, int> square;
map<ll, set<int> > ne, wa;
set<ll> st;
 
main() {
	cin >> n;
	for(int i = 1; i <= n; i ++)
		cin >> a[i];
	for(int i = 1; i <= n; i ++) {
		for(ll x = (int)3e3; x >= 1; x --) {
			if(a[i] % (x * x * x) == 0)	{
				waste[i] = a[i] / (x * x * x);
				break;
			}
		}
	}
	for(int x = 2; x <= (int)3e3; x ++) {
		if(is_prime(x)) {
			pr.pb(x);
		}
	}
	for(int x = 1; x <= (int)1e5; x ++) 
		square[1ll * x * x] = x;
	
	for(int i = 1; i <= n; i ++) {
		ll tmp = a[i], tmp_need = 1;
		for(int it = 0; it < sz(pr); it ++) {
			int cnt = 0;
			while(tmp % pr[it] == 0) 
				cnt ++, tmp /= pr[it];
			cnt %= 3;
			if(cnt == 1) tmp_need *= pr[it] * pr[it];
			if(cnt == 2) tmp_need *= pr[it];			
		}
		if(!square.count(tmp))
			tmp_need *= tmp;
		else 
			tmp_need *= square[tmp];
		
		need[i] = tmp_need;
	}
	for(int i = 1; i <= n; i ++) {
		ne[need[i]].insert(i), wa[waste[i]].insert(i);
		st.insert(need[i]);
		st.insert(waste[i]);
	}
	int res = 0;
	for(auto x : st) {
		if(x == 1) continue;
 
	  if(sz(ne[x]) > sz(wa[x])) res += sz(ne[x]);
	  else res += sz(wa[x]);	  	
 
	 	for(auto ind : ne[x])
	  	if(waste[ind] != x)
		  	wa[waste[ind]].erase(ind);
	 	for(auto ind : wa[x])
	  	if(ne[ind] != x)
		  	ne[need[ind]].erase(ind);
	}
	if(sz(ne[1]) || sz(wa[1]))
		res ++;
	cout << res;
	return 0;  
}


Compiler output:
a.cc:50:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
   50 | main() {
      | ^~~~
a.cc: In function 'int main()':
a.cc:103:28: error: no match for 'operator!=' (operand types are 'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} and 'long long int')
  103 |                 if(ne[ind] != x)
In file included from /usr/include/c++/14/regex:68,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:181,
                 from a.cc:2:
/usr/include/c++/14/bits/regex.h:1132:5: note: candidate: 'template<class _BiIter> bool std::__cxx11::operator!=(const sub_match<_BiIter>&, const sub_match<_BiIter>&)'
 1132 |     operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1132:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::__cxx11::sub_match<_BiIter>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/regex.h:1212:5: note: candidate: 'template<class _Bi_iter, class _Ch_traits, class _Ch_alloc> bool std::__cxx11::operator!=(__sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>&, const sub_match<_BiIter>&)'
 1212 |     operator!=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1212:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'std::__cxx11::__sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/regex.h:1305:5: note: candidate: 'template<class _Bi_iter, class _Ch_traits, class _Ch_alloc> bool std::__cxx11::operator!=(const sub_match<_BiIter>&, __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>&)'
 1305 |     operator!=(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1305:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::__cxx11::sub_match<_BiIter>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/regex.h:1379:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator!=(const typename std::iterator_traits<_Iter>::value_type*, const sub_match<_BiIter>&)'
 1379 |     operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1379:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   mismatched types 'const std::__cxx11::sub_match<_BiIter>' and 'long long int'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/regex.h:1473:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator!=(const sub_match<_BiIter>&, const typename std::iterator_traits<_Iter>::value_type*)'
 1473 |     operator!=(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1473:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::__cxx11::sub_match<_BiIter>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/regex.h:1547:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator!=(const typename std::iterator_traits<_Iter>::value_type&, const sub_match<_BiIter>&)'
 1547 |     operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1547:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   mismatched types 'const std::__cxx11::sub_match<_BiIter>' and 'long long int'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/regex.h:1647:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator!=(const sub_match<_BiIter>&, const typename std::iterator_traits<_Iter>::value_type&)'
 1647 |     operator!=(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1647:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::__cxx11::sub_match<_BiIter>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/regex.h:2213:5: note: candidate: 'template<class _Bi_iter, class _Alloc> bool std::__cxx11::operator!=(const match_results<_BiIter, _Alloc>&, const match_results<_BiIter, _Alloc>&)'
 2213 |     operator!=(const match_results<_Bi_iter, _Alloc>& __m1,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:2213:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::__cxx11::match_results<_BiIter, _Alloc>'
  103 |                 if(ne[ind] != x)
      |                               ^
In file included from /usr/include/c++/14/bits/stl_algobase.h:64,
                 from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51:
/usr/include/c++/14/bits/stl_pair.h:1052:5: note: candidate: 'template<class _T1, class _T2> constexpr bool std::operator!=(const pair<_T1, _T2>&, const pair<_T1, _T2>&)'
 1052 |     operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:1052:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::pair<_T1, _T2>'
  103 |                 if(ne[ind] != x)
      |                               ^
In file included from /usr/include/c++/14/bits/stl_algobase.h:67:
/usr/include/c++/14/bits/stl_iterator.h:455:5: note: candidate: 'template<class _Iterator> constexpr bool std::operator!=(const reverse_iterator<_Iterator>&, const reverse_iterator<_Iterator>&)'
  455 |     operator!=(const reverse_iterator<_Iterator>& __x,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:455:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::reverse_iterator<_Iterator>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/stl_iterator.h:500:5: note: candidate: 'template<class _IteratorL, class _IteratorR> constexpr bool std::operator!=(const reverse_iterator<_Iterator>&, const reverse_iterator<_IteratorR>&)'
  500 |     operator!=(const reverse_iterator<_IteratorL>& __x,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:500:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::reverse_iterator<_Iterator>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/stl_iterator.h:1686:5: note: candidate: 'template<class _IteratorL, class _IteratorR> constexpr bool std::operator!=(const move_iterator<_IteratorL>&, const move_iterator<_IteratorR>&)'
 1686 |     operator!=(const move_iterator<_IteratorL>& __x,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1686:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::move_iterator<_IteratorL>'
  103 |                 if(ne[ind] != x)
      |                               ^
/usr/include/c++/14/bits/stl_iterator.h:1753:5: note: candidate: 'template<class _Iterator> constexpr bool std::operator!=(const move_iterator<_IteratorL>&, const move_iterator<_IteratorL>&)'
 1753 |     operator!=(const move_iterator<_Iterator>& __x,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1753:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::move_iterator<_IteratorL>'
  103 |                 if(ne[ind] != x)
      |                               ^
In file included from /usr/include/c++/14/bits/char_traits.h:42,
                 from /usr/include/c++/14/string:42,
                 from /usr/include/c++/14/bitset:52,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:52:
/usr/include/c++/14/bits/postypes.h:197:5: note: candidate: 'template<class _StateT> bool std::operator!=(const fpos<_StateT>&, const fpos<_StateT>&)'
  197 |     operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
      |     ^~~~~~~~
/usr/include/c++/14/bits/postypes.h:197:5: note:   template argument deduction/substitution failed:
a.cc:103:31: note:   'std::map<long long int, std::set<long long int> >::mapped_type' {aka 'std::set<long long int>'} is not derived from 'const std::fpos<_StateT>'
  103 |                 if(ne[ind] != x)
      |                               ^
In file included from /usr/include/c++/14/string:43:
/usr/include/c++/14/bits/allocator.h:243:5: note: candidate: 'template<class _T1, class _T2> bool std::operator!=(const allocator<_CharT>&, const allocator<_T2>&)'
  243 |     operator!=(const allocat