solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<iostream>
#include<algorithm>
#define INF (1<<24)
using namespace std;
int t[8],x,y,z;
int ans,mini;
int s[]={4,1,4,1,2,1,2,1};
void change(){
int tmp;
tmp=s[0];
for(int i=0;i<7;i++)s[i]=s[i+1];
s[7]=tmp;
}
int compute(){
int res=0;
for(int i=0;i<8;i++){
res+=max(0,t[i]-s[i]);
}
return res;
}
int main(){
while(cin>>t[0]){
ans=mini=INF;
for(int i=1;i<8;i++)cin>>t[i];
for(int i=0;i<8;i++){
change();
x=compute();
y=0;
for(int i=0;i<8;i++){
y+=s[i];
y*=10;
}
if(mini>x){
mini=x;
ans=y;
}else if(mini==x&&y<ans){
ans=y;
}
}
//cout<<ans<<endl;
z=100000000;
for(int i=0;i<8;i++){
if(i)cout<<" ";
cout<<ans/z%10;
z/=10;
}
cout<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
for (int qq = 0; qq < q; qq++) {
int n, m;
cin >> n >> m;
bool cs[n];
for (int i = 0; i < n; i++) {
cs[i] = 0;
}
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<int> s(n);
s = arr;
sort(s.begin(), s.end());
for (int i = 0; i < m; i++) {
int a;
cin >> a;
a--;
cs[a] = 1;
}
string res = "NO";
while (1) {
bool b = 0;
int i;
for (i = 0; i < n - 1; i++) {
if (arr[i] > arr[i + 1]) {
if (cs[i]) {
swap(arr[i], arr[i + 1]);
} else {
b = 1;
break;
}
}
}
if (arr == s) {
res = "YES";
break;
}
if (b) break;
}
cout << res << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INFll = 0x3f3f3f3f3f3f3f3fLL;
const int INF = 0x7ffffff;
const int mod = 1000000007;
double dp[210][210][2 * 201 + 10];
int a[210], p[210];
int n, l, k;
void solve() {
memset(dp, 0, sizeof(dp));
dp[0][0][201 + k] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= i; ++j)
for (int k = 0; k <= 2 * 201; ++k) {
dp[i][j][k] += dp[i - 1][j][k] * (1 - p[i] / 100.0);
if (a[i] == -1) {
if (k > 0) dp[i][j + 1][k - 1] += dp[i - 1][j][k] * (p[i] / 100.0);
} else {
if (k + a[i] > 2 * 201)
dp[i][j + 1][2 * 201] += dp[i - 1][j][k] * (p[i] / 100.0);
else
dp[i][j + 1][k + a[i]] += dp[i - 1][j][k] * (p[i] / 100.0);
}
}
double total = 0.0;
for (int j = l; j <= n; ++j)
for (int k = 201; k <= 2 * 201; ++k) total += dp[n][j][k];
printf("%.12lf\n", total);
}
int main() {
while (~scanf("%d%d%d", &n, &l, &k)) {
for (int i = 1; i <= n; ++i) scanf("%d", &p[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[4 * 100005], dp2[4 * 100005];
vector<pair<int, int> > g[4 * 100005];
int st[4 * 100005], par[4 * 100005];
int child[4 * 100005][2];
vector<int> node;
void build(int n, int s, int e, int p) {
par[n] = p;
if (s == e) return;
int mid = (s + e) / 2;
child[n][0] = n * 2;
child[n][1] = n * 2 + 1;
build(n * 2, s, mid, n);
build(n * 2 + 1, mid + 1, e, n);
}
void find_node(int n, int s, int e, int l, int r) {
if (s > r || l > e) return;
if (l <= s && e <= r) {
node.push_back(n);
return;
}
int mid = (s + e) / 2;
find_node(n * 2, s, mid, l, r);
find_node(n * 2 + 1, mid + 1, e, l, r);
}
int main() {
memset(dp, -1, sizeof(dp));
memset(dp2, -1, sizeof(dp2));
int n, q, s;
scanf("%d%d%d", &n, &q, &s);
build(1, 1, n, 0);
find_node(1, 1, n, s, s);
s = node[0];
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
node.clear();
find_node(1, 1, n, a, a);
a = node[0];
node.clear();
find_node(1, 1, n, b, b);
b = node[0];
g[a].push_back(pair<int, int>(b, c));
} else {
int a, l, r, c;
scanf("%d%d%d%d", &a, &l, &r, &c);
node.clear();
find_node(1, 1, n, a, a);
a = node[0];
node.clear();
find_node(1, 1, n, l, r);
if (t == 2) {
for (int j = 0; j < node.size(); j++)
g[a].push_back(pair<int, int>(node[j], c));
} else {
for (int j = 0; j < node.size(); j++)
g[node[j]].push_back(pair<int, int>(a, c));
}
}
}
dp[s] = 0;
priority_queue<pair<long long, int> > pq;
pq.push(pair<long long, int>(0, s));
while (!pq.empty()) {
long long val = -pq.top().first;
int u = pq.top().second;
pq.pop();
if (dp[u] != val) continue;
for (int i = 0; i < 2; i++) {
if (child[u][i] == 0) continue;
int v = child[u][i];
if (dp[v] == -1 || dp[v] > dp[u])
dp[v] = dp[u], pq.push(pair<long long, int>(-dp[v], v));
}
int cur = u;
while (cur != 0) {
if (dp2[cur] != -1 && dp2[cur] < dp[u]) break;
dp2[cur] = dp[u];
for (int i = 0; i < g[cur].size(); i++) {
int v = g[cur][i].first;
int w = g[cur][i].second;
if (dp[v] == -1 || dp[v] > dp[u] + w)
dp[v] = dp[u] + w, pq.push(pair<long long, int>(-dp[v], v));
}
cur = par[cur];
}
}
pq.push(pair<long long, int>(0, s));
for (int i = 1; i <= n; i++) {
node.clear();
find_node(1, 1, n, i, i);
int cur = node[0];
long long val = dp[cur];
while (cur != 0) {
if (val == -1)
val = dp[cur];
else if (dp[cur] != -1 && dp[cur] < val)
val = dp[cur];
cur = par[cur];
}
printf("%lld ", val);
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[201010];
int main() {
long long n, m, k;
while (~scanf("%lld%lld%lld", &n, &m, &k)) {
memset(a, 0, sizeof(a));
long long i, j, ans = 0, sum = k;
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (i = n; i >= 1; i--) {
if (a[i] > k) continue;
if (a[i] <= sum) {
sum -= a[i];
ans++;
} else {
m--;
if (m <= 0) break;
sum = k;
i++;
}
}
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool check(int step, int m, vector<int> v) {
if (v[0] + step >= m) v[0] = 0;
for (int i = 1; i < v.size(); i++) {
if (v[i] < v[i - 1]) {
if (v[i] + step >= v[i - 1]) v[i] = v[i - 1];
} else {
if (v[i] + step >= m && (v[i] + step) % m >= v[i - 1]) v[i] = v[i - 1];
}
}
for (int i = 1; i < v.size(); i++) {
if (v[i] < v[i - 1]) return false;
}
return true;
}
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
v.push_back(a);
}
if (n <= 1) {
cout << "0" << endl;
return 0;
}
int lo = 0, hi = m - 1;
int ans = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (check(mid, m, v)) {
ans = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, inf = 1e9 + 3;
int main() {
cin >> t;
while (t--) {
long long int x;
cin >> x;
if (x > 14 && x % 14 <= 6 && x % 14 >= 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int u, v, cu, cv;
} Edge;
const int N = 500010, M = 1000010;
int fa[M];
Edge e[M];
int cnt;
int sz[M];
int co[N];
int st[N];
pair<int, int> stk[M];
int top;
int n, m, k;
void init() {
for (int i = 1; i <= n + n; i++) {
fa[i] = i;
sz[i] = 1;
}
}
int cmp(Edge a, Edge b) {
if (a.cu == b.cu) return a.cv < b.cv;
return a.cu < b.cu;
}
int find(int x) {
if (x == fa[x]) return x;
return find(fa[x]);
}
void merge(int u, int v) {
int fu = find(u), fv = find(v);
if (sz[fu] < sz[fv]) swap(fu, fv);
stk[++top] = {fu, fv};
fa[fv] = fu;
sz[fu] += sz[fv];
}
void undo() {
pair<int, int> t = stk[top--];
fa[t.second] = t.second;
sz[t.first] -= sz[t.second];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
init();
for (int i = 1; i <= n; i++) scanf("%d", &co[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (co[u] != co[v])
e[++cnt] = {u, v, min(co[u], co[v]), max(co[u], co[v])};
else {
int fu = find(u), fv = find(v);
if (fu == fv) {
st[co[u]] = 1;
} else {
int fuu = find(u + n), fvv = find(v + n);
merge(fv, fuu), merge(fu, fvv);
}
}
}
sort(e + 1, e + 1 + cnt, cmp);
long long ans = 0;
for (int i = 1; i <= k; i++) {
if (!st[i]) ans++;
}
ans = ans * (ans - 1) / 2;
int now = top;
int flag = 0;
for (int i = 1; i <= cnt; i++) {
if (e[i].cu != e[i - 1].cu || e[i].cv != e[i - 1].cv) {
while (now != top) undo();
flag = 0;
}
if (st[e[i].cv] || st[e[i].cu]) continue;
if (flag) continue;
int fu = find(e[i].u), fv = find(e[i].v);
if (fu == fv) {
ans--;
flag = 1;
continue;
} else {
int fuu = find(e[i].u + n), fvv = find(e[i].v + n);
merge(fu, fvv), merge(fv, fuu);
}
}
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, p1, p2, v1, v2, k, a, b, d, pmin, pmax, vmin, vmax, pl, pu, vl,
vu;
vector<long long> l;
int main() {
cin >> p1 >> p2 >> v1 >> v2 >> k;
a = min(p1, v1);
b = max(p2, v2);
l.push_back(0);
i = 0;
while (l[l.size() - 1] <= b) {
l.push_back(l[i] * 10 + 4);
l.push_back(l[i] * 10 + 7);
i++;
}
d = 0;
for (i = 0; i < l.size() - k + 1; i++) {
if (l[i] < a) continue;
if (l[i + k - 1] > b) continue;
pmin = max(p1, l[i - 1] + 1);
pmax = min(p2, l[i]);
vmin = max(v1, l[i + k - 1]);
vmax = min(v2, l[i + k] - 1);
if (pmax >= pmin && vmax >= vmin)
d += (pmax - pmin + 1) * (vmax - vmin + 1);
vmin = max(v1, l[i - 1] + 1);
vmax = min(v2, l[i]);
pmin = max(p1, l[i + k - 1]);
pmax = min(p2, l[i + k] - 1);
if (pmax >= pmin && vmax >= vmin)
d += (pmax - pmin + 1) * (vmax - vmin + 1);
if (k == 1 && l[i] <= vmax && l[i] >= vmin && l[i] >= pmin && l[i] <= pmax)
d--;
}
double res = (double)d / (p2 - p1 + 1) / (v2 - v1 + 1);
printf("%.9f", res);
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int n;
vector<int>graph[100005];
int dp[100005];
int f(int curr){
int&ret = dp[curr];
if(~ret) return ret;
ret = 0;
for(int i=0; i<graph[curr].size(); i++){
int nexter = graph[curr][i];
ret = max(ret,f(nexter)+1);
}
return ret;
}
int main(){
memset(dp,-1,sizeof(dp));
int m;
cin>>n>>m;
while(m--){
int a,b;
cin>>a>>b;
graph[a].push_back(b);
}
int mx = 0;
for(int i=1; i<=n; i++) mx = max(mx,f(i));
cout<<mx;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long sum[100001], axis[100000];
int s[100001];
long long calc(int n, long long limit) {
for (int i = 0; i < n; i++) axis[i] = sum[i] + limit;
sort(axis, axis + n);
int tot = unique(axis, axis + n) - axis;
memset(s, 0, sizeof(s));
long long res = 0;
for (int i = 0; i < n; i++) {
int loc = lower_bound(axis, axis + tot, sum[i] + limit) - axis;
for (int j = loc + 1; j <= tot; j += j & -j) s[j]++;
loc = lower_bound(axis, axis + tot, sum[i + 1] + 1) - axis;
for (int j = loc; j; j -= j & -j) res += s[j];
}
return res;
}
int main() {
int n;
long long k;
scanf("%d%I64d", &n, &k);
sum[0] = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
sum[i + 1] = sum[i] + x;
}
long long head = -100000000000000LL, tail = 100000000000000LL;
while (head <= tail) {
long long mid = (head + tail) / 2;
if (calc(n, mid) >= k)
head = mid + 1;
else
tail = mid - 1;
}
printf("%I64d\n", head - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
cin >> t;
;
lb:
while (t--) {
string s;
cin >> s;
long long n = s.length();
if (n == 1) {
cout << "YES"
<< "\n";
for (long long i = 0; i < 26; i++) cout << char('a' + i);
cout << "\n";
goto lb;
}
set<char> sn;
for (long long i = 0; i < n; i++) {
sn.insert(s[i]);
}
set<long long> adj[26];
for (long long i = 0; i < n - 1; i++) {
adj[s[i] - 'a'].insert(s[i + 1] - 'a');
adj[s[i + 1] - 'a'].insert(s[i] - 'a');
}
long long r = 0;
for (long long i = 0; i < 26; i++) {
if (adj[i].size() > 2) {
cout << "NO"
<< "\n";
goto lb;
}
if (adj[i].size() == 2) r++;
}
if (r >= sn.size() - 1) {
cout << "NO"
<< "\n";
goto lb;
}
vector<long long> a[26];
for (long long i = 0; i < 26; i++) {
for (auto it = adj[i].begin(); it != adj[i].end(); it++)
a[i].push_back(*it);
}
cout << "YES"
<< "\n";
vector<bool> vis(26);
long long ni = 0;
string k = "";
for (long long i = 0; i < 26; i++) {
if (a[i].size() == 1) {
{
k += ('a' + i);
k += ('a' + a[i][0]);
ni = a[i][0];
vis[i] = 1;
break;
}
}
}
while (!vis[ni]) {
vis[ni] = 1;
for (long long i = 0; i < a[ni].size(); i++) {
if (!vis[a[ni][i]]) {
k += 'a' + a[ni][i];
ni = a[ni][i];
break;
}
}
}
for (long long i = 0; i < 26; i++) {
if (!vis[i]) k += 'a' + i;
}
cout << k << "\n";
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int N,M,Q;
int L,R,p[100000],q[100000];
int x[501][501],sum[501][501];
int main(){
cin>>N>>M>>Q;
for(int i=0;i<M;i++)cin>>L>>R,x[L][R]++;
for(int i=0;i<Q;i++)cin>>p[i]>>q[i],p[i]--;
for(int i=1;i<=N;i++)
for(int j=1;j<=N;j++)
sum[i][j]=x[i][j]+sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1];
for(int i=0;i<Q;i++){
cout<<sum[q[i]][q[i]]-sum[p[i]][q[i]]-sum[q[i]][p[i]]+sum[p[i]][p[i]]<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int inf = 1e9;
inline int read() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
ch = getchar();
if (ch == '-') w = -1;
}
while (ch <= '9' && ch >= '0') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * w;
}
int n, m, tot, Q;
struct node {
int x, c, w;
inline bool operator<(const node &u) const { return w < u.w; }
} p[N];
struct edge {
int next, to;
} a[N << 1];
int head[N], cnt;
inline void add(int u, int v) {
a[++cnt].to = v;
a[cnt].next = head[u];
head[u] = cnt;
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
int d[N][N], vis[N], ps[N];
inline void dij(int s) {
for (int i = 1; i <= n; ++i) d[s][i] = inf, vis[i] = 0;
d[s][s] = 0;
q = priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >();
q.push(make_pair(0, s));
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (vis[x]) continue;
for (int i = head[x]; i; i = a[i].next) {
int y = a[i].to;
if (d[s][y] > d[s][x] + 1) {
d[s][y] = d[s][x] + 1;
if (!vis[y]) q.push(make_pair(d[s][y], y));
}
}
}
}
inline bool chk(int x, int c, int w, int ds) {
long long res = 0, now = 0;
for (int i = 1; i <= tot; ++i) {
if (d[x][p[i].x] <= ds) {
int k = ((p[i].c) < (c - now) ? (p[i].c) : (c - now));
now += k, res += 1ll * p[i].w * k;
if (res > w) return 0;
}
}
if (now < c) return 0;
return 1;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
add(u, v), add(v, u);
}
tot = read();
for (int i = 1; i <= tot; ++i)
p[i].x = read(), p[i].c = read(), p[i].w = read();
sort(p + 1, p + tot + 1);
Q = read();
while (Q--) {
int l = 0, r = n, ans = -1;
int x = read(), c = read(), w = read();
if (!ps[x]) dij(x), ps[x] = 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (chk(x, c, w, mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c, t;
cin >> n >> m;
int a[n + 1];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> c >> t;
a[i] = a[i - 1] + c * t;
}
int pos = 1;
for (int i = 0; i < m; i++) {
cin >> t;
while (pos <= n && t > a[pos]) pos++;
cout << pos << endl;
}
return 0;
}
| 2 |
#include <iostream>
#include<algorithm>
#define ll long long
using namespace std;
bool comp(ll a, ll b)
{
return (a < b);
}
int main()
{
int t;
cin>>t;
while(t--)
{
ll p,a,b,c,d,e,f;
cin>>p>>a>>b>>c;
d=p%a;
e=p%b;
f=p%c;
if(e==0||d==0||f==0)
cout<<"0"<<"\n";
else
{
d=a-d;
e=b-e;
f=c-f;
cout<<min({d,e,f},comp)<<"\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, res, tmp, m;
int a[1000012];
string s;
string dx(string s, int l, int r) {
string ss = "";
for (int i = r; i >= l; i--) ss = ss + s[i];
s.erase(l, r - l + 1);
s.insert(l, ss);
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
cin >> s;
for (int i = 2; i <= n; i++)
if (n % i == 0) {
s = dx(s, 0, i - 1);
}
cout << s;
return 0;
}
| 2 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
vector<string>sts;
vector<int>indnums;
int a = 0;
struct yaml {
bool is_dir;
map<string, yaml>mp;
string prop;
void operator =(const yaml yaml_) {
is_dir = yaml_.is_dir;
mp = yaml_.mp;
prop = yaml_.prop;
}
};
yaml getmap(const int ind);
pair<string,yaml> getmapitem(const int ind) {
yaml ayaml;
const int n = sts[a].find(':');
string key = sts[a].substr(indnums[a], n-indnums[a]);
if (n == sts[a].size()-1) {
ayaml.is_dir = true;
a++;
ayaml = getmap(indnums[a]);
}
else {
ayaml.is_dir = false;
string name = sts[a].substr(n + 2);
ayaml.prop = name;
a++;
}
return make_pair(key,ayaml);
}
yaml getmap(const int ind) {
yaml ayaml;
ayaml.is_dir = true;
ayaml.mp.emplace(getmapitem(ind));
while (1) {
if (a == sts.size() || indnums[a] != ind)break;
ayaml.mp.emplace(getmapitem(ind));
}
return ayaml;
}
int main() {
string st; cin >> st;
int now = 1;
vector<string>keys;
while (1) {
int n = st.find('.',now);
if (n == string::npos) {
break;
}
else {
keys.emplace_back(st.substr(now, n-now));
}
now = n+1;
}
keys.emplace_back(st.substr(now));
string ast;
getline(cin, ast);
while (getline(cin,ast)) {
int n = ast.find_first_not_of(' ');
sts.push_back(ast);
indnums.emplace_back(n);
}
yaml y=getmap(0);
int anstype=0;
string ans;
yaml nyaml = y;
for (int i = 0; i < keys.size(); ++i) {
auto it = nyaml.mp.find(keys[i]);
if (it == nyaml.mp.end()) {
anstype = -1;
break;
}
else {
nyaml = it->second;
}
}
if (anstype == -1) {
cout << "no such property" << endl;
}
else {
if (nyaml.is_dir) {
cout << "object" << endl;
}
else {
cout << "string \"" << nyaml.prop << "\"" << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[2][13] = {{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
int b[2] = {365, 366};
bool legal(int y) {
if ((y % 400 == 0) || ((y % 100 != 0) && (y % 4 == 0))) return true;
return false;
}
int mon(int y1, int y2, int m1, int m2, int d1, int d2) {
int cnt = 0;
if (m1 == m2) {
return d2 - d1;
} else {
int x = legal(y1);
cnt = a[x][m1] - d1 + 1;
int m = m1 + 1;
while (m < m2) cnt += a[x][m++];
cnt += d2 - 1;
return cnt;
}
}
int solve(int y1, int m1, int d1, int y2, int m2, int d2) {
if ((y1 > y2) || ((y1 == y2) && (m1 > m2)) ||
((y1 == y2) && (m1 > m2) && (d1 > d2))) {
swap(y1, y2);
swap(m1, m2);
swap(d1, d2);
}
int ans = 0;
if (y1 == y2) {
return mon(y1, y2, m1, m2, d1, d2);
} else {
int x = legal(y1);
ans = mon(y1, y1, m1, 12, d1, 31) + 1;
int y = y1 + 1;
while (y < y2) {
ans += b[legal(y)];
y++;
}
int t = mon(y2, y2, 1, m2, 1, d2);
ans += t;
return ans;
}
}
int main() {
int y1, m1, d1;
int y2, m2, d2;
char s[100];
scanf("%s", s);
sscanf(s, "%d:%d:%d", &y1, &m1, &d1);
scanf("%s", s);
sscanf(s, "%d:%d:%d", &y2, &m2, &d2);
printf("%d\n", solve(y1, m1, d1, y2, m2, d2));
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int h,w;
cin>>h>>w;
vector<vector<char>> a(h,vector<char>(w));
rep(i,h)rep(j,w)cin>>a[i][j];
vector<bool> t(h),y(w);
rep(i,h){
rep(j,w){
if(a[i][j]=='#')t[i]=y[j]=true;
}
}
rep(i,h){
if(t[i]){
rep(j,w){
if(y[j])cout<<a[i][j];
if(j==w-1)cout<<endl;
}
}
}
}
| 0 |
#include <iostream>
using namespace std;
int n;
string d[2][555555];
int h[2][555555];
int r[555555];
int main() {
cin >> n;
cin >> d[0][0];
int k = 1;
for (int i = 1; i <= n; i++) {
int a = i%2;
int b = 1-a;
for (int x = 0; x < 3; x++) {
for (int y = 0; y < k; y++) {
int z = x*k+y;
int u = x;
string s = "";
for (auto c : d[b][y]) {
if (c == 'S') {
if (u != 0) u = 3-u;
if (s.size() && s.back() == 'S') s.pop_back();
else s.push_back('S');
}
if (c == 'R') {
u++;
if (u == 3) {
u = 0;
s.push_back('R');
}
}
}
d[a][z] = s;
h[a][z] = h[b][y]+u*k;
if (i == n) cout << h[a][z] << " ";
}
}
k *= 3;
}
cout << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[100005];
int col[100005];
bool used[100005];
int finalnode[100005];
int par[100005];
int dfs(int u, int p) {
used[u] = true;
par[u] = p;
int result = 0;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (used[v]) continue;
result += dfs(v, u);
}
finalnode[u] = result;
if (col[u] != col[p]) result++;
return result;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n, u, v;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = 1; i <= n; i++) cin >> col[i];
memset(used, 0, sizeof(used));
;
int ans = dfs(1, 1) + 1;
ans = -1;
for (int i = 1; i <= n; i++) {
int temp1 = finalnode[1] - finalnode[i], temp2 = 0;
if (col[par[i]] != col[i]) temp1--;
if (temp1 > 0) continue;
for (int j = 0; j < edge[i].size(); j++) {
int v = edge[i][j];
if (v == par[i]) continue;
temp2 += finalnode[v];
}
if (temp2 == 0) {
ans = i;
break;
}
}
if (ans == -1) {
cout << "NO";
} else {
cout << "YES" << endl;
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 6;
const long long mod = 777777777;
int n, m;
int w[4][4];
struct node {
long long cnt[4][4];
node() { memset(cnt, 0, sizeof(cnt)); }
};
node tree[4 * MAXN];
node merge(node n1, node n2) {
node ret;
for (int i1 = 1; i1 <= 3; i1++) {
for (int i2 = 1; i2 <= 3; i2++) {
for (int j1 = 1; j1 <= 3; j1++) {
for (int j2 = 1; j2 <= 3; j2++) {
if (w[j1][i2] == 1)
ret.cnt[i1][j2] =
(ret.cnt[i1][j2] + n1.cnt[i1][j1] * n2.cnt[i2][j2]) % mod;
}
}
}
}
return ret;
}
void build(int l, int r, int idx) {
if (l == r) {
tree[idx].cnt[1][1] = 1;
tree[idx].cnt[2][2] = 1;
tree[idx].cnt[3][3] = 1;
return;
}
int mid = (l + r) / 2;
build(l, mid, idx * 2);
build(mid + 1, r, idx * 2 + 1);
tree[idx] = merge(tree[idx * 2], tree[idx * 2 + 1]);
}
void update(int l, int r, int q, int idx, int val) {
if (l > q) return;
if (r < q) return;
if (l == r) {
if (val == 0) {
tree[idx] = node();
tree[idx].cnt[1][1] = 1;
tree[idx].cnt[2][2] = 1;
tree[idx].cnt[3][3] = 1;
} else {
tree[idx] = node();
tree[idx].cnt[val][val] = 1;
}
return;
}
int mid = (l + r) / 2;
update(l, mid, q, idx * 2, val);
update(mid + 1, r, q, idx * 2 + 1, val);
tree[idx] = merge(tree[idx * 2], tree[idx * 2 + 1]);
}
int query() {
long long ans = 0;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
ans += tree[1].cnt[i][j];
ans %= mod;
}
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
cin >> w[i][j];
}
}
build(1, n, 1);
for (int i = 0; i < m; i++) {
int v, t;
cin >> v >> t;
update(1, n, v, 1, t);
cout << query() << endl;
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
int q=0;char ch=' ';
while(ch<'0'||ch>'9') ch=getchar();
while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
return q;
}
typedef long long LL;
const int N=100005;
int n,tot,h[N],ne[N<<1],to[N<<1],du[N];
LL a[N],f[N];
void add(int x,int y) {to[++tot]=y,ne[tot]=h[x],h[x]=tot;}
void dfs(int x,int las) {
if(du[x]==1) {f[x]=a[x];return;}
LL orzabs=0,p,mx=0;
for(RI i=h[x];i;i=ne[i]) {
if(to[i]==las) continue;
dfs(to[i],x),f[x]+=f[to[i]],mx=max(mx,f[to[i]]);
}
if(mx>f[x]-mx) p=f[x]-mx;
else p=f[x]/2;
if(f[x]<a[x]) {puts("NO");exit(0);}
if(f[x]-a[x]>p) {puts("NO");exit(0);}
f[x]-=(f[x]-a[x])*2LL;
}
int main()
{
int x,y;
n=read();
for(RI i=1;i<=n;++i) a[i]=read();
if(n==2) {
if(a[1]==a[2]) puts("YES");
else puts("NO");
return 0;
}
for(RI i=1;i<n;++i)
x=read(),y=read(),add(x,y),add(y,x),++du[x],++du[y];
for(RI i=1;i<=n;++i) if(du[i]>1) {
dfs(i,0);
if(f[i]) puts("NO");
else puts("YES");
return 0;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
struct edge {
int u, v, w;
edge() {}
edge(int _u, int _v, int _w) : u(_u), v(_v), w(_w) {}
};
int n, a, b, c, d;
vector<edge> e, ans;
vector<int> G[maxn];
void dfs(int u, int f, int t) {
if (G[u].size() == 1) {
if (!t) {
if (!a) a = u;
b = u;
} else {
if (!c) c = u;
d = u;
}
}
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == f) continue;
dfs(v, u, t);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
e.push_back(edge(u, v, w));
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (G[i].size() == 2) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 0; i < e.size(); ++i) {
int u = e[i].u, v = e[i].v, w = e[i].w;
a = b = c = d = 0;
dfs(u, v, 0);
dfs(v, u, 1);
ans.push_back(edge(a, c, w / 2));
ans.push_back(edge(b, d, w / 2));
if (a != b) ans.push_back(edge(a, b, -w / 2));
if (c != d) ans.push_back(edge(c, d, -w / 2));
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i)
printf("%d %d %d\n", ans[i].u, ans[i].v, ans[i].w);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void Input();
void solve();
void test_cases();
int test_case = 1;
signed main() {
test_case = 1;
test_cases();
while (test_case--) {
Input();
solve();
}
}
const int M = 2e5;
int n, k, a, m, b, c, d, x, A, B, C;
vector<int> ar, br, v, left, right;
multiset<int> st, st1, st2;
map<int, int> mp;
string str, str2;
int maxi;
void Input() { cin >> n >> str; }
bool go(char x, char y) {
char sy = y;
vector<int> ans(n);
for (int i = 0; i < n; i++) {
if (str[i] >= y) {
ans[i] = 2;
y = str[i];
} else if (str[i] >= x) {
ans[i] = 1;
x = str[i];
} else
return false;
}
if (x > sy) return false;
for (int x : ans) cout << x;
cout << endl;
return true;
}
void solve() {
for (int x = 0; x < 10; x++) {
if (go('0', '0' + x)) {
return;
}
}
cout << "-" << endl;
}
void test_cases() { cin >> test_case; }
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
string second;
int dp[5][N], n;
set<string> ans;
string get(int l, int r) {
string ans = "";
if (r < n) ans = second.substr(l, r - l + 1);
return ans;
}
bool calc(int x, int p) {
if (p >= n) return 1;
return dp[x][p];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> second;
n = second.size();
for (int i = n - 1; i >= 0; i--) {
if (i < 5) continue;
if (i + 1 < n) {
if (get(i, i + 1) != get(i + 2, i + 3) && calc(2, i + 2)) {
dp[2][i] = 1;
ans.insert(get(i, i + 1));
}
if (calc(3, i + 2)) {
dp[2][i] = 1;
ans.insert(get(i, i + 1));
}
}
if (i + 3 - 1 < n) {
if (get(i, i + 2) != get(i + 3, i + 5) && calc(3, i + 3)) {
dp[3][i] = 1;
ans.insert(get(i, i + 2));
}
if (calc(2, i + 3)) {
dp[3][i] = 1;
ans.insert(get(i, i + 2));
}
}
}
cout << ans.size() << endl;
for (auto i : ans) cout << i << endl;
return 0;
}
| 3 |
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int INF=1000000007;
int f[101010],s[101010],a[101010],g[101010];
int ksm(int w,int x)
{
int ans=1;
while(x)
{
if(x&1)
ans=(long long)ans*w%INF;
x/=2;
w=(long long)w*w%INF;
}
return ans;
}
int main()
{
int n,i,ans;
scanf("%d",&n);
f[0]=1;
for(i=1;i<=n;i++)
f[i]=(long long)f[i-1]*i%INF;
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
g[0]=0;
for(i=1;i<=n;i++)
g[i]=(g[i-1]+(long long)f[n]*ksm(i+1,INF-2)%INF)%INF;
ans=0;
for(i=1;i<=n;i++)
ans=(ans+(long long)((long long)g[i-1]+g[n-i]+f[n])*a[i]%INF)%INF;
printf("%d\n",ans);
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
return 0;
}
| 0 |
#include<iostream>
#define rep(i,n) for(int i=0;i<n;i++)
#define ck(a,b) (0<=a&&a<b)
#define INF 1<<30
using namespace std;
int dx0[]={0,1,0,-1,-1,-1},dx1[]={1,1,1,0,-1,0},dy[]={-1,0,1,1,0,-1};
int md[100][100],td[100][100],s,t,sx[10],sy[10],tx[10],ty[10],m,n,tc,mc;
void rec(int x,int y,int a){
td[x][y]=a;
rep(d,6){
int nx=x+(y%2?dx1[d]:dx0[d]),ny=y+dy[d];
if(ck(nx,m)&&ck(ny,n)&&td[nx][ny]>a+1)rec(nx,ny,a+1);
}
}
int main(){
while(cin>>m>>n>>s,m){
rep(i,m)rep(j,n)md[i][j]=INF;
rep(i,s)cin>>sx[i]>>sy[i],sx[i]--,sy[i]--;
cin>>t; rep(i,t)cin>>tx[i]>>ty[i],tx[i]--,ty[i]--;
rep(i,s){
rep(k,m)rep(l,n)td[k][l]=INF;
rec(sx[i],sy[i],0);
rep(k,m)rep(l,n)if(md[k][l]>td[k][l])md[k][l]=td[k][l];
}
mc=0; rep(i,t){
tc=0;
rep(k,m)rep(l,n)td[k][l]=INF;
rec(tx[i],ty[i],0);
rep(k,m)rep(l,n)if(md[k][l]>td[k][l])tc++;
if(mc<tc)mc=tc;
}
cout<<mc<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, q;
cin >> n >> q;
long long int p = 0, m = 0;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1)
p++;
else
m++;
}
long long int l, r;
while (q--) {
cin >> l >> r;
long long int t = r - l + 1;
if (t > 0 && t % 2 == 0 && p >= t / 2 && m >= t / 2) {
cout << 1 << endl;
} else
cout << 0 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string a;
cin >> a;
if (n & 1) {
cout << ":(";
return 0;
}
int cnt1 = 1;
int cnt2 = 1;
if (a[0] == ')') {
cout << ":(";
return 0;
}
a[0] = '(';
if (a.back() == '(') {
cout << ":(";
return 0;
}
a[a.size() - 1] = ')';
for (int i = 1; i < a.size(); ++i)
if (a[i] == '(') ++cnt1;
if (cnt1 > n / 2) {
cout << ":(";
return 0;
}
for (int i = 0; i < a.size(); ++i) {
if (a[i] == '?') {
++cnt1;
a[i] = '(';
}
if (cnt1 == n / 2) break;
}
if (cnt1 < n / 2) {
cout << ":(";
return 0;
}
for (int i = 0; i < a.size(); ++i)
if (a[i] == '?') a[i] = ')';
stack<int> s;
for (int i = 0; i < a.size(); ++i) {
if (a[i] == '(')
s.push(a[i]);
else {
if (s.empty()) {
cout << ":(";
return 0;
} else {
s.pop();
if (s.empty() && i != a.size() - 1) {
cout << ":(";
return 0;
}
}
}
}
if (!s.empty()) {
cout << ":(";
return 0;
}
for (int i = 0; i < a.size(); ++i) cout << a[i];
return 0;
}
| 3 |
#include<iostream>
using namespace std;
bool check(int X,int n,int m){
return (n*2020 + m*2021 == X);
}
//n*2020 + m*2021 = X
void sol(int X){
for (int m = 0; m <= X/2021; m++)
{
int n;
n=(X-2021*m)/2020;
if(check(X,n,m)){
cout << "YES" << endl;
return ;
}
}
cout << "NO" << endl;
return ;
}
int main(){
int t;
cin>>t;
for (int i=0;i<t;i++){
int X;
cin >> X;
sol(X);
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][31][31][31][31], n, H;
inline void updata(int h, int i, int j, int p, int q, int c, int key, int num) {
int w[4] = {i, j, p, q};
for (int t = 0; t < num; t++) {
if (t == c) w[t] = w[t] == H ? H : 0;
if (t != c) w[t] = min(w[t] + 1, H);
}
sort(w, w + num);
dp[h][w[0]][w[1]][w[2]][w[3]] += key;
dp[h][w[0]][w[1]][w[2]][w[3]] %= 1000000009;
}
int solve(int num) {
memset(dp, 0, sizeof(dp));
dp[0][0][0][0][0] = 1;
int ret = 0;
for (int t = 0, g = 1, h = 0; t <= n; t++) {
swap(g, h);
for (int i = 0; i < H; i++)
for (int j = i; j <= H; j++) {
for (int p = j; p <= H; p++) {
for (int q = p; q <= H; q++) {
if (dp[g][i][j][p][q] == 0) continue;
if (t == n) {
ret += dp[g][i][j][p][q];
ret %= 1000000009;
continue;
}
for (int c = 0; c < num; c++)
updata(h, i, j, p, q, c, dp[g][i][j][p][q], num);
dp[g][i][j][p][q] = 0;
}
}
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &H);
printf("%d\n", solve(4));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
#define MP make_pair
#define PB push_back
#define X first
#define Y second
#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define ITER(it, a) for(__typeof(a.begin()) it = a.begin(); it != a.end(); ++it)
#define ALL(a) a.begin(), a.end()
#define SZ(a) (int)((a).size())
#define FILL(a, value) memset(a, value, sizeof(a))
#define debug(a) cerr << #a << " = " << a << endl;
const double PI = acos(-1.0);
const LL INF = 1e9;
const LL LINF = INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int random(int l, int r)
{
return l + rng() % (r - l + 1);
}
const int T = 10000;
int Tmax;
const int N = 400 + 7;
const int M = 800 + 7;
int n, m;
vector<PII> g[N];
pair<int, PII> edges[M];
PII order[T];
VI needed[N];
int dist[N][N];
int parent[N][N];
int G[N][N];
int number_of_orders_on_suf[T];
inline int waiting_orders(int l, int r)
{
if (l > r) return 0;
return number_of_orders_on_suf[r] - (l ? number_of_orders_on_suf[l - 1] : 0);
}
void graph_input()
{
cin >> n >> m;
FOR(i, 1, n + 1) FOR(j, 1, n + 1) G[i][j] = INF;
FOR(i, 1, n + 1) G[i][i] = 0;
FOR(i, 0, m)
{
int u, v, w;
cin >> u >> v >> w;
G[u][v] = G[v][u] = w;
g[u].PB({v, w});
g[v].PB({u, w});
edges[i] = {w, {u, v}};
}
}
void order_input()
{
cin >> Tmax;
FILL(order, -1);
FOR(i, 0, Tmax)
{
int t;
cin >> t;
if (i)
number_of_orders_on_suf[i] = number_of_orders_on_suf[i - 1];
if (t == 0) continue;
number_of_orders_on_suf[i]++;
int id, dst;
cin >> id >> dst;
order[i] = {id, dst};
needed[dst].PB(i);
}
}
void preprocess()
{
FOR(i, 1, n + 1)
{
FOR(j, 1, n + 1) dist[i][j] = INF;
dist[i][i] = 0;
set<PII> S;
FOR(j, 1, n + 1)
S.insert({dist[i][j], j});
while(SZ(S))
{
int v = S.begin()->Y;
S.erase(S.begin());
for(auto e: g[v])
{
int to = e.X, len = e.Y;
if (dist[i][to] <= dist[i][v] + len) continue;
parent[i][to] = v;
S.erase({dist[i][to], to});
dist[i][to] = dist[i][v] + len;
S.insert({dist[i][to], to});
}
}
}
}
vector<int> path(int from, int to)
{
vector<int> res;
while(from != to)
{
res.PB(to);
to = parent[from][to];
}
res.PB(from);
reverse(ALL(res));
return res;
}
vector<int> go(vector<int>& orders, int start_time)
{
int curr_vertex = 1;
vector<int> res;
const int Magic = 47;
while(SZ(orders))
{
int to = -1;
for(auto i: orders)
if (to == -1 || dist[curr_vertex][to] > dist[curr_vertex][order[i].Y])
to = order[i].Y;
if (2 * dist[curr_vertex][to] > dist[curr_vertex][1] && SZ(res) >= Magic)
to = 1;
int curr_time = start_time + SZ(res);
if (curr_time >= 7000 && waiting_orders(start_time, curr_time) >= 3 * SZ(orders) + 47)
to = 1;
vector<int> way = path(curr_vertex, to);
FOR(i, 0, SZ(way) - 1)
FOR(j, 0, G[way[i]][way[i + 1]])
res.PB(way[i + 1]);
curr_vertex = to;
sort(ALL(way));
vector<int> nxt;
for(auto i: orders)
{
auto it = lower_bound(ALL(way), order[i].Y);
if (it != way.end() && *it == order[i].Y) continue;
nxt.PB(i);
}
orders = nxt;
if (to == 1) break;
}
vector<int> way = path(curr_vertex, 1);
FOR(i, 0, SZ(way) - 1)
FOR(j, 0, G[way[i]][way[i + 1]])
res.PB(way[i + 1]);
return res;
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
graph_input();
order_input();
preprocess();
vector<int> res;
vector<int> orders;
int Magic = 1;
int chas = 0;
while(chas < Tmax)
{
if (order[chas].X != -1)
orders.PB(chas);
if (SZ(orders) >= Magic)
{
auto tut = go(orders, chas);
for(auto i: tut) res.PB(i);
if (SZ(res) >= Tmax)
{
res.resize(Tmax);
break;
}
FOR(i, 0, SZ(tut))
{
chas++;
if (order[chas].X != -1) orders.PB(chas);
}
continue;
}
chas++;
res.PB(-1);
}
for(auto i: res) cout << i << endl;
//cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 9;
int n;
char a[N];
void home() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void enter() { cin >> n; }
bool check(char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); }
void solve() {
bool ok = false;
int id = 0, l = 0;
int res1 = 0, res2 = 0;
for (int i = (1); i <= (n + 1); ++i) {
if (i > n)
a[i] = '_';
else
cin >> a[i];
if (a[i] == '(')
ok = true;
else if (a[i] == ')')
ok = false, l = 0;
else if (ok) {
if (check(a[i]) && !check(a[i - 1])) res2++;
} else if (!ok) {
if (check(a[i]))
l++;
else
l = 0;
res1 = ((res1) > (l) ? (res1) : (l));
}
}
cout << res1 << " " << res2;
}
int main() {
home();
enter();
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int N;
cin >> N;
vector<int> arr(2 * N);
for (auto& x : arr) {
cin >> x;
}
sort(arr.begin(), arr.end(), greater<int>());
if (arr[N - 1] > arr[N])
cout << "YES";
else
cout << "NO";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
vector<vector<long long int> > dp(n, vector<long long int>(n, -1));
for (long long int i = n - 1; i >= 0; i--) {
for (long long int j = i; j < n; j++) {
if (i == j) {
dp[i][j] = v[i];
continue;
}
for (long long int k = i; k < j; k++) {
if (dp[i][k] == dp[k + 1][j] && dp[i][k] != -1) dp[i][j] = dp[i][k] + 1;
}
}
}
vector<long long int> dp2(n, 0);
for (long long int i = 0; i < n; i++) {
dp2[i] = i + 1;
for (long long int j = 0; j <= i; j++) {
if (dp[j][i] != -1) {
if (j == 0)
dp2[i] = 1;
else
dp2[i] = min(dp2[i], dp2[j - 1] + 1);
}
}
}
cout << dp2[n - 1] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
//typedef long long int ll;
//#define M (int)(1e9+7)
#define int long long
const int mxN=1e5;
//ll n,m,a[mxN],b[mxN];
bool comp(pair<int,int> a,pair<int,int> b){
if(a.first==b.first)
return a.second>b.second;
else return a.first<b.first;
}
bool isPrime(int n){
for(int i=2;i<=sqrt(n);i++)
{
if(n%i==0)
return false;
}
return true;
}
int gcd(int a,int b){
if(b==0)
return a;
return gcd(b,a%b);
}
vector<int> store;
void subsetSum(vector<int> value,int l, int r,int sum=0){
if(l>r)
{
store.push_back(sum);
return;
}
subsetSum(value,l+1,r,sum+value[l]);
subsetSum(value,l+1,r,sum);
}
void print(vector<int> ans){
for(int i=0;i<ans.size();i++)
{
cout<< ans[i]<<" ";
}cout<<"\n";
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tt;
cin >> tt;
while(tt--)
{
int n;
cin >> n;
vector<int> seq(n);
for(int i=0;i<n;i++)
{
cin >> seq[i];
}
vector<int> ans;
int first=0,last=n-1;
for(int i=0;i<n;i++)
{
if(i%2==0)
{
ans.push_back(seq[first]);
first++;
}
else{
ans.push_back(seq[last]);
last--;
}
}
print(ans);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[17];
int n;
int check(int l, int r) {
int cnt = 1;
for (int i = l + 1; i <= r; i++) {
if (arr[i] >= arr[i - 1]) {
cnt += 1;
} else {
return 1;
}
}
return cnt;
}
int divide(int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
return max(max(divide(l, m), divide(m + 1, r)), check(l, r));
}
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
cout << max(divide(0, n - 1), check(0, n - 1)) << endl;
}
| 1 |
#include<iostream>
#include<cstdio>
int n,m;
struct edge{int to,nxt;}E[200050];
int H[100050],tot=1;
void add_edge(int a,int b){
E[++tot]=(edge){b,H[a]},H[a]=tot;
E[++tot]=(edge){a,H[b]},H[b]=tot;
}
int D[100050],cnt6,cnt4,way,P,Q;
void dfs(int now,int S,int T,int fae){
if (fae&&now==S) return;
if (now==T){way++;return;}
for (int i=H[now];i;i=E[i].nxt){
if ((i^1)==fae) continue;
dfs(E[i].to,S,T,i);
}
}
int main(){
scanf("%d%d",&n,&m);
for (int i=1,x,y;i<=m;i++) scanf("%d%d",&x,&y),add_edge(x,y),D[x]++,D[y]++;
for (int i=1;i<=n;i++){
if (D[i]&1) return puts("No"),0;
if (D[i]==6) cnt6++;
if (D[i]==4){
cnt4++;
if (!P) P=i;
else if (!Q) Q=i;
}
}
if (cnt6||cnt4>=3) puts("Yes");
else if (cnt4==2){
dfs(P,P,Q,0);
puts(way==4?"No":"Yes");
}
else puts("No");
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define pb push_back
#define mp make_pair
#define f first
#define s second
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
sort(a, a + n);
if(a[0] < 0)
cout<<"NO\n";
else
{
cout<<"YES\n";
cout<<101<<'\n';
for(int i=0;i<=100;i++)
cout<<i<<" ";
cout<<'\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, sum = 0;
cin >> b;
for (a = 1; a <= sqrt(b); a++) {
if (b % a == 0) {
if (b / a == a)
sum += 1;
else
sum += 2;
}
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
vector<int> v[102];
int deg[102];
bool vis[102];
queue<int> q;
int dp[102][102];
long long int unused[102][102];
int mx[102];
long long int C[102][102];
long long int r[2][102];
inline void dfs(int b, int pr = -1) {
if (pr != -1) {
memset(dp[b], 0, sizeof(dp[b]));
memset(unused[b], 0, sizeof(unused[b]));
dp[b][0] = 1;
mx[b] = 0;
unused[b][0] = 1;
for (int i = 0; i < v[b].size(); i++) {
if (pr == v[b][i]) continue;
if (!vis[v[b][i]]) {
continue;
}
dfs(v[b][i], b);
int go = v[b][i];
for (int j = mx[b]; j >= 0; j--) {
for (int k = 1; k <= mx[go]; k++) {
dp[b][j + k] +=
(dp[b][j] *
(((long long int)(dp[go][k]) * C[j + k][j]) % 1000000009)) %
1000000009;
if (dp[b][j + k] >= 1000000009) dp[b][j + k] -= 1000000009;
}
for (int k = 1; k <= mx[go]; k++) {
unused[b][j + k] +=
(unused[b][j] *
(((long long int)(unused[go][k] + dp[go][k]) * C[j + k][j]) %
1000000009)) %
1000000009;
if (unused[b][j + k] >= 1000000009) unused[b][j + k] -= 1000000009;
}
dp[b][j] = 0;
}
mx[b] += mx[go];
}
mx[b]++;
for (int i = mx[b]; i >= 1; i--) {
dp[b][i] = dp[b][i - 1];
}
dp[b][0] = 0;
} else {
memset(unused[b], 0, sizeof(unused[b]));
unused[b][0] = 1;
memset(r, 0, sizeof(r));
r[0][0] = 1;
mx[b] = 0;
for (int i = 0; i < v[b].size(); i++) {
if (pr == v[b][i] || vis[v[b][i]] == false) continue;
dfs(v[b][i], b);
int go = v[b][i];
for (int j = mx[b]; j >= 0; j--) {
for (int k = 1; k <= mx[go]; k++) {
r[0][j + k] += ((dp[go][k] * C[j + k][j]) % 1000000009) * r[0][j];
r[0][j + k] %= 1000000009;
r[1][j + k] += ((dp[go][k] * C[j + k][j]) % 1000000009) * r[1][j];
r[1][j + k] %= 1000000009;
r[1][j + k] += ((r[0][j] * C[j + k][j]) % 1000000009) * unused[go][k];
r[1][j + k] %= 1000000009;
}
for (int k = 1; k <= mx[go]; k++) {
unused[b][j + k] +=
(unused[b][j] *
(((long long int)(unused[go][k] + dp[go][k]) * C[j + k][j]) %
1000000009)) %
1000000009;
if (unused[b][j + k] >= 1000000009) unused[b][j + k] -= 1000000009;
}
r[1][j] = r[0][j];
r[0][j] = 0;
}
mx[b] += mx[go];
}
mx[b]++;
for (int j = mx[b]; j >= 1; j--) {
r[0][j] = r[0][j - 1];
r[1][j] = r[1][j - 1];
}
r[0][0] = r[1][0] = 0;
}
}
int belong[102];
bool flag[102];
int nex[102];
inline int root(int b) {
if (belong[b] == -1) return b;
belong[b] = root(belong[b]);
return belong[b];
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
belong[b] = a;
}
long long int ans[102][102];
long long int outt[102];
long long int ppow(long long int i, long long int j) {
long long int r = 1;
while (j) {
if ((j & 1LL)) {
r *= i;
if (r >= 1000000009) r %= 1000000009;
}
i *= i;
if (i >= 1000000009) i %= 1000000009;
j >>= 1LL;
}
return r;
}
int main() {
memset(belong, -1, sizeof(belong));
C[0][0] = 1;
for (int i = 0; i + 1 < 102; i++) {
for (int j = 0; j <= i; j++) {
C[i][j] %= 1000000009;
C[i + 1][j] += C[i][j];
C[i + 1][j + 1] += C[i][j];
}
}
for (int i = 0; i < 102; i++) {
for (int j = 0; j < 102; j++) {
C[i][j] %= 1000000009;
}
}
cin >> n;
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
deg[a]++;
deg[b]++;
}
for (int i = 0; i < n; i++) {
if (deg[i] <= 1) {
q.push(i);
vis[i] = true;
}
}
while (!q.empty()) {
int b = q.front();
q.pop();
for (int i = 0; i < v[b].size(); i++) {
deg[v[b][i]]--;
if (deg[v[b][i]] <= 1 && vis[v[b][i]] == false) {
vis[v[b][i]] = true;
q.push(v[b][i]);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < v[i].size(); j++) {
if (vis[i] && vis[v[i][j]]) merge(i, v[i][j]);
}
}
for (int i = 0; i < n; i++) {
if (vis[i] == false) {
for (int j = 0; j < v[i].size(); j++) {
if (vis[v[i][j]]) {
flag[root(v[i][j])] = true;
nex[root(v[i][j])] = v[i][j];
}
}
}
}
for (int i = 0; i < n; i++) {
if (vis[i] == true) {
if (flag[root(i)] == true && nex[root(i)] != i) continue;
dfs(i);
if (1) {
for (int j = 0; j <= n; j++) {
ans[root(i)][j] +=
r[0][j] + r[1][j] * (long long int)(flag[root(i)] ^ true);
}
}
if (flag[root(i)] == true) {
for (int j = 0; j <= n; j++) {
ans[root(i)][j] += unused[i][j];
}
}
}
}
outt[0] = 1;
for (int i = 0; i < n; i++) {
if (root(i) == i) {
for (int j = n; j >= 0; j--) {
if (outt[j]) {
for (int k = 1; k <= n; k++) {
outt[j + k] +=
(((outt[j] * C[j + k][j]) % 1000000009) * ans[i][k]) %
1000000009;
outt[j + k] %= 1000000009;
}
}
}
}
}
puts("1");
for (int i = 1; i <= n; i++) {
printf("%lld\n", outt[i]);
}
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t, a[310][310];
int tp, tu, td;
int r[301][301], d[301][301], l[301][301], u[301][301];
void init() {
memset(d, 0, sizeof(d));
memset(r, 0, sizeof(r));
memset(l, 0, sizeof(l));
memset(u, 0, sizeof(u));
for (int i = 0; i < n; i++)
for (int j = 0; j < m - 1; j++)
if (a[i][j + 1] > a[i][j])
r[i][j + 1] = r[i][j] + tu;
else if (a[i][j + 1] == a[i][j])
r[i][j + 1] = r[i][j] + tp;
else
r[i][j + 1] = r[i][j] + td;
for (int i = 0; i < n; i++)
for (int j = m - 1; j > 0; j--)
if (a[i][j - 1] > a[i][j])
l[i][j - 1] = l[i][j] + tu;
else if (a[i][j - 1] == a[i][j])
l[i][j - 1] = l[i][j] + tp;
else
l[i][j - 1] = l[i][j] + td;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < m; j++)
if (a[i + 1][j] > a[i][j])
d[i + 1][j] = d[i][j] + tu;
else if (a[i + 1][j] == a[i][j])
d[i + 1][j] = d[i][j] + tp;
else
d[i + 1][j] = d[i][j] + td;
for (int i = n - 1; i > 0; i--)
for (int j = 0; j < m; j++)
if (a[i - 1][j] > a[i][j])
u[i - 1][j] = u[i][j] + tu;
else if (a[i - 1][j] == a[i][j])
u[i - 1][j] = u[i][j] + tp;
else
u[i - 1][j] = u[i][j] + td;
}
int calc(int x1, int y1, int x2, int y2) {
int temp = r[x1][y2] - r[x1][y1] + d[x2][y2] - d[x1][y2] + l[x2][y1] -
l[x2][y2] + u[x1][y1] - u[x2][y1];
return temp;
}
void solve() {
cin >> n >> m >> t;
cin >> tp >> tu >> td;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
init();
int sx = 0, sy = 0, ex = 2, ey = 2;
for (int i = 0; i + 2 < n; i++)
for (int j = 0; j + 2 < m; j++)
for (int p = i + 2; p < n; p++) {
int lb = j + 2, ub = m - 1;
while (ub - lb >= 0) {
int mid = (ub + lb) >> 1;
int temp = calc(i, j, p, mid);
if (temp > t)
ub = mid - 1;
else
lb = mid + 1;
if (sx == -1 || abs(calc(sx, sy, ex, ey) - t) > abs(temp - t)) {
sx = i;
sy = j;
ex = p;
ey = mid;
}
}
}
cout << sx + 1 << ' ' << sy + 1 << ' ' << ex + 1 << ' ' << ey + 1 << endl;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
int l = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] <= a[i]) {
int n = 0;
n = (a[i] - a[i + 1]) / k + 1;
l = l + n;
a[i + 1] = a[i + 1] + n * k;
}
}
cout << l << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1000], t = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) {
t++;
}
}
if (n == 1 && t == 0) {
cout << "YES";
} else {
if (t == 1 && n > 1) {
cout << "YES";
} else {
cout << "NO";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int count = 0;
int n, m;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n - 1; i++) {
if (a[i][m - 1] != 'D') {
count++;
}
}
for (int i = 0; i < m - 1; i++) {
if (a[n - 1][i] != 'R') {
count++;
}
}
cout << count << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
pair<long long, int> a[N];
long long ans[N];
long long levelPrice[N];
long long n, A, cf, cm, m;
int main() {
ios::sync_with_stdio(false);
cout.precision(10);
cin >> n >> A >> cf >> cm >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
ans[i] = a[i].first;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
levelPrice[i] =
levelPrice[i - 1] + (long long)(i - 1) * (a[i].first - a[i - 1].first);
}
long long neededFull = (long long)A * n;
for (int i = 1; i <= n; i++) {
neededFull -= a[i].first;
}
if (m >= neededFull) {
cout << cf * n + cm * A << "\n";
for (int i = 1; i <= n; i++) {
cout << A << " ";
}
cout << "\n";
return 0;
}
long long best = 0, bnf = 0, bf = 0;
for (int k = n - 1; k >= 0; k--) {
neededFull -= (A - a[n - k].first);
if (neededFull <= m) {
long long rem = m - neededFull;
long long lvl;
if (rem >= levelPrice[n]) {
rem -= levelPrice[n];
lvl = a[n].first;
lvl = min(A, lvl + rem / n);
} else {
int firstFull = n - k + 1;
int pos = upper_bound(levelPrice + 1, levelPrice + n + 1, rem) -
levelPrice - 1;
long long wid;
if (pos + 1 >= firstFull) {
rem -= levelPrice[firstFull - 1];
lvl = a[firstFull - 1].first;
wid = firstFull - 1;
} else {
rem -= levelPrice[pos];
lvl = a[pos].first;
wid = pos;
}
lvl = min(A, lvl + rem / wid);
}
long long cur = k * cf + lvl * cm;
if (cur > best) {
best = cur;
bnf = neededFull;
bf = k;
}
}
}
long long rem = m - bnf;
long long lvl;
int firstFull = n - bf + 1;
if (rem >= levelPrice[n]) {
rem -= levelPrice[n];
lvl = a[n].first;
lvl = min(A, lvl + rem / n);
for (int i = 1; i < firstFull; i++) {
a[i].first = lvl;
}
} else {
int pos =
upper_bound(levelPrice + 1, levelPrice + n + 1, rem) - levelPrice - 1;
long long wid;
if (pos + 1 >= firstFull) {
rem -= levelPrice[firstFull - 1];
lvl = a[firstFull - 1].first;
wid = firstFull - 1;
} else {
rem -= levelPrice[pos];
lvl = a[pos].first;
wid = pos;
}
lvl = min(A, lvl + rem / wid);
for (int i = 1; i <= wid; i++) {
a[i].first = lvl;
}
}
for (int i = firstFull; i <= n; i++) {
a[i].first = A;
}
for (int i = 1; i <= n; i++) {
ans[a[i].second] = a[i].first;
}
cout << best << "\n";
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int X[] = {0, 0, 1, 0, 0, -1};
int Y[] = {0, 1, 0, 0, -1, 0};
int Z[] = {1, 0, 0, -1, 0, 0};
struct node {
int x, y;
node() {}
node(int x, int y) : x(x), y(y) {}
};
int sum, mx;
vector<int> v[200004];
map<int, int> mp;
int a[200005];
bool vis[200005];
void dfs(int u) {
if (vis[u]) return;
sum++;
mp[a[u]]++;
mx = max(mx, mp[a[u]]);
vis[u] = 1;
for (int i = 0; i < v[u].size(); i++) {
int x = v[u][i];
dfs(x);
}
}
int main() {
int i, j, k, l, x, y, z, t, m, n;
memset(vis, 0, sizeof(vis));
cin >> n >> m >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
l = 0;
for (i = 1; i <= n; i++) {
sum = 0, mx = 0;
dfs(i);
l += sum - mx;
mp.clear();
}
printf("%d\n", l);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &c) {
s << "[ ";
for (auto it : c) s << it << " ";
s << "]";
return s;
}
const int MAXN = 101010;
const int INF = 1029384756;
int N, M;
bool ans[MAXN];
vector<pair<int, char> > edge[MAXN];
int abest;
int vis[MAXN];
int good, bad;
vector<int> vlast;
bool dfs(int v, int p, int c, char cc) {
if (vis[v] != -1) return vis[v] == c;
vis[v] = c;
if (c)
bad++;
else
good++;
vlast.push_back(v);
for (auto e : edge[v]) {
int u = e.first;
int dif = (e.second != cc);
if (u == p) continue;
if (!dfs(u, v, c ^ dif, cc)) return false;
}
return true;
}
void calc2(char cc) {
for (int i = 0; i < N; i++) vis[i] = -1;
for (int i = 0; i < N; i++) {
if (vis[i] != -1) continue;
good = bad = 0;
vlast.clear();
bool res = dfs(i, -1, 0, cc);
if (!res) return;
if (bad > good) {
for (auto v : vlast) vis[v] ^= 1;
}
}
int total = 0;
for (int i = 0; i < N; i++) total += vis[i];
if (total < abest) {
abest = total;
for (int i = 0; i < N; i++) ans[i] = vis[i];
}
}
void calc() {
abest = INF;
calc2('R');
calc2('B');
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
for (int i = 0; i < M; i++) {
int u, v;
char c;
cin >> u >> v >> c;
u--;
v--;
edge[u].push_back({v, c});
edge[v].push_back({u, c});
}
calc();
if (abest == INF)
cout << -1 << endl;
else {
cout << abest << endl;
for (int i = 0; i < N; i++)
if (ans[i]) cout << i + 1 << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
while (n % i == 0) n = n / i;
if (n == 1)
cout << i;
else
cout << 1;
return;
}
}
cout << n;
}
int main() {
long long t = 1;
while (t--) {
solve();
cout << endl;
}
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, a, b) for(ll i = ll(a); i <= ll(b); i++)
int main()
{
ll a,b,x;
cin>>a>>b;
string s;
cin>>s;
if(count(s.begin(),s.end(),'-')==1 && s[a]=='-')
cout<<"Yes";
else
cout<<"No";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
void solve() {
int n;
cin >> n;
vector<int> v(n);
for (auto& x : v) {
cin >> x;
}
int g = 0;
for (int i = 0; i < 30; ++i) {
int k = (1 << i);
int c = 0;
for (auto x : v) {
if (x & k) {
++c;
}
}
g = gcd(g, c);
}
for (int i = 1; i <= n; ++i) {
if (g % i == 0) {
cout << i << ' ';
}
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0 || b == 0) return 0;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
int main() {
int n, m, z;
cin >> n >> m >> z;
int lcm = n * m / gcd(n, m);
cout << z / lcm;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a, s, d[200003][6], d1[200003][6], f[6], f1[6], g, h, j, k, l, i, n,
m;
vector<int> v[200003];
void dfs(int idx, int par) {
for (auto it : v[idx]) {
if (it == par) continue;
dfs(it, idx);
d[idx][0]++;
d1[idx][0]++;
for (int i = 1; i < m; i++) {
d[idx][i] += d[it][i - 1];
d1[idx][i] += d1[it][i - 1];
}
d[idx][0] += d[it][m - 1] + d1[it][m - 1];
d1[idx][0] += d1[it][m - 1];
}
for (int i = 0; i < m; i++) {
k += 2 * d[idx][i];
}
d[idx][0]--;
d1[idx][0]--;
for (auto it : v[idx]) {
if (it == par) continue;
for (int i = 1; i < m; i++) {
f[i] = d[it][i - 1];
f1[i] = d1[it][i - 1];
d[idx][i] -= f[i];
d1[idx][i] -= f1[i];
}
f[0] = d[it][m - 1] + d1[it][m - 1];
f1[0] = d1[it][m - 1];
d[idx][0] -= f[0];
d1[idx][0] -= f1[0];
f[0]++;
f1[0]++;
for (int i = 0; i < m; i++) {
if (!d1[idx][i]) continue;
for (int a = 0; a < m; a++) {
if (!f1[a]) continue;
if (i + a + 2 <= m)
k += (d[idx][i] - d1[idx][i]) * f1[a] + (f[a] - f1[a]) * d1[idx][i] +
f1[a] * d1[idx][i];
else {
k += d[idx][i] * f1[a] + f[a] * d1[idx][i];
}
}
}
f[0]--;
f1[0]--;
for (int i = 0; i < m; i++) {
d[idx][i] += f[i];
d1[idx][i] += f1[i];
}
}
d[idx][0]++;
d1[idx][0]++;
}
int main() {
cin >> n >> m;
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &s);
v[a].push_back(s);
v[s].push_back(a);
}
dfs(1, 0);
cout << k / 2;
}
| 4 |
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
typedef pair<int,int> ii;
const int IINF = INT_MAX;
struct Point3d {
int x,y,z;
bool operator < ( const Point3d &p ) const {
if( z != p.z ) return z < p.z;
if( y != p.y ) return y > p.y;
return x > p.x;
}
};
int a, b, C = ~(1<<31), M = (1<<16)-1;
int r() {
a = 36969 * (a & M) + (a >> 16);
b = 18000 * (b & M) + (b >> 16);
return (C & ((a << 16) + b)) % 1000000;
}
const int MAX = 300010;
int m,n,A,B;
Point3d ps[MAX];
set<ii> dp[MAX];
bool check(int index,ii v){
set<ii>::iterator it = dp[index].lower_bound(v);
while( (*it).second < v.second ){
if( (*it).first < v.first ) return true;
--it;
}
return false;
}
void update(int index,ii v){
set<ii>::iterator it = dp[index].lower_bound(v);
--it;
if( (*it).second <= v.second ) return;
++it;
while( (*it).second >= v.second ) dp[index].erase(it++);
dp[index].insert(v);
}
int LIS2D(vector<ii> &vec) {
rep(i,(int)vec.size()+1) {
dp[i].clear();
dp[i].insert(ii(-1,IINF));
dp[i].insert(ii(IINF,-1));
}
dp[0].insert(ii(-1,-1));
int maxi = 0;
rep(i,(int)vec.size()){
int low = 0, hig = i+1;
while( hig - low ) {
int mid = ( low + hig ) / 2;
if( check(mid,vec[i]) ) low = mid + 1;
else hig = mid;
}
maxi = max(maxi,low);
update(low,vec[i]);
}
return maxi + 1;
}
void compute(){
sort(ps,ps+n+m);
vector<ii> vec;
rep(i,n+m) vec.push_back(ii(ps[i].y,ps[i].x));
cout << LIS2D(vec) << endl;
}
int main(){
while( scanf("%d %d %d %d",&m,&n,&A,&B), m|n|A|B ){
a = A, b = B;
rep(i,m) scanf("%d %d %d",&ps[i].x,&ps[i].y,&ps[i].z);
rep(i,n) {
ps[m+i].x = r();
ps[m+i].y = r();
ps[m+i].z = r();
}
compute();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define forn(i,n) for(int i=0;i<(int)(n);i++)
#define si(c) ((int)(c).size())
#define forsn(i,s,n) for(int i = (int)(s); i<((int)n); i++)
#define dforsn(i,s,n) for(int i = (int)(n)-1; i>=((int)s); i--)
#define all(c) (c).begin(), (c).end()
#define D(a) cerr << #a << "=" << a << endl;
#define pb push_back
#define eb emplace_back
#define mp make_pair
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int,int> pii;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 55;
const int L = 18;
int n,k,s,t;
ll a[N], comb[N][N], cnt[1<<L];
ll solve() {
cin >> n >> k >> s >> t;
if ((s & t) != s) return 0;
{
int sz = 0;
forn(_,n) {
ll x; cin >> x;
if ((s & x) != s) continue;
if ((x | t) != t) continue;
a[sz++] = x-s;
}
n = sz;
}
ll ans = 0;
forn(i,n) {
memset(cnt, 0, sizeof cnt);
forsn(j,i+1,n) cnt[a[j]^a[i]]++;
forn(bit,L) forn(mask,1<<L) if ((mask>>bit)&1)
cnt[mask] += cnt[mask - (1<<bit)];
forn(mask,1<<L) cnt[mask] = comb[cnt[mask]][k-1];
forn(bit,L) forn(mask,1<<L) if ((mask>>bit)&1)
cnt[mask] -= cnt[mask - (1<<bit)];
ans += cnt[t-s];
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
forn(n,N) {
comb[n][0] = 1;
forsn(r,1,n+1) comb[n][r] = comb[n-1][r-1] + comb[n-1][r];
}
forn(n,N) {
forsn(r,1,N) comb[n][r] += comb[n][r-1];
}
cout << solve() << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long C[1005][1005];
long long pow1[1005];
const long long mod = 1e9 + 7;
int n, m;
int light[1005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
C[0][0] = 1;
pow1[0] = 1;
pow1[1] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
pow1[i + 1] = pow1[i] * 2 % mod;
}
int num = n - m;
long long ans = 1;
for (int i = 0; i < m; i++) cin >> light[i];
sort(light, light + m);
int len;
for (int i = 0; i < m; i++) {
if (i == 0) {
len = light[i] - 1;
ans = (ans * C[num][len]) % mod;
num -= len;
} else {
len = light[i] - light[i - 1] - 1;
ans = (ans * pow1[len]) % mod;
ans = (ans * C[num][len]) % mod;
num -= len;
}
if (i == m - 1) {
len = n - light[i];
ans = (ans * C[num][len]) % mod;
num -= len;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long v[200002], w[200002], u[400010];
int main() {
long long n, m, i, j, k = 0;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> v[i];
if (v[i] == m) j = i;
}
for (i = j - 1; i >= 1; i--) {
if (v[i] < m)
w[i] = w[i + 1] - 1;
else
w[i] = w[i + 1] + 1;
}
for (i = j + 1; i <= n; i++) {
if (v[i] < m)
w[i] = w[i - 1] - 1;
else
w[i] = w[i - 1] + 1;
}
for (i = j; i >= 1; i--) u[w[i] + 200004]++;
for (i = j; i <= n; i++) {
k += u[0 - w[i] + 200004];
k += u[1 - w[i] + 200004];
}
cout << k;
return 0;
}
| 5 |
#include <cstdio>
int main(){int n,s;while(scanf("%d",&n)+1){for(s=1;n;s*=2){n&s&&printf("%d%c",s,n-s?32:10);n-=n&s;}}} | 0 |
#include<stdio.h>
int main(void)
{
int N,A,B;
scanf("%d%d",&N,&A);
B=N*N-A;
printf("%d\n",B);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string impossible;
mt19937 mt_rand(
chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 5e2 + 5;
const int M = 1e4 + 5;
const int L = 41;
int MOD = 1e9 + 7;
long long n, m, k, i, j, d;
bool f0, f1, f2;
const int MAXN = 2e3;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(11);
int tests = 1;
cin >> tests;
for (int te = 1; te <= tests; te++) {
string s;
cin >> s;
int n = s.size();
priority_queue<int> pq;
for (int i = 0; i < n;) {
int j = i + 1;
if (s[i] == '1') {
while (j < n && s[j] == '1') {
j++;
}
pq.push(j - i);
}
i = j;
}
int a = 0;
while (!pq.empty()) {
a += pq.top();
pq.pop();
if (!pq.empty()) pq.pop();
}
cout << a << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void fillString(unsigned long long int n, string &st) {
while (n > 0) {
int num = n % 10;
n /= 10;
if ((num & 1) == 0) {
st = "0" + st;
} else {
st = "1" + st;
}
}
int left = 18 - st.length();
for (int i = 0; i < left; i++) {
st = "0" + st;
}
return;
}
unordered_map<string, int> mp;
void solve() {
unsigned long long int n;
char operation;
cin >> operation >> n;
string st = "";
fillString(n, st);
if (operation == '?') {
cout << mp[st] << endl;
} else if (operation == '+') {
mp[st]++;
} else {
mp[st]--;
}
}
int main() {
mp.clear();
int t;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
#define rep(i, n) REP(i, 0, n)
#define REP(i, a, n) for(int i=(a); i<n; i++)
pair<pii, pii> cut(pii& p, int s) {
int w = p.first, d = p.second;
s %= 2*w + 2*d;
pii a, b;
if(s < w) {
a = {s, d};
b = {w-s, d};
} else if(s < w+d) {
a = {w, s-w};
b = {w, d-s+w};
} else if(s < w+d+w) {
a = {s-w-d, d};
b = {w-s+w+d, d};
} else {
a = {w, s-w-w-d};
b = {w, d-s+w+w+d};
}
if(a.first*a.second < b.first*b.second)
return {a, b};
return {b, a};
}
int main() {
while(1) {
int n, w, d; cin >> n >> w >> d;
if(n==0 && w==0 && d==0) break;
vector<pii> ps;
ps.push_back({w, d});
rep(i, n) {
int t, s; cin >> t >> s;
t -= 1;
pair<pii, pii> ret = cut(ps[t], s);
ps.erase(ps.begin()+t);
ps.push_back(ret.first);
ps.push_back(ret.second);
if(ret.first.first*ret.first.second < 0 || ret.second.first*ret.second.second<0) {
cout << i << endl;
}
}
vector<int> v;
for(auto p : ps) {
v.push_back(p.first*p.second);
}
sort(v.begin(), v.end());
rep(i, v.size()-1)
cout << v[i] << " ";
cout << v.back() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
template <typename T>
bool PN(T x){ if (x <= 1) return false; if (x == 2) return true; for (int i = 2; i < sqrt(x) + 1; i++) if (x % i == 0) return false; return true;}
const ll MOD = 1e9+7;
long long Comb(int n, int i){long long ans = 1; if(i == 0 || i == n) return 1; else {for(int j = 1; j <= i; ++j){
ans *=(n+1-j);
ans /= j;
ans %= MOD;} }return ans;}
void solve()
{
int n; cin >> n;
int a[n];
for(int i = 0; i < n; ++i){
cin >> a[i];
}
int q; cin >> q;
while(q--){
int k; cin >> k;
int left = 0;
int right = n;
int flag = 0;
int middle = (left+right)/2;
while(left < right){
if(a[middle] == k) {
cout << 1 <<endl;
flag = 1;
break;
} else if(a[middle] > k){
right = middle-1;
} else {
left = middle + 1;
}
middle = (left + right)/2;
if(a[middle] == k) {
cout << 1 << endl;
flag = 1;
break;
}
}
if(!flag) cout << 0 << endl;
}
}
int main()
{
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x, y, q;
void exgcd(int a, int b) {
int temp;
if (b == 0) {
x = 1;
y = 0;
q = a;
} else {
exgcd(b, a % b);
temp = x;
x = y;
y = temp - a / b * y;
}
}
int c3, c4, c5;
int k3, k4, k5;
int f, x0, Why_Cant_I_Use_y0_In_Eclipse;
int up, down;
void init() {
up = 0xfffffff;
down = -0xfffffff;
down = max(down, (-x * f) / x0);
if (x * f + x0 * down < 0) down++;
up = min(up, (k4 - x * f) / x0);
if (x * f + x0 * up > k4) up--;
up = min(up, (y * f - k4) / Why_Cant_I_Use_y0_In_Eclipse);
if (y * f - Why_Cant_I_Use_y0_In_Eclipse * up < k4) up--;
}
int o3, o4, o5;
int ans;
void get_o(int t) {
o3 = x * f + x0 * t;
o4 = k4;
o5 = y * f - Why_Cant_I_Use_y0_In_Eclipse * t;
}
void solve(int s) {
exgcd(c3, c5);
if (s % q != 0) return;
f = s / q;
x0 = c5 / q;
Why_Cant_I_Use_y0_In_Eclipse = c3 / q;
{
init();
down = max(down, (c4 * k4 - c3 * x * f) / (c3 * x0));
if (c3 * x * f + c3 * x0 * down < c4 * k4) down++;
up = min(up, (c5 * y * f - c4 * k4) / (c5 * Why_Cant_I_Use_y0_In_Eclipse));
if (c5 * y * f - c4 * k4 < c5 * Why_Cant_I_Use_y0_In_Eclipse * up) up--;
if (down <= up) {
int judge = s - 2 * c4 * k4;
if (judge < ans) {
ans = judge;
get_o(down);
}
}
}
{
init();
up = min(up, (c4 * k4 - c3 * x * f) / (c3 * x0));
if (c4 * k4 - c3 * x * f < c3 * x0 * up) up--;
down =
max(down, (c5 * y * f - c4 * k4) / (c5 * Why_Cant_I_Use_y0_In_Eclipse));
if (c5 * y * f - c5 * Why_Cant_I_Use_y0_In_Eclipse * down > c4 * k4) down++;
if (down <= up) {
int judge = 2 * c4 * k4 - s;
if (judge < ans) {
ans = judge;
get_o(up);
}
}
}
{
init();
down = max(down, (c4 * k4 - c3 * x * f) / (c3 * x0));
if (c3 * x * f + c3 * x0 * down < c4 * k4) down++;
down =
max(down, (c5 * y * f - c4 * k4) / (c5 * Why_Cant_I_Use_y0_In_Eclipse));
if (c5 * y * f - c5 * Why_Cant_I_Use_y0_In_Eclipse * down > c4 * k4) down++;
if (down <= up) {
int judge = c3 * (x * f + x0 * down) -
c5 * (y * f - Why_Cant_I_Use_y0_In_Eclipse * down);
if (judge < ans) {
ans = judge;
get_o(down);
}
}
}
{
init();
up = min(up, (c4 * k4 - c3 * x * f) / (c3 * x0));
if (c4 * k4 - c3 * x * f < c3 * x0 * up) up--;
up = min(up, (c5 * y * f - c4 * k4) / (c5 * Why_Cant_I_Use_y0_In_Eclipse));
if (c5 * y * f - c4 * k4 < c5 * Why_Cant_I_Use_y0_In_Eclipse * up) up--;
if (down <= up) {
int judge = -c3 * (x * f + x0 * up) +
c5 * (y * f - Why_Cant_I_Use_y0_In_Eclipse * up);
if (judge < ans) {
ans = judge;
get_o(up);
}
}
}
}
int main() {
int n, s;
scanf("%d %d", &n, &s);
c3 = c4 = c5 = 0;
while (n--) {
int f;
scanf("%d", &f);
if (f == 3) c3++;
if (f == 4) c4++;
if (f == 5) c5++;
}
ans = 0xfffffff;
for (int i = 0; i <= s; i++) {
if (c4 * i > s) break;
k4 = i;
solve(s - c4 * k4);
}
if (ans == 0xfffffff)
printf("-1\n");
else {
printf("%d %d %d\n", o3, o4, o5);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
const int Mod = 1e9 + 7;
const int Inf = (1LL << 31) - 1;
const int Maxx = 2e5;
void _case() {
int n;
cin >> n;
int one = 0, zero = 0, x;
ll ans = 1;
while (n--) {
cin >> x;
if (x) {
one++;
if (one == 2) {
ans *= zero + 1;
zero = 0;
one--;
}
} else {
if (one) zero++;
}
}
cout << (one ? ans : 0);
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
_case();
return 0;
}
| 2 |
#include<iostream>
#define LEFT 0x01
#define RIGHT 0x02
#define BOTH 0x03
using namespace std;
typedef unsigned long long int ull;
int main()
{
while(true){
int n;
int ans=0;
cin>>n;if(n==0)break;
ull cls[n][n],hand[n][n],shrow[n],hgcol[n];
fill(shrow,shrow+n,~(0ULL));fill(hgcol,hgcol+n,0);
for(int i=0;i<n;++i)for(int j=0;j<n;++j){ull t;cin>>t;cls[i][j]=t;shrow[i]=min(t,shrow[i]);hgcol[j]=max(t,hgcol[j]);hand[i][j]=0;}
for(int i=0;i<n;++i)for(int j=0;j<n;++j){if(cls[i][j]==shrow[i])hand[i][j]|=LEFT;if(cls[i][j]==hgcol[j])hand[i][j]|=RIGHT;}
for(int i=0;i<n;++i)for(int j=0;j<n;++j){if(hand[i][j]==BOTH){ans=cls[i][j];}}
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000000;
const int MAXN = 810;
const int MAXE = 1000000;
struct Edge {
int s, e, nx, c;
double co;
} E[MAXE];
int head[MAXN], cnt;
void add(int s, int e, int c, double co) {
E[cnt].s = s;
E[cnt].e = e;
E[cnt].c = c;
E[cnt].co = co;
E[cnt].nx = head[s];
head[s] = cnt++;
swap(s, e);
E[cnt].s = s;
E[cnt].e = e;
E[cnt].c = 0;
E[cnt].co = -co;
E[cnt].nx = head[s];
head[s] = cnt++;
}
double dis[MAXN];
int q[1000000], mi[MAXN], pre[MAXN];
bool vst[MAXN];
bool spfa(int V, int s, int t) {
for (int i = 0; i <= V; i++) {
dis[i] = oo;
vst[i] = 0;
}
int l = 0, r = 0;
q[r++] = s;
vst[s] = 1;
dis[s] = 0;
while (l != r) {
int u = q[l++];
vst[u] = 0;
for (int i = head[u]; ~i; i = E[i].nx) {
int v = E[i].e;
if (E[i].c && dis[v] - E[i].co > dis[u]) {
dis[v] = dis[u] + E[i].co;
pre[v] = i;
if (!vst[v]) {
q[r++] = v;
vst[v] = 1;
}
}
}
}
return dis[t] != oo;
}
int flow;
double co;
void mincost(int V, int s, int t) {
flow = 0;
co = 0;
while (spfa(V, s, t)) {
int now = t;
while (now != s) {
E[pre[now]].c--;
E[pre[now] ^ 1].c++;
now = E[pre[now]].s;
}
flow++;
co += dis[t];
}
}
int x[MAXN], y[MAXN], n;
double cal(int i, int j) {
return sqrt(1.0 * (x[i] - x[j]) * (x[i] - x[j]) +
1.0 * (y[i] - y[j]) * (y[i] - y[j]));
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x[i], &y[i]);
}
for (int i = 0; i <= 2 * n + 2; i++) {
head[i] = -1;
}
cnt = 0;
int S = 2 * n + 1, T = 2 * n + 2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (y[i] > y[j]) {
add(i, j + n, 1, cal(i, j));
}
}
}
for (int i = 1; i <= n; i++) {
add(S, i, 2, 0);
add(n + i, T, 1, 0);
}
mincost(2 * n + 2, S, T);
if (flow != n - 1) {
puts("-1");
} else {
printf("%.15f\n", co);
}
}
return 0;
}
| 5 |
#include <iostream>
#include <string>
int main()
{
int n, a, b;
std::cin >> n >> a >> b;
std::string s;
std::cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == 'a' && a+b > 0) {
std::cout << "Yes" << std::endl;
if (a > 0) { a--; }
else { b--; }
}
else if (s.at(i) == 'b' && b > 0) {
std::cout << "Yes" << std::endl;
b--;
}
else {
std::cout << "No" << std::endl;
}
}
return 0;
} | 0 |
#include<iostream>
using namespace std;
int main(){
int a;
cin >> a;
int b = a / 200;
cout << 10 - b << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x[101] = {0}, y[101] = {0};
char c;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c;
if (c == '*') {
x[i]++;
y[j]++;
}
}
}
for (int i = 1; i <= n; i++) {
if (x[i] == 1) cout << i << ' ';
}
for (int i = 1; i <= m; i++) {
if (y[i] == 1) cout << i << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2")
using namespace std;
using ll = long long;
int a[101001];
int b[101010];
int dp[101010];
int p1[101010];
int p2[101010];
ll ans = 0;
int n, k;
void add(int* __restrict a, int* __restrict dp, int n) {
for (int i = 0; i < n; ++i) {
a[i]++;
ans -= a[i] == 0 ? dp[i] : 0;
}
}
void sub(int* __restrict a, int* __restrict dp, int n) {
for (int i = 0; i < n; ++i) {
ans += a[i] == 0 ? dp[i] : 0;
a[i]--;
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
b[i] = -k - 1;
cin >> a[i];
--a[i];
p1[i] = p2[i] = -1;
}
dp[0] = 1;
ans = 1;
for (int i = 0; i < n; ++i) {
int x = a[i];
sub(b + p2[x] + 1, dp + p2[x] + 1, p1[x] - p2[x]);
add(b + p1[x] + 1, dp + p1[x] + 1, i - p1[x]);
ans %= 998244353;
if (ans < 0) ans += 998244353;
dp[i + 1] = (int)ans;
ans *= 2;
p2[x] = p1[x];
p1[x] = i;
}
cout << ans / 2 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> fs(20, 1);
for (int i = int(1); i < int(20); i++) fs[i] = fs[i - 1] * i;
vector<long long> ls;
for (int i = 1; i <= 10; i++) {
for (int j = int(0); j < int(1 << i); j++) {
long long n = 0;
for (int k = int(0); k < int(i); k++) {
n *= 10;
if (1 << k & j)
n += 7;
else
n += 4;
}
ls.push_back(n);
}
}
sort((ls).begin(), (ls).end());
for (int n, k; cin >> n >> k && n | k;) {
if (n < 20 && fs[n] < k) {
cout << -1 << endl;
continue;
}
k--;
int len = upper_bound((fs).begin(), (fs).end(), k) - fs.begin();
vector<int> a(len);
iota((a).begin(), (a).end(), 0);
for (int i = int(0); i < int(len); i++) {
int p = k / fs[len - 1 - i];
rotate(a.begin() + i, a.begin() + i + p, a.begin() + i + p + 1);
k -= fs[len - 1 - i] * p;
}
int res = 0;
for (int i = int(0); i < int(ls.size()); i++)
if (ls[i] <= n - len) res++;
for (int i = int(0); i < int(len); i++)
if (binary_search((ls).begin(), (ls).end(), n - len + a[i] + 1) &&
binary_search((ls).begin(), (ls).end(), n - len + i + 1))
res++;
cout << res << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, len, x, ans, s;
int main() {
cin >> x;
x = abs(x);
while (x > s) {
ans++;
s += ans;
}
while ((s - x) % 2 == 1) {
ans++;
s += ans;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const long long z = 127, MOD = 1e9 + 7;
long long Z[MAXN + 1];
void fillZ() {
Z[0] = 1;
for (int n = 1; n <= MAXN; ++n) Z[n] = z * Z[n - 1] % MOD;
}
struct RollingHashing {
vector<long long> H;
RollingHashing(string &S) {
int N = S.length();
H.resize(N + 1);
H[N] = 0;
for (int i = N - 1; i >= 0; --i) H[i] = (S[i] + z * H[i + 1]) % MOD;
}
long long hash(int i, int k) {
long long ans = (H[i] - Z[k] * H[i + k] % MOD);
return ans >= 0 ? ans : ans + MOD;
}
};
int main() {
string ss1, ss2;
cin >> ss1 >> ss2;
string s1, s2;
if (ss1.size() > s2.size()) {
s1 = ss2;
s2 = ss1;
} else {
s1 = ss1;
s2 = ss2;
}
long long n1 = s1.size();
long long n2 = s2.size();
fillZ();
RollingHashing rh1(s1);
RollingHashing rh2(s2);
long long d = 0;
for (long long k = 1; k <= n1; ++k) {
if (n1 % k == 0) {
bool divisor1 = true;
for (long long i = 0; i < n1; i += k) {
if (rh1.hash(0, k) == rh1.hash(i, k)) {
divisor1 = true;
} else {
divisor1 = false;
break;
}
}
if (divisor1) {
if (n2 % k == 0) {
bool divisor2 = true;
for (long long i = 0; i < n2; i += k) {
if (rh1.hash(0, k) == rh2.hash(i, k)) {
divisor2 = true;
} else {
divisor2 = false;
break;
}
}
if (divisor2) {
d++;
}
}
}
}
}
cout << d;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
const int N = 1e3 + 5;
const long long M = 1e9 + 7;
long long dp[N][N];
long long is_in[N][N];
struct Point {
long long y, x;
Point(long long x_, long long y_) : x(x_), y(y_){};
Point(){};
};
Point vers[N];
long long cross(Point& a, Point& b, Point& c) {
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
int odc(int a, int b, int c, int d) {
if (a > b) {
swap(a, b);
}
if (c > d) {
swap(c, d);
}
return !((b < c) || (d < a));
}
int main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
double beg = 1.0 * clock() / CLOCKS_PER_SEC;
int n;
cin >> n;
;
for (int i = (1); i <= (n); ++i) {
int y, x;
cin >> y >> x;
;
vers[i] = Point(y, x);
}
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
is_in[i][j] = true;
if (abs(i - j) == 1 || abs(i - j) == (n - 1)) {
continue;
}
for (int k = (1); k <= (n); ++k) {
if (k == i || k == j) {
continue;
}
int kk = 1 + k % n;
if (kk == i || kk == j) {
continue;
}
long long cr1 = cross(vers[i], vers[j], vers[k]);
long long cr2 = cross(vers[i], vers[j], vers[kk]);
bool first_inter = false;
bool second_inter = false;
if (cr1 == 0 && cr2 == 0) {
first_inter = false;
;
} else {
if ((cr1 <= 0 && cr2 >= 0) || (cr1 >= 0 && cr2 <= 0)) {
first_inter = true;
}
}
cr1 = cross(vers[k], vers[kk], vers[i]);
cr2 = cross(vers[k], vers[kk], vers[j]);
if (cr1 == 0 && cr2 == 0) {
first_inter = false;
} else {
if ((cr1 <= 0 && cr2 >= 0) || (cr1 >= 0 && cr2 <= 0)) {
second_inter = true;
}
}
if (first_inter && second_inter) {
is_in[i][j] = false;
}
}
int ii = 1 + i % n;
long long abs_area = 0;
long long area_left = 0;
long long area_right = 0;
bool passed = false;
while (ii != i) {
if (ii == j) {
passed = true;
}
long long tr_area = cross(vers[i], vers[ii], vers[1 + ii % n]);
if (passed) {
area_right += tr_area;
} else {
area_left += tr_area;
}
ii = 1 + ii % n;
}
if ((area_left >= 0 && area_right <= 0) ||
(area_left <= 0 && area_right >= 0)) {
if (is_in[i][j]) {
}
is_in[i][j] = false;
}
}
}
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
cerr << is_in[i][j];
}
cerr << "\n";
}
for (int i = 1; i <= n; i++) {
int ii = 1 + i % n;
dp[i][ii] = 1;
}
for (int dl = 2; dl <= n - 1; dl++) {
for (int i = 1; i <= n; i++) {
int ii = 1 + (i + dl - 1) % n;
int mid = 1 + i % n;
while (mid != ii) {
if (is_in[i][mid] && is_in[mid][ii]) {
dp[i][ii] = (dp[i][ii] + dp[i][mid] * dp[mid][ii]) % M;
}
mid = 1 + mid % n;
}
if (is_in[i][ii] == 0) {
dp[i][ii] = 0;
}
}
}
assert(dp[2][1] == dp[1][n]);
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
assert(is_in[i][j] == is_in[j][i]);
}
}
cout << dp[2][1] << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
const int N=3003,mod=1e9+7,inv2=5e8+4;
int n,m,Q,a[N],f[N][N];
void add(int &x,int y){x=(x+y)%mod;}
int main()
{
scanf("%d%d",&n,&Q);
for(int i=1;i<=n;i++)scanf("%d",&a[i]);
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)f[i][j]=a[i]<a[j]?1:0;
for(int T=1;T<=Q;T++)
{
int x,y;scanf("%d%d",&x,&y);
for(int i=1;i<=n;i++)
if(i!=x&&i!=y)
{
f[i][x]=f[i][y]=1ll*(f[i][x]+f[i][y])*inv2%mod;
f[x][i]=f[y][i]=1ll*(f[x][i]+f[y][i])*inv2%mod;
}
f[x][y]=f[y][x]=1ll*(f[x][y]+f[y][x])*inv2%mod;
}
int ans=0;
for(int i=1;i<=n;i++)
for(int j=1;j<i;j++)
ans=(ans+f[i][j])%mod;
for(int i=1;i<=Q;i++)ans=2ll*ans%mod;
printf("%d\n",ans);
} | 0 |
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
#include <cmath>
using namespace std;
typedef long long i64;
typedef long double ld;
typedef pair<i64,i64> P;
#define rep(i,s,e) for(int i = (s);i <= (e);i++)
int n;
int m;
vector<ld> a(505,0);
ld dp[505][505];
ld sum[505];
int main(){
cin >> n >> m;
for(int i = 1;i <= n;i++){
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for(int i = 0;i < 505;i++){
for(int j = 0;j < 505;j++){
dp[i][j] = -1e9;
}
}
dp[0][0] = 0;
rep(i,1,n){
rep(j,1,m){
rep(from,0,i - 1){
dp[i][j] = max(dp[i][j] , dp[from][j - 1] + (sum[i] - sum[from])/(i - from));
}
}
}
cout << fixed << setprecision(8);
cout << dp[n][m] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int md = 1e9;
const int xn = 1e5 + 10;
const int xm = 1e6 + 10;
const int SQ = 450;
const int sq = 1e3 + 10;
const int inf = 1e9 + 10;
long long power(long long a, long long b) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2) % md
: power(a * a % md, b / 2) % md));
}
long long jaam(int a, int b) { return (a + b) % md; }
long long menha(int a, int b) { return (a - b + md) % md; }
long long zarb(int a, int b) { return (1LL * a * b) % md; }
int n;
string name;
map<string, int> mp;
set<string> st;
vector<pair<int, string> > vec;
bool cmp(pair<int, string> i, pair<int, string> j) {
if (i.first != j.first) return i.first > j.first;
return i.second < j.second;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> name >> n;
for (int i = 0; i < n; i++) {
string a, b, c, d, e;
cin >> a >> b >> c >> d;
string dd = "";
if (b == "posted") {
cin >> e;
for (int j = 0; j < d.size() - 2; j++) dd += d[j];
d = dd;
if (a == name || d == name) mp[a] += 15, mp[d] += 15;
st.insert(a), st.insert(d);
} else if (b == "commented") {
cin >> e;
for (int j = 0; j < d.size() - 2; j++) dd += d[j];
d = dd;
if (a == name || d == name) mp[a] += 10, mp[d] += 10;
st.insert(a), st.insert(d);
} else {
for (int j = 0; j < c.size() - 2; j++) dd += c[j];
c = dd;
if (a == name || c == name) mp[a] += 5, mp[c] += 5;
st.insert(a), st.insert(c);
}
}
for (string x : st) {
vec.push_back({mp[x], x});
}
sort(vec.begin(), vec.end(), cmp);
for (int i = 0; i < vec.size(); i++)
if (vec[i].second != name) cout << vec[i].second << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define mod 998244353
long long pw[5000005],fact[5000005],inv[5000005];
long long pow_log(long long x,int y)
{
if (!y)
return 1;
long long ret=pow_log(x,y/2);
ret=(ret*ret)%mod;
if (y%2)
ret=(ret*x)%mod;
return ret;
}
int ncr(int n,int r)
{
return ((fact[n]*inv[r])%mod*inv[n-r])%mod;
}
int main()
{
int n;
scanf("%d",&n);
n/=2;
fact[0]=1;
pw[0]=1;
for (int i=1;i<=n;i++)
{
fact[i]=(i*fact[i-1])%mod;
pw[i]=(2*pw[i-1])%mod;
}
inv[n]=pow_log(fact[n],mod-2);
for (int i=n-1;i>=0;i--)
inv[i]=((i+1)*inv[i+1])%mod;
int ans=0,sum=pw[n];
for (int a=0;a<=n;a++)
{
long long tmp=(ncr(n,a)*pw[n-a])%mod;
ans=(ans+2*tmp*sum-tmp*tmp%mod+mod)%mod;
if (a!=n)
{
sum=(sum+ncr(n,a+1)*pw[n-a-1])%mod;
sum=(sum-ncr(n,a)*pw[a]%mod+mod)%mod;
}
}
printf("%d",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T, class... U>
void DEBUG(const T &head, const U &...tail) {}
int MOD = 1e9 + 7;
void ADD(int64_t &x, int64_t v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
struct Combination {
int a[12], xb, s[SIZE][12], j, jf[SIZE], vf[SIZE], mod;
void init(int _mod) {
mod = _mod;
int x = mod, y = mod;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
a[++xb] = i;
y = y / i * (i - 1);
while (x % i == 0) x /= i;
}
if (x > 1) a[++xb] = x, y = y / x * (x - 1);
*jf = *vf = 1;
for (int i = (1); i < (SIZE); ++i) {
for (x = i, memcpy(s[i], s[i - 1], 48), j = 1; j <= xb; ++j)
if (x % a[j] == 0)
while (x % a[j] == 0) x /= a[j], ++s[i][j];
jf[i] = 1ll * jf[i - 1] * x % mod;
vf[i] = 1ll * vf[i - 1] * pow(x, y - 1) % mod;
}
}
int pow(int x, int y) {
int ans = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) ans = 1ll * ans * x % mod;
return ans;
}
int64_t C(int x, int y) {
int i, ans = 1ll * jf[x] * vf[y] % mod * vf[x - y] % mod;
for (i = 1; i <= xb; ++i)
ans = 1ll * ans * pow(a[i], s[x][i] - s[y][i] - s[x - y][i]) % mod;
return ans;
}
} cal;
int64_t solve(int n, int x) {
int64_t v = 0;
for (int i = (x); i <= (n); ++i) {
ADD(v, cal.C(n, i) * cal.C(i, (i - x) / 2));
}
return v;
}
int main() {
int n, l, r;
R(n, MOD, l, r);
cal.init(MOD);
int64_t an = solve(n, l);
ADD(an, -solve(n, r + 1));
W(an);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int sum[n];
bool won[n];
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (i)
sum[i] = sum[i - 1] + x - 1;
else
sum[i] = x - 1;
won[i] = x - 1;
}
vector<pair<int, int>> sols;
for (int t = 1; t < n + 1; t++) {
int m1 = 0, m2 = 0;
int from = 0, to = n - 1;
int w1 = 0, w2 = 0;
bool ok = true;
while (from < n) {
to = n - 1;
while (from < to) {
int avg = (from + to) / 2;
int aw = avg - sum[avg] + 1 - m1;
int bw = sum[avg] - m2;
bool b = (aw > bw) == won[avg];
if ((aw > t || bw > t) || (aw == t && bw == t)) {
to = avg - 1;
} else if (aw < t && bw < t) {
from = avg + 1;
} else if (b) {
to = avg - 1;
} else {
from = avg;
to = avg;
break;
}
}
int aw = from - sum[from] + 1 - m1;
int bw = sum[from] - m2;
if (aw < t && bw < t) {
ok = false;
break;
}
m1 += aw;
m2 += bw;
if (aw > bw)
w1++;
else
w2++;
from++;
}
if (!ok) continue;
if (w1 != w2)
if ((w1 < w2 && won[n - 1]) || (w1 > w2 && !won[n - 1]))
sols.push_back({max(w1, w2), t});
}
sort(sols.begin(), sols.end());
cout << sols.size() << endl;
for (int i = 0; i < sols.size(); i++)
cout << sols[i].first << " " << sols[i].second << endl;
return 0;
}
| 2 |
#include <climits>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct edge {
int to, dist, num;
edge(int t, int d, int n):to(t), dist(d), num(n){}
};
struct state {
int pos, num, money;
state(int p, int n, int m):pos(p), num(n), money(m){}
bool operator>(const state& s) const {
return num > s.num;
}
};
vector<vector<edge> > es;
int dijkstra(int s, int t, int l) {
priority_queue<state, vector<state>, greater<state> > que;
vector<vector<int> > nums(es.size(), vector<int>(l + 1, INT_MAX));
que.push(state(s, 0, l));
nums[s][l] = 0;
while(!que.empty()) {
state s = que.top();
que.pop();
if(nums[s.pos][s.money] < s.num)
continue;
if(s.pos == t)
return s.num;
for(int i = 0; i < es[s.pos].size(); ++i) {
const edge& e = es[s.pos][i];
if(nums[e.to][s.money] > nums[s.pos][s.money] + e.num) {
nums[e.to][s.money] = nums[s.pos][s.money] + e.num;
que.push(state(e.to, nums[e.to][s.money], s.money));
}
if(s.money >= e.dist && nums[e.to][s.money - e.dist] > nums[s.pos][s.money]) {
nums[e.to][s.money - e.dist] = nums[s.pos][s.money];
que.push(state(e.to, nums[e.to][s.money - e.dist], s.money - e.dist));
}
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
for(int n, m, l; cin >> n >> m >> l, n;) {
es.clear();
es.resize(n);
for(int i = 0; i < m; ++i) {
int a, b, d, e;
cin >> a >> b >> d >> e;
--a;
--b;
es[a].push_back(edge(b, d, e));
es[b].push_back(edge(a, d, e));
}
cout << dijkstra(0, n - 1, l) << endl;
}
return EXIT_SUCCESS;
} | 0 |
#include <iostream>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
cout << x*y/2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct E {
int v, w, next;
} e[200010];
int head[200010], cnt;
int dis[200010], vis[200010];
int tmp[200010];
map<int, int> Map[200010];
void add(int u, int v, int w) {
e[cnt].v = v;
e[cnt].w = w;
e[cnt].next = head[u];
head[u] = cnt++;
}
queue<int> q;
void spfa(int s, int t) {
int i, u, v, D;
for (i = 1; i <= t; ++i) {
dis[i] = -1;
vis[i] = 0;
}
dis[s] = 0;
while (!q.empty()) q.pop();
q.push(s);
vis[s] = 1;
while (!q.empty()) {
u = q.front();
q.pop();
vis[u] = 0;
for (i = head[u]; ~i; i = e[i].next) {
v = e[i].v;
if (dis[v] == -1 || dis[v] > dis[u] + Map[u][dis[u]] + e[i].w) {
dis[v] = dis[u] + Map[u][dis[u]] + e[i].w;
if (vis[v] == 0) {
q.push(v);
vis[v] = 1;
}
}
}
}
}
int main() {
int n, m, k, a, b, c;
while (scanf("%d%d", &n, &m) == 2) {
memset(head, -1, sizeof(head));
cnt = 0;
while (m--) {
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
add(b, a, c);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &k);
if (k == 0) continue;
for (int j = 0; j < k; ++j) scanf("%d", &tmp[j]);
if (i == n) break;
Map[i][tmp[k - 1]] = 1;
for (int j = k - 2; j >= 0; --j) {
if (tmp[j] + 1 == tmp[j + 1])
Map[i][tmp[j]] = Map[i][tmp[j + 1]] + 1;
else
Map[i][tmp[j]] = 1;
}
}
spfa(1, n);
printf("%d\n", dis[n]);
}
}
| 4 |
#include "bits/stdc++.h"
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
int main() {
int N, K;
cin >> N >> K;
vector<int> x(N);
rep(i, N) cin >> x[i];
int ans = 1e9;
rep(i, N - K + 1) {
int l = x[i], r = x[i + K - 1];
ans = min({ans, abs(l) + r - l, abs(r) + r - l});
}
cout << ans << endl;
} | 0 |
#include <iostream>
#include <cstdio>
using namespace std;
void solve(int s, int g){
if(s <= 5){
if(s < g){
for(int i = s; i < g; i++){
printf("%d ", i);
}
printf("%d\n", g);
}else{
for(int i = s; i > g; i--){
printf("%d ", i);
}
printf("%d\n", g);
}
}else{
if(s < g){
for(int i = s; i < g; i++){
printf("%d ", i);
}
printf("%d\n", g);
}else if(g <= 5){
for(int i = s; i <= 9; i++){
printf("%d ", i);
}
for(int i = 5; i > g; i--){
printf("%d ", i);
}
printf("%d\n", g);
}else{
for(int i = s; i <= 9; i++){
printf("%d ", i);
}
for(int i = 5; i > 0; i--){
printf("%d ", i);
}
for(int i = 0; i < g; i++){
printf("%d ", i);
}
printf("%d\n", g);
}
}
}
int main(void){
int n, s, g;
scanf("%d", &n);
for(int i = 0; i < n; i++){
scanf("%d %d", &s, &g);
solve(s, g);
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,m,a,s=0;
cin>>n>>m;
while(m--)
{
cin>>a;
s=s+a;
}
if(s>n)
cout<<"-1";
else
cout<<(n-s);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string A[100000 + 5], s;
int val[10], fact[10];
int n;
int main() {
cin >> s >> n;
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
for (int i = 0; i < 10; ++i) {
val[i] = i, fact[i] = 10;
}
for (int i = n - 1; i >= 0; i--) {
int d = A[i][0] - '0';
int sz = A[i].size();
long long ac = 0, f = 1;
for (int j = 3; j < sz; j++) {
int cur = A[i][j] - '0';
ac = ((ac * fact[cur]) % 1000000007 + val[cur]) % 1000000007;
f = (f * fact[cur]) % 1000000007;
}
val[d] = ac, fact[d] = f;
}
int sz = s.size();
long long ac = 0;
for (int i = 0; i < sz; i++) {
int cur = s[i] - '0';
ac = ((ac * fact[cur]) % 1000000007 + val[cur]) % 1000000007;
}
cout << ac << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int n, m, k, ki;
vector<int> a[200];
int visited[200];
int counter = 0;
void dfs(int v) {
if (visited[v]) {
return;
}
visited[v] = 1;
for (int i = 0; i < a[v].size(); i++) {
dfs(a[v][i]);
}
}
int main() {
cin >> n >> m;
int all_zeros = 1;
for (int i = 0; i < n; i++) {
cin >> k;
if (k != 0) {
all_zeros = 0;
}
for (int j = 0; j < k; j++) {
cin >> ki;
ki--;
a[i].push_back(ki + 100);
a[ki + 100].push_back(i);
}
}
if (all_zeros) {
cout << n << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (!visited[i]) {
dfs(i);
counter++;
}
}
cout << counter - 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int T, x, a, up, low, mid;
cin >> T >> x;
for (int i = 0; i < T; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
mid = (T + 1) / 2;
if (v[mid - 1] == x) {
cout << "0" << endl;
return 0;
}
up = upper_bound(v.begin(), v.end(), x) - v.begin();
low = lower_bound(v.begin(), v.end(), x) - v.begin();
if (up <= mid && low < mid) {
cout << T - 2 * up << endl;
} else {
cout << low * 2 + 1 - T << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
int check(int no) {
if (no > n || no < 1) return 0;
return 2;
}
int main() {
int i, j, t;
scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
int p_r = c - b;
int p_s = d - a;
int p_t = c + d - a - b;
long long int ans = 0;
for (i = 1; i <= n; i++) {
int flag = 1;
int p = i;
int r = p - p_r;
int s = p - p_s;
int t = p - c - d + a + b;
if (check(r) != 2 || check(s) != 2 || check(t) != 2) {
flag = 0;
}
if (flag) {
ans += (n);
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main()
{
while(true){
int M, T, P, R;
cin >> M >> T >> P >> R;
if(M==0 && T==0 && P==0 && R==0)
break;
int CP[50], TT[50], PT[50][10]; // 正解数，時間計，ペナルティ
for(int i=0; i<T; i++){
CP[i] = TT[i] = 0;
for(int j=0; j<P; j++)
PT[i][j] = 0;
}
for(int i=0; i<R; i++){ // 各チームの正解数，時間計を求める
int m, t, p, j;
cin >> m >> t >> p >> j;
if(j==0){
CP[t-1]++;
TT[t-1] += (m+PT[t-1][p-1]);
}
else{
PT[t-1][p-1] += 20;
}
}
int tnow, tpre = -1; // 今のチーム，1つ前のチーム
bool flg[50]; // 処理済フラグ
for(int i=0; i<T; i++)
flg[i] = false;
for(int i=0; i<T; i++){
tnow = -1;
for(int j=0; j<T; j++){ // 今のチームを求める
if(flg[j])
continue;
if(tnow==-1){
tnow = j;
}
else{
if(CP[j]>CP[tnow] || (CP[j]==CP[tnow] && TT[j]<=TT[tnow])){
tnow = j;
}
}
}
if(tpre!=-1){ // 出力
if(CP[tnow]==CP[tpre] && TT[tnow]==TT[tpre])
cout << '=';
else
cout << ',';
}
cout << tnow+1;
flg[tnow] = true;
tpre = tnow;
}
cout << endl;
}
return 0;
}
| 0 |
#include<stdio.h>
#include<iostream>
using namespace std;
int main(){
int n;
while(1){
scanf("%d",&n);if(n==0)break;
int s=0;int t=0;
for(int i=1;i*i<=n;i++)
{t=n/i;
if(n%i==0){s+=i+t;
if(n==t||t==i)s-=t;
}
//cout<<t<<endl;
}
if(n==1)s=0;
//cout<<s<<endl;
if(s>n)printf("abundant number\n");
if(s==n)printf("perfect number\n");
if(s<n)printf("deficient number\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, count = 0, t, n, k, taps[200], res[200], f[200], m;
cin >> t;
for (i = 1; i <= t; i++) {
count = 0;
cin >> n >> k;
for (j = 1; j <= k; j++) {
cin >> taps[j];
}
for (j = 1; j <= n; j++) f[j] = 0;
while (1) {
for (j = 1; j <= k; j++) {
if (taps[j] + count <= n) f[taps[j] + count] = 1;
if (taps[j] - count > 0) f[taps[j] - count] = 1;
}
count++;
for (m = 1; m <= n; m++) {
if (f[m] == 0) break;
}
if (m > n) break;
}
res[i] = count;
}
for (i = 1; i <= t; i++) cout << res[i] << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 7;
const int MAXN = 4e4 + 10;
int n, k;
int a[MAXN];
int s[70][MAXN << 2], lazy[70][MAXN << 2];
void pushDown(int b, int rt) {
if (s[b][rt] > 0) {
s[b][rt << 1] += lazy[b][rt];
s[b][rt << 1 | 1] += lazy[b][rt];
lazy[b][rt << 1] += lazy[b][rt];
lazy[b][rt << 1 | 1] += lazy[b][rt];
lazy[b][rt] = 0;
}
}
void pushUp(int b, int rt) { s[b][rt] = max(s[b][rt << 1], s[b][rt << 1 | 1]); }
void update(int L, int R, int b, int c, int l, int r, int rt) {
if (l >= L && r <= R) {
s[b][rt] += c;
lazy[b][rt] += c;
return;
}
int m = (l + r) / 2;
pushDown(b, rt);
if (L <= m) update(L, R, b, c, l, m, rt << 1);
if (R > m) update(L, R, b, c, m + 1, r, rt << 1 | 1);
pushUp(b, rt);
}
int query(int L, int R, int b, int l, int r, int rt) {
if (l >= L && r <= R) {
return s[b][rt];
}
int m = (l + r) / 2;
pushDown(b, rt);
int res = 0;
if (L <= m) res = query(L, R, b, l, m, rt << 1);
if (R > m) res = max(res, query(L, R, b, m + 1, r, rt << 1 | 1));
pushUp(b, rt);
return res;
}
int last[MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
update(last[a[i]] + 1, i, 0, 1, 1, n, 1);
for (int j = 1; j <= min(k, i); j++) {
update(last[a[i]] + 1, i, j, 1, 1, n + 1, 1);
int res = query(j, i, j - 1, 1, n + 1, 1);
if (i == n) ans = max(ans, res);
update(i + 1, i + 1, j, res, 1, n + 1, 1);
}
last[a[i]] = i;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
long long int k = n * m;
long long int arr[k + 1];
arr[0] = -1;
map<long long int, long long int> mp1;
long long int t = 0, sum = 0;
for (long long int i = 1; i <= k; i++) {
cin >> arr[i];
if (arr[i] == 1)
mp1[i] = 8;
else
t++;
}
if (t == k) {
cout << "0";
return 0;
}
long long int p = k - m, x, c = 0;
vector<long long int> v;
map<long long int, long long int> mp;
for (long long int i = 1; i < p; i++) {
if (arr[i] == 1 && i % m != 0) {
x = m * ((i / m) + 1) + (i % m);
if (arr[i + 1] == 1 && arr[x] == 1 && arr[x + 1] == 1) {
mp[i] = 8;
mp[i + 1] = 8;
mp[x] = 8;
mp[x + 1] = 8;
sum += 4;
v.push_back(i);
c++;
}
}
}
sum = mp.size();
long long int t1 = mp1.size();
if (sum != t1)
cout << "-1";
else {
cout << c << "\n";
for (long long int i = 0; i < v.size(); i++) {
cout << (v[i] / m) + 1 << " " << (v[i] % m) << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
const long long N = 1e5 + 4;
const long long mod = 1e9 + 7;
vector<long long> adj[N];
long long moves = 0;
long long arr[N];
long long add[N], sub[N];
void dfs(long long i, long long par) {
for (auto a : adj[i]) {
if (a == par) continue;
dfs(a, i);
add[i] = max(add[a], add[i]);
sub[i] = max(sub[i], sub[a]);
}
arr[i] -= add[i];
arr[i] += sub[i];
add[i] += max(0ll, arr[i]);
sub[i] += max(0ll, -arr[i]);
}
void Main() {
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long a;
cin >> a;
long long b;
cin >> b;
adj[a - 1].push_back(b - 1);
adj[b - 1].push_back(a - 1);
}
for (long long i = 0; i < n; i++) cin >> arr[i];
dfs(0, -1);
cout << add[0] + sub[0] << "\n";
}
int32_t main() {
srand(time(0));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 1; i <= t; i++) {
Main();
}
}
| 2 |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
using namespace std;
//const long long int MOD = 1000000007;
//const int MOD = 1000000007;
const int MOD = 998244353;
long long int N, M, K, H, W, L, R;
//int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
if (s.size() == 2) {
if (s[0] == s[1])cout << 1 << endl;
else cout << 2 << endl;
return 0;
}
vector<int>v;
for (auto i : s)v.push_back(i - 'a');
if (s.size() == 3) {
set<vector<int>>st;
st.insert(v);
for (int i = 0; i < 20; i++) {
for (auto j : st) {
for (int k = 0; k < 2; k++) {
if (j[k] != j[k + 1]) {
int a = j[k];
int b = j[k + 1];
j[k] = 3 - a - b;
j[k + 1] = 3 - a - b;
st.insert(j);
j[k] = a;
j[k + 1] = b;
}
}
}
}
cout << st.size() << endl;
return 0;
}
N = s.size();
K = accumulate(v.begin(), v.end(), 0) % 3;
set<int>box;
for (auto i : v)box.insert(i);
if (box.size() == 1) {
cout << 1 << endl;
return 0;
}
vector<vector<vector<vector<long long int>>>>dp(N, vector<vector<vector<long long int>>>(3, vector<vector<long long int>>(2, vector<long long int>(3))));
for (int i = 0; i < 3; i++)dp[0][i][0][i] = 1;
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 2; k++) {
// cout << i << " " << j << " " << k << endl;
for (int l = 0; l < 3; l++) {
dp[i][j][k][l] %= MOD;
for (int m = 0; m < 3; m++) {
if (j != m) {
dp[i + 1][m][k][(l + m) % 3] += dp[i][j][k][l];
}
else {
dp[i + 1][m][1][(l + m) % 3] += dp[i][j][k][l];
}
}
}
}
}
}
long long int ans = 1;
for (int i = 0; i < 3; i++)ans += dp.back()[i][1][K];
ans %= MOD;
for (int i = 1; i < N; i++) {
if (v[i] == v[i - 1]) {
ans--;
break;
}
}
ans += MOD;
ans %= MOD;
cout << ans << endl;
return 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.