Code C++

#include <bits/stdc++.h>
using namespace std;
int main()
{
 unsigned long long n, a, b, lcm, boia, boib, boilcm;
 cin >> n >> a >> b;
 boia = n / a;
 boib = n / b;
 lcm = (a * b) / __gcd(a, b);
 boilcm = n / lcm;
 cout << boia + boib - boilcm;
}

=============================

Code pascal

program Hello;
uses crt;
var n, a, b: int64;
function gcd(a, b: Int64): Int64;
var
  temp: Int64;
begin
  while b <> 0 do
  begin
    temp := b;
    b := a mod b;
    a := temp
  end;
  gcd:= a
end;
function dem(a, b, n: int64): int64;
var lcm, boia, boib, boilcm: int64;
begin
    boia:= n div a;
    boib:= n div b;
    lcm:= (a * b) div gcd(a,b);
    boilcm:= n div lcm;
    dem:= boia + boib - boilcm;
end;
begin
    readln(n, a, b);
    writeln(dem(a, b, n));
end.

==================================

Ý tưởng:

Đếm số lượng bội của A: boia = N / A.

Đếm số lượng bội của B: boib =N / B.

Sau đó cộng lại được số lượng bội của A hoặc B. Nhưng trong đó có các số bị trùng nhau.

Như N = 6, A = 2, B = 3. 

Thì 6 / 2 + 6 / 3 = 3 + 2 = 5. ( 2, 4, 6, 3, 6)

Như vậy ta bị dư một số 6, mà ta thấy 6 là bội chung nhỏ nhất của cả A và B nên, ta cần trừ nó đi.

Tìm bội chung nhỏ nhất của A và B: lcm = (A * B) / gcd(A, B). (gcd là ước chung lớn nhất)

Đếm số lượng bội của lcm: boilcm = N / lcm.

Như vậy số lượng bội của A và B không lớn hơn N là:

boia + boib - boilcm

==================

Trong hình có thời gian chạy code nhé.

- Ý tưởng:

+ Tính xem có bao nhiêu số trong khoảng [1..n] chia hết cho a : n//a

+ Tính xem có bao nhiêu số trong khoảng [1..n] chia hết cho b : n//b

+ Tính xem có bao nhiêu số bị đếm 2 lần ( chia hết cho cả a và b ) để giảm đi : n//( (a*b)/gcd(a*b) )

  * Nháp thử vài lần là biết thôi :D

- Code c++:

#include <bits/stdc++.h>
#define ull unsigned long long
using namespace std;

int main()
{
 int n,a,b;
 cin >> n >> a >> b;
 int ta = n/a;
 int tb = n/b;
 int tab = n/((a*b)/__gcd(a,b));
 cout << ta+tb-tab;
}