solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int exp(long long int x, long long int y) {
long long int res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long int modinv(long long int x) { return exp(x, mod - 2); }
long long int add(long long int a, long long int b) {
a %= mod, b %= mod;
a = ((a + b) % mod + mod) % mod;
return a;
}
long long int sub(long long int a, long long int b) {
a = ((a - b) % mod + mod) % mod;
return a;
}
long long int mul(long long int a, long long int b) {
a %= mod, b %= mod;
a = ((a * b) % mod + mod) % mod;
return a;
}
void solve() {
long long int a, b;
cin >> a >> b;
long long int ans;
if (a == b) {
cout << 0 << endl;
return;
}
if (a < b) {
long long int x = (((b - a) / 10));
if (x * 10 + a < b) x++;
cout << x << endl;
return;
} else {
long long int x = (a - b) / 10;
if (10 * x + b < a) x++;
cout << x << endl;
return;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edg {
bool tpe;
int u, v;
int gt00, gt01, gt10, gt11;
};
const int md = 1000000007;
inline void add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
inline int mul(int a, int b) { return 1ll * a * b % md; }
int mn0, mn1;
void updmn(int s0, int s1) {
int n0 = mul(mn0, s0);
add(n0, mul(mn1, s1));
int n1 = mul(mn0, s1);
add(n1, mul(mn1, s0));
mn0 = n0;
mn1 = n1;
}
void upd(int &a0, int &a1, int s0, int s1) {
int n0 = mul(a0, s0);
add(n0, mul(a1, s1));
int n1 = mul(a0, s1);
add(n1, mul(a1, s0));
a0 = n0;
a1 = n1;
}
bool vis[100010];
int deg[100010];
vector<edg> adj[100010];
int cnt[100010];
int cur[100010];
int dp[100010][2][2];
inline void cto(int i, int j) { memcpy(dp[j], dp[i], sizeof(dp[i])); }
void updsel(int ii, int &a0, int &a1, int cho) {
int i = cur[ii];
vis[i] = 1;
if (cho) {
int cnt = 0;
for (int j = adj[i].size() - 1; ~j; --j) {
if (!adj[i][j].tpe && adj[i][j].gt01) {
++cnt;
}
}
if (cnt & 1) {
swap(a0, a1);
}
} else {
int cnt = 0;
for (int j = adj[i].size() - 1; ~j; --j) {
if (!adj[i][j].tpe && adj[i][j].gt00) {
++cnt;
}
}
if (cnt & 1) {
swap(a0, a1);
}
}
}
void solve_line(int n) {
dp[1][0][1] = dp[1][1][1] = 0;
dp[1][0][0] = dp[1][1][0] = 1;
updsel(1, dp[1][0][0], dp[1][0][1], 0);
updsel(1, dp[1][1][0], dp[1][1][1], 1);
for (int i = 2; i <= n; ++i) {
memset(dp[i], 0, sizeof(dp[i]));
int _ = cur[i];
int cnt;
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt00;
}
}
if (cnt & 1) {
add(dp[i][0][0], dp[i - 1][0][1]);
add(dp[i][0][1], dp[i - 1][0][0]);
} else {
add(dp[i][0][0], dp[i - 1][0][0]);
add(dp[i][0][1], dp[i - 1][0][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt10;
}
}
if (cnt & 1) {
add(dp[i][1][0], dp[i - 1][0][1]);
add(dp[i][1][1], dp[i - 1][0][0]);
} else {
add(dp[i][1][0], dp[i - 1][0][0]);
add(dp[i][1][1], dp[i - 1][0][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt01;
}
}
if (cnt & 1) {
add(dp[i][0][0], dp[i - 1][1][1]);
add(dp[i][0][1], dp[i - 1][1][0]);
} else {
add(dp[i][0][0], dp[i - 1][1][0]);
add(dp[i][0][1], dp[i - 1][1][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt11;
}
}
if (cnt & 1) {
add(dp[i][1][0], dp[i - 1][1][1]);
add(dp[i][1][1], dp[i - 1][1][0]);
} else {
add(dp[i][1][0], dp[i - 1][1][0]);
add(dp[i][1][1], dp[i - 1][1][1]);
}
updsel(i, dp[i][0][0], dp[i][0][1], 0);
updsel(i, dp[i][1][0], dp[i][1][1], 1);
}
updmn(dp[n][0][0] + dp[n][1][0], dp[n][0][1] + dp[n][1][1]);
}
void solve_circ(int n) {
int c0 = 0, c1 = 0;
dp[1][0][0] = 1;
dp[1][0][1] = dp[1][1][0] = dp[1][1][1] = 0;
for (int i = 2; i <= n; ++i) {
memset(dp[i], 0, sizeof(dp[i]));
int _ = cur[i];
int cnt;
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt00;
}
}
if (cnt & 1) {
add(dp[i][0][0], dp[i - 1][0][1]);
add(dp[i][0][1], dp[i - 1][0][0]);
} else {
add(dp[i][0][0], dp[i - 1][0][0]);
add(dp[i][0][1], dp[i - 1][0][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt10;
}
}
if (cnt & 1) {
add(dp[i][1][0], dp[i - 1][0][1]);
add(dp[i][1][1], dp[i - 1][0][0]);
} else {
add(dp[i][1][0], dp[i - 1][0][0]);
add(dp[i][1][1], dp[i - 1][0][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt01;
}
}
if (cnt & 1) {
add(dp[i][0][0], dp[i - 1][1][1]);
add(dp[i][0][1], dp[i - 1][1][0]);
} else {
add(dp[i][0][0], dp[i - 1][1][0]);
add(dp[i][0][1], dp[i - 1][1][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt11;
}
}
if (cnt & 1) {
add(dp[i][1][0], dp[i - 1][1][1]);
add(dp[i][1][1], dp[i - 1][1][0]);
} else {
add(dp[i][1][0], dp[i - 1][1][0]);
add(dp[i][1][1], dp[i - 1][1][1]);
}
}
if (n != 2) {
int t0 = 0, t1 = 0;
for (int j = adj[cur[n]].size() - 1; ~j; --j) {
if (adj[cur[n]][j].v == cur[1]) {
t0 = 0, t1 = 0;
if (adj[cur[n]][j].gt00) {
add(t0, dp[n][0][1]);
add(t1, dp[n][0][0]);
} else {
add(t0, dp[n][0][0]);
add(t1, dp[n][0][1]);
}
if (adj[cur[n]][j].gt10) {
add(t0, dp[n][1][1]);
add(t1, dp[n][1][0]);
} else {
add(t0, dp[n][1][0]);
add(t1, dp[n][1][1]);
}
break;
}
}
add(c0, t0);
add(c1, t1);
} else {
add(c0, dp[n][0][0]);
add(c0, dp[n][1][0]);
add(c1, dp[n][0][1]);
add(c1, dp[n][1][1]);
}
dp[1][1][0] = 1;
dp[1][0][0] = dp[1][0][1] = dp[1][1][1] = 0;
for (int i = 2; i <= n; ++i) {
memset(dp[i], 0, sizeof(dp[i]));
int _ = cur[i];
int cnt;
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt00;
}
}
if (cnt & 1) {
add(dp[i][0][0], dp[i - 1][0][1]);
add(dp[i][0][1], dp[i - 1][0][0]);
} else {
add(dp[i][0][0], dp[i - 1][0][0]);
add(dp[i][0][1], dp[i - 1][0][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt10;
}
}
if (cnt & 1) {
add(dp[i][1][0], dp[i - 1][0][1]);
add(dp[i][1][1], dp[i - 1][0][0]);
} else {
add(dp[i][1][0], dp[i - 1][0][0]);
add(dp[i][1][1], dp[i - 1][0][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt01;
}
}
if (cnt & 1) {
add(dp[i][0][0], dp[i - 1][1][1]);
add(dp[i][0][1], dp[i - 1][1][0]);
} else {
add(dp[i][0][0], dp[i - 1][1][0]);
add(dp[i][0][1], dp[i - 1][1][1]);
}
cnt = 0;
for (int j = adj[_].size() - 1; ~j; --j) {
if (adj[_][j].v == cur[i - 1]) {
cnt += adj[_][j].gt11;
}
}
if (cnt & 1) {
add(dp[i][1][0], dp[i - 1][1][1]);
add(dp[i][1][1], dp[i - 1][1][0]);
} else {
add(dp[i][1][0], dp[i - 1][1][0]);
add(dp[i][1][1], dp[i - 1][1][1]);
}
}
if (n != 2) {
int t0 = 0, t1 = 0;
for (int j = adj[cur[n]].size() - 1; ~j; --j) {
if (adj[cur[n]][j].v == cur[1]) {
t0 = 0, t1 = 0;
if (adj[cur[n]][j].gt01) {
add(t0, dp[n][0][1]);
add(t1, dp[n][0][0]);
} else {
add(t0, dp[n][0][0]);
add(t1, dp[n][0][1]);
}
if (adj[cur[n]][j].gt11) {
add(t0, dp[n][1][1]);
add(t1, dp[n][1][0]);
} else {
add(t0, dp[n][1][0]);
add(t1, dp[n][1][1]);
}
break;
}
}
add(c0, t0);
add(c1, t1);
} else {
add(c0, dp[n][0][0]);
add(c0, dp[n][1][0]);
add(c1, dp[n][0][1]);
add(c1, dp[n][1][1]);
}
updmn(c0, c1);
}
int main(void) {
mn0 = 1;
int n, m;
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; ++i) {
int k, u, v;
bool ut = 0, vt = 0;
edg t;
scanf("%d", &k);
if (k & 1) {
scanf("%d", &u);
if (u < 0) ut = 1, u = -u;
t.tpe = 0;
t.u = u;
if (ut) {
t.gt00 = 1;
t.gt01 = 0;
t.gt10 = t.gt11 = 0;
} else {
t.gt00 = 0;
t.gt01 = 1;
t.gt10 = t.gt11 = 0;
}
adj[u].push_back(t);
} else {
scanf("%d%d", &u, &v);
if (u < 0) ut = 1, u = -u;
if (v < 0) vt = 1, v = -v;
t.u = u;
t.v = v;
if (u == v) {
t.tpe = 0;
if (ut) {
if (vt) {
t.gt00 = 1;
t.gt01 = t.gt10 = t.gt11 = 0;
} else {
t.gt00 = t.gt01 = 1;
t.gt10 = t.gt11 = 0;
}
} else {
if (vt) {
t.gt00 = t.gt01 = 1;
t.gt10 = t.gt11 = 0;
} else {
t.gt01 = 1;
t.gt00 = t.gt10 = t.gt11 = 0;
}
}
adj[u].push_back(t);
} else {
++deg[u];
++deg[v];
t.tpe = 1;
if (ut) {
if (vt) {
t.gt00 = t.gt01 = t.gt10 = 1;
t.gt11 = 0;
} else {
t.gt00 = t.gt01 = t.gt11 = 1;
t.gt10 = 0;
}
} else {
if (vt) {
t.gt00 = t.gt10 = t.gt11 = 1;
t.gt01 = 0;
} else {
t.gt01 = t.gt10 = t.gt11 = 1;
t.gt00 = 0;
}
}
adj[u].push_back(t);
swap(t.u, t.v);
swap(t.gt01, t.gt10);
adj[v].push_back(t);
}
}
}
for (int i = 1; i <= n; ++i) {
if (!deg[i]) {
vis[i] = 1;
int fn0 = 0, fn1 = 0;
int cnt = 0;
for (int j = adj[i].size() - 1; ~j; --j) {
if (adj[i][j].gt00) {
++cnt;
}
}
if (cnt & 1)
++fn1;
else
++fn0;
cnt = 0;
for (int j = adj[i].size() - 1; ~j; --j) {
if (adj[i][j].gt01) {
++cnt;
}
}
if (cnt & 1)
++fn1;
else
++fn0;
updmn(fn0, fn1);
}
}
for (int i = 1; i <= n; ++i) {
if (!vis[i] && (deg[i] & 1)) {
int cnt = 1;
queue<int> q;
q.push(i);
cur[1] = i;
vis[i] = 1;
while (!q.empty()) {
int id = q.front();
q.pop();
for (int j = adj[id].size() - 1; ~j; --j) {
int nxt = adj[id][j].v;
if (adj[id][j].tpe && !vis[nxt]) {
vis[nxt] = 1;
cur[++cnt] = nxt;
q.push(nxt);
break;
}
}
}
solve_line(cnt);
}
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
int cnt = 1;
queue<int> q;
q.push(i);
cur[1] = i;
vis[i] = 1;
while (!q.empty()) {
int id = q.front();
q.pop();
for (int j = adj[id].size() - 1; ~j; --j) {
int nxt = adj[id][j].v;
if (!vis[nxt]) {
vis[nxt] = 1;
cur[++cnt] = nxt;
q.push(nxt);
break;
}
}
}
solve_circ(cnt);
}
}
printf("%d", mn1);
return 0;
}
| 10 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef long long ll;
#define pb push_back
#define po pop_back
#define pii pair < lli ,lli >
#define it iterator
#define pll pair < ll, ll>
#define plli pair < lli, lli>
#define mp make_pair
#define vi vector <lli>
#define len length
#define fi first
#define sec second
#define sz size
#define rep(i,a,b) for(lli i=a;i<b;i++)
#define repi(i,a,b) for(lli i=a;i>=b;i--)
#define Pi 3.1415926535897932384626433832795
#define all(c) c.begin(),c.end()
#define alli(c) c.rbegin(),c.rend()
#define NIL -1
#define mo 1000000007
#define N 1000000000000
void solve()
{
lli A,B,n;
cin>>A>>B>>n;
vector<lli> a(n),b(n);
for(lli&i:a)
cin>>i;
for(lli&i:b)
cin>>i;
vector<pair<lli,lli>> v;
rep(i,0,n)
v.pb(mp(a[i],b[i]));
sort(all(v));
rep(i,0,n-1)
{
if(v[i].second%A==0)
B=B-(v[i].second)/A*v[i].first;
else
B=B-((v[i].second/A)+1)*v[i].first;
if(B<=0)
{
cout<<"NO\n";
return;
}
}
lli k=ceil(v[n-1].second/float(A));
lli p=ceil(float(B)/v[n-1].first);
if(k<=p)
cout<<"YES\n";
else
cout<<"NO\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
lli t;
cin>>t;
while(t--)
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
struct pnt {
int x, y;
};
int x, y, z;
int a, b, c;
int ar[7];
int kenar() {
pnt p1, p2, p3, p4;
pnt vas;
p1.x = 0;
p1.y = 0;
p2.x = a;
p2.y = 0;
p3.x = a;
p3.y = c;
p4.x = 0;
p4.y = c;
vas.x = x;
vas.y = z;
int res = 0;
if (vas.y < p1.y) res += ar[3];
if (vas.y > p3.y) res += ar[4];
if (vas.x < p1.x) res += ar[5];
if (vas.x > p2.x) res += ar[6];
return res;
}
int yukari() {
if (y > b) return ar[2];
if (y < 0) return ar[1];
return 0;
}
int main() {
scanf(" %d %d %d %d %d %d", &x, &y, &z, &a, &b, &c);
scanf(" %d %d %d %d %d %d", &ar[1], &ar[2], &ar[3], &ar[4], &ar[5], &ar[6]);
printf("%d\n", kenar() + yukari());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long gcd(unsigned long long a, unsigned long long b) {
unsigned long long c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int pri[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
vector<int> vv;
string s;
for (int i = 0; i < 16; i++) {
cout << pri[i] << endl;
cin >> s;
if (s == "yes") vv.push_back(pri[i]);
}
if (!vv.size()) {
cout << "prime\n";
return 0;
}
if (vv.size() > 1) {
cout << "composite\n";
return 0;
}
if (vv.size() == 1) {
if (vv[0] * vv[0] > 100) {
cout << "prime\n";
return 0;
}
cout << vv[0] * vv[0] << endl;
cin >> s;
if (s == "yes")
cout << "composite\n";
else
cout << "prime\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int num1 = 0;
int num2 = 0;
int num3 = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1') {
num1++;
} else if (s[i] == '2') {
num2++;
} else if (s[i] == '3') {
num3++;
}
}
for (int j = 0; j < num1; j++) {
if (j == 0) {
cout << "1";
} else {
cout << "+1";
}
}
for (int k = 0; k < num2; k++) {
if (k == 0 && num1 == 0) {
cout << "2";
} else {
cout << "+2";
}
}
for (int l = 0; l < num3; l++) {
if (l == 0 && num1 == 0 && num2 == 0) {
cout << "3";
} else {
cout << "+3";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const int N = 10005;
long long ans = 0;
vector<int> g[N];
void dfs(int v, int pr = -1) {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == pr) {
continue;
}
dfs(to, v);
ans += (g[to].size() - 1);
}
long long first = g[v].size() - (pr != -1);
ans += first * (first - 1) / 2;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int q, w;
cin >> q >> w;
g[q].push_back(w);
g[w].push_back(q);
}
dfs(1);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007, INF = 2000000001;
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
dy[] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
const double EPS = 1e-9;
void init(string fname) {
freopen((fname + ".in").c_str(), "r", stdin);
freopen((fname + ".out").c_str(), "w", stdout);
}
long long gcd(long long a, long long b) { return (b != 0) ? gcd(b, a % b) : a; }
long long modpow(long long a, long long x, long long m = mod) {
int p = 1;
while (x > 0) {
if (x & 1 == 1) {
p = p * a % m;
--x;
} else {
x >>= 1;
a = a * a % m;
}
}
return p;
}
void getZ(const string& s, vector<int>& v) {
v = vector<int>(s.length());
int n = s.length();
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) v[i] = min(v[i - l], r - i + 1);
while (i + v[i] < n && s[v[i]] == s[i + v[i]]) ++v[i];
if (i + v[i] - 1 > r) r = (l = i) + v[i] - 1;
}
}
long long dfs(vector<vector<int> >& g, vector<long long>& a, int v,
vector<bool>& used, vector<long long>& pop) {
used[v] = true;
long long ans = a[v];
for (int i = 0; i < g[v].size(); ++i) {
if (!used[g[v][i]]) {
ans += dfs(g, a, g[v][i], used, pop);
}
}
return pop[v] = ans;
}
void make_set(vector<int>& p, vector<int>& r, int v) {
p[v] = v;
r[v] = 0;
}
int find_set(vector<int>& p, int v) {
return p[v] == v ? v : p[v] = find_set(p, p[v]);
}
void unite_sets(vector<int>& p, vector<int>& r, int v1, int v2) {
int p1 = v1, p2 = v2;
if (r[p1] > r[p2]) swap(p1, p2);
p[p1] = p2;
if (r[p1] == r[p2]) ++r[p2];
}
class Edge {
public:
double weight;
int v1, v2;
Edge(double w = 0, int i = 0, int j = 0) : weight(w), v1(i), v2(j) {}
};
class CompEdge {
public:
bool operator()(const Edge& a, const Edge& b) const {
return (a.weight < b.weight) ||
(a.weight == b.weight &&
(a.v1 < b.v1 || (a.v1 == b.v1 && a.v2 < b.v2)));
}
};
long long gcdex(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
} else {
long long x1, y1;
long long g = gcdex(b % a, a, x1, y1);
x = y1 - b / a * x1;
y = x1;
return g;
}
}
void _a() {}
void _b() {}
void _c() {
int n;
cin >> n;
vector<string> names(n);
for (int i = 0; i < n; ++i) cin >> names[i];
vector<vector<int> > dp(26, vector<int>(26));
for (int i = 0; i < n; ++i) {
char b = names[i][0], e = names[i][names[i].length() - 1];
for (int j = 0; j < 26; ++j) {
if (dp[j][b - 'a'] > 0) {
dp[j][e - 'a'] =
max(dp[j][b - 'a'] + (int)names[i].length(), dp[j][e - 'a']);
}
}
dp[b - 'a'][e - 'a'] = max(dp[b - 'a'][e - 'a'], (int)names[i].length());
}
int ans = 0;
for (int i = 0; i < 26; ++i) ans = max(ans, dp[i][i]);
cout << ans;
}
void _d() {}
void _e() {}
int main() {
_c();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 100;
int n, a[maxn], b[maxn], c[maxn], ac[maxn], bc[maxn], a2b2[maxn];
long long res;
struct Point {
long long x, y;
};
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
Point getStand(Point t) {
if (t.x == 0) {
if (t.y == 0) return t;
t.y = 1;
return t;
} else if (t.y == 0) {
t.x = 1;
return t;
}
long long d = gcd(abs(t.x), abs(t.y));
t.x /= d;
t.y /= d;
if (t.x < 0) {
t.x = -t.x;
t.y = -t.y;
}
return t;
}
void solve() {
for (int i = 1; i <= n; i++) {
ac[i] = a[i] * c[i];
bc[i] = b[i] * c[i];
a2b2[i] = a[i] * a[i] + b[i] * b[i];
}
res = 0;
for (int i = 1; i <= n; i++) {
map<long long, map<long long, long long> > mp;
int same = 0, ans = 0;
for (int j = i + 1; j <= n; j++) {
Point t;
t.x = (long long)a2b2[j] * (long long)ac[i] -
(long long)a2b2[i] * (long long)ac[j];
t.y = (long long)a2b2[j] * (long long)bc[i] -
(long long)a2b2[i] * (long long)bc[j];
t = getStand(t);
if (t.x == 0 && t.y == 0) {
same++;
ans += (j - i - 1);
} else {
ans += mp[t.x][t.y] + same;
mp[t.x][t.y]++;
}
}
res += ans;
}
printf("%I64d\n", res);
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, col[777], Head[777], Next[5555555], Go[5555555], Cnt = 0, tim = 0;
void addedge(int x, int y) {
Go[++Cnt] = y;
Next[Cnt] = Head[x];
Head[x] = Cnt;
Go[++Cnt] = x;
Next[Cnt] = Head[y];
Head[y] = Cnt;
}
int ask(vector<int> V) {
if (V.size() <= 1) return 0;
printf("? %d\n", V.size());
for (int i = 0; i < V.size(); i++) printf("%d ", V[i]);
putchar('\n');
fflush(stdout);
int x;
scanf("%d", &x);
return x;
}
int cedge(int x, vector<int> V) {
int b = ask(V);
V.push_back(x);
int a = ask(V);
return a - b;
}
void GG(vector<int> V) {
printf("N %d\n", V.size());
for (int i = 0; i < V.size(); i++) printf("%d ", V[i]);
putchar('\n');
fflush(stdout);
exit(0);
}
void OK(vector<int> V) {
printf("Y %d\n", V.size());
for (int i = 0; i < V.size(); i++) printf("%d ", V[i]);
putchar('\n');
fflush(stdout);
exit(0);
}
vector<int> get1() {
vector<int> V;
V.clear();
for (int i = 1; i <= n; i++)
if (col[i] == 1) V.push_back(i);
return V;
}
vector<int> get0() {
vector<int> V;
V.clear();
for (int i = 1; i <= n; i++)
if (col[i] == 0) V.push_back(i);
return V;
}
vector<int> get_f1() {
vector<int> V;
V.clear();
for (int i = 1; i <= n; i++)
if (col[i] == -1) V.push_back(i);
return V;
}
int Solve(int x, vector<int> V, int ans = -1) {
vector<int> V1, V2;
V1.clear();
V2.clear();
int s = V.size(), md = s / 2, t;
if (ans == -1)
t = cedge(x, V);
else
t = ans;
if (!t) return 0;
if (s == 1) {
addedge(x, V[0]);
return 1;
}
for (int i = 0; i < md; i++) V1.push_back(V[i]);
for (int i = md; i < s; i++) V2.push_back(V[i]);
int tmp = Solve(x, V1);
Solve(x, V2, t - tmp);
return t;
}
vector<int> VGG;
void getGG(int x, int c = 0) {
col[x] = c;
VGG.push_back(x);
for (int T = Head[x]; T; T = Next[T])
if (col[Go[T]] == -1)
getGG(Go[T], !c);
else if (col[Go[T]] == col[x])
GG(VGG);
VGG.pop_back();
}
void Search(int x, int c = 0) {
col[x] = -1;
if (c == 0 && cedge(x, get0())) {
Solve(x, get0());
memset(col, -1, sizeof col);
getGG(x);
} else if (c == 1 && cedge(x, get1())) {
Solve(x, get1());
memset(col, -1, sizeof col);
getGG(x);
}
col[x] = c;
Solve(x, get_f1());
vector<int> V;
V.clear();
for (int T = Head[x]; T; T = Next[T])
if (col[Go[T]] == -1) col[Go[T]] = !c, V.push_back(Go[T]);
for (int i = 0; i < V.size(); i++) Search(V[i], !c);
}
int main() {
scanf("%d", &n);
memset(col, -1, sizeof col);
Search(1);
vector<int> V;
V.clear();
for (int i = 1; i <= n; i++)
if (col[i] == 0) V.push_back(i);
OK(V);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, -1, 0, 1, 1, -1, -1, 1};
int dy[] = {-1, 0, 1, 0, -1, -1, 1, 1};
int dx1[] = {0, 1, 1}, dx2[] = {0, 1, 1}, dy1[] = {1, 1, 0},
dy2[] = {-1, -1, 0};
int n, x[4], y[4], maxx, maxy, minx, miny;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
minx = x[min_element(x, x + n) - x];
miny = y[min_element(y, y + n) - y];
maxx = x[max_element(x, x + n) - x];
maxy = y[max_element(y, y + n) - y];
if (minx == maxx || miny == maxy)
cout << -1;
else
cout << (maxx - minx) * (maxy - miny);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
int t, n;
char s[N];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
scanf("%s", s + 1);
int ans = n;
for (int i = 1; i <= n; i++) {
if (s[i] == '1') {
ans = max(ans, i * 2);
ans = max(ans, (n - i + 1) * 2);
ans = max(ans, n + 1);
}
}
printf("%d\n", ans);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long a, b, n, m;
cin >> a >> b >> n >> m;
if (a + b >= n + m && min(a, b) >= m)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long n, k;
cin >> n >> k;
long long type = -1;
long long tran = -1;
long long boxes = -1;
for (long long i = 0; i < k; i++) {
long long x;
cin >> x;
long long temp = n - n % x;
if (temp > tran) {
tran = n - n % x;
type = i + 1;
boxes = n / x;
}
}
cout << type << " " << boxes << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long a[N], ch[N], p[N];
bool vis[N], vis1[N];
vector<long long> v[N];
set<int> s;
map<string, long long> mp;
int node1 = 1, node2 = 1, mx = 0, n;
bool q = 0;
int dfs(int j, int r) {
for (int i = 0; i < v[j].size(); i++) {
if (v[j][i] != r) p[v[j][i]] = j, ch[j] += dfs(v[j][i], j);
}
if (ch[j] == n / 2) node1 = j, node2 = r;
return ch[j];
}
int main() {
int t;
cin >> t;
while (t--) {
int x, y;
cin >> n;
v[1].clear(), ch[1] = 0, node1 = 1, node2 = 1, mx = 0;
for (int i = 2; i <= n; i++) v[i].clear(), ch[i] = 1;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
v[y].push_back(x), v[x].push_back(y);
}
if (n % 2) {
cout << node1 << " " << v[node1][0] << "\n"
<< node2 << " " << v[node1][0] << "\n";
continue;
}
dfs(1, 0);
for (int i = 0; i < v[node1].size(); i++) {
if (node2 != v[node1][i]) {
cout << node1 << " " << v[node1][i] << "\n"
<< node2 << " " << v[node1][i] << "\n";
break;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void Read(int &x) {
char c;
bool flag = 0;
while (c = getchar(), c != EOF && (c < '0' || c > '9') && c != '-')
;
if (c == '-') {
c = getchar();
flag = 1;
}
x = c - '0';
while (c = getchar(), c != EOF && c >= '0' && c <= '9') x = x * 10 + c - '0';
}
queue<int> q;
vector<int> a[100010];
int n, m, k, vis[100010], st, ed;
bool va[100010], inq[100010];
bool check(int s) {
memset(vis, -1, sizeof vis);
vis[st] = 0;
q.push(st);
while (!q.empty()) {
int x = q.front();
inq[x] = 0;
q.pop();
if (vis[x] + 1 > s) continue;
for (int i = 0; i < a[x].size(); i++)
if (vis[a[x][i]] == -1 || vis[a[x][i]] > vis[x] + 1) {
vis[a[x][i]] = vis[x] + 1;
if (va[a[x][i]] == 1) vis[a[x][i]] = 0;
if (inq[a[x][i]] == 0) {
inq[a[x][i]] = 1;
q.push(a[x][i]);
}
}
}
if (vis[ed] != -1) return 1;
return 0;
}
int main() {
Read(n), Read(m), Read(k);
int x, y;
for (int i = 1; i <= k; i++) {
Read(x);
va[x] = 1;
}
for (int i = 1; i <= m; i++) {
Read(x), Read(y);
a[x].push_back(y);
a[y].push_back(x);
}
Read(st), Read(ed);
int l = 0, r = n;
int ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%d", ans);
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, m, f;
scanf("%d %d %d", &n, &m, &f);
int a[n][m];
int i, j = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
printf("\n\n");
}
int k = 0, temp, p = 0;
if (f == 1) {
for (i = 0; i < m; i++) {
for (j = i + 1; j < m; j++) {
p++;
}
}
printf("%d", p);
printf("\n\n");
k = 0;
for (i = 0; i < m; i++) {
for (j = i + 1; j < m; j++) {
printf("%d %d", j + 1, i + 1);
printf("\n");
}
}
}
if (f == 0) {
for (i = 0; i < m; i++) {
for (j = i + 1; j < m; j++) {
p++;
}
}
printf("%d\t", p);
printf("\n");
for (i = 0; i < m; i++) {
for (j = i + 1; j < m; j++) {
printf("%d %d", i + 1, j + 1);
printf("\n");
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int N = 1e5 + 5;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
string s;
cin >> n >> s;
unordered_map<long long int, long long int> f;
for (long long int i = 0; i < (long long int)((s).size()); i++) {
long long int tmp = 0;
for (long long int j = i; j < (long long int)((s).size()); j++) {
tmp += (s[j] - '0');
f[tmp]++;
}
}
long long int ans = 0;
if (n) {
for (long long int i = 1; i * i <= n; i++) {
if (n % i) continue;
if (i == n / i)
ans += f[i] * f[i];
else
ans += 2LL * f[i] * f[n / i];
}
} else {
long long int all = 0;
for (auto to : f) {
all += to.second;
}
all -= f[0];
ans += f[0] * f[0];
ans += 2LL * f[0] * all;
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
long long M = 1000000007;
using namespace std;
long long fact[10000];
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;
}
unsigned long long modInverse(unsigned long long n, long long p) {
return power(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n, long long r,
long long p) {
if (n < r) return 0;
if (r == 0) return 1;
return (fact[n] * modInverse(fact[r], p) % p * modInverse(fact[n - r], p) %
p) %
p;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, m, cnt = 0, mi = 1e9, m1 = 0;
cin >> n >> m;
long long a[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
cnt += abs(a[i][j]);
if (a[i][j] < 0) m1++;
mi = min(mi, abs(a[i][j]));
}
}
if (m1 % 2 != 0) cnt -= 2 * mi;
cout << cnt << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int add(int a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
return a;
}
int rest(int a, int b) {
a -= b;
if (a < 0) {
a += mod;
}
return a;
}
int mult(int a, int b) { return ((long long)a * (long long)b) % mod; }
const int MaxC = 256;
const int MAX = 300020;
int offset, n;
int suma[MAX], tmp[MAX];
int rank1[MAX], rank2[MAX];
int c[MAX], p[MAX], lcp[MAX];
bool different(int a, int b) {
if (b + offset >= n) return true;
if (rank1[a] != rank1[b]) return true;
if (rank2[a] != rank2[b]) return true;
return false;
}
void suffix_array(char *text) {
n = strlen(text);
for (int i = 0; i < MaxC; i++) suma[i] = 0;
for (int i = 0; i < n; i++) suma[text[i]]++;
for (int i = 0; i < MaxC; i++) suma[i + 1] += suma[i];
for (int i = 0; i < n; i++) c[i] = suma[text[i]] - 1;
for (offset = 1; offset <= n; offset <<= 1) {
for (int i = 0; i < n; i++) {
rank1[i] = c[i];
rank2[i] = (i + offset < n) ? c[i + offset] : 0;
}
fill(suma, suma + n, 0);
for (int i = 0; i < n; i++) suma[rank2[i]]++;
for (int i = 0; i < n; i++) suma[i + 1] += suma[i];
for (int i = 0; i < n; i++) tmp[--suma[rank2[i]]] = i;
fill(suma, suma + n, 0);
for (int i = 0; i < n; i++) suma[rank1[i]]++;
for (int i = 0; i < n; i++) suma[i + 1] += suma[i];
for (int i = n - 1; i >= 0; i--) p[--suma[rank1[tmp[i]]]] = tmp[i];
c[p[0]] = 0;
for (int i = 1; i < n; i++) {
c[p[i]] = c[p[i - 1]];
if (different(p[i], p[i - 1])) c[p[i]]++;
}
}
offset = 0;
for (int i = 0; i < n; i++) {
if (c[i] == n - 1) {
lcp[n - 1] = 0;
continue;
}
while (text[i + offset] != '{' &&
text[i + offset] == text[p[c[i] + 1] + offset])
offset++;
lcp[c[i]] = offset;
if (offset > 0) offset--;
}
}
int cc[3][MAX];
int indw[MAX];
int len[3];
char s[MAX];
int sol[MAX];
int cant(int l, int r, int x) {
if (l == 0) {
return cc[x][r];
}
return rest(cc[x][r], cc[x][l - 1]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int sz = 0;
for (int i = 0; i < 3; i++) {
string tmp;
cin >> tmp;
len[i] = tmp.size();
for (int j = 0; j < len[i]; j++) {
indw[sz] = i;
s[sz++] = tmp[j];
}
s[sz++] = '{';
}
s[sz] = '\0';
suffix_array(s);
n -= 3;
for (int i = 0; i < n; i++) {
if (i > 0) {
cc[0][i] = cc[0][i - 1];
cc[1][i] = cc[1][i - 1];
cc[2][i] = cc[2][i - 1];
}
cc[indw[p[i]]][i]++;
}
stack<int> st;
for (int i = 0; i < n; i++) {
while (!st.empty() && lcp[st.top()] >= lcp[i]) {
int j = st.top();
st.pop();
if (lcp[i] == lcp[j]) {
continue;
}
int l = 0;
int r = i;
int mx = lcp[i];
if (!st.empty()) {
mx = max(mx, lcp[st.top()]);
l = st.top() + 1;
}
int tmp = mult(cant(l, r, 0), mult(cant(l, r, 1), cant(l, r, 2)));
sol[mx + 1] = add(sol[mx + 1], tmp);
sol[lcp[j] + 1] = rest(sol[lcp[j] + 1], tmp);
}
st.push(i);
}
int tmp = 0;
for (int i = 1; i <= min(len[0], min(len[1], len[2])); i++) {
tmp = add(tmp, sol[i]);
if (i > 1) {
cout << ' ';
}
cout << tmp;
}
cout << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long two[51];
void init() {
two[0] = 1;
for (int i = 1; i < 51; i++) two[i] = two[i - 1] * 2;
}
long long dfs(long long h, long long n, int dir) {
if (h == 0) return 0;
long long vis = 1;
int req = (n > (1LL << (h - 1)));
if (req != dir) vis += two[h] - 1;
if (n > (1LL << (h - 1))) n -= (1LL << (h - 1));
vis += dfs(h - 1, n, req ^ 1);
return vis;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init();
long long h, n;
cin >> h >> n;
cout << dfs(h, n, 0) << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0},
dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
int used[300][300], board[300][300];
int T, n, m, cnt, xmax, xmin, ans;
void dfs(int x, int y) {
if (used[x][y] || !board[x][y]) return;
used[x][y] = 1;
cnt++;
xmax = max(xmax, x);
xmin = min(xmin, x);
for (int i = 0; i < 8; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
dfs(xx, yy);
}
}
bool check1(int x, int y) {
int d = xmax - xmin;
if (d < 1) return false;
if (cnt != d * 4) return false;
for (int i = x; i <= x + d; i++)
if (!used[i][y] || !used[i][y + d]) return false;
for (int j = y; j <= y + d; j++)
if (!used[x][j] || !used[x + d][j]) return false;
return true;
}
bool check2(int x, int y) {
int d = (xmax - xmin) / 2;
if (d < 1) return false;
if (cnt != d * 4) return false;
for (int i = 0; i <= d; i++) {
if (!used[x + i][y + i] || !used[x + i][y - i]) return false;
}
for (int i = 1; i <= d; i++) {
if (!used[x + d + i][y - d + i] || !used[x + d + i][y + d - i])
return false;
}
return true;
}
int main() {
cin >> T;
while (T--) {
ans = 0;
memset(board, 0, sizeof(board));
memset(used, 0, sizeof(used));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == '1')
board[i][j] = 1;
else
board[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cnt = 0;
xmax = -1 << 29;
;
xmin = 1 << 29;
;
if (!used[i][j] && board[i][j]) {
dfs(i, j);
if (check1(i, j) || check2(i, j)) ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> e[200010];
int a[200010], top, dp[200010], flag, x;
bool f[200010];
char s[200010];
int dfs(int u) {
f[u] = 1;
if (e[u].size() == 0) {
if (u == x) flag = 1;
return 1;
} else {
int q = dfs(e[u][0]) + 1;
if (u == x) flag = q;
return q;
}
}
int main() {
int i, j, n, m, q, h;
flag = 0;
scanf("%d%d", &n, &x);
for (i = 1; i <= n; i++) {
scanf("%d", &q);
if (q) e[i].push_back(q), f[q] = 1;
}
for (i = 1; i <= n; i++)
if (!f[i]) {
q = dfs(i);
if (flag)
h = flag, flag = 0;
else
a[top++] = q;
}
dp[0] = 1;
for (i = 0; i < top; i++)
for (j = n - a[i]; j >= 0; j--) dp[j + a[i]] |= dp[j];
for (i = 0; i <= n; i++)
if (dp[i]) printf("%d\n", i + h);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
double calculate(int x1, int y1, int x2, int y2, int x3, int y3) {
return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
}
double cacu(int x1, int y1, point a[]) {
double sum = 0;
int next;
for (int i = 0; i < 4; i++) {
next = (i + 1) % 4;
sum += calculate(x1, y1, a[i].x, a[i].y, a[next].x, a[next].y);
}
return sum;
}
point a[4], b[4];
point mid1, mid2;
int main() {
for (int i = 0; i < 4; i++) {
cin >> a[i].x >> a[i].y;
a[i].x = (a[i].x) * 2;
a[i].y = (a[i].y) * 2;
if (i == 0) {
mid1.x = 0;
mid1.y = 0;
}
mid1.x += a[i].x;
mid1.y += a[i].y;
}
for (int i = 0; i < 4; i++) {
cin >> b[i].x >> b[i].y;
b[i].x = (b[i].x) * 2;
b[i].y = (b[i].y) * 2;
if (i == 0) {
mid2.x = 0;
mid2.y = 0;
}
mid2.x += b[i].x;
mid2.y += b[i].y;
}
mid1.x /= 4;
mid1.y /= 4;
mid2.x /= 4;
mid2.y /= 4;
double first, second;
second = calculate(b[0].x, b[0].y, b[1].x, b[1].y, b[2].x, b[2].y);
second *= 2;
first = calculate(a[0].x, a[0].y, a[1].x, a[1].y, a[2].x, a[2].y);
first *= 2;
double sum, sum2;
bool flag = false;
for (int i = 0; i < 4; i++) {
sum = cacu(a[i].x, a[i].y, b);
if (sum == second) flag = true;
}
for (int i = 0; i < 4; i++) {
sum = cacu(b[i].x, b[i].y, a);
if (sum == first) flag = true;
}
sum = cacu(mid1.x, mid1.y, b);
if (sum == second) flag = true;
sum = cacu(mid2.x, mid2.y, a);
if (sum == first) flag = true;
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
long long qpow(long long x, long long q) {
long long ans = 1;
while (q) {
if (q & 1) ans = ans * x % Mod;
q >>= 1;
x = (x * x) % Mod;
}
return ans % Mod;
}
long long x, n;
int main() {
cin >> x >> n;
vector<int> a;
for (long long i = 2; i <= sqrt(x); i++) {
if (x % i) continue;
a.push_back(i);
while (x % i == 0) x /= i;
}
if (x != 1) a.push_back(x);
long long ans = 1;
for (int i = 0; i < a.size(); i++) {
long long now = n, tot = 0;
while (now) {
tot += now / a[i];
now /= a[i];
}
ans = (ans * qpow(a[i], tot) % Mod) % Mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct caca {
long long a, b;
};
caca v[7005];
bool ok[7005];
bool cmp(caca a, caca b) { return a.a < b.a; }
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i].a;
for (int i = 1; i <= n; i++) cin >> v[i].b;
sort(v + 1, v + n + 1, cmp);
v[0].a = -1;
v[n + 1].a = -1;
for (int i = 1; i <= n; i++) {
if (v[i].a == v[i - 1].a || v[i].a == v[i + 1].a) {
ok[i] = 1;
for (int j = 1; j <= n; j++) {
if ((v[i].a & v[j].a) == v[j].a) {
ok[j] = 1;
}
}
}
}
long long sol = 0;
for (int i = 1; i <= n; i++) {
if (ok[i]) {
sol += v[i].b;
}
}
cout << sol;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void test(T a) {
cout << a << endl;
}
template <class T, class T2>
void test(T a, T2 b) {
cout << a << " " << b << endl;
}
template <class T, class T2, class T3>
void test(T a, T2 b, T3 c) {
cout << a << " " << b << " " << c << endl;
}
const int N = 2e6 + 10;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-15;
const long long mod = 1000000007;
bool isprime[N];
vector<int> prime;
void getprime() {
memset(isprime, 1, sizeof(isprime));
isprime[0] = isprime[1] = 0;
for (int i = 2; i <= (1e5); i++) {
if (isprime[i]) prime.push_back(i);
for (int j = 2 * i; j < 1e5; j += i) {
isprime[j] = 0;
}
}
}
set<int> ve[N];
map<long long, int> dp;
int cal(long long x) {
if (dp.find(x) != dp.end()) return dp[x];
if (!x) return x;
int vis[55] = {0};
int k = 0;
for (int i = 0; i < (40); i++) {
if (x & (1ll << i)) k = i;
}
for (int i = k; i >= 0; i--) {
long long y = (x >> i + 1) | (x & ((1ll << i) - 1));
vis[cal(y)] = 1;
}
for (int i = 0; i < (40); i++)
if (!vis[i]) return dp[x] = i;
}
void work() {
int n;
cin >> n;
int v;
map<int, int> Hash;
int idx = 0;
for (int i = 0; i < (n); i++) {
cin >> v;
for (int i = 0; i < ((int)prime.size()); i++) {
int cnt = 0;
if (prime[i] > v) break;
while (v % prime[i] == 0) {
cnt++;
v /= prime[i];
}
if (cnt) {
if (Hash.find(prime[i]) == Hash.end()) {
Hash[prime[i]] = idx++;
}
int id = Hash[prime[i]];
ve[id].insert(cnt);
}
}
if (v && v - 1) {
if (Hash.find(v) == Hash.end()) {
Hash[v] = idx++;
}
int id = Hash[v];
ve[id].insert(1);
}
}
map<int, int>::iterator it;
int ans = 0;
for (it = Hash.begin(); it != Hash.end(); it++) {
auto p = *it;
int id = p.second;
long long x = 0;
for (auto stit = ve[id].begin(); stit != ve[id].end(); stit++) {
int v = *stit;
x |= (1ll << (v - 1));
}
ans ^= cal(x);
}
if (ans)
test("Mojtaba");
else
test("Arpa");
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
getprime();
work();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long extgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long x1, y1;
long long d = extgcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
long long revrsno(long long n) {
long long k = 0;
vector<long long> z;
while (n > 0) {
z.push_back(n % 10);
n /= 10;
}
for (long long i = 0; i < z.size(); i++) k = k * 10 + z[i];
return k;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long divide(long long a, long long b) {
return (a % 1000000007) * powm(b, 1000000007 - 2) % 1000000007;
}
long long mul(long long a, long long b) {
return ((a % 1000000007) * (b % 1000000007)) % 1000000007;
}
long long add(long long a, long long b) {
return (a % 1000000007 + b % 1000000007) % 1000000007;
}
long long Totfun(long long n) {
long long z = n;
if (n % 2 == 0) {
while (n % 2 == 0) {
n /= 2;
}
z /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (isPrime(i) && n % i == 0) {
while (n % i == 0) {
n /= i;
}
z -= z / i;
}
}
if (n > 1) {
z -= z / n;
}
return z;
}
long long maxPrimeFactor(long long n) {
long long maxPrime = -1;
while (n % 2 == 0) {
maxPrime = 2;
n >>= 1;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
}
if (n > 2) maxPrime = n;
return maxPrime;
}
long long fact[100001];
long long nCr(long long n, long long r) {
if (r > n || r < 0) return 0;
long long z = fact[n];
z = mul(z, powm(fact[n - r], 1000000007 - 2));
z = mul(z, powm(fact[r], 1000000007 - 2));
return z;
}
long long v[200001][19];
void cal() {
for (long long i = 0; i < 19; i++) {
for (long long j = 1; j < 200001; j++) {
if ((j & (1 << i)))
v[j][i] = 1;
else
v[j][i] = 0;
}
}
for (long long i = 0; i < 19; i++) {
for (long long j = 1; j < 200001; j++) {
v[j][i] += v[j - 1][i];
}
}
}
void solve() {
long long l, r;
cin >> l >> r;
long long ans = 1e9;
for (long long i = 0; i < 19; i++) {
ans = ((ans > (r - l + 1) - (v[r][i] - (v[l - 1][i])))
? (r - l + 1) - (v[r][i] - (v[l - 1][i]))
: ans);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
cal();
while (t--) {
solve();
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long MAXN = 5e3 + 19;
const long long INF = 1e18;
long long n, a[MAXN], b[MAXN];
long long tmp[MAXN], tot;
long long dp[MAXN][MAXN];
long long dfs(long long l, long long r) {
if (dp[l][r] != INF) return dp[l][r];
bool flag = 0;
long long L, R;
long long mn;
long long res = 0;
for (long long i = l; i <= r; ++i)
if (a[i]) {
if (!flag) L = i, flag = 1, mn = a[i];
mn = std::min(mn, a[i]);
if (i == r || a[i + 1] == 0) {
flag = 0;
R = i;
long long del = 0;
for (long long j = L; j <= R; ++j) {
if (a[j] == mn) ++del;
a[j] -= mn;
}
if (dfs(L, R) - del + mn < 0) res += dfs(L, R) - del + mn;
}
}
return dp[l][r] = res;
}
signed main() {
std::scanf("%lld", &n);
long long ans = 0;
for (long long i = 1; i <= n; ++i) std::scanf("%lld", a + i);
for (long long i = 1; i <= n; ++i)
if (a[i]) ++ans;
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= n; ++j) dp[i][j] = INF;
std::printf("%lld\n", ans + dfs(1, n));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans;
long long a, b;
cin >> a >> b;
long long sum = 0;
for (long long i = 1; i <= a; i++) sum = (sum + i) % 1000000007;
ans = 0;
for (long long i = 1; i < b; i++) {
ans = (ans + ((sum * b) % 1000000007) * i % 1000000007 + (i * a)) %
1000000007;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int w[maxn], c[maxn], arr[4][maxn], top[4], n, m;
long long sum[4][maxn];
struct Node {
long long cost;
int i, j;
} dp[maxn * 3];
int main() {
while (~scanf("%d%d", &n, &m)) {
long long ans = 0;
for (int i = 1; i <= 3; i++) sum[i][0] = top[i] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &w[i], &c[i]);
arr[w[i]][++top[w[i]]] = c[i];
}
for (int i = 1; i <= 3; i++)
sort(arr[i] + 1, arr[i] + top[i] + 1, greater<int>());
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= top[i]; j++) sum[i][j] = sum[i][j - 1] + arr[i][j];
}
for (int i = 0; i <= m; i++) dp[i].cost = 0;
dp[1].cost = arr[1][1], dp[1].i = 2, dp[1].j = 1;
dp[0].i = dp[0].j = 1;
for (int j = 2; j <= m; j++) {
if (dp[j - 1].cost + (dp[j - 1].i <= top[1] ? arr[1][dp[j - 1].i] : 0) >
dp[j - 2].cost + (dp[j - 2].j <= top[2] ? arr[2][dp[j - 2].j] : 0)) {
dp[j].cost =
dp[j - 1].cost + (dp[j - 1].i <= top[1] ? arr[1][dp[j - 1].i] : 0);
dp[j].i = dp[j - 1].i + 1;
dp[j].j = dp[j - 1].j;
} else {
dp[j].cost =
dp[j - 2].cost + (dp[j - 2].j <= top[2] ? arr[2][dp[j - 2].j] : 0);
dp[j].i = dp[j - 2].i;
dp[j].j = dp[j - 2].j + 1;
}
}
for (int i = 0; 3 * i <= m; i++) {
ans = max(ans, sum[3][i] + dp[m - 3 * i].cost);
}
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, ar[25], ori[25], temp[25];
bool cmp(int a, int b) { return ar[a] < ar[b]; }
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &ar[i]);
ori[i] = i;
}
sort(ori, ori + N, cmp);
for (int i = 0; i < N; i++) temp[ori[i]] = ar[ori[(i + 1) % N]];
for (int i = 0; i < N; i++) {
printf("%d", temp[i]);
if (i != N - 1) printf(" ");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int exp(long long int x, long long int y) {
if (y == 0) return 1;
if (y == 1) return x;
if (y % 2 == 0)
return exp(x, y / 2) * exp(x, y / 2);
else
return x * exp(x, y / 2) * exp(x, y / 2);
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int l;
long long int fact(long long int x) {
if (x == 1)
return 1;
else
return x * fact(x - 1);
}
bool isPrime(int x) {
int ans = 0;
for (int i = 2; i <= sqrt(x); ++i) {
if (x % i == 0) {
ans = 1;
i = x;
}
}
if (ans == 0)
return true;
else
return false;
}
void solve() {
string s;
cin >> s;
vector<int> v;
for (int i = 0; i < s.length(); ++i) {
if (s[i] != '+') v.push_back((int)s[i] - '0');
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i) {
if (i == v.size() - 1)
cout << v[i];
else
cout << v[i] << "+";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, d;
int main() {
cin >> a >> b;
d = a - b;
if (d < 0) d *= -1;
long long rez = 0;
rez = (long long)(d / 2) * (d / 2 + 1);
if (d % 2) rez += d / 2 + 1;
cout << rez;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
vector<int> in;
int i = 0;
for (i = 1; i <= n; i++) {
int a = 0;
cin >> a;
in.push_back(a);
}
vector<int> out = in;
sort(in.begin(), in.end());
int shoot = 0;
for (i = in.end() - in.begin() - 1; i >= 0; i--) {
shoot += (in.end() - in.begin() - 1 - i) * in[i] + 1;
}
cout << shoot << endl;
for (i = in.size() - 1; i >= 0; i--) {
if (i != in.size() - 1) cout << " ";
int k = 0;
for (k = 0; k < out.size(); k++) {
if (in[i] == out[k]) {
cout << k + 1;
out[k] = 0;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 100010;
int n;
char s[N];
bool f[26];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n - 25; i++) {
int c = 0;
for (int j = 0; j < 26; j++) f[j] = false;
for (int j = i; j < i + 26; j++)
if (s[j] != '?')
f[s[j] - 'A'] = true;
else
c++;
for (int j = 0; j < 26; j++)
if (f[j]) c++;
if (c == 26) {
for (int j = i; j < i + 26; j++)
if (s[j] == '?')
for (int k = 0; k < 26; k++)
if (!f[k]) {
f[k] = true;
s[j] = k + 'A';
break;
}
for (int j = 1; j <= n; j++)
if (s[j] == '?') s[j] = 'A';
printf("%s", s + 1);
return 0;
}
}
printf("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[100001];
int main() {
int l;
scanf("%s", s);
l = strlen(s);
puts((s[l - 1] & 1) || (s[l - 1] / 2 + (l > 1 ? s[l - 2] : 0) & 1) ? "0"
: "4");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2 * 1e6 + 7, mod = 1e9 + 7;
int n, a[maxx], prime[maxx], vis[maxx];
void getprime(int x) {
for (int i = 2; i <= x; i++) {
if (!vis[i]) prime[++prime[0]] = i;
for (int j = 1; j <= prime[0] && i * prime[j] <= x; j++) {
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
int main() {
getprime(2000000);
int one = 0, ans = 0, two = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) one++;
if (a[i] % 2 == 0 && !vis[a[i] + 1]) two = a[i];
}
ans = one + (two != 0);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (!vis[a[i] + a[j]] && ans <= 2) {
cout << 2 << '\n' << a[i] << " " << a[j] << endl;
goto next;
}
}
}
if (ans) {
cout << ans << endl;
for (int i = 1; i <= one; i++) cout << 1 << " ";
if (two)
cout << two << endl;
else
cout << endl;
} else
cout << 1 << '\n' << a[1] << endl;
next:;
}
| 5 |
#include <bits/stdc++.h>
int par[100050][20];
int dep[100050];
int nw[100050];
std::vector<std::vector<int>> adj;
int make_tree(int id, int depth) {
nw[id] = 1;
dep[id] = depth;
for (auto i : adj[id]) {
if (dep[i]) continue;
int pidx = id, cnt = 0;
par[i][0] = id;
while (pidx != -1) {
pidx = par[i][cnt + 1] = par[pidx][cnt];
cnt++;
}
nw[id] += make_tree(i, depth + 1);
}
return nw[id];
}
int lca(int u, int v) {
if (dep[u] < dep[v]) std::swap(u, v);
for (int i = 16; i >= 0; i--)
if (1 << i <= dep[u] - dep[v]) u = par[u][i];
if (u == v) return u;
for (int i = 16; i >= 0; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return par[u][0];
}
int dist(int a, int b) {
int m = lca(a, b);
int ret = ((dep[m] - dep[a]) < 0 ? -(dep[m] - dep[a]) : (dep[m] - dep[a])) +
1 +
((dep[b] - dep[m]) < 0 ? -(dep[b] - dep[m]) : (dep[b] - dep[m]));
return ret;
}
int get_v(int s, int t, int f) {
int sf = dist(s, f);
int tf = dist(t, f);
int m = lca(s, t);
int sm = dist(m, s);
int tm = dist(m, t);
int ret = (sf - sm + tf - tm) / 2 + 1;
return ret;
}
int main() {
memset(par, 0xff, sizeof(par));
int N, Q;
scanf("%d%d", &N, &Q);
adj.resize(N + 1);
for (int i = 2; i <= N; i++) {
int v;
scanf("%d", &v);
adj[v].push_back(i);
adj[i].push_back(v);
}
make_tree(1, 1);
for (int tc = 0; tc < Q; tc++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
printf("%d\n", std::max({get_v(a, b, c), get_v(a, c, b), get_v(c, b, a)}));
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, a[1005], ans, min, min2;
a[1004] = 100000;
cin >> t;
for (int i = 0; i < t; i++) {
scanf("%d%d", &m, &n);
ans = 0;
min = 1004;
min2 = 1004;
for (int j = 0; j < m; j++) {
scanf("%d", &a[j]);
ans += a[j];
if (a[j] < a[min])
min = j;
else if (a[j] < min2)
min2 = j;
}
if (n < m || m <= 2) {
cout << "-1" << endl;
continue;
}
ans *= 2;
ans += (n - m) * (a[min] + a[min2]);
cout << ans << endl;
for (int i = 1; i < m; i++) {
printf("%d %d\n", i, i + 1);
}
printf("%d %d\n", m, 1);
for (int i = 0; i < n - m; i++) {
printf("%d %d\n", min + 1, min2 + 1);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n % 2 != 0)
cout << a[(n / 2)];
else
cout << a[(n / 2) - 1];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int input() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
long long int ans = 0;
while (c >= '0' && c <= '9') {
ans = (ans << 3) + (ans << 1) + c - '0';
c = getchar();
}
return (ans);
}
int main() {
long long int permut[5] = {0, 1, 2, 3, 4}, ans = 0;
long long int g[5][5], i, j;
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
g[i][j] = input();
}
}
while (next_permutation(permut, permut + 5)) {
ans = max(ans, 2 * (g[permut[2]][permut[3]] + g[permut[3]][permut[2]]) +
2 * (g[permut[3]][permut[4]] + g[permut[4]][permut[3]]) +
g[permut[0]][permut[1]] + g[permut[1]][permut[0]] +
g[permut[1]][permut[2]] + g[permut[2]][permut[1]]);
}
ans = max(ans, 2 * (g[permut[2]][permut[3]] + g[permut[3]][permut[2]]) +
2 * (g[permut[3]][permut[4]] + g[permut[4]][permut[3]]) +
g[permut[0]][permut[1]] + g[permut[1]][permut[0]] +
g[permut[1]][permut[2]] + g[permut[2]][permut[1]]);
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool checkMin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool checkMax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int INF = 1e9;
const int N = 3e5 + 10;
int n, k;
long long a[N], l[N];
pair<int, int> q[N];
int main() {
while (scanf("%d", &n) != EOF) {
memset(l, 0, sizeof l);
memset(a, 0, sizeof a);
for (int i = (1); i <= (n); i++) {
cin >> q[i].first;
q[i].second = i;
}
sort(q + 1, q + n + 1);
for (int i = (1); i <= (n); i++) {
a[i] = q[i].first;
}
cin >> k;
int i, b = -1;
long long sum = 0, bsum;
long long f = 0;
for (i = 1; i <= k; i++) {
f += a[i];
sum += i * a[i] - f;
}
for (i = n; i >= 1; i--) l[i] = l[i + 1] + a[i];
bsum = sum;
b = 1;
for (i = k + 1; i <= n; i++) {
f -= a[i - k];
f += a[i];
sum -= (l[i - k] - l[i]) - a[i - k] * k;
sum += a[i] * k - f;
if (sum < bsum) {
bsum = sum;
b = i - k + 1;
}
}
for (i = 0; i < k; i++) printf("%d ", q[b + i].second);
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define maxn 130086
using namespace std;int n, p;int f[maxn], g[maxn], h[maxn];
int main(){scanf("%d%d", &n, &p);f[0] = 1;for(int i = 0;i < maxn;i++) g[i] = 1;int ans = 0;for(int i = 1;i <= n - 1;i++){
for(int j = maxn - 1;~j;j--) f[j] = (g[j] + p - (j - i < 0 ? 0 : g[j - i])) % p;
for(int j = 0;j < maxn;j++) g[j] = (f[j] + (j ? g[j - 1] : 0)) % p, h[j] = (g[j] + (j ? h[j - 1] : 0)) % p;
int sum = 0, val = 0;for(int j = 0;j < maxn;j++){if(j - 2 >= 0) val = (val + 1ll * i * g[j - 2]) % p;
if(j - 3 >= 0) val = (1ll * val + (j - i - 3 < 0 ? 0 : h[j - i - 3]) + p - h[j - 3]) % p;sum = (sum + 1ll * f[j] * val) % p;}
for(int j = 1;j <= n - i - 1;j++) sum = 1ll * sum * (n - j + 1) % p;ans = (ans + sum) % p;}printf("%d", ans);} | 9 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
char s[100002], a[11];
int pos[11][11 - 1][4][100002];
void add(int len, int r, int val, int x) {
for (int i = abs(x); i <= n; i += i & (-i))
if (x > 0)
++pos[len][r][val][i];
else
--pos[len][r][val][i];
}
int sum(int len, int r, int val, int x) {
if (x <= 0) return 0;
int ret = 0;
for (; x > 0; x -= x & (-x)) ret += pos[len][r][val][x];
return ret;
}
int conv(char c) {
if (c == 'G') return 1;
if (c == 'T') return 2;
if (c == 'C') return 3;
return 0;
}
int main() {
scanf("%s\n", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
int val = conv(s[i]);
for (int len = 1; len <= 10; ++len) add(len, i % len, val, i);
}
scanf("%d", &q);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, val1, val2;
char c;
scanf("%d %c", &x, &c);
val1 = conv(s[x]);
val2 = conv(c);
if (val1 != val2) {
for (int len = 1; len <= 10; ++len) {
add(len, x % len, val2, x);
add(len, x % len, val1, -x);
}
s[x] = c;
}
} else {
int l, r, ans = 0;
scanf("%d %d %s", &l, &r, a + 1);
int len = strlen(a + 1);
for (int i = l; i <= r && i < l + len; ++i) {
int val = conv(a[i - l + 1]);
ans += sum(len, i % len, val, r) - sum(len, i % len, val, l - 1);
}
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string s;
cin >> s;
long long int i;
map<char, long long int> mp;
for (i = 0; i < s.length(); i++) mp[s[i]]++;
char x;
long long int eve = 0, odd = 0;
for (x = 'a'; x <= 'z'; x++) {
if (mp[x] != 0) {
if (mp[x] % 2 == 0)
eve++;
else
odd++;
}
}
if (odd <= 1) {
cout << "First";
return 0;
}
odd--;
if (odd % 2 != 0) {
cout << "Second";
} else {
cout << "First";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, u;
cin >> n >> u;
int a[n + 5];
for (int i = 1; i <= n; i++) cin >> a[i];
double ans = 0;
for (int i = 1; i < n - 1; i++) {
int pos = upper_bound(a + 1, a + n + 1, a[i] + u) - (a + 1);
if (pos <= i + 1) continue;
ans = max(ans, (double)(a[pos] - a[i + 1]) / (double)(a[pos] - a[i]));
}
if (ans == 0)
puts("-1");
else
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long INFll = 1ll * 1000000000 * 1000000000;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int mul(int a, int b, int mod = 1000003) { return int(a * 1ll * b % mod); }
int norm(int a, int mod = 1000003) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
int powmod(int x, int y, int mod = 1000003) {
int res = 1;
while (y > 0) {
if (y & 1) res = mul(res, x, mod);
x = mul(x, x, mod);
y = y >> 1;
}
return res;
}
int inv(int a, int mod = 1000003) { return powmod(a, mod - 2); }
int main() {
int n;
cin >> n;
vector<int> a(n), b(n), p(n + 1);
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
int pos = -1, k = 0, disrupt = 0, ans = 0;
queue<int> q;
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] == 1) {
pos = i;
}
q.push(b[i]);
p[b[i]] = i + 1;
}
if (pos != -1) {
int i;
k = 2;
for (i = pos + 1; i < n; i++) {
if (b[i] == k) {
k++;
} else {
break;
}
}
if (i == n) {
k = k - 1;
} else {
k = 0;
disrupt = 1;
}
}
if (k != 0) {
while ((k + 1) <= n) {
if (disrupt == 1) {
while (q.front() != 1) {
m[q.front()]++;
q.pop();
m[0]--;
q.push(0);
ans++;
}
m[q.front()]++;
q.pop();
m[0]--;
q.push(0);
ans++;
k = 0;
disrupt = 0;
continue;
}
if (m[k + 1] == 1) {
m[k + 1]--;
m[q.front()]++;
q.pop();
q.push(k + 1);
ans++;
k++;
} else {
disrupt = 1;
}
}
} else {
ans = n;
int res = 0;
for (int i = 1; i <= n; i++) {
if (m[i]) continue;
if (p[i] > i - 1) {
res = max(res, p[i] - (i - 1));
}
}
ans += res;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string A, B;
int used[10][2];
int memo[10][2];
int m;
int dp(int pos, int mayor) {
if (pos == m) return mayor;
if (used[pos][mayor]) return memo[pos][mayor];
used[pos][mayor] = 1;
int &dev = memo[pos][mayor] = 0;
if (B[pos] == '?') {
if (mayor) {
if (pos == 0) {
dev = dp(pos + 1, 1);
} else {
dev = dp(pos + 1, 1);
}
} else {
for (int c = A[pos]; c <= '9'; ++c) {
if (pos == 0 && c == '0') continue;
dev |= dp(pos + 1, c > A[pos]);
}
}
} else {
if (!mayor && B[pos] < A[pos])
return 0;
else
dev = dp(pos + 1, mayor ? 1 : (B[pos] > A[pos]));
}
return dev;
}
string rec(int pos, int mayor) {
if (pos == m) return "";
if (B[pos] == '?') {
if (mayor) {
if (pos == 0) {
return string(1, '1') + rec(pos + 1, 1);
} else {
return string(1, '0') + rec(pos + 1, 1);
}
} else {
for (int c = A[pos]; c <= '9'; ++c) {
if (pos == 0 && c == '0') continue;
if (dp(pos + 1, c > A[pos]))
return string(1, c) + rec(pos + 1, c > A[pos]);
}
}
} else {
return string(1, B[pos]) + rec(pos + 1, mayor ? 1 : (B[pos] > A[pos]));
}
}
int toi(string &s) {
istringstream in(s);
int x;
in >> x;
return x;
}
string tos(int x) {
ostringstream out;
out << x;
return out.str();
}
string S[100000 + 5];
void fix(string &s) {
for (int i = 0; i < ((int)(s).size()); ++i) {
if (s[i] == '?') {
if (i == 0)
s[i] = '1';
else
s[i] = '0';
}
}
}
bool f(string &s, string &t) {
if (((int)(s).size()) > ((int)(t).size())) return 0;
for (int i = 0; i < ((int)(s).size()); ++i)
if (s[i] == '?') return 0;
if (((int)(s).size()) < ((int)(t).size())) {
fix(t);
return 1;
}
memset(used, 0, sizeof(used));
m = ((int)(s).size());
A = s, B = t;
if (!dp(0, 0)) return 0;
string C = rec(0, 0);
t = C;
return 1;
}
int main() {
ios_base ::sync_with_stdio(0);
int n;
while (cin >> n) {
S[0] = "";
bool possible = 1;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
bool ok = f(S[i], s);
if (!ok) possible = 0;
S[i + 1] = s;
}
if (!possible)
cout << "NO" << '\n';
else {
cout << "YES" << '\n';
for (int i = 0; i < n; ++i) cout << S[i + 1] << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
template <class T>
void minn(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void maxx(T &a, T b) {
if (a < b) a = b;
}
int madd(int &a, int b) {
a += b;
if (a >= 1000000009) a -= 1000000009;
return a;
}
int msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000009;
return a;
}
int mmult(int &a, int b) { return a = (long long)a * b % 1000000009; }
int mdiv(long long a, long long b, long long m) {
a = (a % 1000000009 + 1000000009) % 1000000009;
b = (b % 1000000009 + 1000000009) % 1000000009;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m, l;
int A[10123];
int F[13];
set<int> s;
bool B[13];
bool happy(int a) { return s.count(a); }
int fnd(int n, int m, int p, int i = 0) {
if (n == 0) return 0;
int k = m / F[n - 1];
int res = 0;
int j;
for (j = (0); j < (13); ++j) {
if (!B[j]) --k;
if (k < 0) break;
}
B[j] = 1;
res = happy(p + i + 1) && happy(p + j + 1);
return res + fnd(n - 1, m % F[n - 1], p, i + 1);
}
int slv(int n, int m, int p = 0) {
--m;
if (n < 13 && F[n] <= m) return -1;
int i;
for (i = (0); i < (13); ++i) B[i] = 0;
return fnd(n, m, p);
}
int main() {
int i, j, k;
char c;
int a, d;
l = 0;
for (i = (1); i < (10); ++i)
for (j = (0); j < (1 << i); ++j) {
int r = 0;
int d = 1;
for (k = (0); k < (i); ++k) r += d * (((j >> k) & 1) ? 7 : 4), d *= 10;
A[l++] = r;
s.insert(r);
}
F[0] = 1;
for (i = (1); i < (13); ++i) F[i] = F[i - 1] * i;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
scanf(
"%"
"d",
&(m));
int res = 0;
for (i = (0); i < (l); ++i)
if (A[i] <= n - 13) ++res;
if (n <= 13)
res += slv(n, m);
else
res += slv(13, m, n - 13);
printf(
"%"
"d",
(res));
printf("\n"), firstout = 1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return (long long)x * x; }
long long tri(long long x) {
if (x < 0) return 0;
return (long long)x * (x + 1) / 2;
}
long long calc(long long n, long long s, long long x, long long y) {
long long res = 2LL * s * (s + 1) + 1;
if (x - s < 1) res -= sqr(s - x + 1);
if (y - s < 1) res -= sqr(s - y + 1);
if (x + s > n) res -= sqr(x + s - n);
if (y + s > n) res -= sqr(y + s - n);
if (x - s < 1 && y - s < 1) res += tri(s - 1 - (x - 1 + y - 1));
if (x - s < 1 && y + s > n) res += tri(s - 1 - (x - 1 + n - y));
if (x + s > n && y - s < 1) res += tri(s - 1 - (n - x + y - 1));
if (x + s > n && y + s > n) res += tri(s - 1 - (n - x + n - y));
if (res > (long long)n * n) fprintf(stderr, "error\n");
return res;
}
int main() {
int n, x, y, c;
scanf("%d%d%d%d", &n, &x, &y, &c);
long long head = 0;
long long tail = 2 * n - 1;
while (head <= tail) {
int mid = (head + tail) / 2;
if (calc(n, mid, x, y) >= c) {
tail = mid - 1;
} else {
head = mid + 1;
}
}
printf("%I64d\n", tail + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
inline int read() {
register int x = 0, f = 0;
register char c = getchar();
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0', c = getchar();
return f ? -x : x;
}
int n;
char s[N];
namespace Check {
bool check(int S) {
for (int i = 0; i < 4; ++i)
if ((S >> i) & 1)
s[i + 2] = '1';
else
s[i + 2] = '0';
for (int i = 4; i < 8; ++i)
if ((S >> i) & 1)
s[i + 3] = '1';
else
s[i + 3] = '0';
for (int i = 1; i <= 11; ++i)
for (int j = 1; i + j * 2 <= 11; ++j)
if (s[i] == s[i + j] && s[i] == s[i + j * 2]) return false;
return true;
}
int main() {
s[1] = s[6] = s[11] = '0';
for (int i = 0; i < (1 << 8); ++i)
if (check(i)) puts("RQ");
return 0;
}
} // namespace Check
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
long long ans = 0;
int L = 0;
for (int r = 1; r <= n; ++r) {
for (int l = r - 1; l >= 1; l--)
if ((l + r) % 2 == 0 && s[l] == s[r] && s[(l + r) / 2] == s[r]) {
L = max(l, L);
break;
}
ans += L;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[20] = {1, 5, 13, 25, 41, 61, 85, 113};
int b[20] = {1, 3, 5, 7, 9, 11, 13, 15};
int x;
scanf("%d", &x);
if (x == 3)
printf("5\n");
else {
for (int i = 0; i <= 100; i++) {
if (a[i] >= x) {
printf("%d\n", b[i]);
break;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[510][510], b[510][510], A[1020][510], B[1020][510];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &b[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) A[i + j][++A[i + j][0]] = a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) B[i + j][++B[i + j][0]] = b[i][j];
for (int i = 2; i <= n + m; i++) sort(A[i] + 1, A[i] + A[i][0] + 1);
for (int i = 2; i <= n + m; i++) sort(B[i] + 1, B[i] + B[i][0] + 1);
for (int i = 2; i <= n + m; i++)
for (int j = 1; j <= A[i][0]; j++)
if (A[i][j] != B[i][j]) {
printf("NO\n");
return 0;
}
printf("YES\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[5005], dpl[5005][5005], dpr[5005][5005];
int n, ans, cnt;
void prepare() {
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
if (a[j] < a[i])
dpl[i][j] = dpl[i][j - 1] + 1;
else
dpl[i][j] = dpl[i][j - 1];
}
for (int i = 1; i <= n; i++)
for (int j = i - 1; j >= 1; j--) {
if (a[i] > a[j])
dpr[j][i] = dpr[j + 1][i] + 1;
else
dpr[j][i] = dpr[j + 1][i];
}
ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (a[i] > a[j]) ans++;
}
void work() {
int tem = 0, k = ans;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
tem = k + 2 * dpr[i][j] - 2 * dpl[i][j] + (a[i] > a[j] ? 1 : -1);
if (ans > tem) {
ans = tem;
cnt = 1;
} else if (ans == tem)
cnt++;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
prepare();
work();
printf("%d %d\n", ans, cnt);
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAX = 1e3 + 5;
const long long MAX2 = 11;
const long long MOD = 1000000007;
const long long MOD2 = 1000005329;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 555;
int n, ls, cnt, hit, jl;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size(), s = 'a' + s;
for (int i = 1; i <= n; ++i) {
if (s[i] == '(')
++cnt;
else if (s[i] == ')')
--cnt;
else
--cnt, ls = i, ++jl;
}
if (cnt < 0) return cout << "-1\n", 0;
hit = cnt, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (s[i] == '(')
++cnt;
else if (s[i] == ')')
--cnt;
else
--cnt;
if (i == ls) cnt -= hit;
if (cnt < 0) return cout << "-1\n", 0;
}
if (cnt != 0) return cout << "-1\n", 0;
for (int i = 2; i <= jl; ++i) cout << "1\n";
cout << hit + 1 << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long modpow(long long a, long long n, long long temp) {
long long res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
long long getbit(long long j, long long i) { return ((i >> (j - 1ll)) & 1ll); }
long long ison(long long mask, long long pos) { return (mask & (1 << pos)); }
long long cbit(long long n) {
long long k = 0;
while (n) n &= (n - 1), k++;
return k;
}
long long nbit(long long n) {
long long k = 0;
while (n) n /= 2, k++;
return k;
}
long long mod = 1e9 + 7;
int sgn(long long x) { return x < 0 ? -1 : !!x; }
const double eps = 1e-7;
const double pi = acos(-1.0);
inline void inc(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
inline void dec(long long &x, long long y) {
x -= y;
if (x < 0) x += mod;
}
inline void chmax(long long &x, long long y) {
if (y > x) x = y;
}
inline void mulm(long long &x, long long y) {
x *= y;
if (x >= mod) x -= mod;
}
long long xo(long long i) {
if ((i & 3) == 0) return i;
if ((i & 3) == 1) return 1;
if ((i & 3) == 2) return i + 1;
return 0;
}
long long pri[1000005];
long long l, r, k;
bool chk(long long u) {
for (long long i = l; i <= r - u + 1ll; i++) {
if (pri[u + i - 1] - pri[i - 1] < k) return 0;
}
return 1;
}
int main() {
long long n, t, i, j;
pri[0] = pri[1] = 1;
for (long long i = 2; i <= 1000000; i++) {
if (pri[i] == 0) {
for (j = 2 * i; j <= 1000000; j += i) pri[j] = 1;
}
}
for (long long i = 1; i <= 1000000; i++) pri[i] = 1ll - pri[i];
for (long long i = 1; i <= 1000000; i++) pri[i] += pri[i - 1];
cin >> l >> r >> k;
long long ans = mod;
long long lo = 1;
long long hi = r - l + 1;
while (hi >= lo) {
long long m = (hi + lo) / 2ll;
if (chk(m)) {
ans = min(ans, m);
hi = m - 1ll;
} else
lo = m + 1ll;
}
if (ans == mod)
cout << -1;
else
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int na, ka;
int lowbit(int x) { return x & (-x); }
bool chk(int n, int k) {
if (k < 0) return 0;
if (!(n % 2)) return 0;
if (k && k * 2 + 3 > n) return 0;
if (lowbit(n + 1) == n + 1 && k == 1) return 0;
if (lowbit(n + 1) != n + 1 && k == 0) return 0;
if (n == 9 && k == 2) return 0;
return 1;
}
int cnt = 1;
void pr(int u, int n, int k, int fa) {
printf("%d ", fa);
if (n == 1) return;
for (int i = 1; i < n; i = i * 2 + 1) {
int p;
if (n - i - 1 >= i * 2 || i >= (n - i - 1) * 2)
p = k - 1;
else
p = k;
if (chk(i, 0) && chk(n - i - 1, p)) {
pr(++cnt, i, 0, u);
pr(++cnt, n - i - 1, p, u);
return;
}
}
}
int main() {
scanf("%d%d", &na, &ka);
if (!chk(na, ka))
printf("NO\n");
else {
printf("YES\n");
pr(1, na, ka, 0);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &u) {
u = 0;
char c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
u = (u << 3) + (u << 1) + (c ^ 48), c = getchar();
if (flag) u = -u;
}
template <class T>
void write(T u) {
if (u < 0) printf("-"), u = -u;
if (u < 10)
putchar(48 + u);
else
write(u / 10), putchar(48 + u % 10);
}
void write(char u) { putchar(u); }
template <class T, class... Arg>
void read(T &u, Arg &...v) {
read(u);
read(v...);
}
template <class T, class... Arg>
void write(T u, Arg... v) {
write(u);
write(v...);
}
template <class T>
bool checkmin(T &a, T b) {
return (b < a ? a = b, 1 : 0);
}
template <class T>
bool checkmax(T &a, T b) {
return (b > a ? a = b, 1 : 0);
}
template <class T>
T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
T _max(T a, T b) {
return (a > b ? a : b);
}
const int N = 200005;
int n, q;
char s[N];
int sum[N][26];
void init() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &q);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 26; ++j) {
sum[i][j] = sum[i - 1][j];
}
sum[i][s[i] - 'a']++;
}
}
void solve() {
int l, r;
while (q--) {
scanf("%d%d", &l, &r);
if (l == r) {
puts("Yes");
continue;
}
if (s[l] != s[r]) {
puts("Yes");
continue;
}
int cnt = 0;
for (int i = 0; i < 26; ++i) {
if (sum[r][i] - sum[l - 1][i]) ++cnt;
}
if (cnt <= 2) {
puts("No");
} else {
puts("Yes");
}
}
}
int main() {
int t = 1;
while (t--) {
init();
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
const int mod = 1e9 + 7;
int n;
int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < n; i++) {
int j = i;
int cnt = 0;
vector<char> v;
while (j < n) {
if (s[j] >= 'A' && s[j] <= 'Z') break;
if (a[s[j]] == 0) {
cnt++;
v.push_back(s[j]);
a[s[j]] = 1;
}
j++;
}
for (int h = 0; h < v.size(); h++) {
a[v[h]] = 0;
}
ans = max(ans, cnt);
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 410;
int n, m;
int nxt[N][26];
char s[N], t[N];
void init() {
for (int j = 0; j <= 25; j++) {
nxt[n][j] = n + 1;
nxt[n + 1][j] = n + 1;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= 25; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
}
char t1[N], t2[N];
int F[N][N];
bool Calc(int n1, int n2) {
for (int i = 1; i <= n1; i++) t1[i] = t[i];
for (int i = 1; i <= n2; i++) t2[i] = t[i + n1];
for (int i = 0; i <= n1; i++)
for (int j = 0; j <= n2; j++) F[i][j] = n + 1;
F[0][0] = 0;
for (int i = 0; i <= n1; i++)
for (int j = 0; j <= n2; j++) {
if (i > 0) F[i][j] = min(F[i][j], nxt[F[i - 1][j]][t1[i] - 'a']);
if (j > 0) F[i][j] = min(F[i][j], nxt[F[i][j - 1]][t2[j] - 'a']);
}
if (F[n1][n2] <= n) return 1;
return 0;
}
int main() {
int tCase;
cin >> tCase;
while (tCase--) {
cin >> (s + 1);
n = strlen(s + 1);
cin >> (t + 1);
m = strlen(t + 1);
init();
bool ok = 0;
for (int n1 = 1; n1 <= m; n1++)
if (Calc(n1, m - n1)) {
cout << "YES" << endl;
ok = 1;
break;
}
if (!ok) cout << "NO" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
mt19937 rng(steady_clock::now().time_since_epoch().count());
void usaco(string filename) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
const long double pi = 3.14159265358979323846;
const long long mod = 1000000007;
long long n, m, k, q, l, r, x, y, z;
long long a[1000005];
long long b[1000005];
long long c[1000005];
string second, t;
long long ans = 0;
long long top[100005][26];
long long pre[100005], suf[100005];
bool one[100005];
string ss[100005];
void solve(int tc) {
cin >> n;
for (long long i = 0; i < (n); ++i) {
cin >> ss[i];
second = ss[i];
int sz = second.size();
int j = 1;
while (j < sz && second[j] == second[0]) ++j;
pre[i] = j;
j = sz - 2;
while (j >= 0 && second[j] == second[sz - 1]) --j;
suf[i] = sz - j - 1;
one[i] = (pre[i] == sz);
long long pt = 0;
for (long long j = 0; j < (sz); ++j) {
if (second[j] != second[pt]) {
top[i][second[pt] - 'a'] = max(top[i][second[pt] - 'a'], j - pt);
pt = j;
}
}
top[i][second[pt] - 'a'] = max(top[i][second[pt] - 'a'], sz - pt);
}
for (long long i = (1); i < (n); ++i) {
if (one[i]) {
int p = ss[i][0] - 'a';
top[i][p] = max(top[i][p], pre[i] * (top[i - 1][p] + 1) + top[i - 1][p]);
}
for (long long c = 0; c < (26); ++c)
if (top[i - 1][c] > 0) {
long long x = 1;
if (ss[i][0] - 'a' == c) x += pre[i];
if (ss[i][ss[i].size() - 1] - 'a' == c) x += suf[i];
top[i][c] = max(top[i][c], x);
}
}
for (long long i = 0; i < (26); ++i) ans = max(ans, top[n - 1][i]);
cout << ans << '\n';
}
int main() {
{ ios_base::sync_with_stdio(false); }
{
cin.tie(NULL);
cout.tie(NULL);
}
int tc;
tc = 1;
for (int t = 0; t < tc; t++) solve(t);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
set<long long> div(long long num) {
set<long long> ret;
ret.insert(0);
for (long long i = num; i < 1e9; i++) {
if (i % num == 0) {
ret.insert(i);
}
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, a;
cin >> n >> a;
long long ans = 0, nodd = 1;
bool ok = 1;
while (ok) {
if (a == n || a == nodd)
ok = 0;
else
ans++, n -= 2, nodd += 2;
}
cout << ++ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1200005;
int n, q;
vector<int> v[N];
int f[N * 5][8], x, ans[15], Ans[N];
struct Ask {
int l, r, from;
} A[N];
inline int cmp(Ask x, Ask y) { return x.r < y.r; }
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
for (int j = 2; j * j <= x; j++)
if (x % j == 0) {
int flag = 0;
while (x % j == 0) flag ^= 1, x /= j;
if (flag) v[i].push_back(j);
}
if (x != 1) v[i].push_back(x);
}
for (int i = 1; i <= q; i++) scanf("%d%d", &A[i].l, &A[i].r), A[i].from = i;
sort(A + 1, A + q + 1, cmp);
for (int i = 1, l = 1; i <= n; i++) {
for (int j = 0; j < 1 << v[i].size(); j++) {
int cnt = 0, s = 1;
for (int k = 0; k < v[i].size(); k++)
if ((1 << k) & j)
s *= v[i][k];
else
cnt++;
for (int k = 0; k <= 7; k++) ans[k + cnt] = max(ans[k + cnt], f[s][k]);
f[s][cnt] = i;
}
while (l <= q && i == A[l].r) {
for (int j = 0; j <= 14; j++)
if (ans[j] >= A[l].l) {
Ans[A[l].from] = j;
break;
}
l++;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", Ans[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos((long double)-1.0);
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
long long qpow(long long x, long long n, long long mod = MOD) {
if (n < 0) return 0;
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long sq(long long x) { return x * x; }
long long read() {
long long res = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
namespace Solver {
void InitOnce() { int t; }
int n, m, k;
vector<pair<int, int> > G[200005];
unsigned long long hc1[200005], hc2[200005];
unsigned long long To1[10][10], To2[10][10];
void Read() {
int res = scanf("%d%d%d", &n, &m, &k);
if (res == -1) exit(0);
for (int i = 1; i <= n; ++i) G[i].clear();
for (int i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].emplace_back(w, v);
}
mt19937_64 rnd;
rnd.seed(19981111);
for (int i = 1; i <= n; ++i) {
sort(G[i].begin(), G[i].end());
hc1[i] = rnd();
hc2[i] = rnd();
}
for (int i = 0; i <= 9; ++i) {
for (int j = 0; j <= 9; ++j) {
To1[i][j] = 0;
To2[i][j] = 0;
}
}
for (int u = 1; u <= n; ++u) {
int sz = G[u].size();
for (int i = 0; i < sz; ++i) {
int v = G[u][i].second;
To1[sz][i + 1] ^= hc1[v];
To2[sz][i + 1] ^= hc2[v];
}
}
}
unsigned long long okcode1, okcode2;
unsigned long long code1, code2;
int ans;
void dfs(int pos, int val) {
code1 ^= To1[pos][val];
code2 ^= To2[pos][val];
if (pos == k)
ans += (code1 == okcode1) && (code2 == okcode2);
else {
for (int i = 1; i <= pos + 1; ++i) dfs(pos + 1, i);
}
code1 ^= To1[pos][val];
code2 ^= To2[pos][val];
return;
}
void Solve() {
code1 = 0;
okcode1 = 0;
code2 = 0;
okcode2 = 0;
for (int i = 1; i <= n; ++i) okcode1 ^= hc1[i];
for (int i = 1; i <= n; ++i) okcode2 ^= hc2[i];
ans = 0;
dfs(1, 1);
printf("%d\n", ans);
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 1, inf = 1e9 + 7;
int p[maxn], dp[maxn];
int n, usd[maxn], a[maxn];
vector<pair<int, char> > g[maxn];
int t[4 * maxn], add[4 * maxn];
int cp = 0;
void push(int x, int cl, int cr) {
if (cr - cl > 1) {
add[2 * x] += add[x];
add[2 * x + 1] += add[x];
}
t[x] += add[x];
add[x] = 0;
}
void upd(int x, int cl, int cr, int first, int second, int vl) {
push(x, cl, cr);
if (second <= cl || cr <= first) return;
if (first <= cl && cr <= second) {
add[x] += vl;
push(x, cl, cr);
return;
}
upd((x << 1), cl, (cl + cr) >> 1, first, second, vl);
upd((x << 1) + 1, (cl + cr) >> 1, cr, first, second, vl);
t[x] = min(t[2 * x], t[2 * x + 1]);
}
int get(int x, int cl, int cr, int first, int second) {
push(x, cl, cr);
if (second <= cl || cr <= first) return inf;
if (first <= cl && cr <= second) return t[x];
return min(get(x << 1, cl, (cl + cr) >> 1, first, second),
get((x << 1) + 1, (cl + cr) >> 1, cr, first, second));
}
bool cmp(pair<int, char> p1, pair<int, char> p2) {
return p1.second < p2.second;
}
void dfs(int x) {
if (usd[x]) upd(1, 0, n, 0, cp + 1, 1);
if (x && usd[x]) dp[x] = get(1, 0, n, 0, cp + 1);
if (x) dp[x] = min(dp[x], dp[p[x]] + 1);
upd(1, 0, n, cp, cp + 1, dp[x] - inf);
++cp;
sort(g[x].begin(), g[x].end(), cmp);
for (auto to : g[x]) dfs(to.first);
--cp;
int cx = get(1, 0, n, cp, cp + 1);
upd(1, 0, n, cp, cp + 1, inf - cx);
}
signed main() {
for (int i = 1; i < maxn; i++) dp[i] = inf;
for (int i = 0; i < 4 * maxn; i++) t[i] = inf;
cin >> n;
++n;
p[0] = -1;
for (int i = 1; i < n; i++) {
char c;
cin >> p[i] >> c;
g[p[i]].push_back({i, c});
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
usd[a[i]] = 1;
}
dfs(0);
for (int i = 0; i < k; i++) cout << dp[a[i]] << ' ';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, c, s, ans;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> a >> b >> c;
n *= 2;
for (int i = 0; i <= c; i++)
for (int j = 0; j <= b; j++) {
s = 4 * i + 2 * j;
s = n - s;
if (s >= 0 && s <= a) ++ans;
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p;
class cp {
public:
bool operator()(pair<long long, long long> p1,
pair<long long, long long> p2) {
if (p1.first / p < p2.first / p)
return true;
else if (p1.first / p == p2.first / p) {
if (p1.first == p2.first && p1.second == p2.second) return false;
if (p1.second <= p2.second) return true;
return false;
}
return false;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long q, i, i1, j1, j, k, l, t, m, temp = 0, ans = 0;
string s;
cin >> s;
n = s.size();
p = ceil(sqrt(n));
set<pair<long long, long long>, cp> st;
map<pair<long long, long long>, long long> mp;
cin >> q;
vector<pair<long long, long long>> has(q);
for (i = 0; i <= q - 1; i++) {
cin >> j >> k;
j--;
k--;
st.insert(make_pair(j, k));
has[i] = make_pair(j, k);
}
ans = 0;
long long left, right;
left = right = 0;
for (auto pos = st.begin(); pos != st.end(); ++pos) {
i = pos->first;
j = pos->second;
while (j > right) {
right++;
if (s[right] == s[right - 1]) ans++;
}
while (right > j) {
if (s[right] == s[right - 1]) ans--;
right--;
}
while (left < i) {
if (s[left] == s[left + 1]) ans--;
left++;
}
while (left > i) {
left--;
if (s[left] == s[left + 1]) ans++;
}
mp[make_pair(i, j)] = ans;
}
for (i = 0; i < q; i++) {
cout << mp[make_pair(has[i].first, has[i].second)] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, d, z, y, p, k, n, flag, M = 0;
std::vector<long long> v(4);
for (long long i = 0; i < 4; i++) cin >> v[i];
sort(v.begin(), v.end());
long long abc = (v[0] + v[1] + v[2] + v[3]) / 3;
cout << abc - v[0] << " " << abc - v[1] << " " << abc - v[2] << " ";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
const int maxn = 5111;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-10;
long long a[maxn];
int cnt[maxn];
long long odd[maxn];
int f[maxn];
int main() {
ios::sync_with_stdio(false);
int n, i, j, ans;
cin >> n;
long long t;
for (i = 1; i <= n; ++i) {
f[i] = 1;
cin >> a[i];
t = a[i];
while ((t + 1) & 1) {
t >>= 1;
++cnt[i];
}
odd[i] = t;
}
int diff;
for (i = 1; i <= n; ++i) {
for (j = i + 1; j <= n; ++j) {
diff = j - i;
if (cnt[j] < diff || cnt[j] == cnt[i] + diff) {
if (odd[i] % odd[j] == 0) {
f[j] = max(f[j], f[i] + 1);
}
}
}
}
ans = n - *max_element(f + 1, f + n + 1);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
int times[maxn][maxn], Time, cost[maxn][maxn], n, m;
string k[maxn];
int dfs(int x, int y) {
if (!min(x, y) or x > n or y > m) return 0;
times[x][y] = ++Time;
int now = k[x][y - 1];
int nextx, nexty;
if (now == 'R')
nextx = x, nexty = y + 1;
else if (now == 'L')
nextx = x, nexty = y - 1;
else if (now == 'U')
nextx = x - 1, nexty = y;
else
nextx = x + 1, nexty = y;
if (times[nextx][nexty]) {
cost[x][y] = Time - times[nextx][nexty] + 1;
times[x][y] = 0;
return cost[x][y] - 1;
}
if (cost[nextx][nexty]) {
cost[x][y] = cost[nextx][nexty] + 1;
times[x][y] = 0;
return 0;
}
int gg = dfs(nextx, nexty);
if (!gg) {
cost[x][y] = cost[nextx][nexty] + 1;
times[x][y] = 0;
return 0;
} else {
cost[x][y] = cost[nextx][nexty];
times[x][y] = 0;
return gg - 1;
}
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> k[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
Time = 0;
if (!cost[i][j]) dfs(i, j);
}
}
int ans = 0, ansx, ansy;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (cost[i][j] > ans) ans = cost[i][j], ansx = i, ansy = j;
cout << ansx << " " << ansy << " " << ans << '\n';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cost[i][j] = times[i][j] = 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
for (int i = 1; i <= t; i++) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-8;
struct p3d {
long double x, y, z;
p3d(long double xx = 0, long double yy = 0, long double zz = 0) {
x = xx, y = yy, z = zz;
}
};
long double abs(const p3d &v) {
return sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
}
ostream &operator<<(ostream &os, const p3d &p) {
return os << "(" << p.x << "," << p.y << "," << p.z << ")";
}
p3d operator+(const p3d &a, const p3d &b) {
return p3d(a.x + b.x, a.y + b.y, a.z + b.z);
}
p3d operator-(const p3d &a, const p3d &b) {
return p3d(a.x - b.x, a.y - b.y, a.z - b.z);
}
p3d operator*(const long double &s, const p3d &v) {
return p3d(s * v.x, s * v.y, s * v.z);
}
p3d operator/(const p3d &v, const long double &s) {
return p3d(v.x / s, v.y / s, v.z / s);
}
inline long double dot(const p3d &a, const p3d &b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
inline p3d cross(const p3d &a, const p3d &b) {
return p3d(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z,
a.x * b.y - a.y * b.x);
}
inline long double dist(const p3d &s, const p3d &p) {
return (p.x - s.x) * (p.x - s.x) + (p.y - s.y) * (p.y - s.y) +
(p.z - s.z) * (p.z - s.z);
}
inline p3d pl_inter(const p3d &p, const p3d &n, const p3d &a1, const p3d &a2) {
return a1 + dot(p - a1, n) / dot(n, a2 - a1) * (a2 - a1);
}
long double a, b, m;
long double vx, vy, vz;
bool in_bounds(const p3d &p) {
return ((p.x + eps >= 0) && (p.x <= a + eps) && (p.z + eps >= 0) &&
(p.z <= b + eps) && (p.y + eps >= 0) && (p.y <= m + eps));
}
int main() {
cin >> a >> b >> m >> vx >> vy >> vz;
p3d o(0, 0, 0), p(a, 0, b), i(1, 0, 0), j(0, 1, 0), k(0, 0, 1);
p3d d0(0.5 * a, m, 0), v0(vx, vy, vz);
p3d reflect_pt;
vector<pair<p3d, p3d> > planes;
planes.push_back(make_pair(o, i));
planes.push_back(make_pair(o, k));
planes.push_back(make_pair(p, (-1) * i));
planes.push_back(make_pair(p, (-1) * k));
planes.push_back(make_pair(o, j));
int r;
while (abs(d0.y) > eps) {
for (int i = 0; i < 5; i++) {
reflect_pt = pl_inter(planes[i].first, planes[i].second, d0, d0 + v0);
if (in_bounds(reflect_pt) && abs(d0 - reflect_pt) > eps) {
r = i;
break;
}
}
d0 = reflect_pt;
v0 = v0 - 2 * dot(v0, planes[r].second) * planes[r].second;
}
cout << setprecision(10) << d0.x << " " << d0.z << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ask(int x, int y) {
cout << x << " " << y << endl;
string color;
cin >> color;
return color == "black";
}
int main() {
int n;
cin >> n;
int pivot = ask(0, 0);
if (n == 1) {
cout << "1 0 1 1" << endl;
return 0;
}
int pivot2 = ask(1 << 29, 0);
int L = 0, R = 1 << 29;
for (int i = 3; i <= n; i++) {
int mid = (L + R) / 2;
int cur = (pivot != pivot2) ? ask(mid, 0) : ask(0, mid);
if (cur != pivot)
R = mid;
else
L = mid;
}
if (pivot != pivot2)
cout << L + 1 << " 0 " << L + 1 << " 1" << endl;
else
cout << "0 " << L + 1 << " 1 " << L + 1 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Q, X, Y, a, b;
int MT[1001][1001];
bool ans[200005];
vector<int> qidx[200005];
class EDGE {
public:
int a, b;
} E[200005];
class QUERY {
public:
int l, r, s, t, idx;
} QR[200005];
int main() {
cin >> N >> M >> Q;
for (int i = 1; i <= M; i++) scanf("%d%d", &E[i].a, &E[i].b);
for (int i = 1; i <= Q; i++) {
scanf("%d%d%d%d", &QR[i].l, &QR[i].r, &QR[i].s, &QR[i].t);
qidx[QR[i].r].push_back(i);
}
for (int i = 1; i <= M; i++) {
a = E[i].a, b = E[i].b;
for (int j = 1; j <= N; j++) {
X = MT[a][j];
Y = MT[b][j];
if (MT[b][j] < X) MT[b][j] = X;
if (MT[a][j] < Y) MT[a][j] = Y;
}
MT[b][a] = MT[a][b] = i;
for (int j = 0; j < qidx[i].size(); ++j) {
if (MT[QR[qidx[i][j]].t][QR[qidx[i][j]].s] >= QR[qidx[i][j]].l)
ans[qidx[i][j]] = true;
}
}
for (int i = 1; i <= Q; i++) puts(ans[i] ? "Yes" : "No");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string chain(string a, string b) {
int n = min(a.size(), b.size());
unsigned long long ah = 0, bh = 0;
unsigned long long mul = 1;
int cur = 0;
for (int i = 0; i < n; i++) {
ah = ah * 101 + a[a.size() - i - 1];
bh += mul * b[i];
mul *= 101;
if (ah == bh) cur = i + 1;
}
return a + b.substr(cur);
}
int main() {
string s[3];
while (cin >> s[0] >> s[1] >> s[2]) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
if (i != j && s[i].find(s[j]) != string::npos) s[j] = "";
int idx[3] = {0, 1, 2};
int ans = 1000000000;
do {
ans = min(ans, (int)chain(chain(s[idx[0]], s[idx[1]]), s[idx[2]]).size());
} while (next_permutation(idx, idx + 3));
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int SI = 3e5 + 100;
int n, m, k;
struct node {
int id, to, w;
node(int id, int to, int w) {
this->id = id;
this->to = to;
this->w = w;
}
};
bool vis[SI];
long long d[SI];
vector<node> G[SI];
int pre[SI];
bool use[SI];
vector<int> ans;
void dij() {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(pair<long long, int>(0, 1));
memset(vis, 0, sizeof(vis));
memset(use, 0, sizeof(use));
memset(pre, -1, sizeof(pre));
d[1] = 0;
while (!q.empty() && ans.size() < k) {
pair<long long, int> p = q.top();
q.pop();
int u = p.second;
if (vis[u]) continue;
vis[u] = true;
if (pre[u] != -1) ans.push_back(pre[u]);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i].to;
long long w = G[u][i].w;
if (!vis[v] && d[v] > d[u] + w) {
d[v] = d[u] + w;
q.push(pair<long long, int>(d[v], v));
pre[v] = G[u][i].id;
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int u, v;
long long w;
for (int i = 1; i <= n; ++i) d[i] = 1e18;
for (int i = (1); i < (m + 1); ++i) {
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(node(i, v, w));
G[v].push_back(node(i, u, w));
}
dij();
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) {
printf("%d ", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline long long read() {
long long 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 * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 2e5 + 10;
int a[maxn], cnt[maxn], step[maxn], vis[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
step[a[i]] = 0;
cnt[a[i]]++;
}
for (int i = 1; i <= n; i++) {
int t = a[i];
vis[t] = i;
int x = 0;
while (t * 2 < maxn) {
t *= 2;
x++;
vis[t] = i;
step[t] += x;
cnt[t]++;
}
t = a[i];
x = 0;
while (t) {
t /= 2;
x++;
vis[t] = i;
step[t] += x;
cnt[t]++;
int tt = t, tx = x;
while (tt * 2 < maxn) {
tt *= 2;
tx++;
if (vis[tt] == i) break;
vis[tt] = i;
step[tt] += tx;
cnt[tt]++;
}
}
}
int ans = INF;
for (int i = 0; i < maxn; i++) {
if (cnt[i] != n) continue;
ans = min(ans, step[i]);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXINT = 1073741823;
long long int a[MAXN];
set<long long int> s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, m, k, x, page, counter = 0, answer = 0, cc;
cin >> n >> m >> k;
for (long long int i = 0; i < m; i++) {
cin >> a[i];
a[i]--;
s.insert(a[i]);
}
while (!s.empty()) {
x = *s.begin();
page = (x - counter) / k;
cc = 0;
while (!s.empty() && ((*s.begin()) - counter) / k == page) {
s.erase(s.begin());
cc++;
}
counter += cc;
answer++;
}
cout << answer;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1000000021;
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = acos(-1);
const int INF = 0x3f3f3f3f;
const int NINF = 0x3f3f3f40;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0x3f3f3f3f3f3f3f40;
const int mxN = 100001;
int type[mxN];
string name[mxN];
bool flag[mxN];
int arr[mxN];
int rev[mxN];
int n;
int ex, nor;
set<int> open;
vector<int> badex;
vector<int> badnorm;
vector<pair<string, string>> ans;
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> n;
for (int i = (1); i < (n + 1); ++i) {
open.insert(i);
}
string s;
for (int i = (0); i < (n); ++i) {
cin >> s;
name[i] = s;
cin >> type[i];
if (type[i] == 1)
ex++;
else
nor++;
int num = 0;
bool ok = true;
for (int j = (0); j < (s.size()); ++j) {
if ((s[j] - '0' < 0) || (s[j] - '0' >= 10) ||
(s[j] - '0' == 0 && num == 0)) {
ok = false;
break;
}
num = num * 10 + s[j] - '0';
}
if (!ok || num > n) {
arr[i] = -1;
if (type[i] == 1)
badex.push_back(i);
else
badnorm.push_back(i);
} else {
arr[i] = num;
open.erase(open.find(num));
rev[num] = i;
}
}
for (int i = (0); i < (n); ++i) {
if (arr[i] > -1 && type[i] == 1 && arr[i] > ex)
badex.push_back(i);
else if (arr[i] > -1 && type[i] == 0 && arr[i] <= ex)
badnorm.push_back(i);
}
if (badex.size() == 0 && badnorm.size() == 0) {
cout << "0\n";
return 0;
}
if (open.size() == 0) {
open.insert(arr[badex[0]]);
ans.push_back({to_string(arr[badex[0]]), "hello"});
arr[badex[0]] = -1;
name[badex[0]] = "hello";
}
while (open.size() > 0 && (badnorm.size() > 0 || badex.size() > 0)) {
int num = *open.upper_bound(0);
if (num > ex) {
int k = badnorm.back();
if (arr[k] > -1) open.insert(arr[k]);
ans.push_back({name[k], to_string(num)});
badnorm.pop_back();
} else {
int k = badex.back();
if (arr[k] > -1) open.insert(arr[k]);
ans.push_back({name[k], to_string(num)});
badex.pop_back();
}
open.erase(open.find(num));
}
cout << ans.size() << "\n";
for (auto p : ans) {
cout << "move " << p.first << " " << p.second << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int a[MAXN];
int main() {
int n, x, y, count = 0;
cin >> n >> x >> y;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= x) count++;
}
if (x > y)
cout << n;
else
cout << (count + 1) / 2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
int N;
string s;
void solve(int tc) {
cin >> N >> s;
vector<pair<long long, long long> > v;
v.push_back({INF, -1});
long long sum = 0, ans = 0, cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
cnt++;
while (v.back().first <= cnt) {
pair<long long, long long> cur = v.back();
v.pop_back();
sum -= cur.first * (cur.second - v.back().second);
}
ans += cnt * (i - cnt - v.back().second);
ans += cnt * (cnt + 1) / 2;
} else {
for (int j = i - cnt; j < i; j++) {
sum += (j - v.back().second) * (i - j);
v.push_back({i - j, j});
}
cnt = 0;
}
ans += sum;
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
if (0) {
int T;
cin >> T;
for (int i = 1; i <= T; i++) solve(i);
} else {
solve(0);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1e9 + 7;
vector<int> moves;
int main() {
moves.push_back(0);
for (int i = 0; i < 20; ++i) {
int n = moves.size();
for (int k = n - 1; k >= 0; --k) {
moves.push_back(moves[k] | (1 << i));
}
}
int n;
scanf("%d", &n);
vector<int> a;
vector<int> L;
for (int i = 0; i < n; ++i) {
int A;
scanf("%d", &A);
a.push_back(A);
for (int k = 20; k >= 0; --k) {
if ((1 << k) & A) {
L.push_back(k);
break;
}
}
}
vector<int> c;
for (int len = 0; len < 20; ++len) {
vector<int> b(a);
vector<int> cur;
for (int k = 0; k < 20; ++k) {
int M = -1;
for (int i = 0; i < n; ++i) {
if (L[i] > len) continue;
if ((1 << k) & b[i]) {
M = i;
break;
}
}
if (M == -1) break;
cur.push_back(a[M]);
for (int i = 0; i < n; ++i) {
if (L[i] > len) continue;
if (i == M) continue;
if (b[i] & (1 << k)) b[i] ^= b[M];
}
b[M] = 0;
}
if (cur.size() == len + 1) c = cur;
}
int len = c.size();
printf("%d\n", len);
for (int i = 0; i < (1 << len); ++i) {
int cur = 0;
for (int j = 0; j < 20; ++j) {
if ((1 << j) & moves[i]) {
cur ^= c[j];
}
}
printf("%d ", cur);
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
long long ara[N];
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long x;
cin >> x;
++ara[x];
}
vector<long long> v;
for (long long i = 1; i <= 100; ++i) {
if (ara[i] != 0) v.push_back(ara[i]);
}
long long mx = 0;
for (long long i = 1; i <= 100; ++i) {
long long s = 0;
for (long long j = 0; j < v.size(); ++j) {
s += v[j] / i;
}
if (s >= n) mx = max(mx, i);
}
cout << mx;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int dp[5005][5005][2];
map<int, int> mp;
int main() {
int n;
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
memset(dp, 0x3f, sizeof(dp));
for (int i = 1; i <= n; i++) dp[i][i][0] = dp[i][i][1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
for (int col = 0; col < 2; col++) {
int it = (col ? v[i] : v[j]);
if (j >= 2) {
dp[j - 1][i][0] =
min(dp[j - 1][i][0], dp[j][i][col] + (v[j - 1] != it));
}
if (i < n) {
dp[j][i + 1][1] =
min(dp[j][i + 1][1], dp[j][i][col] + (it != v[i + 1]));
}
}
}
}
cout << min(dp[1][n][0], dp[1][n][1]) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, u, v, w, x, y, z, a, b, c, d, e, f, t = 1, tc;
long long flg, sz, cnt, gt, ans, mx, mn;
long long m, k, n, i, j;
long long low, hi, md, inp[200007], sm, ff, ex;
vector<long long> tk[4];
cin >> a >> b >> c;
cin >> n;
string st;
for (int i = 0; i < n; i++) {
cin >> x >> st;
if (st == "USB") {
tk[1].push_back(x);
;
} else {
tk[2].push_back(x);
;
}
}
sort(tk[1].begin(), tk[1].end());
sort(tk[2].begin(), tk[2].end());
ans = 0, cnt = 0;
for (int i = 0; i < tk[1].size(); i++) {
if (!a) break;
cnt++;
ans += tk[1][i];
tk[1][i] = 0;
a--;
}
for (int i = 0; i < tk[2].size(); i++) {
if (!b) break;
cnt++;
ans += tk[2][i];
tk[2][i] = 0;
b--;
}
for (int i = 0; i < tk[1].size(); i++) {
if (tk[1][i]) tk[3].push_back(tk[1][i]);
;
}
for (int i = 0; i < tk[2].size(); i++) {
if (tk[2][i]) tk[3].push_back(tk[2][i]);
;
}
sort(tk[3].begin(), tk[3].end());
for (int i = 0; i < tk[3].size(); i++) {
if (!c) break;
cnt++;
ans += tk[3][i];
c--;
}
cout << cnt << " " << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 5;
const long long INF = 1e18 + 5;
const long long maxn = 5e5 + 5;
long long n, b[555555], mx = -1000000001;
int a[555555], sum, cnt, ans;
set<int> second;
int p[555555];
int d[5555][5555];
vector<long long> v, x, y;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], p[a[i]] = i;
for (int i = 1; i <= n; i++) {
if (p[i] > p[i - 1])
b[i] = b[i - 1] + 1;
else
b[i] = 1;
mx = max(mx, b[i]);
}
cout << n - mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
const int N = 200, M = 100;
vector<vector<int> > a(N), b(N);
for (int i = 0; i < N; i++) a[i].resize(N), b[i].resize(N);
a[M][M] = n;
while (1) {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) b[i][j] = 0;
int cnt = 0;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
if (a[i][j] >= 4) {
cnt++;
b[i][j] += a[i][j] & 3;
b[i][j + 1] += a[i][j] >> 2;
b[i][j - 1] += a[i][j] >> 2;
b[i + 1][j] += a[i][j] >> 2;
b[i - 1][j] += a[i][j] >> 2;
} else
b[i][j] += a[i][j];
}
a = b;
if (cnt == 0) break;
}
while (q--) {
int x, y;
cin >> x >> y;
x += M, y += M;
if (x < 0 || x >= N || y < 0 || y >= N) {
puts("0");
continue;
}
printf("%d\n", a[x][y]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 100005;
int n, m, k;
long double lnFact[MAXM] = {0}, ans = 0;
int t;
inline double lnC(int x, int y) {
return lnFact[x] - lnFact[y] - lnFact[x - y];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 2; i < MAXM; ++i) lnFact[i] = lnFact[i - 1] + log(i);
for (int i = 0; i <= n && ans < 1e99; ++i)
for (int j = 0; j <= n && ans < 1e99; ++j) {
t = k - n * (i + j) + i * j;
if (t < 0) continue;
ans += exp(lnC(n, i) + lnC(n, j) + lnC(m - n * (i + j) + i * j, t) -
lnC(m, k));
}
end:
cout << setprecision(15) << (ans < 1e99 ? ans : 1e99) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int N = 2e4 + 10, LOG = 15, K = 31;
template<typename T>
inline T max(const T &x, const T &y) {
return x > y ? x : y;
}
template<typename T>
inline T min(const T &x, const T &y) {
return x < y ? x : y;
}
int n, q, a[N], lg[N], dp[LOG][K][N], f[LOG][K][N], ans[N], pos[K][N];
struct qustion {
int l, r, k;
} loveti[N];
int query_max(int k, int l, int r) {
int d = lg[r - l + 1];
return max(f[d][k][l], f[d][k][r - (1 << d) + 1]);
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cin >> n >> q;
for (int i = 2; i < N; ++i) {
lg[i] = lg[i / 2] + 1;
}
for (int i = 1; i <= n; ++i) {
std::cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < K; ++j) {
dp[0][j][i] = min(a[i] + i + j, n);
}
}
for (int i = 1; i < LOG; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 0; k < K; ++k) {
f[0][k][j] = dp[i - 1][k][j];
}
}
for (int l = 1; l < LOG; ++l) {
for (int k = 0; k < K; ++k) {
for (int j = 1; j + (1 << l) - 1 <= n; ++j) {
f[l][k][j] = max(f[l - 1][k][j], f[l - 1][k][j + (1 << l) / 2]);
}
}
}
for (int k_1 = 0; k_1 < K; ++k_1) {
for (int k_2 = 0; k_2 + k_1 < K; ++k_2) {
for (int j = 1; j <= n; ++j) {
dp[i][k_1 + k_2][j] = max(dp[i][k_1 + k_2][j], query_max(k_2, j, dp[i - 1][k_1][j]));
}
}
}
}
for (int i = 1; i <= q; ++i) {
std::cin >> loveti[i].l >> loveti[i].r >> loveti[i].k;
if (loveti[i].l == loveti[i].r) {
ans[i] = -1;
}
for (int j = 0; j <= loveti[i].k; ++j) {
pos[j][i] = loveti[i].l;
}
}
for (int i = LOG - 1; ~i; --i) {
for (int k = 0; k < K; ++k) {
for (int j = 1; j <= n; ++j) {
f[0][k][j] = dp[i][k][j];
}
}
for (int l = 1; l < LOG; ++l) {
for (int k = 0; k < K; ++k) {
for (int j = 1; j + (1 << i) - 1 <= n; ++j) {
f[l][k][j] = max(f[l - 1][k][j], f[l - 1][k][j + (1 << l) / 2]);
}
}
}
for (int j = 1; j <= q; ++j) {
if (ans[j] == -1) {
continue;
}
static int np[K];
memset(np, 0, sizeof np);
for (int k_1 = 0; k_1 <= loveti[j].k; ++k_1) {
for (int k_2 = 0; k_2 + k_1 <= loveti[j].k; ++k_2) {
np[k_1 + k_2] = max(np[k_1 + k_2], query_max(k_2, loveti[j].l, pos[k_1][j]));
}
}
if (np[loveti[j].k] < loveti[j].r) {
ans[j] |= 1 << i;
for (int k = 0; k <= loveti[j].k; ++k) {
pos[k][j] = np[k];
}
}
}
}
for (int i = 1; i <= q; ++i) {
std::cout << ans[i] + 1 << '\n';
}
return 0;
} | 13 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC target("avx,tune=native")
using namespace std;
const long long inf = (long long)4e18;
const double eps = 1e-6;
const long long mod = 1000000007;
long long modpow(long long x, long long y, long long md = mod) {
if (y == 0) return 1;
long long ret = modpow(x, y >> 1, md);
ret = (long long)ret * ret % md;
if (y & 1) ret = (long long)ret * x % md;
return ret;
}
long long n, m, q;
long long ans[500005];
pair<long long, long long> cnt[500005];
pair<long long, long long> qry[500005];
struct BIT {
long long a[500005] = {};
BIT() { memset(a, 0, sizeof a); }
void add(long long x) {
while (x <= 500000) {
a[x]++;
x += x & -x;
}
}
long long sum(long long x) {
long long ret = 0;
while (x) {
ret += a[x];
x -= x & -x;
}
return ret;
}
} bit;
long long get_kth(long long k) {
long long l = 0, r = 500000;
while (r - l > 1) {
long long mid = l + r >> 1;
if (bit.sum(mid) >= k)
r = mid;
else
l = mid;
}
return r;
}
signed main() {
scanf("%I64d%I64d%I64d", &n, &m, &q);
for (long long i = 1; i <= m; i++) cnt[i].second = i;
for (long long i = 1; i <= n; i++) {
long long x;
scanf("%I64d", &x);
cnt[x].first++;
}
for (long long i = 1; i <= q; i++) {
long long x;
scanf("%I64d", &x);
qry[i] = make_pair(x, i);
}
sort(qry + 1, qry + q + 1);
sort(cnt + 1, cnt + m + 1);
cnt[m + 1] = make_pair(inf, inf);
long long time = n;
long long pos = 1;
for (long long i = 1; i <= m; i++) {
bit.add(cnt[i].second);
long long dif = cnt[i + 1].first - cnt[i].first;
long long nxt = time + i * dif;
if (i == m) nxt = inf;
long long r = pos;
while (r <= q && qry[r].first <= nxt) r++;
for (long long j = pos; j < r; j++) {
long long rest = qry[j].first - time;
rest %= i;
if (rest == 0) rest = i;
ans[qry[j].second] = get_kth(rest);
}
time = nxt;
pos = max(pos, r);
}
for (long long i = 1; i <= q; i++) printf("%I64d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct no {
int fim;
map<char, no *> t;
no() : fim(-1) {}
} trie;
bool memo[10010] = {};
int n, m;
string ans, text, dict[100010];
void add(int id, const string &s) {
no *r = ≜
for (int i = 0; i < (int)s.size(); ++i) {
char c = tolower(s[i]);
if (!r->t[c]) r->t[c] = new no();
r = r->t[c];
}
r->fim = id;
}
bool solve(int i) {
if (i == n) return 1;
if (memo[i]++) return 0;
no *r = ≜
while (1) {
char c = text[i];
if (!r->t.count(c)) return 0;
++i;
r = r->t[c];
if (r->fim != -1 && solve(i)) {
ans = dict[r->fim] + " " + ans;
return 1;
}
}
}
int main() {
cin.sync_with_stdio(0), cin.tie(0);
string w;
cin >> n >> text >> m;
for (int i = 0; i < m; ++i) {
cin >> dict[i];
w = dict[i];
reverse(w.begin(), w.end());
add(i, w);
}
solve(0);
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> vec;
cin >> n;
while (n) {
n--;
priority_queue<int> pq;
int one = 0, wildcard = 0, zero = 0;
int m, brojac = 0;
cin >> m;
for (int i = 0; i < m; i++) {
string s;
cin >> s;
for (char c : s) {
if (c == '0') {
zero++;
} else {
one++;
}
}
if (s.size() % 2 == 1) {
wildcard++;
pq.push(-(s.size() - 1));
} else {
pq.push(-s.size());
}
}
while (!pq.empty()) {
int cur = -pq.top();
pq.pop();
if (cur == 0) {
brojac++;
continue;
}
while (cur > 0) {
if (cur <= one) {
one -= cur;
brojac++;
break;
} else {
if (one % 2 == 1) {
cur -= (one - 1);
one %= 2;
} else {
cur -= one;
one = 0;
}
}
if (cur <= zero) {
zero -= cur;
brojac++;
break;
} else {
if (zero % 2 == 1) {
cur -= (zero - 1);
zero %= 2;
} else {
cur -= zero;
zero = 0;
}
}
if (cur > 0) {
break;
}
}
}
vec.push_back(brojac);
}
for (int br : vec) {
cout << br << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int r, c, n, len, l, z, x, y, m, t, k, ans;
int a[200005], b[200005];
map<int, int> ind;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
ind[a[i]] = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
int ii = 0;
if (b[ii] == 0) {
ii++;
}
x = ind[b[ii]];
for (int i = ii; i < n; i++) {
if (x >= n) x = 0;
if (b[i] == 0) continue;
if (a[x] == 0) x++;
if (x >= n) x = 0;
if (b[i] != a[x]) {
printf("No");
return 0;
}
x++;
}
printf("Yes");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 0;
int main() {
int button, light;
int arr[105];
for (int i = 0; i < 105; i++) {
arr[i] = 0;
}
cin >> button >> light;
for (int i = 0; i < button; i++) {
int x;
cin >> x;
for (int i = 0; i < x; i++) {
int y;
cin >> y;
arr[y - 1]++;
}
}
bool flag = true;
for (int i = 0; i < light; i++) {
if (arr[i] == 0) {
flag = false;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
char s1[maxn], s2[maxn];
int main() {
int n, m, i, x = 0, y = 0;
scanf("%s %s", s1, s2);
n = strlen(s1);
m = strlen(s2);
for (i = 0; i < n; i++)
if (s1[i] == '1') x++;
if (x % 2) x++;
for (i = 0; i < m; i++)
if (s2[i] == '1') y++;
if (x < y)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mod = 998244353;
const int maxn = 2e5 + 5;
const long long int INF = 1e18;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
vector<int> arr(n);
vector<long long> prefix(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i == 0)
prefix[i] = arr[i];
else
prefix[i] = prefix[i - 1] + arr[i];
}
if (n == 1) {
cout << "1\n";
continue;
}
int k = 0;
while (k * (k + 1) <= 2 * n) k++;
k--;
vector<vector<long long> > dp(n + 2, vector<long long>(k + 1, -INF));
for (int i = 0; i <= n; i++) dp[i][0] = INF;
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j <= k; j++) {
if (i + j - 1 < n &&
prefix[i + j - 1] - (i - 1 >= 0 ? prefix[i - 1] : 0) <
dp[i + j][j - 1])
dp[i][j] = max(dp[i][j],
prefix[i + j - 1] - (i - 1 >= 0 ? prefix[i - 1] : 0));
dp[i][j] = max(dp[i][j], dp[i + 1][j]);
}
}
int ans = 0;
for (int j = 0; j <= k; j++) {
if (dp[0][j] != -INF)
ans = j;
else
break;
}
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x;
long long ans;
char c[2000][2000];
int u[2000][2000], d[2000][2000], l[2000][2000], r[2000][2000];
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i <= (n - 1); i++) scanf("%s", c[i]);
for (int i = (1); i <= (n - 2); i++) {
bool u = 1;
for (int j = (0); j <= (m - 1); j++)
if (c[i][j] == '#') {
u = 0;
break;
}
if (u) ans++;
}
for (int j = (1); j <= (m - 2); j++) {
bool u = 1;
for (int i = (0); i <= (n - 1); i++)
if (c[i][j] == '#') {
u = 0;
break;
}
if (u) ans++;
}
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
if (c[i][j] == '#') break;
l[i][j] = 1;
}
for (int j = (m - 1); j >= (0); j--) {
if (c[i][j] == '#') break;
r[i][j] = 1;
}
}
for (int j = (0); j <= (m - 1); j++) {
for (int i = (0); i <= (n - 1); i++) {
if (c[i][j] == '#') break;
u[i][j] = 1;
}
for (int i = (n - 1); i >= (0); i--) {
if (c[i][j] == '#') break;
d[i][j] = 1;
}
}
for (int i = (1); i <= (n - 2); i++) {
for (int j = (1); j <= (m - 2); j++) {
if (u[i][j] && l[i][j]) ans++;
if (u[i][j] && r[i][j]) ans++;
if (d[i][j] && l[i][j]) ans++;
if (d[i][j] && r[i][j]) ans++;
}
}
for (int i = (1); i <= (n - 2); i++) {
x = 0;
for (int j = (1); j <= (m - 4); j++) {
x += u[i][j] + d[i][j];
if (c[i][j] == '#') x = 0;
if (c[i][j + 1] == '.') {
if (u[i][j + 2]) ans += x;
if (d[i][j + 2]) ans += x;
}
}
}
for (int i = (1); i <= (n - 2); i++)
for (int j = (1); j <= (m - 3); j++) {
if (u[i][j] && d[i][j + 1]) ans++;
if (d[i][j] && u[i][j + 1]) ans++;
}
for (int j = (1); j <= (m - 2); j++) {
x = 0;
for (int i = (1); i <= (n - 4); i++) {
x += l[i][j] + r[i][j];
if (c[i][j] == '#') x = 0;
if (c[i + 1][j] == '.') {
if (l[i + 2][j]) ans += x;
if (r[i + 2][j]) ans += x;
}
}
}
for (int j = (1); j <= (m - 2); j++)
for (int i = (1); i <= (n - 3); i++) {
if (l[i][j] && r[i + 1][j]) ans++;
if (r[i][j] && l[i + 1][j]) ans++;
}
printf("%I64d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cout << 1 << " ";
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int mod = 1e9 + 7;
const int N = 1234;
int n, m;
long long k;
int a[N][N], h[N * N], p[N * N];
long long b[N][N];
bool used[N][N];
vector<pair<int, int> > go = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
int get(int x) { return x == p[x] ? x : p[x] = get(p[x]); }
void unite(int x, int y) {
x = get(x);
y = get(y);
if (x == y) return;
p[x] = y;
h[y] += h[x];
h[x] = 0;
}
long long qwe;
void dfs(int i, int j) {
k -= qwe;
used[i][j] = true;
b[i][j] = qwe;
for (auto w : go) {
int x = i + w.first, y = j + w.second;
if (check(x, y) && !used[x][y] && k > 0ll && a[x][y] >= qwe) dfs(x, y);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
vector<pair<int, pair<int, int> > > v;
v.reserve(n * m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
p[i * m + j] = i * m + j;
h[i * m + j] = 1;
v.push_back({a[i][j], {i, j}});
}
}
sort(v.rbegin(), v.rend());
for (int i = 0; i < n * m; i++) {
int x = v[i].second.first, y = v[i].second.second, w = v[i].first;
for (auto z : go) {
int nx = x + z.first, ny = y + z.second;
if (check(nx, ny) && a[nx][ny] >= w) {
unite(x * m + y, nx * m + ny);
}
}
int sz = h[get(x * m + y)];
if (k % (long long)w == 0ll && k / (long long)w <= (long long)sz) {
qwe = w;
dfs(x, y);
cout << "YES\n";
for (int j = 0; j < n; j++) {
for (int z = 0; z < m; z++) {
cout << b[j][z] << " ";
}
cout << '\n';
}
return 0;
}
}
cout << "NO";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int flag, tmp;
int ans, mxm, mnm;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
long long l, r;
scanf("%lld%lld", &l, &r);
printf("YES\n");
for (long long i = l; i < r; i += 2) {
printf("%lld %lld\n", i, i + 1);
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.