solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
int temp[200010];
struct Edge {
int b, e, n, l, i;
bool operator<(const Edge& a) const { return l < a.l; }
} ed[200010 << 1], e[200010 << 1];
int sign[200010];
int hd[200010], cnt;
int n, m;
void add(int a, int b, int l, int i) {
e[++cnt].e = b, e[cnt].b = a, e[cnt].l = l, e[cnt].i = i, e[cnt].n = hd[a],
hd[a] = cnt;
}
int F[200010];
int find(int x) { return x == F[x] ? x : F[x] = find(F[x]); }
struct segtree {
int mn, mx, l, r, lazy;
} t[200010 << 2];
int inf = 1.2e9;
int dep[200010], siz[200010], son[200010], fa[200010], lento[200010];
int pre[200010];
void dfs1(int p, int f, int d) {
int i, mx = 0;
fa[p] = f;
dep[p] = d;
siz[p] = 1;
for (i = hd[p]; i; i = e[i].n) {
int q = e[i].e;
if (q == f) continue;
dfs1(q, p, d + 1);
siz[p] += siz[q];
lento[q] = e[i].l;
pre[q] = e[i].i;
if (siz[q] > mx) {
mx = siz[q];
son[p] = q;
}
}
}
int top[200010], pos[200010], count;
void dfs2(int p, int Top) {
int i;
pos[p] = ++count;
temp[count] = lento[p];
top[p] = Top;
if (!son[p]) return;
dfs2(son[p], Top);
for (i = hd[p]; i; i = e[i].n) {
int q = e[i].e;
if (q != son[p] && q != fa[p]) dfs2(q, q);
}
}
void krustal() {
int i;
for (i = 1; i <= n; i++) F[i] = i;
for (i = 1; i <= m; i++) {
int st, fn, p = ed[i].e, q = ed[i].b;
if ((st = find(p)) == (fn = find(q))) continue;
sign[ed[i].i] = 1;
add(p, q, ed[i].l, ed[i].i);
add(q, p, ed[i].l, ed[i].i);
F[st] = fn;
}
}
void update(int p) {
t[p].mn = std::min(t[p << 1].mn, t[p << 1 | 1].mn);
t[p].mx = std::max(t[p << 1].mx, t[p << 1 | 1].mx);
}
void build(int p, int l, int r) {
t[p].l = l;
t[p].r = r;
t[p].mn = t[p].lazy = inf;
if (l == r) {
t[p].mx = temp[l];
return;
}
build(p << 1, l, (l + r) >> 1);
build(p << 1 | 1, ((l + r) >> 1) + 1, r);
update(p);
}
void pushdown(int p) {
int lazy = t[p].lazy;
t[p << 1].mn = std::min(t[p << 1].mn, lazy);
t[p << 1].lazy = std::min(t[p << 1].lazy, lazy);
t[p << 1 | 1].mn = std::min(t[p << 1 | 1].mn, lazy);
t[p << 1 | 1].lazy = std::min(t[p << 1 | 1].lazy, lazy);
t[p].lazy = inf;
}
int querymax(int p, int l, int r) {
int L = t[p].l, R = t[p].r;
pushdown(p);
if (l <= L && R <= r) return t[p].mx;
if (l > R || r < L) return 0;
return std::max(querymax(p << 1, l, r), querymax(p << 1 | 1, l, r));
}
int querymin(int p, int Pos) {
int L = t[p].l, R = t[p].r;
pushdown(p);
if (Pos == L && R == Pos) return t[p].mn;
if (Pos > R || Pos < L) return inf;
return std::min(querymin(p << 1, Pos), querymin(p << 1 | 1, Pos));
}
void modifymin(int p, int l, int r, int w) {
int L = t[p].l, R = t[p].r;
pushdown(p);
if (l <= L && r >= R) {
t[p].mn = std::min(t[p].mn, w);
t[p].lazy = std::min(t[p].lazy, w);
return;
}
if (l > R || r < L) return;
modifymin(p << 1, l, r, w);
modifymin(p << 1 | 1, l, r, w);
update(p);
}
int ans[200010];
int rangequerymax(int x, int y) {
int ans = 0;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) std::swap(x, y);
ans = std::max(ans, querymax(1, pos[top[x]], pos[x]));
x = fa[top[x]];
}
if (dep[x] < dep[y]) std::swap(x, y);
return std::max(ans, querymax(1, pos[y] + 1, pos[x]));
}
void rangemodifymin(int x, int y, int w) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) std::swap(x, y);
modifymin(1, pos[top[x]], pos[x], w);
x = fa[top[x]];
}
if (dep[x] < dep[y]) std::swap(x, y);
modifymin(1, pos[y] + 1, pos[x], w);
}
int main() {
int i;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++)
scanf("%d%d%d", &ed[i].b, &ed[i].e, &ed[i].l), ed[i].i = i;
std::sort(ed + 1, ed + m + 1);
krustal();
dfs1(1, 0, 1);
dfs2(1, 1);
build(1, 1, n);
for (i = 1; i <= m; i++)
if (!sign[ed[i].i]) {
ans[ed[i].i] = rangequerymax(ed[i].b, ed[i].e) - 1;
rangemodifymin(ed[i].b, ed[i].e, ed[i].l);
}
for (i = 2; i <= n; i++) ans[pre[i]] = querymin(1, pos[i]) - 1;
for (i = 1; i <= m; i++) printf("%d ", ans[i] <= 1e9 ? ans[i] : -1);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
int32_t main() {
int l, r; cin>>l>>r;
if(r - l > 1e4){
cout<<0<<endl;
return 0;
}
int ans = 2019;
for(int i = l; i < r; i++){
for(int j = i + 1; j <= r; j++){
ans = min(ans, i * j % 2019);
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q[100000 + 5];
int a[100000 + 5];
int main() {
int m, n;
cin >> m;
for (int i = 0; i <= m - 1; i++) cin >> q[i];
cin >> n;
for (int i = 0; i <= n - 1; i++) cin >> a[i];
long long ans = 0;
sort(a, a + n);
sort(q, q + m);
int d = 0, tmp = n - 1, b = 0;
while (1) {
if (b >= n) break;
if (q[d] <= n - b) {
for (int i = 0; i < q[d]; i++) {
ans += (long long)a[tmp--];
}
b += q[d] + 2;
tmp -= 2;
} else {
for (int i = tmp; i >= 0; i--) {
ans += (long long)a[i];
}
b = n;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int w = 0, f = 1;
char c = ' ';
while (c < '0' || c > '9') c = getchar(), f = c == '-' ? -1 : f;
while (c >= '0' && c <= '9') w = w * 10 + c - 48, c = getchar();
return w * f;
}
int read01() {
char c = getchar();
while (c != '1' && c != '0') c = getchar();
return c == '1';
}
int n, m, q, a[1005][1005], b[1005][1005], cnt;
bool c[1005][1005];
vector<pair<int, int> > l[1005 * 1005];
void dfs(int x, int y) {
if (c[x][y]) return;
l[cnt].push_back(make_pair(x, y));
b[x][y] = cnt;
c[x][y] = 1;
if (a[x - 1][y] == a[x][y]) dfs(x - 1, y);
if (a[x + 1][y] == a[x][y]) dfs(x + 1, y);
if (a[x][y - 1] == a[x][y]) dfs(x, y - 1);
if (a[x][y + 1] == a[x][y]) dfs(x, y + 1);
}
struct node {
int u, d;
bool operator<(const node& o) const { return d > o.d; }
node(int U, int D) { u = U, d = D; }
};
int dis[1005 * 1005];
const int inf = 1e9;
bool vis[1005 * 1005];
vector<pair<int, int> > e[1005 * 1005];
void dij(vector<int> s) {
priority_queue<node> q;
for (int i = 1; i < 1005 * 1005; i++) dis[i] = inf;
for (auto i : s) q.push(node(i, 0)), dis[i] = 0;
while (!q.empty()) {
int u = q.top().u;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto i : e[u]) {
int v = i.first, w = i.second;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
q.push(node(v, dis[v]));
}
}
}
}
void init() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (!c[i][j]) cnt++, dfs(i, j);
vector<int> s;
for (int i = 1; i <= cnt; i++) {
for (auto j : l[i]) {
int x = j.first, y = j.second;
if (a[x][y - 1] != a[x][y] && a[x][y - 1] != -1)
e[i].push_back(make_pair(b[x][y - 1], 1));
if (a[x][y + 1] != a[x][y] && a[x][y + 1] != -1)
e[i].push_back(make_pair(b[x][y + 1], 1));
if (a[x + 1][y] != a[x][y] && a[x + 1][y] != -1)
e[i].push_back(make_pair(b[x + 1][y], 1));
if (a[x - 1][y] != a[x][y] && a[x - 1][y] != -1)
e[i].push_back(make_pair(b[x - 1][y], 1));
}
if (l[i].size() > 1) s.push_back(i);
}
dij(s);
}
signed main() {
n = read(), m = read(), q = read();
memset(a, -1, sizeof(a));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = read01();
init();
int x, y;
long long t;
while (q--) {
x = read(), y = read();
scanf("%lld", &t);
if (t <= dis[b[x][y]] || dis[b[x][y]] >= inf)
printf("%d\n", a[x][y]);
else
printf("%d\n", (t - dis[b[x][y]]) & 1 ? (a[x][y] ^ 1) : a[x][y]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t = 0;
cin >> n >> m;
int a, b;
for (int k = 1; k <= n; k++) {
cin >> a >> b;
if (a <= t && t <= b) t = b;
}
if (t >= m)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int n, m;
vector<int> adl[N];
vector<pair<int, int> > edges;
unordered_map<int, bool> mark[N];
int par[N], sz[N];
int parent[N], color[N];
void init() {
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
void make(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
}
void dfs_scc(int node, int p) {
if (color[node] == 2) return;
if (color[node]) {
int cur = p;
make(node, p);
while (find(cur) != find(parent[cur])) {
make(cur, parent[cur]);
cur = parent[cur];
}
return;
}
parent[node] = p;
color[node] = 1;
for (auto x : adl[node]) {
if (x == p) continue;
dfs_scc(x, node);
}
color[node] = 2;
}
bool vis[N];
void dfs_edge(int node, int comp) {
if (vis[node]) return;
vis[node] = 1;
for (auto x : adl[node]) {
if (find(x) != comp || mark[x][node]) continue;
mark[node][x] = 1;
dfs_edge(x, comp);
}
}
void dfs_center(int node) {
vis[node] = 1;
for (auto x : adl[node]) {
if (vis[x]) continue;
if (find(node) != find(x)) {
mark[x][node] = 1;
}
dfs_center(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
adl[a].push_back(b);
adl[b].push_back(a);
edges.push_back(make_pair(a, b));
}
init();
dfs_scc(1, 1);
for (int i = 1; i <= n; i++) {
if (par[i] == i) {
dfs_edge(i, i);
}
}
int ans = 0, id;
for (int i = 1; i <= n; i++) {
if (par[i] == i) {
if (ans < sz[i]) {
ans = sz[i];
id = i;
}
}
}
fill(vis, vis + n + 2, 0);
dfs_center(id);
cout << ans << '\n';
for (auto x : edges) {
int a = x.first, b = x.second;
if (mark[a][b])
cout << a << " " << b << '\n';
else
cout << b << " " << a << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define repi(i,x,n) for(int i = x; i < n; i++)
#define rep(i,n) repi(i,0,n)
using namespace std;
using ll = long long;
const int INF = 1<<30;
const int MOD = 1e9 + 7;
#define int long long
#define MAX 5100
#define x first
#define a second
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int N, L;
vector<pair<int,int>> t, z;
static int dp[MAX][MAX];
// vector<vector<int>> dp;
int ans = 0;
cin>>N>>L;
t.resize(N+10);
//dp.resize(N+5,vector<int>(L+5,0));
for(int i = 0; i < N; i++){
cin>>t[i].x;
}
for(int i = 0; i < N; i++){
cin>>t[i].a;
}
for(int i = N-1; i >= 0; i--){
z.push_back(t[i]);
}
for(int i = z[0].x; i < L; i += z[0].a){
dp[0][i] = 1;
// cout<<0<<" "<<i<<" "<<dp[0][i]<<endl;
if(z[0].a == 0) break;
}
for(int i = 1; i < N; i++){
for(int j = L-i, sum = 0; j >= z[i].x; j--){
if(z[i].a == 0){
if(z[i].x == j){
dp[i][j] = sum%MOD;
}
} else if((j-z[i].x)%z[i].a == 0){
dp[i][j] = sum%MOD;
//cout<<i<<" "<<j<<" "<<dp[i][j]<<endl;
}
sum += dp[i-1][j];
sum %= MOD;
}
}
for(int i = 0; i < L; i++){
ans += dp[N-1][i];
ans %= MOD;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define fr(i,n) for(int i=0;i<(n);++i)
#define Fr(i,n) for(int i=1;i<=(n);++i)
#define ifr(i,n) for(int i=(n)-1;i>=0;--i)
#define iFr(i,n) for(int i=(n);i>0;--i)
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
istream& in(cin);
ostream& out(cout);
int n;
scanf("%d",&n);
if(n==2) return cout<<-1<<endl,0;
if(n==3) return puts("aa.\n..a\n..a"),0;
vector<string> q={"aabc","ddbc","bcaa","bcdd"},
p={"aabbc","cdd.c","c..ba","a..ba","accdd"},
h={".llkkj","iihh.j","ggfe..","..fedd","c...ba","c...ba"},
s={".nnmmll","kkjji..","hhggi..","f....ed","f....ed","....cba","....cba"};
vector<string> ans(n,string(n,'.'));
fr(i,n/4){
fr(I,4) fr(J,4){
ans[4*i+I][4*i+J]=q[I][J];
}
}
if(n%4==1) fr(i,5) fr(j,5) ans[n-5+i][n-5+j]=p[i][j];
if(n%4==2) fr(i,6) fr(j,6) ans[n-6+i][n-6+j]=h[i][j];
if(n%4==3) fr(i,7) fr(j,7) ans[n-7+i][n-7+j]=s[i][j];
fr(i,n) printf("%s\n",ans[i].c_str());
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int a[N];
map<int, int> mp;
int mex() {
for (int i = 0;; ++i) {
if (mp.find(i) == mp.end()) {
return i;
}
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
bool flag = true;
for (int i = 0; i < n - 1; ++i) {
if (a[i] > a[i + 1]) {
flag = false;
break;
}
}
if (!flag) {
vector<int> res;
for (int i = 0; i < n; ++i) {
++mp[a[i]];
}
while (1) {
bool flag = true;
for (int i = 0; i < n - 1; ++i) {
if (a[i] > a[i + 1]) {
flag = false;
break;
}
}
if (flag) {
break;
}
int t = mex();
int old;
if (t == n) {
int i;
for (i = 0; i < n; ++i) {
if (a[i] != i) {
old = a[i];
a[i] = t;
res.push_back(i + 1);
break;
}
}
--mp[old];
if (mp[old] == 0) {
mp.erase(old);
}
++mp[a[i]];
} else if (t < n) {
int old = a[t];
a[t] = t;
res.push_back(t + 1);
--mp[old];
if (mp[old] == 0) {
mp.erase(old);
}
++mp[a[t]];
}
}
printf("%d\n", res.size());
for (int i = 0; i < res.size(); ++i) printf("%d ", res[i]);
} else {
puts("0");
}
puts("");
mp.clear();
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
const int N=1e6+5;
int n,ans;
int nxt[N][26],pre[N];
int co[N];
string s[N];
vector<int> v;
bool is_end[N];
int main()
{
cin>>n;
int cnt=1;
for(int i=0;i<n;i++)
{
cin>>s[i];
reverse(s[i].begin(),s[i].end());
int node=1;
for(int j=0;j<s[i].size();j++)
{
if(!nxt[node][s[i][j]-'a'])
nxt[node][s[i][j]-'a']=++cnt,co[cnt]=s[i][j]-'a';
pre[nxt[node][s[i][j]-'a']]=node;
node=nxt[node][s[i][j]-'a'];
}
v.pb(node);
is_end[node]=1;
}
for(int i=0;i<v.size();i++)
{
int suffix=0;
for(int j=v[i];j;j=pre[j])
{
for(int k=0;k<26;k++)
if(suffix>>k&1 && is_end[nxt[j][k]]) ans++;
suffix|=1<<co[j];
}
}
cout<<ans-n<<'\n';
return 0;
}
| 0 |
#include <stdio.h>
int main(void) {
int K=0;
scanf("%d",&K);
printf("%d",K/2*((K+1)/2));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long f[505][505];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) f[i][0] = 1;
f[1][1] = 1;
for (int i = 2; i <= n; i++) {
for (int r = 1; r <= n; r++) {
for (int k = 0; k <= r + 1; k++) {
if (k < r) f[i][r] = (f[i][r] + f[i - 1][k] * f[i - 1][r - k - 1]);
if (k <= r) {
f[i][r] =
(f[i][r] + f[i - 1][k] * f[i - 1][r - k] % mod * (1 + 2 * r));
}
f[i][r] = (f[i][r] +
f[i - 1][k] * f[i - 1][r + 1 - k] % mod * r * (r + 1) % mod);
f[i][r] %= mod;
}
}
}
printf("%lld\n", f[n][1]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string int2str(int i) { return to_string(i); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<string> s(n);
vector<int> t(n), c(2, 0);
for (int i = 0; i < n; ++i) {
cin >> s[i] >> t[i];
++c[t[i]];
}
map<string, int> m;
for (int i = 1; i <= c[1]; ++i) m[int2str(i)] = 1;
for (int i = c[1] + 1; i <= n; ++i) m[int2str(i)] = 0;
queue<string> corra, corrb, oppa, oppb, rana, ranb, fria, frib;
for (int i = 0; i < n; ++i) {
if (t[i] == 0) {
if (m.count(s[i]) > 0) {
if (m[s[i]] == 0)
corra.push(s[i]);
else
oppa.push(s[i]);
m[s[i]] = 1337;
} else
rana.push(s[i]);
} else {
if (m.count(s[i]) > 0) {
if (m[s[i]] == 1)
corrb.push(s[i]);
else
oppb.push(s[i]);
m[s[i]] = 1337;
} else
ranb.push(s[i]);
}
}
for (int i = 1; i <= c[1]; ++i)
if (m[int2str(i)] < 2) frib.push(int2str(i));
for (int i = c[1] + 1; i <= n; ++i)
if (m[int2str(i)] < 2) fria.push(int2str(i));
if (corra.size() == c[0] && corrb.size() == c[1]) {
cout << 0 << endl;
return 0;
}
vector<string> ret;
if (rana.empty() && ranb.empty()) {
string q = oppa.front();
oppa.pop();
ret.push_back("move " + q + " bajs");
rana.push("bajs");
frib.push(q);
}
if (!fria.empty()) {
string old = fria.front();
fria.pop();
while (true) {
if (oppa.empty()) {
fria.push(old);
break;
}
string q = oppa.front();
oppa.pop();
ret.push_back("move " + q + " " + old);
old = q;
if (oppb.empty()) {
frib.push(old);
break;
}
q = oppb.front();
oppb.pop();
ret.push_back("move " + q + " " + old);
old = q;
}
} else {
string old = frib.front();
frib.pop();
while (true) {
if (oppb.empty()) {
frib.push(old);
break;
}
string q = oppb.front();
oppb.pop();
ret.push_back("move " + q + " " + old);
old = q;
if (oppa.empty()) {
fria.push(old);
break;
}
q = oppa.front();
oppa.pop();
ret.push_back("move " + q + " " + old);
old = q;
}
}
while (!oppa.empty()) {
string a = oppa.front(), b = fria.front();
oppa.pop();
fria.pop();
ret.push_back("move " + a + " " + b);
frib.push(a);
}
while (!oppb.empty()) {
string a = oppb.front(), b = frib.front();
oppb.pop();
frib.pop();
ret.push_back("move " + a + " " + b);
fria.push(a);
}
while (!rana.empty()) {
string a = rana.front(), b = fria.front();
rana.pop();
fria.pop();
ret.push_back("move " + a + " " + b);
}
while (!ranb.empty()) {
string a = ranb.front(), b = frib.front();
ranb.pop();
frib.pop();
ret.push_back("move " + a + " " + b);
}
cout << ret.size() << endl;
for (int i = 0; i < ret.size(); ++i) cout << ret[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
int xp, yp, xv, yv;
int main() {
scanf("%d%d%d%d", &xp, &yp, &xv, &yv);
if (xp + yp <= yv || xp + yp <= xv || (xp <= xv && yp <= yv))
printf("Polycarp");
else
printf("Vasiliy");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long a[3000] = {
0, 4, 7, 44, 47, 74,
77, 444, 447, 474, 477, 744,
747, 774, 777, 4444, 4447, 4474,
4477, 4744, 4747, 4774, 4777, 7444,
7447, 7474, 7477, 7744, 7747, 7774,
7777, 44444, 44447, 44474, 44477, 44744,
44747, 44774, 44777, 47444, 47447, 47474,
47477, 47744, 47747, 47774, 47777, 74444,
74447, 74474, 74477, 74744, 74747, 74774,
74777, 77444, 77447, 77474, 77477, 77744,
77747, 77774, 77777, 444444, 444447, 444474,
444477, 444744, 444747, 444774, 444777, 447444,
447447, 447474, 447477, 447744, 447747, 447774,
447777, 474444, 474447, 474474, 474477, 474744,
474747, 474774, 474777, 477444, 477447, 477474,
477477, 477744, 477747, 477774, 477777, 744444,
744447, 744474, 744477, 744744, 744747, 744774,
744777, 747444, 747447, 747474, 747477, 747744,
747747, 747774, 747777, 774444, 774447, 774474,
774477, 774744, 774747, 774774, 774777, 777444,
777447, 777474, 777477, 777744, 777747, 777774,
777777, 4444444, 4444447, 4444474, 4444477, 4444744,
4444747, 4444774, 4444777, 4447444, 4447447, 4447474,
4447477, 4447744, 4447747, 4447774, 4447777, 4474444,
4474447, 4474474, 4474477, 4474744, 4474747, 4474774,
4474777, 4477444, 4477447, 4477474, 4477477, 4477744,
4477747, 4477774, 4477777, 4744444, 4744447, 4744474,
4744477, 4744744, 4744747, 4744774, 4744777, 4747444,
4747447, 4747474, 4747477, 4747744, 4747747, 4747774,
4747777, 4774444, 4774447, 4774474, 4774477, 4774744,
4774747, 4774774, 4774777, 4777444, 4777447, 4777474,
4777477, 4777744, 4777747, 4777774, 4777777, 7444444,
7444447, 7444474, 7444477, 7444744, 7444747, 7444774,
7444777, 7447444, 7447447, 7447474, 7447477, 7447744,
7447747, 7447774, 7447777, 7474444, 7474447, 7474474,
7474477, 7474744, 7474747, 7474774, 7474777, 7477444,
7477447, 7477474, 7477477, 7477744, 7477747, 7477774,
7477777, 7744444, 7744447, 7744474, 7744477, 7744744,
7744747, 7744774, 7744777, 7747444, 7747447, 7747474,
7747477, 7747744, 7747747, 7747774, 7747777, 7774444,
7774447, 7774474, 7774477, 7774744, 7774747, 7774774,
7774777, 7777444, 7777447, 7777474, 7777477, 7777744,
7777747, 7777774, 7777777, 44444444, 44444447, 44444474,
44444477, 44444744, 44444747, 44444774, 44444777, 44447444,
44447447, 44447474, 44447477, 44447744, 44447747, 44447774,
44447777, 44474444, 44474447, 44474474, 44474477, 44474744,
44474747, 44474774, 44474777, 44477444, 44477447, 44477474,
44477477, 44477744, 44477747, 44477774, 44477777, 44744444,
44744447, 44744474, 44744477, 44744744, 44744747, 44744774,
44744777, 44747444, 44747447, 44747474, 44747477, 44747744,
44747747, 44747774, 44747777, 44774444, 44774447, 44774474,
44774477, 44774744, 44774747, 44774774, 44774777, 44777444,
44777447, 44777474, 44777477, 44777744, 44777747, 44777774,
44777777, 47444444, 47444447, 47444474, 47444477, 47444744,
47444747, 47444774, 47444777, 47447444, 47447447, 47447474,
47447477, 47447744, 47447747, 47447774, 47447777, 47474444,
47474447, 47474474, 47474477, 47474744, 47474747, 47474774,
47474777, 47477444, 47477447, 47477474, 47477477, 47477744,
47477747, 47477774, 47477777, 47744444, 47744447, 47744474,
47744477, 47744744, 47744747, 47744774, 47744777, 47747444,
47747447, 47747474, 47747477, 47747744, 47747747, 47747774,
47747777, 47774444, 47774447, 47774474, 47774477, 47774744,
47774747, 47774774, 47774777, 47777444, 47777447, 47777474,
47777477, 47777744, 47777747, 47777774, 47777777, 74444444,
74444447, 74444474, 74444477, 74444744, 74444747, 74444774,
74444777, 74447444, 74447447, 74447474, 74447477, 74447744,
74447747, 74447774, 74447777, 74474444, 74474447, 74474474,
74474477, 74474744, 74474747, 74474774, 74474777, 74477444,
74477447, 74477474, 74477477, 74477744, 74477747, 74477774,
74477777, 74744444, 74744447, 74744474, 74744477, 74744744,
74744747, 74744774, 74744777, 74747444, 74747447, 74747474,
74747477, 74747744, 74747747, 74747774, 74747777, 74774444,
74774447, 74774474, 74774477, 74774744, 74774747, 74774774,
74774777, 74777444, 74777447, 74777474, 74777477, 74777744,
74777747, 74777774, 74777777, 77444444, 77444447, 77444474,
77444477, 77444744, 77444747, 77444774, 77444777, 77447444,
77447447, 77447474, 77447477, 77447744, 77447747, 77447774,
77447777, 77474444, 77474447, 77474474, 77474477, 77474744,
77474747, 77474774, 77474777, 77477444, 77477447, 77477474,
77477477, 77477744, 77477747, 77477774, 77477777, 77744444,
77744447, 77744474, 77744477, 77744744, 77744747, 77744774,
77744777, 77747444, 77747447, 77747474, 77747477, 77747744,
77747747, 77747774, 77747777, 77774444, 77774447, 77774474,
77774477, 77774744, 77774747, 77774774, 77774777, 77777444,
77777447, 77777474, 77777477, 77777744, 77777747, 77777774,
77777777, 444444444, 444444447, 444444474, 444444477, 444444744,
444444747, 444444774, 444444777, 444447444, 444447447, 444447474,
444447477, 444447744, 444447747, 444447774, 444447777, 444474444,
444474447, 444474474, 444474477, 444474744, 444474747, 444474774,
444474777, 444477444, 444477447, 444477474, 444477477, 444477744,
444477747, 444477774, 444477777, 444744444, 444744447, 444744474,
444744477, 444744744, 444744747, 444744774, 444744777, 444747444,
444747447, 444747474, 444747477, 444747744, 444747747, 444747774,
444747777, 444774444, 444774447, 444774474, 444774477, 444774744,
444774747, 444774774, 444774777, 444777444, 444777447, 444777474,
444777477, 444777744, 444777747, 444777774, 444777777, 447444444,
447444447, 447444474, 447444477, 447444744, 447444747, 447444774,
447444777, 447447444, 447447447, 447447474, 447447477, 447447744,
447447747, 447447774, 447447777, 447474444, 447474447, 447474474,
447474477, 447474744, 447474747, 447474774, 447474777, 447477444,
447477447, 447477474, 447477477, 447477744, 447477747, 447477774,
447477777, 447744444, 447744447, 447744474, 447744477, 447744744,
447744747, 447744774, 447744777, 447747444, 447747447, 447747474,
447747477, 447747744, 447747747, 447747774, 447747777, 447774444,
447774447, 447774474, 447774477, 447774744, 447774747, 447774774,
447774777, 447777444, 447777447, 447777474, 447777477, 447777744,
447777747, 447777774, 447777777, 474444444, 474444447, 474444474,
474444477, 474444744, 474444747, 474444774, 474444777, 474447444,
474447447, 474447474, 474447477, 474447744, 474447747, 474447774,
474447777, 474474444, 474474447, 474474474, 474474477, 474474744,
474474747, 474474774, 474474777, 474477444, 474477447, 474477474,
474477477, 474477744, 474477747, 474477774, 474477777, 474744444,
474744447, 474744474, 474744477, 474744744, 474744747, 474744774,
474744777, 474747444, 474747447, 474747474, 474747477, 474747744,
474747747, 474747774, 474747777, 474774444, 474774447, 474774474,
474774477, 474774744, 474774747, 474774774, 474774777, 474777444,
474777447, 474777474, 474777477, 474777744, 474777747, 474777774,
474777777, 477444444, 477444447, 477444474, 477444477, 477444744,
477444747, 477444774, 477444777, 477447444, 477447447, 477447474,
477447477, 477447744, 477447747, 477447774, 477447777, 477474444,
477474447, 477474474, 477474477, 477474744, 477474747, 477474774,
477474777, 477477444, 477477447, 477477474, 477477477, 477477744,
477477747, 477477774, 477477777, 477744444, 477744447, 477744474,
477744477, 477744744, 477744747, 477744774, 477744777, 477747444,
477747447, 477747474, 477747477, 477747744, 477747747, 477747774,
477747777, 477774444, 477774447, 477774474, 477774477, 477774744,
477774747, 477774774, 477774777, 477777444, 477777447, 477777474,
477777477, 477777744, 477777747, 477777774, 477777777, 744444444,
744444447, 744444474, 744444477, 744444744, 744444747, 744444774,
744444777, 744447444, 744447447, 744447474, 744447477, 744447744,
744447747, 744447774, 744447777, 744474444, 744474447, 744474474,
744474477, 744474744, 744474747, 744474774, 744474777, 744477444,
744477447, 744477474, 744477477, 744477744, 744477747, 744477774,
744477777, 744744444, 744744447, 744744474, 744744477, 744744744,
744744747, 744744774, 744744777, 744747444, 744747447, 744747474,
744747477, 744747744, 744747747, 744747774, 744747777, 744774444,
744774447, 744774474, 744774477, 744774744, 744774747, 744774774,
744774777, 744777444, 744777447, 744777474, 744777477, 744777744,
744777747, 744777774, 744777777, 747444444, 747444447, 747444474,
747444477, 747444744, 747444747, 747444774, 747444777, 747447444,
747447447, 747447474, 747447477, 747447744, 747447747, 747447774,
747447777, 747474444, 747474447, 747474474, 747474477, 747474744,
747474747, 747474774, 747474777, 747477444, 747477447, 747477474,
747477477, 747477744, 747477747, 747477774, 747477777, 747744444,
747744447, 747744474, 747744477, 747744744, 747744747, 747744774,
747744777, 747747444, 747747447, 747747474, 747747477, 747747744,
747747747, 747747774, 747747777, 747774444, 747774447, 747774474,
747774477, 747774744, 747774747, 747774774, 747774777, 747777444,
747777447, 747777474, 747777477, 747777744, 747777747, 747777774,
747777777, 774444444, 774444447, 774444474, 774444477, 774444744,
774444747, 774444774, 774444777, 774447444, 774447447, 774447474,
774447477, 774447744, 774447747, 774447774, 774447777, 774474444,
774474447, 774474474, 774474477, 774474744, 774474747, 774474774,
774474777, 774477444, 774477447, 774477474, 774477477, 774477744,
774477747, 774477774, 774477777, 774744444, 774744447, 774744474,
774744477, 774744744, 774744747, 774744774, 774744777, 774747444,
774747447, 774747474, 774747477, 774747744, 774747747, 774747774,
774747777, 774774444, 774774447, 774774474, 774774477, 774774744,
774774747, 774774774, 774774777, 774777444, 774777447, 774777474,
774777477, 774777744, 774777747, 774777774, 774777777, 777444444,
777444447, 777444474, 777444477, 777444744, 777444747, 777444774,
777444777, 777447444, 777447447, 777447474, 777447477, 777447744,
777447747, 777447774, 777447777, 777474444, 777474447, 777474474,
777474477, 777474744, 777474747, 777474774, 777474777, 777477444,
777477447, 777477474, 777477477, 777477744, 777477747, 777477774,
777477777, 777744444, 777744447, 777744474, 777744477, 777744744,
777744747, 777744774, 777744777, 777747444, 777747447, 777747474,
777747477, 777747744, 777747747, 777747774, 777747777, 777774444,
777774447, 777774474, 777774477, 777774744, 777774747, 777774774,
777774777, 777777444, 777777447, 777777474, 777777477, 777777744,
777777747, 777777774, 777777777, 4444444444, 4444444447, 4444444474,
4444444477, 4444444744, 4444444747, 4444444774, 4444444777, 4444447444,
4444447447, 4444447474, 4444447477, 4444447744, 4444447747, 4444447774,
4444447777, 4444474444, 4444474447, 4444474474, 4444474477, 4444474744,
4444474747, 4444474774, 4444474777, 4444477444, 4444477447, 4444477474,
4444477477, 4444477744, 4444477747, 4444477774, 4444477777, 4444744444,
4444744447, 4444744474, 4444744477, 4444744744, 4444744747, 4444744774,
4444744777, 4444747444, 4444747447, 4444747474, 4444747477, 4444747744,
4444747747, 4444747774, 4444747777, 4444774444, 4444774447, 4444774474,
4444774477, 4444774744, 4444774747, 4444774774, 4444774777, 4444777444,
4444777447, 4444777474, 4444777477, 4444777744, 4444777747, 4444777774,
4444777777, 4447444444, 4447444447, 4447444474, 4447444477, 4447444744,
4447444747, 4447444774, 4447444777, 4447447444, 4447447447, 4447447474,
4447447477, 4447447744, 4447447747, 4447447774, 4447447777, 4447474444,
4447474447, 4447474474, 4447474477, 4447474744, 4447474747, 4447474774,
4447474777, 4447477444, 4447477447, 4447477474, 4447477477, 4447477744,
4447477747, 4447477774, 4447477777, 4447744444, 4447744447, 4447744474,
4447744477, 4447744744, 4447744747, 4447744774, 4447744777, 4447747444,
4447747447, 4447747474, 4447747477, 4447747744, 4447747747, 4447747774,
4447747777, 4447774444, 4447774447, 4447774474, 4447774477, 4447774744,
4447774747, 4447774774, 4447774777, 4447777444, 4447777447, 4447777474,
4447777477, 4447777744, 4447777747, 4447777774, 4447777777, 4474444444,
4474444447, 4474444474, 4474444477, 4474444744, 4474444747, 4474444774,
4474444777, 4474447444, 4474447447, 4474447474, 4474447477, 4474447744,
4474447747, 4474447774, 4474447777, 4474474444, 4474474447, 4474474474,
4474474477, 4474474744, 4474474747, 4474474774, 4474474777, 4474477444,
4474477447, 4474477474, 4474477477, 4474477744, 4474477747, 4474477774,
4474477777, 4474744444, 4474744447, 4474744474, 4474744477, 4474744744,
4474744747, 4474744774, 4474744777, 4474747444, 4474747447, 4474747474,
4474747477, 4474747744, 4474747747, 4474747774, 4474747777, 4474774444,
4474774447, 4474774474, 4474774477, 4474774744, 4474774747, 4474774774,
4474774777, 4474777444, 4474777447, 4474777474, 4474777477, 4474777744,
4474777747, 4474777774, 4474777777, 4477444444, 4477444447, 4477444474,
4477444477, 4477444744, 4477444747, 4477444774, 4477444777, 4477447444,
4477447447, 4477447474, 4477447477, 4477447744, 4477447747, 4477447774,
4477447777, 4477474444, 4477474447, 4477474474, 4477474477, 4477474744,
4477474747, 4477474774, 4477474777, 4477477444, 4477477447, 4477477474,
4477477477, 4477477744, 4477477747, 4477477774, 4477477777, 4477744444,
4477744447, 4477744474, 4477744477, 4477744744, 4477744747, 4477744774,
4477744777, 4477747444, 4477747447, 4477747474, 4477747477, 4477747744,
4477747747, 4477747774, 4477747777, 4477774444, 4477774447, 4477774474,
4477774477, 4477774744, 4477774747, 4477774774, 4477774777, 4477777444,
4477777447, 4477777474, 4477777477, 4477777744, 4477777747, 4477777774,
4477777777, 4744444444, 4744444447, 4744444474, 4744444477, 4744444744,
4744444747, 4744444774, 4744444777, 4744447444, 4744447447, 4744447474,
4744447477, 4744447744, 4744447747, 4744447774, 4744447777, 4744474444,
4744474447, 4744474474, 4744474477, 4744474744, 4744474747, 4744474774,
4744474777, 4744477444, 4744477447, 4744477474, 4744477477, 4744477744,
4744477747, 4744477774, 4744477777, 4744744444, 4744744447, 4744744474,
4744744477, 4744744744, 4744744747, 4744744774, 4744744777, 4744747444,
4744747447, 4744747474, 4744747477, 4744747744, 4744747747, 4744747774,
4744747777, 4744774444, 4744774447, 4744774474, 4744774477, 4744774744,
4744774747, 4744774774, 4744774777, 4744777444, 4744777447, 4744777474,
4744777477, 4744777744, 4744777747, 4744777774, 4744777777, 4747444444,
4747444447, 4747444474, 4747444477, 4747444744, 4747444747, 4747444774,
4747444777, 4747447444, 4747447447, 4747447474, 4747447477, 4747447744,
4747447747, 4747447774, 4747447777, 4747474444, 4747474447, 4747474474,
4747474477, 4747474744, 4747474747, 4747474774, 4747474777, 4747477444,
4747477447, 4747477474, 4747477477, 4747477744, 4747477747, 4747477774,
4747477777, 4747744444, 4747744447, 4747744474, 4747744477, 4747744744,
4747744747, 4747744774, 4747744777, 4747747444, 4747747447, 4747747474,
4747747477, 4747747744, 4747747747, 4747747774, 4747747777, 4747774444,
4747774447, 4747774474, 4747774477, 4747774744, 4747774747, 4747774774,
4747774777, 4747777444, 4747777447, 4747777474, 4747777477, 4747777744,
4747777747, 4747777774, 4747777777, 4774444444, 4774444447, 4774444474,
4774444477, 4774444744, 4774444747, 4774444774, 4774444777, 4774447444,
4774447447, 4774447474, 4774447477, 4774447744, 4774447747, 4774447774,
4774447777, 4774474444, 4774474447, 4774474474, 4774474477, 4774474744,
4774474747, 4774474774, 4774474777, 4774477444, 4774477447, 4774477474,
4774477477, 4774477744, 4774477747, 4774477774, 4774477777, 4774744444,
4774744447, 4774744474, 4774744477, 4774744744, 4774744747, 4774744774,
4774744777, 4774747444, 4774747447, 4774747474, 4774747477, 4774747744,
4774747747, 4774747774, 4774747777, 4774774444, 4774774447, 4774774474,
4774774477, 4774774744, 4774774747, 4774774774, 4774774777, 4774777444,
4774777447, 4774777474, 4774777477, 4774777744, 4774777747, 4774777774,
4774777777, 4777444444, 4777444447, 4777444474, 4777444477, 4777444744,
4777444747, 4777444774, 4777444777, 4777447444, 4777447447, 4777447474,
4777447477, 4777447744, 4777447747, 4777447774, 4777447777, 4777474444,
4777474447, 4777474474, 4777474477, 4777474744, 4777474747, 4777474774,
4777474777, 4777477444, 4777477447, 4777477474, 4777477477, 4777477744,
4777477747, 4777477774, 4777477777, 4777744444, 4777744447, 4777744474,
4777744477, 4777744744, 4777744747, 4777744774, 4777744777, 4777747444,
4777747447, 4777747474, 4777747477, 4777747744, 4777747747, 4777747774,
4777747777, 4777774444, 4777774447, 4777774474, 4777774477, 4777774744,
4777774747, 4777774774, 4777774777, 4777777444, 4777777447, 4777777474,
4777777477, 4777777744, 4777777747, 4777777774, 4777777777, 7444444444,
7444444447, 7444444474, 7444444477, 7444444744, 7444444747, 7444444774,
7444444777, 7444447444, 7444447447, 7444447474, 7444447477, 7444447744,
7444447747, 7444447774, 7444447777, 7444474444, 7444474447, 7444474474,
7444474477, 7444474744, 7444474747, 7444474774, 7444474777, 7444477444,
7444477447, 7444477474, 7444477477, 7444477744, 7444477747, 7444477774,
7444477777, 7444744444, 7444744447, 7444744474, 7444744477, 7444744744,
7444744747, 7444744774, 7444744777, 7444747444, 7444747447, 7444747474,
7444747477, 7444747744, 7444747747, 7444747774, 7444747777, 7444774444,
7444774447, 7444774474, 7444774477, 7444774744, 7444774747, 7444774774,
7444774777, 7444777444, 7444777447, 7444777474, 7444777477, 7444777744,
7444777747, 7444777774, 7444777777, 7447444444, 7447444447, 7447444474,
7447444477, 7447444744, 7447444747, 7447444774, 7447444777, 7447447444,
7447447447, 7447447474, 7447447477, 7447447744, 7447447747, 7447447774,
7447447777, 7447474444, 7447474447, 7447474474, 7447474477, 7447474744,
7447474747, 7447474774, 7447474777, 7447477444, 7447477447, 7447477474,
7447477477, 7447477744, 7447477747, 7447477774, 7447477777, 7447744444,
7447744447, 7447744474, 7447744477, 7447744744, 7447744747, 7447744774,
7447744777, 7447747444, 7447747447, 7447747474, 7447747477, 7447747744,
7447747747, 7447747774, 7447747777, 7447774444, 7447774447, 7447774474,
7447774477, 7447774744, 7447774747, 7447774774, 7447774777, 7447777444,
7447777447, 7447777474, 7447777477, 7447777744, 7447777747, 7447777774,
7447777777, 7474444444, 7474444447, 7474444474, 7474444477, 7474444744,
7474444747, 7474444774, 7474444777, 7474447444, 7474447447, 7474447474,
7474447477, 7474447744, 7474447747, 7474447774, 7474447777, 7474474444,
7474474447, 7474474474, 7474474477, 7474474744, 7474474747, 7474474774,
7474474777, 7474477444, 7474477447, 7474477474, 7474477477, 7474477744,
7474477747, 7474477774, 7474477777, 7474744444, 7474744447, 7474744474,
7474744477, 7474744744, 7474744747, 7474744774, 7474744777, 7474747444,
7474747447, 7474747474, 7474747477, 7474747744, 7474747747, 7474747774,
7474747777, 7474774444, 7474774447, 7474774474, 7474774477, 7474774744,
7474774747, 7474774774, 7474774777, 7474777444, 7474777447, 7474777474,
7474777477, 7474777744, 7474777747, 7474777774, 7474777777, 7477444444,
7477444447, 7477444474, 7477444477, 7477444744, 7477444747, 7477444774,
7477444777, 7477447444, 7477447447, 7477447474, 7477447477, 7477447744,
7477447747, 7477447774, 7477447777, 7477474444, 7477474447, 7477474474,
7477474477, 7477474744, 7477474747, 7477474774, 7477474777, 7477477444,
7477477447, 7477477474, 7477477477, 7477477744, 7477477747, 7477477774,
7477477777, 7477744444, 7477744447, 7477744474, 7477744477, 7477744744,
7477744747, 7477744774, 7477744777, 7477747444, 7477747447, 7477747474,
7477747477, 7477747744, 7477747747, 7477747774, 7477747777, 7477774444,
7477774447, 7477774474, 7477774477, 7477774744, 7477774747, 7477774774,
7477774777, 7477777444, 7477777447, 7477777474, 7477777477, 7477777744,
7477777747, 7477777774, 7477777777, 7744444444, 7744444447, 7744444474,
7744444477, 7744444744, 7744444747, 7744444774, 7744444777, 7744447444,
7744447447, 7744447474, 7744447477, 7744447744, 7744447747, 7744447774,
7744447777, 7744474444, 7744474447, 7744474474, 7744474477, 7744474744,
7744474747, 7744474774, 7744474777, 7744477444, 7744477447, 7744477474,
7744477477, 7744477744, 7744477747, 7744477774, 7744477777, 7744744444,
7744744447, 7744744474, 7744744477, 7744744744, 7744744747, 7744744774,
7744744777, 7744747444, 7744747447, 7744747474, 7744747477, 7744747744,
7744747747, 7744747774, 7744747777, 7744774444, 7744774447, 7744774474,
7744774477, 7744774744, 7744774747, 7744774774, 7744774777, 7744777444,
7744777447, 7744777474, 7744777477, 7744777744, 7744777747, 7744777774,
7744777777, 7747444444, 7747444447, 7747444474, 7747444477, 7747444744,
7747444747, 7747444774, 7747444777, 7747447444, 7747447447, 7747447474,
7747447477, 7747447744, 7747447747, 7747447774, 7747447777, 7747474444,
7747474447, 7747474474, 7747474477, 7747474744, 7747474747, 7747474774,
7747474777, 7747477444, 7747477447, 7747477474, 7747477477, 7747477744,
7747477747, 7747477774, 7747477777, 7747744444, 7747744447, 7747744474,
7747744477, 7747744744, 7747744747, 7747744774, 7747744777, 7747747444,
7747747447, 7747747474, 7747747477, 7747747744, 7747747747, 7747747774,
7747747777, 7747774444, 7747774447, 7747774474, 7747774477, 7747774744,
7747774747, 7747774774, 7747774777, 7747777444, 7747777447, 7747777474,
7747777477, 7747777744, 7747777747, 7747777774, 7747777777, 7774444444,
7774444447, 7774444474, 7774444477, 7774444744, 7774444747, 7774444774,
7774444777, 7774447444, 7774447447, 7774447474, 7774447477, 7774447744,
7774447747, 7774447774, 7774447777, 7774474444, 7774474447, 7774474474,
7774474477, 7774474744, 7774474747, 7774474774, 7774474777, 7774477444,
7774477447, 7774477474, 7774477477, 7774477744, 7774477747, 7774477774,
7774477777, 7774744444, 7774744447, 7774744474, 7774744477, 7774744744,
7774744747, 7774744774, 7774744777, 7774747444, 7774747447, 7774747474,
7774747477, 7774747744, 7774747747, 7774747774, 7774747777, 7774774444,
7774774447, 7774774474, 7774774477, 7774774744, 7774774747, 7774774774,
7774774777, 7774777444, 7774777447, 7774777474, 7774777477, 7774777744,
7774777747, 7774777774, 7774777777, 7777444444, 7777444447, 7777444474,
7777444477, 7777444744, 7777444747, 7777444774, 7777444777, 7777447444,
7777447447, 7777447474, 7777447477, 7777447744, 7777447747, 7777447774,
7777447777, 7777474444, 7777474447, 7777474474, 7777474477, 7777474744,
7777474747, 7777474774, 7777474777, 7777477444, 7777477447, 7777477474,
7777477477, 7777477744, 7777477747, 7777477774, 7777477777, 7777744444,
7777744447, 7777744474, 7777744477, 7777744744, 7777744747, 7777744774,
7777744777, 7777747444, 7777747447, 7777747474, 7777747477, 7777747744,
7777747747, 7777747774, 7777747777, 7777774444, 7777774447, 7777774474,
7777774477, 7777774744, 7777774747, 7777774774, 7777774777, 7777777444,
7777777447, 7777777474, 7777777477, 7777777744, 7777777747, 7777777774,
7777777777};
long long cnt, summ, x, y, xx, yy, pl, pr, vl, vr, k, l, r, tmpx, tmpy, ll, rr,
n;
bool flag;
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 b;
else
return a;
}
int main() {
cin >> pl >> pr >> vl >> vr >> k;
n = 2046;
xx = min(pl, vl);
yy = max(pr, vr);
summ = (pr - pl + 1) * (vr - vl + 1);
flag = true;
for (int i = 1; i <= n; i++) {
if (a[i] >= xx) {
tmpx = i;
flag = false;
break;
}
}
if (flag == true) tmpx = n;
flag = true;
for (int i = 1; i <= n; i++) {
if (a[i] > yy) {
tmpy = i - 1;
flag = false;
break;
}
}
if (flag == true) tmpy = n;
cnt = 0;
for (int i = tmpx; i <= tmpy - k + 1; i++) {
l = max(pl, a[i - 1] + 1);
ll = min(pr, a[i]);
rr = min(vr, a[i + k] - 1);
r = max(vl, a[i + k - 1]);
if (ll - l + 1 >= 0 && rr - r + 1 >= 0) cnt += (ll - l + 1) * (rr - r + 1);
if (ll == r) cnt--;
l = max(vl, a[i - 1] + 1);
ll = min(vr, a[i]);
rr = min(pr, a[i + k] - 1);
r = max(pl, a[i + k - 1]);
if (ll - l + 1 >= 0 && rr - r + 1 >= 0) cnt += (ll - l + 1) * (rr - r + 1);
}
double anss;
if (cnt > summ) cnt = summ;
anss = double(cnt) / double(summ);
printf("%.10llf", anss);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
cin >> t;
while (t--) {
int n, t1, t2, ans = 1, start = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t1 >> t2;
ans = max(ans, t1);
if (t2 >= ans) {
cout << ans << " ";
ans++;
} else {
cout << 0 << " ";
}
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct station {
int pos, price;
} a[200003];
int T[800008], d, n, m;
long long cnt;
bool comp(station A, station B) { return (A.pos < B.pos); }
void Build_MinIT(int, int, int);
int Find_Min(int, int, int, int, int);
int main() {
scanf("%d %d %d", &d, &n, &m);
for (int i = 1; i <= m; i++) scanf("%d %d", &a[i].pos, &a[i].price);
sort(a + 1, a + 1 + m, comp);
a[++m].pos = d;
for (int i = 1; i <= m; i++) {
if (a[i].pos - a[i - 1].pos > n) {
cout << -1;
return 0;
}
}
if (n >= d) {
cout << 0;
return 0;
}
a[200002].price = 1E+9;
Build_MinIT(1, m, 1);
int i = 0, j = 1, t = n;
while (j <= m) {
while (a[i].price < a[j].price && a[j].pos - a[i].pos <= n && j <= m) j++;
if (a[j].pos - a[i].pos <= n) {
cnt += (long long)(a[j].pos - (a[i].pos + t)) * a[i].price;
t = 0;
i = j++;
} else {
int k = Find_Min(i + 1, j - 1, 1, m, 1);
cnt += (long long)(n - t) * a[i].price;
t = a[i].pos + n - a[k].pos;
i = k;
}
}
cout << cnt;
return 0;
}
void Build_MinIT(int L, int R, int v) {
if (L == R) {
T[v] = L;
return;
}
int m = (L + R) / 2;
Build_MinIT(L, m, v * 2);
Build_MinIT(m + 1, R, v * 2 + 1);
T[v] = (a[T[v * 2]].price < a[T[v * 2 + 1]].price ? T[v * 2] : T[v * 2 + 1]);
}
int Find_Min(int l, int r, int L, int R, int v) {
if (l > r) return 200002;
if (l == L && r == R) return T[v];
int m = (L + R) / 2;
int x = Find_Min(l, min(r, m), L, m, v * 2),
y = Find_Min(max(l, m + 1), r, m + 1, R, v * 2 + 1);
return (a[x].price < a[y].price ? x : y);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int q;
set<int> st[N];
void solve(int x, int k, int s) {
if (s - k < 1 || x % k != 0) {
puts("-1");
return;
}
auto pos = st[k].upper_bound(s - x);
if (st[k].empty() || pos == st[k].begin()) {
puts("-1");
return;
}
int ans = -1;
for (pos--; pos != st[k].begin(); pos--) {
int v = *pos;
if (ans > x + v) break;
ans = max(x ^ v, ans == -1 ? x ^ v : ans);
}
int v = *st[k].begin();
ans = max(x ^ v, ans == -1 ? x ^ v : ans);
printf("%d\n", ans == -1 ? ans : ans ^ x);
}
int main() {
scanf("%d", &q);
while (q--) {
int op, u, x, k, s;
scanf("%d", &op);
if (op == 1) {
scanf("%d", &u);
for (int i = 1; i * i <= u; i++) {
if (u % i == 0) {
st[i].insert(u);
st[u / i].insert(u);
}
}
} else {
scanf("%d%d%d", &x, &k, &s);
solve(x, k, s);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
long long n, m;
cin >> T;
while (T--) {
cin >> n >> m;
cout << n + m << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[2010], sum;
long long num[2010];
long long c(int a, int b) {
int t = a, ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * t % 1000000007;
b >>= 1;
t = (long long)t * t % 1000000007;
}
return ans;
}
int main() {
int n, k;
long long tmp;
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
if (k == 0) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
} else {
sum = a[0];
num[0] = 1;
cout << sum << " ";
for (int i = 1; i < n; i++) {
sum = 0;
num[i] = num[i - 1] * c(i, 1000000005) % 1000000007 * (k + i - 1) %
1000000007;
for (int j = 0; j <= i; j++) {
sum = (long long)(sum + num[j] * a[i - j]) % 1000000007;
}
cout << sum << " ";
}
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 * 1000 + 10;
int a[MAX_N];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
if (k >= n) {
cout << a[n - 1];
return 0;
}
int ans = a[n - 1];
int t = 2 * k - n;
k -= t;
n -= t;
for (int i = 0, j = n - 1; i < n && j >= 0 && i <= j; i++, j--) {
ans = max(ans, a[i] + a[j]);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool ok[6][6];
set<char> s1[6];
set<char> s2[6];
vector<int> v1[6], v2[6];
char col[105];
char num[105];
int hint[105];
int ans;
int main() {
cin >> n;
ans = n;
for (int i = 1; i <= n; i++) {
cin >> col[i] >> num[i];
if (col[i] == 'R') {
col[i] = 'A';
} else if (col[i] == 'G') {
col[i] = 'B';
} else if (col[i] == 'B') {
col[i] = 'C';
} else if (col[i] == 'Y') {
col[i] = 'D';
} else {
col[i] = 'E';
}
v1[col[i] - 'A' + 1].push_back(i);
v2[num[i] - '0'].push_back(i);
}
for (int msk = 0; msk < (1 << 10); msk++) {
int t = msk;
int pl = 0;
int cnt = 0;
for (int i = 1; i <= 5; i++) {
s1[i].clear();
s2[i].clear();
}
memset(hint, 0, sizeof(hint));
while (t) {
pl++;
if (t % 2) {
cnt++;
if (pl <= 5) {
for (int i = 0; i < v1[pl].size(); i++) {
hint[v1[pl][i]]++;
s1[pl].insert(num[v1[pl][i]]);
}
} else {
for (int i = 0; i < v2[pl - 5].size(); i++) {
hint[v2[pl - 5][i]]++;
s2[pl - 5].insert(col[v2[pl - 5][i]]);
}
}
}
t /= 2;
}
set<pair<char, char> > S;
for (int i = 1; i <= n; i++) {
if (hint[i] == 2) {
s1[col[i] - 'A' + 1].erase(num[i]);
s2[num[i] - '0'].erase(col[i]);
} else if (hint[i] == 0) {
S.insert(make_pair(col[i], num[i]));
}
}
bool flag = true;
for (int i = 1; i <= 5; i++) {
if (s1[i].size() > 1 || s2[i].size() > 1) {
flag = false;
break;
}
}
if (S.size() > 1) {
flag = false;
}
if (flag) {
ans = min(ans, cnt);
}
}
cout << ans;
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(x,b) ((x)>=0&&(x)<(b))
#define Y first
#define X second
#define INF 1 << 30
typedef pair<int, int> pii;
typedef queue<int> qi;
typedef pair<int, int> pi;
int board[51][51], Y, X;
int dx[] = {0,1,0,-1}, dy[] = {1,0,-1,0};
pii nextp1(pii now, int i){
pii next = now;
next.Y += dy[i];
next.X += dx[i];
if(BW((next.Y), Y) && BW((next.X), X) && board[next.Y][next.X] == 0) return next;
return now;
}
pii nextp2(pii now, int i){
pii next = now;
next.Y += -1 * dy[i];
next.X += -1 * dx[i];
if(BW(next.Y, Y) && BW(next.X, X) && board[next.Y][next.X] == 0) return next;
return now;
}
pii nextp(pii now, int i, int d){
pii next = now;
next.Y += dy[i] * d;
next.X += dx[i] * d;
if(BW(next.Y, Y) && BW(next.X, X) && board[next.Y][next.X] == 0) return next;
return now;
}
int main(){
while(scanf("%d%d", &X, &Y) && X+Y){
int tx, ty, kx, ky;
scanf("%d%d%d%d", &tx, &ty, &kx, &ky); tx--; ty--; kx--; ky--;
rep(i, Y) rep(j, X) scanf("%d", &board[i][j]);
map<pair<pi,pi>, bool>m; // t k
queue<pii>tq, kq;
tq.push(make_pair(ty, tx));
kq.push(make_pair(ky, kx));
m[make_pair(make_pair(ty, tx), make_pair(ky, kx))] = 1;
int res = 1;
while(!tq.empty()){
if(res >= 100) break;
int qsize = (int)tq.size();
rep(i, qsize){
pii t = tq.front(); tq.pop();
pii k = kq.front(); kq.pop();
rep(j, 4){
pii nt = nextp(t, j, 1), nk = nextp(k, j, -1);
pair<pi, pi> next = make_pair(make_pair(nt.Y, nt.X), make_pair(nk.Y, nk.X));
if(m.count(next) == 1) continue;
if(nt == nk){
printf("%d\n", res);
goto end;
}
m[next] = 1;
tq.push(nt); kq.push(nk);
}
}
res++;
}
puts("NA");
end:;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> sf1, sf2;
priority_queue<int, std::vector<int>, std::greater<int> > myq;
set<int> myset;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x;
cin >> y;
sf1.push_back(x);
sf2.push_back(y);
myq.push(x);
myq.push(y);
}
for (int i = 0; i < n; ++i) {
int val = myq.top();
myq.pop();
myset.insert(val);
}
vector<char> s1, s2;
for (int i = 0; i < n; ++i) {
if (i < n / 2) {
s1.push_back('1');
s2.push_back('1');
} else {
if (myset.find(sf1[i]) != myset.end()) {
s1.push_back('1');
s2.push_back('0');
} else if (myset.find(sf2[i]) != myset.end()) {
s2.push_back('1');
s1.push_back('0');
} else {
s2.push_back('0');
s1.push_back('0');
}
}
}
for (int i = 0; i < n; ++i) {
cout << s1[i];
}
cout << endl;
for (int i = 0; i < n; ++i) {
cout << s2[i];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-parameter"
using namespace std;
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wformat"
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long power(long long B, long long P) {
if (P == 0) return 1;
long long X = power(B, P / 2);
if (P % 2 == 0)
return X * X;
else
return B * X * X;
}
int fx[] = {1, -1, 0, 0};
int fy[] = {0, 0, 1, -1};
int main() {
int T, cs = 0;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
set<int> st;
vector<int> v;
for (int i = 1; i <= n; i++) st.insert(i);
for (int i = 1; i <= n; i++) {
int u;
scanf("%d", &u);
if (st.find(u) != st.end())
st.erase(u);
else
v.push_back(u);
}
sort(v.rbegin(), v.rend());
int res = 0;
for (auto it : v) {
auto ck = st.end();
ck--;
if (*ck > (it - 1) / 2) {
res = 1;
break;
}
st.erase(ck);
}
if (res == 1)
cout << "-1\n";
else
cout << v.size() << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class point {
public:
int x, y;
inline bool operator<(const point& P) const {
return (x != P.x) ? (x < P.x) : (y < P.y);
}
};
const int MAXN = 3001;
int main() {
int n;
cin >> n;
set<point> pts;
for (int i = 0; i < n; ++i) {
point p;
cin >> p.x >> p.y;
pts.insert(p);
}
int cnt = 0;
for (set<point>::iterator it1 = pts.begin(); it1 != pts.end(); it1++) {
set<point>::iterator it2 = it1;
for (it2++; it2 != pts.end(); it2++) {
if (((it1->x + it2->x) % 2 == 0) && ((it1->y + it2->y) % 2 == 0)) {
point p;
p.x = (it1->x + it2->x) / 2;
p.y = (it1->y + it2->y) / 2;
if (pts.find(p) != pts.end()) {
cnt++;
}
}
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
#include<stack>
#include<queue>
#include<string.h>
#include<functional>
#include<set>
using namespace std;
#define INF 1<<21
#define DIV 1000000007
#define MAX 100005
int main(){
int n;
while (cin >> n,n) {
int meet[55][35];
int have[55][55];
memset(meet, 0, sizeof(meet));
memset(have, 0, sizeof(have));
for (int i = 1; i <= n; i++) {
int f;
cin >> f;
int m;
for (int j = 0; j < f; j++) {
cin >> m;
meet[i][m] = 1;
}
}
for (int i = 1; i <= n; i++) {
have[i][i] = 1;
}
int flag = 0;
for (int t = 1; t <= 30; t++) {
set<int> S;
for (int i = 1; i <= n; i++) {
if (!meet[i][t])continue;
for (int j = 1; j <= n; j++) {
if (have[i][j])S.insert(j);
}
}
for (int i = 1; i <= n; i++) {
if (!meet[i][t])continue;
for (auto s = S.begin(); s != S.end(); s++) {
have[i][*s] = 1;
}
}
if (S.size() == n) {
cout << t << endl;
break;
}
if (S.size() < n&&t == 30)flag = 1;
}
if (flag)cout << -1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int MOD_MAX = 1e9 + 7;
int main() {
int h[N];
int n, count = 0;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
int curr_h = 0;
for (int i = 0; i < n; i++) {
count += (h[i] - curr_h + 1);
curr_h = h[i];
if (i < n - 1) {
count++;
if (curr_h > h[i + 1]) {
count += (curr_h - h[i + 1]);
curr_h = h[i + 1];
}
}
}
cout << count;
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main()
{
bool f;
cin>>f;
cout<<!f<<endl;
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
int main()
{
int n,mm[200005],mmnn[200005];
cin>>n;
for(int i=0;i<n;i++)
{
cin>>mm[i];
mmnn[i]=mm[i];
}
sort(mm,mm+n);
int ans=mm[n/2];
for(int i=0;i<n;i++)
{
if(ans>mmnn[i])cout<<mm[n/2]<<endl;
else cout<<mm[n/2-1]<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
vector<int> G[maxn];
int totson[maxn], subtree[maxn][10], n, k, u, v;
long long ans;
int subtract(int a, int b) { return ((a - b) % k + k) % k; }
void dfs(int cur, int par, int dept) {
totson[cur] = subtree[cur][dept % k] = 1;
for (int i = 0; i < G[cur].size(); i++) {
int son = G[cur][i];
if (son == par) continue;
dfs(son, cur, dept + 1);
for (int a = 0; a < k; a++) {
for (int b = 0; b < k; b++) {
int dis = subtract(a + b, 2 * dept);
int needs = subtract(k, dis);
ans += (long long)needs * subtree[cur][a] * subtree[son][b];
}
}
totson[cur] += totson[son];
for (int j = 0; j < k; j++) subtree[cur][j] += subtree[son][j];
}
ans += (long long)totson[cur] * (n - totson[cur]);
}
int main() {
ans = 0;
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, -1, 0);
ans /= k;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum, n;
while (cin >> n) {
sum = 1;
string name[405];
string str;
for (int i = 0; i < n; i++) {
cin >> str;
int len = str.size();
for (int j = len - 1; j >= 0; j--) {
if (str[j] == 'o' && str[j - 1] == 'o') {
str[j - 1] = 'u';
continue;
}
if (str[j] == 'o' && str[j - 1] == 'u') {
str[j] = 'u';
str[j - 1] = 'o';
}
if (str[j] == 'h' && j > 0 && str[j - 1] == 'k') {
str[j - 1] = 'h';
continue;
}
name[i] += str[j];
}
}
sort(name, name + n);
for (int i = 0; i < n - 1; i++) {
if (name[i] != name[i + 1]) sum++;
}
cout << sum << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10e10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int _ = 0; _ < t; ++_) {
bool pos = true;
int now = 1;
int n;
cin >> n;
vector<int> been(n + 1);
been.assign(n + 1, 0);
vector<int> q(n);
vector<int> ans(n);
for (int i = 0; i < n; ++i) {
cin >> q[i];
if (i == 0) {
ans[0] = q[i];
++been[q[i]];
} else if (q[i - 1] != q[i]) {
ans[i] = q[i];
++been[q[i]];
} else if (q[i - 1] == q[i]) {
for (int j = now; j <= n; ++j) {
if (j > q[i]) {
pos = false;
break;
} else if (been[j] == 0) {
++been[j];
ans[i] = j;
now = j + 1;
break;
}
}
}
}
if (pos) {
for (int i = 0; i < n; ++i) {
cout << ans[i] << " ";
}
cout << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000;
const long long MOD = 998244353;
long long dp[MAXN][MAXN], a[MAXN][MAXN], dpp, xp, xpp, yp, ypp;
int n, m, cnt;
pair<long long, long long> id[MAXN * MAXN];
long long pw(long long a, long long b) {
if (b == 0) return 1LL;
return pw(a * a % MOD, b / 2) * (b % 2 ? a : 1LL) % MOD;
}
bool cmp(pair<int, int> x, pair<int, int> y) {
return a[x.first][x.second] < a[y.first][y.second];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j], id[cnt++] = make_pair(i, j);
sort(id, id + cnt, cmp);
int pt = 0;
for (int i = 0, pt = 0; i < cnt; i = pt = pt + 1) {
while (a[id[i].first][id[i].second] ==
a[id[pt + 1].first][id[pt + 1].second])
pt++;
for (int j = i; j <= pt; j++) {
long long x = id[j].first, y = id[j].second;
dp[x][y] = ((x * x * i % MOD + y * y * i % MOD + dpp - 2 * x * xp % MOD -
2 * y * yp + xpp + ypp) %
MOD +
MOD) %
MOD;
dp[x][y] = dp[x][y] * pw(i, MOD - 2) % MOD;
}
for (int j = i; j <= pt; j++) {
long long x = id[j].first, y = id[j].second;
dpp = (dpp + dp[x][y]) % MOD;
xp = (xp + x) % MOD;
yp = (yp + y) % MOD;
xpp = (xpp + x * x) % MOD;
ypp = (ypp + y * y) % MOD;
}
}
long long r, c;
cin >> r >> c;
cout << dp[r][c] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct date {
int m, d, h, min, s;
};
struct date a[100000];
const int mon[13] = {0, 31, 60, 91, 121, 152, 182,
213, 244, 274, 305, 335, 366};
int m, c;
char st[5000005];
int getsec(struct date *x) {
int t;
t = mon[x->m - 1] * 3600 * 24;
t += (x->d - 1) * 3600 * 24;
t += x->h * 3600;
t += x->min * 60;
t += x->s;
return t;
}
int cmp(int p1, int p2, int m) {
int t1, t2;
t1 = getsec(&a[p1]);
t2 = getsec(&a[p2]);
if (t1 - t2 + 1 <= m) return 1;
return 0;
}
int main() {
int i = 0, flag = 0;
scanf("%d%d\n", &m, &c);
while (gets(st) != NULL) {
++i;
sscanf(st, "2012-%d-%d %d:%d:%d", &a[i].m, &a[i].d, &a[i].h, &a[i].min,
&a[i].s);
if (i >= c && cmp(i, i - c + 1, m)) {
printf("2012-%02d-%02d %02d:%02d:%02d\n", a[i].m, a[i].d, a[i].h,
a[i].min, a[i].s);
flag = 1;
break;
}
}
if (flag == 0) printf("-1\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[500000], b[500000];
int c[500000], need[500000];
int main() {
int i;
int m, k, n, s;
scanf("%d %d %d %d", &m, &k, &n, &s);
for (i = 0; i < m; i++) scanf("%d", &a[i]), a[i]--;
for (i = 0; i < s; i++) scanf("%d", &b[i]), b[i]--, need[b[i]]++;
int j = 0, l, no = 0;
for (i = 0; i < 500000; i++) {
if (need[i] > 0) no++;
}
for (i = 0; i < m; i++) {
if (need[a[i]] - 1 == c[a[i]]) no--;
c[a[i]]++;
;
;
while ((j <= i) && (no == 0)) {
if (need[a[j]] == c[a[j]]) no++;
c[a[j]]--;
j++;
};
if (j > 0) {
int s = j - 1;
s = min(s, i - k + 1);
if ((s / k + (m - i - 1) / k) >= n - 1) {
vector<int> del;
int d = s % k;
for (l = 0; l < s; l++) {
if (l < d) del.push_back(l);
}
memset(c, 0, sizeof(c));
d = (i - s + 1) - k;
for (l = s; l <= i; l++) {
if ((d > 0) && (need[a[l]] == c[a[l]]))
del.push_back(l), d--;
else
c[a[l]]++;
}
printf("%d\n", del.size());
for (l = 0; l < del.size(); l++) printf("%d ", del[l] + 1);
printf("\n");
return 0;
}
}
}
printf("-1\n");
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define se second
#define ll long long
#define mod 1000000007
using namespace std;
int n,m;
int c[109],b[109];
int smb[109],ssb[109];
int f[109][10009],sf[109][10009],g[10009];
int pt[109],smc[109];
pii q[100009];
int ans[100009];
int mo(int x)
{
f[0][0]=1;
for(int i=1;i<=n;i++)
{
int mn=i*x+ssb[i-1],lp=0,sm=0;
for(int j=0;j<=smc[i];j++)
{
(sm+=f[i-1][j])%=mod;
(lp<j-c[i])&&((sm+=mod-f[i-1][lp])%=mod);
lp+=(lp<j-c[i]);
// printf("i:%d j:%d lp:%d sm:%d\n",i,j,lp,sm);
f[i][j]=j>=mn?sm:0;
}
}
int ans=0;
for(int i=0;i<=smc[n];i++)
ans=(ans+f[n][i])%mod;
return ans;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",c+i);
smc[i]=smc[i-1]+c[i];
}
for(int i=1;i<=n-1;i++)
{
scanf("%d",b+i);
smb[i]=smb[i-1]+b[i];
ssb[i]=ssb[i-1]+smb[i];
}
scanf("%d",&m);
for(int i=1;i<=m;i++)
{
scanf("%d",&q[i].fi);
q[i].se=i;
}
sort(q+1,q+m+1);
for(int k=1;k<=1000;k++)
for(int i=1;i<=m;i++)
ans[q[i].se]=mo(q[i].fi);
for(int i=1;i<=m;i++)
printf("%d\n",ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v1[100005];
vector<int> adj[100005];
void addEdge(int x, int y) {
adj[x].push_back(y);
adj[y].push_back(x);
}
int indexes = 0;
bool visited[100005];
void dfs(int node) {
visited[node] = true;
v1[indexes].push_back(node);
for (int i = 0; i < adj[node].size(); i++) {
if (visited[adj[node][i]] == false) dfs(adj[node][i]);
}
}
int main() {
memset(visited, false, sizeof(visited));
int n;
cin >> n;
int arr1[n];
int arr2[n];
map<int, int> m1;
for (int i = 0; i < n; i++) {
cin >> arr1[i];
arr2[i] = arr1[i];
m1[arr1[i]] = i + 1;
}
sort(arr2, arr2 + n);
for (int i = 0; i < n; i++) {
arr1[i] = m1[arr1[i]];
arr2[i] = m1[arr2[i]];
addEdge(arr1[i], arr2[i]);
}
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
dfs(i);
indexes++;
}
}
cout << indexes << endl;
for (int i = 0; i < indexes; i++) {
cout << v1[i].size() << " ";
for (int j = 0; j < v1[i].size(); j++) cout << v1[i][j] << " ";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#define N 500005
using namespace std;
int arr[N],f[N],l[N],c[N],dp[N];
int main(){
int n;
cin >> n;
for(int i=1;i<=n;i++){
cin >> arr[i];
if(!f[arr[i]])f[arr[i]] = i;
l[arr[i]] = i;
}
for(int i=n;i;i--){
dp[i] = max(dp[i+1],(i==f[arr[i]])*dp[l[arr[i]]+1]+(++c[arr[i]]));
}
cout << n-dp[1];
}
| 5 |
#include <bits/stdc++.h>
#define int long long
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
signed main(){
int q;
map<string,int>m;
cin>>q;
while(q--){
int t,y;
string x;
cin>>t;
if(t==0){
cin>>x>>y;
m[x]=y;
}
if(t==1){
cin>>x;
if(m.count(x))cout<<m[x]<<endl;
else cout<<0<<endl;
}
if(t==2){
cin>>x;
m.erase(x);
}
if(t==3){
string l,r;
cin>>l>>r;
map<string,int>::iterator end,it;
it=m.lower_bound(l);
end=m.upper_bound(r);
for(;it!=end;it++){
cout<<(*it).first<<' '<<(*it).second<<endl;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, bool> f;
int a, b[200010], k, i, n, m;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
f[a] = 1;
}
for (i = 1; i <= k; i++) {
if (f[i]) continue;
k -= i;
m++;
b[m] = i;
}
cout << m << endl;
for (i = 1; i <= m; i++) printf("%d ", b[i]);
}
| 3 |
#include <bits/stdc++.h>
const int MXN = 1000010;
int da[MXN], db[MXN];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) db[i] = n - 1;
while (m--) {
int a, b;
scanf("%d %d", &a, &b);
da[a]++, da[b]++;
db[a]--, db[b]--;
}
long long ans = -(long long)n * (n - 1) * (n - 2) / 6;
for (int i = 1; i <= n; i++) {
ans += (long long)da[i] * (da[i] - 1) / 2;
ans += (long long)db[i] * (db[i] - 1) / 2;
}
printf("%I64d\n", ans / 2);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2, s3;
int main() {
cin >> s1 >> s2 >> s3;
for (int i = 0; i < s3.size(); i++) {
for (int j = 0; j < s1.size(); j++) {
if (s3[i] + 32 == s1[j]) {
s3[i] = (s2[j] - 32);
break;
} else if (s3[i] == s1[j]) {
s3[i] = s2[j];
break;
}
}
}
cout << s3;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int i, j, k;
string s;
cin >> s;
vector<int> a[26];
for (i = 0; i < s.length(); i++) {
a[s[i] - 'a'].push_back(i);
}
int first = 0, lastcount = 0;
for (i = 25; i >= 0; i--) {
if (a[i].size() != 0) {
if (!first) {
for (j = 0; j < a[i].size(); j++) cout << char(i + 'a');
first = 1;
lastcount = a[i][a[i].size() - 1];
} else {
for (j = 0; j < a[i].size(); j++) {
if (a[i][j] > lastcount) {
cout << char(i + 'a');
lastcount = a[i][j];
}
}
}
}
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[202];
multiset<int> S1, S2;
int n, k, sol;
int sum[202];
int main() {
cin >> n >> k;
sol = -10002;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sol = max(sol, a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int st = 1; st <= n; ++st) {
S1.clear();
S2.clear();
for (int j = 1; j <= n; ++j) S2.insert(a[j]);
for (int dr = st; dr <= n; ++dr) {
S1.insert(a[dr]);
S2.erase(S2.find(a[dr]));
int s = sum[dr] - sum[st - 1];
set<int>::iterator it1 = S1.begin();
set<int>::reverse_iterator it2 = S2.rbegin();
for (int op = 1; op <= k && it1 != S1.end() && it2 != S2.rend();
++op, ++it1, ++it2) {
int x = *it1;
int y = *it2;
if (x < y) s += y - x;
}
sol = max(sol, s);
}
}
cout << sol << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
vector<int> G[MAX];
int color[MAX];
int a[MAX], b[MAX];
void dfs(int v, int c) {
color[v] = c;
for (int i = 0; i < G[v].size(); i++) {
if (color[G[v][i]] != 0) continue;
color[G[v][i]] = -c;
dfs(G[v][i], -c);
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i], &b[i]);
G[a[i]].push_back(b[i]);
G[b[i]].push_back(a[i]);
}
for (int i = 1; i <= 2 * n; i += 2) {
G[i].push_back(i + 1);
G[i + 1].push_back(i);
}
for (int i = 1; i <= 2 * n; i++) {
if (color[i]) continue;
dfs(i, 1);
}
for (int i = 0; i < n; i++) {
if (color[a[i]] == 1)
cout << "1 2" << endl;
else
cout << "2 1" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, -1, 0, 1, 1, -1, -1, 1};
bool a[2010][2010];
int n;
int kp;
short x[4000010], y[4000010];
bool u[2010][2010];
int s[2010][2010];
void dfs(int cx, int cy) {
x[kp] = cx;
y[kp] = cy;
u[cx][cy] = true;
kp++;
for (int q = 0; q < (int)(4); q++) {
int nx = cx + dx[q];
int ny = cy + dy[q];
if (nx >= 0 && ny >= 0 && nx < n && ny < n)
if (a[nx][ny] && !u[nx][ny]) dfs(nx, ny);
}
}
bool isBorder(int cx, int cy) {
if (cx == 0 || cy == 0 || cx == n - 1 || cy == n - 1) return true;
for (int q = 0; q < (int)(4); q++) {
int nx = cx + dx[q];
int ny = cy + dy[q];
if (a[nx][ny] == 0) return true;
}
return false;
}
int main() {
scanf("%d", &n);
int z;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) {
scanf("%d", &z);
a[i][j] = z;
}
for (int i = 1; i < n - 1; i++)
for (int j = 1; j < n - 1; j++) {
int cnt = 0;
for (int q = 0; q < (int)(8); q++) {
cnt += a[i + dx[q]][j + dy[q]];
}
if (cnt < 2) a[i][j] = 0;
if (cnt > 6) a[i][j] = 1;
}
for (int q = 0; q < (int)(1); q++) {
for (int i = 0; i < (int)(n + 5); i++)
for (int j = 0; j < (int)(n + 5); j++)
s[i + 1][j + 1] = s[i + 1][j] + s[i][j + 1] - s[i][j] + a[i][j];
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) {
if (i < 3 || j < 3)
a[i][j] = 0;
else {
int ss = s[i + 4][j + 4] - s[i + 4][j - 3] - s[i - 3][j + 4] +
s[i - 3][j - 3];
a[i][j] = ss > 24;
}
}
}
int ci = 0, sq = 0;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
if (a[i][j] && !u[i][j]) {
kp = 0;
dfs(i, j);
if (kp < 50) continue;
double sx = 0, sy = 0;
for (int i = 0; i < (int)(kp); i++) {
sx += x[i];
sy += y[i];
}
sx /= kp, sy /= kp;
double maxD = -1, minD = 1e9;
for (int i = 0; i < (int)(kp); i++) {
if (!isBorder(x[i], y[i])) continue;
double d = (x[i] - sx) * (x[i] - sx) + (y[i] - sy) * (y[i] - sy);
if (d < minD) minD = d;
if (d > maxD) maxD = d;
}
if (maxD / minD < 1.5)
ci++;
else
sq++;
}
printf("%d %d\n", ci, sq);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void in(T &x) {
x = 0;
int fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
x *= fl;
}
template <typename T>
void out(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x / 10) out(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void outln(T x) {
out(x);
putchar(10);
}
template <typename T>
inline void outsp(T x) {
out(x);
putchar(' ');
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a > b) {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
} else {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int N = 200005;
int n, h, l[N], r[N], ans, nowr = 2;
void move(int &R, int H) {
if (R < l[nowr]) {
int t = min(l[nowr] - R, H);
R += t;
H -= t;
}
while (H) {
R = r[nowr];
int t = min(l[nowr + 1] - R, H);
;
R += t;
H -= t;
nowr++;
}
}
int main() {
in(n);
in(h);
for (int i = (1); i <= (n); i++) in(l[i]), in(r[i]);
l[n + 1] = r[n + 1] = 2e9 + 5;
int L = l[1], R = r[1];
move(R, h);
ans = max(ans, R - L);
for (int i = (2); i <= (n); i++) {
L = l[i];
move(R, l[i] - r[i - 1]);
ans = max(ans, R - L);
}
outln(ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T __sqr(const T x) {
return x * x;
}
template <class T, class X>
inline T __pow(T a, X y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= a;
}
return z;
}
template <class T>
inline T gcd(T a, T b) {
a = abs(a);
b = abs(b);
if (!b) return a;
return __gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / __gcd(a, b)) * b;
}
inline bool ispow2(int x) { return (x != 0 && (x & (x - 1)) == 0); }
template <class T>
void UpdateMin(T &x, T y) {
if (y < x) {
x = y;
}
}
template <class T>
void UpdateMax(T &x, T y) {
if (x < y) {
x = y;
}
}
template <class T, class X, class Y>
inline T bigmod(T n, X m, Y mod) {
unsigned long long ret = 1, a = n % mod;
while (m) {
if (m & 1) ret = (ret * a) % mod;
m >>= 1;
a = (a * a) % mod;
}
ret %= mod;
return (T)ret;
}
template <class T, class Y>
inline T modinv(T n, Y mod) {
return bigmod(n, mod - 2, mod);
}
template <class T, class X>
int getbit(T s, X i) {
return (s >> i) & 1;
}
template <class T, class X>
T onbit(T s, X i) {
return s | (T(1) << i);
}
template <class T, class X>
T offbit(T s, X i) {
return s & (~(T(1) << i));
}
template <class T>
inline void read(T &n) {
char c;
for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar())
;
n = c - '0';
for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
void extended_euclid(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
long long first, second;
extended_euclid(b, a % b, first, second);
x = second;
y = first - (a / b) * second;
}
pair<long long, pair<long long, long long> > extendedEuclid(long long a,
long long b) {
long long x = 1, y = 0;
long long xLast = 0, yLast = 1;
long long q, r, m, n;
while (a != 0) {
q = b / a;
r = b % a;
m = xLast - q * x;
n = yLast - q * y;
xLast = x, yLast = y;
x = m, y = n;
b = a, a = r;
}
return make_pair(b, make_pair(xLast, yLast));
}
const long long mod[] = {0, 1000000007, 1000000009,
1000000021, 1000000033, 1000000097,
1000000093, 1000000097, 1000000103};
const long long base[] = {0, 1000003, 1000033, 1000037, 1000039,
1000081, 1000099, 1000117, 1000121};
char str[(100000 + 20)];
int node[30][4 * (100000 + 20)];
int lazy[30][4 * (100000 + 20)];
void build(int id, int s, int e) {
if (s == e) {
for (int i = 1; i <= 26; i++) {
int ch = i;
node[ch][id] = ((str[s] - 'a' + 1) == ch);
;
}
return;
}
int m = (s + e) / 2;
int lf = 2 * id, rg = 2 * id + 1;
build(lf, s, m);
build(rg, m + 1, e);
for (int i = 1; i <= 26; i++) {
int ch = i;
node[ch][id] = node[ch][lf] + node[ch][rg];
}
}
void update_lazy(int ch, int id, int s, int m, int e, int lf, int rg) {
if (s == e) return;
node[ch][lf] = (node[ch][id] ? (m - s + 1) : 0);
node[ch][rg] = (node[ch][id] ? (e - (m + 1) + 1) : 0);
lazy[ch][id] = 0;
lazy[ch][lf] = lazy[ch][rg] = 1;
}
int query(int ch, int id, int s, int e, int st, int ed) {
if (ed < st) return 0;
if (s == st && e == ed) return node[ch][id];
int m = (s + e) / 2;
int lf = 2 * id, rg = 2 * id + 1;
if (lazy[ch][id]) update_lazy(ch, id, s, m, e, lf, rg);
int ret;
if (ed <= m) {
ret = query(ch, lf, s, m, st, ed);
} else if (st > m) {
ret = query(ch, rg, m + 1, e, st, ed);
} else {
int r1 = query(ch, lf, s, m, st, m);
int r2 = query(ch, rg, m + 1, e, m + 1, ed);
ret = r1 + r2;
}
return ret;
}
void update(int ch, int id, int s, int e, int st, int ed, int val) {
if (ed < st) return;
if (s == st && e == ed) {
node[ch][id] = val * (e - s + 1);
lazy[ch][id] = 1;
return;
}
int m = (s + e) / 2;
int lf = 2 * id, rg = 2 * id + 1;
if (lazy[ch][id]) update_lazy(ch, id, s, m, e, lf, rg);
if (ed <= m)
update(ch, lf, s, m, st, ed, val);
else if (st > m)
update(ch, rg, m + 1, e, st, ed, val);
else {
update(ch, lf, s, m, st, m, val);
update(ch, rg, m + 1, e, m + 1, ed, val);
}
node[ch][id] = node[ch][lf] + node[ch][rg];
}
int n, q;
void res() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 26; j++) {
if (query(j, 1, 1, n, i, i)) {
printf("%c", 'a' + j - 1);
break;
}
}
}
puts("");
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s", str + 1);
build(1, 1, n);
int x, y, tp;
for (int i = 1; i <= q; i++) {
scanf("%d%d%d", &x, &y, &tp);
int tot = 0;
for (int j = 1; j <= 26; j++) {
int ch = j;
int q = query(ch, 1, 1, n, x, y);
update(ch, 1, 1, n, x, y, 0);
if (tp)
update(ch, 1, 1, n, x + tot, x + tot + q - 1, 1);
else
update(ch, 1, 1, n, y - tot - q + 1, y - tot, 1);
tot += q;
}
}
res();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[105][105];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
scanf("%1d", &a[i][j]);
}
}
int ans = 0;
int t = 0;
for (int i = 0; i < m; i++) {
int flag = 0;
for (int j = 0; j < n; j++) {
if (a[i][j] == 0) {
flag = 1;
break;
}
}
if (flag)
t++;
else
t = 0;
ans = max(ans, t);
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int A1, A2, A3, A4;
int main() {
int i;
scanf("%d%d%d%d", &A1, &A2, &A3, &A4);
if (abs(A3 - A4) > 1)
printf("-1");
else {
if (A3 == A4) {
if ((((A1) > (A2) ? (A1) : (A2)) - A3 - 1 < 0) ||
(((A1) < (A2) ? (A1) : (A2)) < A3))
printf("-1");
else {
if (A1 - A3 - 1 < 0) {
for (i = 1; i <= A3; ++i) printf("74");
for (i = A2 - A3; i >= 1; --i) printf("7");
} else {
for (i = A1 - A3 - 1; i >= 1; --i) printf("4");
for (i = 1; i <= A3; ++i) printf("47");
for (i = A2 - A3; i >= 1; --i) printf("7");
printf("4");
}
}
} else {
if (A3 > A4) {
if ((A1 - A3 < 0) || (A2 - A3 < 0))
printf("-1");
else {
for (i = A1 - A3; i >= 1; --i) printf("4");
for (i = 1; i <= A3; ++i) printf("47");
for (i = A2 - A3; i >= 1; --i) printf("7");
}
} else {
if ((A1 - A3 - 1 < 0) || (A4 - 2 < 0) || (A2 - A3 < 0))
printf("-1");
else {
printf("74");
for (i = A1 - A3 - 1; i >= 1; --i) printf("4");
for (i = A4 - 2; i >= 1; --i) printf("74");
for (i = A2 - A3; i >= 1; --i) printf("7");
printf("4");
}
}
}
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 100000;
void solve() {
int n;
cin >> n;
int a[101];
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
int ele;
cin >> ele;
a[ele]++;
}
int cnt = 0, sum = 0;
for (int i = 0; i <= 101; i++) {
if (a[i] >= 2)
continue;
else if (a[i] == 1) {
if (cnt == 0) {
sum += i;
cnt = 1;
}
} else {
if (cnt == 0)
sum += 2 * i;
else
sum += i;
break;
}
}
cout << sum << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
int uno = 0, dos = 0;
for (int i = 0; i < N; i++) {
int tmp;
cin >> tmp;
if (tmp == 1)
uno++;
else
dos++;
}
if (uno && dos) {
cout << 2 << ' ' << 1 << ' ';
uno--;
dos--;
for (int i = 0; i < dos; i++) cout << 2 << ' ';
for (int i = 0; i < uno; i++) cout << 1 << ' ';
cout << '\n';
} else if (!uno) {
while (dos--) {
cout << "2 ";
}
cout << '\n';
} else {
while (uno--) {
cout << "1 ";
}
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5100;
const long long M = 15;
const long long mod = 1e9 + 7;
const long long MOD = 998244353;
const long long P = 1336;
const long double eps = 0.000000001;
const long long inf = 1e9;
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
long long w[N], b[N], a[N], dp[N], u[N];
vector<long long> nom[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
long long n, k, V;
cin >> n >> k >> V;
long long sum = 0;
if (V == 0) {
cout << "YES" << '\n';
cout << inf << " 1 2";
return 0;
}
for (long long i = 0; i < n; i++) {
cin >> w[i];
sum += w[i];
b[i] = w[i] % k;
a[i] = w[i] - b[i];
if (a[i] > V) a[i] = V / k * k;
}
if (sum < V) {
cout << "NO";
return 0;
}
dp[0] = 1;
for (long long i = 0; i < n; i++) {
for (long long j = k; j >= 0; j--) {
if (dp[j] != 1) continue;
long long per = (j + b[i]) % k;
if (per == 0) per = k;
if (dp[per]) continue;
dp[per] = 2;
for (auto to : nom[j]) {
nom[per].push_back(to);
}
nom[per].push_back(i);
}
for (long long j = k; j >= 0; j--) {
if (dp[j] == 2) dp[j] = 1;
}
}
for (long long i = 0; i < n; i++) {
long long need = (V - a[i]) % k;
if (need == 0) need = k;
if (!dp[need] && need != k) continue;
long long no = -1;
vector<pair<long long, pair<long long, long long> > > g;
for (long long j = 0; j < n; j++) {
u[j] = 0;
}
for (auto to : nom[need]) {
u[to] = 1;
}
if (u[i] == 0 && need != k) continue;
long long s = 0;
for (auto to : nom[need]) {
u[to] = 1;
if (to == i) {
s += w[i];
continue;
}
g.push_back({inf, {to, i}});
s += w[to];
}
long long e = -1;
for (long long j = 0; j < n; j++) {
if (u[j]) continue;
e = j;
}
if (s < V) {
need = (V - s) / k;
for (long long j = 0; j < n; j++) {
if (u[j] || j == e) continue;
long long c = w[j] / k;
if (w[j] % k) c++;
if (c) g.push_back({c, {j, e}});
w[e] += w[j];
}
long long c = w[e] / k;
if (c < need) continue;
g.push_back({need, {e, i}});
}
if (s > V) {
need = (s - V) / k;
if (i)
g.push_back({need, {i, 0}});
else
g.push_back({need, {i, 1}});
}
cout << "YES" << '\n';
for (auto to : g) {
cout << to.first << " " << to.second.first + 1 << " "
<< to.second.second + 1 << '\n';
}
return 0;
}
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
set<int> g[N];
int d[N], len[N];
queue<int> q;
int ans[N];
int main() {
cin >> n;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
g[u].insert(v);
g[v].insert(u);
d[u]++;
d[v]++;
}
for (int i = 1; i <= n; i++)
if (d[i] == 1) q.push(i), len[i] = 1;
int siz = q.size();
for (int i = siz; i <= n; i++) ans[i] = n;
int now = siz;
while (!q.empty()) {
int u = q.front();
q.pop();
if (g[u].empty()) break;
int v = *g[u].begin();
if (len[v] || g[v].size() > 2) {
g[u].erase(v);
g[v].erase(u);
now--;
ans[now] = ans[now + 1] - len[u];
} else {
g[u].erase(v);
g[v].erase(u);
len[v] = len[u] + 1;
q.push(v);
}
}
ans[1] = 1;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MOD = 998244353;
using namespace std;
bool sortcol(const vector<int>& v1, const vector<int>& v2) {
return v1[1] < v2[1];
}
long long int power(long long int a, long long int n) {
long long int res = 1;
while (n) {
if (n % 2) {
res = (res * a) % MOD;
}
n >>= 1;
a = (a * a) % MOD;
}
return res;
}
long long int ncr(long long int n, long long int r) {
if (n == 1 || r == 0) return 1;
if (r > n / 2) r = n - r;
long long int ans = 1;
for (long long int i = 1; i <= r; i++) {
ans = ((ans * n) / i);
n--;
}
return ans;
}
long long int ncrsum(long long int n, long long int r, long long int mod) {
if (n == 1 || r == 0) return 1;
}
const int maxn = 4e5 + 100;
vector<int> v[maxn];
long long int dis[maxn] = {0};
long long int vis[maxn] = {0};
long long int col[maxn] = {0};
long long int C[2] = {0};
long long int dfs(long long int node, long long int c) {
vis[node] = 1;
C[c]++;
col[node] = c;
for (auto child : v[node]) {
if (vis[child] == 0) {
long long int code = dfs(child, c ^ 1);
if (code == -1) return -1;
} else {
if (col[node] == col[child]) return -1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n, i1, i2, k, m, j, j1, a1, i31, i3, j2, i5, i4, i6, i7, i;
long long int x, y, z;
long long int total = 0, cnt = 0;
long long int flag = 0;
y = 0;
long long int res, res1, ans, res2, q;
ans = 0;
res1 = 0, res = 1;
long long int s1, s2, s3;
s2 = 0;
long long int sum = 0;
s1 = 0;
long long int k1, k2, k3;
long long int d;
string s;
cin >> n >> m;
for (i = 1; i <= n; i++) {
v[i].clear();
vis[i] = 0;
col[i] = 0;
}
for (i = 1; i <= m; i++) {
long long int x1, x2;
cin >> x1 >> x2;
v[x1].push_back(x2);
v[x2].push_back(x1);
}
bool f1 = true;
for (i = 1; i <= n; i++) {
if (vis[i] == 0) {
C[1] = C[0] = 0;
x = dfs(i, 0);
if (x == -1) {
f1 = false;
break;
}
res = (res * (power(2, C[0]) + power(2, C[1]))) % MOD;
}
}
if (f1 == false)
cout << 0 << "\n";
else
cout << res << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v2d = vector<vector<T>>;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 1e2 + 10;
int n, a[4][maxN][maxN], ans = 1e9;
;
void cal(int board, pair<int, int> &ans) {
ans.first = ans.second = 0;
for (int i = 1; i <= (int)(n); ++i) {
for (int j = 1; j <= (int)(n); ++j) {
if ((i + j) % 2 == 0) {
ans.first += (a[board][i][j] != 0);
} else {
ans.first += (a[board][i][j] != 1);
}
}
}
for (int i = 1; i <= (int)(n); ++i) {
for (int j = 1; j <= (int)(n); ++j) {
if ((i + j) % 2 == 0) {
ans.second += (a[board][i][j] != 1);
} else {
ans.second += (a[board][i][j] != 0);
}
}
}
}
void solve() {
cin >> n;
for (int board = 0; board < (int)(4); ++board) {
for (int i = 1; i <= (int)(n); ++i) {
for (int j = 1; j <= (int)(n); ++j) {
char c;
cin >> c;
a[board][i][j] = c - '0';
}
}
}
vector<pair<int, int>> vec(4);
for (int board = 0; board < (int)(4); ++board) {
cal(board, vec[board]);
cerr << vec[board].first << ' ' << vec[board].second << '\n';
}
vector<int> per(4);
iota((per).begin(), (per).end(), 0);
for (int iter = 1; iter <= (int)(24); ++iter) {
int cur = vec[per[0]].first + vec[per[1]].first + vec[per[2]].second +
vec[per[3]].second;
uin(ans, cur);
next_permutation((per).begin(), (per).end());
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
int n;
int mat[2002][2002];
int rmat[2002][2002];
int vis[2002];
stack<int> f;
void dfs(int u) {
vis[u] = 1;
for (int i = 0; i < (n); i++) {
if (mat[u][i])
if (vis[i] == 0) dfs(i);
}
f.push(u);
}
void dfsr(int u) {
vis[u] = 0;
for (int i = 0; i < (n); i++) {
if (rmat[u][i])
if (vis[i] == 1) dfsr(i);
}
}
int main() {
scanf("%d", &n);
;
bool zero = false;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) {
scanf("%d", &mat[i][j]);
;
rmat[j][i] = mat[i][j];
}
memset((vis), (0), sizeof((vis)));
for (int i = 0; i < (n); i++) {
if (mat[i][i] > 0) {
dfs(i);
for (int i = 0; i < (n); i++) {
if (vis[i] == 0) {
zero = true;
}
}
dfsr(f.top());
for (int i = 0; i < (n); i++) {
if (vis[i] == 1) {
zero = true;
}
}
break;
}
}
if (!zero)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int L[550], R[550], w[550], s[550], val[550];
int id[550];
bool cmp(int u, int v) { return R[u] - L[u] < R[v] - L[v]; }
bool cmp1(int u, int v) { return L[u] < L[v]; }
int dp[550][1010];
int sum[550 << 1];
int main() {
int n, S;
gn(n, S);
for (int i = 0; i < n; i++) {
gn(L[i], R[i]);
gn(w[i], s[i], val[i]);
id[i] = i;
}
id[n] = n;
L[n] = 0, R[n] = n * 2 - 1, w[n] = 0, s[n] = S, val[n] = 0;
n++;
sort(id, id + n, cmp);
for (int i = 0; i < n; i++) {
int u = id[i];
sort(id, id + i, cmp1);
for (int j = 0; j <= S; j++) {
int lim = min(j - w[u], s[u]);
if (lim < 0) continue;
int cur = 0;
for (int k = L[u]; k < R[u]; k++) {
smax(sum[k + 1], sum[k]);
while (L[id[cur]] < k && cur < i) cur++;
while (cur < i && L[id[cur]] == k) {
if (R[id[cur]] <= R[u]) {
smax(sum[R[id[cur]]], sum[k] + dp[id[cur]][lim]);
}
cur++;
}
}
int M = 0;
for (int k = L[u]; k <= R[u]; k++) smax(M, sum[k]), sum[k] = 0;
smax(dp[u][j], M + val[u]);
}
for (int j = 1; j <= S; j++) smax(dp[u][j], dp[u][j - 1]);
}
int ans = 0;
for (int i = 0; i < n; i++) smax(ans, dp[i][S]);
println(ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
char s[101];
long long L;
long long AddX = 0, AddY = 0;
long long CurX = 0, CurY = 0;
int main() {
long long i;
long long m1, m2;
scanf("%I64d %I64d", &a, &b);
scanf("%s", s);
L = strlen(s);
for (i = 0; i < L; i++) {
switch (s[i]) {
case 'U':
AddY++;
break;
case 'R':
AddX++;
break;
case 'D':
AddY--;
break;
case 'L':
AddX--;
break;
}
}
if (a == 0 && b == 0) {
printf("Yes\n");
return 0;
}
for (i = 0; i < L; i++) {
switch (s[i]) {
case 'U':
CurY++;
break;
case 'R':
CurX++;
break;
case 'D':
CurY--;
break;
case 'L':
CurX--;
break;
}
if (AddX == 0 && AddY == 0) {
if (CurX == a && CurY == b) {
printf("Yes\n");
return 0;
}
continue;
}
if (AddX == 0) {
if (CurX == a) {
if ((b - CurY) % AddY == 0) {
m1 = (b - CurY) / AddY;
if (m1 >= 0) {
printf("Yes\n");
return 0;
}
}
}
continue;
}
if (AddY == 0) {
if (CurY == b) {
if ((a - CurX) % AddX == 0) {
m1 = (a - CurX) / AddX;
if (m1 >= 0) {
printf("Yes\n");
return 0;
}
}
}
continue;
}
if ((a - CurX) % AddX == 0 && (b - CurY) % AddY == 0) {
m1 = (a - CurX) / AddX;
m2 = (b - CurY) / AddY;
if (m1 == m2 && m1 >= 0) {
printf("Yes\n");
return 0;
}
}
}
printf("No\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, temp, i;
cin >> n >> k;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long int count = 0;
for (i = 0; i < n - 1; i++) {
long long int j = i + 1;
long long int cnt = 1;
while (a[i] == a[j] && j < n) {
j++;
cnt++;
}
if (a[i] + k >= a[j]) {
count = count + cnt;
}
i = j - 1;
}
cout << n - count << endl;
return 0;
}
| 2 |
#include <cstdio>
using namespace std;
long long int x;
long long int ans;
int main(){
scanf("%lld", &x);
ans += x / 11 * 2;
x %= 11;
if(x >= 7) ans += 2;
else if(x != 0) ans ++;
printf("%lld\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100][100010], a[200];
bool vst[100][100010];
long long n;
int k;
long long dfs(int k, long long n) {
if (k == 0) return n - n / a[0];
if (k < 100 && n <= 100000) {
if (vst[k][n]) return dp[k][n];
vst[k][n] = 1;
return dp[k][n] = dfs(k - 1, n) - dfs(k - 1, n / a[k]);
}
return dfs(k - 1, n) - dfs(k - 1, n / a[k]);
}
int main() {
scanf("%I64d%d", &n, &k);
for (int i = 0; i < k; i++) scanf("%d", &a[i]);
sort(a, a + k);
printf("%I64d\n", dfs(k - 1, n));
}
| 5 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define ll long long
#define gmax(x,y) x=max(x,y)
#define gmin(x,y) x=min(x,y)
#define F first
#define S second
#define P pair
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i<b;i++)
#define V vector
#define RE return
#define ALL(a) a.begin(),a.end()
#define MP make_pair
#define PB emplace_back
#define PF push_front
#define FILL(a,b) memset(a,b,sizeof(a))
#define lwb lower_bound
#define upb upper_bound
using namespace std;
int co[200005],n,sum[2];
V<int> v[200005];
void dfs(int p,int fa,int color){
co[p]=color;
sum[co[p]]++;
for(auto u:v[p]){
if(u==fa)continue;
dfs(u,p,color^1);
}
}
int ans[200005];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin>>n;
int x,y;
rep(i,1,n){
cin>>x>>y;
v[x].PB(y);
v[y].PB(x);
}
dfs(1,-1,0);
int l[4];
l[1]=n/3+(n%3>0);
l[2]=n/3+(n%3>1);
l[3]=n/3;
int t[2]={};
if(l[1]<=sum[0]&&l[2]<=sum[1]){
t[0]=1;t[1]=2;
}else if(l[1]<=sum[1]&&l[2]<=sum[0]){
t[1]=1;t[0]=2;
}
if(t[0]){
FOR(i,1,n)ans[i]=t[co[i]],l[t[co[i]]]--;
FOR(i,1,n){
if(co[i]){
if(l[t[1]]<0){
l[t[1]]++;
ans[i]=3;
}
}else{
if(l[t[0]]<0){
l[t[0]]++;
ans[i]=3;
}
}
}
}else{
int lc;
if(l[3]>=sum[0]){
lc=0;
}else lc=1;
FOR(i,1,n){
if(co[i]==lc)ans[i]=3;
else if(l[1]){
l[1]--;ans[i]=1;
}else if(l[2]){
l[2]--;ans[i]=2;
}else ans[i]=3;
}
}
int st[4]={};
FOR(i,1,n){
cout<<st[ans[i]]*3+ans[i]<<' ';
st[ans[i]]++;
}
RE 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll kInf = 1LL << 50;
const int kMax = 150;
int N, Si[kMax];
ll A, B, Ri[kMax];
int sum;
ll f[2][kMax + 1][kMax + 1];
bool fv[2][kMax + 1][kMax + 1];
void read();
void solve();
ll dp(int, int, int);
int main() {
while (cin >> N >> A >> B)
read(), solve();
return 0;
}
void read() {
for (int i = 0; i < N; ++i)
cin >> Ri[i] >> Si[i];
}
void solve() {
int res;
sum = accumulate(&Si[0], &Si[N], 0);
fill(&fv[0][0][0], &fv[2][0][0], false);
for (res = sum; res > 0; --res)
if (dp(0, 0, res) <= A - B)
break;
cout << res << " " << sum - res << "\n";
}
ll dp(int p, int b, int s) {
if (s < 0)
return -kInf;
if (s > sum)
return kInf;
if (fv[p][b][s])
return f[p][b][s];
fv[p][b][s] = true;
if (b == N)
return f[p][N][s] = (s == 0 ? -kInf : kInf);
// alice
if (p == 0) {
f[0][b][s] = dp(0, b, s + 1);
f[0][b][s] = min(f[0][b][s], dp(1, b + 1, s - Si[b]) - Ri[b]);
f[0][b][s] = min(f[0][b][s], max(dp(0, b + 1, s) + Ri[b] + 1, 1LL));
}
// brianna
else {
f[1][b][s] = dp(1, b, s - 1);
f[1][b][s] = max(f[1][b][s], dp(0, b + 1, s) + Ri[b]);
f[1][b][s] = max(f[1][b][s], min(dp(1, b + 1, s - Si[b]) - Ri[b] - 1, 0LL));
}
return f[p][b][s];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 40005;
int n, a, b, ans;
bool f[N][35], vis[N][35];
inline long long fast_pow(long long x, int y) {
long long ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = ret * x;
x = x * x;
}
return ret;
}
bool dfs(int x, int y) {
if (vis[x][y]) return f[x][y];
vis[x][y] = 1;
int now;
if (fast_pow(1ll * x, y) >= n) return f[x][y] = 1;
now = (dfs(x + 1, y) ^ 1) | (dfs(x, y + 1) ^ 1);
if (now) return f[x][y] = 1;
return f[x][y] = 0;
}
int one(int a, int b) {
int ret = 0, tmp = 0;
while (fast_pow(2, b) < n) {
if (!dfs(2, b)) {
if (!tmp)
ret = 1;
else
ret = 2;
break;
}
tmp ^= 1;
b++;
}
return ret;
}
int two(int a, int b) {
int tmp = 0, ret = 0, pre = a;
while (fast_pow(a, 2) < n) {
if (!dfs(a, 2)) {
if (!tmp)
ret = 1;
else
ret = 2;
break;
}
tmp ^= 1;
a++;
}
if (!ret) {
if ((n - 1 - pre) & 1)
ret = 1;
else
ret = 2;
}
return ret;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
if (a == 1 && b == 1) {
int now1 = one(a, b + 1);
if (now1 != 0) now1 = 3 - now1;
int now2 = two(a + 1, b);
now2 = 3 - now2;
if (now1 == 1 || now2 == 1)
puts("Masha");
else if (now1 == 2 && now2 == 2)
puts("Stas");
else
puts("Missing");
return 0;
} else if (a == 1) {
ans = one(a, b);
if (ans == 1)
puts("Masha");
else if (ans == 2)
puts("Stas");
else
puts("Missing");
return 0;
} else if (b == 1) {
ans = two(a, b);
if (ans == 1)
puts("Masha");
else if (ans == 2)
puts("Stas");
return 0;
}
if (dfs(a, b))
puts("Masha");
else
puts("Stas");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const ll INF=0x3f3f3f3f3f3f3f3f;
int n,K;
ll dp[310][310][310];
int h[400];
int main(){
cin>>n>>K;
rep(i,n)scanf("%d",&h[i]);
vector<int>xs{0};
rep(i,n)xs.push_back(h[i]);
sort(xs.begin(),xs.end());
memset(dp,0x3f,sizeof(dp));
dp[0][0][0]=0;
rep(i,n){
int id=lower_bound(xs.begin(),xs.end(),h[i])-xs.begin();
rep(j,K+1)rep(k,xs.size()){
dp[i+1][j][id]=min(dp[i+1][j][id],dp[i][j][k]+max(0,h[i]-xs[k]));
dp[i+1][j+1][k]=min(dp[i+1][j+1][k],dp[i][j][k]);
}
}
ll ans=INF;
rep(i,K+1)rep(j,xs.size())ans=min(ans,dp[n][i][j]);
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int main() {
cin >> N >> M;
int putere = 1;
for (int i = 1; i <= M; i++) {
putere <<= 1;
if (putere >= 1000000009) putere -= 1000000009;
}
int val = 1;
for (int i = putere - 1; i >= putere - N; i--)
val = (1LL * val * i) % 1000000009;
cout << val;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x = "";
bool b = false;
cin >> x;
for (int i = 0; i < x.length(); i++) {
switch (x[i]) {
case 'H':
b = true;
break;
case 'Q':
b = true;
break;
case '9':
b = true;
break;
}
}
if (b) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tests;
scanf("%d", &tests);
for (int test = 1; test <= tests; test++) {
int s, i, e, answer;
scanf("%d%d%d", &s, &i, &e);
if (i + e - s < 0)
answer = e + 1;
else {
int limit = (i + e - s) / 2 + 1;
if (limit > e)
answer = 0;
else
answer = e - limit + 1;
}
printf("%d\n", answer);
}
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int n;
cin >> n;
cout << n*32 <<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define bs binary_search
#define F first
#define S second
#define nl "\n"
#define pll pair<ll, ll>
#define all(v) (v).begin(), (v).end()
#define decimal(n) cout << fixed << setprecision(n)
#define mod 1000000007
// #define mod 998244353
#define pi 3.14159265358979323846
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1, tc;
cin >> t;
for (tc = 1; tc <= t; tc++)
{
ll n,i,j;
cin>>n;
ll a[n+3];
for(i=0;i<n;i++)cin>>a[i];
set<ll> s;
s.insert(a[0]);
bool f=0;
for(i=1;i<n;i++){
ll x=min(a[i],a[i-1]), y=max(a[i-1],a[i]);
auto it=s.ub(x);
if(it!=s.end() && *it<y){
f=1;
break;
}
s.insert(a[i]);
}
cout<<(f?"NO\n":"YES\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const double eps = 1e-1;
const long long mod = 1e9 + 7;
bool check_pow_2(long long n) { return (n & (n - 1) == 0); }
bool is_prime(long long a, long long p) {
for (long long i = 2; i <= sqrt(a) && i <= p; i++)
if (a % i == 0) return false;
return true;
}
long long div_up(long long x, long long y) {
if (x == 0) return 0;
return (x - 1) / y + 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = 0;
for (long long i = 0; i < 61; i++)
if ((n & (1LL << i)) > 0) ans += (1LL << i + 1) - 1;
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const bool testing = true;
void program() {
int n, s, t;
cin >> n >> s >> t;
int x = s;
int y = t;
vector<int> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
int cn = 0;
if (s == t) {
cout << "0" << endl;
return;
}
while (v[x] != t) {
if (v[x] == s) {
cout << "-1" << endl;
return;
} else {
cn++;
x = v[x];
}
}
cout << cn + 1 << endl;
}
int main() {
if (testing) {
program();
return 0;
}
FILE* fin = NULL;
fin = fopen("in.txt", "w+");
fprintf(fin, "4 2 1\n2 3 4 1\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(1) => expected : \n");
printf("3\n");
printf("test case(1) => founded : \n");
program();
fin = fopen("in.txt", "w+");
fprintf(fin, "4 3 3\n4 1 3 2\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(2) => expected : \n");
printf("0\n");
printf("test case(2) => founded : \n");
program();
fin = fopen("in.txt", "w+");
fprintf(fin, "4 3 4\n1 2 3 4\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(3) => expected : \n");
printf("-1\n");
printf("test case(3) => founded : \n");
program();
fin = fopen("in.txt", "w+");
fprintf(fin, "3 1 3\n2 1 3\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(4) => expected : \n");
printf("-1\n");
printf("test case(4) => founded : \n");
program();
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <vector>
#include <string>
#include <queue>
#include <deque>
#include <list>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <bitset>
#include <random>
#include <complex>
#include <assert.h>
using namespace std;
typedef long long ll;
#define endl '\n'
constexpr ll mod = 1000000007LL;
constexpr ll v_e[] = { 869418286, 727008098, 660103155, 183023413, 471090892, 417297686, 237315285, 542573865, 444014759, 927321758, 184117322, 5655049, 347662323, 346175634, 765144583, 0 };
constexpr ll v_o[] = { 869418286, 727008098, 660103155, 183023413, 471090892, 417297686, 237315285, 542573865, 444014759, 927321758, 184117322, 962779130, 404391958, 700407153, 729548371, 539588932 };
int main() {
ios::sync_with_stdio(false);
std::cin.tie(0);
ll T, N, N2, N4, N8; cin >> T;
ll ans0, ans4,ans8, ans12;
for (int _t = 0; _t < T; _t++) {
cin >> N;
N2 = (N * N) % mod;
N4 = (N2 * N2) % mod;
N8 = (N4 * N4) % mod;
if (N & 1) {// odd
ans0 = (((v_o[0] * N + v_o[1]) % mod) * N2 + ((v_o[2] * N + v_o[3]) % mod)) % mod;
ans4 = (((v_o[4] * N + v_o[5]) % mod) * N2 + ((v_o[6] * N + v_o[7]) % mod)) % mod;
ans8 = (((v_o[8] * N + v_o[9]) % mod) * N2 + ((v_o[10] * N + v_o[11]) % mod)) % mod;
ans12 = (((v_o[12] * N + v_o[13]) % mod) * N2 + ((v_o[14] * N + v_o[15]) % mod)) % mod;
cout << (((ans0 * N4 + ans4) % mod) * N8 + ((ans8 * N4 + ans12) % mod)) % mod << endl;
}
else {// even
ans0 = (((v_e[0] * N + v_e[1]) % mod) * N2 + ((v_e[2] * N + v_e[3]) % mod)) % mod;
ans4 = (((v_e[4] * N + v_e[5]) % mod) * N2 + ((v_e[6] * N + v_e[7]) % mod)) % mod;
ans8 = (((v_e[8] * N + v_e[9]) % mod) * N2 + ((v_e[10] * N + v_e[11]) % mod)) % mod;
ans12 = (((v_e[12] * N + v_e[13]) % mod) * N2 + ((v_e[14] * N + v_e[15]) % mod)) % mod;
cout << (((ans0 * N4 + ans4) % mod) * N8 + ((ans8 * N4 + ans12) % mod)) % mod << endl;
}
}
return 0;
}
| 0 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
using namespace std;
#define MOD 1000000007
#define ADD(X,Y) ((X) = ((X) + (Y)%MOD) % MOD)
typedef long long i64; typedef vector<int> ivec; typedef vector<string> svec;
int N, M;
int X[200], Y[200];
int out[200];
i64 dp[1 << 15];
int main()
{
scanf("%d%d", &N, &M);
for (int i = 0; i < M; ++i) {
scanf("%d%d", X + i, Y + i);
--X[i]; --Y[i];
out[X[i]] |= 1 << Y[i];
}
dp[0] = 1;
for (int m = 1; m < (1 << N); ++m) {
dp[m] = 0;
for (int t = m; t > 0; t = (t - 1) & m) {
// choose <t> for nodes with largest grundy number among <m>
if ((t & 3) == 3) continue;
int rem = m ^ t;
i64 pat = dp[rem];
for (int i = 0; i < N; ++i) {
if (!(m & (1 << i))) {
pat = pat * ((1 << __builtin_popcount(out[i] & t)) - 1) % MOD;
}
if (t & (1 << i)) {
pat = pat * (1 << __builtin_popcount(out[i] & ~m)) % MOD;
}
}
ADD(dp[m], pat);
}
}
printf("%lld\n", dp[(1 << N) - 1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;cin>>s;
int ans=0;
for(int i=0;i<s.length()/2;i++){
if(s[i]!=s[(s.length()-1)-i]){
ans++;
}
}
cout<<ans<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int n,m,q;
int one[2010][2010];
int l[2010][2010];
int u[2010][2010];
char grid[2010][2010];
int main()
{
cin>>n>>m>>q;
for(int i=1;i<=n;i++)
{
scanf("%s",grid[i]+1);
for(int j=1;j<=m;j++)
{
one[i][j]=one[i-1][j]+one[i][j-1]-one[i-1][j-1]+(grid[i][j]=='1');
l[i][j]=l[i-1][j]+l[i][j-1]-l[i-1][j-1]+(grid[i][j]=='1'&&grid[i][j-1]=='1');
u[i][j]=u[i-1][j]+u[i][j-1]-u[i-1][j-1]+(grid[i][j]=='1'&&grid[i-1][j]=='1');
}
}
while(q--)
{
int x1,x2,y1,y2;
cin>>x1>>y1>>x2>>y2;
int dots=one[x2][y2]-one[x2][y1-1]-one[x1-1][y2]+one[x1-1][y1-1];
dots-=l[x2][y2]-l[x2][y1]-l[x1-1][y2]+l[x1-1][y1];
dots-=u[x2][y2]-u[x2][y1-1]-u[x1][y2]+u[x1][y1-1];
cout<<dots<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
return (first < second) ? (first = second, 1) : 0;
}
const int MAXN = 15;
vector<int> adj[MAXN];
int N, M;
int possible[1 << MAXN][MAXN][MAXN];
int dp[1 << MAXN];
int dp_from[1 << MAXN];
pair<int, int> in_out_pair[1 << MAXN];
vector<int> one_bit[1 << MAXN];
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; (i) < (M); ++(i)) {
int u, v;
scanf("%d %d", &u, &v);
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(possible, -1, sizeof(possible));
for (int u = 0; (u) < (N); ++(u)) {
for (auto v : adj[u]) {
possible[0][u][v] = u;
}
}
for (int mask = 0; (mask) < (1 << N); ++(mask)) {
for (int first = 0; (first) < (N); ++(first)) {
for (int second = 0; (second) < (N); ++(second)) {
if (possible[mask][first][second] == -1 || first == second) continue;
if (mask & (1 << first)) continue;
if (mask & (1 << second)) continue;
for (auto z : adj[second]) {
if ((1 << z) & mask) continue;
if (z == possible[mask][first][second]) continue;
possible[mask | (1 << second)][first][z] = second;
}
}
}
}
for (int mask = 0; (mask) < (1 << N); ++(mask)) {
for (int j = 0; (j) < (N); ++(j)) {
if (mask & (1 << j)) {
one_bit[mask].push_back(j);
}
}
}
memset(dp_from, -1, sizeof(dp_from));
memset(dp, (0x3f3f3f3f), sizeof(dp));
dp[1] = 0;
for (int mask = 0; (mask) < (1 << N); ++(mask)) {
for (int new_mask = mask; new_mask; new_mask = (new_mask - 1) & mask) {
int p_mask = mask ^ new_mask;
int path_len = __builtin_popcount(new_mask) + 1;
for (auto first : one_bit[p_mask]) {
for (auto second : one_bit[p_mask]) {
if (possible[new_mask][first][second] != -1) {
if (mina(dp[mask], dp[p_mask] + path_len)) {
in_out_pair[mask] = pair<int, int>(first, second);
dp_from[mask] = p_mask;
}
}
}
}
}
}
int ans = dp[(1 << N) - 1];
assert(ans != (0x3f3f3f3f));
cout << ans << endl;
int cur = (1 << N) - 1;
while (dp_from[cur] != -1) {
int p_mask = dp_from[cur];
int first = in_out_pair[cur].first;
int second = in_out_pair[cur].second;
vector<int> path;
int added_mask = cur ^ p_mask;
int ll = -1;
while (added_mask) {
ll = possible[added_mask][first][second];
cout << (ll + 1) << " " << (second + 1) << endl;
added_mask ^= (1 << ll);
second = ll;
}
assert(ll != -1);
cout << (ll + 1) << " " << (first + 1) << endl;
cur = p_mask;
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll n;
cin>>n;
vector<int>v(n);
for(int i=1;i<n;i++){
int a;
cin>>a;
v[a-1]++;
}
for(auto& p:v){
cout<<p<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
multiset<long long> s;
int main() {
int n;
scanf("%d", &n);
long long sum = 0;
while (n--) {
int now;
scanf("%d", &now);
if (!s.empty() && *s.begin() < now) {
sum += now - *s.begin();
s.erase(s.begin());
s.insert(now);
s.insert(now);
} else
s.insert(now);
}
printf("%lld", sum);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long double eps = 1e-12;
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
long long int m = 0, n, res = 0, k, h;
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 x, long long int y) {
return (x * y) / gcd(x, y);
}
string s2, ch = "", s, s1 = "", t;
vector<pair<string, long long int> > vm;
vector<pair<pair<long long int, long long int>, long long int> > vvvl, vvvr;
vector<pair<long long int, long long int> > vv, vv2;
vector<long long int> v[500005];
long long int dp[1000005];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int i = 0, x = 0, z = 0, y = 0, j = 0, q, mx = 0, mm, idx = 0,
ok = 0, l = 0, r = 0, negatif = 0, positif = 0, l1, r1, g = 0,
d;
set<long long int>::iterator it;
cin >> n;
for (i = 1; i <= n; i++) {
for (j = i; j <= (5e5 + i); j += i) {
if (j > i) dp[j] = max(dp[j], i);
}
}
sort(dp + 1, dp + 1 + n);
for (i = 2; i <= n; i++) {
cout << dp[i] << " ";
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define N 50005
#define re register
#define ll long long
#define P 998244353
using namespace std;
bool m1;
int n,m,K;
inline void Rd(int &res){
re char c;res=0;
while(c=getchar(),c<48);
do res=(res<<3)+(res<<1)+(c^48);
while(c=getchar(),c>47);
}
struct Point{
double x,y;
Point operator+(const Point&a)const{return (Point){x+a.x,y+a.y};}
Point operator-(const Point&a)const{return (Point){x-a.x,y-a.y};}
Point operator*(const double&v)const{return (Point){x*v,y*v};}
double operator*(const Point&a)const{return x*a.x+y*a.y;}
double operator^(const Point&a)const{return x*a.y-y*a.x;}
double len(){return sqrt(x*x+y*y);}
}p1,p2,p;
bool m2;
int main(){
scanf("%lf%lf%lf%lf",&p1.x,&p1.y,&p2.x,&p2.y);
Point p3=p2-p1;
double l=p3.len();
int q;Rd(q);
while(q--){
scanf("%lf%lf",&p.x,&p.y);
double l1=((p-p1)*p3)/l;
Point q=p3*(l1/l);
q=p1+q;
printf("%.12lf %.12lf\n",q.x,q.y);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int _N = 1e5 + 11;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
double p[22][22], dp[(1 << 19)][19], res = 0.0;
int n;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
cout << fixed;
cout << setprecision(15);
srand(time(NULL));
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> p[i][j];
}
}
dp[1][0] = 1;
for (int bit = 3; bit < (1 << n); bit += 2) {
for (int i = 0; i < n; i++) {
if (!(bit & (1 << i))) continue;
for (int j = 0; j < n; j++) {
if (i == j || !(bit & (1 << j))) continue;
dp[bit][i] = max(dp[bit][i], p[i][j] * dp[bit ^ (1 << j)][i] +
p[j][i] * dp[bit ^ (1 << i)][j]);
}
}
}
for (int i = 0; i < n; i++) res = max(res, dp[(1 << n) - 1][i]);
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct ComparisonClass {
bool operator()(pair<int, int> lhs, pair<int, int> rhs) {
if (lhs.first != rhs.first)
return lhs.first < rhs.first;
else
return lhs.second > rhs.second;
}
};
int main() {
int n;
cin >> n;
string s;
cin >> s;
sort(s.begin(), s.end());
cout << s << endl;
}
| 1 |
#include <iostream>
#include <complex>
#include <utility>
#include <vector>
using namespace std;
typedef complex<double> Point, Vector;
typedef pair<Point, Point> Segment, Line;
typedef vector<Point> Polygon;
#define X real()
#define Y imag()
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
double cross(Vector a, Vector b){
return a.X * b.Y - a.Y * b.X;
}
double convexArea(Polygon pol){
int n = pol.size();
if(n == 0) return 0.0;
Point basep = pol[0];
double S = 0.0;
for(int i=1; i<n-1; i++){
Vector a = pol[i] - basep;
Vector b = pol[i+1] - basep;
S += cross(a, b) / 2;
}
return S;
}
int main(){
int n; cin>>n;
Polygon pol;
while(n--){
double x, y; cin>>x>>y;
pol.emplace_back(x, y);
}
printf("%.1f\n", convexArea(pol));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int binary_search(vector<int>& v, int istart, int iend, int value) {
int n = v.size();
if (istart > iend)
return 0;
int imid = istart + (iend - istart) / 2;
if (v[imid] > value) {
return binary_search(v, istart, imid - 1, value);
} else if (v[imid] < value) {
return binary_search(v, imid + 1, iend, value);
} else {
return 1;
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> va(n);
for (int i = 0; i < n; i++) {
cin >> va[i];
}
cin >> n;
vector<int> vb(n);
for (int i = 0; i < n; i++) {
cin >> vb[i];
}
bool result = 1;
for (int i = 0; i < n; i++) {
result &= binary_search(va, 0, va.size() - 1, vb[i]);
}
cout << result << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
if (b == 0) return 1;
long long int p = power(a, b / 2);
if (b % 2 == 0)
return p * p;
else
return a * p * p;
}
long int gcd(long int a, long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
std::ios_base::sync_with_stdio(false);
long long int n, i, j, k, c = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
vector<long int> fac;
for (i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (i > 2) fac.push_back(i);
if (n != i * i) fac.push_back(n / i);
}
}
for (i = 0; i < fac.size(); i++) {
for (j = 0; j < n / fac[i]; j++) {
c = 0;
for (k = j; k < n; k += n / fac[i]) {
if (a[k] != 1)
break;
else
c++;
}
if (c == fac[i]) break;
}
if (j != n / fac[i]) break;
}
if (i != fac.size())
cout << "YES";
else
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int INF = 1e9;
int _w;
int n;
char str[N];
bool intersect(int l1, int r1, int l2, int r2) {
int l = max(l1, l2);
int r = min(r1, r2);
return l <= r;
}
bool checkws(int up, int down) {
int upmin = INF;
int upmax = -1;
int downmin = INF;
int downmax = -1;
int x = 0;
if (x == up) {
upmin = min(upmin, 0);
upmax = max(upmax, 0);
}
if (x == down) {
downmin = min(downmin, 0);
downmax = max(downmax, 0);
}
for (int i = 1; i <= n; ++i) {
if (str[i] == 'W') {
++x;
} else if (str[i] == 'S') {
--x;
}
if (x == up) {
upmin = min(upmin, i);
upmax = max(upmax, i);
}
if (x == down) {
downmin = min(downmin, i);
downmax = max(downmax, i);
}
}
return intersect(upmin, upmax, downmin, downmax) ? false : true;
}
bool checkad(int lft, int rait) {
int lftmin = INF;
int lftmax = -1;
int raitmin = INF;
int raitmax = -1;
int y = 0;
if (y == lft) {
lftmin = min(lftmin, 0);
lftmax = max(lftmax, 0);
}
if (y == rait) {
raitmin = min(raitmin, 0);
raitmax = max(raitmax, 0);
}
for (int i = 1; i <= n; ++i) {
if (str[i] == 'A') {
--y;
} else if (str[i] == 'D') {
++y;
}
if (y == lft) {
lftmin = min(lftmin, i);
lftmax = max(lftmax, i);
}
if (y == rait) {
raitmin = min(raitmin, i);
raitmax = max(raitmax, i);
}
}
return intersect(lftmin, lftmax, raitmin, raitmax) ? false : true;
}
void solve() {
int x = 0, y = 0;
int up = 0, down = 0, lft = 0, rait = 0;
for (int i = 1; i <= n; ++i)
if (str[i] == 'W') {
++x;
up = max(up, x);
} else if (str[i] == 'S') {
--x;
down = min(down, x);
} else if (str[i] == 'A') {
--y;
lft = min(lft, y);
} else {
assert(str[i] == 'D');
++y;
rait = max(rait, y);
}
int dx = up - down + 1;
int dy = rait - lft + 1;
long long ans = 1LL * dx * dy;
if (dx >= 3 && checkws(up, down)) ans = min(ans, 1LL * (dx - 1) * dy);
if (dy >= 3 && checkad(lft, rait)) ans = min(ans, 1LL * (dy - 1) * dx);
cout << ans << endl;
}
int main() {
int T;
_w = scanf("%d", &T);
while (T--) {
_w = scanf("%s", str + 1);
n = (int)strlen(str + 1);
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, m;
cin >> n >> q >> m;
int a[n + 1];
int i;
for (i = 1; i <= n; i++) cin >> a[i];
vector<pair<int, pair<int, int> > > op;
for (i = 0; i < q; i++) {
int t, x, y;
cin >> t >> x >> y;
op.push_back(make_pair(t, make_pair(x, y)));
}
int j;
for (j = 0; j < m; j++) {
int id;
cin >> id;
for (i = op.size() - 1; i >= 0; i--) {
int t = op[i].first;
int x = op[i].second.first;
int y = op[i].second.second;
if (id >= x && id <= y) {
if (t == 1) {
if (id == x)
id = y;
else
id--;
} else {
if ((y - x) & 1) {
if (id <= (y - x + 1) / 2) {
int c = id - x;
id = y - c;
} else {
int c = y - id;
id = x + c;
}
} else {
if (id <= (y - x) / 2) {
int c = id - x;
id = y - c;
} else {
int c = y - id;
id = x + c;
}
}
}
}
}
cout << a[id] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = 10 * x + c - '0';
c = getchar();
}
x *= f;
}
int main() {
int n;
read(n);
if (n == 1) {
printf("1");
return 0;
}
if (n == 2 || n == 4 || n == 5) {
printf("3");
return 0;
}
for (int i = 5; i <= 10000; i++) {
if (i & 1) {
int l = 3, r = (i * i + 1) / 2;
if (n >= l && n <= r) {
printf("%d", i);
return 0;
}
} else if (n % 4 == 0) {
int x = n, mx = (i - 2) / 2;
mx = (mx * mx + 1) / 2;
if (mx * 4 >= x) {
printf("%d", i);
return 0;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
set<int> s;
vector<int> a(n), b(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
vector<int> c;
for (int i = 0; i < m; i++) {
if (s.count(b[i])) {
c.push_back(b[i]);
break;
}
}
if (c.size()) {
cout << "YES"
<< "\n";
cout << 1 << " " << c[0] << "\n";
} else {
cout << "NO"
<< "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
map<pair<int, int>, vector<int>> mp;
for (int j = 0; j < n - 2; j++) {
vector<int> a(3);
for (int k = 0; k < 3; k++) cin >> a[k];
for (int x = 0; x < 3; x++) {
for (int y = x + 1; y < 3; y++) {
int A = a[x];
int B = a[y];
A--;
B--;
if (A > B) swap(A, B);
mp[make_pair(A, B)].push_back(j);
}
}
}
if (n == 3) {
cout << "1 2 3" << endl;
cout << "1" << endl;
continue;
}
vector<vector<int>> Eten(n, vector<int>());
vector<vector<int>> Ehen(n - 2, vector<int>());
for (auto a : mp) {
if (a.second.size() == 1) {
Eten[a.first.first].push_back(a.first.second);
Eten[a.first.second].push_back(a.first.first);
} else {
Ehen[a.second[0]].push_back(a.second[1]);
Ehen[a.second[1]].push_back(a.second[0]);
}
}
vector<int> p, q;
int now = 0;
set<int> visited;
while (p.size() != n) {
p.push_back(now);
visited.insert(now);
for (int j = 0; j < Eten[now].size(); j++) {
int to = Eten[now][j];
if (visited.count(to)) continue;
now = to;
break;
}
}
vector<int> D(n - 2, 0);
queue<int> Q;
for (int j = 0; j < n - 2; j++) {
D[j] = Ehen[j].size();
if (Ehen[j].size() == 1) {
Q.push(j);
}
}
set<int> v;
while (q.size() != n - 2) {
now = Q.front();
Q.pop();
if (v.count(now)) continue;
q.push_back(now);
v.insert(now);
for (int j = 0; j < Ehen[now].size(); j++) {
int to = Ehen[now][j];
if (v.count(to)) continue;
D[to]--;
if (D[to] == 1) {
Q.push(to);
}
}
}
for (int j = 0; j < n; j++) {
if (j != 0) cout << ' ';
cout << p[j] + 1;
}
cout << endl;
for (int j = 0; j < n - 2; j++) {
if (j != 0) cout << ' ';
cout << q[j] + 1;
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fact[40000 + 10], ifact[40000 + 10];
vector<int> primes;
void sieve() {
int m[40000];
for (int i = int(0); i < int(40000); ++i) m[i] = 1;
for (long long i = 2; i * i <= 1e9; ++i)
if (m[i]) {
primes.push_back(i);
for (long long j = i * i; j < 40000; j += i) m[j] = 0;
}
}
long long binpow(long long x, long long p) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * x) % 1000000007;
p >>= 1;
x = (x * x) % 1000000007;
}
return ans;
}
void build() {
fact[0] = ifact[0] = fact[1] = ifact[1] = 1;
for (int i = 2; i <= 40000; ++i) {
fact[i] = (fact[i - 1] * i) % 1000000007;
ifact[i] = binpow(fact[i], 1000000007 - 2);
}
}
inline long long go(long long k, long long n) {
return (((fact[k + n] * ifact[n]) % 1000000007) * ifact[k]) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
sieve();
build();
int n, a;
map<int, int> mapa;
cin >> n;
for (int i = int(0); i < int(n); ++i) {
cin >> a;
for (int p : primes) {
if (a == 1) break;
while (a % p == 0) mapa[p]++, a /= p;
}
if (a != 1) mapa[a]++;
}
long long ans = 1;
for (pair<int, int> p : mapa) ans = (ans * go(p.second, n - 1)) % 1000000007;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T max(T a_, T b_, T c_) {
return max(a_, max(b_, c_));
}
template <typename T>
T min(T a_, T b_, T c_) {
return min(a_, min(b_, c_));
}
const int maxn = 1000010;
string s;
set<int> st;
vector<int> todo;
int kdfnbfkd[maxn], klnjdfkbndf[maxn];
void apply() {
vector<int> temp;
temp = todo;
todo.clear();
for (int b : temp) st.erase(b);
for (int b : temp) {
auto it = st.lower_bound(b);
int l = -1, r = -1;
if (it != st.end()) r = *it;
if (it != st.begin()) {
it--, l = *it;
}
if (l == -1 and r == -1)
continue;
else if (l == -1) {
kdfnbfkd[r] = 0;
if (kdfnbfkd[r] or klnjdfkbndf[r]) todo.push_back(r);
} else if (r == -1) {
klnjdfkbndf[l] = 0;
if (kdfnbfkd[l] or klnjdfkbndf[l]) todo.push_back(l);
} else {
klnjdfkbndf[l] = int(s[l] != s[r]);
kdfnbfkd[r] = int(s[l] != s[r]);
if (kdfnbfkd[l] or klnjdfkbndf[l]) todo.push_back(l);
if (kdfnbfkd[r] or klnjdfkbndf[r]) todo.push_back(r);
}
}
sort(todo.begin(), todo.end());
todo.erase(unique(todo.begin(), todo.end()), todo.end());
}
int32_t main() {
cin >> s;
for (int i = 0; i < s.size(); i++) st.insert(i);
for (int i = 0; i < s.size(); i++) {
if (i != 0) kdfnbfkd[i] = int(s[i - 1] != s[i]);
if (i != s.size() - 1) klnjdfkbndf[i] = int(s[i] != s[i + 1]);
if (kdfnbfkd[i] or klnjdfkbndf[i]) todo.push_back(i);
}
int c = 0;
while (!todo.empty()) {
apply();
c++;
}
cout << c << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 123;
int summ[(maxn + maxn) * 4];
int stpo[maxn + maxn];
int h, M;
int n, m;
void merge(const int& k) { summ[k] = summ[k << 1] + summ[k << 1 | 1]; }
void updata(const int& k, const int& x) { summ[k] += x; }
void ini() {
int i;
h = ceil(log(n + m + 2.0) / log(2.0)) + 1;
M = 1 << (h - 1);
for (int i = M + m + 1; i <= M + n + m; ++i) {
summ[i] = 1;
stpo[i - M] = i - M - m;
}
for (int i = M - 1; i > 0; --i) merge(i);
}
void change(int k, const int& x) {
for (k += M, updata(k, x), k >>= 1; k >= 1; k >>= 1) merge(k);
}
int findn(int pos) {
int i = 1;
while (i < M) {
i <<= 1;
if (pos > summ[i]) {
pos -= summ[i];
i++;
}
}
return i - M;
}
int pon[maxn];
int nop[maxn];
int main() {
scanf("%d%d", &n, &m);
ini();
bool flag = true;
for (int i = m; i >= 1; --i) {
int x, y;
scanf("%d%d", &x, &y);
if (!flag) continue;
int leaf = findn(y);
int npos = stpo[leaf];
if (nop[npos] == 0 && pon[x] == 0) {
nop[npos] = x;
pon[x] = npos;
} else if (nop[npos] != x || pon[x] != npos)
flag = false;
change(leaf, -1);
change(i, 1);
stpo[i] = npos;
}
if (!flag)
puts("-1");
else {
int ion = 1, iop = 1;
while (ion <= n && iop <= n) {
if (pon[ion] == 0 && nop[iop] == 0) {
pon[ion] = iop;
nop[iop] = ion;
iop++;
ion++;
} else if (pon[ion] != 0)
ion++;
else
iop++;
}
printf("%d", nop[1]);
for (int i = 2; i <= n; ++i) printf(" %d", nop[i]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, a[1000006], pa[1000006], s[1000006], c, d, p, q, j, k;
vector<long long> v1, v2;
vector<long long> v[1000006];
long long daddy(long long z) {
if (z != pa[z]) pa[z] = daddy(pa[z]);
return pa[z];
}
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pa[i] = i;
s[i] = 1;
}
for (i = 1; i <= m; i++) {
scanf("%lld%lld", &c, &d);
p = daddy(c);
q = daddy(d);
if (s[p] > s[q]) {
s[p] += s[q];
pa[q] = p;
} else {
s[q] += s[p];
pa[p] = q;
}
}
for (i = 1; i <= n; i++) {
v[daddy(i)].push_back(i);
}
for (i = 1; i <= n; i++) {
if (v[i].size() != 0) {
for (j = 0; j < v[i].size(); j++) {
v1.push_back(a[v[i][j]]);
v2.push_back(v[i][j]);
}
}
sort(v1.begin(), v1.end());
reverse(v1.begin(), v1.end());
for (j = 0; j < v1.size(); j++) {
a[v2[j]] = v1[j];
}
v1.clear();
v2.clear();
}
for (i = 1; i <= n; i++) printf("%lld ", a[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (1 << 29) + 5;
const long long int LLINF = (1ll << 59) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_X = 1024;
int n, k, x;
int arr[228228];
int cnt[2][MAX_X];
int main() {
scanf("%d%d%d", &n, &k, &x);
for (int i = 0; i < n; ++i) {
scanf("%d", &arr[i]);
++cnt[0][arr[i]];
}
int pt = 0;
for (int i = 0; i < k; ++i) {
int prev = 0;
for (int j = 0; j < MAX_X; ++j) {
if (prev % 2 == 0) {
cnt[pt ^ 1][j ^ x] += ((cnt[pt][j] + 1) >> 1);
cnt[pt ^ 1][j] += cnt[pt][j] - ((cnt[pt][j] + 1) >> 1);
} else {
if (cnt[pt][j] > 0) {
cnt[pt ^ 1][j] += 1;
prev += 1;
--cnt[pt][j];
cnt[pt ^ 1][j ^ x] += ((cnt[pt][j] + 1) >> 1);
cnt[pt ^ 1][j] += cnt[pt][j] - ((cnt[pt][j] + 1) >> 1);
}
}
prev += cnt[pt][j];
}
pt ^= 1;
memset(cnt[pt ^ 1], 0, sizeof(int) * MAX_X);
}
int ma = -1;
int mi = 228228;
for (int i = 0; i < MAX_X; ++i) {
if (cnt[pt][i] != 0) {
ma = max(ma, i);
mi = min(mi, i);
}
}
cout << ma << " " << mi << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m;
int x, y;
int l[N][4], r[N][4], u[N][4], d[N][4];
char s[N];
inline long long int get(int ot) {
int lt(x);
if (ot == 0) {
int tmp(y - x);
if (n - tmp <= m)
x = n - tmp, y = n;
else
x = m, y = tmp + m;
} else if (ot == 1) {
int tmp(x + y);
if (tmp - 1 <= m)
x = tmp - 1, y = 1;
else
x = m, y = tmp - m;
} else if (ot == 2) {
int tmp(y - x);
if (1 - tmp >= 1)
x = 1 - tmp, y = 1;
else
x = 1, y = tmp + 1;
} else if (ot == 3) {
int tmp(x + y);
if (tmp - n >= 1)
x = tmp - n, y = n;
else
x = 1, y = tmp - 1;
}
return abs(lt - x);
}
inline int checkL() {
for (int i = 0; i < 4; ++i)
if (l[y][i]) return 0;
return 1;
}
inline int checkR() {
for (int i = 0; i < 4; ++i)
if (r[y][i]) return 0;
return 1;
}
inline int checkD() {
for (int i = 0; i < 4; ++i)
if (d[x][i]) return 0;
return 1;
}
inline int checkU() {
for (int i = 0; i < 4; ++i)
if (u[x][i]) return 0;
return 1;
}
inline int turn(int ot) {
if (x == 1) {
if (y == 1)
return 0;
else if (y == n)
return 1;
else if (ot == 2)
return 1;
else
return 0;
} else if (x == m) {
if (y == 1)
return 3;
else if (y == n)
return 2;
else if (ot == 1)
return 2;
else
return 3;
} else if (y == 1) {
if (x == 1)
return 0;
else if (x == m)
return 3;
else if (ot == 1)
return 0;
else
return 3;
} else if (y == n) {
if (x == 1)
return 1;
else if (x == m)
return 2;
else if (ot == 0)
return 1;
else
return 2;
}
return -1;
}
inline bool check(int ot) {
if (x == 1) return l[y][ot];
if (x == m) return r[y][ot];
if (y == 1) return d[x][ot];
if (y == n) return u[x][ot];
return false;
}
int main() {
int ot;
scanf("%d%d", &n, &m);
long long int ans(1);
scanf("%d%d", &x, &y);
scanf("%s", s + 1);
swap(x, y);
y = n - y + 1;
if (s[1] == 'U' && s[2] == 'R')
ot = 0;
else if (s[1] == 'D' && s[2] == 'R')
ot = 1;
else if (s[1] == 'D' && s[2] == 'L')
ot = 2;
else if (s[1] == 'U' && s[2] == 'L')
ot = 3;
int tmp(0);
if (x == 1) {
tmp += checkL(), l[y][ot] = 1;
if (y == 1) d[x][ot] = 1;
if (y == n) u[x][ot] = 1;
}
if (x == m) {
tmp += checkR(), r[y][ot] = 1;
if (y == 1) d[x][ot] = 1;
if (y == n) u[x][ot] = 1;
}
if (y == 1) {
tmp += checkD(), d[x][ot] = 1;
if (x == 1) l[y][ot] = 1;
if (x == m) r[y][ot] = 1;
}
if (y == n) {
tmp += checkU(), u[x][ot] = 1;
if (x == 1) l[y][ot] = 1;
if (x == m) r[y][ot] = 1;
}
int all(n + m - 2);
for (; tmp < all;) {
ans += get(ot);
if (x == 1) {
tmp += checkL(), l[y][ot] = 1;
if (y == 1) d[x][ot] = 1;
if (y == n) u[x][ot] = 1;
}
if (x == m) {
tmp += checkR(), r[y][ot] = 1;
if (y == 1) d[x][ot] = 1;
if (y == n) u[x][ot] = 1;
}
if (y == 1) {
tmp += checkD(), d[x][ot] = 1;
if (x == 1) l[y][ot] = 1;
if (x == m) r[y][ot] = 1;
}
if (y == n) {
tmp += checkU(), u[x][ot] = 1;
if (x == 1) l[y][ot] = 1;
if (x == m) r[y][ot] = 1;
}
ot = turn(ot);
if (check(ot)) {
printf("-1");
return 0;
}
if (x == 1) l[y][ot] = 1;
if (x == m) r[y][ot] = 1;
if (y == 1) d[x][ot] = 1;
if (y == n) u[x][ot] = 1;
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long inf = 4e18;
int T, n;
long long x[N], y[N], z[N], X, Y, Z;
template <typename _Tp>
inline void IN(_Tp& x) {
char ch;
bool flag = 0;
x = 0;
while (ch = getchar(), !isdigit(ch))
if (ch == '-') flag = 1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
if (flag) x = -x;
}
long long l[4], r[4];
inline bool check(long long p) {
for (int i = 0; i < 4; ++i) l[i] = -inf, r[i] = inf;
for (int i = 1; i <= n; ++i)
l[0] = max(l[0], x[i] + y[i] + z[i] - p),
r[0] = min(r[0], x[i] + y[i] + z[i] + p),
l[1] = max(l[1], y[i] + z[i] - x[i] - p),
r[1] = min(r[1], y[i] + z[i] - x[i] + p),
l[2] = max(l[2], x[i] - y[i] + z[i] - p),
r[2] = min(r[2], x[i] - y[i] + z[i] + p),
l[3] = max(l[3], x[i] + y[i] - z[i] - p),
r[3] = min(r[3], x[i] + y[i] - z[i] + p);
for (int i = 0; i < 2; ++i) {
long long l0 = l[0] + ((l[0] & 1) ^ i), l1 = l[1] + ((l[1] & 1) ^ i),
l2 = l[2] + ((l[2] & 1) ^ i), l3 = l[3] + ((l[3] & 1) ^ i);
long long r0 = r[0] - ((r[0] & 1) ^ i), r1 = r[1] - ((r[1] & 1) ^ i),
r2 = r[2] - ((r[2] & 1) ^ i), r3 = r[3] - ((r[3] & 1) ^ i);
if (l0 > r0 || l1 > r1 || l2 > r2 || l3 > r3) continue;
if (l1 + l2 + l3 > r0 || r1 + r2 + r3 < l0) continue;
long long a = l1, b = l2, c = l3;
if (a + b + c < l0) a = min(r1, l0 - b - c);
if (a + b + c < l0) b = min(r2, l0 - c - a);
if (a + b + c < l0) c = min(r3, l0 - a - b);
X = (b + c) >> 1, Y = (c + a) >> 1, Z = (a + b) >> 1;
return true;
}
return false;
}
inline void solve() {
IN(n);
for (int i = 1; i <= n; ++i) IN(x[i]), IN(y[i]), IN(z[i]);
long long l = 0, r = inf, mid;
while (l <= r) check(mid = (l + r) >> 1) ? r = mid - 1 : l = mid + 1;
printf("%lld %lld %lld\n", X, Y, Z);
}
int main() {
IN(T);
while (T--) solve();
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.