Lưu ý: Các code mẫu dưới đây chỉ mang tính tham khảo và có thể không AC được bài tập này

Code mẫu của flashmt

#include<iostream>
#include<algorithm>
#define fr(a,b,c) for (a=b;a<=c;a++)
#define maxn 222
using namespace std;
int n,nq,c[maxn][maxn],a[maxn],b[maxn],d[maxn],q[maxn],mid,t,v[maxn],e[maxn];

int find()
{
    int i,x,y;
    nq=0;
    fr(i,1,n) 
    {
       d[i]=0; e[i]=0;
    }
    fr(i,1,n)
      if (!a[i])
      {
         nq++; q[nq]=i;
      }
    i=1;
    while (i<=nq)
    {
        x=q[i++]; e[x]=1;
        fr(y,1,n)  
          if (c[x][y] && !d[y])
          {
             d[y]=x;
             if (!b[y])
             {
                t=y; 
                return 1;
             }
             nq++; q[nq]=b[y];
          }
    }
    return 0;
}

void inc()
{
     int x,y;
     while (t)
     {
           x=d[t]; y=t;
           t=a[x]; a[x]=y; b[y]=x;
     }
}

int main()
{
    int i,j,re=0;
    cin >> n;
    fr(i,1,n) cin >> v[i];
    fr(i,1,n-1)
      fr(j,i+1,n)
        if (v[i]>v[j]) swap(v[i],v[j]);
    fr(i,1,n-1)
      fr(j,i+1,n)
        if (v[j]%v[i]==0) c[j][i]=1;
    while (find()) inc();
    fr(i,1,n)
      if (!d[i] && e[i]) re++;
    cout << re << endl;
    fr(i,1,n)
      if (!d[i] && e[i]) cout << v[i] << " ";
    return 0;    
}

Code mẫu của ladpro98

#include <bits/stdc++.h>
const int N = 222;
const int oo = N * N;
using namespace std;
vector<int> a[N];
bool in[N];
int cover[N], b[N], st[N], res[N];
int n;

void Enter() {
    scanf("%d\n", &n);
    int i, j;
    for(i=1; i<=n; i++) scanf("%d", &b[i]);
    for(i=1; i<n; i++) for(j=i+1; j<=n; j++)
    if (b[i] % b[j] == 0 || b[j] % b[i] == 0) {
        a[i].push_back(j); a[j].push_back(i);
    }

}

int deg(int u) {
    int s = 0, i, v;
    for(i=0; i<a[u].size(); i++) {
        v = a[u][i];
        if (cover[v] == 0) s++;
    }
    return s;
}

void Push(int u) {
    in[u] = true;
    cover[u] = 1;
    int i, v;
    for(i=0; i<a[u].size(); i++) {
        v = a[u][i];
        cover[v]++;
    }
}

void Pop(int u) {
    in[u] = false;
    cover[u] = 0;
    int i, v;
    for(i = 0; i<a[u].size(); i++) {
        v = a[u][i];
        cover[v]--;
    }
}

void Greedy() {
    int minD, v, i, td;
    while (true) {
        minD = oo;  v = 0;
        for(i=1; i<=n; i++)
        if (cover[i] == 0) {
            td = deg(i);
            if (minD > td) {
                minD = td;
                v = i;
            }
        }
        if (v == 0) break;
        Push(v);
    }
}

bool Optimize() {
    int i, j, cnt;
    for(i=1; i<=n; i++)
    if (in[i]) {
        //try pop it out
        Pop(i); cnt = 0;
        //how many vertexes can we push in
        for(j=1; j<=n; j++)
        if (cover[j] == 0) {
            st[++cnt] = j; Push(j);
        }
        if (cnt > 1) return true;
        for(j=1; j<=cnt; j++) Pop(st[j]);
        Push(i);
    }
    return false;
}

int main()
{
    Enter();
    Greedy();
    while (Optimize());
    int i, cnt = 0;
    for(i=1; i<=n; i++)
        if (in[i]) res[++cnt] = b[i];
    printf("%d\n", cnt);
    for(i=1; i<=cnt; i++) printf("%d ", res[i]);
    return 0;
}

Code mẫu của RR

//Wishing myself a happy lunar new year with a lot of accept solutions
//Written by Nguyen Thanh Trung
{$R+,Q+}
uses math;
const
  FINP='';
  FOUT='';
  MAXN=201;
var
  ke:array[1..MAXN,1..MAXN] of longint;
  choose,deg,queue,matchX,matchY,trace,a:array[1..MAXN] of longint;
  first,last,n:longint;
  f1,f2:text;
procedure openF;
begin
  assign(f1,FINP); reset(f1);
  assign(f2,FOUT); rewrite(f2);
end;
procedure closeF;
begin
  close(f1); close(f2);
end;
procedure inp;
var
  i:longint;
begin
  read(f1,n);
  for i:=1 to n do read(f1,a[i]);
end;
var
  temp:longint;
procedure swap(var a,b:longint); inline;
begin
  temp:=a; a:=b; b:=temp;
end;
var
  mid:longint;
procedure sort(l,r:longint);
var
  i,j:longint;
begin
  i:=l; j:=r; mid:=a[l+random(r-l+1)];
  repeat
    while a[i]<mid do inc(i);
    while a[j]>mid do dec(j);
    if i<=j then
      begin
        swap(a[i],a[j]);
        inc(i); dec(j);
      end;
  until i>j;
  if i<r then sort(i,r);
  if l<j then sort(l,j);
end;
procedure refine;
var
  i,j:longint;
begin
  j:=1;
  for i:=2 to n do
    if a[i]>a[j] then
      begin
        inc(j);
        a[j]:=a[i];
      end;
  n:=j;
end;
procedure init;
var
  i,j:longint;
begin
  for i:=1 to n do
  for j:=1 to n do
    if i<>j then
    if a[i] mod a[j]=0 then
      begin
        inc(deg[i]);
        ke[i,deg[i]]:=j;
      end;
end;
procedure ans;
var
  i,count:longint;
begin
  count:=0;
  for i:=1 to n do
    if matchY[i]=0 then inc(count);
  writeln(f2,count);
  for i:=1 to n do
    if choose[i]=0 then write(f2,a[i],' ');
  writeln(f2);
end;
function findPath(startu:longint):longint;
var
  u,v,i:longint;
begin
  fillchar(trace,sizeof(trace),0);
  first:=1; last:=1; queue[1]:=startu;
  while first<=last do
    begin
      u:=queue[first]; inc(first);
      for i:=1 to deg[u] do
        begin
          v:=ke[u,i];
          if (matchX[u]<>v) and (trace[v]=0) then
            begin
              trace[v]:=u;
              if matchY[v]=0 then exit(v);
              inc(last); queue[last]:=matchY[v];
            end;
        end;
    end;
  findPath:=0;
end;
procedure incMatch(y:longint);
var
  x,next:longint;
begin
  if y=0 then exit;
  repeat
    x:=trace[y];
    next:=matchX[x];
    matchX[x]:=y;
    matchY[y]:=x;
    y:=next;
  until y=0;
end;
procedure bfs(u:longint);
var
  v,i:longint;
begin
  first:=1; last:=1; queue[1]:=u;
  while first<=last do
    begin
      u:=queue[first]; inc(first);
      for i:=1 to deg[u] do
        begin
          v:=ke[u,i];
          if choose[v]=0 then
            begin
              choose[v]:=1;
              inc(last); queue[last]:=matchY[v];
            end;
        end;
    end;
end;
procedure solve;
var
  i:longint;
begin
  //Tim cap ghep
  for i:=1 to n do
    incMatch(findPath(i));
  //Xac dinh tap Y* gom cac dinh v thuoc Y ma den duoc tu 1 dinh chua
  //ghep u thuoc X, qua 1 duong pha
  for i:=1 to n do
    if matchX[i]=0 then bfs(i);
  //Xac dinh tap X* gom cac dinh da ghep u thuoc X ma matchX[u] khong thuoc Y*
  for i:=1 to n do
    if matchX[i]<>0 then
    if choose[matchX[i]]<>1 then choose[i]:=2;
end;
begin
  openF;
  inp;
  sort(1,n);
  refine;
  init;
  solve;
  ans;
  closeF;
end.

Code mẫu của hieult

#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <iomanip>
#include <iostream>
#include <algorithm>

#include <ctime>
#include <deque>
#include <bitset>
#include <cctype>
#include <utility>
#include <cassert>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned int ui;
typedef unsigned long long ull;

#define Rep(i,n) for(int i = 0; i < (n); ++i)
#define Repd(i,n) for(int i = (n)-1; i >= 0; --i)
#define For(i,a,b) for(int i = (a); i <= (b); ++i)
#define Ford(i,a,b) for(int i = (a); i >= (b); --i)
#define Fit(i,v) for(__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i)
#define Fitd(i,v) for(__typeof((v).rbegin()) i = (v).rbegin(); i != (v).rend(); ++i)
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define sz(a) ((int)(a).size())
#define all(a) (a).begin(), (a).end()
#define ms(a,x) memset(a, x, sizeof(a))

template<class F, class T> T convert(F a, int p = -1) { stringstream ss; if (p >= 0) ss << fixed << setprecision(p); ss << a; T r; ss >> r; return r; }
template<class T> T gcd(T a, T b) { T r; while (b != 0) { r = a % b; a = b; b = r; } return a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<class T> T sqr(T x) { return x * x; }
template<class T> T cube(T x) { return x * x * x; }
template<class T> int getbit(T s, int i) { return (s >> i) & 1; }
template<class T> T onbit(T s, int i) { return s | (T(1) << i); }
template<class T> T offbit(T s, int i) { return s & (~(T(1) << i)); }
template<class T> int cntbit(T s) { return s == 0 ? 0 : cntbit(s >> 1) + (s & 1); }

const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
    if (rsz <= 0) {
        ptr = 0;
        rsz = (int) fread(bf, 1, bfsz, stdin);
        if (rsz <= 0)
            return EOF;
    }
    --rsz;
    return bf[ptr++];
}
void ga(char &c) {
    c = EOF;
    while (!isalpha(c))
        c = gc();
}
int gs(char s[]) {
    int l = 0;
    char c = gc();
    while (isspace(c))
        c = gc();
    while (c != EOF && !isspace(c)) {
        s[l++] = c;
        c = gc();
    }
    s[l] = '\0';
    return l;
}
template<class T> bool gi(T &v) {
    v = 0;
    char c = gc();
    while (c != EOF && c != '-' && !isdigit(c))
        c = gc();
    if (c == EOF)
        return false;
    bool neg = c == '-';
    if (neg)
        c = gc();
    while (isdigit(c)) {
        v = v * 10 + c - '0';
        c = gc();
    }
    if (neg)
        v = -v;
    return true;
}

typedef pair<int, int> II;

const double PI = acos(-1.0);
const double eps = 1e-9;

const int dr[] = {0, +1, 0, -1};
const int dc[] = {+1, 0, -1, 0};

const int inf = (int)1e9 + 5;
const ll linf = (ll)1e16 + 5;
const ll mod = (ll)1e9 + 7;

#define maxn 1005
#define maxv 1005
#define maxe 100005

struct HopcroftKarp {
    int nx, ny, E, adj[maxe], next[maxe], last[maxv], run[maxv], level[maxv], que[maxv], matx[maxv], maty[maxv];

    void init(int _nx, int _ny) {
        nx = _nx; ny = _ny;
        E = 0; ms(last, -1);
        ms(matx, -1); ms(maty, -1);
    }

    void add(int x, int y) {
        adj[E] = y; next[E] = last[x]; last[x] = E++;
    }

    bool bfs() {
        int qsize = 0;

        For(x, 1, nx) if (matx[x] != -1) level[x] = -1;
        else {
            level[x] = 0;
            que[qsize++] = x;
        }

        bool found = false;

        Rep(i, qsize) {
            for (int x = que[i], e = last[x]; e != -1; e = next[e]) {
                int y = adj[e];
                if (maty[y] == -1) found = true;
                else if (level[maty[y]] == -1) {
                    level[maty[y]] = level[x] + 1;
                    que[qsize++] = maty[y];
                }
            }
        }

        return found;
    }

    int dfs(int x) {
        for (int &e = run[x]; e != -1; e = next[e]) {
            int y = adj[e];
            if (maty[y] == -1 || (level[maty[y]] == level[x] + 1 && dfs(maty[y]))) {
                matx[x] = y;
                maty[y] = x;
                return 1;
            }
        }
        return 0;
    }

    int maxmat() {
        int total = 0;

        while (bfs()) {
            For(x, 1, nx) run[x] = last[x];
            For(x, 1, nx) if (matx[x] == -1) total += dfs(x);
        }

        return total;
    }
} hopkarp;

int n, a[maxn], hx[maxn], hy[maxn];

int main(){
//  freopen("in.txt", "r", stdin);

    cin >> n;
    For(i, 1, n) cin >> a[i];
    sort(a + 1, a + n + 1);

    hopkarp.init(n, n);
    For(i, 1, n) For(j, 1, i - 1) if(a[i] % a[j] == 0){
        hopkarp.add(i, j);
    }

    hopkarp.maxmat();
    vector<int> V;

//  For(i, 1, n) printf("%d %d %d\n", hopkarp.matx[i], hopkarp.maty[i], hopkarp.level[i]);

    ms(hx, 0); ms(hy, 0);
    For(i, 1, n) if(hopkarp.maty[i] > -1 && hopkarp.level[hopkarp.maty[i]] > 0){
        hx[i] = 1;
    }
    For(i, 1, n) if(hopkarp.matx[i] != -1 && hx[hopkarp.matx[i]] == 0) {
        hy[i] = 1;
    }
    For(i, 1, n) if(!hx[i] && !hy[i]) V.pb(a[i]);

    cout << sz(V) << endl;
    Rep(i, sz(V)) printf("%d%c", V[i], i == sz(V) - 1 ? '\n' : ' ');

    return 0;
}

Code mẫu của ll931110

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;

int a[202],b[202];
bool visitX[202],visitY[202];
int trace[202],matchX[202],matchY[202];
vector<int> adj[202];
int n,k;

int findpath(int s)
{
    memset(trace,0,sizeof(trace));
    queue<int> q;  q.push(s);
    while (!q.empty())
    {
      int u = q.front(); q.pop();
      for (int i = 0; i < adj[u].size(); i++)
      {
          int v = adj[u][i];
          if (!trace[v])
          {
             trace[v] = u;
             if (!matchY[v]) return v;
             q.push(matchY[v]);
          };
      };
    };
    return 0;
};

void enlarge(int f)
{
     while (f)
     {
           int x = trace[f],next = matchX[x];
           matchX[x] = f;  matchY[f] = x;
           f = next;
     };
};

void findans()
{
     memset(visitX,false,sizeof(visitX));
     memset(visitY,false,sizeof(visitY));
     queue<int> q;
     for (int i = 1; i <= n; i++) if (!matchX[i]) 
     {
         q.push(i);  visitX[i] = true;
     };

     while (!q.empty())
     {
           int u = q.front();  q.pop();
           for (int i = 0; i < adj[u].size(); i++)
           {
               int v = adj[u][i];
               if (visitY[v]) continue;
               visitY[v] = true;  visitX[matchY[v]] = true;  q.push(matchY[v]);
           };
     };
};

int main()
{
//    freopen("divrel.in","r",stdin);
//    freopen("divrel.ou","w",stdout);

    scanf("%d", &k);
    for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
    sort(a + 1,a + k + 1);
    b[1] = a[1];  n = 1;
    for (int i = 2; i <= k; i++) if (a[i] > a[i - 1]) b[++n] = a[i];

    for (int i = 1; i <= n; i++) 
      for (int j = 1; j <= n && j != i; j++) if (b[i] % b[j] == 0) adj[i].push_back(j);
    memset(matchX,0,sizeof(matchX));
    memset(matchY,0,sizeof(matchY));
    for (int i = 1; i <= n; i++) enlarge(findpath(i));

    findans();  
    int ret = 0;
    for (int i = 1; i <= n; i++) if (visitX[i] && !visitY[i]) ret++;
    printf("%d\n", ret);
    for (int i = 1; i <= n; i++) if (visitX[i] && !visitY[i]) printf("%d ", b[i]);
};

Code mẫu của khuc_tuan

#include <iostream>
using namespace std;

int n, a[202];
bool vs[422], mark[222];
int cap[422][422], flow[422][422];

bool dfs(int i) {
    if(vs[i]) return false;
    if(i==2*n+1) return true;
    vs[i] = true;
    for(int j=0;j<2*n+2;++j) {
        if(cap[i][j] > flow[i][j] && dfs(j)) {
            ++ flow[i][j];
            return true;
        }
        else if(flow[j][i] > 0 && dfs(j)) {
            -- flow[j][i];
            return true;
        }
    }
    return false;
}

int main() {
    scanf("%d", &n);
    for(int i=0;i<n;++i)
        scanf("%d", a+i);
    sort( a, a+n);
    n = unique( a, a+n) - a;
    for(int i=0;i<n;++i) 
        for(int j=i+1;j<n;++j)
            if(a[j] % a[i] == 0)
                cap[i][j+n] = 1000;
    for(int i=0;i<n;++i) cap[2*n][i] = 1;
    for(int i=n;i<2*n;++i) cap[i][2*n+1] = 1;
    int dem = 0;
    while(1) { memset( vs, 0, sizeof(vs)); if(!dfs(2*n)) break; else ++dem; }
    printf("%d\n", n - dem);
    for(int i=0;i<n;++i) if(!vs[i] || vs[i+n]) mark[i] = true;
    for(int i=0;i<n;++i) if(!mark[i]) printf("%d ", a[i]);
    // system("pause");
    return 0;
}