text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
char s[1010000];
int main() {
int i, j, k, m, n;
scanf("%s", s);
n = strlen(s);
if (n % 2 == 1) {
n = (n + 1) / 2;
for (i = 1; i <= n; i++) putchar('4');
for (i = 1; i <= n; i++) putchar('7');
puts("");
} else {
char u = '7';
int flag = 0;
for (i = 0; i < n; i++) {
if (i + i == n) u = '4';
if (s[i] > u) {
flag = -1;
break;
} else if (s[i] < u) {
flag = 1;
break;
}
}
if (flag == -1) {
n = (n + 2) / 2;
for (i = 1; i <= n; i++) putchar('4');
for (i = 1; i <= n; i++) putchar('7');
puts("");
} else {
int pos = -1;
int c4 = 0, c7 = 0;
int f = 0;
for (i = 0; i < n; i++) {
if (f || s[i] <= '4') {
if (s[i] < '4') f = 1;
s[i] = '4';
pos = i;
c4++;
} else if (s[i] <= '7') {
if (s[i] < '7') f = 1;
s[i] = '7';
c7++;
} else {
s[i] = '4';
s[pos] = '7';
pos = i;
c7++;
f = 1;
}
}
if (c7 > c4) {
int cnt = 0;
for (i = n - 1; i >= 0; i--) {
if (s[i] == '7') cnt++;
if (cnt >= (c7 - c4) / 2 + 1) break;
}
for (; i >= 0; i--)
if (s[i] == '4') {
c7++;
c4--;
s[i] = '7';
break;
}
for (i = i + 1; i < n; i++)
if (s[i] == '7') {
s[i] = '4';
c7--;
c4++;
}
}
if (c7 < c4) {
for (i = n - 1; i >= 0; i--) {
if (c4 > c7 && s[i] == '4') {
s[i] = '7';
c4--;
c7++;
}
}
}
puts(s);
}
}
scanf("%*d");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, hn;
string s, r, c;
int c1[100005], c2[100005];
string times(string s, int t) {
c = "";
for (int i = 0; i < t; ++i) c += s;
return c;
}
inline void work(int w) {
cout << r.substr(0, w + 1) + times("4", hn - c1[w]) + times("7", hn - c2[w]) +
'\n';
}
signed main() {
cin >> s, r = "";
n = s.size(), hn = (n + 1) >> 1;
if (n & 1) {
for (int i = 1, I((n + 1) >> 1); i <= I; ++i) r = '4' + r + '7';
return cout << r + '\n', 0;
}
for (int i = 1; i <= hn; ++i) r = '7' + r + '4';
if (r < s) {
r = "";
for (int i = 0; i <= hn; ++i) r = '4' + r + '7';
return cout << r + '\n', 0;
}
r = "";
for (int i = 0, l(0), ll(0), t; i < n; ++i) {
c1[i] = i ? c1[i - 1] : 0, c2[i] = i ? c2[i - 1] : 0;
if (s[i] <= '4') {
if (c1[i] < hn)
r += '4', ++c1[i], l = i;
else
r += '7', ++c2[i], ll = l;
} else if (s[i] <= '7' && c2[i] < hn)
r += '7', ++c2[i], ll = l;
else
return t = c2[i] < hn ? l : ll, r[t] = '7', --c1[t], ++c2[t], work(t), 0;
if (s[i] < r[i]) return work(i), 0;
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string n;
string mini = "7777777777777777";
void bt(string s) {
if (s.size() == n.size() + 4) return;
bt(s + '4');
bt(s + '7');
long long f = 0, sev = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '4')
f++;
else
sev++;
}
if (f != sev) return;
if (s.size() < n.size()) return;
if (s.size() == n.size() && n > s) return;
if (s.size() > mini.size()) return;
if (s.size() == mini.size() && s > mini) return;
if (f == sev && s.size() <= mini.size()) mini = min(mini, s);
if (s.size() < mini.size()) mini = s;
}
int main() {
cin >> n;
if (n <= "47" && n.size() <= 2) {
cout << "47";
return 0;
}
string s = "";
bt(s);
cout << mini;
return 0;
}
|
#include <bits/stdc++.h>
char str[1000000], s1[1000000];
int n;
int main() {
int i, j, c, flag = 0;
scanf("%s", str);
n = strlen(str);
if (n % 2 == 1) flag = 1;
for (i = j = c = 0; i < n && i + abs(j) <= n && !flag && !c; i++) {
if (str[i] < '4')
c = 1, s1[i] = '4', j++;
else if (str[i] == '4')
s1[i] = '4', j++;
else if (str[i] < '7')
s1[i] = '7', j--, c = 1;
else if (str[i] == '7')
s1[i] = '7', j--;
else
break;
}
if (!flag && !c && i < n && i + abs(j) <= n) {
for (--i; i >= 0; i--)
if (s1[i] == '4') break;
if (i < 0)
flag = 1;
else {
s1[i++] = '7';
for (c = j = 0; c < i; c++)
if (s1[c] == '4')
j++;
else
j--;
if (i + abs(j) > n)
flag = 1;
else
c = 1;
}
}
if (i + abs(j) > n) {
for (; i > 0 && (s1[i - 1] == '7' || i + abs(j - 2) > n); i--)
if (s1[i - 1] == '7')
j++;
else
j--;
if (i <= 0)
flag = 1;
else
j--, s1[i - 1] = '7', j--, c = 1;
}
if (c && i + abs(j) <= n) {
if (j < 0) {
for (; j < 0; i++, j++) s1[i] = '4';
for (j = 0; j < (n - i) / 2; j++) s1[i + j] = '4';
for (j = 0; j < (n - i) / 2; j++) s1[i + j + (n - i) / 2] = '7';
} else {
for (c = 0; c < (n - i - j) / 2; c++) s1[i + c] = '4';
for (i += c; i < n; i++) s1[i] = '7';
}
} else if (i < n || i + abs(j) > n)
flag = 1;
if (flag) {
for (i = 0; i < n / 2 + 1; i++) putchar('4');
for (i = 0; i < n / 2 + 1; i++) putchar('7');
puts("");
} else
puts(s1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length();
if (len % 2) {
for (int i = 0; i <= len / 2; ++i) cout << 4;
for (int i = 0; i <= len / 2; ++i) cout << 7;
return 0;
}
string res = "9999999999";
string t;
for (int i = 0; i < len / 2; ++i) t += '4';
for (int i = 0; i < len / 2; ++i) t += '7';
do {
if (t >= s) res = min(t, res);
} while (next_permutation(t.begin(), t.end()));
if (res != "9999999999") {
cout << res;
return 0;
}
len++;
for (int i = 0; i <= len / 2; ++i) cout << 4;
for (int i = 0; i <= len / 2; ++i) cout << 7;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, d, O4[100005], O7[100005], S4[100005], S7[100005];
char s[100005];
int tooLarge() {
for (int i = 0; i < n / 2; i++) {
if (s[i] > '7') return -1;
if (s[i] < '7') return i;
}
for (int i = n / 2; i < n; i++) {
if (s[i] > '4') return -1;
if (s[i] < '4') return i;
}
return n;
}
int main() {
scanf("%s", s);
n = strlen(s);
if (n % 2 == 0) {
d = tooLarge();
if (d < 0) n++;
}
if (n & 1) {
n++;
for (int i = 0; i * 2 < n; i++) printf("4");
for (int i = 0; i * 2 < n; i++) printf("7");
printf("\n");
return 0;
}
S7[0] = (s[0] == '7');
for (int i = 1; i < n; i++) S7[i] = S7[i - 1] + (s[i] == '7');
S4[0] = (s[0] == '4');
for (int i = 1; i < n; i++) S4[i] = S4[i - 1] + (s[i] == '4');
for (int i = n - 1; i >= 0; i--) {
if (s[i] > '7')
O7[i] = 0;
else if (s[i] < '7')
O7[i] = 1;
else
O7[i] = O7[i + 1];
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] > '4')
O4[i] = 0;
else if (s[i] < '4')
O4[i] = 1;
else
O4[i] = O4[i + 1];
}
x = y = n / 2;
int ok = 0;
for (int i = 0; i < n; i++) {
if (ok) {
if (y)
printf("4"), y--;
else
printf("7"), x--;
} else if (!x)
printf("4"), y--;
else if (!y)
printf("7"), x--;
else {
if (s[i] == '7')
printf("7"), x--;
else if (s[i] < '4')
printf("4"), y--, ok = 1;
else if (s[i] == '4') {
int c = 7;
if (S7[i + x] - S7[i] == x) {
if (S4[n - 1] - S4[i + x] == y - 1)
c = 4;
else if (O4[i + x + 1])
c = 4;
} else if (O7[i + 1])
c = 4;
if (c == 7)
printf("7"), x--, ok = 1;
else
printf("4"), y--;
} else
printf("7"), x--, ok = 1;
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
string ans = "";
bool cal(int &a, int &b) {
int x = -1;
int y = -1;
for (int j = ans.size() - 1; j >= 0; j--) {
if (ans[j] == '7') {
x = j;
break;
}
}
if (x == -1) {
return false;
}
for (int j = x - 1; j >= 0; j--) {
if (ans[j] == '4') {
y = j;
break;
}
}
if (y == -1) {
return false;
}
while (ans.size() - 1 != y) {
if (ans[ans.size() - 1] == '4') {
a++;
} else if (ans[ans.size() - 1] == '7') {
b++;
}
ans.pop_back();
}
a++;
ans.pop_back();
b--;
ans += '7';
while (a > 0) {
a--;
ans += '4';
}
while (b > 0) {
b--;
ans += '7';
}
return true;
}
int main() {
scanf("%s", s);
int n = strlen(s);
if (n % 2 == 1) {
n++;
for (int i = 0; i < n / 2; i++) {
printf("4");
}
for (int i = 0; i < n / 2; i++) {
printf("7");
}
puts("");
} else {
int a = n / 2;
int b = n / 2;
bool ok = true;
for (int i = 0; i < n && ok && (a + b) != 0; i++) {
if (s[i] < '4') {
while (a > 0) {
a--;
ans += '4';
}
while (b > 0) {
b--;
ans += '7';
}
break;
} else if (s[i] == '4') {
if (a != 0) {
a--;
ans += '4';
continue;
}
while (b > 0) {
b--;
ans += '7';
}
break;
} else if (s[i] < '7') {
if (b == 0) {
if (!cal(a, b)) {
ok = false;
}
continue;
}
b--;
ans += '7';
while (a > 0) {
a--;
ans += '4';
}
while (b > 0) {
b--;
ans += '7';
}
break;
} else if (s[i] == '7') {
if (b == 0) {
if (!cal(a, b)) {
ok = false;
}
continue;
}
b--;
ans += '7';
} else {
if (b == 0) {
if (!cal(a, b)) {
ok = false;
}
continue;
}
while (ans.size() > 0 && ans[ans.size() - 1] != '4') {
b++;
ans.pop_back();
}
if (ans.size() == 0) {
ok = false;
continue;
}
a++;
ans.pop_back();
b--;
ans += '7';
while (a > 0) {
a--;
ans += '4';
}
while (b > 0) {
b--;
ans += '7';
}
}
}
if (ok) {
printf("%s\n", ans.c_str());
} else {
n += 2;
for (int i = 0; i < n / 2; i++) {
printf("4");
}
for (int i = 0; i < n / 2; i++) {
printf("7");
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
char aa[maxn], bb[maxn];
int a[maxn], b[maxn];
int main() {
scanf("%s", aa);
int len = strlen(aa);
if (len % 2) {
len++;
for (int i = 1; i <= len / 2; i++) {
printf("4");
}
for (int i = 1; i <= len / 2; i++) {
printf("7");
}
return 0;
} else {
for (int i = 0; i < len / 2; i++) {
bb[i] = '7';
}
for (int i = len / 2; i < len; i++) {
bb[i] = '4';
}
int r = strcmp(aa, bb);
if (r == 1) {
len += 2;
for (int i = 1; i <= len / 2; i++) {
printf("4");
}
for (int i = 1; i <= len / 2; i++) {
printf("7");
}
return 0;
} else {
int k = -1;
int l = len / 2, r = len / 2;
for (int i = 0; i < len; i++) {
if (aa[i] == '4' && l > 0) {
bb[i] = '4';
l--;
} else if (aa[i] < '4' && l > 0) {
bb[i] = '4';
l--;
for (int j = 0; j <= i; j++) {
printf("%c", bb[j]);
}
while (l > 0) {
printf("4");
l--;
}
while (r > 0) {
printf("7");
r--;
}
return 0;
} else if (aa[i] == '7' && r > 0) {
bb[i] = '7';
r--;
} else if (aa[i] < '7' && r > 0) {
bb[i] = '7';
r--;
for (int j = 0; j <= i; j++) {
printf("%c", bb[j]);
}
while (l > 0) {
l--;
printf("4");
}
while (r > 0) {
r--;
printf("7");
}
return 0;
} else {
for (int i = 0; i < len; i++) {
if (b[i] > 0) {
if (bb[i] == '4') {
k = i;
}
}
}
bb[k] = '7';
int c = a[k] + 1;
int d = b[k] - 1;
for (int j = 0; j <= k; j++) {
printf("%c", bb[j]);
}
while (c > 0) {
c--;
printf("4");
}
while (d > 0) {
d--;
printf("7");
}
return 0;
}
a[i] = l;
b[i] = r;
}
for (int i = 0; i < len; i++) {
printf("%c", bb[i]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
getline(cin, a);
vector<int> b(a.size());
for (int i = 0; i < a.size(); ++i) b[i] = a[i] - '0';
bool big = false, back;
int pos = 0, c4 = b.size() / 2;
int c7 = c4;
if (b.size() % 2 == 1) goto out;
while (true) {
back = false;
if (pos == b.size()) break;
if (big == true) {
if (c4 > 0)
b[pos] = 4, c4--;
else
b[pos] = 7, c7--;
} else {
if (b[pos] <= 4 && c4 > 0) {
if (b[pos] < 4) big = true;
b[pos] = 4;
c4--;
} else {
if (b[pos] > 7 || c7 == 0)
back = true;
else {
if (b[pos] < 7) big = true;
b[pos] = 7, c7--;
}
}
}
if (back) {
big = false;
while (!big) {
pos--;
if (pos < 0) goto out;
if (b[pos] == 4) c4++;
if (b[pos] == 7) c7++;
if (b[pos] < 4 && c4 > 0) {
b[pos] = 4;
c4--;
big = true;
} else if (b[pos] < 7 && c7 > 0) {
b[pos] = 7;
c7--;
big = true;
}
}
}
pos++;
}
for (int i = 0; i < b.size(); ++i) cout << b[i];
return 0;
out:
for (int i = 0; i < b.size() / 2 + 1; ++i) cout << 4;
for (int i = 0; i < b.size() / 2 + 1; ++i) cout << 7;
}
|
#include <bits/stdc++.h>
int tc(char a) { return a - int('0'); }
using namespace std;
int main() {
string st;
cin >> st;
int n = st.size();
if (n & 1) {
for (int i = 0; i < n / 2 + 1; i++) cout << '4';
for (int i = 0; i < n / 2 + 1; i++) cout << '7';
cout << endl;
return 0;
}
bool convertir = 0;
int cf = n / 2, cs = n / 2, uf = -1;
string ans;
for (int c = 0; c < n; c++) {
int i = tc(st[c]);
if (i < 4) {
break;
}
if (i == 4) {
if (cf == 0) {
break;
}
if (cs > 0) uf = c;
ans.push_back('4');
cf--;
} else {
if (i < 7) {
if (cs == 0) {
convertir = 1;
break;
}
ans.push_back('7');
cs--;
break;
}
if ((i == 7 && cs == 0) || i > 7) {
convertir = 1;
break;
}
ans.push_back('7');
cs--;
}
}
if (convertir) {
string ans1;
if (uf != -1) {
cf = cs = n / 2;
for (int i = 0; i < uf; i++) {
ans1.push_back(ans[i]);
if (ans[i] == '4') {
cf--;
} else {
cs--;
}
}
ans1.push_back('7');
cs--;
while (cf > 0) {
ans1.push_back('4');
cf--;
}
while (cs > 0) {
ans1.push_back('7');
cs--;
}
cout << ans1 << endl;
return 0;
}
for (int i = 0; i < n / 2 + 1; i++) cout << '4';
for (int i = 0; i < n / 2 + 1; i++) cout << '7';
cout << endl;
return 0;
}
while (cf > 0) {
ans.push_back('4');
cf--;
}
while (cs > 0) {
ans.push_back('7');
cs--;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
char a[100004];
char b[100004];
int make(char b[], int len) {
int i, j, k;
while (1) {
k = 0;
for (i = 0; i < len; i++)
if (b[i] == '7') k++;
if (k == len / 2)
return 0;
else if (k < len / 2) {
for (i = len - 1; i >= 0; i--) {
if (b[i] == '4') k++;
b[i] = '7';
if (k == len / 2) return 0;
}
} else {
for (i = len - 1; i >= 0; i--)
if (b[i] == '7') break;
for (; i >= 0; i--) {
if (b[i] == '4')
break;
else
b[i] = '4';
}
if (i < 0) return 1;
b[i] = '7';
}
}
}
int main() {
int i, j, k, l;
int len;
scanf("%s", a);
len = strlen(a);
j = 0;
if ((len % 2) == 1) {
for (i = 0; i <= len / 2; i++) printf("4");
for (i = 0; i <= len / 2; i++) printf("7");
printf("\n");
} else {
j = 0;
l = 0;
for (i = 0; i < len; i++) {
if (a[i] < '4') {
for (; i < len; i++) b[i] = '4';
} else if (a[i] == '4') {
b[i] = '4';
} else if (a[i] < '7') {
b[i] = '7';
for (i = i + 1; i < len; i++) b[i] = '4';
} else if (a[i] == '7') {
b[i] = '7';
} else {
for (k = i - 1; k >= 0; k--)
if (b[k] == '4') break;
if (k < 0) {
l = 1;
break;
} else {
b[k] = '7';
for (k = k + 1; k < len; k++) {
b[k] = '4';
}
i = len;
}
}
}
l = make(b, len);
if (l == 1) {
for (i = 0; i < len / 2 + 1; i++) printf("4");
for (i = 0; i < len / 2 + 1; i++) printf("7");
} else {
b[len] = 0;
printf("%s", b);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 4.0 * atan(1.0);
int64_t num;
queue<int64_t> qu;
bool ifgood(int64_t x) {
int64_t a, b;
a = 0;
b = 0;
while (x) {
if (x % 10 == 4)
++a;
else if (x % 10 == 7)
++b;
else
return false;
x /= 10;
}
if (a == b) return true;
return false;
}
void bfs() {
while (!qu.empty()) qu.pop();
int64_t a, b, k;
a = 0;
qu.push(a);
while (!qu.empty()) {
b = qu.front();
if (b > num && ifgood(b)) return;
qu.pop();
k = b;
b = b * 10 + 4;
qu.push(b);
k = k * 10 + 7;
qu.push(k);
}
return;
}
int main() {
cin >> num;
if (ifgood(num))
cout << num << endl;
else {
bfs();
cout << qu.front() << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279;
void solve() {
long long num;
cin >> num;
long long dig = log10(num) + 1, i = 0;
string ans = "";
while (i < dig / 2) ans += "47", i++;
if (dig & 1) ans += "47";
sort((ans).begin(), (ans).end());
do {
long long val = stoll(ans);
if (val >= num) {
cout << val;
return;
}
} while (next_permutation(ans.begin(), ans.end()));
ans += "47";
sort((ans).begin(), (ans).end());
do {
long long val = stoll(ans);
if (val >= num) {
cout << val;
return;
}
} while (next_permutation(ans.begin(), ans.end()));
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long testCases = 1;
while (testCases--) {
solve();
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
getline(cin, a);
deque<int> b(a.size());
for (int i = 0; i < a.size(); ++i) b[i] = a[i] - '0';
bool big = false, back = false;
int pos = 0, c4 = b.size() / 2;
int c7 = c4;
if (b.size() % 2 == 1) goto out;
while (true) {
back = false;
if (pos == b.size()) break;
if (big == true) {
if (c4 > 0)
b[pos] = 4, c4--;
else
b[pos] = 7, c7--;
} else {
if (b[pos] <= 4 && c4 > 0) {
if (b[pos] < 4) big = true;
b[pos] = 4;
c4--;
} else {
if (b[pos] > 7 || c7 == 0)
back = true;
else {
if (b[pos] < 7) big = true;
b[pos] = 7, c7--;
}
}
}
if (back) {
big = false;
while (!big) {
pos--;
if (pos < 0) goto out;
if (b[pos] == 4) c4++;
if (b[pos] == 7) c7++;
if (b[pos] < 4 && c4 > 0) {
b[pos] = 4;
c4--;
big = true;
} else if (b[pos] < 7 && c7 > 0) {
b[pos] = 7;
c7--;
big = true;
}
}
}
pos++;
}
for (int i = 0; i < b.size(); ++i) cout << b[i];
return 0;
out:
for (int i = 0; i < b.size() / 2 + 1; ++i) cout << 4;
for (int i = 0; i < b.size() / 2 + 1; ++i) cout << 7;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> all;
void backtrack(long long cur, int cnt4, int cnt7) {
if (cur > 1e10) return;
if (cnt4 == cnt7) all.push_back(cur);
long long nxt = cur * 10 + 4;
backtrack(nxt, cnt4 + 1, cnt7);
nxt = cur * 10 + 7;
backtrack(nxt, cnt4, cnt7 + 1);
}
int main() {
int n;
cin >> n;
backtrack(0, 0, 0);
sort(all.begin(), all.end());
cout << *lower_bound(all.begin(), all.end(), n) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 32000000;
const long long INF = 1E18 + 7;
vector<int> pr;
map<long long, vector<long long>> fct, dst;
int t;
long long n, k;
bool chk[MX];
struct SNode {
long long u, val;
};
inline bool operator<(const SNode &a, const SNode &b) { return a.val < b.val; }
priority_queue<SNode, vector<SNode>, less<SNode>> pq;
void init() {
for (int i = 2; i < MX; i++)
if (!chk[i]) {
pr.push_back(i);
for (int j = i; j < MX / i; j++) chk[i * j] = true;
}
}
void factorize(long long k) {
if (fct.find(k) != fct.end()) return;
vector<long long> &fact = fct[k];
long long t = k;
for (int &v : pr) {
if (1LL * v * v > t) break;
if (t % v == 0) {
fact.push_back(v);
while (t % v == 0) t /= v;
}
}
if (t > 1) fact.push_back(t);
}
void Dijkstra(long long k) {
if (dst.find(k) != dst.end()) return;
vector<long long> &dist = dst[k], &fact = fct[k];
long long pr = fact.front();
dist = vector<long long>(pr, INF);
for (pq.push((SNode){0, dist[0] = 0}); !pq.empty();) {
SNode u = pq.top();
pq.pop();
for (long long &v : fact)
if (dist[(u.u + v) % pr] > u.val + v)
pq.push((SNode){(u.u + v) % pr, dist[(u.u + v) % pr] = u.val + v});
while (!pq.empty() && dist[pq.top().u] < pq.top().val) pq.pop();
}
}
void Euclid(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0;
*y = n;
return;
}
long long x1, y1;
Euclid(b % a, a, &x1, &y1);
*x = y1 - b / a * x1;
*y = x1;
if (b != 0) {
*y -= ((*x % b + b) % b - *x) / b * a;
*x = (*x % b + b) % b;
}
}
void find_ans() {
factorize(k);
if (fct[k].size() == 0)
printf("NO\n");
else if (fct[k].size() == 1)
printf("%s\n", (n % k == 0 ? "YES" : "NO"));
else if (fct[k].size() == 2) {
long long a = fct[k][0], b = fct[k][1], x, y;
Euclid(a, b, &x, &y);
printf("%s\n", (y >= 0 ? "YES" : "NO"));
} else {
Dijkstra(k);
printf("%s\n", (n >= dst[k][n % dst[k].size()] ? "YES" : "NO"));
}
}
int main() {
init();
scanf("%d", &t);
while (t--) {
scanf("%lld%lld", &n, &k);
find_ans();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 55, S = 31624000;
long long T, n, k;
namespace gp {
bool isprime[S];
long long t = 0, prime[20 * N];
void getprime() {
memset(isprime, 0, sizeof(isprime));
for (int i = 2; i < S; i++) {
if (!isprime[i]) prime[++t] = i;
for (int j = 1; j <= t && prime[j] * i < S; j++) isprime[prime[j] * i] = 1;
}
}
} // namespace gp
namespace gtp {
map<int, int> has_worked;
long long gs[M], fj[M][M], cnt = 0;
long long mx, dis[N], vis[N], Q[N * 100];
vector<int> ans[M];
vector<pair<int, int> > e[N];
void build(long long z) {
mx = fj[z][1];
for (int i = 0; i < mx; i++) {
e[i].clear();
for (int j = 1; j <= gs[z]; j++)
e[i].push_back(make_pair((i + fj[z][j]) % mx, fj[z][j]));
}
memset(dis, 127, sizeof(dis));
dis[0] = Q[1] = 0;
int L = 0, R = 1;
while (L < R) {
int u = Q[++L];
vis[u] = 0;
for (int i = 0; i < e[u].size(); i++) {
long long v = e[u][i].first, c = e[u][i].second;
if (dis[u] + c < dis[v]) {
dis[v] = dis[u] + c;
if (!vis[v]) vis[v] = 1, Q[++R] = v;
}
}
}
for (int i = 0; i < mx; i++) ans[z].push_back(dis[i]);
}
int go_to_prime(long long x) {
cnt++;
gs[cnt] = 0;
for (int i = 1; gp::prime[i] * gp::prime[i] <= x && i <= gp::t; i++)
if (x % gp::prime[i] == 0) {
fj[cnt][++gs[cnt]] = gp::prime[i];
while (x % gp::prime[i] == 0) x /= gp::prime[i];
}
if (x != 1) fj[cnt][++gs[cnt]] = x;
if (gs[cnt] >= 3) build(cnt);
return cnt;
}
} // namespace gtp
void getans(int n, int z) {
if (n < gtp::fj[z][1])
printf("NO\n");
else if (gtp::ans[z][n % gtp::fj[z][1]] <= n)
printf("YES\n");
else
printf("NO\n");
}
long long fpow(long long a, long long b, long long p) {
long long ans = 1;
for (; b; b >>= 1, (a *= a) %= p)
if (b & 1) (ans *= a) %= p;
return ans;
}
int main() {
gp::getprime();
for (scanf("%lld", &T); T; T--) {
scanf("%lld%lld", &n, &k);
int &z = gtp::has_worked[k];
if (!z) z = gtp::go_to_prime(k);
if (k == 1) {
printf("NO\n");
continue;
}
if (gtp::gs[z] == 1) {
printf((n % k) ? "NO\n" : "YES\n");
} else if (gtp::gs[z] == 2) {
long long fja = gtp::fj[z][1], fjb = gtp::fj[z][2];
long long tmp = fpow(fjb, fja - 2, fja) * (n % fja) % fja;
printf((tmp * fjb <= n) ? "YES\n" : "NO\n");
} else
getans(n, z);
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long Qmul(const long long &x, const long long &y,
const long long &X) {
long long k = (long long)((1.0L * x * y) / (1.0L * X)), t = x * y - k * X;
t -= X;
while (t < 0) t += X;
return t;
}
class MillerRabin {
private:
const int P[12] = {2, 3, 5, 7, 11, 13, 17, 19, 61, 2333, 4567, 24251};
inline long long Qpow(long long x, long long y, long long X) {
long long t = 1;
while (y) y & 1 && (t = Qmul(t, x, X)), x = Qmul(x, x, X), y >>= 1;
return t;
}
inline bool Check(const long long &x, const int &p) {
if (!(x % p) || Qpow(p % x, x - 1, x) ^ 1) return false;
long long k = x - 1, t;
while (!(k & 1)) {
if ((t = Qpow(p % x, k >>= 1, x)) ^ 1 && t ^ (x - 1)) return false;
if (!(t ^ (x - 1))) return true;
}
return true;
}
public:
bool IsPrime(const long long &x) {
if (x < 2) return false;
for (int i = 0; i ^ 12; ++i) {
if (!(x ^ P[i])) return true;
if (!Check(x, P[i])) return false;
}
return true;
}
};
class PollardRho {
private:
long long ans;
MillerRabin MR;
inline long long gcd(const long long &x, const long long &y) {
return y ? gcd(y, x % y) : x;
}
inline long long Work(const long long &x, const int &y) {
int t = 0, k = 1;
long long v0 = (1LL * rand() * rand() * rand() * rand() % (x - 1) + 1),
v = v0, d, s = 1;
while (1) {
if (v = (Qmul(v, v, x) + y) % x,
s = Qmul(s, ((v - v0) < 0 ? -(v - v0) : (v - v0)), x),
!(v ^ v0) || !s)
return x;
if (++t == k) {
if ((d = gcd(s, x)) ^ 1) return d;
v0 = v, k <<= 1;
}
}
}
inline void Resolve(long long x, int t) {
if (!(x ^ 1) || x <= ans) return;
if (MR.IsPrime(x)) return (void)(ans < (x) && (ans = (x)));
long long y = x;
while ((y = Work(x, t--)) == x)
;
while (!(x % y)) x /= y;
Resolve(x, t), Resolve(y, t);
}
public:
inline PollardRho() { srand(20050521); }
inline long long GetMax(const long long &x) {
return ans = 0, Resolve(x, 302627441), ans;
}
} P;
int T, p, ans[10010];
long long pr[60], dis[100010], head[100010], o;
struct edge {
int to, link;
long long w;
} e[6000010];
struct node {
int id;
long long w;
bool operator<(const node &b) const { return w > b.w; }
};
priority_queue<node> Q;
struct ask {
long long n, k, id;
bool operator<(const ask &b) const { return k < b.k; }
} q[10010];
void add_edge(int u, int v, long long w) {
e[++o].to = v, e[o].link = head[u], head[u] = o, e[o].w = w;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, a;
long long t = exgcd(b, a % b, y, x);
return y -= a / b * x, t;
}
int main() {
scanf("%d", &T);
for (int i = 1; i <= T; i++) scanf("%lld%lld", &q[i].n, &q[i].k), q[i].id = i;
sort(q + 1, q + T + 1);
for (int l = 1, r = 0; l <= T; l = r + 1) {
while (r < T && q[r + 1].k == q[l].k) r++;
long long k = q[l].k;
if (k == 1) continue;
p = 0;
while (k > 1) {
pr[++p] = P.GetMax(k);
while (k % pr[p] == 0) k /= pr[p];
}
if (p == 1) {
for (int i = l; i <= r; i++) ans[q[i].id] = (q[i].n % pr[1] == 0);
continue;
}
if (p == 2) {
long long x, y;
exgcd(pr[1], pr[2], x, y);
x = (x % pr[2] + pr[2]) % pr[2];
for (int i = l; i <= r; i++) {
long long b = q[i].n - Qmul(x, q[i].n, pr[2]) * pr[1];
ans[q[i].id] = (b >= 0);
}
continue;
}
int L = pr[p];
o = 0;
for (int i = 1; i < L; i++) dis[i] = LLONG_MAX;
for (int i = 0; i < L; i++) {
head[i] = 0;
for (int j = 1; j < p; j++) add_edge(i, (i + pr[j]) % L, pr[j]);
}
Q.push((node){0, dis[0] = 0});
while (Q.size()) {
int u = Q.top().id;
Q.pop();
for (int i = head[u]; i; i = e[i].link)
if (e[i].w + dis[u] < dis[e[i].to]) {
dis[e[i].to] = dis[u] + e[i].w;
Q.push((node){e[i].to, dis[e[i].to]});
}
}
for (int i = l; i <= r; i++) ans[q[i].id] = (q[i].n >= dis[q[i].n % L]);
}
for (int i = 1; i <= T; i++) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
const long long INF = (1ull << 62);
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e4 + 5;
const int P = 4e6 + 5;
const int M = 31622776 + 5;
int T;
long long mx;
bool ans[N];
vector<int> frac;
int cnt, prime[P];
bool vis[M];
inline void init(int NN) {
for (int i = 2; i <= NN; i++) {
if (!vis[i]) {
prime[++cnt] = i;
}
for (int j = 1; j <= cnt && i * prime[j] <= NN; j++) {
vis[i * prime[j]] = true;
if (i % prime[j] == 0) break;
}
}
}
inline void calc(long long x) {
frac.clear();
for (int i = 1; 1ll * prime[i] * prime[i] <= x && i <= cnt; i++) {
if (x % prime[i] == 0) {
frac.push_back(prime[i]);
while (x % prime[i] == 0) x /= prime[i];
}
}
if (x != 1) frac.push_back(x);
}
struct QUERY {
long long n, k, id;
} q[N];
inline bool cmp1(QUERY a, QUERY b) { return a.k < b.k; }
inline bool cmp2(QUERY a, QUERY b) { return a.id < b.id; }
inline long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long ret = exgcd(b, a % b, x, y);
long long t = x;
x = y;
y = t - (a / b) * y;
return ret;
}
inline void work(long long a, long long b, long long c, int id) {
long long x, y, g;
g = exgcd(a, b, x, y);
if (c % g) {
ans[id] = 0;
return;
}
long long mod = b / g;
x = (x % mod + mod) % mod;
x = (c / g) % mod * x % mod;
y = (c - x * a) / mod;
ans[id] = y >= 0;
}
struct Node {
long long u, d;
Node(long long U = 0, long long D = 0) {
u = U;
d = D;
}
bool operator<(const Node &rhs) const { return d > rhs.d; }
};
long long dis[P];
inline void dijkstra() {
for (int i = 0; i < frac[0]; i++) dis[i] = INF;
priority_queue<Node> q;
q.push(Node(0, 0));
dis[0] = 0;
while (!q.empty()) {
Node t = q.top();
q.pop();
long long u = t.u, d = t.d;
if (d != dis[u]) continue;
for (int i = 1, sz = frac.size(); i < sz; i++) {
long long v = (frac[i] + u) % frac[0], w = frac[i];
if (dis[u] != INF && dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
q.push(Node(v, dis[v]));
}
}
}
}
int main() {
read(T);
for (int i = 1; i <= T; i++) {
read(q[i].n);
read(q[i].k);
q[i].id = i;
mx = max(mx, q[i].k);
}
init(sqrt(mx));
sort(q + 1, q + T + 1, cmp1);
for (int i = 1; i <= T; i++) {
int type = 0;
if (q[i].k != q[i - 1].k) {
frac.clear();
calc(q[i].k);
if (frac.size() > 2) dijkstra();
}
if (frac.size() == 0) {
ans[q[i].id] = 0;
continue;
} else if (frac.size() == 1)
ans[q[i].id] = (q[i].n % q[i].k == 0);
else if (frac.size() == 2)
work(frac[0], frac[1], q[i].n, q[i].id);
else
ans[q[i].id] = dis[q[i].n % frac[0]] <= q[i].n;
;
}
sort(q + 1, q + T + 1, cmp2);
for (int i = 1; i <= T; i++) printf(ans[i] ? "YES\n" : "NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXT = (int)1e4 + 3;
const int MAXN = (int)31700000;
const int MAXP = (int)1e5 + 3;
const int infint = (int)2e9;
const long long inf = (long long)2e18;
int T;
long long n[MAXT], k[MAXT], dist[MAXP];
bool prime[MAXN], ans[MAXT];
vector<int> all_primes;
void preprocess() {
for (long long i = 2; i < MAXN; i++)
if (prime[i] == 0) {
all_primes.push_back(i);
for (long long j = 1LL * i * i; j < MAXN; j += i) prime[j] = 1;
}
}
vector<int> decp;
void decompose(long long x) {
decp.clear();
for (auto u : all_primes)
if (u * u > x)
break;
else if (x % u == 0) {
decp.push_back(u);
while (x % u == 0) x /= u;
}
if (x > 1) decp.push_back(x);
}
void dijkstra(int mod) {
set<pair<long long, int>> q;
vector<long long> dis(mod, inf);
q.insert({dis[0] = 0, 0});
while (!q.empty()) {
auto u = *q.begin();
q.erase(q.begin());
for (long long v : decp)
if (u.first + v < dis[(u.second + v) % mod])
q.erase({dis[(u.second + v) % mod], (u.second + v) % mod}),
q.insert({dis[(u.second + v) % mod] = u.first + v,
(u.second + v) % mod});
}
for (int i = 0; i < mod; i++) dist[i] = dis[i];
}
long long pwr(long long a, long long b, long long MOD) {
return (b ? ((b & 1 ? a : 1) * (pwr((a * a) % MOD, b >> 1, MOD)) % MOD) % MOD
: 1);
}
bool mika(long long x, long long a, long long b) {
return (x / a) >= (pwr(a, b - 2, b) * (x % b)) % b;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
preprocess();
cin >> T;
set<long long> diffk;
for (int i = 0; i < T; i++) {
cin >> n[i] >> k[i];
diffk.insert(k[i]);
}
for (auto u : diffk) {
decompose(u);
if (decp.size() == 0) continue;
if (decp.size() == 1) {
for (int i = 0; i < T; i++)
if (k[i] == u) ans[i] = (n[i] % k[i] == 0);
continue;
}
if (decp.size() == 2) {
for (int i = 0; i < T; i++)
if (k[i] == u) ans[i] = mika(n[i], decp[0], decp[1]);
continue;
}
dijkstra(decp[0]);
for (int i = 0; i < T; i++)
if (k[i] == u) ans[i] = (n[i] >= dist[n[i] % decp[0]]);
}
for (int i = 0; i < T; i++) cout << ((ans[i] == 1) ? "YES" : "NO") << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 31700000;
struct query {
long long n, k;
int id;
} q[N];
int t, cnt, qs, qe, l, ans[N], vis[M], pri[M], que[N * 20];
long long p[N], f[N];
bool cmp(query a, query b) { return a.k < b.k; }
long long qpow(long long a, long long b, long long mod) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod, b >>= 1;
}
return ret;
}
int main() {
scanf("%d", &t);
for (int i = 1; i <= t; i++) scanf("%lld%lld", &q[i].n, &q[i].k), q[i].id = i;
sort(q + 1, q + t + 1, cmp);
for (int i = 2; i < M; i++) {
if (!vis[i]) pri[++cnt] = i;
for (int j = 1; j <= cnt && i * pri[j] < M; j++) {
vis[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
for (int i = 1; i < M; i++) vis[i] = 0;
for (int i = 1; i <= t; i++) {
long long n = q[i].n, k = q[i].k;
if (k != q[i - 1].k) {
l = 0;
for (int j = 1; k > 1; j++) {
if (1ll * pri[j] * pri[j] > k) {
p[++l] = k;
break;
}
if (k % pri[j] == 0) {
p[++l] = pri[j];
while (k % pri[j] == 0) k /= pri[j];
}
}
}
k = q[i].k;
if (!l)
ans[q[i].id] = 0;
else if (l == 1)
ans[q[i].id] = n % k == 0;
else if (l == 2)
ans[q[i].id] = n % p[1] * qpow(p[2], p[1] - 2, p[1]) % p[1] * p[2] <= n;
else {
if (k != q[i - 1].k) {
f[0] = 0;
for (int j = 1; j <= p[1]; j++) f[j] = 1e18;
qs = 0, qe = 1, vis[que[0] = 0] = 1;
while (qs != qe) {
int u = que[qs++];
for (int j = 2; j <= l; j++) {
long long dis = f[u] + p[j];
int v = (u + p[j]) % p[1];
if (dis < f[v]) {
f[v] = dis;
if (!vis[v]) vis[que[qe++] = v] = 1;
}
}
vis[u] = 0;
}
}
ans[q[i].id] = f[q[i].n % p[1]] <= q[i].n;
}
}
for (int i = 1; i <= t; i++)
if (ans[i])
puts("YES");
else
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
int t, dis[100000];
vector<int> primes;
map<long long, vector<pair<long long, int>>> mp;
bool vis[100000], composite[32000000], res[10000];
vector<pair<int, int>> adj[100000];
void modifiedEuclid(long long f1, long long f2, long long &m1, long long &m2) {
if (f1 == 0) {
m1 = 0;
m2 = 1;
return;
}
modifiedEuclid(f2 % f1, f1, m2, m1);
m1 -= m2 * (f2 / f1);
}
void calcPrimes() {
for (int i = (2); i < (32000000); i++)
if (!composite[i]) {
for (int j = 2 * i; j < 32000000; j += i) composite[j] = 1;
primes.push_back(i);
}
}
vector<long long> factorize(long long k) {
vector<long long> res;
for (const int p : primes)
if (k % p == 0) {
res.push_back(p);
while (k % p == 0) k /= p;
}
if (k > 1) res.push_back(k);
return res;
}
void solve(const long long k, const vector<pair<long long, int>> &v) {
vector<long long> factors = factorize(k);
if (((int)(factors).size()) == 0)
return;
else if (((int)(factors).size()) == 1)
for (const pair<long long, int> p : v)
res[p.second] = p.first % factors[0] == 0;
else if (((int)(factors).size()) == 2) {
long long mult0, mult1;
modifiedEuclid(factors[0], factors[1], mult0, mult1);
mult1 = ((mult1 % factors[0]) + factors[0]) % factors[0];
for (const pair<long long, int> p : v)
res[p.second] =
(mult1 * (p.first % factors[0]) % factors[0]) * factors[1] <= p.first;
} else {
for (int i = 0; i < (factors[0]); i++) adj[i].clear();
for (int i = (1); i < (((int)(factors).size())); i++)
for (int j = 0; j < (factors[0]); j++)
adj[j].push_back(make_pair((j + factors[i]) % factors[0], factors[i]));
memset(dis, 0, factors[0] * sizeof(int)),
memset(vis, 0, factors[0] * sizeof(bool));
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
pq.push(make_pair(0, 0));
while (!pq.empty()) {
pair<int, int> p = pq.top();
pq.pop();
if (vis[p.second]) continue;
vis[p.second] = 1;
dis[p.second] = p.first;
for (const pair<int, int> next : adj[p.second])
pq.push(make_pair(dis[p.second] + next.second, next.first));
}
for (const pair<long long, int> p : v)
res[p.second] = p.first >= dis[p.first % factors[0]];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
calcPrimes();
cin >> t;
for (int i = 0; i < (t); i++) {
long long n, k;
cin >> n >> k;
if (!mp.count(k)) mp.insert(make_pair(k, vector<pair<long long, int>>()));
mp[k].push_back(make_pair(n, i));
}
for (auto p : mp) solve(p.first, p.second);
for (int i = 0; i < (t); i++)
if (res[i])
cout << "YES\n";
else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> m;
map<long long, int>::iterator it;
const int times = 7;
int number = 0;
int n, low, high, mid, prime[100000], cnt_p, mi[100000], list[2][111111],
cnt_list[2], pos[110000];
long long a[110000], xx, yy, ds;
bool is[110000];
int ex[111111];
long long gcd(long long a, long long b) {
long long tmp;
while (b) {
tmp = a % b;
a = b;
b = tmp;
}
return a;
}
void ex_gcd(long long a, long long n) {
if (n == 0) {
xx = 1;
yy = 0;
ds = a;
return;
}
ex_gcd(n, a % n);
long long tmp;
tmp = xx;
xx = yy;
yy = tmp - (a / n) * yy;
}
const int S = 20;
long long mult_mod(long long a, long long b, long long c) {
a %= c;
b %= c;
long long ret = 0;
while (b) {
if (b & 1) {
ret += a;
ret %= c;
}
a <<= 1;
if (a >= c) a %= c;
b >>= 1;
}
return ret;
}
long long mult(long long a, long long n, long long mod) {
if (n == 0) return 0;
long long ret = mult(a, n / 2, mod);
ret = (ret + ret) % mod;
if (n % 2) ret = (ret + a) % mod;
return ret;
}
long long pow_mod(long long x, long long n, long long mod) {
if (n == 1) return x % mod;
x %= mod;
long long tmp = x;
long long ret = 1;
while (n) {
if (n & 1) ret = mult_mod(ret, tmp, mod);
tmp = mult_mod(tmp, tmp, mod);
n >>= 1;
}
return ret;
}
bool check(long long a, long long n, long long x, long long t) {
long long ret = pow_mod(a, x, n);
long long last = ret;
for (int i = 1; i <= t; i++) {
ret = mult_mod(ret, ret, n);
if (ret == 1 && last != 1 && last != n - 1) return true;
last = ret;
}
if (ret != 1) return true;
return false;
}
bool Miller_Rabin(long long n) {
if (n < 2) return false;
if (n == 2) return true;
if ((n & 1) == 0) return false;
long long x = n - 1;
long long t = 0;
while ((x & 1) == 0) {
x >>= 1;
t++;
}
for (int i = 0; i < S; i++) {
long long a = rand() % (n - 1) + 1;
if (check(a, n, x, t)) return false;
}
return true;
}
long long factor[100];
int tol, cnt;
long long Pollard_rho(long long x, long long c) {
long long i = 1, k = 2;
long long x0 = rand() % x;
long long y = x0;
while (1) {
i++;
x0 = (mult_mod(x0, x0, x) + c) % x;
long long d = gcd(abs(y - x0), x);
if (d != 1 && d != x) return d;
if (y == x0) return x;
if (i == k) {
y = x0;
k += k;
}
}
}
void findfac(long long n) {
if (n == 1) return;
if (Miller_Rabin(n)) {
m[n]++;
return;
}
long long p = n;
while (p >= n) p = Pollard_rho(p, rand() % (n - 1) + 1);
findfac(p);
findfac(n / p);
}
struct query {
long long n, k;
int id;
bool operator<(const query &temp) const { return k < temp.k; }
};
query qy[11111];
long long k_list[11111], dist[32333333];
bool ans[11111];
int cnt_k;
struct pp {
long long vl;
int id;
bool operator<(const pp &temp) const {
if (vl == temp.vl) return id < temp.id;
return vl < temp.vl;
}
};
map<pp, int> hs;
map<pp, int>::iterator ht;
pp now, u;
long long power(long long a, long long n, long long mod) {
if (n == 0) return 1;
long long ret = power(a, n / 2, mod);
ret = ret * ret % mod;
if (n % 2) ret = ret * a % mod;
return ret;
}
int main() {
int i, j, s, p, q, t;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%lld%lld", &qy[i].n, &qy[i].k);
qy[i].id = i;
}
sort(qy, qy + t);
for (i = 0; i < t;) {
for (j = i; j < t; j++) {
if (qy[i].k != qy[j].k) break;
}
m.clear();
findfac(qy[i].k);
cnt = 0;
for (it = m.begin(); it != m.end(); it++) factor[cnt++] = it->first;
if (cnt == 2) {
for (s = i; s < j; s++) {
long long vl = qy[s].n % factor[0], x = factor[1] % factor[0];
vl = vl * power(x, factor[0] - 2, factor[0]) % factor[0];
if (factor[1] * vl <= qy[s].n)
ans[qy[s].id] = 1;
else
ans[qy[s].id] = 0;
}
} else if (cnt > 2) {
for (s = 0; s < factor[0]; s++) dist[s] = 1e18 + 9;
dist[0] = 0;
hs.clear();
now.id = 0;
now.vl = 0;
hs[now];
while (hs.size()) {
ht = hs.begin();
u = ht->first;
hs.erase(u);
if (u.vl > dist[u.id]) continue;
for (s = 1; s < cnt; s++) {
int id = (u.id + factor[s]) % factor[0];
long long vl = dist[u.id] + factor[s];
if (dist[id] > vl) {
dist[id] = vl;
now.id = id;
now.vl = vl;
hs[now];
}
}
}
for (s = i; s < j; s++) {
if (dist[qy[s].n % factor[0]] <= qy[s].n)
ans[qy[s].id] = 1;
else
ans[qy[s].id] = 0;
}
} else {
for (s = i; s < j; s++) ans[qy[s].id] = qy[s].n % factor[0] == 0;
}
i = j;
}
for (i = 0; i < t; i++) {
if (ans[i])
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int t;
map<long long int, vector<pair<long long int, long long int>>> qur;
bool p[32000000];
vector<long long int> primes;
vector<pair<long long int, long long int>> adj[1000005];
long long int dist[1000005];
set<pair<long long int, long long int>> s;
string ans[100005];
long long int powmod(long long int a, long long int b, long long int m) {
long long int an = 1;
while (b > 0) {
if ((b & 1)) an = (an * a) % m;
b >>= 1;
a = (a * a) % m;
}
return an;
}
vector<long long int> get_prime_list(long long int x) {
vector<long long int> an;
for (auto j : primes) {
if (j * j > x) break;
if (x % j == 0) {
while (x % j == 0) x /= j;
an.push_back(j);
}
}
if (x > 1) an.push_back(x);
if (an.size() == 0) an.push_back(2e18);
return an;
}
void dij() {
dist[0] = 0;
s.insert({0, 0});
while (s.size()) {
long long int i = s.begin()->second;
long long int d = s.begin()->first;
s.erase(s.begin());
for (auto j : adj[i]) {
if (dist[j.first] > dist[i] + j.second) {
auto h = s.find({dist[j.first], j.first});
if (h != s.end()) s.erase(h);
dist[j.first] = dist[i] + j.second;
s.insert({dist[j.first], j.first});
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
memset(p, 1, sizeof p);
for (int i = 2; i <= 1e4; i++) {
if (p[i]) {
for (int j = i * i; j <= 32000000; j += i) {
p[j] = 0;
}
}
}
for (int i = 2; i <= 32000000; i++)
if (p[i]) primes.push_back(i);
for (int i = 1; i <= t; i++) {
long long int x, y;
cin >> x >> y;
qur[y].push_back({x, i});
}
for (auto j : qur) {
long long int k = j.first;
vector<long long int> pl = get_prime_list(k);
if (pl.size() == 1) {
for (auto pn : j.second) {
ans[pn.second] = (pn.first % pl[0] == 0 ? "YES\n" : "NO\n");
}
} else if (pl.size() == 2) {
for (auto pn : j.second) {
if (pn.first >= ((pl[0] - 1) * (pl[1] - 1)))
ans[pn.second] = "YES\n";
else {
long long int x = pl[0];
long long int y = pl[1];
long long int z = powmod(y % x, x - 2, x);
z = (z * (pn.first % x)) % x;
if (pn.first >= z * y)
ans[pn.second] = "YES\n";
else
ans[pn.second] = "NO\n";
}
}
} else {
for (int i = 0; i < pl[0]; i++) {
dist[i] = 1e18;
adj[i].clear();
}
for (auto h : pl) {
for (int i = 0; i < pl[0]; i++) {
adj[i].push_back({(i + h) % pl[0], h});
}
}
dij();
for (auto pn : j.second)
ans[pn.second] =
(pn.first >= (dist[pn.first % pl[0]]) ? "YES\n" : "NO\n");
}
}
for (int i = 1; i <= t; i++) cout << ans[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 4e7 + 5;
long long n, k;
map<long long, int> IM;
int tot = 0;
vector<long long> s[N];
int ID(long long x) {
if (IM.count(x)) return IM[x];
IM[x] = ++tot;
return -1;
}
int p[M], cnt;
bool vis[M];
void init() {
for (int i = (2); i < (M - 2); i++) {
if (!vis[i]) p[cnt++] = i;
for (int j = 0; j < cnt && (long long)p[j] * i < M; j++) {
vis[p[j] * i] = true;
if (i % p[j] == 0) break;
}
}
}
vector<pair<int, long long> > g[N];
long long d[60][N];
void dij(long long *d) {
priority_queue<pair<int, long long>, vector<pair<int, long long> >,
greater<pair<int, long long> > >
q;
d[0] = 0;
q.push(pair<int, long long>(0, 0));
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = true;
for (auto it : g[u]) {
if (d[u] + it.second < d[it.first]) {
d[it.first] = d[u] + it.second;
q.push(pair<int, long long>(d[it.first], it.first));
}
}
}
}
long long qpow(long long x, long long n, long long p) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % p;
x = x * x % p;
n >>= 1;
}
return res;
}
int main() {
init();
int t;
scanf("%d", &t);
while (t--) {
scanf("%I64d%I64d", &n, &k);
if (n == 1 || k == 1) {
printf("NO\n");
continue;
}
int id = ID(k);
if (id == -1) {
id = tot;
long long tmp = k;
for (int i = 0; (long long)p[i] * p[i] <= tmp; i++) {
if (tmp % p[i] == 0) {
while (tmp % p[i] == 0) tmp /= p[i];
s[id].push_back(p[i]);
}
}
if (tmp > 1) s[id].push_back(tmp);
if ((int)s[id].size() >= 3) {
int mn = s[id][0];
for (int i = (0); i < (mn); i++)
g[i].clear(), vis[i] = false, d[id][i] = 2e18;
for (int i = (0); i < (mn); i++)
for (auto v : s[id])
g[i].push_back(pair<int, long long>((v + i) % mn, v));
dij(d[id]);
}
}
if ((int)s[id].size() == 1) {
if (n % s[id][0] == 0)
printf("YES\n");
else
printf("NO\n");
} else if ((int)s[id].size() == 2) {
long long inv1 = qpow(s[id][0], s[id][1] - 2, s[id][1]);
long long b = n % s[id][1] * inv1 % s[id][1];
if (b == 0 || n / b >= s[id][0]) {
printf("YES\n");
} else
printf("NO\n");
} else if ((int)s[id].size() >= 3) {
int mn = s[id][0];
if (d[id][(n % mn)] <= n)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pr[6000005], cnt, target[5000005], pre[5000005], last[100005], tot;
bool flag[31622780], ans[50005], visited[100005], flag2;
long long dis[100005], w[5000005];
vector<long long> v;
struct query {
long long n, k;
int id;
} c[50005];
bool cmp(query x, query y) { return x.k < y.k; }
void exgcd(long long a, long long b, __int128 &x, __int128 &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
void res(long long x) {
v.clear();
for (int i = 1; i <= cnt; i++)
if (!(x % pr[i])) {
v.push_back(pr[i]);
while (!(x % pr[i])) x /= pr[i];
}
if (x != 1) v.push_back(x);
}
void add(int x, int y, long long z) {
target[++tot] = y;
pre[tot] = last[x];
last[x] = tot;
w[tot] = z;
}
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
void build() {
tot = 0;
for (int i = 0; i < v[0]; i++) dis[i] = 1e18, visited[i] = 0, last[i] = 0;
for (int i = 0; i < v[0]; i++)
for (int j = 1; j < v.size(); j++) add(i, (i + v[j]) % v[0], v[j]);
dis[0] = 0;
q.push(make_pair(0, 0));
while (!q.empty()) {
while ((!q.empty()) && visited[q.top().second]) q.pop();
if (q.empty()) break;
int now = q.top().second;
q.pop();
for (int i = last[now]; i; i = pre[i]) {
int tar = target[i];
if (dis[tar] > dis[now] + w[i])
dis[tar] = dis[now] + w[i], q.push(make_pair(dis[tar], tar));
}
}
}
int main() {
for (int i = 2; i <= 31622776; i++) {
if (!flag[i]) pr[++cnt] = i;
for (int j = 1; j <= cnt && i * pr[j] <= 31622776; j++) {
flag[i * pr[j]] = 1;
if (!(i % pr[j])) break;
}
}
int t;
scanf("%d", &t);
for (int i = 1; i <= t; i++) scanf("%lld%lld", &c[i].n, &c[i].k), c[i].id = i;
sort(c + 1, c + t + 1, cmp);
for (int i = 1; i <= t; i++) {
if (c[i].k == 1) continue;
if (c[i].k != c[i - 1].k) flag2 = 0, res(c[i].k);
if (v.size() == 1)
ans[c[i].id] = ((c[i].n % v[0]) == 0);
else if (v[0] <= 100000) {
if (!flag2) build(), flag2 = 1;
if (dis[c[i].n % v[0]] <= c[i].n) ans[c[i].id] = 1;
} else {
__int128 x, y, t;
exgcd(v[0], v[1], x, y);
if (x < 0) t = x / v[1] + 1, x += t * v[1], y -= t * v[0];
x *= c[i].n, y *= c[i].n;
t = x / v[1];
x -= v[1] * t, y += v[0] * t;
if (y >= 0) ans[c[i].id] = 1;
}
}
for (int i = 1; i <= t; i++)
if (ans[i])
puts("YES");
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 3e6 + 7;
const double pi = acos(-1.0);
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
template <typename T>
inline T powMM(T a, T b, T M) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
const int maxsqrtk = 3.5e7 + 7;
int p[maxsqrtk], cntp;
void initfactor() {
int i, j;
for (i = 2; i < maxsqrtk; i++) {
if (!p[i]) p[cntp++] = i;
for (j = 0; j < cntp; j++) {
if (i * p[j] >= maxsqrtk) break;
p[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
};
}
const int maxk = 57;
vector<long long> minvalue[maxk], factor[maxk];
long long kth[maxk], cntk;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
less<pair<long long, long long> > >
Q;
int TaskA() {
int i, id;
long long n, k;
scanf("%I64d%I64d", &n, &k);
for (id = 0; id < cntk; id++)
if (kth[id] == k) break;
if (cntk == id) {
;
kth[cntk++] = k;
for (i = 0; i < cntp; i++) {
if (p[i] > k / p[i]) break;
if (k % p[i] == 0) factor[id].push_back(p[i]);
while (k % p[i] == 0) k /= p[i];
}
if (k != 1) factor[id].push_back(k);
for (long long v : factor[id])
;
;
if (factor[id].size() > 2) {
;
long long p = factor[id][0];
minvalue[id].resize(p, INFF);
minvalue[id][0] = 0;
Q.push(make_pair(0ll, 0ll));
while (Q.size()) {
auto now = Q.top();
Q.pop();
long long pos = now.second;
if (minvalue[id][pos] != now.first) continue;
for (long long len : factor[id])
if (len != p) {
long long nxtpos = (pos + len) % p,
nxtlen = minvalue[id][pos] + len;
if (minvalue[id][nxtpos] > nxtlen) {
minvalue[id][nxtpos] = nxtlen;
Q.push(make_pair(minvalue[id][nxtpos], nxtpos));
}
}
}
}
}
if (factor[id].size() == 0) {
return 0 * puts("NO");
}
if (factor[id].size() == 1) {
if (n % factor[id][0] == 0)
return 0 * puts("YES");
else
return 0 * puts("NO");
}
if (factor[id].size() == 2) {
long long inv, a, p1 = factor[id][0], p2 = factor[id][1];
inv = powMM(p1, p2 - 2, p2);
a = n % p2 * inv % p2;
if (a * p1 <= n)
return 0 * puts("YES");
else
return 0 * puts("NO");
} else {
if (minvalue[id][n % factor[id][0]] <= n)
return 0 * puts("YES");
else
return 0 * puts("NO");
}
}
int main() {
int startTime = clock();
initfactor();
;
int T = 1;
scanf("%d", &T);
startTime = clock();
while (T--) TaskA();
;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
const int N = 1e5 + 5;
const long long INF = (long long)2e18;
template <class T>
inline void read(T &x) {
x = 0;
int c = getchar(), f = 1;
for (; !isdigit(c); c = getchar())
if (c == 45) f = -1;
for (; isdigit(c); c = getchar()) (x *= 10) += f * (c - '0');
}
vector<int> pl, spf;
int _;
map<long long, vector<pair<long long, int>>> mapchik;
long long dis[N];
bool ans[N];
inline unsigned long long mul_mod(unsigned long long a, unsigned long long b,
unsigned long long mod) {
assert(0 <= a && a < mod);
assert(0 <= b && b < mod);
if (mod < int(1e9)) return a * b % mod;
unsigned long long k = (unsigned long long)((long double)a * b / mod);
unsigned long long res = a * b - k * mod;
if ((unsigned long long)res < 0) res += mod;
return res;
}
void exgcd(long long a, long long b, long long &g, long long &x, long long &y) {
if (!b)
g = a, x = 1, y = 0;
else {
exgcd(b, a % b, g, y, x);
y -= x * (a / b);
}
}
void fast_sieve(int n) {
pl.clear();
spf.assign(n, 0);
for (int i = 2; i < n; ++i) {
if (!spf[i]) {
pl.push_back(i);
spf[i] = i;
}
for (int j = 0; j < ((int)(pl).size()) && i * pl[j] < n; ++j) {
int p = pl[j];
spf[i * p] = p;
if (i % p == 0) break;
}
}
}
vector<long long> factorize(long long n) {
vector<long long> u;
for (int i = 0, t = sqrt(n + 1); pl[i] <= t; ++i)
if (n % pl[i] == 0) {
u.push_back(pl[i]);
while (n % pl[i] == 0) n /= pl[i];
t = sqrt(n + 1);
}
if (n > 1) u.push_back(n);
return u;
}
void solve(long long k, vector<pair<long long, int>> queries) {
vector<long long> p = factorize(k);
int n = ((int)(p).size());
if (n == 0) return;
if (n == 1) {
for (auto &q : queries) ans[q.second] = q.first % p[0] == 0;
return;
}
if (n == 2) {
long long a = p[0], b = p[1], g, x, y;
exgcd(a, b, g, x, y);
for (auto &q : queries)
ans[q.second] = (((y % a * (q.first % a) % a + a) % a) * b) <= q.first;
return;
}
for (int i = 0; i < p[0]; ++i) dis[i] = INF;
dis[0] = 0;
set<pair<long long, int>> pq;
for (int i = 0; i < p[0]; ++i) pq.insert(make_pair(dis[i], i));
while (!pq.empty()) {
int u = (*pq.begin()).second;
pq.erase(pq.begin());
for (int i = 1; i < n; ++i) {
int v = (u + p[i]) % p[0];
long long w = dis[u] + p[i];
if (w >= dis[v]) continue;
pq.erase(make_pair(dis[v], v));
dis[v] = w;
pq.insert(make_pair(dis[v], v));
}
}
for (auto &q : queries) ans[q.second] = dis[q.first % p[0]] <= q.first;
}
int main() {
fast_sieve((int)35e6 + 5);
read(_);
for (int i = 0; i < _; ++i) {
long long n, k;
read(n);
read(k);
mapchik[k].push_back(make_pair(n, i));
}
for (auto &it : mapchik) solve(it.first, it.second);
for (int i = 0; i < _; ++i)
if (ans[i])
puts("YES");
else
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long T = 1e4, SQ = 32e6, inf = 1e18 + 10;
bool notprime[SQ], ans[T];
vector<int> primes;
map<long long, vector<pair<long long, int> > > mapk;
long long euclid(long long x, long long y, long long &z1, long long &z2) {
if (y == 0) {
z1 = 1;
z2 = 0;
return x;
}
long long g = euclid(y, x % y, z2, z1);
z2 -= z1 * (x / y);
return g;
}
vector<long long> tajzieh(long long k) {
vector<long long> tmp;
for (int i = 0; i < primes.size(); i++) {
if (k % primes[i] == 0) {
tmp.push_back(primes[i]);
while (k % primes[i] == 0) k /= primes[i];
}
}
if (k > 1) tmp.push_back(k);
return tmp;
}
void answer(long long k, vector<pair<long long, int> > q) {
vector<long long> kprimes = tajzieh(k);
if (kprimes.size() == 0)
return;
else if (kprimes.size() == 1) {
for (auto query : q) {
if (query.first % kprimes[0] == 0) ans[query.second] = 1;
}
return;
} else if (kprimes.size() == 2) {
long long z1 = 0, z2 = 0;
long long x = kprimes[0], y = kprimes[1];
euclid(x, y, z1, z2);
z2 %= x;
if (z2 < 0) z2 += x;
for (auto query : q) {
long long tmp = (z2 * (query.first % x) % x) * y;
if (tmp <= query.first) ans[query.second] = 1;
}
return;
}
int m = kprimes[0];
long long dis[m];
for (int i = 0; i < m; i++) dis[i] = inf;
dis[0] = 0;
set<pair<long long, long long> > dij;
dij.insert({0, 0});
while (!dij.empty()) {
int x = dij.begin()->second;
dij.erase(dij.begin());
for (int i = 1; i < kprimes.size(); i++) {
long long y = (x + kprimes[i]) % m;
if (dis[x] + kprimes[i] < dis[y]) {
dij.erase({dis[y], y});
dis[y] = dis[x] + kprimes[i];
dij.insert({dis[y], y});
}
}
}
for (auto query : q) {
if (dis[query.first % m] <= query.first) ans[query.second] = 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 2; i < SQ; i++) {
if (notprime[i] == 0) {
primes.push_back(i);
for (int j = i * 2; j < SQ; j += i) notprime[j] = 1;
}
}
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long n, k;
cin >> n >> k;
mapk[k].push_back({n, i});
}
for (auto i : mapk) answer(i.first, i.second);
for (int i = 0; i < t; i++) {
if (ans[i] == 1)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int T = 11000;
long long N[T], M[T];
int id[T];
bool ans[T];
namespace Factor {
const int MAXN = 2000005;
const int CERTAINTY = 8;
const int RUNS = 20;
int maxn, prn;
int p[MAXN], prm[MAXN];
vector<long long> d;
long long fac[110];
long long q[110], e[110];
long long a[1000000];
int cnt;
using PLI = pair<long long, int>;
inline long long mul(long long a, long long b, long long p) {
if (p <= INT_MAX) return a * b % p;
if (p <= 1LL << 40)
return (((a * (b >> 20) % p) << 20) + (a * (b & ((1 << 20) - 1)))) % p;
return (a * b - (long long)((long double)a / p * b + 1e-8) * p + p) % p;
}
void prime_sieve() {
prn = 0;
for (int i = 1; i <= maxn; i++) p[i] = i;
for (int i = 2; i <= maxn; i++) {
if (p[i] == i) prm[prn++] = i;
for (int j = 0, x; j < prn && (x = i * prm[j]) <= maxn && prm[j] <= p[i];
j++)
p[x] = prm[j];
}
}
void init(int mxn) {
maxn = mxn;
prime_sieve();
}
long long modExp(long long a, long long n, long long p) {
long long ret = 1;
for (a = (a % p + p) % p; n; n >>= 1, a = mul(a, a, p))
if (n & 1) ret = mul(ret, a, p);
return ret;
}
bool witness(long long a, long long n) {
long long u = n - 1, x, y;
int t = __builtin_ctzll(u);
u >>= t;
for (x = modExp(a, u, n); t--; x = y) {
y = mul(x, x, n);
if (y == 1 && x != 1 && x != n - 1) return 1;
}
return x != 1;
}
bool miller(long long n) {
if (n < 2) return 0;
if (n == 2) return 1;
if (n <= maxn) return p[n] == n;
if (~n & 1) return 0;
for (int j = 0; j < CERTAINTY; j++)
if (witness(rand() % (n - 1) + 1, n)) return 0;
return 1;
}
void extEuclid(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
extEuclid(b, a % b, y, x);
y -= (a / b) * x;
}
long long gcd(long long a, long long b) {
long long ret = 1;
while (a) {
if ((~a & 1) && (~b & 1))
a >>= 1, b >>= 1, ret <<= 1;
else if (~a & 1)
a >>= __builtin_ctzll(a);
else if (~b & 1)
b >>= __builtin_ctzll(b);
else {
if (a < b) a ^= b ^= a ^= b;
a -= b;
}
}
return ret * b;
}
long long rho(long long n) {
if (n <= 100) {
for (int m = 2; m * m <= n; m++)
if (n % m == 0) return m;
}
while (1) {
int runs = RUNS;
long long x = rand() % n, y, T = 1, *ly = a, *lx = ly;
long long c = rand() % 10 + 3;
x = mul(x, x, n) + c;
*(ly++) = x;
lx++;
y = mul(x, x, n) + c;
*(ly++) = y;
while (x != y) {
long long t = x - y;
if (t < 0) t += n;
long long z = mul(T, t, n);
if (!z) return gcd(T, n);
runs--;
if (!runs) {
runs = RUNS;
z = gcd(z, n);
if (z != 1) return z;
}
T = z;
y = *(ly++) = mul(y, y, n) + c;
y = *(ly++) = mul(y, y, n) + c;
x = *(lx++);
}
}
}
void factorize(long long n) {
for (int i = 0; i < cnt; i++)
if (n % fac[i] == 0) n /= fac[i], fac[cnt++] = fac[i];
if (n <= maxn) {
for (; n > 1; n /= p[n]) fac[cnt++] = p[n];
return;
}
if (n == 1) return;
if (miller(n))
fac[cnt++] = n;
else {
long long x = rho(n);
factorize(x), factorize(n / x);
}
}
void norm() {
sort(fac, fac + cnt);
int _cnt = cnt;
cnt = 0;
for (int i = 0; i < _cnt; i++) {
if (i == 0 || fac[i] != fac[i - 1])
q[cnt] = fac[i], e[cnt++] = 1;
else
e[cnt - 1]++;
}
}
void dfs(long long x, int ptr) {
if (ptr == cnt)
d.push_back(x);
else {
dfs(x, ptr + 1);
for (int i = 0; i < e[ptr]; i++) dfs(x *= q[ptr], ptr + 1);
}
}
vector<long long> divisor(long long n) {
cnt = 0;
factorize(n);
norm();
d.clear();
dfs(1, 0);
return d;
}
vector<pair<long long, int> > factor(long long n) {
cnt = 0;
factorize(n);
norm();
vector<pair<long long, int> > ret;
for (int i = 0; i < cnt; i++) ret.push_back(make_pair(q[i], e[i]));
return ret;
}
bool is_primitive(long long g, long long p) {
assert(miller(p));
vector<PLI> D = factor(p - 1);
for (int i = 0; i < D.size(); i++)
if (modExp(g, (p - 1) / D[i].first, p) == 1) return 0;
return 1;
}
int get_primitive(long long p) {
assert(miller(p));
vector<PLI> D = factor(p - 1);
for (int g = 1;; g++) {
int flg = 1;
for (int i = 0; flg && i < D.size(); i++)
flg &= (modExp(g, (p - 1) / D[i].first, p) != 1);
if (flg) return g;
}
}
}; // namespace Factor
using Factor::factor;
long long dis[1 << 17];
bool chk[1 << 17];
int main() {
int ncase;
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> ncase;
for (int i = 0; i < ncase; i++) cin >> N[i] >> M[i], id[i] = i;
sort(id, id + ncase, [](int i, int j) { return M[i] < M[j]; });
Factor::init(1000000);
for (int i = 0, j; i < ncase; i = j) {
long long K = M[id[i]];
auto v = factor(K);
vector<long long> p;
for (auto t : v) p.push_back(t.first);
auto check = [&](long long n, long long x, long long y) {
if (n < 0) return 0;
if (n >= (x - 1) * (y - 1)) return 1;
long long a, b;
Factor::extEuclid(x, y, a, b);
a = (a % y + y) % y, b = (b % x + x) % x;
a = Factor::mul(a, n % y, y);
if (a * x <= n) return 1;
return 0;
};
auto build = [](vector<long long> p) {
const long long inf = 1LL << 60;
for (int k = 0; k < p[0]; k++) dis[k] = inf, chk[k] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
dis[0] = 0;
Q.emplace(0, 0);
while (!Q.empty()) {
auto cur = Q.top();
Q.pop();
int mod = cur.second;
if (chk[mod]) continue;
for (auto x : p) {
int now = (mod + x) % p[0];
if (dis[now] > dis[mod] + x) {
dis[now] = dis[mod] + x;
Q.emplace(dis[now], now);
}
}
}
};
if (p.size() >= 3) build(p);
for (j = i; j < ncase && M[id[i]] == M[id[j]]; j++) {
int k = id[j];
if (p.empty())
continue;
else if (p.size() == 1)
ans[k] = (N[k] % p[0] == 0);
else if (p.size() == 2) {
if (check(N[k], p[0], p[1])) ans[k] = 1;
} else {
if (dis[N[k] % p[0]] <= N[k]) ans[k] = 1;
}
}
}
for (int i = 0; i < ncase; i++) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e9 * (long long)1e9;
const int T = 1e4 + 10, SQ = 32 * 1e6, N = 1e5 + 10;
long long n[T], k[T], dp[N];
int ans[T], q;
vector<int> cheat;
bitset<SQ> not_prime;
long long power(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long res = power(a, b / 2, mod);
res *= res, res %= mod;
if (b & 1) res *= a, res %= mod;
return res;
}
inline void calculate(vector<long long> &v) {
long long sz = v.size(), p = v[0];
for (int i = 1; i < p; i++) dp[i] = INF;
set<pair<long long, int> > st;
st.insert({0, 0});
while (st.size()) {
auto r = st.begin()->second;
st.erase(st.begin());
for (int i = 1; i < sz; i++) {
int rp = ((long long)r + v[i]) % p;
if (dp[rp] > dp[r] + v[i]) {
st.erase({dp[rp], rp});
dp[rp] = dp[r] + v[i];
st.insert({dp[rp], rp});
}
}
}
return;
}
inline void solve(int p) {
long long y = k[p];
vector<long long> primes;
for (auto i : cheat) {
if (y % i == 0) {
primes.push_back(i);
while (y % i == 0) y /= i;
}
}
if (y > 1) primes.push_back(y);
int sz = primes.size();
if (sz >= 3) {
calculate(primes);
long long p0 = primes[0];
for (int i = 0; i < q; i++) {
if (k[i] == k[p]) {
long long x = n[i];
if (dp[x % p0] <= x)
ans[i] = 1;
else
ans[i] = 0;
}
}
return;
}
if (sz == 2) {
for (int i = 0; i < q; i++) {
if (k[i] == k[p]) {
long long x = n[i];
long long p0 = primes[0], q0 = primes[1];
long long inv = power(q0, p0 - 2, p0);
inv *= (x % p0);
inv %= p0;
if (q0 * inv <= n[i])
ans[i] = 1;
else
ans[i] = 0;
}
}
return;
}
if (sz == 1) {
for (int i = 0; i < q; i++) {
if (k[i] == k[p]) {
long long x = n[i];
if (x % primes[0] == 0)
ans[i] = 1;
else
ans[i] = 0;
}
}
return;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> q;
for (int i = 0; i < q; i++) cin >> n[i] >> k[i];
memset(ans, -1, sizeof ans);
not_prime[0] = 1;
for (long long i = 2; i < SQ; i++)
if (!not_prime[i]) {
cheat.push_back(i);
for (long long j = i * i; j < SQ; j += i) not_prime[j] = true;
}
for (int i = 0; i < q; i++)
if (ans[i] == -1) solve(i);
for (int i = 0; i < q; i++)
if (ans[i])
cout << "YES\n";
else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int M = 4e7;
int pr[M / 10];
int prSz = 0;
bool np[M];
long long mod;
long long mul(long long a, long long b) {
a %= mod;
b %= mod;
long long q = (long long)(1.0 * a * b / mod);
long long r = a * b - q * mod;
r %= mod;
if (r < 0) r += mod;
return r;
}
long long g(long long x) {
long long ans = mul(x, x) + 1;
if (ans >= mod) ans -= mod;
return ans;
}
vector<long long> factorization(long long x) {
vector<long long> res;
for (int i = 0; i < prSz; i++) {
if (x % pr[i]) continue;
res.push_back(pr[i]);
while (x % pr[i] == 0) x /= pr[i];
}
if (x > 1) res.push_back(x);
return res;
}
long long euclid(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = euclid(b, a % b, y, x);
y -= x * (a / b);
return d;
}
bool ans[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 2; i < M; ++i)
if (!np[i]) {
pr[prSz++] = i;
for (long long j = 1ll * i * i; j < M; j += i) np[j] = 1;
}
map<long long, vector<pair<long long, int> > > mp;
int itest;
cin >> itest;
for (int i = 0; i < itest; ++i) {
long long n;
cin >> n;
long long k;
cin >> k;
mp[k].emplace_back(n, i);
}
for (auto it : mp) {
vector<long long> vec = factorization(it.first);
if (vec.size() == 0) continue;
if (vec.size() == 1) {
for (pair<long long, int> T : it.second)
ans[T.second] = (T.first % vec[0] == 0);
continue;
}
if (vec.size() == 2) {
long long a, b;
assert(euclid(vec[0], vec[1], a, b) == 1);
b %= vec[0];
b += vec[0];
b %= vec[0];
for (pair<long long, int> T : it.second)
ans[T.second] = (b * (T.first % vec[0]) % vec[0]) * vec[1] <= T.first;
continue;
}
vector<long long> d(vec[0], 1e18);
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push(pair<long long, int>(0, 0));
d[0] = 0;
while (pq.size()) {
int u = pq.top().second;
long long du = pq.top().first;
pq.pop();
if (du != d[u]) continue;
for (long long x : vec) {
long long v = (x + u) % vec[0];
if (d[v] > du + x) {
d[v] = du + x;
pq.push(pair<long long, int>(d[v], v));
}
}
}
for (pair<long long, int> T : it.second)
ans[T.second] = (T.first >= d[T.first % vec[0]]);
}
for (int i = 0; i < itest; ++i) {
if (ans[i])
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int pri[9] = {2, 3, 5, 7, 11, 13, 15, 17, 23}, cnt = 0;
long long seed = 2001071221701002ll, ans[66];
inline long long rnd() {
seed ^= (seed << 13ll);
seed ^= (seed >> 17ll);
seed ^= (seed << 5ll);
return (seed < 0 ? -seed : seed);
}
inline void add(long long &a, long long b, long long p) {
a = (a + b >= p ? a + b - p : a + b);
}
inline long long mul(long long a, long long b, long long p) {
long long res = 0, tp = a;
while (b) {
if (b & 1ll) add(res, tp, p);
add(tp, tp, p);
b >>= 1ll;
}
return res;
}
inline long long qpow(long long a, long long b, long long mod) {
a %= mod;
long long res = 1, tp = a;
while (b) {
if (b & 1ll) res = mul(res, tp, mod);
tp = mul(tp, tp, mod);
b >>= 1ll;
}
return res;
}
inline long long gcd(long long a, long long b) {
while (a % b) {
long long t = a;
a = b;
b = t % b;
}
return b;
}
inline bool chk(long long n) {
if (n <= 1) return false;
long long now = n - 1;
int cnt = 0, i, j;
while (!(now & 1ll)) {
now >>= 1ll;
cnt++;
}
for (i = 0; i < 9; i++) {
if (n == pri[i]) return true;
if (n % pri[i] == 0) return false;
long long m = qpow(pri[i], now, n), pre;
for (j = 0; j < cnt; j++) {
pre = m;
m = mul(m, m, n);
if (m == 1 && pre != 1 && pre != n - 1) return false;
}
if (m != 1) return false;
}
return true;
}
inline long long rho(long long n) {
long long x = rnd() % (n - 1) + 1, y = x;
long long c = rnd() % (n - 1) + 1, d;
int i = 1, k = 2;
while (1) {
i++;
x = mul(x, x, n) + c;
if (x >= n) x -= n;
if (x == y) return n;
if (i > 4000000) return n;
if (x > y) {
d = gcd(x - y, n);
} else {
d = gcd(y - x, n);
}
if (d > 1 && d < n) return d;
if (i == k) {
y = x;
k <<= 1;
}
}
}
void solve(long long n) {
if (chk(n)) {
ans[++cnt] = n;
return;
}
long long p = rho(n);
while (p == n) p = rho(n);
solve(p);
solve(n / p);
}
struct node {
long long n, k;
int id;
} t[10005];
bool res[10005];
inline bool cmp(node a, node b) { return a.k < b.k; }
long long dis[100005];
int o[66];
priority_queue<pair<long long, int> > q;
inline void work() {
int i, sz = ans[1];
for (i = 1; i <= cnt; i++) o[i] = ans[i] % sz;
for (i = 0; i < sz; i++) dis[i] = (1ll << 60ll);
dis[0] = 0;
q.push(make_pair(0, 0));
while (!q.empty()) {
int id = q.top().second;
long long d = -q.top().first;
q.pop();
if (dis[id] != d) continue;
for (i = 2; i <= cnt; i++) {
int np = (id + o[i] >= sz ? id + o[i] - sz : id + o[i]);
if (dis[np] > dis[id] + ans[i]) {
dis[np] = dis[id] + ans[i];
q.push(make_pair(-dis[np], np));
}
}
}
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
int main() {
srand(time(0));
int T, i;
scanf("%d", &T);
for (i = 1; i <= T; i++) {
scanf("%lld%lld", &t[i].n, &t[i].k);
t[i].id = i;
}
sort(t + 1, t + T + 1, cmp);
for (i = 1; i <= T; i++) {
if (t[i].k == 1) continue;
if (t[i].k != t[i - 1].k) {
cnt = 0;
solve(t[i].k);
sort(ans + 1, ans + cnt + 1);
cnt = unique(ans + 1, ans + cnt + 1) - ans - 1;
if (cnt >= 3) work();
}
if (cnt == 1) {
if (t[i].n % t[i].k == 0) res[t[i].id] = 1;
continue;
}
if (cnt == 2) {
long long x, y;
exgcd(ans[1], ans[2], x, y);
x = (x % ans[2] + ans[2]) % ans[2];
x = mul(x, t[i].n % ans[2], ans[2]);
if (x * ans[1] <= t[i].n) res[t[i].id] = 1;
continue;
}
int bel = t[i].n % ans[1];
if (t[i].n >= dis[bel]) res[t[i].id] = 1;
}
for (i = 1; i <= T; i++) puts(res[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100010, inf = 1e9;
map<long long, long long> mp;
struct poi {
long long x;
long long dis;
};
priority_queue<poi> q;
bool operator<(poi a, poi b) { return a.dis > b.dis; }
struct edge {
long long too;
long long dis;
long long pre;
} e[maxn * 15];
struct que {
long long pos;
long long w;
};
vector<que> v[maxn];
long long n, T, tot, K, tott, pcnt;
long long last[maxn], ans[maxn], prime[10000000];
long long dist[maxn], pri[maxn], pos[maxn];
bool vis[32000000];
template <typename T>
inline void read(T &k) {
long long f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
inline long long power(long long a, long long b, long long mod) {
long long ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * a * ans % mod;
return ans;
}
inline void add(long long x, long long y, long long z) {
e[++tot] = (edge){y, z, last[x]};
last[x] = tot;
}
inline void dij(long long s) {
memset(dist, 0x3f, sizeof(dist));
dist[s] = 0;
q.push((poi){s, dist[s]});
while (!q.empty()) {
poi now = q.top();
q.pop();
if (now.dis != dist[now.x]) continue;
for (long long i = last[now.x], too; i; i = e[i].pre)
if (dist[too = e[i].too] > dist[now.x] + e[i].dis) {
dist[too] = dist[now.x] + e[i].dis;
q.push((poi){too, dist[too]});
}
}
}
inline void getpri(long long n) {
for (long long i = 2; i <= n; i++) {
if (!vis[i]) prime[++pcnt] = i;
for (long long j = 1; prime[j] * i <= n; j++) {
vis[prime[j] * i] = 1;
if (i % prime[j] == 0) break;
}
}
}
signed main() {
read(T);
getpri(sqrt(1e15));
for (long long i = 1; i <= T; i++) {
read(n);
read(K);
if (!mp.count(K)) mp[K] = ++tott, pos[tott] = K;
v[mp[K]].push_back((que){i, n});
}
for (long long i = 1; i <= tott; i++) {
long long x = pos[i];
long long cnt = 0;
for (long long j = 1; 1ll * prime[j] * prime[j] <= x && j <= pcnt; j++)
if (x % prime[j] == 0) {
pri[++cnt] = prime[j];
while (x % prime[j] == 0) x /= prime[j];
}
if (x != 1) pri[++cnt] = x;
if (!cnt)
for (long long j = 0; j < v[i].size(); j++) ans[v[i][j].pos] = 0;
else if (cnt == 1) {
for (long long j = 0; j < v[i].size(); j++)
ans[v[i][j].pos] = (v[i][j].w % pri[1] == 0);
} else if (cnt == 2) {
long long inv = power(pri[1], pri[2] - 2, pri[2]);
for (long long j = 0; j < v[i].size(); j++)
ans[v[i][j].pos] =
(1ll * pri[1] * (1ll * inv * (v[i][j].w % pri[2]) % pri[2]) <=
v[i][j].w);
} else {
tot = 0;
memset(last, 0, sizeof(last));
for (long long j = 0; j < pri[1]; j++) {
for (long long k = 1; k <= cnt; k++)
add(j, (j + pri[k]) % pri[1], pri[k]);
}
dij(0);
for (long long j = 0; j < v[i].size(); j++)
ans[v[i][j].pos] = (dist[v[i][j].w % pri[1]] <= v[i][j].w);
}
}
for (long long i = 1; i <= T; i++) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int tmax = 1e4 + 42, MX = 32e6, K_MAX = 1e5 + 42;
struct query {
long long n, k;
int id;
};
bool cmp(query a, query b) { return a.k < b.k; }
int t;
query inp[tmax];
bitset<MX> is_prime;
vector<int> primes;
void prec() {
int p = 2;
while (p * p < MX) {
for (int j = p * p; j < MX; j = j + p) is_prime[j] = 1;
p++;
while (is_prime[p]) p++;
}
for (int i = 2; i < MX; i++)
if (is_prime[i] == 0) primes.push_back(i);
}
bool output[tmax];
vector<long long> current;
long long dist[K_MAX];
priority_queue<pair<long long, int> > pq;
long long my_pow(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long mem = my_pow(a, b / 2, mod);
if (b % 2) return mem * mem % mod * a % mod;
return mem * mem % mod;
}
void solve(int l, int r) {
current = {};
for (auto k : primes) {
if (1LL * k * k > inp[l].k) break;
if (inp[l].k % k == 0) {
while (inp[l].k % k == 0) inp[l].k = inp[l].k / k;
current.push_back(k);
}
}
if (inp[l].k != 1) current.push_back(inp[l].k);
if (current.size() == 0) return;
if (current.size() == 1) {
long long p = current[0];
for (int j = l; j <= r; j++)
if (inp[j].n % p == 0) output[inp[j].id] = 1;
return;
}
if (current.size() >= 3) {
for (int j = 0; j < current[0]; j++) dist[j] = -1;
pq.push({0, 0});
while (pq.size()) {
pair<long long, int> now = pq.top();
pq.pop();
if (dist[now.second] != -1) continue;
dist[now.second] = -now.first;
for (int i = 1; i < current.size(); i++)
pq.push({-(-now.first + current[i]),
(-now.first + current[i]) % current[0]});
}
for (int j = l; j <= r; j++)
if (dist[inp[j].n % current[0]] <= inp[j].n) output[inp[j].id] = 1;
}
for (int j = l; j <= r; j++)
if (inp[j].n % current[0] == 0 || inp[j].n % current[1] == 0)
output[inp[j].id] = 1;
else {
long long b = my_pow(current[1] % current[0], current[0] - 2, current[0]);
b = b * (inp[j].n % current[0]) % current[0];
if (b <= inp[j].n / current[1]) output[inp[j].id] = 1;
}
}
int main() {
prec();
scanf("%i", &t);
for (int i = 1; i <= t; i++) {
scanf("%lld%lld", &inp[i].n, &inp[i].k);
inp[i].id = i;
}
sort(inp + 1, inp + t + 1, cmp);
for (int i = 1; i <= t; i++) {
int j = i;
while (j <= t && inp[i].k == inp[j].k) j++;
solve(i, j - 1);
i = j - 1;
}
for (int i = 1; i <= t; i++)
if (output[i])
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
const int N = 31623000;
using namespace std;
bool fl[N];
int pri[2000000], tot;
void init() {
for (int i = 2; i < N; i++) {
if (!fl[i]) pri[++tot] = i;
for (int j = 1; i * pri[j] < N; j++) {
fl[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
long long mul(long long x, long long y, long long mo) {
long long s = 0;
x %= mo;
y %= mo;
for (; y; y /= 2, x = (x + x) % mo)
if (y & 1) s = (s + x) % mo;
return s;
}
long long power(long long x, long long y, long long mo) {
long long s = 1;
for (; y; y /= 2, x = mul(x, x, mo))
if (y & 1) s = mul(s, x, mo);
return s;
}
struct que {
long long n, x;
int id;
} q[10005];
bool cmp(que a, que b) { return a.x < b.x; }
bool pd[100005];
bool ans[10005];
long long f[100005];
long long p[55];
void upd(long long x, int w) {
for (int i = 0; i < w; i++) pd[i] = 0;
for (int i = 0; i < w; i++)
if (!pd[i]) {
int k = i, j = (i + x) % w;
for (; j != i;) {
if (f[j] < f[k]) k = j;
j = (j + x) % w;
}
j = k;
for (;;) {
pd[k] = 1;
f[(k + x) % w] = min(f[(k + x) % w], f[k] + x);
k = (k + x) % w;
if (k == j) break;
}
}
}
void solve(int l, int r, long long k) {
long long n, m = k;
int cnt = 0;
for (int i = 1; i <= tot; i++) {
if (1ll * pri[i] * pri[i] > m) break;
if (m % pri[i] == 0) {
p[++cnt] = pri[i];
for (; m % pri[i] == 0; m /= pri[i])
;
}
}
if (m > 1) p[++cnt] = m;
if (cnt == 0) {
for (int i = l; i <= r; i++) ans[q[i].id] = (q[i].n == 0);
} else if (cnt == 1) {
for (int i = l; i <= r; i++) ans[q[i].id] = (q[i].n % k == 0);
} else if (cnt == 2) {
long long a = p[1], b = p[2], c, d;
c = power(b, a - 2, a);
for (int i = l; i <= r; i++) {
long long n = q[i].n;
d = mul(n, c, a);
d = (d + a) % a;
if (d <= n / b) ans[q[i].id] = 1;
}
} else {
long long w = p[1];
for (int i = 1; i < p[1]; i++) f[i] = (1ll << 60);
f[0] = 0;
for (int i = 2; i <= cnt; i++) upd(p[i], w);
for (int i = l; i <= r; i++)
if (f[q[i].n % w] <= q[i].n) ans[q[i].id] = 1;
}
}
int T;
int main() {
init();
scanf("%d", &T);
for (int i = 1; i <= T; i++) {
scanf("%lld%lld", &q[i].n, &q[i].x);
q[i].id = i;
}
sort(q + 1, q + T + 1, cmp);
for (int i = 1, j; i <= T; i = j + 1) {
for (j = i; j != T && q[j + 1].x == q[i].x; j++)
;
solve(i, j, q[i].x);
}
for (int i = 1; i <= T; i++) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T, typename... U>
inline void read(T& x, U&... y) {
read(x), read(y...);
}
const int N = 1e5 + 10, INF = 0x7fffffff, MAX = 5e7, M = MAX + 10;
int cnt, p, T, tot, gg;
long long fc[55][20], V[20];
int dis[N], pri[M];
bool vis[N], sign[M], ANS[10010];
map<long long, int> used;
struct Query {
long long n, k;
int id;
} PB[10010];
bool cmp(Query A, Query B) { return A.k < B.k; }
struct Data {
int u, dis;
Data() {}
Data(int a, int b) : u(a), dis(b) {}
bool operator<(const Data& rhs) const { return dis > rhs.dis; }
};
void Prepare() {
for (int i = 2; i <= MAX; ++i) {
if (!sign[i]) pri[++gg] = i;
for (int j = 1; i * pri[j] <= MAX; ++j) {
sign[i * pri[j]] = true;
if (i % pri[j] == 0) break;
}
}
}
void Solve(long long x) {
tot = 0;
if (x == 1) return;
if (used[x]) {
int t = used[x];
for (int i = 1; i <= fc[t][0]; ++i) V[++tot] = fc[t][i];
return;
}
used[x] = ++cnt;
for (int i = 1; i <= gg && pri[i] <= x; ++i)
if (x % pri[i] == 0) {
fc[cnt][++fc[cnt][0]] = pri[i];
V[++tot] = pri[i];
while (x % pri[i] == 0) x /= pri[i];
}
if (x != 1) fc[cnt][++fc[cnt][0]] = x, V[++tot] = x;
}
void Dijkstra() {
priority_queue<Data> Q;
for (int i = 0; i < V[1]; ++i) vis[i] = false, dis[i] = INF;
dis[0] = 0;
Q.push(Data(0, 0));
while (!Q.empty()) {
Data A = Q.top();
Q.pop();
int u = A.u;
if (vis[u]) continue;
vis[u] = true;
for (int i = 2; i <= tot; ++i) {
int v = (u + V[i]) % V[1];
if (dis[v] > dis[u] + V[i]) {
dis[v] = dis[u] + V[i];
Q.push(Data(v, dis[v]));
}
}
}
}
long long Pow(long long a, long long k, long long P) {
long long res = 1;
for (long long i = k; i; i >>= 1) {
if (i & 1) res = res * a % P;
a = a * a % P;
}
return res;
}
int main() {
Prepare();
read(T);
for (int i = 1; i <= T; ++i) read(PB[i].n, PB[i].k), PB[i].id = i;
sort(PB + 1, PB + T + 1, cmp);
long long t;
for (int c = 1; c <= T; ++c) {
int Next = c;
while (PB[Next + 1].k == PB[c].k) ++Next;
Solve(PB[c].k);
if (tot > 1) t = Pow(V[2], V[1] - 2, V[1]);
if (tot > 2) Dijkstra();
for (int j = c; j <= Next; ++j) {
if (tot == 0) {
ANS[PB[j].id] = false;
continue;
}
if (tot == 1) {
ANS[PB[j].id] = PB[j].n % PB[j].k == 0;
continue;
}
if (tot == 2) {
long long x = PB[j].n % V[1] * t % V[1];
ANS[PB[j].id] = x * V[2] <= PB[j].n;
} else
ANS[PB[j].id] = dis[PB[j].n % V[1]] <= PB[j].n;
}
c = Next;
}
for (int i = 1; i <= T; ++i) puts(ANS[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 4e6 + 5;
long long pri[maxn], cnt;
bool p[maxn * 9];
long long P;
void init() {
for (long long i = 2; i <= P; ++i) {
if (!p[i]) pri[++cnt] = i;
for (long long j = 1; j <= cnt && i * pri[j] <= P; ++j) {
p[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
long long a[50], tot;
long long dis[100005];
vector<pair<int, int>> e[100005];
priority_queue<pair<long long, long long>> Q;
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
map<long long, long long> mp;
long long owo = 0;
vector<pair<long long, long long>> q[100];
long long ans[10010];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long T;
cin >> T;
P = sqrt(1e15 + 0.5);
init();
for (long long _ = 1; _ <= T; ++_) {
long long n, k;
cin >> n >> k;
if (!mp[k]) mp[k] = ++owo;
q[mp[k]].emplace_back(n, _);
}
for (auto xs : mp) {
long long k, u;
tie(k, u) = xs;
tot = 0;
for (long long i = 1; i <= cnt && 1ll * pri[i] * pri[i] <= k; ++i) {
if (k % pri[i] == 0) {
a[++tot] = pri[i];
while (k % pri[i] == 0) k /= pri[i];
}
}
if (k != 1) a[++tot] = k;
if (k == 1) {
for (auto x : q[u]) {
long long n, id;
tie(n, id) = x;
ans[id] = 0;
}
} else if (tot == 1) {
for (auto x : q[u]) {
long long n, id;
tie(n, id) = x;
if (n % a[1])
ans[id] = 0;
else
ans[id] = 1;
}
} else if (tot == 2) {
long long x, y;
exgcd(a[1], a[2], x, y);
x = (x % a[2] + a[2]) % a[2];
for (auto xx : q[u]) {
long long n, id;
tie(n, id) = xx;
long long tx = n % a[2] * x % a[2];
long long ty = (n - a[1] * tx) / a[2];
if (ty < 0)
ans[id] = 0;
else
ans[id] = 1;
}
} else {
memset(dis, 0x3f, sizeof dis);
for (long long i = 0; i < a[1]; ++i) e[i].clear();
for (long long i = 2; i <= tot; ++i)
for (long long j = 0; j < a[1]; ++j)
e[j].emplace_back((j + a[i]) % a[1], a[i]);
dis[0] = 0;
Q.emplace(0, 0);
while (!Q.empty()) {
long long u;
long long d;
tie(d, u) = Q.top();
Q.pop();
d = -d;
if (d != dis[u]) continue;
for (auto x : e[u]) {
long long v, w;
tie(v, w) = x;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
Q.emplace(-dis[v], v);
}
}
}
for (auto x : q[u]) {
long long n, id;
tie(n, id) = x;
if (dis[n % a[1]] <= n)
ans[id] = 1;
else
ans[id] = 0;
}
}
}
for (long long i = 1; i <= T; ++i) {
cout << (ans[i] ? "YES" : "NO") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, cnt, ans, pr[32000010], tot;
bool p[32000010], an[100010];
long long f[100010], inf = 1e18 + 7, d[100];
struct qu {
long long n, m;
int id;
bool operator<(qu const &a) const { return m < a.m; }
} q[100010];
struct node {
int s;
long long v;
node(int _s = 0, long long _v = 0) { s = _s, v = _v; }
bool operator<(node const &a) const { return v > a.v; }
};
priority_queue<node> qe;
long long mul(long long a, long long b, long long c) {
a %= c;
b %= c;
long long k = 0;
while (b) {
if (b & 1) k = (k + a) % c;
a = 2 * a % c;
b >>= 1;
}
return k;
}
long long pw(long long i, long long k, long long mm) {
long long a = 1;
while (k) {
if (k & 1) a = mul(a, i, mm);
i = mul(i, i, mm);
k >>= 1;
}
return a;
}
void solve(long long mi) {
int i, s, a, b, k;
long long vv = mi;
node j;
for (i = 1, cnt = 0; i <= tot && pr[i] * pr[i] <= vv; i++)
if (!(vv % pr[i])) {
while (!(vv % pr[i])) vv /= pr[i];
d[++cnt] = pr[i];
}
if (vv > 1) d[++cnt] = vv;
if (cnt < 3) return;
for (i = 0; i < d[1]; i++) f[i] = inf;
f[0] = 0;
qe.push(node(0, 0));
while (!qe.empty()) {
j = qe.top();
qe.pop();
if (j.v > f[s = j.s]) continue;
for (i = 2; i <= cnt; i++) {
k = (s + d[i]) % d[1];
if (f[k] > f[s] + d[i]) qe.push(node(k, f[k] = f[s] + d[i]));
}
}
}
int main() {
int i, s, a, b;
long long x, y, c, j, k;
for (i = 2; i < 32000010; i++) {
if (!p[i]) pr[++tot] = i;
for (s = 1; s <= tot && i * pr[s] < 32000010; s++) {
p[i * pr[s]] = 1;
if (!(i % pr[s])) break;
}
}
scanf("%d", &t);
for (i = 1; i <= t; i++) scanf("%I64d%I64d", &q[i].n, &q[i].m), q[i].id = i;
sort(q + 1, q + 1 + t);
for (i = 1; i <= t; i = s) {
solve(q[i].m);
s = i;
while (s <= t && q[s].m == q[i].m) {
if (!cnt) an[q[s].id] = 0;
if (cnt == 1) an[q[s].id] = !(q[s].n % d[1]);
if (cnt == 2) {
k = mul(q[s].n, j = pw(d[2], d[1] - 2, d[1]), d[1]);
k = ((k % d[1]) + d[1]) % d[1];
an[q[s].id] = (k <= (q[s].n / d[2]));
}
if (cnt >= 3) an[q[s].id] = (q[s].n >= f[q[s].n % d[1]]);
s++;
}
}
for (i = 1; i <= t; i++) {
if (an[i])
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10003, M = 31622800, K = 1952000, L = 100003;
template <typename T>
inline void read(T &x) {
int ch = getchar();
x = 0;
bool f = false;
for (; ch < '0' || ch > '9'; ch = getchar()) f |= ch == '-';
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
if (a > b) return a = b, 1;
return 0;
}
int t, m, pri[K], cnt, tot, head[L], to[L << 2], nxt[L << 2];
bool ans[N];
struct Query {
int id;
long long n, k;
inline bool operator<(const Query &o) const {
return k < o.k || k == o.k && id < o.id;
}
} q[N];
bitset<M> notp;
long long p[N], dis[L], w[L << 2], x, y, d;
void init(int m) {
notp[0] = notp[1] = 1;
for (register int i = 2; i <= m; ++i) {
if (!notp[i]) pri[tot++] = i;
for (register int j = 0; j < tot && i * pri[j] <= m; ++j) {
notp[i * pri[j]] = true;
if (!(i % pri[j])) break;
}
}
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
d = a;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
void add(int a, int b, long long c) {
to[++cnt] = b;
nxt[cnt] = head[a];
head[a] = cnt;
w[cnt] = c;
}
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
int main() {
read(t);
init(M - 1);
for (register int i = 1; i <= t; ++i) {
read(q[i].n);
read(q[i].k);
q[i].id = i;
}
sort(q + 1, q + t + 1);
for (register int i = 1; i <= t; ++i) {
if (q[i].k == 1) continue;
if (q[i].k != q[i - 1].k) {
m = 0;
long long tmp = q[i].k;
for (register int j = 0; j < tot && (long long)pri[j] * pri[j] <= tmp;
++j)
if (!(tmp % pri[j])) {
p[m++] = pri[j];
tmp /= pri[j];
while (!(tmp % pri[j])) tmp /= pri[j];
}
if (tmp > 1) p[m++] = tmp;
if (m > 2) {
memset(head, 0, sizeof head);
cnt = 0;
for (register int i = 1; i < m; ++i)
for (register int j = 0; j < p[0]; ++j)
add(j, (j + p[i]) % p[0], p[i]);
memset(dis, 0x3f, sizeof dis);
dis[0] = 0;
pq.push(make_pair(0ll, 0));
while (!pq.empty()) {
pair<long long, long long> tmp = pq.top();
pq.pop();
if (tmp.first != dis[tmp.second]) continue;
int u = tmp.second;
for (register int i = head[u]; i; i = nxt[i])
if (chmin(dis[to[i]], dis[u] + w[i]))
pq.push(make_pair(dis[to[i]], to[i]));
}
} else if (m == 2) {
exgcd(p[0], p[1], x, y);
x = (x % p[1] + p[1]) % p[1];
}
}
if (m > 2)
ans[q[i].id] = dis[q[i].n % p[0]] <= q[i].n;
else if (m == 2) {
if (q[i].n % d) continue;
q[i].n /= d;
long long tmp = (q[i].n % p[1] * x % p[1] + p[1]) % p[1];
ans[q[i].id] = tmp * p[0] <= q[i].n;
} else
ans[q[i].id] = !(q[i].n % p[0]);
}
for (register int i = 1; i <= t; ++i) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, vector<pair<long long, int>>> mapchik;
const long long INF = (long long)2e18;
const int M = (int)35e6;
const int PSZ = (int)3e6;
bool p[M];
int pr[PSZ];
int prSz;
const int N = (int)1e5 + 10;
bool ANS[N];
long long dist[N];
long long euclid(long long x, long long y, long long &k, long long &l) {
if (y == 0) {
k = 1;
l = 0;
return x;
}
long long g = euclid(y, x % y, l, k);
l -= k * (x / y);
return g;
}
vector<long long> factorize(long long x) {
vector<long long> res;
for (int i = 0; i < prSz; i++) {
if (x % pr[i]) continue;
res.push_back(pr[i]);
while (x % pr[i] == 0) x /= pr[i];
}
if (x > 1) res.push_back(x);
return res;
}
void solve(long long k, vector<pair<long long, int>> queries) {
vector<long long> a = factorize(k);
int n = (int)a.size();
if (n == 0) {
return;
} else if (n == 1) {
for (pair<long long, int> q : queries) {
ANS[q.second] = q.first % a[0] == 0;
}
return;
} else if (n == 2) {
long long r = 0, s = 0;
if (euclid(a[0], a[1], r, s) != 1) throw;
s %= a[0];
if (s < 0) s += a[0];
for (pair<long long, int> q : queries) {
long long z = ((s * (q.first % a[0])) % a[0]) * a[1];
ANS[q.second] = z <= q.first;
}
return;
}
int m = a[0];
for (int i = 0; i < m; i++) dist[i] = INF;
dist[0] = 0;
set<pair<long long, int>> setik;
for (int i = 0; i < m; i++) setik.insert(make_pair(dist[i], i));
while (!setik.empty()) {
int v = setik.begin()->second;
setik.erase(setik.begin());
for (int i = 1; i < n; i++) {
int u = (v + a[i]) % m;
long long w = dist[v] + a[i];
if (w >= dist[u]) continue;
setik.erase(make_pair(dist[u], u));
dist[u] = w;
setik.insert(make_pair(dist[u], u));
}
}
for (pair<long long, int> q : queries) {
ANS[q.second] = dist[q.first % m] <= q.first;
}
}
int main() {
for (int i = 2; i < M; i++) p[i] = 1;
for (int x = 2; x < M; x++) {
if (!p[x]) continue;
pr[prSz++] = x;
for (int y = 2 * x; y < M; y += x) p[y] = 0;
}
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
long long n, k;
scanf("%lld%lld", &n, &k);
mapchik[k].push_back(make_pair(n, i));
}
for (auto it : mapchik) {
solve(it.first, it.second);
}
for (int i = 0; i < t; i++)
if (ANS[i])
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
#pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename T>
int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
long long read() {
long long x = 0;
bool q = 0;
char c = getchar();
while (!isdigit(c)) q |= (c == '-'), c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + c - '0', c = getchar();
return q ? -x : x;
}
void print(long long x, char q = '\n') {
if (x < 0) putchar('-'), x = -x;
if (x == 0) putchar('0');
stack<char> s;
s.push(q);
while (x > 0) s.push(x % 10 + '0'), x /= 10;
while (!s.empty()) putchar(s.top()), s.pop();
}
string read_s() {
string s;
char c = getchar();
while (c == ' ' || c == '\t' || c == '\n') c = getchar();
while (c != ' ' && c != '\t' && c != '\n') s += c, c = getchar();
return s;
}
void print_s(string s, char q = '\n') {
for (char c : s) putchar(c);
putchar(q);
}
char read_c() {
char c = getchar();
while (c == ' ' || c == '\t' || c == '\n') c = getchar();
return c;
}
long long mul(long long a, long long b, long long mod) {
bool q = (a < 0) ^ (b < 0);
a = abs(a) % mod, b = abs(b) % mod;
long long ret = 0;
while (b) {
if (b & 1) {
ret += a;
if (ret >= mod) ret -= mod;
}
a += a;
if (a >= mod) a -= mod;
b >>= 1;
}
if (q) ret = (-ret) % mod;
return ret;
}
long long ext_gcd(long long a, long long b, long long &x, long long &y) {
long long xx = y = 0, yy = x = 1;
while (b) {
int q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
bool solve(long long a, long long b, long long c, long long &x, long long &y,
long long &z) {
z = ext_gcd(a, b, x, y);
if (c % z != 0) return 0;
long long dx = c / a;
c -= dx * a;
long long dy = c / b;
c -= dy * b;
x = dx + mul(x, c / z, b);
y = dy + mul(y, c / z, a);
z = abs(z);
return 1;
}
const int MAX_N = 50000002;
vector<long long> a[204];
map<long long, int> pt;
map<long long, int> M;
bool pr[MAX_N];
int main() {
int id = 0, idx = 60;
for (int i = 2; i * i < MAX_N; i++) {
if (!pr[i]) {
for (int j = i * i; j < MAX_N; j += i) {
pr[j] = 1;
}
}
}
vector<long long> p;
for (int i = 2; i < MAX_N; i++)
if (!pr[i]) p.push_back(i);
int t = read();
while (t--) {
long long n = read(), k = read();
if (k == 1) {
puts("NO");
continue;
}
int _;
if (pt.count(k))
_ = pt[k];
else {
_ = pt[k] = id;
vector<long long> &z = a[id++];
long long x = k;
for (long long u : p)
if (x % u == 0) {
while (x % u == 0) x /= u;
z.push_back(u);
}
if (x > 1) z.push_back(x);
}
vector<long long> z = a[_];
if (z.size() == 1)
puts(n % z.front() == 0 ? "YES" : "NO");
else if (z.size() == 2) {
long long x, y, w;
if (!solve(z[0], z[1], n, x, y, w))
puts("NO");
else {
z[0] /= w;
z[1] /= w;
if (x < 0) {
x = -x;
long long t = x / z[1] + (x % z[1] != 0 ? 1 : 0);
if (y - z[0] * t < 0)
puts("NO");
else
puts("YES");
} else if (y < 0) {
y = -y;
long long t = y / z[0] + (y % z[0] != 0 ? 1 : 0);
if (x - z[1] * t < 0)
puts("NO");
else
puts("YES");
} else {
puts("YES");
}
}
} else {
if (n < z[0]) {
puts("NO");
continue;
}
if (M.count(k))
_ = M[k];
else {
_ = M[k] = idx;
vector<long long> &D = a[idx++];
D.assign(z[0], (long long)2e18);
D[0] = 0;
map<long long, long long> q;
q[0] = 0;
while (q.size()) {
long long x = (*q.begin()).first, d = (*q.begin()).second;
q.erase(x);
for (long long u : z) {
long long xx = (x + u) % z[0], dd = d + u;
if (dd > 2e18) continue;
if (D[xx] > dd) D[xx] = q[xx] = dd;
}
}
}
vector<long long> &D = a[_];
if (D[n % z[0]] > n)
puts("NO");
else
puts("YES");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 50000007;
const long long INF = 0x3f3f3f3f3f3f3f3f;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
int Q, ans[MAXN];
struct Query {
long long n, k;
int id;
bool operator<(const Query &rhs) const { return k < rhs.k; }
} q[MAXN];
int pr[MAXM], pcnt, pfac[MAXN], tot;
bool notp[MAXM];
void sieve(int m) {
for (int i = 2; i <= m; ++i) {
if (!notp[i]) {
pr[++pcnt] = i;
}
for (int j = 1; j <= pcnt && i * pr[j] <= m; ++j) {
notp[i * pr[j]] = 1;
if (i % pr[j] == 0) break;
}
}
}
void extend_gcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
extend_gcd(b, a % b, y, x);
y -= a / b * x;
}
long long dis[MAXN];
bool vis[MAXN];
priority_queue<pair<long long, int> > pq;
void Dijkstra(int p) {
for (int i = 0; i < p; ++i) {
dis[i] = INF;
vis[i] = 0;
}
dis[0] = 0;
pq.push(make_pair(0, 0));
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = 2; i <= tot; ++i) {
int v = (pfac[i] + u) % p;
if (dis[v] > dis[u] + pfac[i]) {
dis[v] = dis[u] + pfac[i];
pq.push(make_pair(-dis[v], v));
}
}
}
}
void init() {
sieve(50000000);
read(Q);
for (int i = 1; i <= Q; ++i) {
read(q[i].n);
read(q[i].k);
q[i].id = i;
}
sort(q + 1, q + Q + 1);
}
void solve() {
for (int i = 1, j = 1; i <= Q; i = j + 1) {
for (j = i; j + 1 <= Q && q[j + 1].k == q[i].k; ++j)
;
long long tmp = q[i].k;
tot = 0;
for (int t = 1; t <= pcnt && 1LL * pr[t] * pr[t] <= tmp; ++t) {
if (tmp % pr[t]) continue;
pfac[++tot] = pr[t];
while (tmp % pr[t] == 0) {
tmp /= pr[t];
}
}
if (tmp > 1) {
pfac[++tot] = tmp;
}
if (tot == 1) {
for (int t = i; t <= j; ++t) {
ans[q[t].id] = (q[t].n % q[t].k == 0);
}
} else if (tot == 2) {
long long x, y;
extend_gcd(pfac[1], pfac[2], x, y);
long long ia = (x + pfac[2]) % pfac[2];
for (int t = i; t <= j; ++t) {
ans[q[t].id] = (pfac[1] * (q[t].n % pfac[2] * ia % pfac[2]) <= q[t].n);
}
} else if (tot >= 3) {
Dijkstra(pfac[1]);
for (int t = i; t <= j; ++t) {
ans[q[t].id] = (dis[q[t].n % pfac[1]] <= q[t].n);
}
}
}
for (int i = 1; i <= Q; ++i) {
puts(ans[i] ? "YES" : "NO");
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[100100];
int pr[31600000], t, p[100100], l, que[100100 * 20], head, tail;
bool bz[31600000], ans[100100], vis[100100];
struct qry {
long long n, k, w;
} q[100100];
bool cmp(qry a, qry b) { return a.k < b.k; }
long long qpow(long long a, long long i, long long mo) {
long long r = 1;
for (; i; i >>= 1, a = a * a % mo)
if (i & 1) r = r * a % mo;
return r;
}
int main() {
scanf("%d", &t);
for (int i = 1; i <= t; i++)
scanf("%I64d %I64d", &q[i].n, &q[i].k), q[i].w = i;
sort(q + 1, q + t + 1, cmp);
for (int i = 2; i < 31600000; i++) {
if (!bz[i]) pr[++pr[0]] = i;
for (int j = 1; j <= pr[0] && i * pr[j] < 31600000; j++) {
bz[i * pr[j]] = 1;
if (i % pr[j] == 0) break;
}
}
for (int i = 1; i <= t; i++) {
long long n = q[i].n, k = q[i].k;
if (k != q[i - 1].k) {
l = 0;
for (int j = 1; k > 1; j++) {
if ((long long)pr[j] * pr[j] > k) {
p[++l] = k;
break;
}
if (k % (long long)pr[j] == 0) {
p[++l] = pr[j];
while (k % (long long)pr[j] == 0) k /= (long long)pr[j];
}
}
}
k = q[i].k;
if (l == 0)
ans[q[i].w] = 0;
else if (l == 1)
ans[q[i].w] = n % k == 0;
else if (l == 2) {
long long b =
n % (long long)p[1] * qpow(p[2], p[1] - 2, p[1]) % (long long)p[1];
ans[q[i].w] = b * (long long)p[2] <= n;
} else {
if (k != q[i - 1].k) {
for (int j = 1; j <= p[1]; j++) f[j] = 1e18;
f[0] = 0;
for (head = 0, vis[que[tail = 1] = 0] = 1; head ^ tail;) {
int x, j;
for (x = que[++head], j = 2; j <= l; j++) {
long long F = f[x] + p[j];
int v = (x + p[j]) % p[1];
if (F < f[v]) {
f[v] = F;
if (!vis[v]) vis[que[++tail] = v] = 1;
}
}
vis[x] = 0;
}
}
ans[q[i].w] = f[q[i].n % p[1]] <= q[i].n;
}
}
for (int i = 1; i <= t; i++)
if (ans[i])
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const long long inf = (long long)2e18;
int ed, T, ans[10005], fir[N];
long long que[66], dis[N];
struct Edge {
int v, nxt;
long long w;
} e[N * 66];
struct Info {
long long n, k;
int id;
bool operator<(const Info& x) const { return k < x.k; }
} qry[10005];
void adde(int x, int y, long long z) {
e[++ed].v = y;
e[ed].w = z;
e[ed].nxt = fir[x];
fir[x] = ed;
}
namespace Prim {
const int maxn = 31700000;
int np, p[maxn / 10];
bool vis[maxn];
void init() {
int i, j;
for (i = 2; i < maxn; ++i) {
if (!vis[i]) p[++np] = i;
for (j = 1; j <= np && i * p[j] < maxn; ++j) {
vis[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
}
int cut(long long n, long long* q) {
int i, t = 0;
for (i = 1; i <= np && p[i] <= n; ++i)
if (n % p[i] == 0) {
for (; n % p[i] == 0; n /= p[i])
;
q[++t] = p[i];
}
if (n != 1) q[++t] = n;
return t;
}
} // namespace Prim
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (!b) return x = 1, y = 0, a;
long long d = exgcd(b, a % b, y, x);
return y -= a / b * x, d;
}
int solve2(long long a, long long b, long long n) {
assert(a > 1 && b > 1);
long long x, y;
long long d = exgcd(a, b, x, y);
if (n % d) return 0;
a /= d;
b /= d;
n /= d;
x = (x % b * (n % b) % b + b) % b;
y = (n - a * x) / b;
return y >= 0;
}
struct P {
long long d;
int x;
P() {}
P(long long _d, int _x) { d = _d, x = _x; }
bool operator<(const P& t) const { return d > t.d; }
};
priority_queue<P> Q;
void dijkstra(int n) {
int i;
for (; Q.size(); Q.pop())
;
for (i = 1; i < n; ++i) dis[i] = inf;
Q.push(P(0, 0));
for (; Q.size();) {
P t = Q.top();
Q.pop();
if (dis[t.x] < t.d) continue;
for (i = fir[t.x]; i; i = e[i].nxt)
if (dis[e[i].v] > dis[t.x] + e[i].w) {
Q.push(P(dis[e[i].v] = dis[t.x] + e[i].w, e[i].v));
}
}
}
int main() {
int i, j;
Prim::init();
scanf("%d", &T);
for (i = 1; i <= T; ++i)
scanf("%I64d%I64d", &qry[i].n, &qry[i].k), qry[i].id = i;
sort(qry + 1, qry + 1 + T);
int l, r;
for (l = 1; l <= T; l = r) {
for (r = l; r <= T && qry[r].k == qry[l].k; ++r)
;
int cnt = Prim::cut(qry[l].k, que);
if (cnt == 1)
for (i = l; i < r; ++i) ans[qry[i].id] = qry[i].n % que[1] == 0;
if (cnt == 2)
for (i = l; i < r; ++i) ans[qry[i].id] = solve2(que[1], que[2], qry[i].n);
if (cnt >= 3) {
assert(que[1] < 100000);
for (ed = i = 0; i < que[1]; ++i) fir[i] = 0;
for (i = 0; i < que[1]; ++i) {
for (j = 2; j <= cnt; ++j) {
adde(i, (i + que[j]) % que[1], que[j]);
}
}
dijkstra(que[1]);
for (i = l; i < r; ++i)
ans[qry[i].id] = dis[qry[i].n % que[1]] <= qry[i].n;
}
}
for (i = 1; i <= T; ++i) printf("%s\n", ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using std::abs;
using std::cerr;
using std::cin;
using std::cout;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::string;
using std::swap;
using std::vector;
using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ull = unsigned long long;
using ld = long double;
template <typename T>
void _dbg(const char *_s, T _h) {
cerr << _s << " = " << _h << "\n";
}
template <typename T, typename... Ts>
void _dbg(const char *_s, T _h, Ts... _t) {
int _b = 0;
while (((_b += *_s == '(') -= *_s == ')') != 0 || *_s != ',') cerr << *_s++;
cerr << " = " << _h << ",";
_dbg(_s + 1, _t...);
}
struct init {
init() {
cin.tie(0);
std::iostream::sync_with_stdio(0);
cout << std::fixed << std::setprecision(10);
cerr << std::fixed << std::setprecision(5);
}
~init() {}
} init;
const int MAXN = 35e6;
const ll INF = 2e18;
int lp[MAXN];
int pr[2146775];
int cpr = 0;
void calc_primes(int n) {
for (int i = 2; i <= n; ++i) {
if (!lp[i]) {
lp[i] = i;
pr[cpr++] = i;
}
for (int j = 0; j < cpr && pr[j] <= lp[i] && i * pr[j] <= n; ++j)
lp[i * pr[j]] = pr[j];
}
}
vector<ll> fct(ll k) {
ll x = k;
vector<ll> res;
for (int j = 0; j < cpr && pr[j] * 1LL * pr[j] <= k; ++j) {
if (x % pr[j] == 0) {
res.emplace_back(pr[j]);
while (x % pr[j] == 0) x /= pr[j];
}
}
if (x ^ 1LL) res.emplace_back(x);
return res;
}
ll mulmod(ll a, ll b, ll m) {
int sign = 1;
if (a < 0) {
a = -a;
sign = -sign;
}
if (b < 0) {
b = -b;
sign = -sign;
}
a %= m;
b %= m;
ull q = (ld)a * (ld)b / (ld)m;
ull r = a * b - q * m;
return (sign * (ll)(((r + 5 * m) % m + m) % m)) % m;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
T p = b / a;
T g = extgcd(b - p * a, a, y, x);
x -= p * y;
return g;
}
template <typename T>
bool diophant(T a, T b, T c, T &x, T &y, T &g) {
if (a == 0 && b == 0) {
if (c == 0) {
x = y = g = 0;
return true;
}
return false;
}
if (a == 0) {
if (c % b == 0) {
x = 0;
y = c / b;
g = abs(b);
return true;
}
return false;
}
if (b == 0) {
if (c % a == 0) {
x = c / a;
y = 0;
g = abs(a);
return true;
}
return false;
}
g = extgcd(a, b, x, y);
if (c % g != 0) {
return false;
}
T dx = c / a;
c -= dx * a;
T dy = c / b;
c -= dy * b;
x = dx + mulmod(x, c / g, b);
y = dy + mulmod(y, c / g, a);
g = abs(g);
return true;
}
int32_t main() {
calc_primes(MAXN - 1);
;
int t;
cin >> t;
map<ll, vector<ll>> dv, dts;
while (t--) {
ll n, k;
cin >> n >> k;
if (dv.find(k) == dv.end()) dv[k] = fct(k);
vector<ll> ps = dv[k];
for (int i : ps)
;
if (ps.empty())
cout << "NO\n";
else if (ps.size() == 1) {
if (n % k == 0)
cout << "YES\n";
else
cout << "NO\n";
} else if (ps.size() == 2) {
ll x, y, g;
if (!diophant(ps[0], ps[1], n, x, y, g))
cout << "NO\n";
else {
;
if (x < 0) {
int bg = ps[1] / g;
int need = (-x + bg - 1) / bg;
x += bg * need;
y -= ps[0] / g * need;
}
if (y < 0) {
int ag = ps[0] / g;
int need = (-y + ag - 1) / ag;
y += ag / need;
x -= ps[1] / g * need;
}
if (x >= 0 && y >= 0)
cout << "YES\n";
else
cout << "NO\n";
}
} else {
;
if (dts.find(k) == dts.end()) {
vector<ll> d(ps[0], INF);
d[0] = 0;
set<pll> s;
s.insert({0, 0});
while (!s.empty()) {
pll v = *s.begin();
s.erase(s.begin());
for (int i = 1; i < ps.size(); ++i) {
ll to = (v.second + ps[i]) % ps[0];
ll len = ps[i];
if (d[to] > v.first + len) {
s.erase({d[to], to});
s.insert({d[to] = v.first + len, to});
}
}
}
dts[k] = d;
}
if (n >= dts[k][n % ps[0]])
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
long long n, m, i, j, t, pc, f[100005], ans[100005];
int p[31600005];
bitset<31600005> np;
map<long long, vector<pair<long long, long long> > > mp;
vector<long long> d;
long long exgcd(long long x, long long y, long long &a, long long &b) {
if (!y) {
a = 1;
b = 0;
return x;
}
long long g = exgcd(y, x % y, b, a);
b -= x / y * a;
return g;
}
long long mul(long long x, long long y, long long mod) {
long long z = 0;
while (y) {
if (y & 1) (z += x) %= mod;
(x += x) %= mod;
y /= 2;
}
return z;
}
void gd(long long x) {
d.clear();
long long i;
for (i = 1; i <= pc; i++) {
if (x % p[i] == 0) {
d.push_back(p[i]);
while (x % p[i] == 0) x /= p[i];
}
}
if (x > 1) d.push_back(x);
}
void solve(long long x, vector<pair<long long, long long> > qrys) {
if (x == 1) return;
int i;
gd(x);
if (d.size() == 1) {
for (__typeof((qrys).begin()) it = (qrys).begin(); it != (qrys).end();
it++) {
if (it->first % x == 0) ans[it->second] = 1;
}
return;
}
if (d.size() == 2) {
for (__typeof((qrys).begin()) it = (qrys).begin(); it != (qrys).end();
it++) {
long long x, y;
long long g = exgcd(d[0], d[1], x, y);
long long mod = d[1] / g;
if (it->first % g != 0) continue;
x %= mod;
x += mod;
x %= mod;
x = mul(x, it->first / g, mod);
if (x * d[0] <= it->first) ans[it->second] = 1;
}
return;
}
memset((f), (0x16), (sizeof((f))));
f[0] = 0;
priority_queue<pair<long long, long long> > pq;
pq.push(make_pair(0, 0));
while (!pq.empty()) {
long long x = pq.top().second, y = -pq.top().first;
pq.pop();
if (f[x] != y) continue;
for (i = 1; i < d.size(); i++) {
long long y = (x + d[i]) % d[0], z = f[x] + (x + d[i]) / d[0];
if (f[y] > z) {
f[y] = z;
pq.push(make_pair(-z, y));
}
}
}
for (__typeof((qrys).begin()) it = (qrys).begin(); it != (qrys).end(); it++) {
if (f[it->first % d[0]] <= it->first / d[0]) ans[it->second] = 1;
}
}
int main() {
for ((i) = (2); (i) <= (31600000); (i)++) {
if (!np[i]) {
p[++pc] = i;
}
for (j = 1; j <= pc; j++) {
if (i * p[j] > 31600000) break;
np[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
read(t);
for (((i)) = (1); ((i)) <= ((t)); ((i))++) {
long long x, y;
read(x);
read(y);
mp[y].push_back(make_pair(x, i));
}
for (__typeof((mp).begin()) it = (mp).begin(); it != (mp).end(); it++) {
solve(it->first, it->second);
}
for (((i)) = (1); ((i)) <= ((t)); ((i))++) {
if (ans[i])
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
}
using namespace std;
int t;
int pri[4001000], pcnt;
bool depri[35001000];
inline void init() {
depri[1] = true;
const int up = 3.5e7;
for (int i = 2; i <= up; ++i) {
if (!depri[i]) pri[++pcnt] = i;
for (int j = 1; j <= pcnt && i * pri[j] <= up; ++j) {
depri[i * pri[j]] = true;
if (i % pri[j] == 0) break;
}
}
}
struct TC {
int id;
long long n, k;
inline bool operator<(const TC &a) const { return k < a.k; }
} tc[10100];
bool ans[10100];
long long p[100];
int ptot;
inline void Div(long long x) {
ptot = 0;
for (int i = 1; 1ll * pri[i] * pri[i] <= x; ++i) {
if (x % pri[i] == 0) {
p[++ptot] = pri[i];
while (x % pri[i] == 0) x /= pri[i];
}
}
if (x != 1) p[++ptot] = x;
}
struct node {
int cur;
long long val;
inline bool operator<(const node &a) const { return val > a.val; }
};
priority_queue<node> q;
long long dis[100100];
bool vis[100100];
inline void Update(long long k) {
Div(k);
if (ptot <= 2) return;
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
dis[0] = 0;
q.push((node){0, 0});
while (!q.empty()) {
int cur = (q.top()).cur;
q.pop();
if (vis[cur]) continue;
vis[cur] = true;
for (int i = 2; i <= ptot; ++i) {
int to = (cur + p[i]) % p[1];
long long val = (cur + p[i]) / p[1];
if (dis[to] <= dis[cur] + val) continue;
dis[to] = dis[cur] + val;
q.push((node){to, dis[to]});
}
}
}
inline long long quickmul(long long x, long long k, long long P) {
x = (x % P + P) % P;
k = (k % P + P) % P;
long long res = 0;
while (k) {
if (k & 1) res = (res + x) % P;
x = (x + x) % P;
k >>= 1;
}
return res;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long g = exgcd(b, a % b, x, y);
long long tmp = x;
x = y;
y = tmp - a / b * y;
return g;
}
inline bool get_ans(long long n) {
if (!ptot) return false;
if (ptot == 1) return n % p[1] == 0;
if (ptot == 2) {
long long x = 0, y = 1;
exgcd(p[1], p[2], x, y);
x = quickmul(x, n, p[2]);
if (1.0 * x * p[1] > 2e18) return false;
return n >= x * p[1];
}
if (1.0 * dis[n % p[1]] * p[1] > 2e18) return false;
return dis[n % p[1]] * p[1] + n % p[1] <= n;
}
signed main() {
init();
read(t);
for (int i = 1; i <= t; ++i) {
read(tc[i].n), read(tc[i].k);
tc[i].id = i;
}
sort(tc + 1, tc + 1 + t);
for (int i = 1; i <= t; ++i) {
if (tc[i].k != tc[i - 1].k) Update(tc[i].k);
ans[tc[i].id] = get_ans(tc[i].n);
}
for (int i = 1; i <= t; ++i) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mulmod(long long a, long long b, long long c) {
long long sign = 1;
if (a < 0) {
a = -a;
sign = -sign;
}
if (b < 0) {
b = -b;
sign = -sign;
}
a %= c;
b %= c;
long long res = 0;
while (b > 0) {
if (b & 1) {
res = (res + a) % c;
}
a = (a + a) % c;
b >>= 1;
}
if (sign == -1) {
res = (-res) % c;
}
return res;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
T p = b / a;
T g = extgcd(b - p * a, a, y, x);
x -= p * y;
return g;
}
template <typename T>
bool diophantine(T a, T b, T c, T &x, T &y, T &g) {
if (a == 0 && b == 0) {
if (c == 0) {
x = y = g = 0;
return true;
}
return false;
}
if (a == 0) {
if (c % b == 0) {
x = 0;
y = c / b;
g = abs(b);
return true;
}
return false;
}
if (b == 0) {
if (c % a == 0) {
x = c / a;
y = 0;
g = abs(a);
return true;
}
return false;
}
g = extgcd(a, b, x, y);
if (c % g != 0) {
return false;
}
T dx = c / a;
c -= dx * a;
T dy = c / b;
c -= dy * b;
x = dx + mulmod(x, c / g, b);
y = dy + mulmod(y, c / g, a);
g = abs(g);
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const int MAX = (int)(sqrt(1e15) + 1e3);
vector<bool> is_prime(MAX, true);
for (int i = 2; i * i < MAX; i++) {
if (is_prime[i]) {
for (int j = i * i; j < MAX; j += i) {
is_prime[j] = false;
}
}
}
vector<int> primes;
for (int i = 2; i < MAX; i++) {
if (is_prime[i]) {
primes.push_back(i);
}
}
int sz = (int)primes.size();
int tt;
cin >> tt;
vector<long long> ns(tt), ks(tt);
map<long long, vector<int>> mapik;
vector<int> res(tt, 0);
for (int i = 0; i < tt; i++) {
cin >> ns[i] >> ks[i];
mapik[ks[i]].push_back(i);
}
for (auto &p : mapik) {
long long k = p.first;
vector<long long> d;
{
long long tmp = k;
for (int it = 0; it < sz && (long long)primes[it] * primes[it] <= tmp;
it++) {
if (tmp % primes[it] == 0) {
d.push_back(primes[it]);
while (tmp % primes[it] == 0) {
tmp /= primes[it];
}
}
}
if (tmp > 1) {
d.push_back(tmp);
}
}
if (d.size() == 0) {
continue;
}
if (d.size() == 1) {
for (int i : p.second) {
res[i] = (ns[i] % d[0] == 0);
}
continue;
}
if (d.size() == 2) {
for (int i : p.second) {
long long x, y, g;
if (diophantine(d[0], d[1], ns[i], x, y, g)) {
if (x >= 0 && y < 0) {
long long can_subtr = x / d[1];
long long need_add = ((-y) + d[0] - 1) / d[0];
if (can_subtr >= need_add) {
y = 0;
}
}
if (x < 0 && y >= 0) {
long long can_subtr = y / d[0];
long long need_add = ((-x) + d[1] - 1) / d[1];
if (can_subtr >= need_add) {
x = 0;
}
}
res[i] = (x >= 0 && y >= 0);
}
}
continue;
}
const long long inf = (long long)2e18;
vector<long long> dist(d[0], inf);
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
s;
dist[0] = 0;
s.emplace(dist[0], 0);
while (!s.empty()) {
long long expected = s.top().first;
int i = s.top().second;
s.pop();
if (dist[i] != expected) {
continue;
}
for (int it = 1; it < (int)d.size(); it++) {
int to = (int)((i + d[it]) % d[0]);
if (dist[i] + d[it] < dist[to]) {
dist[to] = dist[i] + d[it];
s.emplace(dist[to], to);
}
}
}
for (int i : p.second) {
res[i] = (ns[i] >= dist[ns[i] % d[0]]);
}
}
for (int i = 0; i < tt; i++) {
cout << (res[i] ? "YES" : "NO") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int L = 32e6;
const int C = 1e4 + 5;
const int N = 1e5 + 5;
const long long INF = 1e12;
int P[3000005], u;
bool bz[L + 5];
void prepare() {
for (int i = 2; i <= L; i++) {
if (!bz[i]) P[++u] = i;
for (int j = 1; j <= u; j++) {
if (1ll * i * P[j] > L) break;
bz[i * P[j]] = 1;
if (i % P[j] == 0) break;
}
}
}
bool ans[C];
struct query {
long long n, k;
int id;
} qry[C];
bool cmp(query a, query b) { return a.k < b.k; }
long long pri[C];
int m;
long long dis[N];
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
struct status {
int x;
long long dis;
status(const int x_ = 0, const long long dis_ = 0) {
x = x_;
dis = dis_;
}
friend bool operator<(status a, status b) {
return a.dis != b.dis ? a.dis < b.dis : a.x < b.x;
}
};
set<status> s;
long long quickmi(long long x, long long tim, long long mo) {
long long ret = 1;
for (; tim; tim /= 2, x = x * x % mo)
if (tim & 1) ret = ret * x % mo;
return ret;
}
void solve(int L, int R) {
long long k = qry[L].k;
if (k == 1) return;
m = 0;
int lim = sqrt(k);
for (int i = 1; i <= u; i++) {
if (1ll * P[i] * P[i] > k) break;
if (k % P[i] == 0) {
pri[++m] = P[i];
while (k % P[i] == 0) k /= P[i];
}
}
if (k > 1) pri[++m] = k;
if (m == 1) {
for (int i = L; i <= R; i++) ans[qry[i].id] = (qry[i].n % pri[1] == 0);
return;
}
if (m == 2) {
for (int i = L; i <= R; i++) {
long long tmp = qry[i].n % pri[1] *
quickmi(pri[2] % pri[1], pri[1] - 2, pri[1]) % pri[1];
ans[qry[i].id] = (qry[i].n >= tmp * pri[2]);
}
return;
}
int mo = pri[1];
for (int i = 0; i <= mo - 1; i++) dis[i] = -1;
dis[0] = 0;
s.clear();
s.insert(status(0, 0));
while (s.begin() != s.end()) {
int x = (*s.begin()).x;
s.erase(s.begin());
for (int i = 1; i <= m; i++) {
int y = (x + pri[i]) % mo;
if (dis[y] == -1 || dis[y] > dis[x] + pri[i]) {
if (dis[y] != -1) s.erase(status(y, dis[y]));
dis[y] = dis[x] + pri[i];
s.insert(status(y, dis[y]));
}
}
}
for (int i = L; i <= R; i++) {
if (dis[qry[i].n % mo] == -1)
ans[qry[i].id] = 0;
else
ans[qry[i].id] = (qry[i].n >= dis[qry[i].n % mo]);
}
}
int main() {
prepare();
int T = get();
for (int i = 1; i <= T; i++) {
qry[i].id = i;
scanf("%I64d%I64d", &qry[i].n, &qry[i].k);
}
sort(qry + 1, qry + 1 + T, cmp);
int lst = 0;
for (int i = 1; i <= T; i++) {
if (i == T || qry[i].k != qry[i + 1].k) {
solve(lst + 1, i);
lst = i;
}
}
for (int i = 1; i <= T; i++)
if (ans[i])
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 60;
const int MAXT = 1E4 + 10;
const int LIM = 1E5 + 10;
namespace Pollard_Rho {
const int pr[] = {2, 3, 5, 7, 11, 23, 43, 79};
const int M = (1 << 8) - 1;
mt19937 RandEngine(chrono::steady_clock::now().time_since_epoch().count());
long long RandInt(long long L, long long R) {
return uniform_int_distribution<long long>(L, R)(RandEngine);
}
vector<long long> Res;
long long Mx = 0;
long long gcd(long long a, long long b) {
if (!a || !b) return a | b;
int shift = __builtin_ctzll(a | b);
b >>= __builtin_ctzll(b);
while (a) {
a >>= __builtin_ctzll(a);
if (a < b) swap(a, b);
a -= b;
}
return b << shift;
}
unsigned long long Mul(unsigned long long a, unsigned long long b,
unsigned long long P) {
unsigned long long c =
(long long)a * b -
(long long)((unsigned long long)((long double)a * b / P)) * P;
return (c + P) % P;
}
long long ksm(long long a, long long b, long long P) {
long long ret = 1;
for (; b; b >>= 1, a = Mul(a, a, P))
if (b & 1) ret = Mul(ret, a, P);
return ret;
}
bool Miller_Rabin(long long n) {
if (n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 23 || n == 43 ||
n == 79)
return true;
if (~n & 1) return false;
for (int p : pr) {
long long t = n - 1, c = 0;
while (~t & 1) t >>= 1, ++c;
long long pw = ksm(p, t, n);
if (pw == 1) continue;
bool f = (pw == n - 1);
while (c) {
pw = Mul(pw, pw, n);
f |= (pw == n - 1);
--c;
if (pw == 1 && !f) return false;
}
if (pw != 1 || !f) return false;
}
return true;
}
long long Pollard_Rho(long long n) {
int c = RandInt(1, n - 1);
long long t = 1, x = 0, y = 0, q = 1;
auto F = [=](long long x) { return (Mul(x, x, n) + c) % n; };
for (int i = 2;; i <<= 1, y = x, q = 1) {
for (int j = 1; j <= i; j++) {
x = F(x);
q = Mul(q, abs(x - y), n);
if (!(j & M)) {
if ((t = gcd(q, n)) > 1) break;
}
}
if (t > 1 || ((t = gcd(q, n)) > 1)) break;
}
if (t == n) {
t = 1;
while (t == 1) x = F(x), t = gcd(abs(x - y), n);
}
return t;
}
void Factorize(long long n) {
if (Miller_Rabin(n)) return Res.push_back(n), void();
long long d = n;
while (d == n) d = Pollard_Rho(n);
Factorize(n / d);
Factorize(d);
}
vector<long long> solve(long long n) {
Res.clear();
Factorize(n);
return Res;
}
} // namespace Pollard_Rho
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, void();
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
int Ans[MAXT], tot;
long long dis[LIM];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
vector<long long> pr;
map<long long, int> M;
vector<pair<long long, int> > Q[MAXK];
void Dijkstra() {
memset(dis, 0x3f, sizeof dis);
dis[0] = 0;
pq.emplace(0, 0);
while (!pq.empty()) {
auto x = pq.top();
pq.pop();
if (x.first != dis[x.second]) continue;
for (long long p : pr) {
long long v = (p + x.second) % pr[0];
if (dis[v] <= x.first + p) continue;
dis[v] = x.first + p;
pq.emplace(dis[v], v);
}
}
}
int main() {
int T, tst = 0;
scanf("%d", &T);
for (long long n, k; T; T--) {
scanf("%lld%lld", &n, &k);
if (!M.count(k)) M[k] = ++tot;
int id = M[k];
Q[id].emplace_back(n, ++tst);
}
for (auto pK : M) {
int idx = pK.second;
long long K = pK.first;
if (K == 1) continue;
pr = Pollard_Rho::solve(K);
if (pr.size() == 1) {
for (auto q : Q[idx]) Ans[q.second] = q.first % K == 0;
} else if (pr.size() == 2) {
for (auto q : Q[idx]) {
long long x, y;
exgcd(pr[0], pr[1], x, y);
x = (x % pr[1] + pr[1]) % pr[1];
long long fx = Pollard_Rho::Mul(x, q.first, pr[1]), fy;
fy = (q.first - fx * pr[0]) / pr[1];
assert(fx * pr[0] + fy * pr[1] == q.first);
Ans[q.second] = fx >= 0 && fy >= 0;
}
} else {
sort(pr.begin(), pr.end());
Dijkstra();
for (auto q : Q[idx]) Ans[q.second] = dis[q.first % pr[0]] <= q.first;
}
}
for (int i = 1; i <= tst; i++) puts(Ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e18;
const long long MAXK = 1e15;
const long long INF = 4e18;
const int MAXV = 3.2e7 + 5;
const int MAXP = 2e6 + 10;
const int MAXF = 1e5 + 10;
const int MAXQ = 50;
const int MAXLOG = 64;
long long n, k, tot, q;
int f[MAXV], prime[MAXP], cnt[MAXQ + 1];
long long p[MAXQ + 1][MAXLOG], dist[MAXQ + 1][MAXF];
long long mem[MAXQ];
bool visited[MAXP];
template <typename T>
inline void read(T &x) {
long long f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline long long exp_mod(long long a, long long n, long long p) {
long long res = 1, b = a;
while (n > 0) {
if (n & 1) res = res * b % p;
b = b * b % p;
n >>= 1;
}
return res;
}
int main() {
int T;
read(T);
for (int i = 2; i < MAXV; i++) {
if (!f[i]) prime[++tot] = f[i] = i;
for (int j = 1; j <= tot; j++) {
int tmp = i * prime[j];
if (tmp >= MAXV) break;
f[tmp] = prime[j];
}
}
while (T--) {
read(n);
read(k);
if (k == 1) {
printf("NO\n");
continue;
}
int pos = 0;
for (int i = 1; i <= q; i++)
if (mem[i] == k) pos = i;
if (!pos) {
pos = ++q;
mem[pos] = k;
cnt[pos] = 0;
for (int i = 1; 1ll * prime[i] * prime[i] <= k; i++) {
if (k % prime[i] == 0) {
p[pos][++cnt[pos]] = prime[i];
while (k % prime[i] == 0) k /= prime[i];
}
}
if (k != 1) p[pos][++cnt[pos]] = k;
if (cnt[pos] >= 3) {
for (int i = 0; i < p[pos][1]; i++) {
dist[pos][i] = INF;
visited[i] = false;
}
dist[pos][0] = 0;
static priority_queue<pair<long long, int> > q;
q.push(make_pair(0, 0));
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (visited[u]) continue;
visited[u] = true;
for (int i = 2; i <= cnt[pos]; i++) {
int to = (u + p[pos][i]) % p[pos][1];
int w = p[pos][i];
if (dist[pos][u] + w < dist[pos][to]) {
dist[pos][to] = dist[pos][u] + w;
q.push(make_pair(-dist[pos][to], to));
}
}
}
}
}
if (cnt[pos] == 1) {
if (n % p[pos][1] == 0) {
printf("YES\n");
continue;
} else {
printf("NO\n");
continue;
}
}
if (cnt[pos] == 2) {
long long b = n % p[pos][1] *
exp_mod(p[pos][2], p[pos][1] - 2, p[pos][1]) % p[pos][1];
if (b * p[pos][2] <= n)
printf("YES\n");
else
printf("NO\n");
continue;
}
int val = n % p[pos][1];
if (n >= dist[pos][val])
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "sz = " << vc.size() << endl << "[";
for (const T& v : vc) o << v << ",";
o << "]";
return o;
}
using ll = long long;
const ll ccc = 32000000;
bool prime[ccc + 1];
vector<ll> pr;
void makeprime() {
ll i, j;
for (i = 2; i <= ccc; i++) prime[i] = true;
for (i = 2; i * i <= ccc; i++)
if (prime[i])
for (j = 2; j * i <= ccc; j++) prime[j * i] = false;
for (i = 2; i <= ccc; i++)
if (prime[i]) pr.push_back(i);
}
ll extgcd(ll a, ll b, ll& x, ll& y) {
ll u[] = {a, 1, 0}, v[] = {b, 0, 1};
while (*v) {
ll t = *u / *v;
for (int i = 0; i < (int)(3); i++) swap(u[i] -= t * v[i], v[i]);
}
if (u[0] < 0)
for (int i = 0; i < (int)(3); i++) u[i] = -u[i];
x = u[1], y = u[2];
return u[0];
}
ll inv(ll a, ll mod) {
ll x, y;
extgcd(a, mod, x, y);
if (x < 0) x += mod;
return x;
}
const ll inf = 2e18;
vector<ll> dp;
bool solve(ll n, const vector<ll>& vs) {
int K = vs.size();
if (K == 0) return 0;
if (K == 1) return n % vs[0] == 0;
if (K == 2) {
ll a = vs[1], b = vs[0];
ll x = n % b * inv(a, b) % b;
ll y = (n - a * x) / b;
return a * x <= n;
}
return n >= dp[n % vs[0]];
}
void precalc(vector<ll> vs) {
ll a = vs[0];
dp = vector<ll>(a, inf);
dp[0] = 0;
using P = pair<ll, int>;
priority_queue<P, vector<P>, greater<P>> que;
que.push(P(0, 0));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
ll c = p.first;
if (dp[v] != c) continue;
for (ll x : vs) {
int u = (v + x) % a;
if (dp[u] > dp[v] + x) {
dp[u] = dp[v] + x;
que.push(P(dp[u], u));
}
}
}
}
int main() {
makeprime();
int T;
cin >> T;
map<ll, vector<pair<ll, int>>> k2nt;
for (int t = 0; t < (int)(T); t++) {
ll n, k;
cin >> n >> k;
k2nt[k].push_back(make_pair(n, t));
}
vector<bool> ans(T);
for (auto it : k2nt) {
ll k = it.first;
auto vnt = it.second;
vector<ll> ps;
ll ok = k;
for (ll p : pr)
if (k % p == 0) {
ps.push_back(p);
while (k % p == 0) k /= p;
}
if (k > 1) ps.push_back(k);
k = ok;
int A = ps.size();
if (A >= 3) {
precalc(ps);
}
for (auto p : vnt) {
ll n = p.first;
int t = p.second;
ans[t] = solve(n, ps);
}
}
for (int t = 0; t < (int)(T); t++) {
if (ans[t])
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
const int N = 1e5 + 5;
const long long INF = (long long)2e18;
template <class T>
inline void read(T &x) {
x = 0;
int c = getchar(), f = 1;
for (; !isdigit(c); c = getchar())
if (c == 45) f = -1;
for (; isdigit(c); c = getchar()) (x *= 10) += f * (c - '0');
}
vector<int> pl, spf;
int _;
map<long long, vector<pair<long long, int>>> mapchik;
long long dis[N];
bool ans[N];
void exgcd(long long a, long long b, long long &g, long long &x, long long &y) {
if (!b)
g = a, x = 1, y = 0;
else {
exgcd(b, a % b, g, y, x);
y -= x * (a / b);
}
}
void fast_sieve(int n) {
pl.clear();
spf.assign(n, 0);
for (int i = 2; i < n; ++i) {
if (!spf[i]) {
pl.push_back(i);
spf[i] = i;
}
for (int j = 0; j < ((int)(pl).size()) && i * pl[j] < n; ++j) {
int p = pl[j];
spf[i * p] = p;
if (i % p == 0) break;
}
}
}
vector<long long> factorize(long long n) {
vector<long long> u;
for (int i = 0, t = sqrt(n + 1); pl[i] <= t; ++i)
if (n % pl[i] == 0) {
u.push_back(pl[i]);
while (n % pl[i] == 0) n /= pl[i];
t = sqrt(n + 1);
}
if (n > 1) u.push_back(n);
return u;
}
void solve(long long k, vector<pair<long long, int>> queries) {
vector<long long> p = factorize(k);
int n = ((int)(p).size());
if (n == 0) return;
if (n == 1) {
for (auto &q : queries) ans[q.second] = q.first % p[0] == 0;
return;
}
if (n == 2) {
long long a = p[1], b = p[0], g, x, y;
exgcd(a, b, g, x, y);
for (auto &q : queries)
ans[q.second] = (((x % b * (q.first % b) % b + b) % b) * a) <= q.first;
return;
}
for (int i = 0; i < p[0]; ++i) dis[i] = INF;
dis[0] = 0;
set<pair<long long, int>> pq;
for (int i = 0; i < p[0]; ++i) pq.insert(make_pair(dis[i], i));
while (!pq.empty()) {
int u = (*pq.begin()).second;
pq.erase(pq.begin());
for (int i = 1; i < n; ++i) {
int v = (u + p[i]) % p[0];
long long w = dis[u] + p[i];
if (w >= dis[v]) continue;
pq.erase(make_pair(dis[v], v));
dis[v] = w;
pq.insert(make_pair(dis[v], v));
}
}
for (auto &q : queries) ans[q.second] = dis[q.first % p[0]] <= q.first;
}
int main() {
fast_sieve((int)35e6 + 5);
read(_);
for (int i = 0; i < _; ++i) {
long long n, k;
read(n);
read(k);
mapchik[k].push_back(make_pair(n, i));
}
for (auto &it : mapchik) solve(it.first, it.second);
for (int i = 0; i < _; ++i)
if (ans[i])
puts("YES");
else
puts("NO");
}
|
#include <bits/stdc++.h>
const int N = 32000010;
const int M = 10010;
int min[N];
int prime[2000010], pcnt;
bool ans[M];
bool dp[N];
void init() {
for (int i = 2; i < N; ++i) {
if (!min[i]) {
min[i] = i;
prime[pcnt++] = i;
}
for (int j = 0; j < pcnt && i * prime[j] < N; ++j) {
min[i * prime[j]] = prime[j];
if (i % prime[j] == 0) {
break;
}
}
}
}
long long ex_euc(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long ret = ex_euc(b, a % b, x, y), tmp = y;
y = x - a / b * y;
x = tmp;
return ret;
}
long long inv(long long a, long long moder) {
long long b = moder, s = 1, t = 0;
while (b) {
long long tmp = a, q = a / b;
a = b, b = tmp % a;
tmp = s;
s = t;
t = tmp - s * q;
}
return s < 0 ? s + moder : s;
}
long long divide(long long a, long long b) {
return a / b - ((a ^ b) < 0 && a % b);
}
bool check(long long u, long long v, long long x, long long y, long long n) {
return divide(-n * x + v - 1, v) <= divide(n * y, u);
}
int main() {
init();
int test;
scanf("%d", &test);
std::map<long long, std::vector<std::pair<long long, int>>> map;
for (int i = 0; i < test; ++i) {
long long n, k;
scanf("%lld%lld", &n, &k);
map[k].push_back({n, i});
}
for (auto &u : map) {
long long k = u.first;
std::vector<long long> prime;
long long x = k;
for (int i = 0; i < pcnt; ++i) {
if (x % ::prime[i] == 0) {
prime.push_back(::prime[i]);
while (x % ::prime[i] == 0) {
x /= ::prime[i];
}
}
}
if (x > 1) {
prime.push_back(x);
}
if (prime.size() >= 4) {
int sz = prime[0] * prime[1];
memset(dp, 0, sizeof(bool) * sz);
dp[0] = true;
for (auto v : prime) {
for (int i = 0; i + v < sz; ++i) {
if (dp[i]) dp[i + v] = true;
}
}
for (auto v : u.second) {
ans[v.second] = v.first >= sz ? true : dp[v.first];
}
continue;
}
if (prime.empty()) {
for (auto v : u.second) {
ans[v.second] = false;
}
continue;
}
if (prime.size() == 1) {
for (auto v : u.second) {
ans[v.second] = !(v.first % prime[0]);
}
continue;
}
if (prime.size() == 2) {
for (auto v : u.second) {
long long n = v.first;
if (n >= prime[0] * prime[1]) {
ans[v.second] = true;
continue;
}
long long t = (n % prime[0]) * inv(prime[1], prime[0]) % prime[0];
ans[v.second] = n - t * prime[1] >= 0;
}
continue;
}
long long uu = prime[0], vv = prime[1];
long long y;
ex_euc(uu, vv, x, y);
for (auto v : u.second) {
long long n = v.first;
if (n >= uu * vv) {
ans[v.second] = true;
continue;
}
ans[v.second] = false;
for (int i = 0; i * prime[2] <= n; ++i) {
if (check(uu, vv, x, y, n - i * prime[2])) {
ans[v.second] = true;
break;
}
}
}
}
for (int i = 0; i < test; ++i) {
puts(ans[i] ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)2e18;
const int MAXN = (int)1e4 + 5;
const int P = (int)3e7 + (int)3e6;
const int M = (int)1e5;
pair<pair<long long, long long>, int> req[MAXN];
vector<int> primes;
bool isP[P + 5];
bool ans[MAXN];
long long dp[M + 5];
int q;
void pre() {
for (int i = 2; i <= P; ++i) {
if (!isP[i]) {
primes.push_back(i);
if (i * 1ll * i <= P) {
for (int j = i * i; j <= P; j += i) {
isP[j] = 1;
}
}
}
}
}
long long binPow(long long a, long long b, long long m) {
long long ret = 1;
while (b > 0) {
if (b & 1) {
ret = (ret * a) % m;
}
a = (a * a) % m;
b >>= 1;
}
return ret;
}
vector<long long> getPrimes(long long x) {
vector<long long> ret;
for (int p : primes) {
if (x % p == 0) {
ret.push_back(p);
while (x % p == 0) {
x /= p;
}
}
}
if (x > 1) {
ret.push_back(x);
}
return ret;
}
void calcDp(vector<long long> V) {
for (long long i = 0; i < V[0]; ++i) {
dp[i] = INF;
}
dp[0] = 0;
set<pair<long long, int>> S;
S.insert(make_pair(0, 0));
while (!S.empty()) {
int v = S.begin()->second;
S.erase(S.begin());
for (long long cur : V) {
long long to = (v + cur) % V[0];
if (dp[v] + cur < dp[to]) {
S.erase(make_pair(dp[to], to));
dp[to] = dp[v] + cur;
S.insert(make_pair(dp[to], to));
}
}
}
}
void solve() {
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%lld %lld", &req[i].first.second, &req[i].first.first);
req[i].second = i;
}
sort(req + 1, req + q + 1);
vector<long long> V;
long long cur = 0;
for (int i = 1; i <= q; ++i) {
long long n = req[i].first.second;
long long k = req[i].first.first;
int id = req[i].second;
if (cur != k) {
cur = k;
V = getPrimes(cur);
if (V.size() > 2) {
calcDp(V);
}
}
if (cur == 1) {
ans[id] = 0;
continue;
}
if (V.size() == 1) {
ans[id] = (n % k == 0);
} else if (V.size() == 2) {
long long p = V[0], q = V[1];
long long x = ((n % q) * binPow(p, q - 2, q)) % q;
if (n - x * p >= 0) {
ans[id] = 1;
}
} else {
if (dp[n % V[0]] <= n) {
ans[id] = 1;
}
}
}
for (int i = 1; i <= q; ++i) {
printf(ans[i] ? "YES\n" : "NO\n");
}
}
int main() {
int tt = 1;
pre();
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_P = 40000010, N = 10010, MAX_N = 100010;
const long long inf = 1e17;
int p[MAX_P], t, ans[N];
map<long long, vector<pair<long long, int> > > M;
inline void Pre(const int &n) {
for (int i = 2; i <= n; i++) {
if (!p[i]) p[++*p] = i;
for (int j = 1; j <= *p && 1LL * i * p[j] <= n; j++)
if (p[p[j] * i] = 1, i % p[j] == 0) break;
}
}
int m, res;
long long fac[N];
void exgcd(long long x, long long y, long long &a, long long &b) {
if (!y) {
a = 1;
b = 0;
return;
}
exgcd(y, x % y, b, a);
b -= (x / y) * a;
}
long long dis[MAX_N];
priority_queue<pair<long long, int> > Q;
long long a, b;
inline void solve(long long k) {
m = 0;
for (int i = 1; i <= *p && 1LL * p[i] * p[i] <= k; i++)
if (k % p[i] == 0) {
fac[++m] = p[i];
while (k % p[i] == 0) k /= p[i];
}
if (k ^ 1) fac[++m] = k;
if (m <= 1) return;
if (m == 2) {
exgcd(fac[1], fac[2], a, b);
return;
}
for (int i = 0; i < fac[1]; i++) dis[i] = inf;
dis[0] = 0;
Q.push(pair<long long, int>(0, 0));
while (!Q.empty()) {
int x = Q.top().second;
long long d = -Q.top().first;
Q.pop();
if (d != dis[x]) continue;
for (int i = 1; i <= m; i++)
if (dis[(x + fac[i]) % fac[1]] > dis[x] + fac[i]) {
dis[(x + fac[i]) % fac[1]] = dis[x] + fac[i];
Q.push(pair<long long, int>(-dis[(x + fac[i]) % fac[1]],
(x + fac[i]) % fac[1]));
}
}
}
int main() {
scanf("%d", &t);
Pre(MAX_P - 10);
for (int i = 1; i <= t; i++) {
long long n, k;
scanf("%lld%lld", &n, &k);
M[k].push_back(pair<long long, int>(n, i));
}
for (auto Z : M) {
vector<pair<long long, int> > &cur = Z.second;
long long k = Z.first;
solve(k);
for (auto x : cur) {
if (!m)
ans[x.second] = 0;
else if (m == 1)
ans[x.second] = !(x.first % fac[1]);
else if (m == 2) {
long long c =
(x.first % fac[2] * (a % fac[2]) % fac[2] + fac[2]) % fac[2];
ans[x.second] = c <= x.first / fac[1];
} else
ans[x.second] = x.first >= dis[x.first % fac[1]];
}
}
for (int i = 1; i <= t; i++) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, maxm = 35000000;
int T, tot, p[maxm];
long long n, k, dist[maxn];
bool ans[maxn];
map<long long, vector<pair<long long, int> > > mp;
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x), y -= a / b * x;
}
void solve(long long k, vector<pair<long long, int> > Q) {
vector<long long> a;
for (long long i = 1; i <= tot; i++) {
if (k % p[i] == 0) {
a.push_back(p[i]);
while (k % p[i] == 0) k /= p[i];
}
}
if (k > 1) a.push_back(k);
int n = a.size();
if (n == 0) return;
if (n == 1) {
for (auto q : Q) ans[q.second] = q.first % a[0] == 0;
return;
}
if (n == 2) {
long long x, y;
exgcd(a[0], a[1], x, y);
for (auto q : Q)
ans[q.second] =
(y % a[0] + a[0]) % a[0] * (q.first % a[0]) % a[0] * a[1] <= q.first;
return;
}
int m = a[0];
for (int i = 0; i < m; i++) dist[i] = 2e18;
dist[0] = 0;
set<pair<long long, int> > S;
for (int i = 0; i < m; i++) S.insert(pair<long long, int>(dist[i], i));
while (!S.empty()) {
int v = S.begin()->second;
S.erase(S.begin());
for (int i = 1; i < n; i++) {
int u = (v + a[i]) % m;
long long w = dist[v] + a[i];
if (dist[u] > w)
S.erase(pair<long long, int>(dist[u], u)),
S.insert(pair<long long, int>(dist[u] = w, u));
}
}
for (auto q : Q) ans[q.second] = dist[q.first % m] <= q.first;
}
int main() {
fill(p, p + maxm, 1);
for (int i = 2; i < maxm; i++) {
if (p[i]) p[++tot] = i;
for (int j = 1; j <= tot && i * p[j] < maxm; j++) {
p[i * p[j]] = 0;
if (i % p[j] == 0) break;
}
}
scanf("%d", &T);
for (int i = 0; i < T; i++)
scanf("%lld %lld", &n, &k), mp[k].push_back(pair<long long, int>(n, i));
for (auto it : mp) solve(it.first, it.second);
for (int i = 0; i < T; i++) printf("%s\n", ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<long long, long long>;
const long long MAX = 10004, M2 = 1e5 + 10, K = 4e7 + 5;
const long long inf = 0x3f3f3f3f;
void minn(long long &a, long long b) {
if (b < a) a = b;
}
void maxx(long long &a, long long b) {
if (b > a) a = b;
}
bool ans[MAX], vs[MAX];
bitset<K> hav;
bool mark[K];
int32_t lp[K + 1];
long long getlt(long long A, long long n, long long mod) {
long long res = 1;
for (long long i = log2(n); i >= 0; i--)
if (n & (1 << i)) {
res = res * res % mod * A % mod;
} else
res = res * res % mod;
return res;
}
long long a[M2];
long long N[MAX], M[MAX];
long long D[M2];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T;
cin >> T;
vector<long long> pr;
for (long long i = 2; i <= K; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (long long j = 0;
j < (long long)pr.size() && pr[j] <= lp[i] && i * pr[j] <= K; ++j)
lp[i * pr[j]] = pr[j];
}
for (long long i = 1; i <= T; i++) {
cin >> N[i] >> M[i];
}
for (long long c = 1; c <= T; c++)
if (vs[c]) {
if (ans[c])
cout << "YES\n";
else
cout << "NO\n";
} else {
if (M[c] == 1) {
cout << "NO\n";
continue;
}
long long m = M[c];
long long cn = 0;
for (long long i : pr)
if (m % i == 0) {
while (m % i == 0) m /= i;
a[++cn] = i;
}
if (m != 1) {
a[++cn] = m;
}
a[cn + 1] = 1e18;
m = M[c];
if (cn == 1) {
for (long long z = c, n; z <= T; z++)
if (M[z] == m) {
vs[z] = 1;
if (N[z] % a[1] == 0) ans[z] = 1;
}
} else {
long long F = a[1] * a[2];
long long u = 2;
while (a[u + 1] <= F) u++;
if (u == 2 && a[1] != 2) {
for (long long z = c, u; z <= T; z++)
if (M[z] == m) {
vs[z] = 1;
u = N[z] % a[1] * getlt(a[2] % a[1], a[1] - 2, a[1]) % a[1];
if (N[z] >= u * a[2]) ans[z] = 1;
}
} else {
memset(D, 0x3f, sizeof D);
priority_queue<ii, vector<ii>, greater<ii> > Q;
Q.push(ii(0, 0));
D[0] = 0;
while (!Q.empty()) {
ii p = Q.top();
Q.pop();
if (p.first != D[p.second]) continue;
for (long long i = 2; i <= u; i++)
if (D[(p.second + a[i]) % a[1]] > p.first + a[i]) {
D[(p.second + a[i]) % a[1]] = p.first + a[i];
Q.push(ii(p.first + a[i], (p.second + a[i]) % a[1]));
}
}
for (long long z = c, n; z <= T; z++)
if (M[z] == m) {
vs[z] = 1;
n = N[z];
if (n >= D[n % a[1]]) ans[z] = 1;
}
}
}
if (ans[c])
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 3e6 + 7;
const double pi = acos(-1.0);
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
template <typename T>
inline T powMM(T a, T b, T M) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
const int maxsqrtk = 3.5e7 + 7;
int p[maxsqrtk], cntp;
void initfactor() {
int i, j;
for (i = 2; i < maxsqrtk; i++) {
if (!p[i]) p[cntp++] = i;
for (j = 0; j < cntp; j++) {
if (i * p[j] >= maxsqrtk) break;
p[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
fprintf(stderr, "cnt_prime=%d\n", cntp);
}
const int maxk = 57;
vector<long long> minvalue[maxk], factor[maxk];
long long kth[maxk], cntk;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
less<pair<long long, long long> > >
Q;
int TaskA() {
int i, id;
long long n, k;
scanf("%I64d%I64d", &n, &k);
for (id = 0; id < cntk; id++)
if (kth[id] == k) break;
if (cntk == id) {
fprintf(stderr, "%s\n", "initialize");
kth[cntk++] = k;
for (i = 0; i < cntp; i++) {
if (p[i] > k / p[i]) break;
if (k % p[i] == 0) factor[id].push_back(p[i]);
while (k % p[i] == 0) k /= p[i];
}
if (k != 1) factor[id].push_back(k);
if (factor[id].size() > 2) {
long long p = factor[id][0];
minvalue[id].resize(p, INFF);
minvalue[id][0] = 0;
Q.push(make_pair(0ll, 0ll));
while (Q.size()) {
auto now = Q.top();
Q.pop();
long long pos = now.second;
if (minvalue[id][pos] != now.first) continue;
for (long long len : factor[id])
if (len != p) {
long long nxtpos = (pos + len) % p,
nxtlen = minvalue[id][pos] + len;
if (minvalue[id][nxtpos] > nxtlen) {
minvalue[id][nxtpos] = nxtlen;
Q.push(make_pair(minvalue[id][nxtpos], nxtpos));
}
}
}
}
}
if (factor[id].size() == 0) {
return 0 * puts("NO");
}
if (factor[id].size() == 1) {
if (n % factor[id][0] == 0)
return 0 * puts("YES");
else
return 0 * puts("NO");
}
if (factor[id].size() == 2) {
long long inv, a, p1 = factor[id][0], p2 = factor[id][1];
inv = powMM(p1, p2 - 2, p2);
a = n % p2 * inv % p2;
if (a * p1 <= n)
return 0 * puts("YES");
else
return 0 * puts("NO");
} else {
if (minvalue[id][n % factor[id][0]] <= n)
return 0 * puts("YES");
else
return 0 * puts("NO");
}
}
int main() {
int startTime = clock();
initfactor();
fprintf(stderr, "/--- initializeTime: %d milliseconds ---/\n",
clock() - startTime);
int T = 1;
scanf("%d", &T);
startTime = clock();
while (T--) TaskA();
fprintf(stderr, "/--- computeTime: %d milliseconds ---/\n",
clock() - startTime);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10003, M = 31622800, K = 1952000, L = 100003;
template <typename T>
inline void read(T &x) {
int ch = getchar();
x = 0;
bool f = false;
for (; ch < '0' || ch > '9'; ch = getchar()) f |= ch == '-';
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
if (a > b) return a = b, 1;
return 0;
}
int t, m, pri[K], cnt, tot, head[L], to[L << 2], nxt[L << 2];
bool ans[N];
struct Query {
int id;
long long n, k;
inline bool operator<(const Query &o) const {
return k < o.k || k == o.k && id < o.id;
}
} q[N];
bitset<M> notp;
long long p[N], dis[L], w[L << 2], x, y, d;
void init(int m) {
notp[0] = notp[1] = 1;
for (register int i = 2; i <= m; ++i) {
if (!notp[i]) pri[tot++] = i;
for (register int j = 0; j < tot && i * pri[j] <= m; ++j) {
notp[i * pri[j]] = true;
if (!(i % pri[j])) break;
}
}
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
d = a;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
void add(int a, int b, long long c) {
to[++cnt] = b;
nxt[cnt] = head[a];
head[a] = cnt;
w[cnt] = c;
}
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
int main() {
read(t);
init(M - 1);
for (register int i = 1; i <= t; ++i) {
read(q[i].n);
read(q[i].k);
q[i].id = i;
}
sort(q + 1, q + t + 1);
for (register int i = 1; i <= t; ++i) {
if (q[i].k == 1) continue;
if (q[i].k != q[i - 1].k) {
m = 0;
long long tmp = q[i].k;
for (register int j = 0; j < tot && (long long)pri[j] * pri[j] <= tmp;
++j)
if (!(tmp % pri[j])) {
p[m++] = pri[j];
tmp /= pri[j];
while (!(tmp % pri[j])) tmp /= pri[j];
}
if (tmp > 1) p[m++] = tmp;
if (m > 2) {
memset(head, 0, sizeof head);
cnt = 0;
for (register int i = 1; i < m; ++i)
for (register int j = 0; j < p[0]; ++j)
add(j, (j + p[i]) % p[0], p[i]);
memset(dis, 0x3f, sizeof dis);
dis[0] = 0;
pq.push(make_pair(0ll, 0));
while (!pq.empty()) {
pair<long long, long long> tmp = pq.top();
pq.pop();
if (tmp.first != dis[tmp.second]) continue;
int u = tmp.second;
for (register int i = head[u]; i; i = nxt[i])
if (chmin(dis[to[i]], dis[u] + w[i]))
pq.push(make_pair(dis[to[i]], to[i]));
}
} else if (m == 2) {
exgcd(p[0], p[1], x, y);
x = (x % p[1] + p[1]) % p[1];
}
}
if (m > 2)
ans[q[i].id] = dis[q[i].n % p[0]] <= q[i].n;
else if (m == 2) {
if (q[i].n % d) continue;
q[i].n /= d;
long long tmp = (q[i].n % p[1] * x % p[1] + p[1]) % p[1];
ans[q[i].id] = tmp * p[0] <= q[i].n;
} else
ans[q[i].id] = !(q[i].n % p[0]);
}
for (register int i = 1; i <= t; ++i) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXQ = 55;
const int MAXLOG = 64;
const int MAXN = 100005;
const int MAXP = 2e6 + 5;
const int MAXV = 3.2e7 + 5;
const long long INF = 4e18;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
int q;
long long memk[MAXQ];
int tot, prime[MAXP], f[MAXV];
int cnt[MAXQ];
long long p[MAXQ][MAXLOG];
long long dist[MAXQ][MAXN];
struct info {
long long dist;
int home;
};
bool operator<(info a, info b) { return a.dist > b.dist; }
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
long long q = a / b, r = a % b;
exgcd(b, r, y, x);
y -= q * x;
}
int main() {
for (int i = 2; i < MAXV; i++) {
if (f[i] == 0) prime[++tot] = f[i] = i;
for (int j = 1; j <= tot && prime[j] <= f[i]; j++) {
int tmp = prime[j] * i;
if (tmp >= MAXV) break;
f[tmp] = prime[j];
}
}
int T;
read(T);
while (T--) {
long long n, k;
read(n), read(k);
int pos = 0;
for (int i = 1; i <= q; i++)
if (memk[i] == k) pos = i;
if (pos == 0) {
pos = ++q;
memk[q] = k;
long long tmp = k;
for (int i = 1; 1ll * prime[i] * prime[i] <= tmp; i++)
if (tmp % prime[i] == 0) {
p[pos][++cnt[pos]] = prime[i];
while (tmp % prime[i] == 0) tmp /= prime[i];
}
if (tmp != 1) p[pos][++cnt[pos]] = tmp;
if (cnt[pos] >= 3) {
for (int i = 0; i < p[pos][1]; i++) dist[pos][i] = INF;
static priority_queue<info> Heap;
dist[pos][0] = 0;
Heap.push((info){0, 0});
static bool vis[MAXN];
memset(vis, false, sizeof(vis));
while (!Heap.empty()) {
while (!Heap.empty() && vis[Heap.top().home]) Heap.pop();
if (Heap.empty()) break;
info tmp = Heap.top();
Heap.pop();
for (int i = 2; i <= cnt[pos]; i++) {
int dest = (tmp.home + p[pos][i]) % p[pos][1];
if (dist[pos][dest] > tmp.dist + p[pos][i]) {
dist[pos][dest] = tmp.dist + p[pos][i];
Heap.push((info){dist[pos][dest], dest});
}
}
}
}
}
bool flg = false;
for (int i = 1; i <= cnt[pos]; i++)
if (n % p[pos][i] == 0) {
printf("YES\n");
flg = true;
break;
}
if (flg) continue;
if (cnt[pos] <= 1) {
printf("NO\n");
continue;
}
if (cnt[pos] == 2) {
long long x = 0, y = 0;
exgcd(p[pos][1], p[pos][2], x, y);
y = (y % p[pos][1] + p[pos][1]) % p[pos][1];
long long tmp = y * (n % p[pos][1]) % p[pos][1] * p[pos][2];
if (tmp <= n)
printf("YES\n");
else
printf("NO\n");
continue;
}
int tmp = n % p[pos][1];
if (dist[pos][tmp] <= n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, B = 32e6;
const long long inf = 1e17;
int p[N * 50], nump;
bool np[B + 5];
long long n, k, pr[105], cnt, d[N];
bool vis[N], ans[N];
struct data {
long long n, k;
int id;
} Q[N];
priority_queue<pair<long long, int> > q;
bool cmp(data a, data b) { return a.k < b.k; }
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long res = exgcd(b, a % b, y, x);
y -= a / b * x;
return res;
}
void solve() {
long long x = k;
cnt = 0;
for (int i = 1; 1ll * p[i] * p[i] <= x; ++i)
if (x % p[i] == 0) {
pr[++cnt] = p[i];
while (x % p[i] == 0) x /= p[i];
}
if (x > 1) pr[++cnt] = x;
if (cnt < 3) return;
for (int i = (0); i <= (pr[1]); ++i) d[i] = inf, vis[i] = 0;
d[0] = 0, q.push(make_pair(0, 0));
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = (2); i <= (cnt); ++i) {
int v = (x + pr[i]) % pr[1];
if (d[v] > d[x] + pr[i]) {
d[v] = d[x] + pr[i], q.push(make_pair(-d[v], v));
}
}
}
}
int main() {
int T;
scanf("%d", &T);
np[1] = 1;
for (int i = (2); i <= (B); ++i) {
if (!np[i]) p[++nump] = i;
for (int j = (1); j <= (nump); ++j) {
if (1ll * i * p[j] > B) break;
np[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
for (int i = (1); i <= (T); ++i)
scanf("%I64d%I64d", &Q[i].n, &Q[i].k), Q[i].id = i;
sort(Q + 1, Q + T + 1, cmp);
for (int i = (1); i <= (T); ++i) {
n = Q[i].n, k = Q[i].k;
if (i == 1 || k != Q[i - 1].k) solve();
if (!cnt)
ans[Q[i].id] = 0;
else if (cnt == 1)
ans[Q[i].id] = !(n % pr[1]);
else if (cnt == 2) {
long long a = pr[1], b = pr[2], x, y;
exgcd(a, b, x, y);
y = (y % a + a) % a, ans[Q[i].id] = (y * (n % a) % a * b <= n);
} else
ans[Q[i].id] = (d[n % pr[1]] <= n);
}
for (int i = (1); i <= (T); ++i) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e7 + 10;
bool isprime[N];
vector<int> prime;
const int M = 1e5 + 10;
int dis[55][M];
vector<int> factor[55];
bool vis[M];
vector<pair<int, long long> > edge[M];
map<long long, int> ma;
void init(int n) {
memset(isprime, true, sizeof(isprime));
isprime[1] = false;
for (int i = (2); i < (n + 1); i++) {
if (isprime[i]) prime.push_back(i);
for (int j = 0; j < (int)prime.size() && i * prime[j] <= n; j++) {
isprime[i * prime[j]] = false;
if (i % prime[j] == 0) break;
}
}
}
int cnt = 0;
void dij(int *dis) {
priority_queue<pair<int, long long>, vector<pair<int, long long> >,
greater<pair<int, long long> > >
q;
memset(vis, false, sizeof(false));
for (int i = (0); i < (M); i++) dis[i] = 1e9;
dis[0] = 0;
q.push(make_pair(0, 0));
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (vis[x]) continue;
for (auto i : edge[x]) {
if (dis[i.first] > dis[x] + i.second) {
dis[i.first] = dis[x] + i.second;
q.push(make_pair(dis[i.first], i.first));
}
}
}
}
int solve(long long x) {
if (ma.find(x) != ma.end()) {
return ma[x];
}
cnt++;
ma[x] = cnt;
for (auto i : prime) {
if ((long long)i * i > x) break;
if (x % i == 0) {
while (x % i == 0) {
x /= i;
}
factor[cnt].push_back(i);
}
}
if (x != 1) factor[cnt].push_back(x);
if ((int)factor[cnt].size() >= 3) {
int p = factor[cnt][0];
for (int i = (0); i < (p + 1); i++) edge[i].clear();
for (int i = (0); i < (p); i++) {
for (auto j : factor[cnt]) {
edge[i].push_back(make_pair((i + j) % p, j));
}
}
dij(dis[cnt]);
}
return cnt;
}
long long qpow(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = res * a % mod;
}
b >>= 1;
a = a * a % mod;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init(4e7);
int T;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
int id = solve(k);
if ((int)factor[id].size() == 0) {
cout << "NO"
<< "\n";
continue;
}
if ((int)factor[id].size() == 1) {
if (n % k == 0) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
continue;
} else if ((int)factor[id].size() == 2) {
int tmp = n % factor[id][1] *
qpow(factor[id][0], factor[id][1] - 2, factor[id][1]) %
factor[id][1];
if ((__int128)factor[id][0] * tmp <= n) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
continue;
} else {
int p = factor[id][0];
if (dis[id][n % p] <= n)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3.5e7 + 9, M = 1e5 + 9, kkk = 53;
const long long INF = 0x3f3f3f3f;
long long n, K, T, cnt, num[kkk];
long long prime[3000009], tot, p[kkk][109];
long long dis[kkk][M], been[kkk];
bool isprime[N], vis[M];
priority_queue<pair<long long, long long> > Q;
inline void sieve() {
for (long long i = 2; i < N; i++) {
if (!isprime[i]) prime[++tot] = i;
for (long long j = 1; j <= tot; j++) {
long long k = prime[j];
if (i * k >= N) break;
if (i * k < N) isprime[i * k] = true;
if (i % k == 0) break;
}
}
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, x, y);
long long z = x;
x = y, y = z - (a / b) * y;
}
signed main() {
sieve();
scanf("%lld", &T);
memset(dis, INF, sizeof dis);
while (T--) {
scanf("%lld%lld", &n, &K);
if (K == 1) {
puts("NO");
continue;
}
long long pos = 0;
for (long long i = 1; i <= cnt; i++)
if (been[i] == K) pos = i;
if (!pos) {
been[pos = ++cnt] = K;
for (long long i = 1; prime[i] * prime[i] <= K; i++)
if (K % prime[i] == 0) {
++num[pos];
p[pos][num[pos]] = prime[i];
while (K % prime[i] == 0) K /= prime[i];
}
if (K != 1) ++num[pos], p[pos][num[pos]] = K;
if (num[pos] <= 2) goto lab;
dis[pos][0] = 0;
Q.push(make_pair(0, 0));
memset(vis, 0, sizeof vis);
while (!Q.empty()) {
long long u = Q.top().second;
Q.pop();
if (vis[u]) continue;
vis[u] = true;
for (long long i = 2; i <= num[pos]; i++) {
long long v = (p[pos][i] + u) % p[pos][1];
if (dis[pos][v] > dis[pos][u] + p[pos][i]) {
dis[pos][v] = dis[pos][u] + p[pos][i];
Q.push(make_pair(-dis[pos][v], v));
}
}
}
}
lab:;
for (long long i = 1; i <= num[pos]; i++)
if (n % p[pos][i] == 0) {
puts("YES");
goto nxt;
}
if (num[pos] == 1) {
puts("NO");
goto nxt;
}
if (num[pos] == 2) {
long long x, y;
exgcd(p[pos][1], p[pos][2], x, y);
if (y < 0) y += p[pos][1];
y = y * (n % p[pos][1]) % p[pos][1] * p[pos][2];
puts(y <= n ? "YES" : "NO");
goto nxt;
}
puts(dis[pos][n % p[pos][1]] <= n ? "YES" : "NO");
nxt:;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int T, tot, p[3000010];
long long n, k, dist[maxn];
bool ok[35000000], ans[maxn];
map<long long, vector<pair<long long, int> > > mp;
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x), y -= a / b * x;
}
void solve(long long k, vector<pair<long long, int> > Q) {
vector<long long> a;
for (long long i = 1; i <= tot; i++) {
if (k % p[i] == 0) {
a.push_back(p[i]);
while (k % p[i] == 0) k /= p[i];
}
}
if (k > 1) a.push_back(k);
int n = a.size();
if (n == 0) return;
if (n == 1) {
for (auto q : Q) ans[q.second] = q.first % a[0] == 0;
return;
}
if (n == 2) {
long long x, y;
exgcd(a[0], a[1], x, y), y = (y % a[0] + a[0]) % a[0];
for (auto q : Q)
ans[q.second] = y * (q.first % a[0]) % a[0] * a[1] <= q.first;
return;
}
int m = a[0];
for (int i = 0; i < m; i++) dist[i] = 2e18;
dist[0] = 0;
set<pair<int, long long> > S;
for (int i = 0; i < m; i++) S.insert(make_pair(dist[i], i));
while (!S.empty()) {
int v = S.begin()->second;
S.erase(S.begin());
for (int i = 1; i < n; i++) {
int u = (v + a[i]) % m;
long long w = dist[v] + a[i];
if (dist[u] <= w) continue;
S.erase(make_pair(dist[u], u)), S.insert(make_pair(dist[u] = w, u));
}
}
for (auto q : Q) ans[q.second] = dist[q.first % m] <= q.first;
}
int main() {
for (int i = 2; i < 35000000; i++) {
if (ok[i]) continue;
p[++tot] = i;
for (int j = i + i; j < 35000000; j += i) ok[j] = 1;
}
scanf("%d", &T);
for (int i = 0; i < T; i++) {
scanf("%lld %lld", &n, &k), mp[k].push_back(make_pair(n, i));
}
for (auto it : mp) solve(it.first, it.second);
for (int i = 0; i < T; i++) printf("%s\n", ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 60;
const int MAXT = 1E4 + 10;
const int LIM = 1E5 + 10;
namespace Pollard_Rho {
const int pr[] = {2, 3, 5, 7, 11, 23, 43, 79};
const int M = (1 << 8) - 1;
mt19937 RandEngine(chrono::steady_clock::now().time_since_epoch().count());
long long RandInt(long long L, long long R) {
return uniform_int_distribution<long long>(L, R)(RandEngine);
}
vector<long long> Res;
long long Mx = 0;
long long gcd(long long a, long long b) {
if (!a || !b) return a | b;
int shift = __builtin_ctzll(a | b);
b >>= __builtin_ctzll(b);
while (a) {
a >>= __builtin_ctzll(a);
if (a < b) swap(a, b);
a -= b;
}
return b << shift;
}
unsigned long long Mul(unsigned long long a, unsigned long long b,
unsigned long long P) {
unsigned long long c =
(long long)a * b -
(long long)((unsigned long long)((long double)a * b / P)) * P;
return (c + P) % P;
}
long long ksm(long long a, long long b, long long P) {
long long ret = 1;
for (; b; b >>= 1, a = Mul(a, a, P))
if (b & 1) ret = Mul(ret, a, P);
return ret;
}
bool Miller_Rabin(long long n) {
if (n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 23 || n == 43 ||
n == 79)
return true;
if (~n & 1) return false;
for (int p : pr) {
long long t = n - 1, c = 0;
while (~t & 1) t >>= 1, ++c;
long long pw = ksm(p, t, n);
if (pw == 1) continue;
bool f = (pw == n - 1);
while (c) {
pw = Mul(pw, pw, n);
f |= (pw == n - 1);
--c;
if (pw == 1 && !f) return false;
}
if (pw != 1 || !f) return false;
}
return true;
}
long long Pollard_Rho(long long n) {
int c = RandInt(1, n - 1);
long long t = 1, x = 0, y = 0, q = 1;
auto F = [=](long long x) { return (Mul(x, x, n) + c) % n; };
for (int i = 2;; i <<= 1, y = x, q = 1) {
for (int j = 1; j <= i; j++) {
x = F(x);
q = Mul(q, abs(x - y), n);
if (!(j & M)) {
if ((t = gcd(q, n)) > 1) break;
}
}
if (t > 1 || ((t = gcd(q, n)) > 1)) break;
}
if (t == n) {
t = 1;
while (t == 1) x = F(x), t = gcd(abs(x - y), n);
}
return t;
}
void Factorize(long long n) {
if (Miller_Rabin(n)) return Res.push_back(n), void();
long long d = n;
while (d == n) d = Pollard_Rho(n);
Factorize(n / d);
Factorize(d);
}
vector<long long> solve(long long n) {
Res.clear();
Factorize(n);
return Res;
}
} // namespace Pollard_Rho
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, void();
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
int Ans[MAXT], tot;
long long dis[LIM];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
vector<long long> pr;
map<long long, int> M;
vector<pair<long long, int> > Q[MAXK];
void Dijkstra() {
memset(dis, 0x3f, sizeof dis);
dis[0] = 0;
pq.emplace(0, 0);
while (!pq.empty()) {
auto x = pq.top();
pq.pop();
if (x.first != dis[x.second]) continue;
for (long long p : pr) {
long long v = (p + x.second) % pr[0];
if (dis[v] <= x.first + p) continue;
dis[v] = x.first + p;
pq.emplace(dis[v], v);
}
}
}
int main() {
int T, tst = 0;
scanf("%d", &T);
for (long long n, k; T; T--) {
scanf("%lld%lld", &n, &k);
if (!M.count(k)) M[k] = ++tot;
int id = M[k];
Q[id].emplace_back(n, ++tst);
}
for (auto pK : M) {
int idx = pK.second;
long long K = pK.first;
if (K == 1) continue;
pr = Pollard_Rho::solve(K);
if (pr.size() == 1) {
for (auto q : Q[idx]) Ans[q.second] = q.first % K == 0;
} else if (pr.size() == 2) {
for (auto q : Q[idx]) {
long long x, y;
exgcd(pr[0], pr[1], x, y);
x = (x % pr[1] + pr[1]) % pr[1];
long long fx = Pollard_Rho::Mul(x, q.first, pr[1]), fy;
fy = (q.first - fx * pr[0]) / pr[1];
Ans[q.second] = fx >= 0 && fy >= 0;
}
} else {
sort(pr.begin(), pr.end());
Dijkstra();
for (auto q : Q[idx]) Ans[q.second] = dis[q.first % pr[0]] <= q.first;
}
}
for (int i = 1; i <= tst; i++) puts(Ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int T_MAX = 10005;
const int SIEVE_MAX = 32000000;
const int SMALL_MAX = 100005;
const long long LL_INF = 2e18;
struct video {
long long n, k;
int index;
bool operator<(const video &other) const {
return make_pair(k, n) < make_pair(other.k, other.n);
}
};
int T;
video videos[T_MAX];
vector<bool> is_prime(SIEVE_MAX, true);
vector<int> primes;
vector<bool> answers(T_MAX, false);
long long smallest_sum[SMALL_MAX];
void sieve() {
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i < SIEVE_MAX; i++) {
if (is_prime[i]) {
for (int j = i * i; j < SIEVE_MAX; j += i) {
is_prime[j] = false;
}
}
}
for (int i = 2; i < SIEVE_MAX; i++) {
if (is_prime[i]) primes.push_back(i);
}
}
int mod_pow(long long a, int p, int mod) {
long long result = 1;
while (p > 0) {
if (p & 1) result = result * a % mod;
a = a * a % mod;
p >>= 1;
}
return result;
}
int mod_inv(int a, int mod) { return mod_pow(a, mod - 2, mod); }
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
void check_and_add(int value, long long sum) {
if (sum < smallest_sum[value]) {
smallest_sum[value] = sum;
pq.push(make_pair(sum, value));
}
}
void dijkstra(vector<long long> k_primes) {
int small_prime = (int)k_primes[0];
assert(small_prime < SMALL_MAX);
for (int i = 0; i < small_prime; i++) {
smallest_sum[i] = LL_INF;
}
assert(pq.empty());
check_and_add(0, 0);
while (!pq.empty()) {
pair<long long, int> top = pq.top();
pq.pop();
int value = top.second;
long long sum = top.first;
for (long long p : k_primes) {
int next_value = (value + p) % small_prime;
long long next_sum = sum + p;
check_and_add(next_value, next_sum);
}
}
smallest_sum[0] = small_prime;
}
void solve(int start, int end) {
long long k = videos[start].k;
vector<long long> k_primes;
for (int p : primes) {
if (p > k) break;
if (k % p == 0) {
k_primes.push_back(p);
do {
k /= p;
} while (k % p == 0);
}
}
if (k > 1) {
k_primes.push_back(k);
}
sort(k_primes.begin(), k_primes.end());
for (int i = start; i < end; i++) {
long long n = videos[i].n;
bool answer;
if (k_primes.empty()) {
answer = false;
} else if (k_primes.size() == 1) {
answer = n % k_primes[0] == 0;
} else if (k_primes.size() == 2) {
long long a = k_primes[0], b = k_primes[1];
long long goal = n % a;
long long smallest = (goal * mod_inv(b, a) % a) * b;
answer = n >= smallest;
} else {
int small_prime = (int)k_primes[0];
if (i == start) {
dijkstra(k_primes);
}
answer = n >= smallest_sum[n % small_prime];
}
answers[videos[i].index] = answer;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
sieve();
cin >> T;
for (int i = 0; i < T; i++) {
cin >> videos[i].n >> videos[i].k;
videos[i].index = i;
}
sort(videos, videos + T);
for (int i = 0, j = 0; i < T; i = j) {
while (j < T && videos[j].k == videos[i].k) j++;
solve(i, j);
}
for (int i = 0; i < T; i++) {
cout << (answers[i] ? "YES" : "NO") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chkmin(T& x, T y) {
return x > y ? x = y, true : false;
}
template <class T>
inline bool chkmax(T& x, T y) {
return x < y ? x = y, true : false;
}
const long long MAXN = 1e18;
const long long MAXK = 1e15;
const long long INF = 4e18;
const int MAXV = 3.2e7 + 5;
const int MAXP = 2e6 + 10;
const int MAXF = 1e5 + 10;
const int MAXQ = 50;
const int MAXLOG = 64;
long long n, k, tot, q;
int f[MAXV], prime[MAXP], cnt[MAXQ + 1];
long long p[MAXQ + 1][MAXLOG], dist[MAXQ + 1][MAXF];
long long mem[MAXQ];
bool vis[MAXP];
template <typename T>
inline void read(T& x) {
long long f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline long long ppow(long long a, long long b, long long MO) {
long long ret = 1;
for (; b; b >>= 1) {
if (b & 1) ret = ret * a % MO;
a = a * a % MO;
}
return ret;
}
int main() {
int T;
read(T);
for (int i = (2); i <= (MAXV - 1); ++i) {
if (!f[i]) prime[++tot] = f[i] = i;
for (int j = (1); j <= (tot); ++j) {
int tmp = i * prime[j];
if (tmp >= MAXV) break;
f[tmp] = prime[j];
if (f[i] == prime[j]) break;
}
}
while (T--) {
read(n);
read(k);
if (k == 1) {
printf("NO\n");
continue;
}
int pos = 0;
for (int i = (1); i <= (q); ++i)
if (mem[i] == k) pos = i;
if (!pos) {
pos = ++q;
mem[pos] = k;
cnt[pos] = 0;
for (int i = 1; 1ll * prime[i] * prime[i] <= k; i++) {
if (k % prime[i] == 0) {
p[pos][++cnt[pos]] = prime[i];
while (k % prime[i] == 0) k /= prime[i];
}
}
if (k != 1) p[pos][++cnt[pos]] = k;
if (cnt[pos] >= 3) {
for (int i = 0; i < p[pos][1]; i++) {
dist[pos][i] = INF;
vis[i] = false;
}
dist[pos][0] = 0;
static priority_queue<pair<long long, int> > q;
q.push(make_pair(0, 0));
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = true;
for (int i = (2); i <= (cnt[pos]); ++i) {
int to = (u + p[pos][i]) % p[pos][1];
int w = p[pos][i];
if (dist[pos][u] + w < dist[pos][to]) {
dist[pos][to] = dist[pos][u] + w;
q.push(make_pair(-dist[pos][to], to));
}
}
}
}
}
if (cnt[pos] == 1) {
if (n % p[pos][1] == 0) {
puts("YES");
continue;
} else {
puts("NO");
continue;
}
}
if (cnt[pos] == 2) {
long long b =
n % p[pos][1] * ppow(p[pos][2], p[pos][1] - 2, p[pos][1]) % p[pos][1];
if (b * p[pos][2] <= n)
puts("YES");
else
puts("NO");
continue;
}
int val = n % p[pos][1];
if (n >= dist[pos][val])
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename TP>
inline void read(TP &ret) {
TP x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
ret = (TP)x * f;
}
int t;
struct node {
long long n, k;
int id;
bool operator<(const node &other) const { return k < other.k; }
} a[10010];
long long bas[5] = {2, 3, 7, 61, 24251};
long long gcd(long long x, long long y) {
if (!y) {
return x;
}
return gcd(y, x % y);
}
long long add(long long a, long long b, long long mod) {
return (a + b > mod) ? a + b - mod : a + b;
}
long long ksc(long long a, long long b, long long mod) {
long long sum = 0;
while (b) {
if (b & 1) {
sum = add(sum, a, mod);
b--;
}
a = add(a, a, mod);
b >>= 1;
}
return sum % mod;
}
long long ksm(long long a, long long b, long long mod) {
long long product = 1;
while (b) {
if (b & 1) {
product = ksc(product, a, mod);
b--;
}
a = ksc(a, a, mod);
b >>= 1;
}
return product % mod;
}
bool Miller_Rabin(long long x, long long b) {
if (ksm(b, x - 1, x) != 1) return 0;
long long k = x - 1;
while (!(k & 1)) {
k >>= 1;
long long d = ksm(b, k, x);
if (d != 1 && d != x - 1) return 0;
if (d == x - 1) return 1;
}
return 1;
}
bool Miller_Rabin(long long x) {
if (x < 2 || x == 46856248255981) return 0;
for (int i = 0; i < 5; i++) {
if (x == bas[i]) return 1;
}
for (int i = 0; i < 5; i++) {
if (!Miller_Rabin(x, bas[i])) return 0;
}
return 1;
}
long long Mandelbrot(long long x, long long c, long long p) {
return (ksc(x, x, p) + c) % p;
}
long long Pollard_Rho(long long x) {
long long s, t, c = 1ll * rand() % (x - 1) + 1;
s = t = 0;
long long val = 1;
int goal = 1;
for (;; goal <<= 1, s = t, val = 1) {
for (int i = 1; i <= goal; i++) {
t = Mandelbrot(t, c, x);
val = ksc(val, abs(t - s), x);
if (!(i % 127)) {
long long g = gcd(val, x);
if (g > 1) return g;
}
}
long long g = gcd(val, x);
if (g > 1) return g;
}
}
vector<long long> fac;
long long min_factor;
void divide(long long x) {
if (x < 2) {
return;
}
if (Miller_Rabin(x)) {
min_factor = min(min_factor, x);
fac.push_back(x);
return;
}
long long p = x;
while (p >= x) p = Pollard_Rho(x);
while (!(x % p)) {
x /= p;
}
divide(x);
divide(p);
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long d = exgcd(b, a % b, x, y);
long long res = x;
x = y;
y = res - a / b * y;
return d;
}
long long dis[200020];
bool vis[200020];
queue<int> q;
void spfa(long long mod) {
for (int i = 0; i < mod; i++) {
dis[i] = 1000000000000000000ll;
vis[i] = 0;
}
dis[0] = 0;
q.push(0);
vis[0] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = 1; i < fac.size(); i++) {
int v = (u + fac[i]) % mod;
if (dis[v] > dis[u] + fac[i]) {
dis[v] = dis[u] + fac[i];
if (!vis[v]) {
q.push(v);
vis[v] = 1;
}
}
}
}
}
bool ans[10010];
int main() {
srand(time(NULL));
read(t);
for (int i = 1; i <= t; i++) {
read(a[i].n), read(a[i].k);
a[i].id = i;
}
sort(a + 1, a + t + 1);
for (int i = 1; i <= t; i++) {
int now = i;
while (now < t && a[now + 1].k == a[i].k) now++;
if (a[i].k == 1) {
i = now;
continue;
}
fac.clear();
min_factor = 1000000000000000000ll;
divide(a[i].k);
sort(fac.begin(), fac.end());
if (fac.size() == 1) {
for (int j = i; j <= now; j++) {
if (!(a[j].n % fac[0])) ans[a[j].id] = 1;
}
i = now;
continue;
}
if (fac.size() == 2) {
long long x, y;
long long g = exgcd(fac[0], fac[1], x, y);
long long b = fac[1] / g;
x = add(x, b, b);
for (int j = i; j <= now; j++) {
if (!(a[j].n % g)) {
long long dx = x, dy = y;
dx = ksc(dx, a[j].n / g, b);
dy = (a[j].n - fac[0] * dx) / fac[1];
if (dy >= 0) ans[a[j].id] = 1;
}
}
i = now;
continue;
}
spfa(min_factor);
for (int j = i; j <= now; j++) {
if (dis[a[j].n % min_factor] <= a[j].n) ans[a[j].id] = 1;
}
i = now;
}
for (int i = 1; i <= t; i++) {
printf("%s\n", ans[i] ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2000000000000000000;
const int maxn = 10000 + 10;
struct dong {
long long n, k;
int id;
friend bool operator<(dong a, dong b) { return a.k < b.k; }
} ask[maxn];
long long f[100000 + 10], p[50];
int pri[5000000 + 10];
bool bz[32000000 + 10], pd[100000 + 10], ans[maxn];
int i, j, k, l, r, t, n, m, tot, top, ca;
void prepare() {
for (i = 2; i <= 32000000; i++) {
if (!bz[i]) pri[++top] = i;
for (j = 1; j <= top; j++) {
if ((long long)i * pri[j] > 32000000) break;
bz[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
long long qsc(long long x, long long y, long long mo) {
if (!y) return 0;
long long t = qsc(x, y / 2, mo);
t = (t + t) % mo;
if (y % 2) t = (t + x) % mo;
return t;
}
long long qsm(long long x, long long y, long long mo) {
if (!y) return 1;
long long t = qsm(x, y / 2, mo);
t = qsc(t, t, mo);
if (y % 2) t = qsc(t, x, mo);
return t;
}
void update(long long x, int w) {
int i, j, k;
for (i = 0; i <= w - 1; i++) pd[i] = 0;
for (i = 0; i <= w - 1; i++)
if (!pd[i]) {
k = i;
j = (i + x) % w;
while (j != i) {
if (f[j] < f[k]) k = j;
j = (j + x) % w;
}
j = k;
do {
pd[k] = 1;
f[(k + x) % w] = min(f[(k + x) % w], f[k] + x);
k = (k + x) % w;
} while (k != j);
}
}
void work(int l, int r, long long k) {
long long n, m = k;
tot = 0;
for (i = 1; i <= top; i++) {
if ((long long)pri[i] * pri[i] > m) break;
if (m % pri[i] == 0) {
p[++tot] = pri[i];
while (m % pri[i] == 0) m /= pri[i];
}
}
if (m > 1) p[++tot] = m;
if (tot == 0) {
for (i = l; i <= r; i++) {
n = ask[i].n;
if (n == 0) ans[ask[i].id] = 1;
}
} else if (tot == 1) {
for (i = l; i <= r; i++) {
n = ask[i].n;
if (n % k == 0) ans[ask[i].id] = 1;
}
} else if (tot == 2) {
long long a = p[1], b = p[2], c, d;
c = qsm(b, a - 2, a);
for (i = l; i <= r; i++) {
n = ask[i].n;
d = qsc(n, c, a);
(d += a) %= a;
if (d <= n / b) ans[ask[i].id] = 1;
}
} else {
long long w = p[1];
for (i = 1; i <= w - 1; i++) f[i] = inf;
f[0] = 0;
for (i = 2; i <= tot; i++) update(p[i], w);
for (i = l; i <= r; i++) {
n = ask[i].n;
if (f[n % w] <= n) ans[ask[i].id] = 1;
}
}
}
int main() {
prepare();
scanf("%d", &ca);
for (i = 1; i <= ca; i++) {
scanf("%I64d%I64d", &ask[i].n, &ask[i].k);
ask[i].id = i;
}
sort(ask + 1, ask + ca + 1);
l = 1;
r = 0;
while (l <= ca) {
r = l;
while (r < ca && ask[r + 1].k == ask[r].k) r++;
work(l, r, ask[l].k);
l = r + 1;
}
for (i = 1; i <= ca; i++)
if (ans[i])
printf("YES\n");
else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
bool np[33000000], inq[100010], b;
long long n, k, dis[55][100010], p[55][33000000 / 15 / 6];
int prime[33000000 / 15], num, cnt[55], now, total;
queue<int> q;
map<long long, int> mp;
inline int getint() {
char c = getchar();
int x;
bool p;
x = p = 0;
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') p = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (p) x = -x;
return x;
}
inline long long getll() {
char c = getchar();
long long x;
bool p;
x = p = 0;
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') p = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (p) x = -x;
return x;
}
void prepare() {
total = num = 0;
memset(np, 0, sizeof(np));
for (int i = 2; i < 33000000; ++i) {
if (!np[i]) prime[++num] = i;
for (int j = 1; j <= num; ++j) {
int tmp = i * prime[j];
if (tmp >= 33000000) break;
np[tmp] = 1;
if (!(i % prime[j])) break;
}
}
}
void init() {
n = getll(), k = getll();
b = 0;
if (mp.count(k))
now = mp[k], b = 1;
else
now = ++total, mp[k] = now;
if (b) return;
long long tmp = k;
cnt[now] = 0;
for (int i = 1; 1ll * prime[i] * prime[i] <= k; ++i)
if (!(tmp % prime[i])) {
p[now][++cnt[now]] = prime[i];
while (!(tmp % prime[i])) tmp /= prime[i];
}
if (tmp > 1) p[now][++cnt[now]] = tmp;
}
inline void spfa() {
memset(dis[now], 127, sizeof(dis[now]));
memset(inq, 0, sizeof(inq));
dis[now][0] = 0;
inq[0] = 1;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 2; i <= cnt[now]; ++i) {
int v = (u + p[now][i]) % p[now][1];
if (dis[now][v] > dis[now][u] + p[now][i]) {
dis[now][v] = dis[now][u] + p[now][i];
if (!inq[v]) inq[v] = 1, q.push(v);
}
}
inq[u] = 0;
}
}
inline void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, x, y);
long long tmp = x;
x = y, y = tmp - a / b * y;
}
void solve() {
if (!cnt[now]) {
printf("NO\n");
return;
}
if (cnt[now] == 1) {
if (!(n % p[now][1])) {
printf("YES\n");
return;
}
printf("NO\n");
return;
}
if (cnt[now] == 2) {
long long x, y;
exgcd(p[now][1], p[now][2], x, y);
y = (y % p[now][1] + p[now][1]) % p[now][1];
long long tmp = y * (n % p[now][1]) % p[now][1] * p[now][2];
if (tmp <= n)
printf("YES\n");
else
printf("NO\n");
return;
}
if (!b) spfa();
if (dis[now][n % p[now][1]] <= n)
printf("YES\n");
else
printf("NO\n");
}
int main() {
prepare();
int t = getint();
while (t--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int Maxn = 32000000;
const int Pim = 30000000;
const int N = 200050;
int e[Maxn + 55], prime[Pim], tot;
struct node {
long long n, k;
int num;
bool operator<(const node &i) const { return k < i.k; }
} qy[N];
void prework(void) {
for (int i = 2; i <= Maxn; i++) {
if (!e[i]) prime[++tot] = e[i] = i;
for (int j = 1; j <= tot; j++) {
int t = prime[j] * i;
if (t > Maxn) break;
e[t] = prime[j];
if (e[i] == prime[j]) break;
}
}
}
long long st[N], dis[N], tp;
int vis[N];
priority_queue<pair<long long, int> > q;
void work(long long k) {
tp = 0;
for (int i = 1, t; (long long)prime[i] * prime[i] <= k; i++) {
if (k % (t = prime[i])) continue;
st[++tp] = t;
while (k % t == 0) k /= t;
}
if (k != 1) st[++tp] = k;
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
if (tp == 2) swap(st[1], st[2]);
if (tp >= 3) {
dis[0] = 0, q.push(make_pair(0, 0));
while (q.size()) {
int x = q.top().second;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = 2; i <= tp; i++) {
int y = (x + st[i]) % st[1];
long long t = (x + st[i]) / st[1];
if (dis[y] > dis[x] + t)
dis[y] = dis[x] + t, q.push(make_pair(-dis[y], y));
}
}
}
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, void();
exgcd(b, a % b, x, y);
long long t = x;
x = y, y = t - a / b * y;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
bool solve(long long n) {
if (!tp) return 0;
if (tp == 1) return n % st[1] == 0;
if (tp == 2) {
long long t1 = st[1], t2 = st[2], x, y;
exgcd(t1, t2, x, y);
x = (x % t2 + t2) % t2;
long long tt = n % t2;
x = x * tt % t2;
return n >= x * t1;
}
return n >= dis[n % st[1]] * st[1] + (n % st[1]);
}
int ans[N], T;
int main() {
read(T), prework();
for (int i = 1; i <= T; i++) read(qy[i].n), read(qy[i].k), qy[i].num = i;
sort(qy + 1, qy + T + 1);
for (int l = 1, r; l <= T; l = r + 1) {
work(qy[l].k), r = l;
while (qy[r + 1].k == qy[l].k) r++;
for (int i = l; i <= r; i++) ans[qy[i].num] = solve(qy[i].n);
}
for (int i = 1; i <= T; i++) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int maxt = 10010;
const int maxn = 100010;
int T;
long long q_n[maxt], q_k[maxt];
int p_list[10000010], isnp[40000010], tot;
vector<long long> vec;
map<long long, int> k_id;
long long mul(long long a, long long b, long long mod) {
long long ret = 0;
for (int i = 0; i < 63; i++) {
if ((a >> i) & 1) ret = (ret + b) % mod;
b = b * 2 % mod;
}
return ret;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long qpow(long long x, long long y, long long mod) {
long long ret = 1;
while (y) {
if (y & 1) ret = 1LL * ret * x % mod;
x = 1LL * x * x % mod;
y >>= 1;
}
return ret;
}
void _find(long long n, vector<long long> &vec) {
for (int i = 1; i <= tot; i++) {
while (n % p_list[i] == 0) {
vec.push_back(p_list[i]);
n /= p_list[i];
}
}
if (n > 1) vec.push_back(n);
}
struct ShortestPath {
long long k, minp;
int ps;
stack<long long> st;
vector<long long> prm;
long long dis[maxn];
void init() {
minp = 2e18;
if (k > 1) _find(k, prm);
for (int i = 0; i < prm.size(); i++) minp = min(minp, prm[i]);
ps = int(prm.size());
sort(prm.begin(), prm.end());
prm.erase(unique(prm.begin(), prm.end()), prm.end());
if (ps >= 3) {
for (int i = 0; i < minp; i++) {
dis[i] = 2e18;
}
dis[0] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push(pair<long long, int>(dis[0], 0));
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
for (int i = 0; i < prm.size(); i++) {
long long p = prm[i];
int v = (u + p) % minp;
if (dis[u] + p < dis[v]) {
dis[v] = dis[u] + p;
pq.push(pair<long long, int>(dis[v], v));
}
}
}
}
}
int query(long long n) {
if (ps == 0) {
return 0;
} else if (ps == 1) {
return (n % prm[0] == 0);
} else if (ps == 2) {
long long p1 = prm[0], p2 = prm[1];
if (p1 == p2) return (n % p1 == 0);
if (p1 == minp) swap(p1, p2);
long long r = n % p1;
long long t = qpow(p2, p1 - 2, p1);
long long k = mul(r, t, p1);
return k * p2 <= n;
} else {
return (dis[n % minp] <= n);
}
}
} shortestPath[55];
int main() {
for (int i = 2; i <= 40000000; i++) {
if (!isnp[i]) {
p_list[++tot] = i;
}
for (int j = 1; j <= tot && p_list[j] * i <= 40000000; j++) {
isnp[p_list[j] * i] = 1;
if (i % p_list[j] == 0) break;
}
}
cin >> T;
for (int i = 1; i <= T; i++) {
cin >> q_n[i] >> q_k[i];
vec.push_back(q_k[i]);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
for (int i = 0; i < vec.size(); i++) {
k_id[vec[i]] = i;
shortestPath[i].k = vec[i];
shortestPath[i].init();
}
for (int i = 1; i <= T; i++) {
int id = k_id[q_k[i]];
if (shortestPath[id].query(q_n[i]))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, maxm = 33333333, m = 32000000, mod = 998244353;
inline long long read() {
char ch = getchar();
long long x = 0, f = 0;
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
struct ques {
long long n, k;
int id;
bool operator<(const ques &q) const { return k < q.k; }
} q[maxn];
long long tmp[22], f[maxn];
int T, pr[maxm / 10], pl, tl;
bool vis[maxm], ans[maxn];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
void init() {
for (int i = (2); i <= (m); i++) {
if (!vis[i]) pr[++pl] = i;
for (int j = (1); j <= (pl); j++) {
int k = i * pr[j];
if (k > m) break;
vis[k] = true;
}
}
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, a;
long long d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
int main() {
init();
T = read();
for (int i = (1); i <= (T); i++) {
long long n = read(), k = read();
q[i] = (ques){n, k, i};
}
sort(q + 1, q + T + 1);
for (int i = (1); i <= (T); i++) {
long long k = q[i].k, ttt = k;
tl = 0;
for (int j = (1); j <= (pl); j++)
if (ttt % pr[j] == 0) {
tmp[++tl] = pr[j];
while (ttt % pr[j] == 0) ttt /= pr[j];
}
if (ttt > 1) tmp[++tl] = ttt;
if (tl >= 3) {
assert(tmp[1] <= 1e5);
for (int i = (0); i <= (tmp[1] - 1); i++) f[i] = 2e18;
f[0] = 0;
while (!pq.empty()) pq.pop();
pq.push(make_pair(f[0], 0));
while (!pq.empty()) {
int u = pq.top().second;
long long d = pq.top().first;
pq.pop();
if (f[u] != d) continue;
for (int i = (2); i <= (tl); i++) {
int v = (u + tmp[i]) % tmp[1];
if (d + tmp[i] < f[v]) pq.push(make_pair(f[v] = d + tmp[i], v));
}
}
}
for (int j = (i); j <= (T); j++) {
if (q[j].k != k) {
i = j - 1;
break;
}
long long n = q[j].n;
if (!tl)
ans[q[j].id] = false;
else if (tl == 1)
ans[q[j].id] = n % tmp[1] == 0;
else if (tl == 2) {
long long a = tmp[1], b = tmp[2], x, y;
exgcd(a, b, x, y);
y = (y + a) % a;
y = n % a * y % a;
ans[q[j].id] = b * y <= n;
} else
ans[q[j].id] = f[n % tmp[1]] <= n;
if (j == T) i = T;
}
}
for (int i = (1); i <= (T); i++) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using std::map;
using std::priority_queue;
const int KV2 = 56, S = 32000000;
map<long long, int> mi;
int mar;
long long pr[2333333], pi;
bool vis[S + 1];
void sieve() {
for (long long i = 2; i <= S; i++) {
if (!vis[i]) pr[++pi] = i;
for (int j = 1; j <= pi && pr[j] * i <= S; j++) {
vis[pr[j] * i] = 1;
if (i % pr[j] == 0) break;
}
}
}
struct sumireko {
int to, ne;
long long w;
} e[4000069];
int he[100069], ecnt;
void addline(int f, long long lt, long long w) {
int t = lt;
e[++ecnt].to = t;
e[ecnt].ne = he[f];
e[ecnt].w = w;
he[f] = ecnt;
}
struct shion {
int x;
long long d;
shion() {}
shion(int x, long long d) : x(x), d(d) {}
bool operator<(const shion &b) const { return d > b.d; }
} g;
long long dis[KV2][100069];
priority_queue<shion> q;
bool vv[100069];
void dijkstra(int ki) {
memset(dis[ki], 0x7f, sizeof(dis[ki]));
dis[ki][0] = 0;
q.push(shion(0, 0));
while (!q.empty()) {
g = q.top(), q.pop();
int px = g.x;
long long pd = g.d;
if (vv[px]) continue;
vv[px] = 1;
for (int i = he[px], t = e[i].to; i; i = e[i].ne, t = e[i].to) {
if (pd + e[i].w < dis[ki][t]) {
dis[ki][t] = pd + e[i].w;
q.push(shion(t, dis[ki][t]));
}
}
}
}
long long pl[KV2][68], pc[KV2];
void div(long long k, int ki) {
int ti = 0;
for (int i = 1; i <= pi && pr[i] * pr[i] <= k; i++) {
if (k % pr[i] == 0) pl[ki][++ti] = pr[i];
while (k % pr[i] == 0) k /= pr[i];
}
if (k != 1ll) pl[ki][++ti] = k;
if (ti >= 3) {
long long p1 = pl[ki][1];
memset(he, 0, sizeof(he)), ecnt = 0;
memset(vv, 0, sizeof(vv));
for (int x = 0; x < p1; x++)
for (int j = 1; j <= ti; j++) addline(x, (pl[ki][j] + x) % p1, pl[ki][j]);
dijkstra(ki);
}
pc[ki] = ti;
}
long long fpow(long long a, long long p, long long mo) {
a %= mo;
long long ret = 1;
while (p) {
if (p & 1ll) ret = ret * a % mo;
a = a * a % mo;
p >>= 1;
}
return ret;
}
long long n, k;
int T;
int main() {
sieve();
scanf("%d", &T);
while (T--) {
scanf("%I64d%I64d", &n, &k);
if (k == 1) {
puts("NO");
continue;
}
if (mi.find(k) == mi.end()) {
mi[k] = ++mar;
div(k, mar);
}
int ki = mi[k];
switch (pc[ki]) {
case 1: {
puts(n % pl[ki][1] ? "NO" : "YES");
break;
}
case 2: {
long long p1 = pl[ki][1], p2 = pl[ki][2];
puts(fpow(p2, p1 - 2, p1) * (n % p1) % p1 * p2 <= n ? "YES" : "NO");
break;
}
default: {
n < pl[ki][1]
? (puts("NO"))
: (dis[ki][n % pl[ki][1]] <= n ? puts("YES") : puts("NO"));
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
vector<int> smallestPrimeFactor;
void linearSieve(int n) {
if (n < 1) n = 1;
if ((int)smallestPrimeFactor.size() >= n + 1) return;
int primePiBound = n < 20 ? n - 1 : (int)(n / (log(n * 1.) - 2) + 2);
primes.assign(primePiBound + 1, numeric_limits<int>::max());
int P = 0;
smallestPrimeFactor.assign(n + 1, 0);
smallestPrimeFactor[1] = 1;
int n2 = n / 2, n3 = n / 3, n5 = n / 5;
if (n >= 2) primes[P++] = 2;
if (n >= 3) primes[P++] = 3;
for (int q = 2; q <= n; q += 2) smallestPrimeFactor[q] = 2;
for (int q = 3; q <= n; q += 6) smallestPrimeFactor[q] = 3;
for (int q = 5; q <= n5; q += 2) {
if (smallestPrimeFactor[q] == 0) primes[P++] = smallestPrimeFactor[q] = q;
int bound = smallestPrimeFactor[q];
for (int i = 2;; ++i) {
int p = primes[i];
if (p > bound) break;
int pq = p * q;
if (pq > n) break;
smallestPrimeFactor[pq] = p;
}
}
for (int q = (n5 + 1) | 1; q <= n; q += 2) {
if (smallestPrimeFactor[q] == 0) primes[P++] = smallestPrimeFactor[q] = q;
}
primes.resize(P);
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
void primeFactors(long long x, vector<pair<long long, int>> &out_v) {
out_v.clear();
int sqrtx = (int)sqrt((double)x);
while ((long long)sqrtx * sqrtx < x) ++sqrtx;
for (vector<int>::const_iterator p = primes.begin(); p != primes.end(); ++p) {
if (*p > sqrtx) break;
if (x % *p == 0) {
int t = 1;
x /= *p;
while (x % *p == 0) {
t++;
x /= *p;
}
out_v.push_back(make_pair(*p, t));
}
}
if (x != 1) out_v.push_back(make_pair(x, 1));
}
template <typename T, typename U>
inline auto floordiv(T x, U y) -> decltype(x / y) {
auto q = x / y, r = x % y;
return q - ((r != 0) & ((r < 0) ^ (y < 0)));
}
long long linearFloorDivMin(long long xL, long long xU, long long m,
long long a, long long b, long long c, long long d,
long long e) {
assert(m != 0);
if (xL > xU) return numeric_limits<long long>::max();
if (m < 0) {
m = -m, a = -a, b = -b;
}
if (xL != 0) {
b += a * xL, e += d * xL, xU -= xL, xL = 0;
}
if (a < 0 || a >= m) {
auto q = floordiv(a, m);
a -= m * q, d += c * q;
}
if (b < 0 || b >= m) {
auto q = floordiv(b, m);
b -= m * q, e += c * q;
}
if (a == 0) {
return min(0LL, d * xU) + e;
}
auto u = floordiv(a * xU + b, m);
auto fb = d >= 0 ? -b + a - 1 : m - b - 1;
if (d >= 0) {
auto p = linearFloorDivMin(1, u, a, m, fb, d, c, e);
auto q = e;
return min(p, q);
} else {
auto p = linearFloorDivMin(0, u - 1, a, m, fb, d, c, e);
auto q = c * u + d * xU + e;
return min(p, q);
}
}
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
int main() {
int T;
scanf("%d", &T);
long long maxK = 0;
map<long long, vector<pair<long long, int>>> cases;
for (int ii = 0; ii < T; ++ii) {
long long n;
long long k;
scanf("%lld%lld", &n, &k);
cases[k].emplace_back(n, ii);
amax(maxK, k);
}
linearSieve((int)sqrt((double)maxK) + 2);
vector<int> ans(T, -1);
for (const auto &kc : cases) {
auto K = kc.first;
vector<pair<long long, int>> fs;
primeFactors(K, fs);
if (fs.empty()) {
for (auto t : kc.second) ans[t.second] = 0;
} else if (fs.size() == 1) {
auto p = fs[0].first;
for (auto t : kc.second) ans[t.second] = t.first % p == 0 ? 1 : 0;
} else if (fs.size() == 2) {
int p = (int)fs[0].first;
auto q = fs[1].first;
for (auto t : kc.second) {
auto n = t.first;
auto minMod = linearFloorDivMin(0, n / q, p, -q, n, -p, -q, n);
ans[t.second] = minMod == 0 ? 1 : 0;
}
} else {
const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
int p = (int)fs[0].first;
for (auto f : fs) assert(p <= f.first);
vector<long long> minN(p, INFL);
priority_queue<pair<long long, int>> pq;
vector<bool> vis(p);
int qt = 0;
minN[0] = 0;
pq.push(make_pair(-0LL, 0));
while (!pq.empty()) {
int i = pq.top().second;
pq.pop();
if (vis[i]) continue;
vis[i] = true;
auto x = minN[i];
for (auto f : fs)
if (f.first != p) {
auto y = x + f.first;
int j = y % p;
if (y < minN[j]) {
minN[j] = y;
pq.push(make_pair(-y, j));
}
}
}
for (auto t : kc.second)
ans[t.second] = minN[t.first % p] <= t.first ? 1 : 0;
}
}
for (int x : ans) puts(x != 0 ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e18;
const long long MAXK = 1e15;
const long long INF = 4e18;
const int MAXV = 3.2e7 + 5;
const int MAXP = 2e6 + 10;
const int MAXF = 1e5 + 10;
const int MAXQ = 50;
const int MAXLOG = 64;
long long n, k, tot, q;
int f[MAXV], prime[MAXP], cnt[MAXQ + 1];
long long p[MAXQ + 1][MAXLOG], dist[MAXQ + 1][MAXF];
long long mem[MAXQ];
bool visited[MAXP];
template <typename T>
inline void read(T &x) {
long long f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline long long exp_mod(long long a, long long n, long long p) {
long long res = 1, b = a;
while (n > 0) {
if (n & 1) res = res * b % p;
b = b * b % p;
n >>= 1;
}
return res;
}
int main() {
int T;
read(T);
for (int i = 2; i < MAXV; i++) {
if (!f[i]) prime[++tot] = f[i] = i;
for (int j = 1; j <= tot; j++) {
int tmp = i * prime[j];
if (tmp >= MAXV) break;
f[tmp] = prime[j];
if (f[i] == prime[j]) break;
}
}
while (T--) {
read(n);
read(k);
if (k == 1) {
printf("NO\n");
continue;
}
int pos = 0;
for (int i = 1; i <= q; i++)
if (mem[i] == k) pos = i;
if (!pos) {
pos = ++q;
mem[pos] = k;
cnt[pos] = 0;
for (int i = 1; 1ll * prime[i] * prime[i] <= k; i++) {
if (k % prime[i] == 0) {
p[pos][++cnt[pos]] = prime[i];
while (k % prime[i] == 0) k /= prime[i];
}
}
if (k != 1) p[pos][++cnt[pos]] = k;
if (cnt[pos] >= 3) {
for (int i = 0; i < p[pos][1]; i++) {
dist[pos][i] = INF;
visited[i] = false;
}
dist[pos][0] = 0;
static priority_queue<pair<long long, int> > q;
q.push(make_pair(0, 0));
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (visited[u]) continue;
visited[u] = true;
for (int i = 2; i <= cnt[pos]; i++) {
int to = (u + p[pos][i]) % p[pos][1];
int w = p[pos][i];
if (dist[pos][u] + w < dist[pos][to]) {
dist[pos][to] = dist[pos][u] + w;
q.push(make_pair(-dist[pos][to], to));
}
}
}
}
}
if (cnt[pos] == 1) {
if (n % p[pos][1] == 0) {
printf("YES\n");
continue;
} else {
printf("NO\n");
continue;
}
}
if (cnt[pos] == 2) {
long long b = n % p[pos][1] *
exp_mod(p[pos][2], p[pos][1] - 2, p[pos][1]) % p[pos][1];
if (b * p[pos][2] <= n)
printf("YES\n");
else
printf("NO\n");
continue;
}
int val = n % p[pos][1];
if (n >= dist[pos][val])
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
namespace Factor {
const int N = 1010000;
long long C, fac[10010], n, mut, a[1001000];
int T, cnt, i, l, prime[N], p[N], psize, _cnt;
long long _e[100], _pr[100];
vector<long long> d;
inline long long mul(long long a, long long b, long long p) {
if (p <= 1000000000)
return a * b % p;
else if (p <= 1000000000000ll)
return (((a * (b >> 20) % p) << 20) + (a * (b & ((1 << 20) - 1)))) % p;
else {
long long d = (long long)floor(a * (long double)b / p + 0.5);
long long ret = (a * b - d * p) % p;
if (ret < 0) ret += p;
return ret;
}
}
void prime_table() {
int i, j, tot, t1;
for (i = 1; i <= psize; i++) p[i] = i;
for (i = 2, tot = 0; i <= psize; i++) {
if (p[i] == i) prime[++tot] = i;
for (j = 1; j <= tot && (t1 = prime[j] * i) <= psize; j++) {
p[t1] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
void init(int ps) {
psize = ps;
prime_table();
}
long long powl(long long a, long long n, long long p) {
long long ans = 1;
for (; n; n >>= 1) {
if (n & 1) ans = mul(ans, a, p);
a = mul(a, a, p);
}
return ans;
}
bool witness(long long a, long long n) {
int t = 0;
long long u = n - 1;
for (; ~u & 1; u >>= 1) t++;
long long x = powl(a, u, n), _x = 0;
for (; t; t--) {
_x = mul(x, x, n);
if (_x == 1 && x != 1 && x != n - 1) return 1;
x = _x;
}
return _x != 1;
}
bool miller(long long n) {
if (n < 2) return 0;
if (n <= psize) return p[n] == n;
if (~n & 1) return 0;
for (int j = 0; j <= 7; j++)
if (witness(rand() % (n - 1) + 1, n)) return 0;
return 1;
}
long long gcd(long long a, long long b) {
long long ret = 1;
while (a != 0) {
if ((~a & 1) && (~b & 1))
ret <<= 1, a >>= 1, b >>= 1;
else if (~a & 1)
a >>= 1;
else if (~b & 1)
b >>= 1;
else {
if (a < b) swap(a, b);
a -= b;
}
}
return ret * b;
}
long long rho(long long n) {
for (;;) {
long long X = rand() % n, Y, Z, T = 1, *lY = a, *lX = lY;
int tmp = 20;
C = rand() % 10 + 3;
X = mul(X, X, n) + C;
*(lY++) = X;
lX++;
Y = mul(X, X, n) + C;
*(lY++) = Y;
for (; X != Y;) {
long long t = X - Y + n;
Z = mul(T, t, n);
if (Z == 0) return gcd(T, n);
tmp--;
if (tmp == 0) {
tmp = 20;
Z = gcd(Z, n);
if (Z != 1 && Z != n) return Z;
}
T = Z;
Y = *(lY++) = mul(Y, Y, n) + C;
Y = *(lY++) = mul(Y, Y, n) + C;
X = *(lX++);
}
}
}
void _factor(long long n) {
for (int i = 0; i < cnt; i++) {
if (n % fac[i] == 0) n /= fac[i], fac[cnt++] = fac[i];
}
if (n <= psize) {
for (; n != 1; n /= p[n]) fac[cnt++] = p[n];
return;
}
if (miller(n))
fac[cnt++] = n;
else {
long long x = rho(n);
_factor(x);
_factor(n / x);
}
}
void dfs(long long x, int dep) {
if (dep == _cnt)
d.push_back(x);
else {
dfs(x, dep + 1);
for (int i = 1; i <= _e[dep]; i++) dfs(x *= _pr[dep], dep + 1);
}
}
void norm() {
sort(fac, fac + cnt);
_cnt = 0;
for (int i = 0; i < cnt; i++)
if (i == 0 || fac[i] != fac[i - 1])
_pr[_cnt] = fac[i], _e[_cnt++] = 1;
else
_e[_cnt - 1]++;
}
vector<long long> getd() {
d.clear();
dfs(1, 0);
return d;
}
vector<long long> factor(long long n) {
cnt = 0;
_factor(n);
norm();
return getd();
}
vector<pair<long long, long long>> factorG(long long n) {
cnt = 0;
_factor(n);
norm();
vector<pair<long long, long long>> d;
for (int i = 0; i < _cnt; i++) d.push_back(make_pair(_pr[i], _e[i]));
return d;
}
bool is_primitive(long long a, long long p) {
assert(miller(p));
vector<pair<long long, long long>> D = factorG(p - 1);
for (int i = 0; i < ((int)(D).size()); i++)
if (powl(a, (p - 1) / D[i].first, p) == 1) return 0;
return 1;
}
} // namespace Factor
int T, ret[101000];
long long n, k;
map<long long, vector<pair<long long, int>>> q;
long long dis[101000];
long long mul(long long x, long long y, long long m) {
x %= m;
y %= m;
assert(x >= 0 && y >= 0);
long long d = ((long double)x * y / m);
d = x * y - d * m;
if (d >= m) d -= m;
if (d < 0) d += m;
return d;
}
long long Inv(long long q, long long m) {
if (q == 0) return 0;
assert(q >= 0);
long long a1 = m, b1 = 0, a2 = q, b2 = 1, a3, b3, t;
while (a2 != 1) {
t = a1 / a2, a3 = a1 - t * a2, b3 = b1 - mul(t, b2, m), a1 = a2, a2 = a3,
b1 = b2, b2 = b3;
if (b2 < 0) b2 += m;
}
return b2;
}
int main() {
Factor::init(1000000);
scanf("%d", &T);
for (int i = 0; i < T; i++) {
scanf("%lld%lld", &n, &k);
q[k].push_back(make_pair(n, i));
}
for (auto p : q) {
k = p.first;
auto que = p.second;
auto d = Factor::factorG(k);
sort((d).begin(), (d).end());
if (((int)(d).size()) == 0) continue;
if (((int)(d).size()) == 1) {
for (auto z : que) {
if (z.first % k == 0) ret[z.second] = 1;
}
continue;
}
if (((int)(d).size()) == 2) {
long long p1 = d[0].first, p2 = d[1].first;
long long w = Inv(p1, p2);
for (auto z : que) {
long long w2 = mul(w, z.first, p2);
if (z.first / p1 >= w2) ret[z.second] = 1;
}
continue;
}
long long base = d[0].first;
for (int i = 0; i < base; i++) dis[i] = 1ll << 60;
dis[0] = 0;
for (int i = 1; i < ((int)(d).size()); i++) {
long long p = d[i].first % base;
int pre = 0;
for (int j = 0; j < 2 * base + 10; j++) {
int cur = pre + p;
if (cur >= base) cur -= base;
if (dis[cur] > dis[pre] + d[i].first) dis[cur] = dis[pre] + d[i].first;
pre = cur;
}
}
for (auto z : que) {
n = z.first;
if (dis[n % base] <= n) ret[z.second] = 1;
}
}
for (int i = 0; i < T; i++) puts(ret[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXP = 4e7;
bitset<MXP> prime;
vector<long long> primes;
void sieve() {
for (int p = 2; p < MXP; p++) {
if (prime[p]) continue;
primes.push_back(p);
for (int q = p; q < MXP; q += p) prime.set(q);
}
}
map<long long, vector<pair<long long, int>>> qry;
bool ans[10005];
vector<pair<long long, long long>> adj[100005];
long long dis[100005];
long long euclid(long long a, long long b, long long &x, long long &y) {
if (b) {
long long d = euclid(b, a % b, y, x);
return y -= a / b * x, d;
}
return x = 1, y = 0, a;
}
void solve(long long k, vector<pair<long long, int>> &qs) {
if (k == 1) {
for (auto q : qs) ans[q.second] = false;
return;
}
vector<long long> pf;
for (auto p : primes) {
if (p * p > k) break;
if (k % p) continue;
pf.push_back(p);
while (k % p == 0) k /= p;
}
if (k > 1) pf.push_back(k);
sort(pf.begin(), pf.end());
if (pf.size() == 1) {
for (auto q : qs) ans[q.second] = (q.first % pf[0] == 0);
return;
}
if (pf.size() == 2) {
long long x, y;
long long p = pf[0], q = pf[1];
euclid(q, p, x, y);
x = (x % p + p) % p;
for (auto qry : qs) {
long long n = qry.first;
long long d = n % p;
long long fi = ((n % p) * x) % p;
ans[qry.second] = (q * fi <= n);
}
return;
}
for (int i = 0; i < pf[0]; i++) {
adj[i].clear();
for (int j = 1; j < pf.size(); j++) {
long long p = pf[j];
adj[i].push_back({(i + p) % pf[0], p});
}
}
fill(dis, dis + pf[0], LLONG_MAX);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
dis[0] = 0;
q.push({0, 0});
while (!q.empty()) {
long long d = q.top().first, u = q.top().second;
q.pop();
if (d > dis[u]) continue;
for (auto e : adj[u]) {
long long v = e.first, w = e.second;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
q.push({dis[v], v});
}
}
}
for (auto q : qs) ans[q.second] = (dis[q.first % pf[0]] <= q.first);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
sieve();
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long n, k;
cin >> n >> k;
qry[k].push_back({n, i});
}
for (auto p : qry) solve(p.first, p.second);
for (int i = 0; i < t; i++) cout << (ans[i] ? "YES\n" : "NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long x, long long y) {
return (x % y == 0) ? y : gcd(y, x % y);
}
long long mul(long long x, long long y, long long MOD) {
long long ans = 0;
while (y) {
if (y & 1) ans = (ans + x) % MOD;
x = (x + x) % MOD;
y >>= 1;
}
return ans;
}
long long pow_mod(long long x, long long k, long long MOD) {
long long ans = 1;
while (k) {
if (k & 1) ans = mul(ans, x, MOD);
x = mul(x, x, MOD);
k >>= 1;
}
return ans;
}
long long fact[15];
int cnt;
namespace Math {
const int prime[15] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};
bool is_prime(long long c, long long n) {
long long d = n - 1;
while (!(d & 1)) d >>= 1;
long long t = pow_mod(c, d, n);
while (d != n - 1 && t != 1 && t != n - 1) {
t = mul(t, t, n);
d <<= 1;
}
return (t == n - 1) || (d & 1);
}
bool miller_rabin(long long n) {
for (int i = 0; i < 15; i++) {
if (n == prime[i]) return 1;
if (n % prime[i] == 0) return 0;
}
for (int i = 0; i < 10; i++) {
long long c = rand() % (n - 2) + 2;
if (!is_prime(c, n)) return 0;
}
return 1;
}
void pollard_rho(long long n) {
if (miller_rabin(n)) {
fact[++cnt] = n;
return;
}
for (;;) {
long long a, b, c;
a = b = rand() % n;
c = rand() % n;
b = (mul(b, b, n) + c) % n;
while (a != b) {
long long t = gcd(abs(a - b), n);
if (t != 1 && t != n) {
pollard_rho(t);
pollard_rho(n / t);
return;
}
a = (mul(a, a, n) + c) % n;
b = (mul(b, b, n) + c) % n;
b = (mul(b, b, n) + c) % n;
}
}
}
} // namespace Math
namespace Solve1 {
bool solve(long long n) {
long long a = fact[1], b = fact[2];
long long nev = mul(pow_mod(b % a, a - 2, a), n % a, a);
return (b * nev <= n);
}
} // namespace Solve1
namespace Solve2 {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
long long dis[100005];
void dijkstra() {
memset(dis, 0x3f, sizeof(dis));
while (!q.empty()) q.pop();
int p = fact[1];
dis[0] = 0;
q.push(pair<long long, int>(0, 0));
while (!q.empty()) {
pair<long long, int> t = q.top();
q.pop();
if (dis[t.second] < t.first) continue;
int a = t.second;
long long b = t.first;
for (int i = 2; i <= cnt; i++)
if (b + fact[i] < dis[(a + fact[i]) % p]) {
int u = (a + fact[i]) % p;
dis[u] = b + fact[i];
q.push(pair<long long, int>(dis[u], u));
}
}
}
bool solve(long long n) { return dis[n % fact[1]] <= n; }
} // namespace Solve2
bool ans[10005];
map<long long, int> mp;
vector<pair<long long, int> > vt[55];
long long num[10005];
int main() {
int cases;
scanf("%d", &cases);
int tot = 0;
for (int i = 1; i <= cases; i++) {
long long n = 0, k = 0;
scanf("%lld%lld", &n, &k);
if (k == 1) continue;
if (!mp.count(k)) {
mp[k] = ++tot;
num[tot] = k;
}
vt[mp[k]].push_back(pair<long long, int>(n, i));
}
for (int i = 1; i <= tot; i++) {
cnt = 0;
Math::pollard_rho(num[i]);
sort(fact + 1, fact + cnt + 1);
cnt = unique(fact + 1, fact + cnt + 1) - fact - 1;
if (cnt == 1) {
long long a = fact[1];
for (int j = 0; j < vt[i].size(); j++)
ans[vt[i][j].second] = (vt[i][j].first % a == 0);
} else if (cnt == 2) {
for (int j = 0; j < vt[i].size(); j++)
ans[vt[i][j].second] = Solve1::solve(vt[i][j].first);
} else {
Solve2::dijkstra();
for (int j = 0; j < vt[i].size(); j++)
ans[vt[i][j].second] = Solve2::solve(vt[i][j].first);
}
}
for (int i = 1; i <= cases; i++) puts((ans[i]) ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
const int MX = 33333333;
using namespace std;
int n, cnt, p[2100000], pc, v[51];
bitset<MX> Prime;
map<long long, int> Map;
vector<long long> d[51];
int R[51][101000];
long long Pow(long long a, long long b, long long Mod) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % Mod;
a = a * a % Mod;
b >>= 1;
}
return r;
}
bool OK(long long a, long long b, long long n) {
long long inv = Pow(b, a - 2, a);
long long t = (n % a) * inv % a;
if (n >= b * t) return true;
return false;
}
priority_queue<pair<int, int> > PQ;
void Dijk(int *a, vector<long long> &D) {
int Mod = D[0];
int i;
for (i = 0; i < Mod; i++) a[i] = 1e9;
a[0] = 0;
PQ.push({0, 0});
while (!PQ.empty()) {
auto tp = PQ.top();
PQ.pop();
if (a[tp.second] != -tp.first) continue;
int x = tp.second;
for (auto &t : D) {
int aa = (x + t) % Mod;
long long dd = (x + t) / Mod;
if (a[aa] > a[x] + dd) {
a[aa] = a[x] + dd;
PQ.push({-a[aa], aa});
}
}
}
}
bool Pos(long long n, vector<long long> &D, int num) {
if (D.empty()) return false;
if (D.size() == 1) {
if (n % D[0] == 0) return true;
return false;
}
if (OK(D[0], D[1], n)) return true;
if (D.size() == 2) return false;
if (!v[num]) {
v[num] = 1;
Dijk(R[num], D);
}
if (R[num][n % D[0]] <= n / D[0]) return true;
return false;
}
int main() {
long long m, n;
int i, j;
for (i = 2; i < MX; i++) {
if (Prime[i] == 1) continue;
p[pc++] = i;
for (j = i + i; j < MX; j += i) Prime[j] = 1;
}
int TC;
scanf("%d", &TC);
while (TC--) {
scanf("%lld%lld", &m, &n);
if (!Map.count(n)) {
Map[n] = ++cnt;
long long t = n;
for (i = 0; (long long)p[i] * p[i] <= t; i++) {
if (t % p[i] == 0) {
while (t % p[i] == 0) t /= p[i];
d[cnt].push_back(p[i]);
}
}
if (t != 1) d[cnt].push_back(t);
}
if (Pos(m, d[Map[n]], Map[n]))
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
#pragma GCC target("popcnt")
using namespace std;
struct que {
int id;
long long n, k;
bool operator<(const que &rhs) const { return k < rhs.k; }
} qs[10010];
struct cmp {
bool operator()(const pair<int, long long> &A,
const pair<int, long long> &B) {
return A.second == B.second ? A.first > B.first : A.second > B.second;
}
};
int q;
long long dis[100010];
bool np[34000010], ans[10010];
vector<int> pr, divs;
vector<pair<int, long long> > nxt[100010];
priority_queue<pair<int, long long>, vector<pair<int, long long> >, cmp> Q;
template <class T>
void read(T &x) {
char ch = x = 0;
bool fl = false;
while (!isdigit(ch)) fl |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x = fl ? -x : x;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (a == 1 && !b) return x = 1, y = 0, void();
exgcd(b, a % b, y, x), y -= a / b * x;
}
bool check(long long n, long long a, long long b) {
if (a < b) swap(a, b);
long long x, y;
exgcd(a, b, x, y);
x = (x % b + b) * (n % b) % b;
y = (n - a * x) / b;
return y >= 0;
}
void solve(long long k) {
divs.clear();
for (int i = 0; 1LL * pr[i] * pr[i] <= k; i++) {
if (k % pr[i]) continue;
divs.push_back(pr[i]);
while (k % pr[i] == 0) {
k /= pr[i];
}
}
if (k > 1) divs.push_back(k);
if (divs.size() <= 2) return;
for (int i = 0; i < divs[0]; i++) {
nxt[i].clear();
}
for (int i = 1; i < divs.size(); i++) {
int tmp = divs[i];
for (int j = 0; j < divs[0]; j++) {
nxt[j].push_back({(j + tmp) % divs[0], tmp});
}
}
memset(dis, 0x3f, sizeof(dis));
Q.push({0, dis[0] = 0});
while (!Q.empty()) {
pair<int, long long> x = Q.top();
Q.pop();
if (dis[x.first] != x.second) continue;
for (auto &v : nxt[x.first]) {
if (dis[v.first] <= dis[x.first] + v.second) continue;
Q.push({v.first, dis[v.first] = dis[x.first] + v.second});
}
}
}
void sieve() {
for (int i = 2; i < 34000010; i++) {
if (!np[i]) pr.push_back(i);
for (int j = 0; j < pr.size(); j++) {
if (1LL * i * pr[j] >= 34000010) break;
np[i * pr[j]] = true;
if (i % pr[j] == 0) break;
}
}
}
int main() {
read(q), sieve();
for (int i = 1; i <= q; i++) {
read(qs[i].n), read(qs[i].k), qs[i].id = i;
}
sort(qs + 1, qs + q + 1);
for (int i = 1; i <= q; i++) {
if (qs[i].k != qs[i - 1].k) solve(qs[i].k);
if (divs.empty()) ans[qs[i].id] = false;
if (divs.size() == 1) ans[qs[i].id] = qs[i].n % qs[i].k == 0;
if (divs.size() == 2) ans[qs[i].id] = check(qs[i].n, divs[0], divs[1]);
if (divs.size() > 2) ans[qs[i].id] = dis[qs[i].n % divs[0]] <= qs[i].n;
}
for (int i = 1; i <= q; i++) {
puts(ans[i] ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2000005, M = 55, S = 31624000;
int t;
long long n, k;
int pri[N], cnt;
bool vis[S + 10];
void euler(void) {
vis[1] = 1;
for (int i = 2; i < S; ++i) {
if (!vis[i]) pri[++cnt] = i;
for (int j = 1; j <= cnt && i * pri[j] < S; ++j) {
vis[i * pri[j]] = 1;
if (!i % pri[j]) break;
}
}
return;
}
std::map<long long, int> mp;
int tt, siz[M];
long long son[M][20], dis[M][100005];
std::priority_queue<std::pair<long long, int>,
std::vector<std::pair<long long, int> >,
std::greater<std::pair<long long, int> > >
que;
void build(int k) {
int mx = son[k][1];
memset(dis[k], 0x3f, sizeof(dis[k]));
dis[k][0] = 0;
que.push(std::make_pair(0ll, 0));
while (!que.empty()) {
std::pair<long long, int> tmp = que.top();
que.pop();
int x = tmp.second;
long long d = tmp.first;
if (d != dis[k][x]) continue;
for (int i = 2; i <= siz[k]; ++i) {
int y = (x + son[k][i]) % mx;
long long w = son[k][i];
if (d + w < dis[k][y]) {
dis[k][y] = d + w;
que.push(std::make_pair(dis[k][y], y));
}
}
}
return;
}
void dec(long long k) {
mp[k] = ++tt;
for (int i = 1; 1ll * pri[i] * pri[i] <= k; ++i)
if (k % pri[i] == 0) {
son[tt][++siz[tt]] = pri[i];
while (k % pri[i] == 0) k /= pri[i];
}
if (k != 1) son[tt][++siz[tt]] = k;
std::sort(son[tt] + 1, son[tt] + 1 + siz[tt]);
if (siz[tt] > 2) build(tt);
return;
}
long long qpow(long long x, long long y, long long m) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % m;
y >>= 1, x = x * x % m;
}
return res % m;
}
int main(void) {
euler();
scanf("%d", &t);
while (t--) {
scanf("%lld%lld", &n, &k);
if (!mp.count(k)) dec(k);
int tk = mp[k];
if (siz[tk] == 0)
printf("NO\n");
else if (siz[tk] == 1)
printf("%s\n", n % son[tk][1] ? "NO" : "YES");
else if (siz[tk] == 2) {
long long a = son[tk][1], b = son[tk][2];
long long my = qpow(b, a - 2, a) * (n % a) % a;
printf("%s\n", my * b <= n ? "YES" : "NO");
} else
printf("%s\n",
dis[tk][n % son[tk][1]] <= n && n >= son[tk][1] ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 3e5 + 5;
int T, p[2000000], cnt, m, edgenum, Head[N], Next[M], vet[M];
bool isnp[32000001], vis[N], ans[N];
long long n, k, K[55], d[20], val[M], dis[N], X, Y;
vector<pair<long long, int> > vec[55];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
que;
inline void add(int u, int v, long long w) {
Next[++edgenum] = Head[u];
Head[u] = edgenum;
vet[edgenum] = v;
val[edgenum] = w;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x), y -= a / b * x;
}
int main() {
for (int i = 2; i <= 32000000; i++) {
if (!isnp[i]) p[++cnt] = i;
for (int j = 1; j <= cnt && i * p[j] <= 32000000; j++) {
isnp[i * p[j]] = 1;
if (!(i % p[j])) break;
}
}
cin >> T;
for (int i = 1; i <= T; i++) {
scanf("%lld%lld", &n, &k);
int id;
for (id = 1; id <= m; id++)
if (K[id] == k) break;
if (id > m) K[++m] = k;
vec[id].push_back(pair<long long, int>(n, i));
}
for (int i = 1; i <= m; i++) {
long long _ = K[i];
int dcnt = 0;
for (int j = 1; 1ll * p[j] * p[j] <= K[i]; j++)
if (!(_ % p[j])) {
d[++dcnt] = p[j];
while (!(_ % p[j])) _ /= p[j];
}
if (_ > 1) d[++dcnt] = _;
if (!dcnt)
continue;
else if (dcnt == 1)
for (auto q : vec[i]) ans[q.second] = !(q.first % d[1]);
else if (dcnt == 2) {
exgcd(d[1], d[2], X, Y);
for (auto q : vec[i])
ans[q.second] =
((__int128)X * q.first % d[2] + d[2]) % d[2] * d[1] +
((__int128)Y * q.first % d[1] + d[1]) % d[1] * d[2] <=
q.first;
} else {
edgenum = 0;
for (int i = 0; i < d[1]; i++)
Head[i] = vis[i] = 0, dis[i] = (long long)1e18 + 1;
for (int i = 2; i <= dcnt; i++)
for (int j = 0; j < d[1]; j++) add(j, (j + d[i]) % d[1], d[i]);
dis[0] = 0, que.push(pair<long long, int>(0, 0));
while (!que.empty()) {
int u = que.top().second;
que.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int e = Head[u]; e; e = Next[e]) {
int v = vet[e];
long long w = val[e];
if (dis[v] > dis[u] + w)
dis[v] = dis[u] + w, que.push(pair<long long, int>(dis[v], v));
}
}
for (auto q : vec[i]) ans[q.second] = q.first >= dis[q.first % d[1]];
}
}
for (int i = 1; i <= T; i++) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T &t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T &t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "Yes" : "No");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
const int N = 32000000;
bitset<N + 5> bs;
vector<int> ps;
vector<long long> pks;
bool Ans[100005];
long long extend_gcd(long long a, long long b, long long &x, long long &y,
long long d) {
if (b == 0) {
x = d / a;
y = 0;
return a;
} else {
long long r = extend_gcd(b, a % b, y, x, d);
y -= x * (a / b);
return r;
}
}
void init() {
ps.push_back(2);
for (int i = 3; i <= N; i += 2)
if (!bs[i]) {
ps.push_back(i);
for (int j = i + i; j <= N; j += i) {
bs[j] = 1;
}
}
}
long long p1, p2, G, pg1, pg2;
long long dis[100005];
bool used[100005];
void dij() {
for (int(i) = 0; (i) < (int)(p1); (i)++) {
dis[i] = (1LL << 60);
used[i] = 0;
}
dis[0] = 0;
priority_queue<pair<long long, int>, std::vector<pair<long long, int>>,
std::greater<pair<long long, int>>>
q;
q.push({0, 0});
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (used[x]) continue;
used[x] = 1;
for (auto p : pks) {
long long d = p;
int y = (x + p) % p1;
if (dis[x] + d < dis[y]) {
dis[y] = dis[x] + d;
q.push({dis[y], y});
}
}
}
}
void reinitK(long long k) {
pks.clear();
long long tk = k;
for (int P : ps) {
if ((long long)P * P > tk) break;
if (tk % P == 0) {
pks.push_back(P);
while (tk % P == 0) tk /= P;
}
}
if (tk != 1) pks.push_back(tk);
if (pks.size() == 2) {
p1 = pks[0];
p2 = pks[1];
G = gcd1(p1, p2);
pg1 = p1 / G;
pg2 = p2 / G;
} else if (pks.size() > 2) {
p1 = pks[0];
dij();
}
}
long long qn[100005], qk[100005];
void fmain(int ID) {
init();
scanf("%d", &n);
long long pk = -1;
vector<pair<long long, int>> vp;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%lld%lld", qn + i, qk + i);
vp.push_back({qk[i], i});
}
sort(vp.begin(), vp.end());
for (int(i) = 0; (i) < (int)(n); (i)++) {
int id = vp[i].second;
if (qk[id] != pk) {
reinitK(qk[id]);
pk = qk[id];
}
if (qk[id] == 1)
Ans[id] = 0;
else if (pks.size() == 1)
Ans[id] = qn[id] % pks[0] == 0;
else if (pks.size() == 2) {
if (qn[id] % G != 0) {
Ans[id] = 0;
continue;
}
long long x, y;
extend_gcd(p1, p2, x, y, G);
x %= pg2;
if (x < 0) x += pg2;
Ans[id] = ((qn[id] % p2) * x % p2) * p1 <= qn[id];
} else {
Ans[id] = dis[qn[id] % p1] <= qn[id];
}
}
for (int(i) = 1; (i) <= (int)(n); (i)++) puts(Ans[i] ? "YES" : "NO");
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 102000;
const long long inf = 3e18;
int prime[4000000], len;
long long dis[N];
map<long long, int> Map;
int num;
long long rec[75][N];
bool isprime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
void getp(int n) {
static int small[10000];
static bool vis[10000];
int sz = 0, S = sqrt(n) + 0.5;
for (register int i = (2); i <= (S); i++)
if (isprime(i)) small[++sz] = i, prime[++len] = i;
for (int l = S + 1; l <= n; l += S) {
memset(vis, 0, sizeof(vis));
int r = min(n, l + S - 1);
for (register int i = (1); i <= (sz); i++)
for (register int j = r / small[i] * small[i]; j >= l; j -= small[i])
vis[j - l] = 1;
for (register int i = (0); i <= (S - 1); i++)
if (!vis[i]) prime[++len] = l + i;
}
}
inline vector<long long> getfac(long long n) {
static map<long long, vector<long long> > Map;
long long rec = n;
if (Map.count(n)) return Map[n];
vector<long long> res;
for (register int i = 1; i <= len && 1LL * prime[i] * prime[i] <= n; i++)
if (n % prime[i] == 0) {
res.push_back(prime[i]);
while (n % prime[i] == 0) n /= prime[i];
}
if (n > 1) res.push_back(n);
return Map[rec] = res;
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
inline void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
inline long long mul(long long a, long long b, long long mo) {
long long res = 0;
while (b) {
if (b & 1) res = (res + a) % mo;
a = (a + a) % mo;
b >>= 1;
}
return res;
}
inline bool ckeq(long long c, long long a, long long b) {
long long g = gcd(a, b);
if (c % g) return 0;
a /= g;
b /= g;
c /= g;
long long x, y;
exgcd(a, b, x, y);
x = mul(x, c, b);
x = (x + b) % b;
return c - a * x >= 0;
}
int main() {
getp(35000000);
int T;
read(T);
while (T--) {
long long nn, k;
scanf("%lld%lld", &nn, &k);
vector<long long> s = getfac(k);
if (k == 1)
puts("NO");
else if (((int)s.size()) == 1)
printf("%s\n", nn % s[0] == 0 ? "YES" : "NO");
else if (((int)s.size()) == 2)
printf("%s\n", ckeq(nn, s[0], s[1]) ? "YES" : "NO");
else {
if (!Map.count(k)) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
heap;
int n = s[0];
for (register int i = (0); i <= (n - 1); i++) dis[i] = inf;
dis[0] = 0;
heap.push(pair<long long, int>(dis[0], 0));
while (!heap.empty()) {
int u = heap.top().second;
if (heap.top().first != dis[u]) {
heap.pop();
continue;
}
heap.pop();
for (register int i = (1); i <= (((int)s.size()) - 1); i++) {
int v = (u + s[i]) % n;
long long d = dis[u] + s[i];
if (d < dis[v]) {
dis[v] = d;
heap.push(pair<long long, int>(d, v));
}
}
}
Map[k] = ++num;
for (register int i = (0); i <= (s[0] - 1); i++) rec[num][i] = dis[i];
}
assert(num <= 50);
printf("%s\n", rec[Map[k]][nn % s[0]] <= nn ? "YES" : "NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 3.3e7;
int prm[M], tot;
void init(int n) {
for (int i = 2; i <= n; i++) {
if (!prm[i]) prm[++tot] = i;
for (int j = 1; j <= tot && i * prm[j] <= n; ++j) {
prm[i * prm[j]] = true;
if (i % prm[j] == 0) break;
}
}
}
struct Query {
long long n, k;
int id;
bool operator<(const Query& A) const { return k < A.k; }
} Q[N];
bool ans[N];
int m;
long long fac[N];
void exgcd(long long a, long long b, long long& x, long long& y) {
if (!b)
assert(a == 1), x = 1, y = 0;
else {
exgcd(b, a % b, y, x);
y -= a / b * x;
}
}
void work(long long a, long long b, int l, int r) {
long long x, y;
exgcd(a, b, x, y);
y = (y % a + a) % a;
for (int i = l; i <= r; i++) {
long long val = (y * (Q[i].n % a)) % a * b;
ans[Q[i].id] = val <= Q[i].n;
}
}
bool vis[N];
long long dis[N];
struct Node {
int o;
long long d;
bool operator<(const Node& B) const { return d > B.d; }
};
void Dijkstra() {
int n = fac[1];
for (int i = 0; i <= n; i++) dis[i] = 1ll << 60, vis[i] = 0;
dis[0] = 0;
priority_queue<Node> q;
q.push((Node){0, 0});
while (!q.empty()) {
int o = q.top().o;
q.pop();
if (vis[o]) continue;
vis[o] = true;
for (int i = 2; i <= m; i++) {
long long d = dis[o] + (o + fac[i]) / n;
int u = (o + fac[i]) % n;
if (dis[u] > d) dis[u] = d, q.push((Node){u, d});
}
}
}
int main() {
init(M - 5);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++)
scanf("%I64d%I64d", &Q[i].n, &Q[i].k), Q[i].id = i;
sort(Q + 1, Q + q + 1);
for (int i = 1; i <= q; i++) {
long long x = Q[i].k;
int r = i;
while (r < q && Q[r + 1].k == x) ++r;
m = 0;
for (int j = 1; j <= tot; j++)
if (x % prm[j] == 0) {
fac[++m] = prm[j];
while (x % prm[j] == 0) x /= prm[j];
}
if (x > 1) fac[++m] = x;
if (m == 0)
for (int j = i; j <= r; j++) ans[Q[j].id] = false;
else if (m == 1)
for (int j = i; j <= r; j++) ans[Q[j].id] = Q[j].n % fac[1] == 0;
else if (m == 2)
work(fac[1], fac[2], i, r);
else {
Dijkstra();
for (int j = i; j <= r; j++)
ans[Q[j].id] = dis[Q[j].n % fac[1]] <= Q[j].n / fac[1];
}
i = r;
}
for (int i = 1; i <= q; i++) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXP = 31622800, INF = 1ll << 62;
long long t, n, k, dist[100 * 1000 + 10];
vector<long long> p, pk;
bool b[MXP], ans[10 * 1000 + 10];
vector<pair<long long, long long>> sv;
void primes() {
for (long long i = 2; i < MXP; i++)
if (!b[i]) {
p.push_back(i);
for (long long j = i * i; j < MXP; j += i) b[j] = true;
}
}
long long Pow(long long a, long long b, long long MOD) {
return (b ? ((b & 1 ? a : 1) * (Pow((a * a) % MOD, b >> 1, MOD)) % MOD) % MOD
: 1);
}
void dijkstra() {
set<pair<long long, int>> q;
fill(dist, dist + pk[0], INF);
q.insert({dist[0] = 0, 0});
while (!q.empty()) {
auto u = *q.begin();
q.erase(q.begin());
for (long long v : pk)
if (u.first + v < dist[(u.second + v) % pk[0]])
q.erase({dist[(u.second + v) % pk[0]], (u.second + v) % pk[0]}),
q.insert({dist[(u.second + v) % pk[0]] = u.first + v,
(u.second + v) % pk[0]});
}
}
void solve() {
long long _k = k, pksz;
pk.clear();
for (int i = 0; p[i] * p[i] <= _k; i++)
if (!(_k % p[i])) {
pk.push_back(p[i]);
while (!(_k % p[i])) _k /= p[i];
}
if (_k > 1) pk.push_back(_k);
pksz = pk.size();
if (!pksz) return;
if (pksz == 1) {
for (int i = 0; i < t; i++)
if (sv[i].second == k) ans[i] = !(sv[i].first % k);
return;
}
if (pksz == 2) {
long long inv = Pow(pk[1], pk[0] - 2, pk[0]);
for (int i = 0; i < t; i++)
if (sv[i].second == k)
ans[i] =
((sv[i].first / pk[1]) >= (inv * (sv[i].first % pk[0])) % pk[0]);
return;
}
dijkstra();
for (int i = 0; i < t; i++)
if (sv[i].second == k) ans[i] = (sv[i].first >= dist[sv[i].first % pk[0]]);
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
set<long long> st;
primes();
cin >> t;
for (int i = 0; i < t; i++) cin >> n >> k, sv.push_back({n, k}), st.insert(k);
for (long long x : st) k = x, solve();
for (int i = 0; i < t; i++) cout << (ans[i] ? "YES\n" : "NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<long long int, long long int>, int> queries[10000];
bitset<32000000> bs;
vector<int> primes;
long long int dist[100000];
priority_queue<pair<long long int, int> > H;
int ans[10000];
int main() {
int i;
int t;
long long int n, k;
scanf("%d", &t);
for (i = 0; i < t; i++)
scanf("%I64d %I64d", &n, &k), queries[i] = make_pair(make_pair(k, n), i);
sort(queries, queries + t);
int j;
bs.set();
bs[0] = bs[1] = 0;
for (i = 2; i < 32000000; i++) {
if (bs[i]) {
if (i < 6000) {
for (j = i * i; j < 32000000; j += i) bs[j] = 0;
}
primes.push_back(i);
}
}
vector<long long int> f;
for (i = 0; i < t; i++) {
k = queries[i].first.first, n = queries[i].first.second;
if ((i == 0) || (k != queries[i - 1].first.first)) {
int e = sqrt(k) + 1e-6;
f.clear();
for (j = 0; primes[j] <= e; j++) {
if ((k % primes[j]) == 0) {
f.push_back(primes[j]);
while ((k % primes[j]) == 0) k /= primes[j];
}
}
if (k > 1) f.push_back(k);
if (f.size() > 2) {
fill(dist, dist + f[0], -1);
dist[0] = 0;
H.push(make_pair(0, 0));
while (!H.empty()) {
int u = H.top().second;
int d = -H.top().first;
H.pop();
if (d > dist[u]) continue;
for (j = 1; j < f.size(); j++) {
int v = (u + f[j]) % f[0];
if ((dist[v] == -1) || (dist[u] + f[j] < dist[v])) {
dist[v] = dist[u] + f[j];
H.push(make_pair(-dist[v], v));
}
}
}
}
}
if (f.size() == 0)
ans[queries[i].second] = 0;
else if (f.size() == 1)
ans[queries[i].second] = ((n % f[0]) == 0);
else if (f.size() == 2) {
int e = f[1] - 2;
long long int b = f[0], r = n % f[1];
while (e > 0) {
if (e & 1) r *= b, r %= f[1];
e >>= 1;
b *= b, b %= f[1];
}
ans[queries[i].second] = (n >= r * f[0]);
} else
ans[queries[i].second] = (dist[n % f[0]] != -1) && (dist[n % f[0]] <= n);
}
for (i = 0; i < t; i++) printf(ans[i] ? "YES\n" : "NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void in(T &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f |= (c == '-'), c = getchar();
while (isdigit(c)) x = x * 10 + (c ^ '0'), c = getchar();
f ? x = -x : 0;
}
template <class T>
inline void out(T x, const char c = '\n') {
static short st[30];
short m = 0;
if (x < 0) putchar('-'), x = -x;
do st[++m] = x % 10, x /= 10;
while (x);
while (m) putchar(st[m--] | '0');
putchar(c);
}
template <class T>
inline void err(const T &x, const char c = '\n') {
cerr << x << c;
}
template <class T, class... Args>
inline void in(T &x, Args &...args) {
in(x);
in(args...);
}
template <class T, class... Args>
inline void out(const T &x, const Args &...args) {
out(x, ' ');
out(args...);
}
template <class T, class... Args>
inline void err(const T &x, const Args &...args) {
err(x, ' ');
err(args...);
}
template <class T>
inline void prt(T a[], int n) {
for (register int i = 0; i < n; ++i) out(a[i], i == n - 1 ? '\n' : ' ');
}
template <class T>
inline void clr(T a[], int n) {
memset(a, 0, sizeof(T) * n);
}
template <class T>
inline void clr(T *a, T *b) {
memset(a, 0, sizeof(T) * (b - a));
}
template <class T>
inline bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline bool ckmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
namespace i207M {
bitset<31622777> notp;
int pri[2000000], cntp;
void sieve(int n) {
notp[1] = 1;
for (register int i = 2; i <= n; ++i) {
if (!notp[i]) pri[++cntp] = i;
for (register int j = 1, t; j <= cntp && (t = pri[j] * i) <= n; ++j) {
notp[t] = 1;
if (i % pri[j] == 0) break;
}
}
}
bool ans[10005];
vector<long long> d;
void divi(long long x) {
d.clear();
for (register int i = 1; i <= cntp && (long long)pri[i] * pri[i] <= x; ++i)
if (x % pri[i] == 0) {
d.push_back(pri[i]);
while (x % pri[i] == 0) x /= pri[i];
}
if (x > 1) d.push_back(x);
}
inline long long qmul(const long long &a, const long long &b,
const long long &md) {
long long c = a * b - (long long)((long double)a * b / md + 0.5) * md;
return c < 0 ? c + md : c;
}
inline long long qpow(long long a, long long b, const long long &md) {
long long r = 1;
for (; b; b >>= 1, a = qmul(a, a, md))
if (b & 1) r = qmul(r, a, md);
return r;
}
void solve(long long K, const vector<pair<long long, int> > &Q) {
if (K == 1) return;
divi(K);
if (((int)d.size()) == 1) {
long long t = d[0];
for (const auto &it : Q) ans[it.second] = (it.first % t == 0);
return;
}
if (((int)d.size()) == 2) {
long long a = d[0], b = d[1];
for (const auto &it : Q) {
long long n = it.first;
if (n % a == 0 || n % b == 0) {
ans[it.second] = 1;
continue;
}
long long y = qmul(n % a, qpow(b, a - 2, a), a);
ans[it.second] = (b * y <= n && (n - b * y) % a == 0);
}
return;
}
static long long dis[100005];
static bool ins[100005];
static queue<int> q;
memset(dis, 0x3f, sizeof(dis));
q.push(0), dis[0] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
ins[x] = 0;
for (register int i = 1; i < ((int)d.size()); ++i) {
int v = (x + d[i]) % d[0];
if (ckmin(dis[v], dis[x] + d[i]) && !ins[v]) q.push(v), ins[v] = 1;
}
}
for (const auto &it : Q) ans[it.second] = (dis[it.first % d[0]] <= it.first);
}
map<long long, vector<pair<long long, int> > > rem;
signed main() {
int T;
long long a, b;
in(T);
sieve(31622776);
for (register int i = 1; i <= T; ++i) {
in(a, b);
rem[b].push_back(make_pair(a, i));
}
for (const auto &it : rem) solve(it.first, it.second);
for (register int i = 1; i <= T; ++i) puts(ans[i] ? "YES" : "NO");
return 0;
}
} // namespace i207M
signed main() {
i207M::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
namespace Math {
const int N = 31622800;
const int MX = 1952000;
bool notPrime[N];
int prime[MX], primeCnt = 0;
inline void sieve() {
notPrime[1] = true;
for (int i = 2; i < N; ++i) {
if (!notPrime[i]) {
prime[++primeCnt] = i;
}
for (int j = 1, p; j <= primeCnt; ++j) {
p = prime[j];
if (i * p >= N) {
break;
}
notPrime[i * p] = true;
if (i % p == 0) {
break;
}
}
}
}
long long fac[20], facTop = 0;
inline void factor(long long x) {
facTop = 0;
for (int i = 1, p; i <= primeCnt; ++i) {
p = prime[i];
if ((long long)p * p > x) {
break;
}
if (x % p == 0) {
do {
x /= p;
} while (x % p == 0);
fac[++facTop] = p;
}
}
if (x != 1) {
fac[++facTop] = x;
}
}
} // namespace Math
namespace G {
const int N = 1e5 + 5;
long long dis[N];
inline void dijkstra() {
memset(dis, 0x3f, sizeof(dis));
priority_queue<pair<long long, int>> q;
dis[0] = 0LL;
q.emplace((pair<long long, int>){0LL, 0});
while (!q.empty()) {
auto p = q.top();
q.pop();
long long w = p.first;
int u = p.second;
if (w == dis[u]) {
for (int i = 2, v; i <= Math::facTop; ++i) {
v = (u + Math::fac[i]) % Math::fac[1];
if (dis[v] > w + Math::fac[i]) {
dis[v] = w + Math::fac[i];
q.emplace((pair<long long, int>){dis[v], v});
}
}
}
}
}
} // namespace G
inline int inv(long long x, int MOD) {
int base = x % MOD, exp = MOD - 2, res = 1;
while (exp != 0) {
if (exp & 1) {
res = (long long)res * base % MOD;
}
base = (long long)base * base % MOD;
exp >>= 1;
}
return res;
}
const int N = 1e4 + 5;
int T;
struct Query {
long long n, k;
int id;
inline const bool operator<(const Query &rhs) const { return k < rhs.k; }
};
Query query[N];
bool ans[N];
int main() {
Math::sieve();
read(T);
long long n, k;
for (int cas = 1; cas <= T; ++cas) {
read(n), read(k);
query[cas] = (Query){n, k, cas};
}
sort(query + 1, query + T + 1);
for (int i = 1, fac; i <= T; ++i) {
n = query[i].n, k = query[i].k;
if (k == 1) {
ans[query[i].id] = false;
} else {
if (k != query[i - 1].k) {
Math::factor(k);
fac = Math::facTop;
if (fac > 2) {
G::dijkstra();
}
}
if (fac == 1) {
ans[query[i].id] = (bool)(n % Math::fac[1] == 0);
} else if (fac == 2) {
long long a = Math::fac[1], b = Math::fac[2];
int y = n % a * inv(b, a) % a;
ans[query[i].id] = (bool)(b * y <= n);
} else {
ans[query[i].id] = (bool)(G::dis[n % Math::fac[1]] <= n);
}
}
}
for (int i = 1; i <= T; ++i) {
puts(ans[i] ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace SHENZHEBEI {
static const int GYN = 2333333;
char SZB[GYN], *SS = SZB, *TT = SZB;
inline char gc() {
if (SS == TT) {
TT = (SS = SZB) + fread(SZB, 1, GYN, stdin);
if (SS == TT) return '\n';
}
return *SS++;
}
inline long long read() {
long long x = 0, g = 1;
char ch = gc();
for (; !isdigit(ch); ch = gc())
if (ch == '-') g = -1;
for (; isdigit(ch); ch = gc()) x = x * 10 - 48 + ch;
return x * g;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline char readchar() {
char ch = gc();
for (; isspace(ch); ch = gc())
;
return ch;
}
inline long long readstr(char *s) {
char ch = gc();
int cur = 0;
for (; isspace(ch); ch = gc())
;
for (; !isspace(ch); ch = gc()) s[cur++] = ch;
s[cur] = '\0';
return cur;
}
void Print(long long *a, int s, int t) {
for (int i = (long long)(s); i <= (long long)(t); ++i) printf("%lld ", a[i]);
}
void Print(int *a, int s, int t) {
for (int i = (long long)(s); i <= (long long)(t); ++i) printf("%d ", a[i]);
}
void Print(char *a, int s, int t) {
for (int i = (long long)(s); i <= (long long)(t); ++i) putchar(a[i]);
}
void writeln(long long x) {
write(x);
puts("");
}
void Min(long long &x, long long y) { x = x < y ? x : y; }
void Max(long long &x, long long y) { x = x > y ? x : y; }
} // namespace SHENZHEBEI
using namespace SHENZHEBEI;
const long long N = 500010;
struct dt {
long long x, y, id;
} a[N];
bool mark[40000010];
long long TTT, q[1000], pri[8000010];
long long dis[200000], vis[200010], answ[200010];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
bool cmp(dt a, dt b) { return a.y < b.y; }
void Init() {
TTT = 40000000;
for (int i = (long long)(2); i <= (long long)(TTT); ++i)
if (!mark[i]) {
pri[++pri[0]] = i;
for (long long j = 2 * i; j <= TTT; j += i) mark[j] = 1;
}
}
void FenJie(long long x) {
q[0] = 0;
for (long long i = 1; pri[i] * pri[i] <= x; ++i)
if (!(x % pri[i])) {
q[++q[0]] = pri[i];
for (; !(x % pri[i]); x /= pri[i])
;
}
if (x > 1) q[++q[0]] = x;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
long long mul(long long a, long long b, long long mod) {
long long ans = 0;
for (; b; b >>= 1, a = (a + a) % mod)
if (b & 1) ans = (ans + a) % mod;
return ans;
}
int main() {
long long T = read();
Init();
for (int i = (long long)(1); i <= (long long)(T); ++i) {
long long x = read(), y = read();
a[i] = (dt){x, y, i};
}
sort(a + 1, a + T + 1, cmp);
for (long long i = 1, j; i <= T; i = j + 1) {
j = i;
for (; a[j + 1].y == a[i].y;) ++j;
FenJie(a[j].y);
if (a[j].y == 1) q[q[0] = 1] = 1e18 + 10000;
if (q[0] == 1) {
for (int k = (long long)(i); k <= (long long)(j); ++k) {
answ[a[k].id] = a[k].x % q[1] ? 0 : 1;
}
} else if (q[0] == 2) {
long long A = q[1], B = q[2], X, Y, XX, YY;
exgcd(A, B, X, Y);
X = (X % B + B) % B;
exgcd(B, A, XX, YY);
XX = (XX % A + A) % A;
for (int k = (long long)(i); k <= (long long)(j); ++k) {
long long n = a[k].x, x = n % A, y = n % B,
ans = mul(x * XX, B, (A * B)) + mul(y * X, A, (A * B));
answ[a[k].id] = n < ans ? 0 : 1;
}
} else {
memset(vis, 0, sizeof vis);
memset(dis, 60, sizeof dis);
dis[0] = 0;
Q.push(make_pair(0, 0));
for (; !Q.empty();) {
long long x = Q.top().second;
Q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int j = (long long)(2); j <= (long long)(q[0]); ++j) {
long long dist = dis[x] + q[j], to = dist % q[1];
if (dis[to] > dist) {
dis[to] = dist;
Q.push(make_pair(dis[to], to));
}
}
}
dis[0] = q[1];
for (int k = (long long)(i); k <= (long long)(j); ++k)
answ[a[k].id] = dis[a[k].x % q[1]] <= a[k].x ? 1 : 0;
}
}
for (int i = (long long)(1); i <= (long long)(T); ++i)
puts(answ[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1, c = getchar();
while (c < 48) c == '-' && (f = -1), c = getchar();
while (c > 47) x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int MAXN = 100005;
const int LIM = 31622779;
struct qs {
long long n, k, id;
} qr[MAXN];
std::vector<long long> fac;
int ans[MAXN], vis[LIM], pri[MAXN * 40];
long long dis[MAXN];
int m, cnt;
bool operator<(qs a, qs b) { return a.k < b.k; }
inline void sieve(int n) {
for (int i = 2; i <= n; ++i) {
if (!vis[i]) pri[++cnt] = i;
for (int j = 1; j <= cnt; ++j) {
if (i * pri[j] > n) break;
vis[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
inline void spfa(int mod) {
memset(dis, 0x3f, sizeof dis);
queue<int> q;
dis[0] = 0;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
vis[x] = 0;
for (int i = 1; i < fac.size(); ++i) {
int y = (x + fac[i]) % mod;
if (dis[y] > dis[x] + fac[i]) {
dis[y] = dis[x] + fac[i];
if (!vis[y]) vis[y] = 1, q.push(y);
}
}
}
}
inline void dcmp(long long k) {
long long tmp = k;
fac.clear();
for (int i = 1; 1ll * pri[i] * pri[i] <= tmp && i <= cnt; ++i) {
if (tmp % pri[i] == 0) {
fac.push_back(pri[i]);
while (tmp % pri[i] == 0) tmp /= pri[i];
}
}
if (tmp != 1) fac.push_back(tmp);
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, a;
long long res = exgcd(b, a % b, y, x);
return y -= (a / b) * x, res;
}
int main(int argc, char const *argv[]) {
m = read();
long long mx = 0;
for (int i = 1; i <= m; ++i)
qr[i].n = read(), mx = max(mx, qr[i].k = read()), qr[i].id = i;
mx = sqrt(mx);
sieve(mx);
memset(vis, 0, mx + 1);
sort(qr + 1, qr + m + 1);
for (int i = 1, tp = 0; i <= m; ++i) {
if (qr[i].k != qr[i - 1].k) {
dcmp(qr[i].k);
tp = 0;
if (qr[i].k == 1)
tp = 0;
else if (fac.size() == 1)
tp = 1;
else if (fac.size() == 2)
tp = 2;
else
tp = 3, spfa(fac[0]);
}
if (tp == 0)
ans[qr[i].id] = 0;
else if (tp == 1) {
if (qr[i].n % fac[0] == 0) ans[qr[i].id] = 1;
} else if (tp == 2) {
long long x, y, g = exgcd(fac[0], fac[1], x, y), md = fac[1] / g;
if ((x = (x % md + md) % md, 1) && (qr[i].n % g == 0)) {
x = (qr[i].n / g) % md * x % md;
y = (qr[i].n - x * fac[0]) / fac[1];
if (y >= 0) ans[qr[i].id] = 1;
}
} else if (dis[qr[i].n % fac[0]] <= qr[i].n)
ans[qr[i].id] = 1;
}
for (int i = 1; i <= m; ++i) puts(ans[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Query {
long long n, k;
int pos;
} Q[10005];
int M;
bool V[32000005];
int Prime[32000005];
vector<long long> Div;
int Heap[100005], NHeap, Pos[100005];
bool Res[10005];
bool Use[100005];
long long D[100005];
void Sieve() {
for (int i = 2; 1LL * i * i <= 1000000000000000; i++) {
if (V[i] == 0) {
Prime[++Prime[0]] = i;
for (int j = i + i; 1LL * j * j <= 1000000000000000; j += i) V[j] = 1;
}
}
}
void precalcDiv(long long x) {
int i = 1;
long long init = x;
Div.clear();
while (i <= Prime[0] && 1LL * Prime[i] * Prime[i] <= init && Prime[i] <= x) {
if (x % Prime[i] == 0) Div.push_back(Prime[i]);
while (x % Prime[i] == 0) x /= Prime[i];
++i;
}
if (x > 1) Div.push_back(x);
}
void Swap(int x, int y) {
swap(Heap[x], Heap[y]);
swap(Pos[Heap[x]], Pos[Heap[y]]);
}
void Percolate(int node) {
int f = node / 2;
if (node == 1) return;
if (D[Heap[f]] > D[Heap[node]]) {
Swap(node, f);
Percolate(f);
}
}
void Sift(int node) {
int son = node * 2;
if (son > NHeap) return;
if (son + 1 <= NHeap && D[Heap[son]] > D[Heap[son + 1]]) son++;
if (D[Heap[node]] > D[Heap[son]]) {
Swap(node, son);
Sift(son);
}
}
void Insert(int node) {
Heap[++NHeap] = node;
Pos[node] = NHeap;
Percolate(NHeap);
}
void Erase(int node) {
int pos = Pos[node];
Swap(NHeap, pos);
--NHeap;
Percolate(pos);
Sift(pos);
}
void Dijkstra() {
for (int i = 0; i < Div[0]; i++)
D[i] = 1000000000000000005, Use[i] = 0, Pos[i] = 0;
NHeap = 0;
D[0] = 0;
for (int i = 0; i < Div[0]; i++) Insert(i);
for (int i = 0; i < Div[0]; i++) {
int node = Heap[1];
Erase(node);
Use[node] = 1;
for (int j = 1; j < Div.size(); j++) {
long long cost = Div[j];
int neighb = (node + Div[j]) % Div[0];
if (cost > 1000000000000000000) continue;
if (Use[neighb] == 1) continue;
if (D[neighb] > D[node] + cost) {
Erase(neighb);
D[neighb] = D[node] + cost;
Insert(neighb);
}
}
}
}
inline bool cmp(Query a, Query b) { return a.k < b.k; }
void Read() {
cin >> M;
for (int i = 1; i <= M; i++) {
cin >> Q[i].n >> Q[i].k;
Q[i].pos = i;
}
sort(Q + 1, Q + M + 1, cmp);
}
long long power(long long n, int p, long long mod) {
long long sol = 1;
while (p) {
if (p % 2 == 1) sol = (sol * n) % mod;
p /= 2;
n = (n * n) % mod;
}
return sol;
}
void Solve() {
for (int i = 1; i <= M; i++) {
if (Q[i].k != Q[i - 1].k) {
precalcDiv(Q[i].k);
if (Div.size() >= 3) Dijkstra();
}
if (Div.size() == 0) Res[Q[i].pos] = 0;
if (Div.size() == 1) {
if (Q[i].n % Div[0] == 0)
Res[Q[i].pos] = 1;
else
Res[Q[i].pos] = 0;
}
if (Div.size() == 2) {
long long inv = power(Div[0], Div[1] - 2, Div[1]);
long long mod = Q[i].n % Div[1];
inv = (inv * mod) % Div[1];
if (inv == 0) {
Res[Q[i].pos] = 1;
continue;
}
if (Div[0] > Q[i].n / inv) {
Res[Q[i].pos] = 0;
} else
Res[Q[i].pos] = 1;
}
if (Div.size() >= 3) {
long long mod = Q[i].n % Div[0];
if (D[mod] <= Q[i].n)
Res[Q[i].pos] = 1;
else
Res[Q[i].pos] = 0;
}
}
for (int i = 1; i <= M; i++) {
if (Res[i] == 0)
printf("NO\n");
else
printf("YES\n");
}
}
int main() {
Sieve();
Read();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int T_MAX = 10005;
const int SIEVE_MAX = 32000000;
const int SMALL_MAX = 100005;
const long long LL_INF = 2e18;
struct video {
long long n, k;
int index;
bool operator<(const video &other) const {
return make_pair(k, n) < make_pair(other.k, other.n);
}
};
int T;
video videos[T_MAX];
vector<bool> is_prime(SIEVE_MAX, true);
vector<int> primes;
vector<bool> answers(T_MAX, false);
long long smallest_sum[SMALL_MAX];
void sieve() {
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i < SIEVE_MAX; i++) {
if (is_prime[i]) {
for (int j = i * i; j < SIEVE_MAX; j += i) {
is_prime[j] = false;
}
}
}
for (int i = 2; i < SIEVE_MAX; i++) {
if (is_prime[i]) primes.push_back(i);
}
}
int mod_pow(long long a, int p, int mod) {
long long result = 1;
while (p > 0) {
if (p & 1) result = result * a % mod;
a = a * a % mod;
p >>= 1;
}
return result;
}
int mod_inv(int a, int mod) { return mod_pow(a, mod - 2, mod); }
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
void check_and_add(int value, long long sum) {
if (sum < smallest_sum[value]) {
smallest_sum[value] = sum;
pq.push(make_pair(sum, value));
}
}
void dijkstra(vector<long long> k_primes) {
int small_prime = (int)k_primes[0];
assert(small_prime < SMALL_MAX);
for (int i = 0; i < small_prime; i++) {
smallest_sum[i] = LL_INF;
}
assert(pq.empty());
check_and_add(0, 0);
while (!pq.empty()) {
pair<long long, int> top = pq.top();
pq.pop();
int value = top.second;
long long sum = top.first;
if (sum > smallest_sum[value]) continue;
for (long long p : k_primes) {
int next_value = (value + p) % small_prime;
long long next_sum = sum + p;
check_and_add(next_value, next_sum);
}
}
smallest_sum[0] = small_prime;
}
void solve(int start, int end) {
long long k = videos[start].k;
vector<long long> k_primes;
for (int p : primes) {
if (p > k) break;
if (k % p == 0) {
k_primes.push_back(p);
do {
k /= p;
} while (k % p == 0);
}
}
if (k > 1) {
k_primes.push_back(k);
}
sort(k_primes.begin(), k_primes.end());
for (int i = start; i < end; i++) {
long long n = videos[i].n;
bool answer;
if (k_primes.empty()) {
answer = false;
} else if (k_primes.size() == 1) {
answer = n % k_primes[0] == 0;
} else if (k_primes.size() == 2) {
long long a = k_primes[0], b = k_primes[1];
long long goal = n % a;
long long smallest = (goal * mod_inv(b, a) % a) * b;
answer = n >= smallest;
} else {
int small_prime = (int)k_primes[0];
if (i == start) {
dijkstra(k_primes);
}
answer = n >= smallest_sum[n % small_prime];
}
answers[videos[i].index] = answer;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
sieve();
cin >> T;
for (int i = 0; i < T; i++) {
cin >> videos[i].n >> videos[i].k;
videos[i].index = i;
}
sort(videos, videos + T);
for (int i = 0, j = 0; i < T; i = j) {
while (j < T && videos[j].k == videos[i].k) j++;
solve(i, j);
}
for (int i = 0; i < T; i++) {
cout << (answers[i] ? "YES" : "NO") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
using namespace std;
const long long maxn = 1e5 + 123, inf = 1e9, N = 3e7 + 5e6, INF = 1e18,
mod = 1e9 + 7;
vector<pair<long long, long long> > v, g[maxn];
vector<long long> prime;
bool used[N + 13];
long long t, dis[maxn], n[maxn], k[maxn];
map<pair<long long, long long>, bool> ans;
long long binpow(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
int main() {
for (int i = 2; i <= N; i++) {
if (!used[i]) {
prime.push_back(i);
;
for (long long j = 1ll * i * i; j < N; j += i) used[j] = 1;
}
}
scanf("%lld", &t);
for (int i = 0; i < t; i++) {
scanf("%lld%lld", &n[i], &k[i]);
v.push_back(make_pair(k[i], n[i]));
}
sort(v.begin(), v.end());
for (int i = 0; i < t;) {
long long k = v[i].first, x = v[i].first;
vector<long long> vn, p;
while (i <= t && k == v[i].first) vn.push_back(v[i++].second);
for (int i = 0; i < prime.size(); i++) {
if (x % prime[i] == 0) {
p.push_back(prime[i]);
while (x % prime[i] == 0) x /= prime[i];
}
}
if (x > 1) p.push_back(x);
if (p.size() == 1) {
for (int i = 0; i < vn.size(); i++)
ans[make_pair(vn[i], k)] = (vn[i] % p[0] == 0);
}
if (p.size() == 2) {
long long x = p[0], y = p[1];
for (int i = 0; i < vn.size(); i++) {
long long n = vn[i], a, b;
b = n % x * binpow(y, x - 2, x) % x;
ans[make_pair(n, k)] = (n >= b * y);
}
}
if (p.size() >= 3) {
for (int i = 0; i < p[0]; i++) {
g[i].clear();
for (int j = 0; j < p.size(); j++)
g[i].push_back(make_pair((i + p[j]) % p[0], p[j]));
dis[i] = INF;
}
set<pair<long long, long long> > st;
dis[0] = 0;
st.insert(make_pair(0, 0));
while (!st.empty()) {
long long v = (*st.begin()).second;
st.erase(st.begin());
for (int i = 0; i < g[v].size(); i++) {
long long to = g[v][i].first, w = g[v][i].second;
if (dis[to] > dis[v] + w) {
st.erase(make_pair(dis[to], to));
dis[to] = dis[v] + w;
st.insert(make_pair(dis[to], to));
}
}
}
for (int i = 0; i < vn.size(); i++)
ans[make_pair(vn[i], k)] = (vn[i] >= dis[vn[i] % p[0]]);
}
}
for (int i = 0; i < t; i++)
if (ans[make_pair(n[i], k[i])])
puts("YES");
else
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
int t;
map<int, int> has;
long long fj[55][50], gs[55], bh;
long long n, k;
const long long S = 31624000;
const long long mf = 1e5 + 10;
bool is[S];
long long p[2000000];
void init() {
for (int i = 2; i < S; i++) {
if (!is[i]) p[++p[0]] = i;
for (int j = 1; j <= p[0] && p[j] * i < S; j++) {
is[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
}
long long mx, dis[mf];
vector<pair<int, int> > e[mf];
vector<int> ans[51];
long long Q[mf * 100], vis[mf];
void build(long long z) {
mx = fj[z][1];
for (int i = 0; i < mx; i++) {
e[i].clear();
for (int j = 1; j <= gs[z]; j++)
e[i].push_back(make_pair((i + fj[z][j]) % mx, fj[z][j]));
}
memset(dis, 127, sizeof dis);
dis[0] = 0;
int L = 0, R = 1;
Q[R] = 0;
while (L < R) {
int x = Q[++L];
vis[x] = 0;
for (int i = 0; i < e[x].size(); i++) {
long long y = e[x][i].first, c = e[x][i].second;
if (dis[x] + c < dis[y]) {
dis[y] = dis[x] + c;
if (!vis[y]) {
vis[y] = 1;
Q[++R] = y;
}
}
}
}
for (int i = 0; i < mx; i++) ans[z].push_back(dis[i]);
}
int fen(long long x) {
bh++;
for (int i = 1; p[i] * p[i] <= x; i++) {
if (x % p[i] == 0) {
fj[bh][++gs[bh]] = p[i];
while (x % p[i] == 0) x /= p[i];
}
}
if (x != 1) fj[bh][++gs[bh]] = x;
if (gs[bh] >= 3) build(bh);
return bh;
}
void getans(int n, int z) {
if (n < fj[z][1])
printf("NO\n");
else if (ans[z][n % fj[z][1]] <= n)
printf("YES\n");
else
printf("NO\n");
}
long long ksm(long long x, long long y, long long mo) {
long long ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = ret * x % mo;
x = x * x % mo;
}
return ret;
}
int main() {
init();
for (cin >> t; t; t--) {
scanf("%I64d %I64d", &n, &k);
int &z = has[k];
if (!z) z = fen(k);
if (k == 1) {
printf("NO\n");
continue;
}
if (gs[z] == 1) {
printf(n % fj[z][1] ? "NO\n" : "YES\n");
} else if (gs[z] == 2) {
long long a = fj[z][1], b = fj[z][2];
long long my = ksm(b, a - 2, a) * (n % a) % a;
if (my * b <= n)
printf("YES\n");
else
printf("NO\n");
} else
getans(n, z);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 5;
long long nn[N], kk[N];
map<long long, vector<int> > M;
vector<long long> pr;
bool res[N];
long long egcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long x1, y1;
long long g = egcd(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
long long mulmod(long long a, long long b, long long c) {
long long sign = 1;
if (a < 0) {
a = -a;
sign = -sign;
}
if (b < 0) {
b = -b;
sign = -sign;
}
a %= c;
b %= c;
long long res = 0;
while (b > 0) {
if (b & 1) {
res = (res + a) % c;
}
a = (a + a) % c;
b >>= 1;
}
if (sign == -1) {
res = (-res) % c;
}
return res;
}
bool calc(long long a, long long b, long long c) {
long long x, y;
long long g = egcd(a, b, x, y);
long long dx = c / a;
c -= dx * a;
long long dy = c / b;
c -= dy * b;
x = dx + mulmod(x, c / g, b);
y = dy + mulmod(y, c / g, a);
if (x < 0) {
long long need = (-x + b - 1) / b;
long long can = y / a;
if (need > can) return 0;
}
if (y < 0) {
long long need = (-y + a - 1) / a;
long long can = x / b;
if (need > can) return 0;
}
return 1;
}
int main() {
const int K = sqrt(1e15) + 5;
vector<bool> h(K, 0);
for (int i = 2; i < K; i++) {
if (!h[i]) {
pr.push_back(i);
for (int j = i + i; j < K; j += i) h[j] = i;
}
}
int t;
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
scanf("%lld %lld", nn + i, kk + i);
if (kk[i] == 1) continue;
M[kk[i]].push_back(i);
}
for (auto it : M) {
long long k = it.first;
long long tmp = k;
vector<long long> dv;
for (auto x : pr) {
if (x * x > k) break;
if (k % x == 0) {
dv.push_back(x);
while (k % x == 0) k /= x;
}
}
if (k > 1) dv.push_back(k);
k = tmp;
if (dv.size() == 1) {
for (auto i : it.second) {
res[i] = nn[i] % dv[0] == 0;
}
} else if (dv.size() == 2) {
for (auto i : it.second) {
res[i] = calc(dv[0], dv[1], nn[i]);
}
} else {
vector<long long> d(dv[0], 2e18);
d[0] = 0;
priority_queue<pair<long long, int> > q;
q.push({0, 0});
while (!q.empty()) {
long long c = -q.top().first;
int x = q.top().second;
q.pop();
if (c > d[x]) continue;
for (auto i : dv) {
int y = (x + i) % dv[0];
long long nc = c + i;
if (nc < d[y]) {
d[y] = nc;
q.push({-nc, y});
}
}
}
for (auto i : it.second) {
res[i] = d[nn[i] % dv[0]] <= nn[i];
}
}
}
for (int i = 1; i <= t; i++) {
puts(res[i] ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 4e18;
const int BASE = 131;
const double eps = 1e-4;
const int mod = 998244353;
const int inf = 1061109567;
const double pi = acos(-1);
const int inv2 = (mod + 1) >> 1;
namespace Math {
inline long long popcount(long long x) {
x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
x = (x & 0x0000FFFF) + ((x >> 16) & 0x0000FFFF);
return x;
}
inline long long F(long long x, long long p) { return x >= p ? x - p : x; }
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long ksm(long long x, long long t, long long p) {
long long res = 1;
while (t) {
if (t & 1) res = 1LL * res * x % p;
x = 1LL * x * x % p;
t >>= 1;
}
return res;
}
} // namespace Math
template <typename tp>
inline void read(tp &dig) {
char ch = getchar();
long long flag = 0;
dig = 0;
while (!isdigit(ch)) {
if (ch == '-') flag = 1;
ch = getchar();
}
while (isdigit(ch)) dig = dig * 10 + ch - '0', ch = getchar();
if (flag) dig = -dig;
}
template <typename tp, typename... Args>
inline void read(tp &dig, Args &...args) {
read(dig);
read(args...);
}
struct node {
long long n, k, id;
inline bool operator<(const node &b) const { return k < b.k; }
} a[100010];
long long T, p[31], f[100010], vis[100010], ans[100010];
queue<int> que;
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long mul(long long a, long long b, long long MOD) {
return (a * b - (long long)((long double)a / MOD * b + 1e-6) * MOD + MOD) %
MOD;
}
inline long long ksm(long long x, long long t, long long MOD) {
long long res = 1;
while (t) {
if (t & 1) res = mul(res, x, MOD);
x = mul(x, x, MOD);
t >>= 1;
}
return res;
}
inline bool test(long long x, long long a, long long d) {
while (!(d & 1)) d >>= 1;
long long t = ksm(a, d, x);
while ((d ^ (x - 1)) && t != x - 1 && t != 1) t = mul(t, t, x), d <<= 1;
return t == x - 1 || (d & 1) == 1;
}
inline bool isprime(long long x) {
if (x == 2 || x == 3 || x == 5 || x == 7 || x == 13) return true;
if (x % 2 == 0 || x % 3 == 0 || x % 5 == 0 || x % 7 == 0 || x % 13 == 0)
return false;
int a[] = {2, 3, 5, 7, 13};
for (int i = 0; i <= 4; ++i)
if (!test(x, a[i], x - 1)) return false;
return true;
}
inline long long pollard_rho(long long n, long long c) {
long long x = rand() % n + 1;
if (x == 1) x += 3;
while (x < n / x) x = x * x;
x = (x % n + n) % n;
long long y = x, i = 1, k = 2;
while (true) {
++i;
x = (mul(x, x, n) + c) % n;
long long d = gcd(abs(y - x), n);
if (1 < d && d < n) return d;
if (y == x) return n;
if (i == k) y = x, k <<= 1;
}
}
inline long long find(long long x, long long c) {
if (x == 1) return 0;
if (isprime(x)) {
p[++p[0]] = x;
return 1;
}
long long p = x;
while (p >= x) p = pollard_rho(p, c--);
if (find(p, c)) return 1;
if (find(x / p, c)) return 1;
}
int main() {
read(T);
srand(T);
for (int i = 1; i <= T; ++i) read(a[i].n, a[i].k), a[i].id = i;
sort(a + 1, a + T + 1);
for (int i = 1; i <= T; ++i) {
if (a[i].k ^ a[i - 1].k) {
long long K = a[i].k;
p[0] = 0;
while (K ^ 1) {
find(K, rand() % 51937 + 1);
while (K % p[p[0]] == 0) K /= p[p[0]];
}
}
if (!p[0]) {
ans[a[i].id] = 0;
continue;
}
if (p[0] == 1) {
ans[a[i].id] = (a[i].n % a[i].k == 0);
continue;
}
if (p[0] == 2) {
long long b = a[i].n % p[1] * ksm(p[2], p[1] - 2, p[1]) % p[1];
ans[a[i].id] = (b * p[2] <= a[i].n);
continue;
} else {
if (a[i].k ^ a[i - 1].k) {
sort(p + 1, p + p[0] + 1);
for (int j = 1; j <= p[1]; ++j) f[j] = 1e18;
que.push(0);
vis[0] = 1;
while (!que.empty()) {
int now = que.front();
que.pop();
for (int j = 2; j <= p[0]; ++j) {
int v = (now + p[j]) % p[1];
if (f[now] + p[j] < f[v]) {
f[v] = f[now] + p[j];
if (!vis[v]) que.push(v), vis[v] = 1;
}
}
vis[now] = 0;
}
}
ans[a[i].id] = (f[a[i].n % p[1]] <= a[i].n);
}
}
for (int i = 1; i <= T; ++i)
if (ans[i])
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.