solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return a > val ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
struct GridModule {
int n, m;
vector<vector<int> > a;
vector<vector<int> > row, col;
vector<vector<int> > dig[2];
void init(vector<vector<int> >& x, int k) {
a = x;
n = a.size();
if (n)
m = a[0].size();
else
m = 0;
row.resize(n);
for (int i = 0; i < n; i++) {
row[i].clear();
int tot = 0;
for (int j = 0; j < m; j++) {
tot += a[i][j] == k;
row[i].push_back(tot);
}
}
col.resize(m);
for (int j = 0; j < m; j++) {
col[j].clear();
int tot = 0;
for (int i = 0; i < n; i++) {
tot += a[i][j] == k;
col[j].push_back(tot);
}
}
dig[0].resize(n + m - 1);
for (int i = 0; i < m; i++) {
dig[0][i].clear();
int tot = 0;
for (int j = 0; j < min(i + 1, n); j++) {
tot += a[j][i - j] == k;
dig[0][i].push_back(tot);
}
}
for (int i = 1; i < n; i++) {
dig[0][i + m - 1].clear();
int tot = 0;
for (int j = 0; j < min(n - i, m); j++) {
tot += a[i + j][m - j - 1] == k;
dig[0][i + m - 1].push_back(tot);
}
}
dig[1].resize(n + m - 1);
for (int i = m - 1; i >= 0; i--) {
dig[1][m - i - 1].clear();
int tot = 0;
for (int j = 0; j < min(m - i, n); j++) {
tot += a[j][i + j] == k;
dig[1][m - i - 1].push_back(tot);
}
}
for (int i = 1; i < n; i++) {
dig[1][i + m - 1].clear();
int tot = 0;
for (int j = 0; j < min(n - i, m); j++) {
tot += a[i + j][j] == k;
dig[1][i + m - 1].push_back(tot);
}
}
}
int rowsum(int x, int y, int z) {
if (y > z) swap(y, z);
return row[x][z] - (y ? row[x][y - 1] : 0);
}
int colsum(int x, int y, int z) {
if (y > z) swap(y, z);
return col[x][z] - (y ? col[x][y - 1] : 0);
}
int diagonal(int x, int y, int z, int t) {
if (x > z) {
swap(x, z);
swap(y, t);
}
if (x + y == z + t) {
int u = x + y;
if (u >= m) {
x = m - y - 1;
z = m - t - 1;
}
return dig[0][u][z] - (x ? dig[0][u][x - 1] : 0);
} else if (x - y == z - t) {
int u = m + x - y - 1;
if (u >= m) {
x = y;
z = t;
}
return dig[1][u][z] - (x ? dig[1][u][x - 1] : 0);
}
return 0;
}
} gr[4];
const int maxn = 2010;
int n;
char s[maxn];
int row[maxn];
int col[maxn];
long double p2[maxn];
long double p3[maxn];
void solve() {
p2[0] = p3[0] = 1;
for (int i = (1); i < (maxn); i++)
p2[i] = p2[i - 1] * 2, p3[i] = p3[i - 1] * 3;
scanf("%d", &n);
vector<vector<int> > a(n, vector<int>(n, 0));
for (int i = (0); i < (n); i++) {
scanf("%s", s);
for (int j = (0); j < (n); j++) a[i][j] = s[j] - '0';
}
for (int i = (0); i < (4); i++) gr[i].init(a, i);
pair<long double, int> ans;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++)
if (a[i][j]) {
int lo = 0, hi = i;
chkmin(hi, n - i - 1);
chkmin(hi, j);
chkmin(hi, n - j - 1);
while (lo < hi) {
int mi = lo + hi + 1 >> 1;
if (!gr[0].rowsum(i, j - mi, j + mi) &&
!gr[0].colsum(j, i - mi, i + mi)) {
lo = mi;
} else {
hi = mi - 1;
}
}
int n2 =
gr[2].rowsum(i, j - lo, j + lo) + gr[2].colsum(j, i - lo, i + lo);
int n3 =
gr[3].rowsum(i, j - lo, j + lo) + gr[3].colsum(j, i - lo, i + lo);
chkmax(ans,
make_pair(p2[n2] * p3[n3] / a[i][j],
mult(fpow(2, n2), mult(fpow(3, n3), inv(a[i][j])))));
lo = 0, hi = i;
chkmin(hi, n - i - 1);
chkmin(hi, j);
chkmin(hi, n - j - 1);
while (lo < hi) {
int mi = lo + hi + 1 >> 1;
if (!gr[0].diagonal(i - mi, j - mi, i + mi, j + mi) &&
!gr[0].diagonal(i - mi, j + mi, i + mi, j - mi)) {
lo = mi;
} else {
hi = mi - 1;
}
}
n2 = gr[2].diagonal(i - lo, j - lo, i + lo, j + lo) +
gr[2].diagonal(i - lo, j + lo, i + lo, j - lo);
n3 = gr[3].diagonal(i - lo, j - lo, i + lo, j + lo) +
gr[3].diagonal(i - lo, j + lo, i + lo, j - lo);
chkmax(ans,
make_pair(p2[n2] * p3[n3] / a[i][j],
mult(fpow(2, n2), mult(fpow(3, n3), inv(a[i][j])))));
}
printf("%d\n", ans.second);
}
int main() {
solve();
return 0;
}
| 15
|
/*
ββ β»ββββββ β»β
βγγγγγγβ
βγγγβγγγ β
βγβ³βγ ββ³γ β
βγγγγγγ β
βγγγβ»γγγ β
βγγγγγγ β
βββγγγβββββ
βγγγβ η₯ε
½δΏδ½
βγγγβ
βγγγβββββββββββ
βγγγγγγγ β£β
βγγγγ ββ
βββ β βββββ³ β βββ
β β« β« β β« β«
βββ»ββ βββ»ββ
*/
// Create by JJL
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <queue>
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
const int N=2000010,mod=1e9+7;
vector<int> v;
inline int read(){
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-') f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
return x*f;
}
int main(){
int T;
cin>>T;
while(T--){
LL n;
scanf("%lld",&n);
v.clear();
if(n%2){
puts("-1");
}
else {
LL ans=0;
for(int i=1;i<=63;++i){
if(n&(1ll<<i)){
v.push_back(i);
ans=ans+i;
}
}
printf("%d\n",ans);
for(int i=0;i<v.size();++i){
cout<<"1 ";
for(int j=1;j<v[i]-1;++j)
cout<<0<<' ';
if(v[i]!=1) cout<<"1 ";
}
puts("");
}
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> pega[200005];
int peg[200005], id[200005], rev[200005];
int main() {
ios::sync_with_stdio(false);
int n, q, p;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> pega[i].first;
pega[i].second = i;
}
sort(pega + 1, pega + n + 1);
for (int i = 1; i <= n; i++) {
peg[i] = pega[i].first;
id[i] = pega[i].second;
rev[id[i]] = i;
}
for (int i = 0; i < q; i++) {
int remain;
cin >> p >> remain;
p = rev[p];
int lastleft = 0, lastright = 0, dir = 0;
int fail = 0;
while (true) {
if (dir == 0) {
int rightmost =
upper_bound(peg + p, peg + n + 1, peg[p] + remain) - peg;
rightmost--;
if (rightmost == p) {
if (fail) {
cout << id[p] << endl;
break;
} else {
fail = 1;
dir = 1;
continue;
}
}
remain -= peg[rightmost] - peg[p];
if (rightmost != lastright) {
lastleft = 0;
}
lastright = p = rightmost;
dir = 1;
} else {
int leftmost = lower_bound(peg + 1, peg + p, peg[p] - remain) - peg;
if (leftmost == p) {
if (fail) {
cout << id[p] << endl;
break;
} else {
fail = 1;
dir = 0;
continue;
}
}
if (lastright > 0 && leftmost == lastleft) {
remain %= (peg[lastright] - peg[lastleft]) * 2;
lastleft = lastright = 0;
} else {
remain -= peg[p] - peg[leftmost];
lastleft = p = leftmost;
dir = 0;
}
}
}
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const int MM = 1200000;
long long int m, n, k, p1, p2, p3, p, f, a[MM];
string s, s1, s2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
m = sqrt(n);
for (long long int i = 1; i <= m; i++) {
if ((i + n) % 3 == 0) {
if ((i * (i + 1)) / 2 <= (i + n) / 3) p1++;
}
}
cout << p1;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const double eps = 1e-11;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long mul(long long a, long long b) {
long long ans = 0;
a %= mod, b %= mod;
while (b) {
if (b & 1) ans = (ans + a) % mod;
a = (a * 2) % mod;
b >>= 1;
}
return ans;
}
long long powmod(long long a, long long b) {
long long ans = 1, pow = a;
while (b) {
if (b & 1) ans = (ans * pow) % mod;
pow = (pow * pow) % mod;
b >>= 1;
}
return ans;
}
int pr(long long num) {
if (num == 1) return 0;
if (num == 2 || num == 3) return 1;
if (num % 6 != 1 && num % 6 != 5) return 0;
int tmp = sqrt(num);
for (int i = 5; i <= tmp; i += 6)
if (num % i == 0 || num % (i + 2) == 0) return 0;
return 1;
}
int Day(int y, int m, int d) {
if (m == 1 || m == 2) {
m += 12;
y--;
}
int w = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400) % 7;
return w + 1;
}
long long C(long long n, long long m) {
if (n < m) return 0;
long long res = 1;
for (int i = 1; i <= m; i++) {
long long a = (n + i - m) % mod;
long long b = i % mod;
res = res * (a * powmod(b, mod - 2) % mod) % mod;
}
return res;
}
long long Lucas(long long n, long long m) {
if (m == 0) return 1;
return C(n % mod, m % mod) * Lucas(n / mod, m / mod) % mod;
}
const int maxn = 2e5 + 5;
long long a[maxn];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
map<char, int> mp;
int maxx = 0;
char ans;
for (auto i : s) {
mp[i]++;
if (mp[i] > maxx) {
maxx = mp[i];
ans = i;
}
}
if (ans == 'R')
cout << string(s.size(), 'P') << '\n';
else if (ans == 'P')
cout << string(s.size(), 'S') << '\n';
else
cout << string(s.size(), 'R') << '\n';
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> h[N];
long long w[N], down[N], up[N], sum_down[N], sum_up[N];
void dfs_down(int u, int fa) {
down[u] = sum_down[u] = w[u];
for (int i = 0; i < h[u].size(); i++) {
int j = h[u][i];
if (j == fa) continue;
dfs_down(j, u);
sum_down[u] += sum_down[j];
down[u] += down[j] + sum_down[j];
}
}
void dfs_up(int u, int fa) {
for (int i = 0; i < h[u].size(); i++) {
int j = h[u][i];
if (j == fa) continue;
sum_up[j] = sum_down[u] - sum_down[j] + sum_up[u];
up[j] = up[u] + down[u] - down[j] + sum_up[j] - sum_down[j];
dfs_up(j, u);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
h[a].push_back(b);
h[b].push_back(a);
}
dfs_down(1, -1);
dfs_up(1, -1);
long long res = 0;
for (int i = 1; i <= n; i++) res = max(res, up[i] + down[i]);
printf("%lld", res - sum_down[1]);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 100;
int n, temp;
int arr[MAXN + 1]{};
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
arr[temp]++;
}
int ans = 0;
for (int i = 0; i <= 100; i++) {
ans += arr[i] / 2;
}
cout << ans / 2 << endl;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.);
const int maxn = 100100;
int head;
int p[maxn], pm[maxn], ks, rz[maxn];
vector<int> beg;
void dfs(int u) {
if (!pm[u]) {
pm[u] = ks;
rz[head]++;
dfs(p[u]);
return;
}
}
int main() {
{
srand(time(0));
const string file = "";
if (!file.empty()) {
freopen((file + ".in").c_str(), "r", stdin);
freopen((file + ".out").c_str(), "w", stdout);
}
}
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
bool ok1 = 0, ok2 = 0;
int p1, p2;
for (int i = 1; i <= n; i++) {
if (!pm[i]) {
beg.push_back(i);
head = i;
ks++;
rz[i] = 0;
dfs(i);
if (rz[i] == 1) {
ok1 = 1;
p1 = i;
}
if (rz[i] == 2) {
ok2 = 1;
p2 = i;
}
}
}
if (ok1) {
printf("YES\n");
for (int i = 0; i < (int)beg.size(); i++) {
if (p1 != beg[i]) {
for (int f = p[beg[i]]; f != beg[i]; f = p[f]) {
printf("%d %d\n", p1, f);
}
printf("%d %d\n", p1, beg[i]);
}
}
} else if (ok2) {
for (int i = 0; i < (int)beg.size(); i++) {
if (rz[beg[i]] & 1) {
printf("NO\n");
return (0);
}
}
p1 = p2;
printf("YES\n");
for (int i = 0; i < (int)beg.size(); i++) {
if (p1 != beg[i]) {
for (int f = p[beg[i]], g = p[p1]; f != beg[i]; f = p[f], g = p[g]) {
printf("%d %d\n", g, f);
}
printf("%d %d\n", p1, beg[i]);
}
}
printf("%d %d\n", p1, p[p1]);
} else {
printf("NO\n");
return (0);
}
return (0);
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int q, n;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> n;
if (n == 2)
cout << 2 << "\n";
else {
if (n % 2 != 0)
cout << 1 << "\n";
else
cout << 0 << "\n";
}
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
map<long long, bool> tz;
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b, b % a);
}
int cnk(long long n, long long k, long long mod) {
long long result = 1;
int lal = 0;
for (int lol = n; lal < k; lal++, lol--) {
result *= lol;
result %= mod;
}
return result;
}
string s;
const long long mod = 1e9 + 7;
vector<long long> graph[100000];
vector<long long> vec1, vec2, vec3;
vector<pair<long long, long long> > vec;
long long res;
long long mas[10][10];
int main() {
string s1, s2;
cin >> s1 >> s2;
long long kol1 = 0, kol2 = 0;
for (long long lol = 0; lol < s1.length(); lol++) {
if (s1[lol] > s2[lol]) kol1++;
if (s1[lol] < s2[lol]) kol2++;
}
cout << (max(kol1, kol2));
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
namespace Solve1 {
const int maxn = 100005;
const int spc = 4000005;
struct SegmentTree {
int sumv[spc], lc[spc], rc[spc], rt[spc], np;
void Initial() {
np = 0;
memset(rt, 0, sizeof(rt));
memset(lc, 0, sizeof(lc));
memset(rc, 0, sizeof(rc));
memset(sumv, 0, sizeof(sumv));
return;
}
int Copynode(int pre) {
++np;
sumv[np] = sumv[pre];
lc[np] = lc[pre], rc[np] = rc[pre];
return np;
}
void pushup(int now) {
if (!now) return;
sumv[now] = sumv[lc[now]] + sumv[rc[now]];
return;
}
void Build(int &now, int L, int R) {
now = ++np;
if (L == R) return;
int m = (L + R) >> 1;
Build(lc[now], L, m);
Build(rc[now], m + 1, R);
return;
}
void Update(int pre, int &now, int L, int R, int i, int d) {
now = Copynode(pre);
if (L == R && L == i) {
sumv[now] += d;
return;
}
int m = (L + R) >> 1;
if (i <= m)
Update(lc[pre], lc[now], L, m, i, d);
else
Update(rc[pre], rc[now], m + 1, R, i, d);
pushup(now);
return;
}
int Qpos(int now, int L, int R, int k) {
int low = L, upp = R, mid = -1, ret = -1;
while (low < upp) {
int mid = (low + upp) >> 1;
if (sumv[lc[now]] <= k)
k -= sumv[lc[now]], ret = mid, low = mid + 1, now = rc[now];
else
upp = mid, now = lc[now];
}
if (low == upp && sumv[now] <= k) ret = low;
return ret;
}
} ST;
int n, cnt, A[maxn], B[maxn];
int first[maxn], next[maxn], last[maxn];
void work() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
memcpy(B, A, sizeof(B));
cnt = 1;
sort(B + 1, B + n + 1);
for (int i = 2; i <= n; i++)
if (B[i] != B[i - 1]) B[++cnt] = B[i];
for (int i = 1; i <= n; i++) A[i] = lower_bound(B + 1, B + cnt + 1, A[i]) - B;
ST.Initial();
ST.Build(ST.rt[1], 1, n);
memset(next, 0, sizeof(next));
memset(last, 0, sizeof(last));
memset(first, 0, sizeof(first));
for (int i = 1; i <= n; i++) {
if (!first[A[i]])
first[A[i]] = last[A[i]] = next[i] = i;
else
next[last[A[i]]] = i, last[A[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (i == first[A[i]]) ST.Update(ST.rt[1], ST.rt[1], 1, n, i, 1);
}
for (int i = 1; i < n; i++) {
ST.rt[i + 1] = ST.rt[i];
if (i == last[A[i]])
ST.Update(ST.rt[i + 1], ST.rt[i + 1], 1, n, i, -1);
else {
ST.Update(ST.rt[i + 1], ST.rt[i + 1], 1, n, next[i], 1);
ST.Update(ST.rt[i + 1], ST.rt[i + 1], 1, n, i, -1);
}
}
for (int k = 1; k <= n; k++) {
int now = 1, ans = 0;
while (now <= n) {
ans++;
now = ST.Qpos(ST.rt[now], 1, n, k) + 1;
}
printf("%d ", ans);
}
printf("\n");
return;
}
} // namespace Solve1
int main() {
Solve1::work();
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
char ch[N];
int flag[N];
int main() {
int n, i, f;
scanf("%s", ch + 1);
n = strlen(ch + 1);
if (n == 1)
puts("0");
else {
f = 0;
for (i = 1; i <= n; i++)
if (ch[i] == '0') {
f = 1;
flag[i] = 1;
break;
}
if (f) {
for (i = 1; i <= n; i++)
if (!flag[i]) printf("%c", ch[i]);
return 0;
}
for (i = n; i >= 1; i--)
if (ch[i] == '1') {
flag[i] = 1;
break;
}
for (i = 1; i <= n; i++)
if (!flag[i]) printf("%c", ch[i]);
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
vector<int> E[301000];
int IT[524288 + 524288 + 2], n, Q, C[301000], Num[301000], cnt, Ed[301000],
ReNum[301000];
void DFS(int a) {
Num[a] = ++cnt;
ReNum[cnt] = a;
C[a] = 1;
for (int i = 0; i < E[a].size(); i++) {
DFS(E[a][i]);
C[a] += C[E[a][i]];
}
Ed[a] = cnt;
}
void Ins(int a, int b) {
a += 524288;
IT[a] = b;
while (a != 1) {
a >>= 1;
IT[a] = max(IT[a * 2], IT[a * 2 + 1]);
}
}
int Do(int a, int c) {
a += 524288;
int r = 0;
while (1) {
r = max(r, IT[a]);
if (r * 2 > c) break;
a = (a - 1) >> 1;
}
while (a < 524288) {
a = a * 2 + 1;
if (IT[a] * 2 <= c) a--;
}
return a - 524288;
}
int main() {
int i, a;
scanf("%d%d", &n, &Q);
for (i = 2; i <= n; i++) {
scanf("%d", &a);
E[a].push_back(i);
}
DFS(1);
for (i = 1; i <= n; i++) {
Ins(Num[i], C[i]);
}
while (Q--) {
scanf("%d", &a);
printf("%d\n", ReNum[Do(Ed[a], C[a])]);
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const int MAXN = 200010;
pair<int, int> v[MAXN];
pair<int, int> va[MAXN];
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> v[i].first >> v[i].second;
if (v[i].first > v[i].second) swap(v[i].first, v[i].second);
}
sort(v, v + m);
for (int i = 1; i < n; i++) {
if ((n % i) == 0) {
for (int j = 0; j < m; j++) {
va[j] = {v[j].first + i, v[j].second + i};
if (va[j].first > n) va[j].first -= n;
if (va[j].second > n) va[j].second -= n;
if (va[j].first > va[j].second) swap(va[j].first, va[j].second);
}
sort(va, va + m);
bool igual = true;
for (int j = 0; j < m; j++) {
if (v[j] != va[j]) {
igual = false;
break;
}
}
if (igual) {
cout << "Yes" << '\n';
return 0;
}
}
}
cout << "No" << '\n';
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[500], b, tcase = 1, t, n, i, j, mx = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mx += a[i];
}
int f = 1;
i = 1;
j = 0;
while (mx > 0) {
int fl = 1;
int x = a[i];
if (x) {
printf("P");
mx--;
a[i]--;
}
if (f && i != n) {
if (mx) printf("R");
fl = 0;
} else {
if (i != 1 && mx) {
printf("L");
fl = 0;
}
}
if (!f && i != 1 && fl) {
if (mx) printf("L");
} else {
if (fl && mx) printf("R");
}
if (i == n) f = 0;
if (i == 1) f = 1;
if (f)
i++;
else
i--;
}
printf("\n");
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long dp[5001][5001];
long long aa[5001], n, k;
long long dfs(long long x, long long l) {
if (x >= n) return 0;
if (l <= 0) return 0;
if (dp[x][l] != -1) return dp[x][l];
return dp[x][l] = max(aa[x] + dfs(x + aa[x], l - 1), dfs(x + 1, l));
}
int32_t main() {
fastio();
for (long long i = 0; i < 5001; i++)
for (long long j = 0; j < 5001; j++) dp[i][j] = -1;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (long long i = 0; i < n; i++) {
long long ct = 1;
for (long long j = i + 1; j < n; j++) {
if (a[j] - a[i] <= 5) ct++;
}
aa[i] = ct;
}
cout << max(k, dfs(0, k));
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 500 * 1000;
int ans[max_n * 2];
int main() {
int n;
cin >> n;
memset(ans, -1, sizeof ans);
int a = 0, b = n - 1, c = n, d = 2 * n - 2;
for (int i = (1); i < (n); i++)
if (i & 1) {
ans[a] = ans[b] = i;
a++, b--;
} else {
ans[c] = ans[d] = i;
c++, d--;
}
for (int i = 0; i < (2 * n); i++)
if (ans[i] == -1) ans[i] = n;
for (int i = 0; i < (2 * n); i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 11
|
#include <bits/stdc++.h>
int main() {
char arr1[103];
char arr2[103];
int s1, s2, i, k, j, flag = 1;
gets(arr1);
gets(arr2);
s1 = strlen(arr1);
s2 = strlen(arr2);
if (s1 != s2) {
printf("NO");
return 0;
}
i = 0;
j = strlen(arr1) - 1;
for (k = 0; k < s1; k++) {
if (arr1[i] != arr2[j]) {
flag = 0;
break;
}
i++;
j--;
}
if (flag == 1)
printf("YES");
else
printf("NO");
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 999999;
const long long INF = 1e16;
vector<long long> split(long long k) {
long long cur = 1;
vector<long long> ans;
while (k > 0) {
long long nxt = min(cur, k);
ans.push_back(nxt);
k -= nxt;
cur *= 2;
}
return ans;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long k;
cin >> k;
vector<long long> f(6);
for (long long i = 0; i < 6; i++) {
cin >> f[i];
}
vector<pair<long long, long long>> knapitems;
vector<long long> sp = split(3 * k - 3);
for (long long i : sp) {
long long p = 1;
for (long long j = 0; j < 6; j++) {
knapitems.emplace_back(p * 3 * i, f[j] * i);
p *= 10;
}
}
vector<long long> dp(MAXN + 1, -INF);
dp[0] = 0;
for (auto [cost, val] : knapitems) {
for (long long j = MAXN; j >= cost; j--) {
dp[j] = max(dp[j], dp[j - cost] + val);
}
}
long long p = 1;
for (long long j = 0; j < 6; j++) {
knapitems.clear();
for (long long i = 1; i <= 9; i++) {
long long d = 0;
if (i % 3 == 0) d = i / 3;
knapitems.emplace_back(p * i, d * f[j]);
}
for (long long j = MAXN; j >= 0; j--) {
for (auto [cost, val] : knapitems) {
if (j >= cost) dp[j] = max(dp[j], dp[j - cost] + val);
}
}
p *= 10;
}
long long q;
cin >> q;
while (q--) {
long long x;
cin >> x;
cout << dp[x] << '\n';
}
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
int p10[1000100], n, d[256];
string s, digits = "1689";
int main() {
ios::sync_with_stdio(0);
p10[0] = 1;
for (int i = 1; i <= 1000000; i++) p10[i] = p10[i - 1] * 10 % 7;
d['1'] = d['6'] = d['8'] = d['9'] = 1;
cin >> s;
n = s.size();
for (int i = 0; i < 4; i++)
for (int j = i; j < n; j++)
if (s[j] == digits[i]) {
swap(s[j], s[i]);
break;
}
int rem = 0;
for (int i = 4; i < n; i++) rem = (rem + (s[i] - '0') * p10[n - 1 - i]) % 7;
do {
int curRem = 0;
for (int i = 0; i < 4; i++) curRem = (curRem * 10 + digits[i] - '0') % 7;
if ((curRem * p10[n - 4] + rem) % 7 == 0) {
for (int i = 0; i < 4; i++) s[i] = digits[i];
cout << s << endl;
return 0;
}
} while (next_permutation(digits.begin(), digits.end()));
cout << "0\n";
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200010;
const long long MOD = (int)1e9 + 7;
const int INF = 1e9;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-8;
long long tab[101][101][101];
string s;
vector<int> val;
long long dp(int l, int r, int qt) {
if (l > r) return 0;
if (tab[l][r][qt] != -1) return tab[l][r][qt];
long long res = dp(l + 1, r, 1) + val[qt];
for (int i = l + 1; i <= r; i++) {
if (s[l] == s[i]) {
res = max(res, dp(l + 1, i - 1, 1) + dp(i, r, qt + 1));
}
}
return tab[l][r][qt] = res;
}
int32_t main() {
memset(tab, -1, sizeof(tab));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n >> s;
val.assign(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> val[i];
}
cout << dp(0, n - 1, 1) << '\n';
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
int a[26] = {0};
for (int i = 0; i < n; i++) {
a[s[i] - 'a']++;
}
int flag = 0;
for (int i = 0; i < 26; i++) {
if (a[i] > k) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)1e9 + 10;
const long long int INFLL = (long long int)1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-18;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const int MAX_N = 100010;
int n;
int ansv, cnt;
vector<int> ans[MAX_N];
int main() {
scanf("%d", &n);
while (ansv * (ansv + 1) / 2 <= n) ansv++;
for (long long int i = (1); i < (long long int)(ansv); i++) {
for (long long int j = (0); j < (long long int)(i); j++) {
ans[i].emplace_back(cnt);
ans[j].emplace_back(cnt);
cnt++;
}
}
printf("%d\n", ansv);
for (long long int i = (0); i < (long long int)(ansv); i++)
for (long long int j = (0);
j < (long long int)(((long long int)(ans[i]).size())); j++)
printf("%d%c", ans[i][j] + 1,
(j == ((long long int)(ans[i]).size()) - 1 ? '\n' : ' '));
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
long long lca(unordered_map<long long, long long> &weights, long long v,
long long u, long long w) {
long long result = 0;
while (v != u) {
if (v > u) {
result += weights[v];
weights[v] += w;
v /= 2;
} else {
result += weights[u];
weights[u] += w;
u /= 2;
}
}
return result;
}
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(10);
int q, t;
long long v, u, w;
unordered_map<long long, long long> weights;
cin >> q;
for (size_t i = 0; i < q; ++i) {
cin >> t >> v >> u;
if (t == 1) {
cin >> w;
lca(weights, v, u, w);
} else {
cout << lca(weights, v, u, 0) << '\n';
}
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
signed func(long long int a, long long int b, long long int x,
long long int y) {
if (x - y - b <= 0 && x - y + b >= 0 && x + y - 2 * a + b <= 0 &&
x + y - b >= 0)
return 1;
return 0;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int a, b;
cin >> a >> b;
long long int m;
cin >> m;
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
if (func(a, b, x, y))
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> tree[200005];
vector<long long> v;
int dp[200005], a[200005];
int h[200005];
int c = 1;
void dfs(int node, int p) {
h[c++] = node;
for (auto i : tree[node]) {
if (i.first != p) {
v.push_back(v.back() + i.second);
long long x = v.back() - a[i.first];
int ans = 0;
if (x < v[0])
ans = v.size() - 1;
else {
ans = lower_bound(v.begin(), v.end(), x) - v.begin();
ans = v.size() - ans - 1;
}
x = c - ans - 1;
dp[node]++;
dp[h[x]]--;
dfs(i.first, node);
}
}
v.pop_back();
c--;
}
void dfs2(int node, int p) {
for (auto i : tree[node]) {
if (i.first != p) {
dfs2(i.first, node);
dp[node] += dp[i.first];
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 2; i <= n; i++) {
int x, w;
cin >> x >> w;
tree[i].push_back(make_pair(x, w));
tree[x].push_back(make_pair(i, w));
}
v.push_back(0);
dfs(1, -1);
dfs2(1, -1);
for (int i = 1; i <= n; i++) cout << dp[i] << " ";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
const int MAX_N = 100010;
int n;
int par[MAX_N];
vector<int> ch[MAX_N];
int maxdepth[MAX_N];
vector<int> res;
void computeDepths(int u) {
int res = 0;
for (int v : ch[u]) {
computeDepths(v);
ckmax(res, maxdepth[v] + 1);
}
maxdepth[u] = res;
}
void solve(int u) {
if ((int)ch[u].size() == 0)
return;
else if ((int)ch[u].size() == 1)
solve(ch[u][0]);
else {
int other = ch[u][(int)ch[u].size() - 2];
pair<int, int> bes = make_pair(maxdepth[ch[u].back()], ch[u].back());
maxdepth[other] = bes.first + 1;
res.push_back(bes.second);
ch[u].pop_back();
ch[other].push_back(bes.second);
solve(u);
}
}
vector<pair<int, int> > chsorted[MAX_N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> par[i];
ch[par[i]].push_back(i);
}
computeDepths(0);
for (int i = 1; i < n; i++) {
chsorted[par[i]].push_back(make_pair(maxdepth[i], i));
}
for (int i = 0; i < n; i++) {
sort(chsorted[i].begin(), chsorted[i].end());
ch[i].clear();
for (pair<int, int> p : chsorted[i]) ch[i].push_back(p.second);
}
solve(0);
vector<int> nodes;
int cur = 0;
nodes.push_back(cur);
while (1) {
if ((int)ch[cur].size() == 1) {
cur = *ch[cur].begin();
nodes.push_back(cur);
} else {
break;
}
}
for (int i = 0; i < n; i++) cout << nodes[i] << " ";
reverse(res.begin(), res.end());
cout << "\n";
cout << (int)res.size() << "\n";
for (int x : res) cout << x << " ";
cout << "\n";
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int k = 0; k < t; k++) {
int n;
cin >> n;
if (n % 2 == 0) {
for (int i = 0; i < n / 2; i++) cout << 1;
cout << endl;
} else {
cout << 7;
for (int i = 0; i < n / 2 - 1; i++) cout << 1;
cout << endl;
}
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
long long modInverse(long long a, long long m);
long long gcd(long long a, long long b);
long long power(long long x, unsigned long long y, unsigned long long m);
void pairsort(int a[], int b[], int n);
long long logint(long long x, long long y);
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long power(long long x, unsigned long long y, unsigned long long m) {
if (y == 0) return 1;
long long p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long modInverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
void pairsort(int a[], int b[], int n) {
pair<int, int> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long logint(long long x, long long y) {
long long ans = 0;
long long a = 1;
for (long long i = 0; i < x; i++) {
if (x <= a) {
return ans;
}
ans++;
a *= y;
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int a[n];
int curi = 0;
int sami = 0;
int dp[n];
int f = 0;
for (long long i = 0; i < n; i++) {
int t;
cin >> t;
a[i] = t;
if (i == 0) {
dp[0] = 0;
} else {
int s = a[i - 1];
if (t > s && f == 0) {
sami = i;
} else if (t > s && f == 1) {
for (long long j = curi; j < sami; j++) {
dp[j] = i - 1;
}
curi = sami;
sami = i;
f = 0;
} else if (t < s && f == 0) {
f = 1;
sami = i;
} else if (t < s && f == 1) {
sami = i;
}
}
}
for (long long j = curi; j < n; j++) {
dp[j] = n - 1;
}
for (long long i = 0; i < m; i++) {
int t1, t2;
cin >> t1 >> t2;
if (dp[t1 - 1] >= t2 - 1) {
cout << "Yes\n";
} else
cout << "No\n";
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long ar[3000];
int main() {
long long x, n, i, j, k, s = 0, v = 0;
cin >> x;
for (i = 0; i < x; i++) {
cin >> k;
s += k;
}
cin >> n;
for (i = 0; i < 2 * n; i++) cin >> ar[i];
if (ar[2 * n - 1] < s || n == 0) {
cout << "-1" << endl;
} else {
for (i = 0; i < (2 * n) - 1; i++) {
if (i % 2 == 0) {
if (i == 0 && s < ar[i]) {
i--;
break;
}
if (ar[i] <= s && ar[i + 1] >= s) {
v = 1;
break;
}
} else {
if (ar[i] < s && ar[i + 1] > s) {
v = 2;
break;
}
}
}
if (v == 1)
cout << s << endl;
else
cout << ar[i + 1] << endl;
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void build_z_function(string& s, vector<int>& z) {
int n = s.size();
z = vector<int>(n);
z[0] = n;
int L = 0, R = 0;
for (int i = 1; i < n; i++) {
if (i > R) {
L = R = i;
while (R < n && s[R - L] == s[R]) {
R++;
}
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1) {
z[i] = z[k];
} else {
L = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
using ll = long long;
ll mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, m;
string s;
cin >> n >> m >> s;
string ans(n, '?');
vector<int> z;
build_z_function(s, z);
bool flag = true;
for (int i = 0, last = 0; i < m; i++) {
int k;
cin >> k;
--k;
if (k >= last) {
for (int j = 0; j < s.size(); j++) {
ans[k + j] = s[j];
}
} else {
int l = (k - last) + int(s.size());
if (l + z[l] == int(s.size())) {
for (int j = last - k; j < s.size(); j++) {
ans[k + j] = s[j];
}
} else {
flag = false;
break;
}
}
last = k + s.size();
}
ll total = 0;
if (flag) {
total = 1;
for (char ch : ans) {
if (ch == '?') {
total = (total * 26LL) % mod;
}
}
}
cout << total << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
bool sol(int i, int s, int n) {
if (i == n) {
if (s % 360 == 0)
return 1;
else
return 0;
}
return sol(i + 1, s + v[i], n) || sol(i + 1, s - v[i], n);
}
int main() {
int n, k;
char c = 'a', f = 'c';
cin >> n >> k;
string s;
if (n < k || k == 1 && n != 1) {
cout << -1 << endl;
return 0;
}
while (s.size() < n) {
if (s.size() < n - k + 2) {
if (c == 'a') {
s.push_back(c);
c = 'b';
} else if (c == 'b') {
s.push_back(c);
c = 'a';
}
} else {
s.push_back(f);
f++;
}
}
cout << s << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, maxLength = 0, counter = 0;
cin >> n;
int freq[1001] = {};
for (int i = 0; i < n; i++) {
int number;
cin >> number;
freq[number]++;
}
for (int i = 0; i < 1001; i++) {
if (freq[i]) counter++;
if (freq[i] > maxLength) maxLength = freq[i];
}
cout << maxLength << " " << counter << endl;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using llu = unsigned long long;
vector<ll> v[200005];
ll vis[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t, n, m, i, j, k;
cin >> n;
ll a[n + 1];
for (i = 1; i <= n; i++) cin >> a[i];
ll ans[n + 1];
memset(ans, -1, sizeof(ans));
queue<ll> q;
for (i = 1; i <= n; i++) {
if (i - a[i] > 0) v[i - a[i]].push_back(i);
if (i + a[i] <= n) v[i + a[i]].push_back(i);
if (i - a[i] > 0 && (a[i] % 2 != a[i - a[i]] % 2)) ans[i] = 1;
if (i + a[i] <= n && (a[i] % 2 != a[i + a[i]] % 2)) ans[i] = 1;
if (ans[i] == 1) q.push(i), vis[i] = 1;
}
while (!q.empty()) {
k = q.front();
q.pop();
for (auto y : v[k]) {
if (vis[y] == 0) {
ans[y] = ans[k] + 1;
q.push(y);
vis[y] = 1;
}
}
}
for (i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int pos[100500];
int d[100500];
int res[100500];
int main() {
int n, cur;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &cur);
pos[cur] = i;
}
vector<int> por(n);
set<pair<int, int> > decrease;
set<pair<int, int> > increase;
for (int i = 0; i < n; i++) {
scanf("%d", &cur);
if (pos[cur] >= i) {
d[cur] = pos[cur] - i;
decrease.insert(make_pair(d[cur], cur));
} else {
d[cur] = i - pos[cur];
increase.insert(make_pair(d[cur], cur));
}
por[n - i - 1] = cur;
}
for (int time = 0; time < n; time++) {
int mn = n + 1;
if (!decrease.empty() && decrease.begin()->first - time < mn)
mn = decrease.begin()->first - time;
if (!increase.empty() && increase.begin()->first + time < mn)
mn = increase.begin()->first + time;
res[time] = mn;
while (!decrease.empty() && decrease.begin()->first == time) {
cur = decrease.begin()->second;
d[cur] = -time;
increase.insert(make_pair(d[cur], cur));
decrease.erase(decrease.begin());
}
increase.erase(make_pair(d[por[time]], por[time]));
d[por[time]] = time + pos[por[time]] + 1;
decrease.insert(make_pair(d[por[time]], por[time]));
}
printf("%d\n", res[0]);
for (int i = n - 1; i; i--) printf("%d\n", res[i]);
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void cmin(T &a, T b) {
((a > b) && (a = b));
}
template <class T>
inline void cmax(T &a, T b) {
((a < b) && (a = b));
}
char IO;
template <class T = int>
T rd() {
T s = 0;
int f = 0;
while (!isdigit(IO = getchar())) f |= IO == '-';
do s = (s << 1) + (s << 3) + (IO ^ '0');
while (isdigit(IO = getchar()));
return f ? -s : s;
}
const int N = 1 << 18, INF = 1e9 + 10;
int n, a[N], F[N];
long long ans;
int Find(int x) { return F[x] == x ? x : F[x] = Find(F[x]); }
int main() {
n = rd();
for (int i = 1, iend = n; i <= iend; ++i) {
int x = rd();
a[x]++, ans -= x;
}
a[0]++;
for (int i = 0, iend = N - 1; i <= iend; ++i) F[i] = i;
for (int i = N - 1, iend = 1; i >= iend; --i) {
for (int S = i, T; (S ^ i) <= S; S = (S - 1) & i)
if (a[S] && a[T = S ^ i] && Find(S) != Find(T)) {
ans += 1ll * (a[S] + a[T] - 1) * i;
a[S] = a[T] = 1, F[Find(S)] = Find(T);
}
}
printf("%lld\n", ans);
}
| 27
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, k, c[N], f[N], h[N];
int dp[505][5505];
int main() {
cin >> n >> k;
int num;
for (int i = 1; i <= n * k; ++i) {
cin >> num;
++c[num];
}
for (int i = 1; i <= n; ++i) {
cin >> num;
++f[num];
}
for (int i = 1; i <= k; ++i) {
cin >> h[i];
}
for (int x = 0; x < n; ++x) {
for (int y = 0; y <= n * k; ++y) {
for (int i = 0; i <= k; ++i) {
dp[x + 1][y + i] = max(dp[x + 1][y + i], dp[x][y] + h[i]);
}
}
}
long long ans = 0;
for (int i = 1; i <= 100000; ++i) {
ans += dp[f[i]][c[i]];
}
cout << ans << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int a[n][6];
map<int, int> m1, m2, m3;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 6; ++j) {
cin >> a[i][j];
if (i == 0) ++m1[a[i][j]];
if (i == 2) ++m3[a[i][j]];
if (i == 1) ++m2[a[i][j]];
}
}
for (int i = 1; i <= 999; ++i) {
int d1 = i % 10, d2 = (i / 10) % 10, d3 = (i / 100) % 10;
if (d3 != 0) {
if ((m1[d3] && m2[d2] && m3[d1]) || (m1[d3] && m2[d1] && m3[d2]) ||
(m1[d2] && m2[d3] && m3[d1]) || (m1[d2] && m2[d1] && m3[d3]) ||
(m1[d1] && m2[d2] && m3[d3]) || (m1[d1] && m2[d3] && m3[d2])) {
continue;
} else {
cout << i - 1 << endl;
return 0;
}
} else if (d2 != 0) {
if ((m1[d1] && m2[d2]) || (m1[d1] && m3[d2]) || (m2[d1] && m1[d2]) ||
(m2[d1] && m3[d2]) || (m3[d1] && m1[d2]) || (m3[d1] && m2[d2])) {
continue;
} else {
cout << i - 1 << endl;
return 0;
}
} else {
if (m1[d1] || m2[d1] || m3[d1])
continue;
else {
cout << i - 1 << endl;
return 0;
}
}
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007ll;
void ad(long long &a, long long b) { a = (a + b) % mod; }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n;
scanf("%d", &n);
vector<long long> a(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
vector<int> p(n);
for (int i = 1; i < n; i++) {
scanf("%d", &p[i]);
p[i]--;
}
vector<long long> A = a;
for (int i = n - 1; i > 0; i--) {
A[p[i]] += A[i];
}
vector<long long> C(n + 1, 0);
for (int i = 1; i < n; i++) {
long long k = A[0] / gcd(A[0], A[i]);
if (k <= n) {
C[k]++;
}
}
vector<long long> D(n + 1, 0);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
D[j] += C[i];
}
}
long long ans = 0;
vector<long long> dp(n + 1, 0ll);
dp[1] = 1ll;
for (int i = 1; i <= n; i++) {
if (D[i] < i - 1) continue;
ad(ans, dp[i]);
for (int j = 2 * i; j <= n; j += i) {
if (D[j] >= j - 1) {
ad(dp[j], dp[i]);
}
}
}
printf("%lld\n", ans);
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
bool st[2000], ed[2000];
char a[2001], b[2001], c[2001];
int md = 1e9 + 13;
double ch = 27.321;
set<double> s[2000];
double dd(double x) { return x - floor(x / md) * md; }
void nxt(double &x) {
double z = dd(x * ch);
z = floor(z * 1000) / 1000;
x = z;
}
int main() {
scanf("%s%s%s", a, b, c);
int n = strlen(a), nb = strlen(b), nc = strlen(c);
for (int i = 0; i < n; ++i)
for (int j = 0; j < nb; ++j) {
if (i + j == n || b[j] != a[i + j]) break;
if (j + 1 == nb) st[i] = true;
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < nc; ++j) {
if (i + j == n || c[j] != a[i + j]) break;
if (j + 1 == nc) ed[i + j] = true;
}
string g = a;
int l = max(nb, nc);
for (int i = 0; i < n; ++i) {
double z = 0, p = 1;
for (int j = i; j < i + l - 1; ++j)
z = dd(z + (a[j] - 'a' + 1) * p), nxt(p);
for (int j = i + l - 1; j < n; ++j) {
z = dd(z + (a[j] - 'a' + 1) * p), nxt(p);
if (st[i] && ed[j]) s[j - i].insert(z);
}
}
int an = 0;
for (int i = 0; i < n; ++i) an += s[i].size();
printf("%d", an);
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
if (n <= 2) {
cout << "1\n";
continue;
}
n -= 2;
int ans = 1;
ans += (n + x - 1) / x;
cout << ans << endl;
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int ans, n, cur, d[100100], a[100100];
int main() {
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cur = 0;
for (int j = 2; j * j <= a[i]; j++)
if (a[i] % j == 0) {
cur = max(cur, d[a[i] / j]);
cur = max(cur, d[j]);
}
d[a[i]] = cur + 1;
ans = max(ans, cur + 1);
for (int j = 2; j * j <= a[i]; j++)
if (a[i] % j == 0) {
d[j] = max(d[j], d[a[i]]);
d[a[i] / j] = max(d[a[i] / j], d[a[i]]);
}
}
cout << ans;
return 0;
}
| 7
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long int const mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, a, b, x, d, d1, d2;
cin >> t;
while (t--) {
cin >> a >> b;
d = abs(a - b);
d1 = max(a, b);
d2 = min(a, b);
d1 -= 2 * d;
d2 -= d;
x = min(d1, d2);
a = max(d1, d2);
if (x == 1 && a == 2)
cout << "YES"
<< "\n";
else if (x == a && x >= 0) {
if (x % 3 == 0)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
} else
cout << "NO"
<< "\n";
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
string B = "BRG";
string R = "RGB";
string G = "GBR";
string s;
int l, r, k, n, res, t;
int inB, inR, inG;
void solve() {
res = 1000000;
cin >> n >> k;
cin >> s;
l = r = inB = inR = inG = 0;
while (r < n) {
if (r - l == k) {
res = min(res, min(inB, min(inR, inG)));
if (s[l] != B[l % 3]) inB--;
if (s[l] != G[l % 3]) inG--;
if (s[l] != R[l % 3]) inR--;
l++;
}
if (s[r] != B[r % 3]) inB++;
if (s[r] != G[r % 3]) inG++;
if (s[r] != R[r % 3]) inR++;
r++;
}
res = min(res, min(inB, min(inG, inR)));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
solve();
cout << res << '\n';
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int arr[100001], N, ans;
void DFS(int a, int b, int x, int y, int r) {
if (a <= x && b <= y) {
ans = (ans < N - r ? ans : N - r);
return;
}
if (r == 0 || ans == N - r) return;
if (arr[r] == 2) {
while (a > x) {
x *= 2;
r--;
}
while (b > y) {
y *= 2;
r--;
}
ans = (ans < N - r ? ans : N - r);
return;
}
if (a > x) DFS(a, b, x * arr[r], y, r - 1);
if (b > y) DFS(a, b, x, y * arr[r], r - 1);
}
int main() {
int a, b, h, w;
scanf("%d %d %d %d %d", &a, &b, &h, &w, &N);
for (int i = 1; i <= N; i++) scanf("%d", &arr[i]);
sort(arr + 1, arr + N + 1);
ans = N + 1;
DFS(a / h + (a % h == 0 ? 0 : 1), b / w + (b % w == 0 ? 0 : 1), 1, 1, N);
DFS(a / w + (a % w == 0 ? 0 : 1), b / h + (b % h == 0 ? 0 : 1), 1, 1, N);
printf("%d\n", ans == N + 1 ? -1 : ans);
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a;
long long max_last = -1, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
sum += a;
max_last = max(a, max_last);
}
long long ans = sum / (n - 1);
if (sum % (n - 1) != 0) ans++;
if (max_last > ans) ans += (max_last - ans);
cout << ans << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
const int sz = 10000;
using namespace std;
int clue();
int result();
void show();
bool check();
int main() {
int n, m;
cin >> n >> m;
vector<pair<string, string> > v;
vector<pair<string, string> >::iterator it;
while (m--) {
string a, b;
cin >> a >> b;
if (a.size() <= b.size()) {
v.push_back(make_pair(a, a));
v.push_back(make_pair(b, a));
} else {
v.push_back(make_pair(b, b));
v.push_back(make_pair(a, b));
}
}
while (n--) {
string k;
cin >> k;
for (it = v.begin(); it != v.end(); ++it) {
if (it->first == k) {
cout << it->second << " ";
}
}
}
puts("");
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int n, x[100005], y[100005];
long long ccw(int o, int a, int b) {
return 1LL * (x[a] - x[o]) * (y[b] - y[o]) -
1LL * (x[b] - x[o]) * (y[a] - y[o]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d %d", &x[i], &y[i]);
long long area = 0;
for (int i = 0; i < n; i++) area -= ccw(0, i, (i + 1) % n);
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &x[n], &y[n]);
long long narea = 0;
for (int i = 0; i < n; ++i) {
narea += abs(ccw(n, i, (i + 1) % n));
}
if (area != narea) {
printf("0\n");
continue;
}
long long res = 0;
int l = 0, r = 1;
for (; l < n; ++l) {
for (;; r = (r + 1) % n)
if (ccw(l, n, r) <= 0) break;
res += 1LL * ((r - l - 2 + 2 * n) % n) * ((r - l - 1 + n) % n) / 2;
}
printf("%lld\n", 1LL * n * (n - 1) * (n - 2) / 6 - res);
}
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
vector<int> z_function(string s) {
int n = (int)s.size();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int main() {
string have, need;
cin >> have >> need;
vector<pair<int, int> > ans;
bool cant = false;
while (need.size()) {
int best = 0, start, end;
bool is_reversed = false;
string aux = have;
reverse(aux.begin(), aux.end());
vector<int> ans1 = z_function(need + have);
vector<int> ans2 = z_function(need + aux);
for (int i = (int)need.size(); i < ans1.size(); i++) {
if (ans1[i] > best) {
start = i - need.size();
end = i + ans1[i] - need.size();
best = ans1[i];
}
}
for (int i = (int)need.size(); i < ans2.size(); i++) {
if (ans2[i] > best) {
start = i - need.size();
end = i + ans2[i] - need.size();
best = ans2[i];
is_reversed = true;
}
}
if (best == 0) {
cant = true;
break;
} else {
if (end - start >= need.size()) end = start + need.size();
best = min(best, (int)have.size());
best = min(best, (int)need.size());
need = need.substr(best);
if (!is_reversed)
ans.push_back(pair<int, int>(start + 1, end));
else
ans.push_back(
pair<int, int>(have.size() - start, have.size() - end + 1));
}
}
if (cant)
puts("-1");
else {
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y);
long long mpower(long long x, long long y, long long p);
long long modInv(long long a, long long m);
long long gcdExtended(long long a, long long b, long long *x, long long *y);
bool isPrime(long long n);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, i, j, k, l, p, q, r, x, y, z, a, b, c, d, f, n, m,
M = 1000000007;
char ch, ch2, ch3;
string s, second, s2, s3;
vector<long long> v, w;
vector<long long>::iterator itrv;
unordered_map<long long, long long> N;
set<long long> S;
set<long long>::iterator itr;
cin >> s;
n = s.size();
f = 1;
a = 1;
for (i = 0; i < n; i++) {
if (s[i] == '1') {
cout << 4 << " " << f << "\n";
if (f == 1) {
f = 3;
} else {
f = 1;
}
} else {
cout << 1 << " " << a << "\n";
a++;
if (a == 5) {
a = 1;
}
}
}
return 0;
}
long long modInv(long long a, long long m) {
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
long long res = (x % m + m) % m;
return res;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long mpower(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
long long p = sqrt(n);
for (int i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
string s;
cin >> s;
if (s[0] != 'W' && s[0] != 'B' && s[0] != 'G') {
cout << "#Color" << endl;
return 0;
}
}
}
cout << "#Black&White" << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int total[2000005], mid[2000005];
int main() {
int n, m, maxi, x, y, ok, mid, c, d;
scanf("%d", &n);
maxi = ok = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &m);
total[m]++;
maxi = max(maxi, m);
}
if (total[0] == 1) {
if (maxi == 0) {
ok = c = d = x = y = 1;
} else {
total[0] = 0;
for (int i = 1; i <= maxi; i++) {
if (total[i] - total[i - 1] < 4) {
for (int j = 1; j * j <= n; j++) {
if (n % j == 0) {
c = j;
d = n / j;
ok = 1;
x = c - i + 1;
y = maxi - x + 2;
for (int k = 1; k <= maxi; k++) {
mid = k * 4;
if (k >= x) {
mid -= 2 * (k - x) + 1;
}
if (k >= y) {
mid -= 2 * (k - y) + 1;
}
if (k > c - x) {
mid -= 2 * (k - c + x) - 1;
}
if (k > d - y) {
mid -= 2 * (k - d + y) - 1;
}
if (k - x - y + 1 > 0) {
mid += k - x - y + 1;
}
if (k - c + x - y > 0) {
mid += k - c + x - y;
}
if (k - d + y - x > 0) {
mid += k - d + y - x;
}
if (k - c - d + y + x - 1 > 0) {
mid += k - c - d + y + x - 1;
}
if (mid != total[k]) {
ok = 0;
break;
}
}
if (ok) {
break;
}
c = n / j;
d = j;
ok = 1;
x = c - i + 1;
y = maxi - x + 2;
for (int k = 1; k <= maxi; k++) {
mid = k * 4;
if (k >= x) {
mid -= 2 * (k - x) + 1;
}
if (k >= y) {
mid -= 2 * (k - y) + 1;
}
if (k > c - x) {
mid -= 2 * (k - c + x) - 1;
}
if (k > d - y) {
mid -= 2 * (k - d + y) - 1;
}
if (k - x - y + 1 > 0) {
mid += k - x - y + 1;
}
if (k - c + x - y > 0) {
mid += k - c + x - y;
}
if (k - d + y - x > 0) {
mid += k - d + y - x;
}
if (k - c - d + y + x - 1 > 0) {
mid += k - c - d + y + x - 1;
}
if (mid != total[k]) {
ok = 0;
break;
}
}
if (ok == 1) {
break;
}
}
}
break;
}
}
}
}
if (ok) {
printf("%d %d\n%d %d\n", c, d, x, y);
} else {
printf("-1\n");
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int nmax = 200200;
const int kmax = 6;
int n, k;
vector<int> g[nmax];
long long cnt[nmax][kmax], sumLen[nmax][kmax];
long long res;
int used[nmax];
void solve(int v, int p) {
used[v] = 1;
sumLen[v][0] = 0;
cnt[v][0] = 1;
for (int i = 0; i < g[v].size(); i++)
if (g[v][i] != p) {
int u = g[v][i];
solve(u, v);
for (int j = 0; j < k; j++)
for (int e = 0; e < k; e++) {
res += sumLen[u][j] * cnt[v][e];
res += sumLen[v][e] * cnt[u][j];
if (e + j + 1 > 0) res += cnt[u][j] * cnt[v][e];
if (e + j + 1 > k) res += cnt[u][j] * cnt[v][e];
}
for (int j = 0; j < k - 1; j++) {
sumLen[v][j + 1] += sumLen[u][j];
cnt[v][j + 1] += cnt[u][j];
}
sumLen[v][0] += sumLen[u][k - 1] + cnt[u][k - 1];
cnt[v][0] += cnt[u][k - 1];
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
solve(0, -1);
cout << res << endl;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string bin;
cin >> bin;
int ans = 0;
for (int i = bin.size() - 1; i >= 0; i--) {
if (bin[i] == '0')
ans++;
else if (bin[i] == '1') {
if (i == 0) break;
ans += 2;
bin[i - 1]++;
} else {
ans++;
if (i != 0) bin[i - 1]++;
}
}
cout << ans;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
const int inf = 0x7f7f7f7f;
int n, m;
int u[maxn], v[maxn];
int cnt[maxn];
bool adj[maxn][maxn];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u[i] >> v[i];
cnt[u[i]]++;
cnt[v[i]]++;
adj[u[i]][v[i]] = 1;
adj[v[i]][u[i]] = 1;
}
int rlt = inf;
for (int i = 0; i < m; i++)
for (int j = 1; j <= n; j++) {
int tu = u[i], tv = v[i];
if (adj[tu][j] && adj[j][tv]) {
rlt = min(rlt, cnt[tu] + cnt[tv] + cnt[j] - 6);
}
}
if (rlt == inf)
cout << -1 << endl;
else
cout << rlt << endl;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
map<string, int> q;
int n, m, cnt = 0;
cin >> n >> m;
int ans1 = n, ans2 = m;
while (n--) {
cin >> s;
q[s]++;
}
while (m--) {
cin >> s;
q[s]++;
if (q[s] > 1) cnt++;
}
if (cnt % 2 == 1) ans2 -= 1;
if (ans1 <= ans2)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
int A[2 * 1000002];
template <class type>
class BIT {
type *tree;
int maxVal;
public:
BIT(type *T, int n) {
tree = T;
maxVal = n;
memset(tree, 0, sizeof(type) * maxVal);
}
void update(int id, type val) {
while (id < maxVal) {
tree[id] += val;
id += id & -id;
}
}
type read(int id) {
type sum = 0;
while (id > 0) {
sum += tree[id];
id -= id & -id;
}
return sum;
}
int findFirst(type val) {
int high = maxVal - 1, low = 1;
while (low <= high) {
int mid((low + high) / 2);
if (read(mid) < val)
low = mid - 1;
else
high = mid + 1;
}
return low;
}
int findLast(type val) {
int high = maxVal - 1, low = 1;
while (low <= high) {
int mid((low + high) / 2);
if (read(mid) > val)
high = mid + 1;
else
low = mid - 1;
}
return high;
}
};
int main() {
ios_base::sync_with_stdio(false);
int n, c = 1;
cin >> n;
for (int i = 1; i <= n; i++) A[i] = i;
for (int k = 2; k <= n; k++) {
if (n / k * k < n) A[c + n] = A[c + n / k * k];
for (int i = c + n / k * k; i > c; i -= k) {
A[i] = A[i - k];
}
c++;
}
for (int i = (c); i < (c + n); i++) {
cout << A[i] << " ";
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int A[150010], B[150010], Da[150010], Db[150010], N, i;
int main() {
cin >> N;
for (i = 1; i <= N; ++i) scanf("%d", &A[i]);
for (i = 1; i <= N; ++i) scanf("%d", &B[i]);
if (A[1] != B[1] || A[N] != B[N]) return puts("No"), 0;
for (i = 2; i <= N; ++i) Da[i] = A[i] - A[i - 1];
for (i = 2; i <= N; ++i) Db[i] = B[i] - B[i - 1];
sort(Da + 2, Da + N + 1), sort(Db + 2, Db + N + 1);
for (i = 2; i <= N; ++i)
if (Da[i] != Db[i]) return puts("No"), 0;
puts("Yes");
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1050;
int n, cnt;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch & 15);
ch = getchar();
}
return x * f;
}
struct ufs {
int f[N];
void init() {
for (int i = 1; i <= n; ++i) f[i] = i;
}
int find(int x) { return f[x] ^ x ? f[x] = find(f[x]) : x; }
} s;
bitset<N> neighbors[N], d1[N], notLeaf;
void add(int u, int v) {
int fu = s.find(u), fv = s.find(v);
if (fu ^ fv) {
cout << u << ' ' << v << endl;
++cnt;
s.f[fu] = fv;
d1[u].set(v, 1), d1[u].set(u, 1);
d1[v].set(u, 1), d1[v].set(v, 1);
notLeaf[u] = notLeaf[v] = 1;
}
}
int main() {
n = read();
if (n == 2) return puts("1 2"), 0;
for (int i = 1; i <= n; ++i) {
int k = read();
while (k--) neighbors[i].set(read(), 1);
}
s.init();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < i; ++j) {
bitset<N> tmp = neighbors[i] & neighbors[j];
if (tmp.count() == 2) {
int u = 0, v = 0;
for (int k = 1; k <= n; ++k) {
if (tmp[k]) {
if (u)
v = k;
else
u = k;
}
}
add(u, v);
}
}
}
if (cnt == 0) {
for (int i = 2; i <= n; ++i) {
cout << 1 << ' ' << i << endl;
}
return 0;
}
if (cnt == 1) {
int u = 0, v = 0;
for (int i = 1; i <= n; ++i) {
if (notLeaf[i]) {
if (u)
v = i;
else
u = i;
}
}
for (int i = 1; i <= n; ++i) {
if (neighbors[i].count() != n) {
for (int j = 1; j <= n; ++j) {
if (j != u && j != v) {
cout << (neighbors[i][j] ? u : v) << ' ' << j << endl;
}
}
break;
}
}
return 0;
}
for (int i = 1; i <= n; ++i) {
if (notLeaf[i]) continue;
int mn = 1e9;
bitset<N> tmp;
for (int j = 1; j <= n; ++j)
if (neighbors[j][i] && (neighbors[j] & notLeaf).count() < mn)
mn = (tmp = neighbors[j] & notLeaf).count();
for (int j = 1; j <= n; ++j)
if (tmp[j] && d1[j] == tmp) {
cout << i << ' ' << j << endl;
break;
}
}
return 0;
}
| 24
|
#include <bits/stdc++.h>
template <typename T, typename U>
inline void swap(T &a, U &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
inline void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
inline void swap(long long &a, long long &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (b > a) a = b;
}
template <typename T, typename U>
inline void smin(T &a, U b) {
if (b < a) a = b;
}
inline int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
long long nchose(int a, int b) {
long long ans = 1;
smax(a, b - a);
int p = 2;
for (int i = (b - a + 1); i <= (b); i++) {
ans *= (long long)i;
while (p <= a && ans % p == 0) ans /= p++;
}
return ans;
}
using namespace std;
static long long MOD = 1000000009;
long long t, i, j, x, y, z, m, kk;
long long n, k, d[2];
bool flag;
int main() {
ios::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> n >> k >> d[0] >> d[1];
flag = 0;
for (i = -1; i < 2; i += 2) {
for (j = -1; j < 2; j += 2) {
m = 0;
x = 0, kk = 0;
y = i * d[0];
smin(m, y);
z = j * d[1] + y;
smin(m, z);
x -= m;
y -= m;
z -= m;
kk = k - (x + y + z);
if (kk < 0 || kk % 3 != 0) continue;
if (y > z) swap(y, z);
if (x > y) swap(y, x);
if (y > z) swap(y, z);
kk = n - k;
kk -= z - x;
kk -= z - y;
if (kk >= 0 && kk % 3 == 0) {
flag = 1;
goto en;
}
}
}
en:
if (flag)
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
string str;
cin >> str;
if (n == 1) {
cout << "Yes";
return 0;
}
int cnt[26];
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < str.length(); i++) {
int p = str[i] - 'a';
cnt[p]++;
}
for (int i = 0; i < 26; i++) {
if (cnt[i] > 1) {
cout << "Yes";
return 0;
}
}
cout << "No";
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int n;
int z[10000001];
int kp[10000001];
char s[10000001];
void z_func() {
int L = 0, R = 0;
for (int i = 1; i < n; ++i) {
if (i > R) {
L = R = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) s[i + n] = s[n - i - 1];
n *= 2;
z_func();
int ans = 1;
kp[0] = 1;
for (int i = 1; i < n / 2; ++i) {
int sz = (i + 1) / 2;
int ps = i - sz + 1;
if (z[n - i - 1] >= i + 1) {
kp[i] = kp[sz - 1] + 1;
}
ans += kp[i];
}
printf("%d\n", ans);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
int main() {
int n, t;
int i, j, k, now, flag;
while (cin >> n >> t) {
now = 1;
for (i = 1; i <= n - 1; i++) cin >> a[i];
flag = 0;
while (now <= t) {
now = now + a[now];
if (now == t) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, k, len;
long long arr[N];
long long solve() {
multiset<long long> in, out;
long long mx = -1e16, sum = 0, fadl = k;
for (int i = 1; i <= n; i++) {
sum += arr[i];
if (i - len > 0) {
if (arr[i - len] >= 0)
sum -= arr[i - len];
else {
if (in.find(arr[i - len]) != in.end()) {
in.erase(in.find(arr[i - len]));
sum += arr[i - len];
fadl++;
} else {
if (out.find(arr[i - len]) != out.end())
out.erase(out.find(arr[i - len]));
sum -= arr[i - len];
}
}
}
if (arr[i] < 0) out.insert(arr[i]);
while (fadl > 0 && out.size() != 0) {
long long z = *out.begin();
sum -= z * 2;
fadl--;
out.erase(out.find(z));
in.insert(z);
}
while (out.size() && in.size()) {
long long x = *out.begin(), y = *(--in.end());
if (x < y) {
sum += 2 * y;
sum -= 2 * x;
in.erase(in.find(y));
out.erase(out.find(x));
in.insert(x);
out.insert(y);
} else
break;
}
if (i - len >= 0) mx = max(mx, sum);
}
return mx;
}
int main() {
scanf("%d%d", &n, &len);
for (int i = 1; i <= n; i++) cin >> arr[i];
scanf("%d", &k);
long long sol = solve();
for (int i = 1; i <= n; i++) arr[i] *= -1;
cout << endl;
cout << max(sol, solve());
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50 + 10, M = 2e4 + 10;
int a[N][M], tree[4 * M], lazy[4 * M], dp[N][M];
void update(int i, int l, int r, int ql, int qr, int x);
void propagate(int i, int lc, int rc);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = m; j >= 1; --j) {
a[i][j] += a[i][j + 1];
}
}
m = m - k + 1;
for (int i = 1; i <= n; ++i) {
memset(tree, 0, sizeof(tree));
memset(lazy, 0, sizeof(lazy));
for (int j = 1; j <= m; ++j) {
int intersection = ((i == 1 or (j > k)) ? 0 : a[i][j] - a[i][k + 1]);
update(1, 1, m, j, j, dp[i - 1][j] - intersection);
}
for (int j = 1; j <= m; ++j) {
dp[i][j] = tree[1];
dp[i][j] += (a[i][j] - a[i][j + k]) + (a[i + 1][j] - a[i + 1][j + k]);
if (i > 1) {
update(1, 1, m, j - k + 1, j, a[i][j] - a[i][j + 1]);
update(1, 1, m, j + 1, j + k, -(a[i][j + k] - a[i][j + k + 1]));
}
}
}
int ans = 0;
for (int j = 1; j <= m; ++j) {
ans = max(ans, dp[n][j]);
}
cout << ans << endl;
}
void update(int i, int l, int r, int ql, int qr, int x) {
if (l > qr or ql > r) {
return;
} else if (ql <= l and r <= qr) {
tree[i] += x;
lazy[i] += x;
} else {
int mid = (l + r) / 2, lc = 2 * i, rc = lc + 1;
propagate(i, lc, rc);
update(lc, l, mid, ql, qr, x);
update(rc, mid + 1, r, ql, qr, x);
tree[i] = max(tree[lc], tree[rc]);
}
}
void propagate(int i, int lc, int rc) {
tree[lc] += lazy[i];
tree[rc] += lazy[i];
lazy[lc] += lazy[i];
lazy[rc] += lazy[i];
lazy[i] = 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int v[N];
int main() {
int n, k;
int a, b, c, d;
scanf("%d%d", &n, &k);
scanf("%d%d%d%d", &a, &b, &c, &d);
if (k < n + 1) return 0 * puts("-1");
v[1] = a;
v[2] = c;
v[n - 1] = d;
v[n] = b;
int t = 2;
for (int i = (1); i < (n + 1); ++i) {
if (i == a || i == b || i == c || i == d) continue;
v[++t] = i;
}
if (v[3] == b || v[n - 2] == c) return 0 * puts("-1");
for (int i = (1); i < (n + 1); ++i) printf("%d%c", v[i], i == n ? '\n' : ' ');
printf("%d %d ", c, a);
for (int i = (3); i < (n - 1); ++i) printf("%d ", v[i]);
printf("%d %d\n", b, d);
return 0;
}
| 8
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int main() {
int a, b, r;
scanf("%d %d %d", &a, &b, &r);
if (2 * r <= min(a, b))
puts("First");
else
puts("Second");
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s1[505][505];
long long dp[2][505][505];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s1[i] + 1);
if (s1[1][1] != s1[n][m]) {
puts("0");
return 0;
}
long long ans = 0;
int cur = 0;
dp[0][1][n] = 1;
for (int i = 1; i <= n; i++) {
cur ^= 1;
memset(dp[cur], 0, sizeof dp[cur]);
for (int j = 1; j <= m; j++)
for (int k = i; k <= n; k++) {
int l = n + m + 2 - i - j - k;
if (j > l) continue;
if (s1[i][j] == s1[k][l]) {
dp[cur][j][k] = (dp[cur ^ 1][j][k + 1] + dp[cur ^ 1][j][k] +
dp[cur][j - 1][k + 1] + dp[cur][j - 1][k]) %
1000000007;
}
if (i + j - k - l + 1 == 0) ans = (ans + dp[cur][j][k]) % 1000000007;
if (i == k && j == l) {
ans = (ans + dp[cur][j][k]) % 1000000007;
}
}
}
printf("%lld\n", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long w, h;
while (cin >> w >> h) {
long long res = 0;
for (long long i = 2; i <= w; i += 2) {
for (long long j = 2; j <= h; j += 2) {
res += (w - i + 1) * (h - j + 1);
}
}
cout << res << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t1, t2, t3, c1 = 0, ans, par[100001], g;
vector<pair<int, int>> e[100001];
priority_queue<pair<pair<int, int>, pair<int, int>>,
vector<pair<pair<int, int>, pair<int, int>>>,
greater<pair<pair<int, int>, pair<int, int>>>>
bfs;
pair<pair<int, int>, pair<int, int>> tit;
bool v[100001], op[100001];
pair<pair<int, int>, int> eg[100001], tt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> t1 >> t2 >> t3;
t3 ^= 1;
e[t1].push_back(make_pair(t3, t2));
e[t2].push_back(make_pair(t3, t1));
if (!t3) c1++;
eg[i] = make_pair(make_pair(t1, t2), t3 ^ 1);
}
bfs.push(make_pair(make_pair(0, 0), make_pair(0, 1)));
while (!bfs.empty()) {
tit = bfs.top();
bfs.pop();
if (v[tit.second.second]) continue;
v[tit.second.second] = 1;
par[tit.second.second] = tit.second.first;
if (tit.second.second == n) {
ans = tit.first.second + c1 - (tit.first.first - tit.first.second);
}
for (auto u : e[tit.second.second]) {
if (v[u.second]) continue;
bfs.push(
make_pair(make_pair(tit.first.first + 1, tit.first.second + u.first),
make_pair(tit.second.second, u.second)));
}
}
g = n;
while (g) {
op[g] = 1;
g = par[g];
}
cout << ans << endl;
for (int i = 1; i <= m; i++) {
tt = eg[i];
if (op[tt.first.first] && op[tt.first.second]) {
if (!tt.second)
cout << tt.first.first << " " << tt.first.second << " " << (1) << endl;
continue;
}
if (tt.second)
cout << tt.first.first << " " << tt.first.second << " " << (0) << endl;
}
cout.flush();
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000, M = 6;
long long F[N + 1], G[N + 1], C[M];
struct st {
int i;
long long v;
} Q[N + 1];
int main() {
int k;
scanf("%d", &k);
for (int i = 0; i < M; i++) scanf("%lld", &C[i]);
memset(F + 1, 0xc0, sizeof(long long[N]));
for (int b = 0, t = 1; b < M; b++, t *= 10) {
int w = 3 * t, lim = 3 * (k - 1);
memset(G + 1, 0xc0, sizeof(long long[N]));
for (int r = 0; r < w; r++) {
st *h = Q, *t = Q - 1;
for (int i = r, p = 0; i <= N; i += w, p++) {
long long vi = F[i] - p * C[b];
while (h <= t && t->v <= vi) t--;
*++t = {i, vi};
while (h <= t && (i - h->i) / w > lim) h++;
if (h <= t) G[i] = max(G[i], h->v + p * C[b]);
}
}
memcpy(F + 1, G + 1, sizeof(long long[N]));
for (int i = N; i >= 0; i--) {
for (int j = 1; j <= 9 && j * t <= i; j++) {
long long v = 0;
if (j % 3 == 0) v = (j / 3) * C[b];
F[i] = max(F[i], F[i - j * t] + v);
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int n;
scanf("%d", &n);
printf("%lld\n", F[n]);
}
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
long long a[5205][5205];
bool check(long long i, long long j, long long k) {
k--;
long long act =
a[i + k][j + k] - a[i - 1][j + k] - a[i + k][j - 1] + a[i - 1][j - 1];
k++;
if (act == k * k || act == 0) return 1;
return 0;
}
bool verif(long long n, long long ans) {
long long i, j;
for (i = 1; i <= n - ans + 1; i += ans)
for (j = 1; j <= n - ans + 1; j += ans)
if (!check(i, j, ans)) return 0;
return 1;
}
vector<long long> divv[5205];
int main() {
ios_base::sync_with_stdio(false);
char x;
long long i, j, nr, ind2, n, k, ans;
cin >> n;
for (i = 2; i <= n; i++) {
for (j = i; j <= n; j += i) divv[j].push_back(i);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n / 4; j++) {
cin >> x;
if (x >= '0' && x <= '9')
nr = x - '0';
else
nr = x - 'A' + 10;
for (k = 1; k <= 4; k++) {
ind2 = (j - 1) * 4 + k;
a[i][ind2] = (nr & 8) / 8;
a[i][ind2] += a[i - 1][ind2] + a[i][ind2 - 1] - a[i - 1][ind2 - 1];
nr = nr << 1;
}
}
}
for (long long ind = divv[n].size() - 1; ind >= 0; ind--) {
ans = divv[n][ind];
if (verif(n, ans)) {
cout << ans << '\n';
return 0;
}
}
cout << 1 << '\n';
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 200005;
inline void read(int &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
inline void caltime(int tt) {
tt = clock() - tt;
cerr << (double)tt / CLOCKS_PER_SEC << " seconds!" << endl;
}
int n, m, q;
vector<int> e[maxn * 10];
bool vis[maxn * 10];
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < e[x].size(); i++) {
if (!vis[e[x][i]]) dfs(e[x][i]);
}
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
int x, y;
read(x), read(y);
e[x].push_back(y + n);
e[y + n].push_back(x);
}
int ans = 0;
for (int i = 1; i <= m + n; i++) {
if (!vis[i]) {
dfs(i);
ans++;
}
}
cout << ans - 1 << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, di, cnt;
node(int _x = 0, int _y = 0, int _di = 0, int _cnt = 0) {
x = _x;
y = _y;
di = _di;
cnt = _cnt;
}
};
int n, m;
int cx[5] = {0, 0, 1, -1};
int cy[5] = {1, -1, 0, 0};
char s[1005][1005];
bool mem[1005][1005][5][5];
queue<node> q;
bool check(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m || s[x][y] == '*') return 0;
return 1;
}
int main() {
int i, j, sx, sy;
node t;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf(" %s", s[i]);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (s[i][j] == 'S') {
sx = i;
sy = j;
}
}
}
for (i = 0; i < 4; i++) {
mem[sx][sy][i][2] = 1;
q.push(node(sx, sy, i, 2));
}
while (!q.empty()) {
t = q.front();
q.pop();
if (s[t.x][t.y] == 'T') {
printf("YES");
return 0;
}
for (i = 0; i < 4; i++) {
if (!check(t.x + cx[i], t.y + cy[i])) continue;
if (i != t.di && t.cnt > 0) {
if (!mem[t.x + cx[i]][t.y + cy[i]][i][t.cnt - 1]) {
mem[t.x + cx[i]][t.y + cy[i]][i][t.cnt - 1] = 1;
q.push(node(t.x + cx[i], t.y + cy[i], i, t.cnt - 1));
}
}
if (i == t.di) {
if (!mem[t.x + cx[i]][t.y + cy[i]][t.di][t.cnt]) {
mem[t.x + cx[i]][t.y + cy[i]][t.di][t.cnt] = 1;
q.push(node(t.x + cx[i], t.y + cy[i], t.di, t.cnt));
}
}
}
}
printf("NO");
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string a, b;
cin >> a >> b;
int x = 0, y = 0;
for (int i = 0; i < a.length(); i++) x += a[i] - '0';
for (int i = 0; i < b.length(); i++) y += b[i] - '0';
if (x & 1) x++;
if (x >= y)
puts("YES");
else
puts("NO");
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
string a, b = "AHIMOTUVWXY";
map<char, long long> mp;
long long i, j;
int main() {
cin >> a;
for (j = 0; j < b.size(); j++) {
mp[b[j]]++;
}
for (i = 0; i < a.size(); i++) {
if (mp[a[i]] == 0) {
cout << "NO";
return 0;
}
}
for (i = 0; i < a.size() / 2; i++) {
if (a[i] != a[a.size() - 1 - i]) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 2
|
#include <bits/stdc++.h>
int main() {
int i, min, a[5], b[5] = {1, 1, 2, 7, 4};
for (i = 0; i < 5; i++) scanf("%d", &a[i]);
min = a[0] / b[0];
for (i = 1; i < 5; i++)
if (min > a[i] / b[i]) min = a[i] / b[i];
printf("%d\n", min);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int row, column, r_row, r_column, f_row, f_column;
int dr = 1, dc = 1;
cin >> row >> column >> r_row >> r_column >> f_row >> f_column;
int count;
count = 0;
while (f_row != r_row && f_column != r_column) {
if (r_row + dr > row || r_row + dr < 1) {
dr *= (-1);
}
if (r_column + dc > column || r_column + dc < 1) {
dc *= (-1);
}
r_column += dc;
r_row += dr;
count++;
}
cout << count << endl;
}
}
| 0
|
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
if (n > 11) {
std::cout << 0;
return 0;
}
int a[15][10];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 5; ++j) {
std::cin >> a[i][j];
}
}
std::vector<int> vec;
for (int i = 0; i < n; ++i) {
bool flag = true;
for (int j = 0; j < n; ++j) {
if (i == j) continue;
for (int k = 0; k < n; ++k) {
if (k == i || j == k) continue;
int ans = 0;
for (int l = 0; l < 5; ++l) {
ans += (a[j][l] - a[i][l]) * (a[k][l] - a[i][l]);
}
if (ans > 0) {
flag = false;
}
}
}
if (flag) vec.push_back(i);
}
std::cout << vec.size() << "\n";
for (auto it : vec) {
std::cout << it + 1 << "\n";
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6000 * 2 + 5;
bool isPrime(int val) {
if (val == 1) return false;
int sq = sqrt((double)val);
for (int i = 2; i <= sq; i++)
if (val % i == 0) return false;
return true;
}
int main() {
int n;
cin >> n;
int maxSum = 0;
for (int i = 1; i <= n; i++) maxSum += i;
bool begPrime[MAXN + 1], endPrime[MAXN + 1];
for (int i = 0; i < MAXN; i++) {
begPrime[i] = isPrime(i);
endPrime[MAXN - i] = isPrime(maxSum - i);
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (i == j && i + j) continue;
if (begPrime[i] && begPrime[j] && endPrime[MAXN - i - j]) {
int r = 2;
for (int k = 1; k <= n; k++) {
if (k == i)
cout << r++ << " ";
else if (k == j)
cout << r++ << " ";
else
cout << 1 << " ";
}
return 0;
}
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const double p = 1.000000011;
double fexp(double base, int power) {
double res = 1;
while (power) {
if (power & 1) res *= base;
base *= base;
power >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, t;
cin >> n >> t;
cout << fexp(p, t) * n;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200001;
const int maxk = 51;
double DP[maxn][maxk];
double val[maxn], B[maxn], sum[maxn], recip[maxn];
int N, K;
double costo(int i, int j) {
return B[j] - B[i - 1] - sum[i - 1] * (recip[j] - recip[i - 1]);
}
void doDP(int ini, int fin, int iniq, int finq, int k) {
if (ini > fin) return;
int M = (ini + fin) / 2;
int q, qt;
q = max(iniq, k);
DP[M][k] = DP[q - 1][k - 1] + costo(q, M);
qt = q;
for (q = max(iniq, k) + 1; q <= min(finq, M); q++) {
if (DP[M][k] > DP[q - 1][k - 1] + costo(q, M)) {
DP[M][k] = DP[q - 1][k - 1] + costo(q, M);
qt = q;
}
}
doDP(ini, M - 1, iniq, qt, k);
doDP(M + 1, fin, qt, finq, k);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> K;
int i, j, k;
for (i = 1; i <= N; i++) cin >> val[i];
for (i = 1; i <= N; i++) {
sum[i] = sum[i - 1] + val[i];
B[i] = sum[i] / ((double)val[i]);
B[i] += B[i - 1];
recip[i] = recip[i - 1] + 1.0 / ((double)val[i]);
}
for (i = 1; i <= N; i++) DP[i][1] = costo(1, i);
for (j = 2; j <= K; j++) doDP(1, N, 1, N, j);
cout << fixed << setprecision(6) << DP[N][K];
}
| 16
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int a[10] = {0};
int main() {
bool ok = false;
int v, dig, cur, p, len, ost, mn = 1000000000;
scanf("%d", &v);
for (int(i) = (1); (i) <= (9); ++(i)) {
scanf("%d", &a[i]);
if (a[i] <= mn) {
dig = i;
mn = a[i];
}
}
len = v / mn;
if (!len) {
printf("-1\n");
return 0;
}
ost = v % mn;
for (int(i) = 0; (i) < (len); ++(i)) {
p = dig;
for (int(j) = (9); (j) >= (1); --(j))
if (ost + a[dig] >= a[j]) {
p = j;
break;
}
printf("%d", p);
ost = ost + a[dig] - a[p];
}
printf("\n");
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i;
cin >> n;
if (n == 2 || n == 3) {
cout << "1" << endl;
cout << n;
} else {
if (n % 2 == 0) {
cout << n / 2 << endl;
for (i = 0; i < n / 2; i++) cout << "2 ";
} else {
n = n - 3;
cout << n / 2 + 1 << endl;
for (i = 0; i < n / 2; i++) cout << "2 ";
cout << "3";
}
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 77;
int k, n, m, a[N], type[N];
pair<int, int> t[N];
vector<pair<int, int> > sum[N], mul[N];
vector<pair<long long, pair<long long, int> > > V;
vector<int> A;
bool CMP(pair<long long, pair<long long, int> > A,
pair<long long, pair<long long, int> > B) {
return A.first * 1ll * B.second.first > A.second.first * 1ll * B.first;
}
bool CMP2(int A, int B) { return type[A] < type[B]; }
int main() {
scanf("%d %d %d", &k, &n, &m);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
int tp, x, y;
scanf("%d %d %d", &tp, &x, &y);
type[i] = tp;
if (tp == 1) {
if (t[x].first < y) {
t[x].first = y;
t[x].second = i;
}
continue;
}
if (tp == 2) {
sum[x].push_back(make_pair(y, i));
continue;
}
mul[x].push_back(make_pair(y, i));
}
for (int i = 1; i <= k; i++) {
if (t[i].first > a[i]) {
sum[i].push_back(make_pair(t[i].first - a[i], t[i].second));
}
sort(sum[i].begin(), sum[i].end());
reverse(sum[i].begin(), sum[i].end());
sort(mul[i].begin(), mul[i].end());
reverse(mul[i].begin(), mul[i].end());
for (auto x : mul[i]) {
V.push_back(make_pair(x.first - 1, make_pair(1, x.second)));
}
long long ps = a[i];
for (auto x : sum[i]) {
V.push_back(make_pair(x.first, make_pair(ps, x.second)));
ps += x.first;
}
}
sort(V.begin(), V.end(), CMP);
for (int i = 0; i < min(m, (int)V.size()); i++) {
A.push_back(V[i].second.second);
}
sort(A.begin(), A.end(), CMP2);
printf("%d\n", A.size());
for (int i = 0; i < A.size(); i++) {
printf("%d ", A[i]);
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
struct student {
int id;
int p;
int s;
} st[105], bs[105];
inline student best(const student& a, const student& b) {
return a.p > b.p ? a : b;
}
int n, m, k;
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> st[i].p;
for (int i = 0; i < n; i++) {
int s;
cin >> s;
st[i].id = i + 1;
st[i].s = s;
bs[s] = best(bs[s], st[i]);
}
int res = 0;
for (int i = 0; i < k; i++) {
int c;
cin >> c;
if (c != bs[st[c - 1].s].id) res++;
}
cout << res << '\n';
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int ini() {
int t;
scanf("%d", &t);
return t;
}
vector<vector<pair<long long, long long> > > asd;
int pr[100000 + 5];
vector<int> p;
void path(int u) {
if (u == 0) return;
path(pr[u]);
p.push_back(u);
}
int main() {
int v = ini(), e = ini();
asd.assign(v + 1, vector<pair<long long, long long> >());
for (int i = 0; i < e; i++) {
int from = ini(), to = ini(), w = ini();
from--, to--;
asd[from].push_back(make_pair(to, w));
asd[to].push_back(make_pair(from, w));
}
long long dist[100000 + 5];
for (int i = 0; i <= 100001; i++) {
pr[i] = i;
dist[i] = 1LL << 62;
}
long long INF = dist[0];
int s = 0;
dist[s] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push(pair<long long, long long>(0, s));
while (!pq.empty()) {
pair<long long, long long> top = pq.top();
pq.pop();
int u = top.second;
long long w = top.first;
if (dist[u] == w) {
for (__typeof(asd[u].begin()) it = asd[u].begin(); it != asd[u].end();
it++) {
long long v = it->first;
long long uv = it->second;
long long duv = dist[u] + uv;
if (duv < dist[v]) {
dist[v] = duv;
pq.push(pair<long long, long long>(duv, v));
pr[v] = u;
}
}
}
}
if (dist[v - 1] == INF)
printf("-1\n");
else {
path(v - 1);
printf("%d ", 1);
for (int i = 0; i < p.size(); i++) printf("%d ", p[i] + 1);
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n & 1)
cout << (n - 1) / 2;
else
cout << n / 2;
cout << endl;
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, p;
int x;
long long row[1003], col[1003];
long long ansr[1000006], ansc[1000006];
priority_queue<long long> a;
priority_queue<long long> b;
long long tmp;
long long ans = -201303169;
int max(int c, int d) {
if (c > d)
return c;
else
return d;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &p);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
row[i] += x;
col[j] += x;
}
}
for (int i = 1; i <= n; i++) a.push(row[i]);
for (int j = 1; j <= m; j++) b.push(col[j]);
for (int i = 1; i <= k; i++) {
tmp = a.top();
ansr[i] = ansr[i - 1] + tmp;
a.pop();
a.push(tmp - p * m);
tmp = b.top();
ansc[i] = ansc[i - 1] + tmp;
b.pop();
b.push(tmp - p * n);
}
for (int i = 0; i <= k; i++)
if (i == 0)
ans = ansr[i] + ansc[k - i] - (long long)p * i * (k - i);
else
ans = max(ans, ansr[i] + ansc[k - i] - (long long)p * i * (k - i));
printf("%I64d\n", ans);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
constexpr int INF = 2000000000;
constexpr ll LLINF = 9000000000000000000;
struct ConvexHullSet {
struct Line {
ld a, b;
mutable ld x;
bool type;
bool operator<(const Line &rhs) const {
return type || rhs.type ? x < rhs.x : a < rhs.a;
}
ld intersect(const Line &rhs) const {
return ld(b - rhs.b) / ld(rhs.a - a);
}
};
set<Line> lines;
static constexpr ld MAX = std::numeric_limits<ld>::max();
ld query(ld x) {
auto it = lines.lower_bound(Line{0.0, 0.0, x, true});
return (it != lines.end() ? it->a * x + it->b : -1e300);
}
void adjust(set<Line>::iterator it) {
if (it != lines.end())
it->x = next(it) != lines.end() ? it->intersect(*next(it)) : MAX;
if (it != lines.begin())
prev(it)->x = it != lines.end() ? it->intersect(*prev(it)) : MAX;
}
void insert(ld a, ld b) {
cerr << "Inserting " << a << " x + " << b << '\n';
Line ln = Line{a, b, 0.0, false};
auto it1 = lines.lower_bound(ln);
if (it1 != lines.end() && it1->a == a) {
if (it1->b >= b) return;
it1 = lines.erase(it1);
adjust(it1);
}
ln.x = it1 != lines.end() ? ln.intersect(*it1) : MAX;
while (it1 != lines.end() && ln.x >= it1->x) {
it1 = lines.erase(it1);
ln.x = it1 != lines.end() ? it1->intersect(ln) : MAX;
adjust(it1);
}
while (it1 != lines.begin()) {
--it1;
ld nx = it1->intersect(ln);
if (nx >= it1->x) return;
if (it1 != lines.begin() && prev(it1)->x >= nx) {
it1 = lines.erase(it1);
adjust(it1);
} else
break;
}
it1 = lines.insert(ln).first;
adjust(it1);
}
};
constexpr int L = 0, R = 1000000;
vector<ld> solve(vii &pairs, int s) {
vector<ld> d(R - L + 1, 1e300);
sort(pairs.begin(), pairs.end());
ConvexHullSet chs;
for (int i = 0, p = L; p <= R; ++p) {
while (i < (int)pairs.size() && pairs[i].first == p) {
int x = pairs[i].first, v = pairs[i].second;
ld a = 1.0 / ld(s - v) - ld(v) / (ld(s - v) * ld(s + v));
ld b = -ld(x) / ld(s - v) + ld(x) / ld(s + v) +
ld(v) * ld(x) / (ld(s - v) * ld(s + v));
chs.insert(-a, -b);
++i;
}
d[p] = -chs.query(p);
}
return d;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, s;
cin >> n >> s;
vi x(n, 0), v(n, 0), t(n, 0);
ld lr = 1e300, rr = 1e300;
int minl = R + 1, maxr = L - 1;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> v[i] >> t[i];
if (t[i] == 1) {
lr = min(lr, ld(x[i]) / ld(v[i]));
if (x[i] < minl) minl = x[i];
} else {
rr = min(rr, ld(R - x[i]) / ld(v[i]));
if (x[i] > maxr) maxr = x[i];
}
}
cerr << "lr = " << lr << ", rr = " << rr << endl;
vector<ld> lp, rp;
{
vii pairs[2];
for (int i = 0; i < n; ++i) pairs[t[i] - 1].push_back({x[i], v[i]});
for (ii &pr : pairs[1]) pr.first = R - pr.first;
lp = solve(pairs[0], s);
rp = solve(pairs[1], s);
reverse(rp.begin(), rp.end());
}
ld ans = max(lr, rr);
for (int p = L; p <= R; ++p)
ans = min(ans, max(min(lr, lp[p]), min(rr, rp[p])));
printf("%.10lf\n", double(ans));
return 0;
}
| 17
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
using namespace std;
const long long nmax = 1005;
long long n, k, m, ans[2 * nmax], x;
vector<long long> indx;
pair<pair<long long, long long>, pair<long long, long long>> arr[nmax];
string s;
char result;
struct ecuation_system {
vector<bitset<2 * nmax>> O_o;
void add(vector<long long> tz, char corect) {
O_o.emplace_back();
for (auto it : tz) {
O_o.back()[it] = arr[it].first.first;
O_o.back()[it + n] = arr[it].first.second;
}
if (corect == 'W' || corect == 'B')
O_o.back()[2 * n + 1] = 0;
else if (corect == 'R' || corect == 'Y')
O_o.back()[2 * n + 1] = 1;
O_o.emplace_back();
for (auto it : tz) {
O_o.back()[it] = arr[it].second.first;
O_o.back()[it + n] = arr[it].second.second;
}
if (corect == 'W' || corect == 'R')
O_o.back()[2 * n + 1] = 0;
else if (corect == 'B' || corect == 'Y')
O_o.back()[2 * n + 1] = 1;
}
void solve() {
vector<long long> where(2 * nmax, -1);
long long k = (long long)O_o.size();
for (long long row = 1, col = 1; row <= k && col <= 2 * n; col++) {
for (long long i = row; i <= k; i++) {
if (O_o[i - 1][col] == 1) {
swap(O_o[i - 1], O_o[row - 1]);
}
}
if (O_o[row - 1][col] == 0) {
continue;
} else {
for (long long i = 1; i <= k; i++) {
if (i != row && O_o[i - 1][col] == 1) {
O_o[i - 1] ^= O_o[row - 1];
}
}
where[col] = row - 1;
row++;
}
}
for (long long i = 1; i <= 2 * n; i++) {
if (where[i] != -1) {
ans[i] = O_o[where[i]][2 * n + 1];
}
}
for (auto it : O_o) {
long long cnt = 0;
for (long long i = 1; i <= 2 * n; i++) {
cnt += ans[i] * it[i];
}
if (cnt != it[2 * n + 1]) {
cout << "NO", exit(0);
}
}
}
} Algo;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
srand(chrono::steady_clock::now().time_since_epoch().count());
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
arr[i].first.first = arr[i].second.second = 1;
}
for (long long i = 1; i <= k; i++) {
cin >> s >> m;
indx.clear();
for (long long i = 1; i <= m; i++) {
cin >> x;
indx.push_back(x);
}
if (s == "mix") {
cin >> result;
Algo.add(indx, result);
} else {
if (s == "RY") {
for (auto it : indx) {
arr[it].second.first =
(arr[it].second.first + arr[it].first.first) % 2;
arr[it].second.second =
(arr[it].second.second + arr[it].first.second) % 2;
}
} else if (s == "RB") {
for (auto it : indx) {
swap(arr[it].first.first, arr[it].second.first);
swap(arr[it].first.second, arr[it].second.second);
}
} else {
for (auto it : indx) {
arr[it].first.first =
(arr[it].first.first + arr[it].second.first) % 2;
arr[it].first.second =
(arr[it].first.second + arr[it].second.second) % 2;
}
}
}
}
Algo.solve();
cout << "YES" << '\n';
for (long long i = 1; i <= n; i++) {
if (ans[i] == 0 && ans[i + n] == 0) {
cout << '.';
} else if (ans[i] == 1 && ans[i + n] == 0) {
cout << 'R';
} else if (ans[i] == 0 && ans[i + n] == 1) {
cout << 'B';
} else {
cout << 'Y';
}
}
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int llINF = 0x3f3f3f3f3f3f3f;
const int MAXN = 100100;
const long long int mod = 1e9 + 7;
const int LMAXN = 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, sum, gr[512];
bool um[512];
memset(um, 0, sizeof(um));
cin >> n;
sum = 0;
for (int i = 1; i <= n; i++) {
cin >> gr[i];
sum += gr[i];
if (gr[i] == 1) um[i] = 1;
}
if (sum < (2 * n - 2)) {
cout << "NO" << endl;
return 0;
}
vector<pair<int, int> > edj;
int dim = 0;
int last = -1;
int first;
for (int i = 1; i <= n; i++) {
if (um[i])
continue;
else {
if (last == -1) {
first = i;
last = i;
} else {
edj.push_back({last, i});
gr[last]--;
gr[i]--;
last = i;
dim++;
}
}
}
int j = 0;
for (int i = 1; i <= n; i++)
if (um[i]) {
if (first != -1) {
edj.push_back({first, i});
gr[first]--;
dim++;
first = -1;
continue;
}
if (last != -1) {
gr[last]--;
edj.push_back({last, i});
dim++;
last = -1;
continue;
}
while (um[j] || gr[j] < 1) j++;
gr[j]--;
edj.push_back({i, j});
}
cout << "YES " << dim << endl;
cout << edj.size() << endl;
for (auto x : edj) cout << x.first << ' ' << x.second << endl;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 7;
const int N = 1e4 + 10;
int n, pos, posx, dp[N][27][2];
char s[3][N];
bool emp[N];
void upd(int &x, const int &y) { (x += y) >= mo ? x -= mo : 0; }
int bit(int S, int x) {
if (x == 0) return S % 3;
if (x == 1) return S / 3 % 3;
return S / 9;
}
bool match(int S1, int S2) {
for (int i = 0; i < 3; i++) {
if ((bit(S2, i) == 1) + (bit(S1, i) == 2) == 1) return 0;
}
return 1;
}
bool valid(int S, int x) {
int cnt = 0, tag[3] = {0};
for (int i = 0; i < 3; i++)
if (s[i][x] == '.') {
if (!bit(S, i)) cnt++, tag[i] = 1;
} else if (bit(S, i))
return 0;
return cnt % 2 == 0 && !(tag[0] && tag[2]);
}
bool _rowl(int S, int x) { return x == pos && bit(S, posx) == 1; }
bool _rowr(int S, int x) { return x == pos && bit(S, posx) == 2; }
bool _col(int S, int x) {
return emp[x] && x == pos && posx != 1 &&
(bit(S, 0) | bit(S, 1) | bit(S, 2)) == 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < 3; i++) scanf("%s", &s[i][1]);
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++)
if (s[i][j] == 'O') {
posx = i;
pos = j;
break;
}
for (int i = 1; i <= n; i++)
emp[i] = s[0][i] != 'X' && s[1][i] != 'X' && s[2][i] != 'X';
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 27; j++) {
for (int v = 0; v < 2; v++)
if (dp[i - 1][j][v]) {
for (int S = 0; S < 27; S++)
if (match(j, S) && valid(S, i)) {
int u = v;
if (!u) u = _rowl(j, i) || _col(S, i) || _rowr(S, i - 1);
upd(dp[i][S][u], dp[i - 1][j][v]);
}
}
}
}
int ans = 0;
for (int i = 0; i < 27; i++) {
if ((bit(i, 0) | bit(i, 1) | bit(i, 2)) < 2) {
upd(ans, dp[n][i][1]);
}
}
printf("%d\n", ans);
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<long long> v;
long long a_2, a_5, b_0, b_5, c_7, c_5, d_0, d_01, i, k, len;
cin >> s;
reverse(s.begin(), s.end());
len = s.length();
long long maxx = 1e7;
long long min_25 = maxx, min_50 = maxx, min_75 = maxx, min_00 = maxx;
a_2 = s.find("2");
a_5 = s.find("5");
b_5 = s.find("5");
b_0 = s.find("0");
c_7 = s.find("7");
c_5 = s.find("5");
d_0 = s.find("0");
if (d_0 != -1) {
d_01 = s.substr(d_0 + 1, s.length()).find("0");
if (d_01 != -1) {
d_01 = d_01 + d_0 + 1;
}
} else
d_01 = -1;
if (a_2 != -1 && a_5 != -1) {
if (a_5 < a_2)
min_25 = a_5 + (a_2 - 1);
else
min_25 = a_5 + a_2;
if (a_5 == (len - 1) && s[len - 2] == '0') {
k = 0;
for (i = len - 2; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
if (i == a_2 && (i - 1) >= 0 && s[i - 1] == '0') {
for (i = a_2 - 1; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
}
min_25 += k;
} else if (a_2 == s.length() - 1 && s[s.length() - 2] == '0') {
k = 0;
for (i = s.length() - 2; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
if (i == a_5 && (i - 1) >= 0 && s[i - 1] == '0') {
for (i = a_5 - 1; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
}
min_25 += k;
}
}
if (b_5 != -1 && b_0 != -1) {
if (b_0 < a_5)
min_50 = b_0 + (b_5 - 1);
else
min_50 = b_0 + b_5;
}
if (c_7 != -1 && c_5 != -1) {
if (c_5 < c_7)
min_75 = c_5 + (c_7 - 1);
else
min_75 = c_5 + c_7;
if (c_5 == s.length() - 1 && s[s.length() - 2] == '0') {
k = 0;
for (i = s.length() - 2; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
if (i == c_7 && (i - 1) >= 0 && s[i - 1] == '0') {
for (i = c_7 - 1; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
}
min_75 += k;
} else if (c_5 == s.length() - 1 && s[s.length() - 2] == '0') {
k = 0;
for (i = s.length() - 2; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
if (i == c_7 && (i - 1) >= 0 && s[i - 1] == '0') {
for (i = c_7 - 1; i >= 0; i--) {
if (s[i] != '0') break;
k++;
}
}
min_75 += k;
}
}
if (d_0 != -1 && d_01 != -1) {
min_00 = d_0 + d_01 - 1;
}
v.push_back(min_25);
v.push_back(min_50);
v.push_back(min_75);
v.push_back(min_00);
sort(v.begin(), v.end());
if (v[0] >= maxx) v[0] = -1;
cout << v[0] << "\n";
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int a[1005][1005];
int main() {
int m;
cin >> m;
int tmp = 0;
int i = 100;
while (i * (i - 1) * (i - 2) / 6 > m) i--;
m -= i * (i - 1) * (i - 2) / 6;
for (int j = 0; j < i; j++)
for (int k = 0; k < i; k++)
if (j != k) a[j][k] = 1;
tmp += i;
while (m) {
int p = i;
while (p * (p - 1) / 2 > m) p--;
for (int j = 0; j < p; j++) a[j][tmp] = a[tmp][j] = 1;
tmp++;
m -= p * (p - 1) / 2;
}
cout << tmp << endl;
for (int i = 0; i < tmp; i++) {
for (int j = 0; j < tmp; j++) cout << a[i][j];
cout << endl;
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[1000000 + 10];
int x, y;
int main() {
scanf("%d %d %d", &n, &x, &y);
for (int i = 1; i <= n; i++) scanf("%d", arr + i);
for (int i = 1; i <= n; i++) {
bool isok = true;
for (int j = 1; j <= x; j++) {
if (i - j < 1 || arr[i - j] > arr[i])
continue;
else if (arr[i - j] < arr[i]) {
isok = false;
break;
}
}
for (int j = 1; j <= y; j++) {
if (i + j > n || arr[i + j] > arr[i])
continue;
else if (arr[i + j] < arr[i]) {
isok = false;
break;
}
}
if (isok) {
printf("%d", i);
break;
}
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long int cost[310][310], pd[310][310];
int main(void) {
int i, j, l, r;
long long int c;
while (scanf("%d %d %d", &n, &m, &k) != EOF) {
for (i = 0; i < 310; i++)
for (j = 0; j < 310; j++) cost[i][j] = pd[i][j] = 99999999999999LL;
for (i = 0; i < m; i++) {
cin >> l >> r >> c;
for (j = l; j <= r; j++) cost[l][j] = min(cost[l][j], c);
}
pd[0][0] = 0;
for (i = 1; i <= n; i++)
for (j = 0; j <= k; j++) {
for (l = 0; l < i; l++) pd[i][j] = min(pd[i][j], pd[l][j]);
for (l = 0; l <= j; l++)
if (i - l >= 0 && i - l - 1 >= 0 && j - l - 1 >= 0)
pd[i][j] = min(pd[i][j], cost[i - l][i] + pd[i - l - 1][j - l - 1]);
}
if (pd[n][k] < 99999999999999LL)
cout << pd[n][k] << endl;
else
printf("-1\n");
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
int a[MAXN];
char s[MAXN];
int n, k;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%s", s);
int lst = 0;
for (int i = 1; i < n + 1; i++) {
if (s[i] != s[i - 1]) sort(a + lst, a + i, greater<int>()), lst = i;
}
int ct = k - 1;
long long dmg = a[0];
for (int i = 1; i < n; i++) {
if (s[i] != s[i - 1]) ct = k;
if (ct) dmg += a[i], ct--;
}
printf("%lld\n", dmg);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
const int mod = 1e9 + 7;
int T, n, ans;
int pre[maxn][maxn * 2], suf[maxn][maxn * 2];
char s[maxn], t[maxn];
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d %s %s", &n, s + 1, t + 1);
for (int i = 0; i <= n + 1; i++)
for (int j = -n; j <= n; j++) pre[i][j + n] = suf[i][j + n] = 0;
pre[0][0 + n] = 1;
for (int i = 0; i < n; i++)
for (int j = -n; j <= n; j++) {
int cur = pre[i][j + n];
if (!cur) continue;
for (int fs = 0; fs < 2; fs++)
if (s[i + 1] == '?' || s[i + 1] == '0' + fs)
for (int ft = 0; ft < 2; ft++)
if (t[i + 1] == '?' || t[i + 1] == '0' + ft)
add(pre[i + 1][j + ((i + 1) & 1 ? fs - ft : ft - fs) + n], cur);
}
suf[n + 1][0 + n] = 1;
for (int i = n + 1; i >= 2; i--)
for (int j = -n; j <= n; j++) {
int cur = suf[i][j + n];
if (!cur) continue;
for (int fs = 0; fs < 2; fs++)
if (s[i - 1] == '?' || s[i - 1] == '0' + fs)
for (int ft = 0; ft < 2; ft++)
if (t[i - 1] == '?' || t[i - 1] == '0' + ft)
add(suf[i - 1][j + ((i - 1) & 1 ? fs - ft : ft - fs) + n], cur);
}
ans = 0;
for (int i = 0; i <= n; i++)
for (int j = -n; j <= n; j++)
if (pre[i][j + n] && suf[i + 1][-j + n])
ans =
(ans + 1LL * pre[i][j + n] * suf[i + 1][-j + n] % mod * abs(j)) %
mod;
printf("%d\n", ans);
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int d[27];
string mas;
string New[10000];
int Num(char d) { return ((int)d - (int)'a' + 1); }
int main() {
int j, l, i, n;
string s;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> mas;
for (j = 1; j <= 26; j++) d[j] = 0;
l = mas.size();
for (j = 0; j < l; j++) {
d[Num(mas[j])]++;
}
New[i] = "";
for (j = 1; j <= 26; j++)
if (d[j] != 0) New[i] += (char)(j + 'a' - 1);
}
sort(New + 1, New + n + 1);
int res = 0;
l = 1;
while (l <= n) {
res++;
while ((l <= n) && (New[l] == New[l + 1])) l++;
l++;
}
cout << res;
}
| 1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.