Problem p02642 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
/*
// AUTHOR wiley_codechef
// TASK : Atcoder
//--------------------------------HEADERS-------------------------------------------------------------//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;

//-------------------------------------------------------Typedefs----------------------------------------------//

typedef long long int ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

typedef pair<string, string> pss;

typedef vector<int> vi;

typedef vector<vi> vvi;

typedef vector<pii> vii;

typedef vector<ll> vl;

typedef vector<vl> vvl;



double EPS = 1e-9;

int INF = 1000000005;

long long INFF = 1000000000000000005LL;

double PI = acos(-1);

int dirx[8] = { -1, 0, 0, 1, -1, -1, 1, 1 };

int diry[8] = { 0, 1, -1, 0, -1, 1, -1, 1 };

//---------------------------------------------------------Hash
defines--------------------------------------------------//

# define    PII     3.14159265358979323846
#ifdef TESTING
#define DEBUG fprintf(stderr, "====TESTING====\n")
#define VALUE(x) cerr << "The value of " << #x << " is " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define DEBUG
#define VALUE(x)
#define debug(...)
#endif


#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
#define FORN(a, b, c) for (int(a) = (b); (a) <= (c); ++(a))
#define FORD(a, b, c) for (int(a) = (b); (a) >= (c); --(a))
#define FORSQ(a, b, c) for (int(a) = (b); (a) * (a) <= (c); ++(a))
#define FORC(a, b, c) for (char(a) = (b); (a) <= (c); ++(a))
#define FOREACH(a, b) for (auto&(a) : (b))
#define REP(i, n) FOR(i, 0, n)
#define REPN(i, n) FORN(i, 1, n)
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define SQR(x) ((ll)(x) * (x))
#define RESET(a, b) memset(a, b, sizeof(a))
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ALL(v) v.begin(), v.end()
#define ALLA(arr, sz) arr, arr + sz
#define SIZE(v) (int)v.size()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define SORTA(arr, sz) sort(ALLA(arr, sz))
#define REVERSEA(arr, sz) reverse(ALLA(arr, sz))
#define PERMUTE next_permutation
#define T(a) ll a; cin >> a;
#define TT(t) T(t); while (t--)
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define f(i, x, y) for(int i = x; i < y; i++)
#define array(a)   ll a[n];
#define line "\n";
//-------------------------------------------------TEMPLATES----------------------------------------------------------//

        template<class T> T max(T a, T b, T c) {
            return max(a, max(b, c));
        }
        template<class T> T min(T a, T b, T c) {
            return min(a, min(b, c));
        }
        void SieveOfEratosthenes(ll n)//O(nloglogn)
        {
                ll prime[n];
            memset(prime, true, sizeof(prime));

            for (ll p = 2; p * p <= n; p++)
            {
                if (prime[p] == true)
                {
                    for (ll i = p * p; i <= n; i += p)
                        prime[i] = false;
                }
            }
        }
        bool isPrime(ll n)//O(sqrt(n))
        {
            if (n < 2)
                return false;
            for (ll i = 2; i * i <= n; i++)
                if (n % i == 0)
                    return false;
            return true;
        }
        std::vector<ll> generatePrimeFactors(ll n)
        {
            std::vector<ll> prime;
            for (ll i = 2; i * i <= n; i++)
            {
                if (n % i == 0)
                {
                    prime.pb(i);
                    while (n % i == 0)
                        n = n / i;
                }
            }
            if (n != 1)
                prime.pb(n);
            return prime;
        }
        std::vector<ll> generateFactors(ll n)
        {
            std::vector<ll> fact;
            for (ll i = 2; i * i <= n; i++)
            {
                if (n % i == 0)
                {
                    fact.pb(i);
                    if (n / i != i)
                        fact.pb(n / i);
                    //24 - 1,2,3,4,6,8,12
                }
            }
            fact.pb(1);
            if (n != 1)
                fact.pb(n);
            sort(fact.begin(), fact.end());
            return fact;
        }

        ll extendedGCD(ll a, ll b, ll &x, ll &y)
        {
            //produces correct results for negative integers as well
            if (a == 0)
            {
                x = 0;
                y = 1;
                return b;
            }
            ll x1, y1, d;
            d = extendedGCD(b % a, a, x1, y1);
            x = y1 - (b / a) * x1;
            y = x1;
            return d;
        }
        ll gcd(ll a, ll b) //O(log min(a,b))
        {
            /*
            recursive implementation below
            if(!b) return a;
            return gcd(b,a%b);
            */

int n, ans;
vector<int> v(200010);
unordered_map<int, int> M;
int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> v[i + 1];
    M[v[i + 1]]++;
  }
  for (int i = 1; i <= n; i++) {
    int flag = 1;
    for (ll j = 1; j * j <= v[i]; j++) {
      if (v[i] % j == 0) {
        // v[i]/j, j
        if (j == v[i] && M[j] >= 2 || j != v[i] && M[j] >= 1 ||
            v[i] / j == v[i] && M[v[i] / j] >= 2 ||
            v[i] / j != v[i] && M[v[i] / j] >= 1) {
          flag = 0;
          break;
        }
      }
    }
    if (flag)
      ans++;
  }
  cout << ans;
}

Fixed submission:
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
/*
// AUTHOR wiley_codechef
// TASK : Atcoder
//--------------------------------HEADERS-------------------------------------------------------------//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
*/
int n, ans;
vector<int> v(200010);
unordered_map<int, int> M;
int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> v[i + 1];
    M[v[i + 1]]++;
  }
  for (int i = 1; i <= n; i++) {
    int flag = 1;
    for (ll j = 1; j * j <= v[i]; j++) {
      if (v[i] % j == 0) {
        // v[i]/j, j
        if (j == v[i] && M[j] >= 2 || j != v[i] && M[j] >= 1 ||
            v[i] / j == v[i] && M[v[i] / j] >= 2 ||
            v[i] / j != v[i] && M[v[i] / j] >= 1) {
          flag = 0;
          break;
        }
      }
    }
    if (flag)
      ans++;
  }
  cout << ans;
}