text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
long long first, second;
long long ex_gcd(long long a, long long b) {
if (!b) {
first = 1, second = 0;
return a;
}
long long d = ex_gcd(b, a % b);
long long tmp = first;
first = second;
second = tmp - a / b * second;
return d;
}
struct bignum {
long long a[40];
int l;
bignum() {
l = 0;
memset(a, 0, sizeof(a));
}
bignum(long long n) {
l = 0;
memset(a, 0, sizeof(a));
while (n) {
a[l++] = n % 10;
n /= 10;
}
}
bignum mul(bignum p) {
bignum c;
for (int i = 0; i < l; i++) {
for (int j = 0; j < p.l; j++) {
c.a[i + j] += a[i] * p.a[j];
}
}
c.l = l + p.l;
for (int i = 0; i < c.l; i++) {
if (c.a[i] >= 10) {
c.a[i + 1] += c.a[i] / 10;
c.a[i] %= 10;
}
}
while (c.l && !c.a[c.l - 1]) c.l--;
return c;
}
void div(long long p) {
long long tmp = 0;
for (int i = l - 1; i >= 0; i--) {
long long first = (tmp * 10 + a[i]) % p;
a[i] = (tmp * 10 + a[i]) / p;
tmp = first;
}
while (l && !a[l - 1]) l--;
}
void add(int first) {
a[0] += first;
for (int i = 0; i < l; i++) {
if (a[i] >= 10) {
a[i + 1] += a[i] / 10;
a[i] %= 10;
}
}
if (a[l]) l++;
}
};
bool check(long long p, long long q, long long n) {
if (p > q) swap(p, q);
if (n % p == 0 || n % q == 0) return true;
if (n / q <= 2000) {
for (int i = 0; i * q <= n; i++) {
if ((n - i * q) % p == 0) return true;
}
return false;
}
ex_gcd(p, q);
if (first > 0) swap(p, q), swap(first, second);
first = -first;
bignum t1(first);
bignum t2(second);
bignum _n(n);
t1 = t1.mul(_n);
t2 = t2.mul(_n);
t1.div(q);
t1.add(1);
t2.div(p);
if (t1.l > t2.l) return false;
if (t1.l < t2.l) return true;
for (int i = t1.l - 1; i >= 0; i--) {
if (t1.a[i] == t2.a[i]) continue;
return t1.a[i] < t2.a[i];
}
return true;
}
const int N = 10010;
bool ans[N];
pair<long long, pair<long long, int> > a[N];
const int MAXN = 40000000;
int min_p[MAXN];
int prime[MAXN / 15];
int tot;
void init() {
for (int i = 2; i < MAXN; i++) {
if (!min_p[i]) {
min_p[i] = i;
prime[tot++] = i;
}
for (int j = 0; prime[j] * i < MAXN && j < tot; j++) {
int first = prime[j] * i;
if (i % prime[j] == 0) {
min_p[first] = min_p[i];
break;
} else {
min_p[first] = prime[j];
}
}
}
}
long long fac[55], cnt;
void factor(long long n) {
cnt = 0;
for (int i = 0; 1LL * prime[i] * prime[i] <= n; i++) {
if (n % prime[i]) continue;
while (n % prime[i] == 0) n /= prime[i];
fac[cnt++] = prime[i];
}
if (n > 1) fac[cnt++] = n;
}
long long dis[N * 10];
bool vis[N * 10];
void spfa() {
sort(fac, fac + cnt);
for (int i = 0; i < fac[0]; i++) vis[i] = false, dis[i] = 1LL << 62;
dis[0] = 0;
queue<int> q;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = false;
for (int i = 0; i < cnt; i++) {
int first = (u + fac[i]) % fac[0];
if (dis[first] > dis[u] + fac[i]) {
dis[first] = dis[u] + fac[i];
if (!vis[first]) {
vis[first] = true;
q.push(first);
}
}
}
}
}
void solve(int l, int r) {
if (a[l].first == 1) {
return;
}
factor(a[l].first);
if (cnt > 2) spfa();
for (int i = l; i <= r; i++) {
if (a[i].second.first == 1) {
continue;
}
if (cnt == 1) {
if (a[i].second.first % fac[0] == 0) ans[a[i].second.second] = true;
continue;
}
if (cnt == 2) {
if (check(fac[0], fac[1], a[i].second.first))
ans[a[i].second.second] = true;
continue;
}
if (dis[a[i].second.first % fac[0]] <= a[i].second.first)
ans[a[i].second.second] = true;
}
}
int main() {
init();
int t;
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
cin >> a[i].second.first >> a[i].first;
a[i].second.second = i;
}
sort(a + 1, a + t + 1);
int i = 1;
while (i <= t) {
int j = i;
while (j <= t && a[j].first == a[i].first) j++;
solve(i, j - 1);
i = j;
}
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;
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;
using INT = long long;
INT n, k;
INT multi(INT x, INT y, INT z) {
return (x * y - (INT)(x / (long double)z * y + 1e-8) * z + z) % z;
}
INT power(INT a, INT y, INT z) {
if (y == 0) return 1;
INT b = power(a, y >> 1, z);
b = multi(b, b, z);
if (y & 1LL) b = multi(b, a, z);
return b;
}
bool witness(INT a, INT n) {
int t = 0;
INT u = n - 1;
while (~u & 1LL) {
u >>= 1;
t++;
}
INT x0 = power(a, u, n), x1;
for (int i = 0; i < t; i++) {
x1 = multi(x0, x0, n);
if (x1 == 1 && x0 != n - 1 && x0 != 1) return true;
x0 = x1;
}
if (x0 != 1) return true;
return false;
}
INT add(INT x, const INT &y, const INT &z) {
x += y;
if (x >= z) return x - z;
return x;
}
INT gcd(const INT &a, const INT &b) {
if (!b) return a;
return gcd(b, a % b);
}
INT pollard(INT n) {
static mt19937_64 rnd(996);
static const int maxt = 100;
while (1) {
INT x = rnd() % (n - 3) + 2, y = x, c = rnd() % n, tim = 0, prd = 1;
for (INT i = 1, stp = 2;; ++i) {
if (i == stp) y = x, stp <<= 1;
if ((x = add(multi(x, x, n), c, n)) == y) break;
INT tmp = prd;
if ((prd = multi(prd, abs(y - x), n)) == 0) return gcd(tmp, n);
if ((++tim) < maxt) continue;
if ((prd = gcd(prd, n)) > 1) return prd;
tim = 0;
}
if (tim > 0 && (prd = gcd(prd, n)) > 1) return prd;
}
}
bool is_prime(INT N) {
if (N == 1) return false;
for (int i = 0; i < 70; i++) {
INT a = (INT)rand() % (N - 1) + 1;
if (witness(a, N)) return false;
}
return true;
}
map<INT, vector<INT> > fac;
vector<INT> calc(INT u) {
if (fac.count(u)) return fac[u];
vector<INT> buf;
INT U = u;
for (int i = 2; i <= 100000; i++)
if (u % i == 0) {
while (u % i == 0) u /= i;
buf.push_back(i);
}
if (u > 1) {
if (is_prime(u))
buf.push_back(u);
else {
INT v = pollard(u);
buf.push_back(v);
if (v != u and u / v != v) {
buf.push_back(u / v);
}
sort(buf.begin(), buf.end());
}
}
fac[U] = buf;
return buf;
}
int power(int a, int b, int m, int ans = 1) {
a %= m;
for (; b; b >>= 1, a = 1ll * a * a % m)
if (b & 1) {
ans = 1ll * ans * a % m;
}
return ans;
}
int solve2(INT n, INT a, INT b) {
int y = (INT)n % a * power(b % a, a - 2, a) % a;
assert((INT)b % a * y % a == n % a);
return (b * y <= n);
}
int solve3(INT n, INT a, INT b, INT c) {
INT rev = power(b % a, a - 2, a);
for (int i = 0; i < a and c * i <= n; i++) {
if (c * i + rev * ((n - c * i) % a) % a * b <= n) return 1;
}
return 0;
}
INT dp[10100];
pair<int, INT> q[1100000];
int solve4(INT n, vector<INT> &buf) {
if (n >= buf[0] * buf[1]) return 1;
INT a = buf[0];
assert(a < 10000);
for (int i = 0; i < a; i++) {
dp[i] = n + 1;
}
dp[0] = 0;
int qb = 1, qf = 1;
q[qb++] = {0, 0};
int ss = n % a;
while (qf < qb) {
auto p = q[qf++];
if (dp[p.first] != p.second) continue;
for (auto &u : buf)
if (u != buf[0]) {
int s = u % a + p.first;
if (s >= a) s -= a;
if (dp[s] > p.second + u) {
dp[s] = p.second + u;
if (ss == s) return 1;
q[qb++] = {s, dp[s]};
}
}
}
return (dp[ss] <= n);
}
int solve(vector<INT> &buf, INT n) {
for (auto u : buf)
if (n % u == 0) return 1;
if (buf.size() == 1) return 0;
if (buf.size() == 2) return solve2(n, buf[0], buf[1]);
if (buf.size() == 3) return solve3(n, buf[0], buf[1], buf[2]);
return solve4(n, buf);
}
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> k;
if (k == 1) {
puts("NO");
continue;
}
vector<INT> buf = calc(k);
if (solve(buf, n))
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e4 + 5;
const int M = 1e6 + 5;
struct node {
long long n, k;
int pos;
} q[N];
struct data {
int id;
long long d;
bool operator<(data r) const { return d > r.d; }
};
priority_queue<data> g;
long long dis[M];
int ans[N], vis[M], p[M];
int tot, cnt;
bool cmp(node a, node b) { return a.k < b.k; }
long long abs1(long long x) { return x < 0 ? -x : x; }
long long gcd(long long x, long long y) { return !y ? x : gcd(y, x % y); }
inline long long mul(long long x, long long p, long long mo) {
long long ret = 0;
for (; p; p >>= 1, x = (x + x) % mo)
if (p & 1) ret = (ret + x) % mo;
return ret;
}
inline long long pow(long long x, long long p, long long mo) {
long long ret = 1;
for (; p; p >>= 1, x = mul(x, x, mo))
if (p & 1) ret = mul(ret, x, mo);
return ret;
}
inline bool Mill(long long x) {
if (x < 2) return 0;
int s = 0;
long long z = x;
--x;
while (!(x & 1)) x >>= 1, ++s;
for (int i = 0; i < 10; ++i) {
long long k = (rand() * rand()) % z;
while (!k) k = (rand() * rand()) % z;
k = pow(k, x, z);
long long pre = k;
for (int j = 0; j < s; ++j) {
k = mul(k, k, z);
if (k == 1 && pre != 1 && pre != z - 1) return 0;
pre = k;
}
if (k != 1) return 0;
}
return 1;
}
inline long long rho(long long x) {
int l = 1, r = 2;
long long x0 = (rand() * rand()) % x, y = x0, c = (rand() * rand()) % x + 1;
while (1) {
++l;
x0 = (mul(x0, x0, x) + c) % x;
long long now = gcd(abs1(x0 - y), x);
if (now != 1 && now != x) return now;
if (x0 == y) return x;
if (l == r) r <<= 1, y = x0;
}
}
inline void divi(long long x) {
if (x == 1) return;
if (Mill(x)) {
p[++cnt] = x;
return;
}
long long d = rho(x);
divi(x / d);
divi(d);
}
inline void dij() {
dis[0] = 0, g.push((data){0, 0});
while (!g.empty()) {
data x = g.top();
g.pop();
if (vis[x.id]) continue;
vis[x.id] = 1;
for (int i = 2; i <= cnt; ++i) {
int v = (x.id + p[i]) % p[1];
if (dis[v] > dis[x.id] + p[i]) {
dis[v] = dis[x.id] + p[i];
g.push((data){v, dis[v]});
}
}
}
}
int main() {
int t;
scanf("%d", &t);
for (int i = 1; i <= t; ++i)
scanf("%I64d%I64d", &q[i].n, &q[i].k), q[i].pos = i;
sort(q + 1, q + t + 1, cmp);
for (int i = 1; i <= t; ++i) {
if (q[i].k == q[i - 1].k) {
if (!cnt) {
ans[q[i].pos] = 0;
continue;
}
if (cnt == 1) {
if (q[i].n % q[i].k == 0)
ans[q[i].pos] = 1;
else
ans[q[i].pos] = 0;
continue;
}
if (cnt == 2) {
long long b = q[i].n % p[1] *
pow((long long)p[2], p[1] - 2, (long long)p[1]) % p[1];
if (b * p[2] <= q[i].n)
ans[q[i].pos] = 1;
else
ans[q[i].pos] = 0;
continue;
}
ans[q[i].pos] = dis[q[i].n % (long long)p[1]] <= q[i].n;
continue;
}
cnt = 0;
divi(q[i].k);
sort(p + 1, p + cnt + 1);
cnt = unique(p + 1, p + cnt + 1) - p - 1;
if (!cnt) {
ans[q[i].pos] = 0;
continue;
}
if (cnt == 1) {
if (q[i].n % q[i].k == 0)
ans[q[i].pos] = 1;
else
ans[q[i].pos] = 0;
continue;
}
if (cnt == 2) {
long long b = q[i].n % p[1] *
pow((long long)p[2], p[1] - 2, (long long)p[1]) % p[1];
if (b * p[2] <= q[i].n)
ans[q[i].pos] = 1;
else
ans[q[i].pos] = 0;
continue;
}
for (int j = 0; j < p[1]; ++j) vis[j] = 0, dis[j] = 1e18;
dij();
ans[q[i].pos] = dis[q[i].n % p[1]] <= q[i].n;
}
for (int i = 1; i <= t; ++i)
if (ans[i])
puts("YES");
else
puts("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;
int UUxUU = 10;
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>
int t;
struct item {
int id;
long long n, k;
bool operator<(const item& it) const { return k < it.k; }
} items[10010];
bool ans[10010];
long long ps[100];
int pc;
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)
x = 1, y = 0;
else
exgcd(b, a % b, y, x), y -= a / b * x;
}
long long rnd() {
long long x = rand();
x = x << 15 ^ rand();
return x << 15 ^ rand();
}
unsigned long long mul(unsigned long long a, unsigned long long b,
unsigned long long p) {
unsigned long long c = 0;
for (; b; b >>= 13) (c += a * (b & 8191)) %= p, a = (a << 13) % p;
return c;
}
unsigned long long pw(unsigned long long a, unsigned long long n,
unsigned long long p) {
unsigned long long b = 1;
for (; n; n >>= 1) n % 2 ? b = mul(b, a, p) : 1, a = mul(a, a, p);
return b;
}
bool isp(long long x) {
if (x < 4) return 1;
if (x % 2 == 0) return 0;
if (x == 46856248255981ll) return 0;
const int a[5] = {2, 3, 7, 61, 24251};
for (int i = 0; i < 5 && a[i] < x; i++) {
long long y = x - 1, t, u;
while (y % 2 == 0) y /= 2;
for (t = pw(a[i], y, x); y < x; y *= 2, t = u)
if ((u = mul(t, t, x)) == 1 && t != 1 && t != x - 1) return 0;
if (t != 1) return 0;
}
return 1;
}
void fact(long long n) {
for (; n % 2 == 0; n /= 2) ps[pc++] = 2;
if (n == 1) return;
if (isp(n)) {
ps[pc++] = n;
return;
}
for (long long x = rnd() % n, y = x, z;; x = y = rnd() % n) {
z = rnd() % (n - 1) + 1;
do {
x = (mul(x, x, n) + z) % n;
y = (mul(y, y, n) + z) % n;
y = (mul(y, y, n) + z) % n;
long long g = gcd(x > y ? x - y : y - x, n);
if (g > 1 && g < n) {
fact(g);
fact(n / g);
return;
}
} while (x != y);
}
}
struct qitem {
int v;
long long d;
bool operator<(const qitem& it) const { return d > it.d; }
};
long long dis[100010];
bool vis[100010];
void calc_sp() {
for (int i = 0; i < ps[0]; i++) vis[i] = 0;
std::priority_queue<qitem> Q;
Q.push((qitem){0, 0});
while (!Q.empty()) {
qitem it = Q.top();
Q.pop();
if (vis[it.v]) continue;
vis[it.v] = 1;
dis[it.v] = it.d;
for (int j = 0; j < pc; j++) {
int t = (it.v + ps[j]) % ps[0];
if (!vis[t]) Q.push((qitem){t, it.d + ps[j]});
}
}
}
int main() {
srand(time(0));
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%lld%lld", &items[i].n, &items[i].k);
items[i].id = i;
}
std::sort(items, items + t);
for (int tl = 0, tr = 0; tl < t; tl = tr) {
long long k = items[tl].k;
pc = 0;
fact(k);
std::sort(ps, ps + pc);
pc = std::unique(ps, ps + pc) - ps;
if (pc > 2) calc_sp();
for (; tr < t && items[tr].k == k; tr++) {
int id = items[tr].id;
long long n = items[tr].n;
if (!pc)
ans[id] = 0;
else if (pc == 1)
ans[id] = n % ps[0] == 0;
else if (pc == 2) {
long long x, y;
exgcd(ps[0], ps[1], x, y);
x = (x + ps[1]) % ps[1];
x = mul(x, n % ps[1], ps[1]);
ans[id] = ps[0] * x <= n;
} else
ans[id] = vis[n % ps[0]] && dis[n % ps[0]] <= n;
}
}
for (int i = 0; i < t; i++) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxp = 34000000;
const int maxn = 100100;
const int maxt = 10010;
bool mark[maxp];
vector<int> ps;
long long x[maxt], k[maxt];
long long dis[maxn];
bool ans[maxt];
int power(long long x, int y, int M) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * x % M;
x = x * x % M;
y >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 2; i < maxp; i++)
if (!mark[i]) {
ps.push_back(i);
for (long long j = 1ll * i * i; j < maxp; j += i) mark[j] = true;
}
set<long long> ks;
int t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> x[i] >> k[i];
if (k[i] > 1) ks.insert(k[i]);
}
for (long long kk : ks) {
long long kkk = kk;
vector<long long> P;
for (int p : ps)
if (kk % p == 0) {
P.push_back(p);
while (kk % p == 0) kk /= p;
}
if (kk > 1) P.push_back(kk);
kk = kkk;
if (P.size() == 1) {
for (int i = 0; i < t; i++)
if (k[i] == kk and x[i] % P[0] == 0) ans[i] = true;
} else if (P.size() == 2) {
for (int i = 0; i < t; i++)
if (k[i] == kk) {
if (x[i] % P[0] == 0 or x[i] % P[1] == 0)
ans[i] = true;
else {
long long a = (x[i] % P[1]) * power(P[0], P[1] - 2, P[1]) % P[1];
if (a * P[0] <= x[i]) ans[i] = true;
}
}
} else {
memset(dis, 31, sizeof dis);
set<pair<int, int> > s;
dis[0] = 0;
s.insert({dis[0], 0});
while (s.size()) {
int v = s.begin()->second;
s.erase(s.begin());
for (int j = 1; j < P.size(); j++) {
int u = (v + P[j]) % P[0];
if (dis[u] > dis[v] + P[j]) {
s.erase({dis[u], u});
dis[u] = dis[v] + P[j];
s.insert({dis[u], u});
}
}
}
for (int i = 0; i < t; i++)
if (k[i] == kk and dis[x[i] % P[0]] <= x[i]) ans[i] = true;
}
}
for (int i = 0; i < t; i++) cout << (ans[i] ? "YES" : "NO") << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Q;
long long qx[10010], qn[10010];
int ans[10010];
int K;
vector<long long> item;
long long dist[1000010];
priority_queue<pair<long long, int> > q;
bool used[1000010];
bool isp[32000000];
vector<int> primes;
void pre(void) {
int i;
int p = item[0];
for ((i) = 0; (i) < (int)(p); (i)++) dist[i] = (1ll << 60);
dist[0] = 0;
q.push(make_pair(0ll, 0));
for ((i) = 0; (i) < (int)(p); (i)++) used[i] = false;
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (used[x]) continue;
used[x] = true;
for (i = 1; i < K; i++) {
long long d = dist[x] + item[i];
int y = (x + item[i]) % p;
if (d < dist[y]) {
dist[y] = d;
q.push(make_pair(-d, y));
}
}
}
}
long long mod_inv(long long M, long long x) {
if (x == 1) return 1;
long long y = mod_inv(x, M % x);
return M - (y * (M % x) / x + M / x * y) % M;
}
bool check(long long p, long long q, long long x) {
long long a = x % p;
long long b = q % p;
b = mod_inv(p, b);
long long c = a * b % p;
return (c <= x / q);
}
bool check(long long x) {
if (K == 0) return false;
if (K == 1) return (x % item[0] == 0);
long long p = item[0];
long long q = item[1];
if (K == 2) return check(p, q, x);
return (x >= dist[x % p]);
}
void main2(long long N) {
int i;
item.clear();
long long n = N;
for ((i) = 0; (i) < (int)(primes.size()); (i)++) {
int p = primes[i];
if (n % p == 0) {
while (n % p == 0) n /= p;
item.push_back(p);
}
}
if (n > 1) item.push_back(n);
K = item.size();
sort(item.begin(), item.end());
if (K >= 3) pre();
for ((i) = 0; (i) < (int)(Q); (i)++)
if (qn[i] == N) ans[i] = (check(qx[i]) ? 1 : -1);
}
int main(void) {
int i, j;
for (i = 2; i < 32000000; i++) isp[i] = true;
for (i = 2; i < 32000000; i++)
if (isp[i]) {
for (j = 2 * i; j < 32000000; j += i) isp[j] = false;
primes.push_back(i);
}
cin >> Q;
for ((i) = 0; (i) < (int)(Q); (i)++) cin >> qx[i] >> qn[i];
for ((i) = 0; (i) < (int)(Q); (i)++)
if (ans[i] == 0) {
main2(qn[i]);
}
for ((i) = 0; (i) < (int)(Q); (i)++)
if (ans[i] > 0) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max_Val = 4e7, Max_S = 1e5, Max_T = 1e4;
const long long Inf = (1e18) + 1;
int t, cnt, m, Cnt, Num, Prime[Max_Val / 3 + 5], vis[Max_Val + 5],
lin[Max_S + 5], ans[Max_T + 5];
long long n, k, d[55], p[20], dis[Max_S + 5];
vector<pair<long long, int> > A[55];
priority_queue<pair<long long, int> > Q;
struct kk {
int Id, Next;
long long v;
} e[Max_S * 15 + 5];
inline void Insert(int x, int y, long long z) {
e[++Num].Next = lin[x];
lin[x] = Num;
e[Num].Id = y;
e[Num].v = z;
}
inline void Get_Prime() {
for (int i = 2; i <= Max_Val; i++) {
if (!vis[i]) Prime[++cnt] = i;
for (int j = 1; j <= cnt && i * Prime[j] <= Max_Val; j++) {
vis[i * Prime[j]] = 1;
if (i % Prime[j] == 0) break;
}
}
}
inline long long Exgcd(long long &x, long long &y, long long a, long long b) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long d = Exgcd(x, y, b, a % b);
long long t = x;
x = y;
y = t - a / b * y;
return d;
}
inline void Dijkstra() {
for (int i = 0; i < p[1]; i++) dis[i] = Inf;
dis[0] = 0;
Q.push(make_pair(0, 0));
for (; Q.size();) {
int x = Q.top().second;
Q.pop();
for (int i = lin[x]; i; i = e[i].Next)
if (dis[x] + e[i].v < dis[e[i].Id]) {
dis[e[i].Id] = dis[x] + e[i].v;
Q.push(make_pair(-dis[e[i].Id], e[i].Id));
}
}
}
inline void Work(int x) {
long long val = d[x];
Cnt = 0;
for (int j = 1; j <= cnt && Prime[j] <= val; j++)
if (val % Prime[j] == 0) {
p[++Cnt] = Prime[j];
for (; val % Prime[j] == 0; val /= Prime[j])
;
}
if (val > 1) p[++Cnt] = val;
if (Cnt == 0) {
for (int i = 0; i < A[x].size(); i++) ans[A[x][i].second] = 0;
return;
}
if (Cnt == 1) {
for (int i = 0; i < A[x].size(); i++)
if (A[x][i].first % p[1] == 0) ans[A[x][i].second] = 1;
return;
}
if (Cnt == 2) {
long long s1 = 0, s2 = 0, a = p[1], b = p[2];
long long Gcd = Exgcd(s1, s2, p[1], p[2]);
for (int i = 0; i < A[x].size(); i++) {
long long v1 = s1, v2 = s2;
v1 = (A[x][i].first % b * v1 % b + b) % b;
v2 = (A[x][i].first % a * v2 % a + a) % a;
if (v1 * a + v2 * b <= A[x][i].first) ans[A[x][i].second] = 1;
}
return;
}
for (int i = 0; i < p[1]; i++)
for (int j = 2; j <= Cnt; j++) Insert(i, (i + p[j]) % p[1], p[j]);
Dijkstra();
for (int i = 0; i < A[x].size(); i++)
if (dis[A[x][i].first % p[1]] <= A[x][i].first) ans[A[x][i].second] = 1;
for (int i = 0; i < p[1]; i++) lin[i] = 0;
Num = 0;
}
int main() {
scanf("%d", &t);
Get_Prime();
for (int i = 1; i <= t; i++) {
scanf("%lld%lld", &n, &k);
int flg = 0;
for (int j = 1; j <= m; j++)
if (d[j] == k) flg = 1;
if (!flg) d[++m] = k;
for (int j = 1; j <= m; j++)
if (d[j] == k) A[j].push_back(make_pair(n, i));
}
for (int i = 1; i <= m; i++) Work(i);
for (int i = 1; i <= t; i++) ans[i] ? puts("YES") : puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long nxt, to, val;
} o[100010 * 30];
long long cas, T, n, k, x, y, ver, pr[2146776], p[51][50], head[100010], I,
dis[51][100010], vis[100010];
bitset<35000000> usd;
map<long long, long long> mp;
void make(long long m) {
for (long long i = 2; i <= m; i++) {
if (!usd[i]) pr[++pr[0]] = i;
for (long long j = 1; i * pr[j] <= m && j <= pr[0]; j++) {
usd[i * pr[j]] = 1;
if (i % pr[j] == 0) break;
}
}
}
void add(long long u, long long v, long long w) {
o[++I] = (edge){head[u], v, w};
head[u] = I;
}
void exgcd(long long a, long long b) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b);
long long t = x;
x = y;
y = t - a / b * x;
}
struct node {
long long dist, id;
friend bool operator<(node a, node b) { return a.dist > b.dist; }
};
void dijkstra(long long pos) {
priority_queue<node> q;
memset(vis, 0, sizeof(vis));
for (long long i = 0; i <= 100000; i++) dis[pos][i] = 7000000000000000000ll;
q.push((node){dis[pos][0] = 0, 0});
while (!q.empty()) {
node tt = q.top();
q.pop();
long long now = tt.id;
if (vis[now]) continue;
vis[now] = 1;
for (long long i = head[now]; i != -1; i = o[i].nxt) {
long long t = o[i].to;
if (dis[pos][t] > dis[pos][now] + o[i].val)
q.push((node){dis[pos][t] = dis[pos][now] + o[i].val, t});
}
}
}
void init() {
mp[k] = ++ver;
memset(head, -1, sizeof(head)), I = 0;
memset(&o, 0, sizeof(o));
for (long long i = 1; pr[i] * pr[i] <= k; i++) {
if (k % pr[i]) continue;
p[ver][++p[ver][0]] = pr[i];
while (k % pr[i] == 0) k /= pr[i];
}
if (k != 1) p[ver][++p[ver][0]] = k;
if (p[ver][0] < 3) return;
for (long long i = 0; i < p[ver][1]; i++) {
for (long long j = 1; j <= p[ver][0]; j++)
add(i, (i + p[ver][j]) % p[ver][1], p[ver][j]);
}
dijkstra(ver);
}
signed main() {
scanf("%lld", &T);
make(35000000);
while (T--) {
long long V;
scanf("%lld%lld", &n, &k);
if (!mp.count(k))
init(), V = ver;
else
V = mp[k];
if (k == 1) {
puts("NO");
continue;
}
if (p[V][0] == 1) {
puts(n % p[V][1] ? "NO" : "YES");
continue;
}
if (p[V][0] == 2) {
exgcd(p[V][1], p[V][2]);
x = (n % p[V][2] * x % p[V][2] + p[V][2]) % p[V][2];
if (n / p[V][1] >= x)
puts("YES");
else
puts("NO");
continue;
}
if (n < p[V][1] || dis[V][n % p[V][1]] > n)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#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>
#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 x, long long y, long long mod) {
bool q = (x < 0) ^ (y < 0);
x = abs(x) % mod, y = abs(y) % mod;
long long ret = x * y - (long long)((long double)x * y / mod + 0.5L) * mod;
ret = ret < 0 ? ret + mod : ret;
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;
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[100];
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>
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);
b = (b % fac[1] + fac[1]) % fac[1];
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 = b * (x.first % fac[1]) % fac[1] * fac[2];
ans[x.second] = c <= x.first;
a = -a;
} 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 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 = 2; 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 std ::pair;
using std ::priority_queue;
using std ::sort;
template <typename T>
T max(T x, T y) {
return (x > y) ? x : y;
}
template <typename T>
T min(T x, T y) {
return (x < y) ? x : y;
}
template <typename T>
bool chkmax(T &x, T y) {
return (x >= y) ? 0 : (x = y, 1);
}
template <typename T>
bool chkmin(T &x, T y) {
return (x <= y) ? 0 : (x = y, 1);
}
template <typename T>
T read(T &in) {
in = 0;
char ch;
T f = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
while (isdigit(ch)) in = in * 10 + ch - '0', ch = getchar();
return in *= f;
}
static const int MAX1 = 10000 + 11;
static const int MAX2 = 32000000 + 11;
static const int MAX3 = 100000 + 11;
struct data {
long long n, k;
int i;
};
bool operator<(data a, data b) { return a.k < b.k; }
int T;
data q[MAX1];
bool out[MAX1];
bool vis[MAX2];
int prime[1973816];
void Init(int n = 32000000) {
for (int i = (2), ir = (n); i <= (ir); ++i) {
if (!vis[i]) prime[++prime[0]] = i;
for (int j = (1), jr = (prime[0]); j <= (jr); ++j) {
if (i * prime[j] > n) break;
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
long long Exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) return x = 1, y = 0, a;
long long g = Exgcd(b, a % b, x, y), tx = x;
x = y, y = tx - a / b * y;
return g;
}
void work(long long k, int &id) {
static long long p[60];
int cnt = 0;
long long temp_k = k;
for (int *i = prime + 1; 1ll * *i * *i <= k; ++i)
if (k % *i == 0) {
while (k % *i == 0) k /= *i;
p[++cnt] = *i;
}
if (k != 1) p[++cnt] = k;
k = temp_k;
if (cnt == 0)
while (id <= T && q[id].k == k) out[q[id].i] = false, ++id;
else if (cnt == 1)
while (id <= T && q[id].k == k) out[q[id].i] = (q[id].n % k == 0), ++id;
else if (cnt == 2) {
long long x, y;
long long g = Exgcd(p[1], p[2], x, y);
y = (y % p[1] + p[1]) % p[1];
while (id <= T && q[id].k == k)
out[q[id].i] = (q[id].n % p[1] * y % p[1] * p[2] <= q[id].n), ++id;
} else {
static long long d[MAX3];
static bool vis[MAX3];
memset(d, 0x3f, sizeof(long long) * (p[1] + 1));
memset(vis, 0, sizeof(bool) * (p[1] + 1));
priority_queue<pair<long long, int> > Q;
Q.push(pair<long long, int>(d[0] = 0, 0));
while (!Q.empty()) {
int x = Q.top().second;
Q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = (2), ir = (cnt); i <= (ir); ++i) {
int y = (x + p[i]) % p[1];
if (chkmin(d[y], d[x] + p[i])) Q.push(pair<long long, int>(-d[y], y));
}
}
while (id <= T && q[id].k == k)
out[q[id].i] = (d[q[id].n % p[1]] <= q[id].n), ++id;
}
}
int main() {
Init();
read(T);
for (int i = (1), ir = (T); i <= (ir); ++i)
read(q[i].n), read(q[i].k), q[i].i = i;
sort(1 + q, 1 + T + q);
int i = 1;
while (i <= T) work(q[i].k, i);
for (int i = (1), ir = (T); i <= (ir); ++i) puts(out[i] ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 2e6 + 5, S = 31624000;
int tot;
long long n, k, dis[N], p[M];
bool vis[N], is[S];
vector<long long> ans[55], res[55];
vector<pair<int, int> > e[N];
unordered_map<long long, int> use;
queue<long long> q;
inline void init() {
for (int i = 2; i < S; i++) {
if (!is[i]) p[++p[0]] = i;
for (int j = 1; j <= p[0] && i * p[j] < S; j++) {
is[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
}
inline void build(int x) {
long long m = res[x][0];
for (int i = 0; i < m; i++) {
e[i].clear();
for (auto& j : res[x]) e[i].push_back(make_pair((i + j) % m, j));
}
memset(dis, 0x7f, sizeof(dis));
dis[0] = 0;
q.push(0);
while (!q.empty()) {
long long u = q.front();
q.pop();
vis[u] = 0;
for (auto i : e[u]) {
long long v = i.first, w = i.second;
if (dis[u] + w < dis[v]) {
dis[v] = dis[u] + w;
if (!vis[v]) vis[v] = 1, q.push(v);
}
}
}
for (int i = 0; i < m; i++) ans[x].push_back(dis[i]);
}
inline int div(long long x) {
tot++;
for (long long i = 1; p[i] * p[i] <= x; i++) {
if (x % p[i] == 0) {
res[tot].push_back(p[i]);
while (x % p[i] == 0) x /= p[i];
}
}
if (x != 1) res[tot].push_back(x);
if (res[tot].size() >= 3) build(tot);
return tot;
}
inline long long fpow(long long x, long long y, long long p) {
long long val = 1;
for (; y; y >>= 1, x = x * x % p)
if (y & 1) val = val * x % p;
return val;
}
signed main() {
init();
int T;
scanf("%d", &T);
while (T--) {
scanf("%lld%lld", &n, &k);
int& x = use[k];
if (!x) x = div(k);
if (k == 1) {
puts("NO");
continue;
}
if (res[x].size() == 1) {
puts(n % res[x][0] ? "NO" : "YES");
continue;
}
if (res[x].size() == 2) {
long long a = res[x][0], b = res[x][1];
long long c = n % a * fpow(b, a - 2, a) % a;
puts(b * c <= n ? "YES" : "NO");
continue;
}
puts(n < res[x][0] || n < ans[x][n % res[x][0]] ? "NO" : "YES");
}
return 0;
}
|
#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>
long long x, y;
const int maxn = 33333333;
bool flag[maxn + 100];
int prm[2222222], top;
void primer() {
register int i, ii;
for (i = 2; i <= maxn; i++)
if (!flag[i]) {
prm[++top] = i;
for (ii = i; ii <= maxn / i; ii++) flag[i * ii] = 1;
}
}
inline void exgcd(long long a, long long b) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b);
long long t = x;
x = y, y = t - (a / b) * y;
}
struct pii {
long long x, k;
int Id;
};
inline bool operator<(const pii x, const pii y) { return x.k < y.k; }
long long pr[11111];
int tpr;
inline bool split(long long x) {
tpr = 0;
for (register int i = 1; i <= top; i++)
if (x % prm[i] == 0) {
pr[++tpr] = prm[i];
while (x % prm[i] == 0) x /= prm[i];
}
if (x > 1) pr[++tpr] = x;
return tpr;
}
pii arg[11111];
bool ans[11111];
long long lst = -1;
struct edg {
int p, t, l;
} e[2222222];
int h[111111], tot;
inline void build(int x, int y, int l) {
e[++tot] = (edg){h[x], y, l}, h[x] = tot;
}
long long dis[111111];
bool vis[111111];
struct piii {
int x;
long long v;
};
inline bool operator<(const piii x, const piii y) { return x.v > y.v; }
std::priority_queue<piii> q;
void dij(int S) {
register int i;
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
dis[S] = 0;
q.push((piii){S, 0});
while (q.size()) {
int p = q.top().x;
q.pop();
if (vis[p]) continue;
vis[p] = 1;
for (i = h[p]; i; i = e[i].p) {
int to = e[i].t;
if (dis[to] > dis[p] + e[i].l)
dis[to] = dis[p] + e[i].l, q.push((piii){to, dis[to]});
}
}
}
inline long long mul(long long x, long long y, long long p) {
long long s = 0;
for (; y; y >>= 1, (x += x) %= p)
if (y & 1) (s += x) %= p;
return s;
}
void query(long long k, long long n, int Id) {
long long g;
if (k == 1) {
ans[Id] = 0;
return;
}
if (lst ^ k) split(k);
if (tpr == 1)
ans[Id] = (n % pr[1] == 0);
else if (tpr == 2) {
exgcd(pr[1], pr[2]), g = (x % pr[2] + pr[2]) % pr[2], g = mul(g, n, pr[2]);
if (g > n / pr[1])
ans[Id] = 0;
else
ans[Id] = 1;
} else {
memset(h, 0, sizeof(h)), tot = 0;
if (lst ^ k) {
register int i, ii;
for (i = 0; i < pr[1]; i++)
for (ii = 2; ii <= tpr; ii++) build(i, (i + pr[ii]) % pr[1], pr[ii]);
dij(0);
}
ans[Id] = dis[n % pr[1]] <= n;
}
lst = k;
}
int qq;
int main() {
scanf("%d", &qq);
primer();
register int i;
for (i = 1; i <= qq; i++)
scanf("%lld%lld", &arg[i].x, &arg[i].k), arg[i].Id = i;
std::sort(arg + 1, arg + qq + 1);
for (i = 1; i <= qq; i++) query(arg[i].k, arg[i].x, arg[i].Id);
for (i = 1; i <= qq; i++) puts(ans[i] ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int BASE = 243 * 27;
const double EPS = 1e-7;
const int MAX = 32000000;
bool R[10007];
int P[MAX];
long long bpow(long long a, long long k, int mod) {
a %= mod;
long long res = 1;
while (k) {
if (k & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
k /= 2;
}
return res;
}
long long d[100007];
void dijkstra(vector<long long> p) {
int a = p[0];
for (int i = (0); i < (a); ++i) {
d[i] = 1LL * INF * INF;
}
d[0] = 0;
set<pair<long long, int> > S;
S.insert(make_pair(0, 0));
while ((int)S.size()) {
pair<long long, int> pr = *S.begin();
S.erase(S.begin());
int v = pr.second;
for (int i = (1); i < ((int)p.size()); ++i) {
int to = (v + p[i]) % a;
if (d[to] > d[v] + p[i]) {
S.erase(make_pair(d[to], to));
d[to] = d[v] + p[i];
S.insert(make_pair(d[to], to));
}
}
}
}
int main() {
for (int i = 2; i * i < MAX; ++i)
if (!P[i])
for (int j = i * i; j < MAX; j += i) P[j] = 1;
vector<int> pr;
for (int i = (2); i < (MAX); ++i)
if (!P[i]) pr.push_back(i);
int t;
cin >> t;
vector<pair<pair<long long, long long>, int> > A;
for (int i = (0); i < (t); ++i) {
long long n, k;
cin >> n >> k;
A.push_back(make_pair(make_pair(k, n), i));
}
sort(A.begin(), A.end());
int pos = 0;
while (pos < t) {
int add = 1;
while (pos + add < (int)A.size() &&
A[pos + add].first.first == A[pos].first.first)
++add;
long long k = A[pos].first.first;
vector<long long> p;
for (int i = (0); i < ((int)pr.size()); ++i) {
if ((long long)pr[i] * pr[i] > k) break;
if (k % pr[i] == 0) {
p.push_back(pr[i]);
while (k % pr[i] == 0) k /= pr[i];
}
}
if (k != 1) p.push_back(k);
sort(p.begin(), p.end());
if (p.size() == 0) {
pos += add;
continue;
}
if (p.size() == 1) {
for (int i = (pos); i < (pos + add); ++i) {
long long n = A[i].first.second;
if (n % p[0] == 0) {
R[A[i].second] = true;
}
}
pos += add;
continue;
}
if (p.size() == 2) {
for (int i = (pos); i < (pos + add); ++i) {
long long n = A[i].first.second;
long long y = (n % p[0]) * bpow(p[1], p[0] - 2, p[0]) % p[0];
if (n >= y * p[1]) {
R[A[i].second] = true;
}
}
pos += add;
continue;
}
dijkstra(p);
for (int i = (pos); i < (pos + add); ++i) {
long long n = A[i].first.second;
if (d[n % p[0]] <= n) {
R[A[i].second] = true;
}
}
pos += add;
}
for (int i = (0); i < (t); ++i) {
if (R[i]) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void clampmod(long long &a, long long mod) {
a %= mod;
if (a < 0) a += mod;
}
long long mulmod(long long a, long long b, long long mod) {
clampmod(a, mod);
clampmod(b, mod);
long long res = 0;
while (b != 0) {
if (b & 1LL) {
res = (res + a) % mod;
}
a = (a * 2) % mod;
b /= 2;
}
return res;
}
long long powmod(long long x, long long e, long long mod) {
if (e == 0) {
return 1LL;
}
long long h = powmod(x, e / 2, mod);
if (e % 2 == 0) {
return mulmod(h, h, mod);
} else {
return mulmod(x, mulmod(h, h, mod), mod);
}
}
struct query_t {
long long n, k;
int id;
bool operator<(const query_t &x) const {
return k != x.k ? k < x.k : id < x.id;
}
} query[10004];
bool ans[10004];
vector<long long> allprimes;
const long long HIGH = 31622800;
bitset<HIGH> isprime;
void sieve() {
isprime.set();
for (long long i = 2; i * i < HIGH; ++i) {
if (isprime[i]) {
for (long long j = i * i; j < HIGH; j += i) {
isprime[j] = 0;
}
}
}
for (long long i = 2; i < HIGH; ++i) {
if (isprime[i]) {
allprimes.push_back(i);
}
}
}
void factorize(long long k, vector<long long> &primes) {
for (long long p : allprimes) {
if (p * p > k) {
break;
}
if (k % p == 0) {
while (k % p == 0) {
k /= p;
}
primes.push_back(p);
}
}
if (k != 1) {
primes.push_back(k);
}
}
int gsz;
vector<pair<long long, int>> g[100005];
long long dist[100005];
void build_graph(const vector<long long> &primes) {
assert(((int)(primes).size()) >= 3);
gsz = primes[0];
for (int i = 0; i < gsz; ++i) {
g[i].clear();
}
for (int i = 0; i < gsz; ++i) {
for (int j = 1; j < ((int)(primes).size()); ++j) {
int k = (int)((1LL * i + primes[j]) % (1LL * gsz));
g[i].push_back({primes[j], k});
g[k].push_back({primes[j], k});
}
}
}
void dijkstra(int start) {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
pq.push({0, start});
fill(dist, dist + gsz, numeric_limits<long long>::max());
dist[start] = 0;
while (!pq.empty()) {
int u;
long long d;
tie(d, u) = pq.top();
pq.pop();
if (d != dist[u]) continue;
for (auto e : g[u]) {
if (dist[e.second] == numeric_limits<long long>::max() ||
dist[e.second] > e.first + d) {
dist[e.second] = e.first + d;
pq.push({dist[e.second], e.second});
}
}
}
}
void mmain() {
sieve();
int t;
scanf("%d", &t);
for (int i = 0; i < t; ++i) {
scanf("%lld %lld", &query[i].n, &query[i].k);
query[i].id = i;
}
sort(query, query + t);
int lo = 0, hi = 0;
while (lo < t) {
while (hi + 1 < t && query[hi + 1].k == query[lo].k) {
++hi;
}
long long k = query[lo].k;
;
if (k == 1) {
lo = hi + 1;
continue;
}
vector<long long> primes;
factorize(k, primes);
if (((int)(primes).size()) == 1) {
;
for (int i = lo; i <= hi; ++i) {
if (query[i].n % primes[0] == 0) {
ans[query[i].id] = 1;
}
}
} else if (((int)(primes).size()) == 2) {
long long p1 = primes[0], p2 = primes[1];
;
for (int i = lo; i <= hi; ++i) {
if (query[i].n > p1 * p2 - p1 - p2) {
ans[query[i].id] = 1;
} else {
long long inv2 = powmod(p2, p1 - 2, p1);
assert(mulmod(inv2, p2, p1) == 1);
long long y0 = mulmod(query[i].n, inv2, p1);
assert(query[i].n % p1 == mulmod(p2, y0, p1));
long long x0 = (query[i].n - p2 * y0) / p1;
assert(x0 * p1 + y0 * p2 == query[i].n);
;
if (x0 < 0) {
long long toadd = (-x0) % p2 == 0 ? (-x0) / p2 : (-x0) / p2 + 1;
x0 += toadd * p2;
y0 -= toadd * p1;
}
if (y0 < 0) {
long long toadd = (-y0) % p1 == 0 ? (-y0) / p1 : (-y0) / p1 + 1;
y0 += toadd * p1;
x0 -= toadd * p2;
}
if (x0 >= 0 && y0 >= 0) {
ans[query[i].id] = 1;
}
}
}
} else {
;
build_graph(primes);
dijkstra(0);
for (int i = lo; i <= hi; ++i) {
if (query[i].n >= dist[query[i].n % primes[0]]) {
ans[query[i].id] = 1;
}
}
}
lo = hi + 1;
}
for (int i = 0; i < t; ++i) {
if (ans[i]) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
int main() { mmain(); }
|
#include <bits/stdc++.h>
#define maxn 3086
using namespace std;
int n, m, k;
int a[maxn][maxn];
int x, y, z;
long long f[maxn][maxn][4];
inline void Max(long long &x, long long y){
x = max(x, y);
}
int main(){
scanf("%d%d%d", &n, &m, &k);
while(k--){
scanf("%d%d%d", &x, &y, &z);
a[x][y] = z;
}
memset(f, -0x3f, sizeof(f));
f[1][1][0] = 0;
for(int i = 1;i <= n;i++){
for(int j = 1;j <= m;j++){
for(int k = 0;k <= 3;k++){
Max(f[i][j][k], f[i - 1][j][0]);
Max(f[i][j][k], f[i - 1][j][1]);
Max(f[i][j][k], f[i - 1][j][2]);
Max(f[i][j][k], f[i - 1][j][3]);
Max(f[i][j][k], f[i][j - 1][k]);
}
if(a[i][j]) for(int k = 3;k;k--) Max(f[i][j][k], f[i][j][k - 1] + a[i][j]);
}
}
long long ans = -1e18;
for(int i = 0;i <= 3;i++) Max(ans, f[n][m][i]);
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int) (n); i++)
#define rep3(i, s, n) for (int i = (s); i <=(int) (n); i++)
#define chmax(x,y) x = max(x,y)
int a[3005][3005];
long long dp[3005][3005][5];
int main() {
int R,C,n;
cin >> R >> C >> n;
rep(i, n) {
int r,c,v;
cin >> r >> c >> v;
a[r-1][c-1]=v;
}
rep(i,R){
rep(j,C) {
for (int k=2;k>=0; k--){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4) {
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
}
long long ans =0;
rep(k,4) chmax(ans,dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using vll = vector<ll> ;
#define all(v) v.begin(),v.end()
ll dp[3010][3010][4];
ll item[3010][3010];
int main(){
int R,C;ll K;
cin>>R>>C>>K;
rep(i,K){
int r,c;cin>>r>>c;r--,c--;
int v;cin>>v;
item[r][c]=v;
}
dp[0][0][1] = item[0][0];
rep(i,R){
rep(j,C){
rep(k,4){
dp[i+1][j][0] = max(dp[i+1][j][0],dp[i][j][k]);
dp[i+1][j][1] = max(dp[i+1][j][1],dp[i][j][k]+item[i+1][j]);
dp[i][j+1][k] = max(dp[i][j+1][k],dp[i][j][k]);
if(k+1<=3) dp[i][j+1][k+1] = max(dp[i][j+1][k+1], dp[i][j][k] + item[i][j+1]);
}
}
}
cout << *max_element(dp[R-1][C-1], dp[R-1][C-1]+4) << endl;
return 0;
}
|
#include<bits/stdc++.h>
#include<algorithm>
using namespace std;
typedef long long ll;
ll rc[3001][3001];
int r,c,k;
ll dp[3001][3001][4];
int main(){
scanf("%d%d%d",&r,&c,&k);
for(int i=1;i<=k;i++){
int x,y,w;
scanf("%d%d%d",&x,&y,&w);
rc[x][y]=w;
}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
dp[i][j][0]=max(max(dp[i-1][j][0],dp[i-1][j][1]),dp[i-1][j][2])+rc[i][j];
for(int k=0;k<3;k++){
dp[i][j][k]=max(dp[i][j-1][k],dp[i][j][k]);
if(dp[i][j-1][k]==0){
dp[i][j][k]=max(dp[i][j][k],rc[i][j]);
break;
}else{
dp[i][j][k+1]=max(dp[i][j-1][k]+rc[i][j],dp[i][j][k+1]);
}
}
}
}
ll res=0;
for(int i=0;i<3;i++)
res=max(res,dp[r][c][i]);
printf("%lld\n",res);
}
|
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
typedef long long ll;
const int maxn=3010;
ll f[maxn][maxn][4];
ll a[maxn][maxn];
int main()
{
int r,c,k;cin>>r>>c>>k;
while(k--){
int x,y,z;cin>>x>>y>>z;
a[x][y]=z;
}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
for(int t=1;t<=3;t++){
f[i][j][t]=max(f[i-1][j][3]+a[i][j],max(f[i][j-1][t],f[i][j-1][t-1]+a[i][j]));
}
}
}
cout<<f[r][c][3];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
#define repb(i,n,b) for (ll i = b; i < (ll)(n); i++)
#define rep(i,n) repb(i,n,0)
ll dp[3001][3001][4];
ll gds[3001][3001];
int main(){
ll R,C,K;
cin>>R>>C>>K;
rep(i,K){
ll r,c,v;
cin>>r>>c>>v;
gds[r-1][c-1]=v;
}
rep(i,3){
dp[0][0][i]=gds[0][0];
}
dp[0][0][3]=0;
repb(c,C,1){
rep(i,3){
dp[0][c][i]=max(dp[0][c-1][i+1]+gds[0][c],dp[0][c-1][i]);
}
dp[0][c][3]=dp[0][c-1][3];
}
repb(r,R,1){
rep(i,3){
dp[r][0][i]=gds[r][0]+dp[r-1][0][0];
}
dp[r][0][3]=dp[r-1][0][0];
}
repb(r,R,1){
repb(c,C,1){
rep(i,3){
dp[r][c][i]=max(max(dp[r][c-1][i+1]+gds[r][c],dp[r][c-1][i]),dp[r-1][c][0]+gds[r][c]);
}
dp[r][c][3]=max(dp[r][c-1][3],dp[r-1][c][0]);
}
}
cout<<dp[R-1][C-1][0]<<endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmax(x, y) x = max(x, y)
using namespace std;
typedef long long ll;
ll a[3005][3005], dp[3005][3005][4];
int main() {
ll R, C, n, ans = 0, r, c, v;
cin >> R >> C >> n;
rep(i, n) cin >> r >> c >> v, a[r - 1][c - 1] = v;
rep(i, R) rep(j, C) {
for (int k = 2; k >= 0; --k) chmax(dp[i][j][k + 1], dp[i][j][k] + a[i][j]);
rep(k, 4) {
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
rep(k, 4) chmax(ans, dp[R - 1][C - 1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int MOD=1000000007;
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
ll dp[5000][5000][4];
int val[5000][5000];
int main(){
int h,w,K;cin>>h>>w>>K;
rep(i,K){
int r,c,v;scanf("%d%d%d",&r,&c,&v);r--;c--;
val[r][c]=v;
}
rep(i,h)rep(j,w)rep(k,4){
//pick
if(k<=2){
if(i+1<h)dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]+val[i][j]);
if(j+1<w)dp[i][j+1][k+1]=max(dp[i][j+1][k],dp[i][j][k]+val[i][j]);
}
if(i+1<h)dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
if(j+1<w)dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
}
ll Max=0;
rep(k,4){
if(k<=2)Max=max(Max,dp[h-1][w-1][k]+val[h-1][w-1]);
else Max=max(Max,dp[h-1][w-1][k]);
}
cout<<Max<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int n,k,mm[3030][3030],m;
long long f[3030][3030][4];
int main() {
int r,v,c;
scanf("%d%d%d",&n,&m,&k);
for (int i = 1;i <= k; i++) {
scanf("%d%d%d",&r,&c,&v);
mm[r][c] = v;
}
for (int i = 1;i <= n; i++)
for (int j = 1;j <= m; j++) {
f[i][j][0] = max(f[i][j-1][0],f[i-1][j][3]);
f[i][j][1] = f[i][j][0];
f[i][j][1] = max(f[i][j][1],f[i][j][0]+mm[i][j]);
f[i][j][1] = max(f[i][j][1],f[i][j-1][1]);
f[i][j][2] = f[i][j][1];
f[i][j][2] = max(f[i][j][2],f[i][j-1][1]+mm[i][j]);
f[i][j][2] = max(f[i][j][2],f[i][j-1][2]);
f[i][j][3] = f[i][j][2];
f[i][j][3] = max(f[i][j][3],f[i][j-1][2]+mm[i][j]);
f[i][j][3] = max(f[i][j][3],f[i][j-1][3]);
}
printf("%lld\n",f[n][m][3]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[3010][3010][4];
int r, c, k;
int v[3010][3010];
int main() {
scanf("%d%d%d", &r, &c, &k);
while (k--) {
int x, y; scanf("%d%d", &x, &y);
scanf("%d", &v[x][y]);
}
for (int i = 1; i <= r; ++i)
for (int j = 1; j <= c; ++j) {
f[i][j][0] = max(f[i][j - 1][0], f[i - 1][j][3]);
for (int k = 1; k <= 3; ++k)
f[i][j][k] = max(f[i][j][k - 1],
max(f[i][j - 1][k],
max(f[i][j - 1][k - 1],
f[i - 1][j][3]) + v[i][j]));
}
printf("%lld\n", f[r][c][3]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define sz(x) ((int)(x.size()))
int n, m, k;
long long a[3000][3000];
long long dp[3000][3000][4];
long long memo(int x, int y, int r) {
if(x < 0 || y < 0) return 0;
if(dp[x][y][r] != -1) return dp[x][y][r];
long long res = memo(x-1, y, 3);
res = max(res, memo(x, y-1, r));
if(r > 0) res = max(res, a[x][y] + max(memo(x, y-1, r-1), memo(x-1, y, 3)));
return dp[x][y][r] = res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
cin >> n >> m >> k;
for(int i=0; i<k; i++) {
int x, y, c;
cin >> x >> y >> c;
a[x-1][y-1] = c;
}
memset(dp, -1, sizeof dp);
cout << memo(n-1, m-1, 3) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
using ll = long long;
int h, w, k, vs[3005][3005], r, c, v;
ll dp[3005][3005][4];
inline void chmax(ll &a, ll b){if(a<b) a=b;}
int main(){
scanf("%d%d%d", &h, &w, &k);
rep(i,k){
scanf("%d%d%d", &r, &c, &v);
vs[r-1][c-1] = v;
}
dp[0][0][1] = vs[0][0];
rep(i,h) rep(j,w){
ll m = 0;
rep(l,4){
chmax(m, dp[i][j][l]);
chmax(dp[i][j+1][l], dp[i][j][l]);
if(l) chmax(dp[i][j+1][l], dp[i][j][l-1]+vs[i][j+1]);
}
dp[i+1][j][0] = m;
dp[i+1][j][1] = m + vs[i+1][j];
}
ll ans = 0;
rep(l,4) chmax(ans,dp[h-1][w-1][l]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x, y) x = max(x, y)
int a[3005][3005];
ll dp[3005][3005][4];
int main(){
ll R, C, k;
cin >> R >> C >> k;
rep(i, k){
int r, c, v;
cin >> r >> c >> v;
a[r-1][c-1] = v;
}
rep(i, R) rep(j, C){
for (int k=2; k>=0; k--){
chmax(dp[i][j][k+1], dp[i][j][k]+a[i][j]);
}
rep(k, 4){
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k, 4) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3005][3005][4];
long long item[3005][3005];
int main() {
int r, c, k;
cin >> r >> c >> k;
for ( int i = 0; i < k; i++ ) {
int ri, ci;
long long vi;
cin >> ri >> ci >> vi;
item[ri][ci] = vi;
}
for ( int i = 1; i <= r; i++ ) {
for ( int j = 1; j <= c; j++ ) {
for ( int l = 3; l > 0; l-- ) {
dp[i][j][l] = max(dp[i][j][l], dp[i][j][l-1]+item[i][j]);
}
for ( int l = 0; l < 4; l++ ) {
dp[i+1][j][0] = max(dp[i+1][j][0], dp[i][j][l]);
dp[i][j+1][l] = max(dp[i][j+1][l], dp[i][j][l]);
}
}
}
long long ans = 0;
for ( int l = 0; l < 4; l++ ) {
ans = max(ans, dp[r][c][l]);
}
cout << ans << endl;;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define chmax(x,y) x = max(x,y)
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, n;
cin >> R >> C >> n;
rep(i,n) {
int r, c, v;
cin >> r >> c >> v;
a[r-1][c-1] = v;
}
rep(i,R)rep(j,C) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k+1], dp[i][j][k]+a[i][j]);
}
rep(k,4) {
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k,4) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, m, k, a[N][N];
long long dp[N][N][4];
long long yo(int i, int j, int k) {
if (i > n || j > m) return 0;
long long &ret = dp[i][j][k];
if (ret != -1) return ret;
long long ans = yo(i + 1, j, 0) + (k < 3 ? a[i][j] : 0);
if (k < 3) ans = max(ans, yo(i, j + 1, k + 1) + a[i][j]);
ans = max(ans, yo(i, j + 1, k));
return ret = ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int r, c, x; cin >> r >> c >> x;
a[r][c] = x;
}
memset(dp, -1, sizeof dp);
cout << yo(1, 1, 0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
template<typename T>
void chmax(T &a,T b){
if(a<b)a=b;
}
int R,C,K,r,c,v,d[3123][3123],memo[3123][3123][5];
int f(int y,int x,int cnt){
if(cnt<0||y<0||x<0)return -1e18;
if(~memo[y][x][cnt])return memo[y][x][cnt];
int res=f(y,x,cnt-1);
chmax(res,f(y-1,x,3));
if(cnt)chmax(res,f(y-1,x,3)+d[y][x]);
chmax(res,f(y,x-1,cnt));
chmax(res,f(y,x-1,cnt-1)+d[y][x]);
return memo[y][x][cnt]=res;
}
signed main(){
memset(memo,-1,sizeof(memo));
memo[0][0][0]=0;
cin>>R>>C>>K;
while(K--){
cin>>r>>c>>v;
d[r][c]=v;
}
cout<<f(R+1,C+1,0)<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int r, c, k;
int grid[3005][3005];
long long memo[3005][3005][5];
long long dp(int i, int j, int rem) {
if (memo[i][j][rem] != -1) return memo[i][j][rem];
long long cur = 0;
if (rem == 0) {
if (i <= r) return memo[i][j][rem] = dp(i + 1, j, 3);
else return 0;
}
if (j <= c) cur = max(dp(i, j + 1, rem), dp(i, j + 1, rem - 1) + grid[i][j]);
if (i <= r) cur = max(cur, dp(i + 1, j, 3) + grid[i][j]);
return memo[i][j][rem] = cur;
}
int main() {
scanf("%d%d%d", &r, &c, &k);
for (int i = 0; i < k; i++) {
int r1, c1, v1; scanf("%d%d%d", &r1, &c1, &v1);
grid[r1][c1] = v1;
}
memset(memo, -1, sizeof memo);
printf("%lld\n", dp(1, 1, 3));
return 0;
}
|
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
int main(void){
int R,C,K; cin>>R>>C>>K;
vector<vector<ll>> rcv(R+1,vector<ll>(C+1,0));
for(int i=0; i<K; ++i){ int r,c; cin>>r>>c; cin>>rcv[r][c];}
vector<vector<vector<ll>>> dp(R+2,vector<vector<ll>>(C+2,vector<ll>(4,0)));
for(int i=1; i<=R; ++i) for(int j=1; j<=C; ++j){
for(int k=3; k>0; --k) dp[i][j][k]=max(dp[i][j][k],dp[i][j][k-1]+rcv[i][j]);
for(int k=0; k<4; ++k){
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
}
}
cout<<dp[R+1][C][0];
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,s,n) for (int i = s; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
using pq = priority_queue<ll, vector<ll>, greater<ll>>;
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll dp[3010][3010][4];
int main() {
int r,c,K;
cin >> r >> c >> K;
vector<vector<ll>> field(r+1,vector<ll>(c+1,0));
rep(i,0,K) {
int ri,ci; ll v;
cin >> ri >> ci >> v;
field[ri][ci] = v;
}
rep(i,1,r+1) rep(j,1,c+1) rep(k,0,4) {
if (k > 0) {
chmax(dp[i][j][k],dp[i][j-1][k-1] + field[i][j]);
}
chmax(dp[i][j][k],dp[i][j-1][k]);
chmax(dp[i][j][1],dp[i-1][j][k] + field[i][j]);
}
ll ans = 0;
rep(k,0,4) {
chmax(ans,dp[r][c][k]);
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <map>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i = 0; i < int(n);i++)
ll dp[3010][3010][4];
ll cost[3010][3010];
int main(){
int r,c,k;
cin >> r >> c >> k;
rep(i,k){
int x,y;
ll z;
cin >> x >> y >> z;
x--;y--;
cost[x][y] = z;
}
rep(i,r)rep(j,c){
for (int h = 2; h >= 0;h--){
dp[i][j][h+1] = max(dp[i][j][h+1],dp[i][j][h] + cost[i][j]);
}
rep(h,4){
dp[i+1][j][0] = max(dp[i+1][j][0],dp[i][j][h]);
dp[i][j+1][h] = max(dp[i][j+1][h],dp[i][j][h]);
}
}
ll ans = 0;
for (int i = 0; i <= 3;i++){
ans = max(ans,dp[r-1][c-1][i]);
}
cout << ans << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define ll long long
#define rep(i,n) for(int i = 0;i < (n); i++)
#define mod 1000000007
#define chmax(x,y) x=max(x,y)
//2020/9/16 @ST
int d[3005][3005] = { 0 };
ll dp[3005][3005][4] = { 0 };
int main() {
int r, c, k;
cin >> r >> c >> k;
rep(i, k) {
int rk, ck, vk;
cin >> rk >> ck >> vk;
d[rk - 1][ck - 1] = vk;
}
rep(i, r) rep(j, c) {
for (int l = 2; l >= 0; l--) {
chmax(dp[i][j][l + 1], dp[i][j][l] + d[i][j]);
}
rep(l, 4) {
chmax(dp[i + 1][j][0], dp[i][j][l]);
chmax(dp[i][j + 1][l], dp[i][j][l]);
}
}
ll ans = 0;
rep(l, 4)chmax(ans, dp[r - 1][c - 1][l]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define M 1000000007
#define INF ((1LL<<62LL) - 1)
const int N = 3005;
int a[N][N];
int dp[N][N][4];
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int r,c,k; cin >> r >> c >> k;
for(int i=0;i<k;i++){
int x,y,c; cin >> x >> y >> c;
a[x][y] = c;
}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
dp[i][j][0] = max(dp[i][j-1][0], dp[i-1][j][0]);
for(int type = 1;type<=3;type++){
dp[i][j][type] = a[i][j] + max(dp[i-1][j][3], dp[i][j-1][type-1]);
dp[i][j][type] = max(dp[i][j][type], dp[i][j-1][type]);
}
}
}
cout << dp[r][c][3] << "\n";
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3105][3105][5];
ll ara[3105][3105];
ll n,m,k;
ll call(ll i,ll j,ll tot)
{
if(i>n || j>m )
return 0;
ll &sum=dp[i][j][tot];
if(~sum)
return sum;
sum=0;
if(tot==3)
{
sum=(call(i+1,j,0));
}
else
{
if(ara[i][j]!=0)
{
sum=max(call(i,j+1,tot),max(ara[i][j]+call(i,j+1,tot+1),ara[i][j]+call(i+1,j,0)));
}
else
{
sum=max(call(i+1,j,0),call(i,j+1,tot));
}
}
return sum;
}
int main()
{
cin>>n>>m>>k;
ll a,b,c;
while(k--)
{
cin>>a>>b>>c;
ara[a][b]=c;
}
memset(dp,-1,sizeof(dp));
cout<<call(0,0,0)<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int R,C,K;
long long r[200005],c[200005],v[200005];
long long a[3005][3005];
long long f[3005][3005][4];
int main()
{
scanf("%d%d%d",&R,&C,&K);
for(int i=1;i<=K;++i)
{
scanf("%lld%lld%lld",&r[i],&c[i],&v[i]);
a[r[i]][c[i]]+=v[i];
}
for(int i=1;i<=R;++i)
{
for(int j=1;j<=C;++j)
{
for(int k=1;k<=3;++k)
{
if(k==1)
{
for(int s=1;s<=3;++s)
f[i][j][k]=max(f[i][j][k],f[i-1][j][s]+a[i][j]);
}
f[i][j][k]=max(f[i][j][k],f[i][j-1][k]);
f[i][j][k]=max(f[i][j][k],f[i][j-1][k-1]+a[i][j]);
}
}
}
long long ans=0;
for(int i=1;i<=3;++i)
ans=max(ans,f[R][C][i]);
printf("%lld\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
vector<ll>vec;
ll val[3009][3009];
ll dp[3009][3009][4];
ll n,m;
ll call(ll a,ll b,ll c)
{
if(b>m)
{
return 0;
}
if(a>n)
{
return 0;
}
if(dp[a][b][c]!=-1)
{
return dp[a][b][c];
}
ll x,y;
x=y=0;
if(c<2)
{
x=val[a][b]+call(a,b+1,c+1);
y=val[a][b]+call(a+1,b,0);
x=max(x,y);
y=call(a,b+1,c);
x=max(x,y);
}
else
{
x=val[a][b]+call(a+1,b,0);
y=call(a,b+1,c);
x=max(x,y);
}
return dp[a][b][c]=x;
}
int main()
{
ll a,b,c,d,e,i,j,k,l,x,y,t,p,r;
cin>>n>>m>>k;
for(i=1;i<=k;i++)
{
cin>>a>>b>>c;
val[a][b]=c;
}
memset(dp,-1,sizeof(dp));
x=call(1,1,0);
cout<<x<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int n,m,k,r,c,v,a[3005][3005];
long long ans,dp[3005][3005][5];
int main()
{
cin>>n>>m>>k;
for(int i=1;i<=k;i++)
{
cin>>r>>c>>v;
a[r][c]=v;
}
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
dp[i][j][0]=dp[i][j-1][0];
for(int k=0;k<=3;k++)
{
dp[i][j][0]=max(dp[i][j][0],dp[i-1][j][k]);
dp[i][j][1]=max(dp[i][j][1],dp[i-1][j][k]+(long long)a[i][j]);
}
for(int k=1;k<=3;k++)
dp[i][j][k]=max(max(dp[i][j][k],dp[i][j-1][k]),dp[i][j-1][k-1]+(long long)a[i][j]);
}
for(int i=0;i<=3;i++)
ans=max(ans,dp[n][m][i]);
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3105][3105][5];
ll ara[3105][3105];
ll n,m,k;
ll call(ll i,ll j,ll tot)
{
if(i>n || j>m )
return 0;
ll &sum=dp[i][j][tot];
if(~sum)
return sum;
sum=0;
if(tot==3)
{
sum=(call(i+1,j,0));
}
else
{
if(ara[i][j]!=0)
{
sum=max(call(i,j+1,tot),max(ara[i][j]+call(i,j+1,tot+1),ara[i][j]+call(i+1,j,0)));
}
else
{
sum=max(call(i+1,j,0),call(i,j+1,tot));
}
}
return sum;
}
int main()
{
memset(dp,-1,sizeof(dp));
cin>>n>>m>>k;
ll a,b,c;
while(k--)
{
cin>>a>>b>>c;
ara[a][b]=c;
}
cout<<call(0,0,0)<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
ll dp[3003][3003][5];
ll item[3003][3003];
void chmax(ll &a, ll b) {
a = max(a, b);
}
int main() {
int R, C, K;
cin >> R >> C >> K;
for (int i = 0; i < K; i++) {
int r, c, v;
cin >> r >> c >> v;
item[r - 1][c - 1] = v;
}
for (int i = 0; i <= R; i++) {
for (int j = 0; j <= C; j++) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k + 1], dp[i][j][k] + item[i][j]);
}
for (int k = 0; k <= 3; k++) {
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
}
ll ans = -1;
for (int i = 0; i <= 3; i++) {
ans = max(ans, dp[R][C][i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3005][3005][4];
int main(){
int R, C, K; cin >> R >> C >> K;
vector<vector<long long>> table(R, vector<long long>(C));
for(int i=0; i<K; ++i){
int r, c, v;
cin >> r >> c >> v;
r--; c--;
table[r][c] = v;
}
//init
for(int i=0; i<R; ++i){
for(int j=0; j<C; ++j){
for(int k=0; k<3; ++k){
//右に行く場合
//使う場合
dp[i][j+1][k+1] = max(dp[i][j+1][k+1], dp[i][j][k] + table[i][j]);
//使わない場合
dp[i][j+1][k+1] = max(dp[i][j+1][k+1], dp[i][j][k+1]);
//下に行く場合
dp[i+1][j][0] = max(dp[i+1][j][0], dp[i][j+1][k+1]);
}
}
}
cout << dp[R][C-1][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int) (n); i++)
#define rep3(i, s, n) for (int i = (s); i <=(int) (n); i++)
#define chmax(x,y) x = max(x,y)
long long a[3005][3005];
long long dp[3005][3005][5];
int main() {
int R,C,n;
cin >> R >> C >> n;
rep(i, n) {
int r,c,v;
cin >> r >> c >> v;
a[r-1][c-1]=v;
}
rep(i,R){
rep(j,C) {
for (int k=2;k>=0; k--){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4) {
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
}
long long ans =0;
rep(k,4) chmax(ans,dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n,m,k;
long long dp[3010][3010][5];
int a,b;
long long v[3010][3010];
int main(){
cin>>n>>m>>k;
long long c;
for(int i=1;i<=k;i++){
cin>>a>>b>>c;
v[a][b]=c;
}
long long mx=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
for(int kk=1;kk<=3;kk++){
dp[i][j][kk]=max(dp[i-1][j][3]+v[i][j],max(dp[i][j-1][kk-1]+v[i][j],dp[i][j-1][kk]));
mx=max(mx,dp[i][j][kk]);
}
}
}
cout<<mx<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void chmax(int64_t& a, int64_t b){
a = max(a, b);
}
int main(){
int N, M, K;
cin >> N >> M >> K;
static int A[3001][3001];
while(K--){
int a, b, c;
cin >> a >> b >> c;
A[a-1][b-1] = c;
}
static int64_t dp[3001][3001][5] = {0};
dp[0][0][1] = A[0][0];
for(int i=0; i<N; i++) for(int j=0; j<M; j++) for(int k=0; k<4; k++){
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i+1][j][1], dp[i][j][k] + A[i+1][j]);
chmax(dp[i][j+1][k], dp[i][j][k]);
chmax(dp[i][j+1][k+1], dp[i][j][k] + A[i][j+1]);
}
int64_t ans = 0;
for(int k=0; k<=3; k++) chmax(ans, dp[N-1][M-1][k]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long DP[3030][3030][5];
long long val[3030][3030];
int main()
{
int R,C,N;
cin>>R>>C>>N;
for(int i=0;i<N;i++)
{
int x,y,v;
cin>>x>>y>>v;
val[x][y]=v;
}
if(val[1][1])
DP[1][1][1]=val[1][1];
for(int i=1;i<=R;i++)
for(int j=1;j<=C;j++)
for(int k=0;k<=3;k++)
{
if(j<C)
{
DP[i][j+1][k]=max(DP[i][j+1][k],DP[i][j][k]);
if(val[i][j+1])
DP[i][j+1][k+1]=max(DP[i][j+1][k+1],DP[i][j][k]+val[i][j+1]);
}
if(i<R)
{
DP[i+1][j][0]=max(DP[i+1][j][0],DP[i][j][k]);
if(val[i+1][j])
DP[i+1][j][1]=max(DP[i+1][j][1],DP[i][j][k]+val[i+1][j]);
}
}
cout<<max(max(DP[R][C][0],DP[R][C][1]),max(DP[R][C][2],DP[R][C][3]))<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000 + 10;
typedef long long ll;
int n, m, k, val[MAXN][MAXN];
ll f[4][MAXN][MAXN];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= k; ++i) {
int x, y, _val; scanf("%d %d %d", &x, &y, &_val);
val[x][y] = _val;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
for (int pre = 0; pre <= 3; ++pre) f[0][i][j] = max(f[0][i][j], f[pre][i - 1][j]), f[1][i][j] = max(f[1][i][j], f[pre][i - 1][j] + val[i][j]);
f[0][i][j] = max(f[0][i][j], f[0][i][j - 1]);
for (int cnt = 1; cnt <= 3; ++cnt) {
f[cnt][i][j] = max(f[cnt][i][j], max(f[cnt][i][j - 1], f[cnt - 1][i][j - 1] + val[i][j]));
}
}
}
ll ans = 0;
for (int cnt = 0; cnt <= 3; ++cnt) ans = max(ans, f[cnt][n][m]);
printf("%lld\n", ans);
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long int
struct goods{
ll x, y, val;
};
ll dp[3001][3001][4], val[3001][3001];
int main(){
ll r, c, n, x, y, ans=0;
cin>>r>>c>>n;
for (ll i=1; i<=n; i++) cin>>x>>y, cin>>val[x][y];
for (ll i=1; i<=r; i++){
for (ll j=1; j<=c; j++){
for (ll k=3; k>=0; k--){
dp[i][j][k]=max(dp[i][j][k], max(dp[i-1][j][3], dp[i][j-1][k]));
if (k!=3) dp[i][j][k+1]=max(dp[i][j][k+1], dp[i][j][k]+val[i][j]);
}
}
}
for (ll i=0; i<=3; i++) ans=max(ans, dp[r][c][i]);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3e3;
int n, m, mat[M][M];
long long memo[M][M][4];
long long solve(int i, int j, int cnt) {
if (i == n || j == m)
return 0;
long long &r = memo[i][j][cnt];
if (r == -1) {
r = max(solve(i + 1, j, 0), solve(i, j + 1, cnt));
if (cnt < 3 && mat[i][j])
r = max(r, mat[i][j] + max(solve(i + 1, j, 0), solve(i, j + 1, cnt + 1)));
}
return r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(memo, -1, sizeof memo);
int k;
cin >> n >> m >> k;
while (k--) {
int i, j, x;
cin >> i >> j >> x;
mat[i - 1][j - 1] = x;
}
cout << solve(0, 0, 0) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int R,C,K;
cin >> R >> C >> K;
vector<vector<int>> m(R, vector<int>(C));
vector<vector<vector<long long>>> s(R+1, vector<vector<long long>>(C+1 ,vector<long long>(4)));
int r,c,v;
for(int i=0;i<K;i++){
cin >> r >> c >> v;
m[r-1][c-1] = v;
}
for(int i=0;i<R;i++){
for(int j=0;j<C;j++){
for(int k=2;k>=0;k--){
s[i][j][k+1]=max(s[i][j][k+1],s[i][j][k]+m[i][j]);
}
for(int k=0;k<4;k++){
s[i+1][j][0]=max(s[i+1][j][0], s[i][j][k]);
s[i][j+1][k]=max(s[i][j+1][k], s[i][j][k]);
}
}
}
long long ans=0;
for(int k=0;k<4;k++){
ans=max(ans,s[R-1][C-1][k]);
// cout << ans << endl;
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
long long r, c, k, a, b, w, g[3005][3005], dp[3005][3005][5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> r >> c >> k;
for (int i = 0; i < k; i++){
cin >> a >> b >> w;
g[a][b] = w;
}
for (int i = 1; i <= r; i++){
for (int j = 1; j <= c; j++){
dp[i][j][0] = max(dp[i][j-1][0], dp[i-1][j][4]);
dp[i][j][1] = max(dp[i][j-1][1], dp[i-1][j][4]+g[i][j]);
dp[i][j][2] = max(dp[i][j-1][2], dp[i][j-1][1]+g[i][j]);
dp[i][j][3] = max(dp[i][j-1][3], dp[i][j-1][2]+g[i][j]);
dp[i][j][4] = max(max(dp[i][j][0], dp[i][j][1]), max(dp[i][j][2], dp[i][j][3]));
}
}
cout << dp[r][c][4] << "\n";
}
|
/**
* author: RM07
* created: August 15, 2020 7:00 PM
* motto: Knowledge is Power, Strive for Excellence
**/
#include<bits/stdc++.h>
using namespace std;
const int maxn=3009;
int n,m,K;
int a[maxn][maxn];
long long f[maxn][maxn][4];
int main(){
cin>>n>>m>>K;
while(K--){
int x,y,z;scanf("%d%d%d",&x,&y,&z);
a[x][y]=z;
}
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
for(int k=0;k<=3;++k){
long long t=max(max(f[i-1][j][0],f[i-1][j][1]),max(f[i-1][j][2],f[i-1][j][3]));
f[i][j][k]=max(f[i][j-1][k],t);
if(k)f[i][j][k]=max(f[i][j-1][k-1]+a[i][j],f[i][j][k]);
if(k)f[i][j][k]=max(f[i][j][k],t+a[i][j]);
}
}
}
printf("%lld\n",max(max(f[n][m][0],f[n][m][1]),max(f[n][m][2],f[n][m][3])));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3001][3001][4], a[3001][3001];
int main() {
ll r,c,items, x , y, v, maxi = 0;
cin >> r >> c >> items;
while(items--) {
cin >> x >> y >> v;
a[x-1][y-1]=v;
}
for(int i=0;i<r;i++) for(int j=0;j<c;j++) {
for(int k=2;k>=0;k--) {
dp[i][j][k+1]=max(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
for(int k=0;k<4;k++) {
if(j+1!=c) dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
if(i+1!=r) dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
}
}
for(int i=0;i<r;i++) for(int j=0;j<c;j++) for(int k=0;k<4;k++) maxi=max(maxi,dp[i][j][k]);
cout << maxi;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
ll dp[3010][3010][4];
ll pt[3010][3010];
int main()
{
ll r,c,k;
cin >> r >> c >> k;
for(int i = 0;i<k;i++)
{
ll r,c,v;
cin >> r >> c >> v;
r--;c--;
pt[r][c]=v;
}
for(int i = 0;i<r;i++)
{
for(int j = 0;j<c;j++)
{
for(int k = 0;k<=3;k++)
{
if(pt[i][j])dp[i+1][j+1][1] = max(dp[i+1][j+1][1],dp[i][j+1][k]+pt[i][j]);
dp[i+1][j+1][0] = max(dp[i+1][j+1][0],dp[i][j+1][k]);
}
for(int k = 0;k<=3;k++)
{
if(pt[i][j])
{
if(k<3)dp[i+1][j+1][k+1] = max(dp[i+1][j+1][k+1],dp[i+1][j][k]+pt[i][j]);
}
dp[i+1][j+1][k] = max(dp[i+1][j+1][k],dp[i+1][j][k]);
}
}
}
ll ans = 0;
for(int i = 0;i<=3;i++)ans = max(dp[r][c][i],ans);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3001][3001][3], a[3001][3001];
int main() {
ll r,c,items, x , y, v, maxi = 0;
cin >> r >> c >> items;
while(items--) {
cin >> x >> y >> v;
x--, y--;
dp[x][y][0] = a[x][y] = v;
}
for(int i=0;i<r;i++) for(int j=0;j<c;j++) {
for(int k=0;k<3;k++) {
if(k > 0) dp[i][j][k] = max(dp[i][j][k], dp[i][j][k-1]);
if(j+1 < c) dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k]);
if(j+1 < c && k > 0) dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k-1] + a[i][j+1]);
}
if(i+1 < r) dp[i+1][j][0] = dp[i+1][j][1] = dp[i+1][j][2] = max({dp[i][j][0], dp[i][j][1], dp[i][j][2]}) + a[i+1][j];
}
maxi = dp[r-1][c-1][2];
cout << maxi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int R, C;
int V[3005][3005];
int64_t dp[5][3005][3005];
int64_t f(int rem, int r, int c) {
if (r == R && c == C) {
if (rem) return V[r][c];
return 0;
}
if (dp[rem][r][c] != -1) return dp[rem][r][c];
int64_t ans = -1e18;
if (c < C) ans = max(ans, f(rem, r, c+1));
if (r < R) ans = max(ans, f(3, r+1, c));
if (rem && V[r][c]) {
if (c < C) ans = max(ans, f(rem-1, r, c+1)+V[r][c]);
if (r < R) ans = max(ans, f(3, r+1, c)+V[r][c]);
}
return dp[rem][r][c] = ans;
}
int main() {
int K;
cin >> R >> C >> K;
for (int i = 0 ; i < K; ++i) {
int r, c, v;
cin >> r >> c >> v;
V[r][c] = v;
}
memset(dp, -1, sizeof dp);
cout << f(3, 1, 1) << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define chmax(x, y) x = max(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int a[3005][3005];
ll dp[3005][3005][4];
int main(){
int r, c, k; cin >> r >> c >> k;
rep(i, k){
int ri, ci, v; cin >> ri >> ci >> v;
a[ri - 1][ci - 1] = v;
}
rep(i, r){
rep(j, c){
for(int k = 2; k >= 0; k--){
chmax(dp[i][j][k + 1], dp[i][j][k] + a[i][j]);
}
rep(k, 4){
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
}
ll ans = 0;
rep(k, 4) chmax(ans, dp[r - 1][c - 1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
long long dp[N][N][4];
int v[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int r, c, k;
cin >> r >> c >> k;
while (k--) {
int x, y;
cin >> x >> y >> v[x][y];
}
for (int i = 1; i <= r; ++i) {
for (int j = 1; j <= c; ++j) {
for (int jj = 0; jj < 4; ++jj) dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][jj]), dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j][jj] + v[i][j]);
for (int ii = 0; ii < 4; ++ii) {
dp[i][j][ii] = max(dp[i][j][ii], dp[i][j - 1][ii]);
if (ii) dp[i][j][ii] = max(dp[i][j][ii], dp[i][j - 1][ii - 1] + v[i][j]);
}
}
}
long long ans = 0;
for (int i = 0; i < 4; ++i) ans = max(ans, dp[r][c][i]);
cout << ans;
return 0;
}
|
// E - Picking Goods
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define chmax(x,y) x=max(x,(y))
int V[3000+1][3000+1];
ll dp[3000+1][3000+1][3+1];
int main(){
int R, C, K; cin>>R>>C>>K;
rep(i, K){
int r, c, v; cin>>r>>c>>v;
V[r][c] = v;
}
rep(i, R+1) rep(j, C+1) rep(k, 3+1){
if(i-1 >= 0){
chmax(dp[i][j][0], dp[i-1][j][k]);
chmax(dp[i][j][1], dp[i-1][j][k] + V[i][j]);
}
if(j-1 >= 0){
chmax(dp[i][j][k], dp[i][j-1][k]);
if(k-1 >= 0) chmax(dp[i][j][k], dp[i][j-1][k-1] + V[i][j]);
}
}
ll ans = 0;
rep(k, 3+1) chmax(ans, dp[R][C][k]);
cout<< ans <<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 3050;
int r,c,k,x,y,val;
ll dp[MAX][MAX][4];
ll room[MAX][MAX];
int main() {
cin>>r>>c>>k;
while(k--){
cin>>x>>y>>val;
room[x][y]=val;
}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
for(int k=1;k<=3;k++){
dp[i][j][k]=max(max(dp[i-1][j][3],dp[i][j-1][k]),room[i][j]+max(dp[i][j-1][k-1],dp[i-1][j][3]));
}
}
}
cout<<dp[r][c][3];
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y)
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, n;
cin >> R >> C >> n;
rep(i,n){
int r,c,v;
cin >> r>>c>>v;
a[r-1][c-1]=v;
}
rep(i,R)rep(j,C){
for(int k=2;k>=0;k--){
chmax(dp[i][j][k+1], dp[i][j][k]+a[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans=0;
rep(k,4){
chmax(ans, dp[R-1][C-1][k]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
vector<vector<ll>>v;
ll r,c,k;
ll dp[3005][3005][10];
ll dfs(ll i,ll j,ll cp){
if(i>r || j>c)return 0;
if(dp[i][j][cp]!=-1)return dp[i][j][cp];
ll ans=0;
if(v[i][j]!=0 && cp>0){
ll ans1=v[i][j]+dfs(i,j+1,cp-1);
ll ans2=v[i][j]+dfs(i+1,j,3);
ans=max(ans1,ans2);
}
ll ans1=dfs(i,j+1,cp);
ll ans2=dfs(i+1,j,3);
ans=max(ans,max(ans1,ans2));
return dp[i][j][cp]=ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>r>>c>>k;
vector<vector<ll>>V(r+1,vector<ll>(c+1,0));
for(ll i=0;i<k;i++){
ll x,y,z;
cin>>x>>y>>z;
V[x][y]=z;
}
v=V;
memset(dp,-1,sizeof(dp));
ll ans=dfs(1,1,3);
cout<<ans<<endl;
return 0;
}
|
#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
int R,C,K;
int v[3003][3003];
long dp[3003];
long tmp[4][3003];
int main()
{
cin>>R>>C>>K;
for(int i=0;i<K;i++)
{
int r,c,va;cin>>r>>c>>va;
r--,c--;
v[r][c]=va;
}
for(int i=0;i<R;i++)
{
for(int j=0;j<4;j++)for(int k=0;k<C;k++)tmp[j][k]=0;
long MX[3]={};
for(int k=0;k<C;k++)
{
if(k>0)
{
for(int j=0;j<4;j++)tmp[j][k]=tmp[j][k-1];
}
MX[0]=max(MX[0],dp[k]);
for(int j=0;j<3;j++)
{
tmp[j+1][k]=max(tmp[j+1][k],MX[j]+v[i][k]);
}
for(int j=0;j<3;j++)MX[j]=max(MX[j],tmp[j][k]);
}
for(int k=0;k<C;k++)
{
for(int j=0;j<4;j++)dp[k]=max(dp[k],tmp[j][k]);
}
}
cout<<dp[C-1]<<endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll = long long;
int Item[3005][3005];
ll DP[3005][3005][4];
int main(){
int R,C,k;cin>>R>>C>>k;
rep(i,k){
int r,c,v;
scanf("%d %d %d",&r,&c,&v);
r--;c--;
Item[r][c]=v;
}
rep(i,R)rep(j,C){
for(int k=2;k>=0;k--){
DP[i][j][k+1]=max(DP[i][j][k+1],DP[i][j][k]+Item[i][j]);
}
rep(k,4){
DP[i+1][j][0]=max(DP[i+1][j][0],DP[i][j][k]);
DP[i][j+1][k]=max(DP[i][j+1][k],DP[i][j][k]);
}
}
ll ans=0;
rep(k,4)ans=max(ans,DP[R-1][C-1][k]);
cout<<ans<<endl;
}
|
#include <cstdio>
#include <bits/stdc++.h>
using namespace std;
long long int items[3005][3005];
long long int dp[3005][3005][4];
int main() {
int r, c, k;
scanf("%d%d%d", &r, &c, &k);
for (int l = 0; l < k; l ++) {
int i, j, v;
scanf("%d%d%d", &i, &j, &v);
items[i][j] = v;
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
for (int m = 0; m < 4; m++) {
dp[i][j][m] = max(dp[i - 1][j][3], dp[i][j - 1][m]);
}
if (items[i][j] > 0) {
for (int m = 2; m >= 0; m--) {
dp[i][j][m + 1] = max(dp[i][j][m + 1], dp[i][j][m] + items[i][j]);
}
}
}
}
printf("%lld\n", dp[r][c][3]);
return 0;
}
|
#include <bits/stdc++.h>
#include <string>
#include <vector>
#include <algorithm>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y)
int INF = 1e9;
int a[3005][3005];
ll dp[3005][3005][4];
//配列はグローバルで定義した方がいい？
int main(){
int r,c,k;cin >> r >> c >> k;
rep(i,k){
int ri,ci,vi;cin >> ri >> ci >> vi;
--ri;--ci;
a[ri][ci] = vi;
}
rep(i,r)rep(j,c){
for(int k = 2;k >= 0;k--){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
ll ans = 0;
rep(i,4) ans = max(ans,dp[r-1][c-1][i]);
cout << ans << endl;
}
|
#include<iostream>
#include<algorithm>
#define N 3001
using namespace std;
int r,c,n,i,j,d[N][N],a,b,x;
long long e[N][N][4];
bool v[N][N][4];
long long w(int x,int y,int k){
if(x>r||y>c)return 0;
if(x==r&&y==c)return k<3?d[x][y]:0;
if(v[x][y][k])return e[x][y][k];
v[x][y][k]=1;
e[x][y][k]=max(w(x+1,y,0)+d[x][y],w(x,y+1,k));
if(k<2){
e[x][y][k]=max(e[x][y][k],w(x,y+1,k+1)+d[x][y]);
}
return e[x][y][k];
}
int main(){
cin>>r>>c>>n;
while(n--){
cin>>a>>b>>x;
d[a][b]=x;
}
cout<<w(1,1,0);
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=3005;
int n,m,k,a[N][N],dp[N][N][4];
void chmax(int &a,int b){if(a<b)a=b;}
signed main()
{
ios::sync_with_stdio(false);
cin>>n>>m>>k;
for(int i=1;i<=k;i++)
{
int x,y,v;
cin>>x>>y>>v;
a[x][y]=v;
}
dp[1][1][1]=a[1][1];
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
for(int k=0;k<=3;k++)
{
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
chmax(dp[i+1][j][1],dp[i][j][k]+a[i+1][j]);
if(k<3) chmax(dp[i][j+1][k+1],dp[i][j][k]+a[i][j+1]);
}
}
}
cout<<max(max(dp[n][m][0],dp[n][m][1]),max(dp[n][m][2],dp[n][m][3]))<<endl;
return 0;
}
|
//後日挑戦
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
ll v[3005][3005];
ll dp[3005][3005][4];
int main() {
int r,c,k;
cin >> r >> c >> k;
rep(i,k){
int x,y,z;
cin >> x >> y >> z;
x--;y--;
v[x][y]=z;
}
rep(i,r)rep(j,c){
for(int k=2;k>=0;k--){
chmax(dp[i][j][k+1],dp[i][j][k]+v[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
ll ans=0;
rep(k,4) chmax(ans,dp[r-1][c-1][k]);
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
const int maxn=3009;
int n,m,K;
int a[maxn][maxn];
long long f[maxn][maxn][4];
int main(){
cin>>n>>m>>K;
while(K--){
int x,y,z;scanf("%d%d%d",&x,&y,&z);
a[x][y]=z;
}
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
for(int k=0;k<=3;++k){
long long t=max(max(f[i-1][j][0],f[i-1][j][1]),max(f[i-1][j][2],f[i-1][j][3]));
f[i][j][k]=max(f[i][j-1][k],t);
if(k)f[i][j][k]=max(f[i][j-1][k-1]+a[i][j],f[i][j][k]);
if(k)f[i][j][k]=max(f[i][j][k],t+a[i][j]);
}
}
}
printf("%lld",max(max(f[n][m][0],f[n][m][1]),max(f[n][m][2],f[n][m][3])));
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
int main() {
int R, C, k;
cin >> R >> C >> k;
vector<int> r(k,0), c(k,0), v(k,0);
rep(i,k) cin >> r[i] >> c[i] >> v[i];
vector<vector<int>> arr(R,vector<int>(C));
rep(i,k) arr[r[i]-1][c[i]-1] = v[i];
vector<vector<vector<ll>>> dp(R+1,vector<vector<ll>>(C+1,vector<ll>(4,0)));
rep(i,R) rep(j,C) {
for (int k = 2; k >= 0; k--) {
dp[i][j][k+1] = max(dp[i][j][k+1], dp[i][j][k] + arr[i][j]);
}
rep(k, 4) {
dp[i+1][j][0] = max(dp[i+1][j][0], dp[i][j][k]);
dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k,4) ans = max(ans,dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
using ll = long long;
using P = pair<int, int>;
#include<algorithm>
#include<math.h>
#include<map>
#include<queue>
#include<set>
#define chmax(x,y) x=max(x,y)
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, n;
cin >> R >> C >> n;
rep(i, n) {
int r, c, v;
cin >> r >> c >> v;
a[r - 1][c - 1] = v;
}
rep(i, R)rep(j, C) {
for (int k = 2; k >= 0; --k) {
chmax(dp[i][j][k + 1], dp[i][j][k] + a[i][j]);
}
rep(k, 4) {
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k, 4)chmax(ans, dp[R - 1][C - 1][k]);
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int N = 3005;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, m, k;
long long g[N][N], f[N][N][5];
int main()
{
scanf("%d%d%d", &n, &m, &k);
for(int i = 0, r, c; i < k; ++i)
{
scanf("%d%d", &r, &c);
scanf("%lld", &g[r][c]);
}
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= m; ++j)
{
f[i][j][0] = max(f[i][j-1][0], f[i-1][j][4]);
f[i][j][4] = f[i][j][0];
for(int l = 1; l <= 3; ++l)
{
f[i][j][l] = max(max(f[i][j-1][l], f[i-1][j][4] + g[i][j]), f[i][j-1][l-1] + g[i][j]);
f[i][j][4] = max(f[i][j][4], f[i][j][l]);
}
}
cout << f[n][m][4]<< endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int maxn=3009;
int n,m,K;
int a[maxn][maxn];
long long f[maxn][maxn][4];
int main(){
cin>>n>>m>>K;
while(K--){
int x,y,z;scanf("%d%d%d",&x,&y,&z);
a[x][y]=z;
}
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
for(int k=0;k<=3;++k){
long long t=max(max(f[i-1][j][0],f[i-1][j][1]),max(f[i-1][j][2],f[i-1][j][3]));
f[i][j][k]=max(f[i][j-1][k],t);
if(k)f[i][j][k]=max(f[i][j-1][k-1]+a[i][j],f[i][j][k]);
if(k)f[i][j][k]=max(f[i][j][k],t+a[i][j]);
}
}
}
printf("%lld",max(max(f[n][m][0],f[n][m][1]),max(f[n][m][2],f[n][m][3])));
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define chmax(x, y) x = max(x, y)
using namespace std;
using ll = long long;
// dp[i][j][k] ((i,j)にいるときの最大値. その行で既にk個のアイテムを選んだとき(k <= K))
int table[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, K;
cin >> R >> C >> K;
rep(i, K) {
int r, c, v;
cin >> r >> c >> v;
table[r-1][c-1] = v;
}
rep(i, R) rep(j, C) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k+1], dp[i][j][k] + table[i][j]);
}
rep(k, 4) {
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k, 4) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3001][3001][3], a[3001][3001];
ll func(int r, int c, int cnt, int row, int col) {
if(r > row-1 || c > col-1 || cnt < 0) return 0;
if(dp[r][c][cnt] != -1) return dp[r][c][cnt];
return dp[r][c][cnt] = max({func(r+1, c, 2, row, col) + a[r][c], func(r, c+1, cnt, row, col), func(r, c+1, cnt-1, row, col) + a[r][c]});
}
int main() {
ll r,c,items, x , y, v, maxi = 0;
cin >> r >> c >> items;
while(items--) {
cin >> x >> y >> v;
a[x-1][y-1]=v;
}
for(int i=0;i<r;i++) for(int j=0;j<c;j++) for(int k=0;k<4;k++) dp[i][j][k] = -1;
maxi = func(0, 0, 2, r, c);
cout << maxi;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pb push_back
const int maxn=2e5+10;
const int mod=998244353;
int a[3005][3005];
ll dp[3005][3005][5];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int r,c,k;
cin>>r>>c>>k;
while(k--)
{
int x,y,z;
cin>>x>>y>>z;
a[x][y]=z;
}
ll ans=0;
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{
dp[i][j][0]=max(dp[i][j-1][0],dp[i-1][j][3]);
ans=max(ans,dp[i][j][0]);
for(int x=1;x<=3;x++)
{
dp[i][j][x]=max(dp[i-1][j][3]+a[i][j],max(dp[i][j-1][x],dp[i][j-1][x-1]+a[i][j]));
ans=max(ans,dp[i][j][x]);
}
}
}
cout<<ans<<'\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long r, c, k, v[3004][3004], dp[3004][3004][3];
long long cal(int i, int j, int cnt){
if(cnt == 3) return cal(i+1, j, 0);
if(i >= r || j >= c) return 0;
long long& ret = dp[i][j][cnt];
if(ret != -1) return ret;
ret = max(cal(i+1, j, 0), cal(i, j+1, cnt));
if(v[i][j]) ret = max(ret, max(v[i][j] + cal(i, j+1, cnt+1), v[i][j] + cal(i+1, j, 0)));
return ret;
}
void solve(){
cin>>r>>c>>k;
memset(v, 0, sizeof(v));
for(int i = 0; i < k; i++){
int R, C, V;
cin>>R>>C>>V;
v[R-1][C-1] = V;
}
memset(dp, -1, sizeof(dp));
cout<<cal(0, 0, 0);
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TC;
//cin>>TC;
TC=1;
while(TC--){
solve();
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll ans=0,f[3005][3005][4];
int n,m,K,a[3005][3005];
int main(){
cin>>n>>m>>K;
for(int i=1;i<=K;i++){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
a[x][y]=z;
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
for(int k=0;k<=3;k++)f[i][j][k]=max(f[i-1][j][k],f[i][j-1][k]);
for(int k=1;k<=3;k++)f[i][j][k]=max(f[i][j][k],f[i][j-1][k-1]+a[i][j]);
for(int k=1;k<=3;k++){
for(int l=0;l<=3;l++)f[i][j][k]=max(f[i][j][k],f[i-1][j][l]+a[i][j]);
}
}
}
for(int k=0;k<=3;k++)ans=max(ans,f[n][m][k]);
cout<<ans;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=3010;
int a[maxn][maxn];
bool vis[maxn];
ll dp[3005][3005][4];
int main()
{
int n,m,k;
cin>>n>>m>>k;
for( int i=1;i<=k;i++ )
{
int x,y,w;
cin>>x>>y>>w;
a[x][y]=w;
}
dp[1][1][1]=a[1][1];
for( int i=1;i<=n;i++ )
{
for( int j=1;j<=m;j++ )
{
if( i==1 && j==1 ) continue;
ll maxup=max(dp[i-1][j][3],max(dp[i-1][j][2],max(dp[i-1][j][1],dp[i-1][j][0])));
dp[i][j][0]=max(maxup,dp[i-1][j][0]);
for( int k=1;k<=3;k++ )
{
dp[i][j][k]=max(dp[i][j-1][k-1]+a[i][j],dp[i][j-1][k]);
}
dp[i][j][1]=max(maxup+a[i][j],dp[i][j][1]);
}
}
ll ans=max(dp[n][m][0],max(dp[n][m][1],max(dp[n][m][2],dp[n][m][3])));
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
const int N=3e3+7;
long long dp[N][N][4],v[N][N];
int main()
{
int r,c,n;
scanf("%d%d%d",&r,&c,&n);
for(int i=0;i<n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
scanf("%lld",&v[x][y]);
}
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{
int is=v[i][j]?1:0;
for(int t=0;t<=3;t++)
dp[i][j][0]=max(dp[i][j][0],dp[i-1][j][t]);
if(is)
dp[i][j][1]=dp[i][j][0]+v[i][j];
for(int k=0;k<=3;k++)
{
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k]);
if(is&&k)
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k-1]+v[i][j]);
}
}
}
long long ans=0;
for(int t=0;t<=3;t++)
ans=max(ans,dp[r][c][t]);
printf("%lld\n",ans);
}
|
#include<iostream>
using namespace std;
long long maps[3005][3005]={0};
long long dp[3005][3005][5]={0};
int main(){
int h,w;
int k;
cin>>h>>w;
cin>>k;
for(int i=0;i<k;i++){
int r,c,v;
cin>>r>>c>>v;
maps[r][c]=v;
}
dp[1][1][1]=maps[1][1];
for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
for(int l=3;l>=0;l--){
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][l]);
dp[i+1][j][1]=max(dp[i+1][j][1],dp[i][j][l]+maps[i+1][j]);
dp[i][j+1][l]=max(dp[i][j+1][l],dp[i][j][l]);
if(l<3){
dp[i][j+1][l+1]=max(dp[i][j+1][l+1],dp[i][j][l]+maps[i][j+1]);
}
}
}
}
long long maxim=0;
for(int i=0;i<=3;i++){
maxim=max(maxim,dp[h][w][i]);
}
cout<<maxim<<endl;
return(0);
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=3010;
LL dp[N][N][4],mp[N][N];
int main()
{
int n,m,nn;
scanf("%d%d%d",&n,&m,&nn);
for(int i=1;i<=nn;i++)
{
int r,c;
scanf("%d%d",&r,&c);
scanf("%lld",&mp[r][c]);
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
for(int k=1;k<=3;k++)
{
dp[i][j][k]=max(dp[i][j][k],max(dp[i][j-1][k],dp[i][j-1][k-1]+mp[i][j]));
dp[i][j][0]=max(dp[i][j][0],dp[i-1][j][k]);
dp[i][j][1]=max(dp[i][j][1],dp[i-1][j][k]+mp[i][j]);
}
}
}
LL res=0;
for(int k=1;k<=3;k++)
res=max(res,dp[n][m][k]);
cout<<res<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define maxn 3001
using namespace std;
typedef long long LL;
int n,m,k;
int ar[maxn][maxn];
LL dp[maxn][maxn][4];
LL f(int r , int c , int d) {
if(dp[r][c][d] != -1)
return dp[r][c][d];
dp[r][c][d] = 0;
if(r < n) {
dp[r][c][d] = max( dp[r][c][d] , f(r+1,c,0) );
dp[r][c][d] = max( dp[r][c][d] , f(r+1,c,1) + ar[r+1][c] );
}
if(c < m) {
dp[r][c][d] = max( dp[r][c][d] , f(r,c+1,d) );
if(d < 3)
dp[r][c][d] = max( dp[r][c][d] , f(r,c+1,d+1) + ar[r][c+1] );
}
return dp[r][c][d];
}
int main() {
scanf("%d%d%d",&n,&m,&k);
for( int i = 0 , x,y,z ; i < k ; i++ ) {
scanf("%d%d%d",&x,&y,&z);
ar[x][y] = z;
}
memset(dp,-1,sizeof(dp));
LL ans = max( f(1,1,0) , f(1,1,1) + ar[1][1] );
printf("%lld\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define chmax(a, b) a = max(a, b);
long long dp[3005][3005][4];
int main()
{
int r, c, n;
cin >> r >> c >> n;
vector<vector<int>> d(3000, vector<int>(3000));
for(int i = 0; i < n; i++) {
int h, w, v;
cin >> h >> w >> v;
d[h - 1][w - 1] = v;
}
for(int i = 0; i < r; i++) {
for(int j = 0; j < c; j++) {
for(int k = 2; k >= 0; k--) {
chmax(dp[i][j][k + 1], dp[i][j][k] + d[i][j]);
}
for(int k = 0; k < 4; k++) {
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
}
long long ans = 0;
for(int i = 0; i < 4; i++) chmax(ans, dp[r - 1][c - 1][i]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef int64_t ll;
ll r,c,k,a,b,d,dp[3001][3001][4],v[3001][3001];
int main(){
cin>>r>>c>>k;
for(int i=1;i<=k;i++){cin>>a>>b>>d;v[a][b]=d;}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
for(int k=0;k<=3;k++){
dp[i][j][k]=max(dp[i][j-1][k],dp[i-1][j][3]);
if(k){
dp[i][j][k]=max(dp[i][j][k],max(dp[i][j-1][k-1],dp[i-1][j][3])+v[i][j]);
}
}
}
}
cout<<dp[r][c][3]<<endl;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const double eps = 1e-8;
const int NINF = 0xc0c0c0c0;
const int INF = 0x3f3f3f3f;
const ll mod = 1e9 + 7;
const ll N = 3e3 + 5;
ll R,C,K,a[N][N],f[N][N][4];
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin>>R>>C>>K;
for(int i=1;i<=K;i++){
int u,v,w;
cin>>u>>v>>w;
a[u][v]=w;
}
ll ans=0;
for(int i=1;i<=R;i++)
for(int j=1;j<=C;j++)
for(int k=1;k<=3;k++)
f[i][j][k]=max(f[i-1][j][3]+a[i][j],max(f[i][j-1][k-1]+a[i][j],f[i][j-1][k]));
cout<<f[R][C][3]<<'\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pii pair<int,int>
const ll sz=3010;
ll dp[sz][sz][4];
ll R,C;
ll ara[sz][sz];
ll cholo(ll r,ll c, ll rem)
{
ll &ret=dp[r][c][rem];
if(~ret) return ret;
ll mx=0;
if(rem>0) mx=ara[r][c];
if(r+1<=R){
if(rem>0) mx=max(mx, ara[r][c]+cholo(r+1,c,3));
else mx=max(mx, cholo(r+1,c,3));
}
if(c+1<=C){
if(rem>0) mx=max(mx, ara[r][c]+cholo(r,c+1,rem-1));
mx=max(mx, cholo(r,c+1,rem));
}
return (ret = mx);
}
int main()
{
ll n,m,i,j,k,x;
cin>>R>>C>>k;
for(i=1;i<=k;i++){
cin>>n>>m>>x;
ara[n][m]=x;
}
memset(dp,-1,sizeof dp);
ll ans=cholo(1,1,3);
cout<<ans<<'\n';
}
|
#include<cstdio>
#include<vector>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=3333;
int a[N][N];
ll f[N][N][4];
int n,m,k;
int main(){
int x,y,v;
scanf("%d%d%d",&n,&m,&k);
for (int i=1; i<=k; i++){
scanf("%d%d%d",&x,&y,&v);
a[x][y]=v;
}
for (int i=1; i<=n; i++)
for (int j=1; j<=m; j++){
for (int k=0; k<=3; k++){
if (k) f[i][j][k]=max(f[i][j][k],f[i][j-1][k-1]+a[i][j]);
f[i][j][k]=max(f[i][j][k],f[i][j-1][k]);
}
for (int k=0; k<=3; k++){
f[i][j][0]=max(f[i][j][0],f[i-1][j][k]);
f[i][j][1]=max(f[i][j][1],f[i-1][j][k]+a[i][j]);
}
}
ll ans=0;
for (int i=0; i<=3; i++)
ans=max(ans,f[n][m][i]);
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define ll int64_t
#define _GLIBCXX_DEBUG
ll dp[3005][3005][5];
ll m[3005][3005];
int main(){
int r,c,k;
cin >> r >> c >> k;
rep(i,r+1){
rep(j,c+1){
rep(p,5){
dp[i][j][p]=0;
m[i][j]=0;
}
}
}
rep(i,k){
int a,b;
ll x;
cin >>a>>b>>x;
m[a][b]=x;
}
rep(i,r){
rep(j,c){
dp[i+1][j+1][0]=max(dp[i][j+1][4],dp[i+1][j][0]);
for(int p=1;p<4;p++)
dp[i+1][j+1][p+1]=max(dp[i][j+1][4]+m[i+1][j+1],max(dp[i+1][j][p]+m[i+1][j+1],dp[i+1][j][p+1]));
}
}
cout << dp[r][c][4] << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
ll V[3005][3005];
ll dp[3005][3005][4];
int main() {
ll R, C, K; cin >> R >> C >> K;
rep(i, K){
ll r, c, v; cin >> r >> c >> v;
r--; c--;
V[r][c] = v;
}
rep(i, R){
rep(j, C){
for (int k = 3; k > 0; k--){
dp[i][j][k] = max(dp[i][j][k], dp[i][j][k-1] + V[i][j]);
}
rep(k, 4){
dp[i+1][j][0] = max(dp[i+1][j][0], dp[i][j][k]);
dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k]);
}
}
}
ll ma = 0;
rep(k, 4){
ma = max(ma, dp[R-1][C-1][k]);
}
cout << ma << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.