solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(void){
int n;
cin >> n;
vector<int> h(n+1, 0), a(n+1, 0);
vector<long long> dp(n+1, 0);
for(int i=1;i<=n;i++) cin >> h[i];
for(int i=1;i<=n;i++) cin >> a[i];
long long ans = 0;
for(int i=1;i<=n;i++){
long long res = 0;
int x = h[i];
while(x > 0){
if(res < dp[x]) res = dp[x];
x -= (x & -x);
}
res += a[i];
x = h[i];
while(x <= n){
if(dp[x] < res) dp[x] = res;
x += (x & -x);
}
if(ans < res) ans = res;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, ans = "";
cin >> s;
if (s.size() == 1)
cout << s << endl;
else {
int i, l = (s.size() + 1) / 2, r = l - 1;
while (r >= 0) {
ans += s[r];
ans += s[l];
r--;
l++;
}
cout << ans.substr(0, s.size()) << endl;
return 0;
}
}
| 1 |
#include<bits/stdc++.h>
#define Rint register int
using namespace std;
const int N = 100003;
int n, m, head[N], to[N << 1], nxt[N << 1];
inline void add(int a, int b){
static int cnt = 0;
to[++ cnt] = b; nxt[cnt] = head[a]; head[a] = cnt;
}
int dfn[N], tim;
inline int dfs(int x, int f){
dfn[x] = ++ tim;
int v = 0;
for(Rint i = head[x];i;i = nxt[i]) if(to[i] != f){
if(!dfn[to[i]]){
int val = dfs(to[i], x);
if(val) printf("%d %d\n", x, to[i]);
else printf("%d %d\n", to[i], x);
v ^= val;
} else {
if(dfn[to[i]] < dfn[x]) continue;
printf("%d %d\n", x, to[i]);
v ^= 1;
}
}
return 1 - v;
}
int main(){
scanf("%d%d", &n, &m);
if(m & 1){puts("-1"); return 0;}
for(Rint i = 1;i <= m;i ++){
int a, b;
scanf("%d%d", &a, &b);
add(a, b); add(b, a);
}
dfs(1, 0);
} | 0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <math.h>
#include <vector>
#include <set>
using namespace std;
typedef long long LL;
static const double EPS = 1e-9;
#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define INFINITY 100000
int cost[20][20];
int main(void){
char s;
int n,m,x1,x2,y1,y2;
REP(i,20)
REP(j,20)
cost[i][j] = (i!=j)?INFINITY:0;
cin>>n>>m;
while(m--){
int a,b,c,d;
cin>>a>>s>>b>>s>>c>>s>>d;
cost[a-1][b-1] = c;
cost[b-1][a-1] = d;
}
cin>>x1>>s>>x2>>s>>y1>>s>>y2;
REP(k,n)
REP(i,n)
REP(j,n)
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j]);
cout << y1 - y2 - cost[x1-1][x2-1] - cost[x2-1][x1-1] << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,q;cin>>n>>q;
ll niko[n];
ll sum[n];
ll a[n];
for(ll i=0;i<n;i++){
cin>>a[i];
if(i==0)sum[i]=a[i];
else sum[i]=sum[i-1]+a[i];
if(i==0||i==1)niko[i]=a[i];
else niko[i]=niko[i-2]+a[i];
}
vector<ll> kyou;
for(ll i=n/2;i<n-1;i++){
ll t=n-i-1;
kyou.push_back((a[i]+a[i-t])/2+1);
}
kyou.push_back((a[n-1]+a[n-2])/2+1);
//for(ll i=0;i<n;i++)cout<<niko[i];return 0;
for(ll i=0;i<q;i++){
ll x;cin>>x;
ll y=upper_bound(kyou.begin(),kyou.end(),x)-kyou.begin();
//cout<<y<<endl;
if(y==0)cout<<sum[n-1]-sum[n/2-1]<<endl;
else if(y==kyou.size()){
cout<<niko[n-1]<<endl;
}
else{
ll u=n/2+y-1;
ll ans=sum[n-1]-sum[u];
cout<<ans+niko[2*u-n+1]<<endl;
}
}
} | 0 |
#include <iostream>
using namespace std;
int main() {
int a, b;
while (1) {
cin >> a >> b;
if (!a && !b) {
break;
}
int d = 0;
if (a < b) {
int c = a;
a = b;
b = c;
}
while (b) {
int c = a % b;
a = b;
b = c;
++d;
}
cout << a << " " << d << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
long long first_largest = v[0];
long long sec_largest = v[1];
if (m == k) {
return 0 * printf("%lld\n", first_largest * m);
}
long long q = m / (k + 1);
long long total = 0l;
total = q * (first_largest * k + sec_largest);
long long rem = m - (q * (k + 1));
total += rem * first_largest;
return 0 * printf("%lld\n", total);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r;
cin >> n >> pos >> l >> r;
if (l == 1 && r == n)
cout << 0;
else if (l == 1)
cout << abs(r - pos) + 1;
else if (r == n)
cout << abs(l - pos) + 1;
else
cout << min(abs(r - pos), abs(l - pos)) + r - l + 2;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int n;
char s[7];
int main(){
scanf("%s",s+1);
for(int i=1;i<=3;i++)if(s[i]==s[i+1])return puts("Bad"),0;
puts("Good");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e6 + 3;
const int inf = (int)1e9;
const int base = 10;
int main() {
string s;
getline(cin, s);
int n = (int)s.size();
if (n % 2 == 1)
cout << string((n + 1) / 2, '4') + string((n + 1) / 2, '7');
else if (string(n / 2, '7') + string(n / 2, '4') < s) {
cout << string((n + 2) / 2, '4') + string((n + 2) / 2, '7');
} else {
string ans = "";
bool f = true;
for (int i = 0; i < n && f; ++i) {
if (s[i] < '4') {
f = false;
ans += '4';
} else if (s[i] != '4' && s[i] < '7') {
f = false;
ans += '7';
} else if (s[i] != '4' && s[i] != '7' && s[i] > '7') {
ans += '4';
bool ost = true;
for (int j = (int)ans.size() - 2; j >= 0 && ost; --j) {
if (ans[j] == '4') {
ost = false;
ans[j] = '7';
}
}
} else
ans += s[i];
}
int a = 0;
int b = 0;
for (int i = 0; i < (int)ans.size(); i++)
if (ans[i] == '4')
a++;
else
b++;
a = (n / 2) - a;
b = (n / 2) - b;
if (a < 0 || b < 0) {
if (a < 0) {
b += a;
for (int i = (int)ans.size() - 1; i >= 0 && a < 0; --i) {
if (ans[i] == '4') {
ans[i] = '7';
a++;
}
}
cout << ans + string(b, '7');
} else {
int j = (int)ans.size() - 1;
while (j >= 0 && (ans[j] != '4' || b <= 0)) {
if (ans[j] == '7') b++;
j--;
}
if (j < 0) {
n += 2;
cout << string(n / 2, '4') + string(n / 2, '7');
} else {
ans[j] = '7';
string cur = "";
int a = 0;
int b = 0;
for (int i = 0; i < j + 1; i++) {
cur += ans[i];
if (ans[i] == '4')
a++;
else
b++;
}
a = (n / 2) - a;
b = (n / 2) - b;
cout << cur + string(a, '4') + string(b, '7');
}
}
} else
cout << ans + string(a, '4') + string(b, '7');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long linf = 1LL << 62;
const int MAX = 510000;
long long dy[8] = {0, -1, 0, 1, 1, -1, 1, -1};
long long dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
const double eps = 1e-7;
template <typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <typename T>
inline void print(T &a) {
for (int i = 0; i < (a.size()); i++) cout << a[i] << " ";
cout << "\n";
}
template <typename T1, typename T2>
inline void print2(T1 a, T2 b) {
cout << a << " " << b << "\n";
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << "\n";
}
long long pcount(long long x) { return __builtin_popcountll(x); }
const long long mod = 1e9 + 7;
void solve() {
int n, x, y;
scanf("%d%d%d", &n, &x, &y);
vector<int> a(n);
for (int i = 0; i < (n); i++) scanf("%d", &a[i]), a[i]--;
vector<pair<int, int> > cnt(n + 1);
for (int i = 0; i < (n + 1); i++) cnt[i] = {0, i};
vector<vector<long long> > ls(n + 1);
for (int i = 0; i < (n); i++) {
cnt[a[i]].first++;
ls[a[i]].push_back(i);
}
priority_queue<pair<int, int> > pq;
long long num = cnt.back().second;
for (int i = 0; i < (n + 1); i++) {
if (cnt[i].first)
pq.emplace(cnt[i]);
else
num = i;
}
int z = y - x;
int rest = n - x;
vector<long long> ans(n, -1);
while (x--) {
pair<int, int> p = pq.top();
pq.pop();
ans[ls[p.second].back()] = p.second;
ls[p.second].pop_back();
cnt[p.second].first--;
p.first--;
pq.emplace(p);
}
sort((cnt).rbegin(), (cnt).rend());
if (z > (rest - cnt[0].first) * 2) {
puts("NO");
return;
}
puts("YES");
vector<pair<long long, long long> > b;
for (int i = 0; i < (n); i++) {
if (ans[i] == -1) {
b.emplace_back(a[i], i);
}
}
sort((b).begin(), (b).end());
int m = b.size();
vector<pair<long long, long long> > c(m);
for (int i = 0; i < (m); i++) {
c[(i + cnt[0].first) % m].second = b[i].second;
c[i].first = b[i].first;
}
for (int i = 0; i < (m); i++) {
if (z && a[c[i].second] != c[i].first)
ans[c[i].second] = c[i].first, z--;
else
ans[c[i].second] = num;
}
for (int i = 0; i < (n); i++) ans[i]++;
print(ans);
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001001;
int n;
vector<int> g[maxn];
int N;
int nex[maxn], prv[maxn];
int l[maxn], r[maxn];
int X[maxn];
void insert(int first, int me, int second) {
nex[first] = me;
nex[me] = second;
prv[second] = me;
prv[me] = first;
}
void dfs(int v, int par = -1) {
for (int u : g[v])
if (u != par) {
l[u] = N++;
insert(prv[l[v]], l[u], l[v]);
r[u] = N++;
insert(l[v], r[u], nex[l[v]]);
dfs(u, v);
}
}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
v--, u--;
g[v].push_back(u);
g[u].push_back(v);
}
int head = 0;
int tail = 1;
nex[head] = tail;
prv[tail] = head;
N = 2;
l[0] = N++;
insert(head, l[0], tail);
r[0] = N++;
insert(l[0], r[0], tail);
dfs(0);
for (int v = head, x = 0; v != tail; v = nex[v]) X[v] = x++;
for (int i = 0; i < n; i++) cout << X[l[i]] << " " << X[r[i]] << "\n";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
typedef long long LL;
const int N=1<<20;
const int MOD=998244353;
const int Inv=499122177;
int add (int x,int y) {x=x+y;return x>=MOD?x-MOD:x;}
int mul (int x,int y) {return (LL)x*y%MOD;}
int dec (int x,int y) {x=x-y;return x<0?x+MOD:x;}
int Pow (int x,int y)
{
if (y==0) return 1;
if (y==1) return x;
int lalal=Pow(x,y>>1);
lalal=mul(lalal,lalal);
if (y&1) lalal=mul(lalal,x);
return lalal;
}
int n,sum;
int a[N];
int p[N],q[N];
int tmp[N];
void FWT (int *a,int nn,int o)
{
for (int u=1;u<=nn;u<<=1)
{
for (int i=0;i<=nn;i++) tmp[i]=0;
for (int i=0;i<=nn;i++)
{
if (i&u) tmp[i]=dec(tmp[i],a[i]),tmp[i^u]=add(tmp[i^u],a[i]);
else tmp[i]=add(tmp[i],a[i]),tmp[i^u]=add(tmp[i^u],a[i]);
}
for (int i=0;i<=nn;i++) {a[i]=tmp[i];if (o==-1) a[i]=mul(a[i],Inv);}
}
}
int main()
{
scanf("%d",&n);n=(1<<n);
for (int u=0;u<n;u++) {scanf("%d",&a[u]);sum=add(sum,a[u]);}
sum=Pow(sum,MOD-2);
for (int u=0;u<n;u++)
{
p[u]=mul(a[u],sum);
q[u]=MOD-1;
}
q[0]=n-1;p[0]=dec(p[0],1);
FWT(p,n-1,1);FWT(q,n-1,1);
for (int u=1;u<n;u++) p[u]=mul(q[u],Pow(p[u],MOD-2));
FWT(p,n-1,-1);
for (int u=0;u<n;u++) printf("%d\n",dec(p[u],p[0]));
return 0;
} | 0 |
#include<iostream>
using namespace std;
int n,k,s=1;
int main(){
cin>>n>>k;
for(int i=0;i<n;i++){
if(s>k) s+=k;
else s*=2;}
cout<<s;} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int mN = 1e5 + 100, mod = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int mul(int a, int b) { return (1LL * a * b) % mod; }
struct node {
int sum[6];
int hasL, lz, s, e;
};
node tree[4 * mN];
int arr[mN], helper[6][mN], nCr[6][6];
void upd(int idx, int s, int e, int val) {
tree[idx].hasL = 1;
tree[idx].lz = val;
for (int i = 0; i < 6; ++i) tree[idx].sum[i] = mul(val, helper[i][e - s + 1]);
}
void shift(int idx, int s, int e) {
if (!tree[idx].hasL) return;
tree[idx].hasL = 0;
int m = s + ((e - s) >> 1), L = (idx << 1) + 1, R = L + 1;
upd(L, s, m, tree[idx].lz);
upd(R, m + 1, e, tree[idx].lz);
}
int w[6];
void merge(node &r, node &L, node &R) {
r.hasL = 0;
r.s = L.s;
r.e = R.e;
w[0] = 1;
for (int i = 0; i < 5; ++i) w[i + 1] = mul(w[i], L.e - L.s + 1);
for (int i = 0; i < 6; ++i) {
r.sum[i] = L.sum[i];
for (int xp = i, wp = 0; xp >= 0; --xp, ++wp) {
add(r.sum[i], mul(w[wp], mul(nCr[i][xp], R.sum[xp])));
}
}
}
void build(int idx, int s, int e) {
if (s == e) {
upd(idx, s, e, arr[s]);
tree[idx].s = s;
tree[idx].e = e;
tree[idx].hasL = 0;
return;
}
int m = s + ((e - s) >> 1), L = (idx << 1) + 1, R = L + 1;
build(L, s, m);
build(R, m + 1, e);
merge(tree[idx], tree[L], tree[R]);
}
void assign(int idx, int s, int e, int a, int b, int val) {
if (s >= a && e <= b) {
upd(idx, s, e, val);
return;
}
if (e < a || s > b) return;
shift(idx, s, e);
int m = s + ((e - s) >> 1), L = (idx << 1) + 1, R = L + 1;
assign(L, s, m, a, b, val);
assign(R, m + 1, e, a, b, val);
merge(tree[idx], tree[L], tree[R]);
}
node get(int idx, int s, int e, int a, int b) {
if (s >= a && e <= b) return tree[idx];
shift(idx, s, e);
int m = s + ((e - s) >> 1), L = (idx << 1) + 1, R = L + 1;
if (a >= m + 1) return get(R, m + 1, e, a, b);
if (b <= m) return get(L, s, m, a, b);
node res, Lr, Rr;
Lr = get(L, s, m, a, b);
Rr = get(R, m + 1, e, a, b);
merge(res, Lr, Rr);
return res;
}
void pre() {
for (int i = 0; i < 6; ++i) {
for (int j = 1; j < mN; ++j) {
helper[i][j] = 1;
for (int k = 0; k < i; ++k) {
helper[i][j] = (1LL * helper[i][j] * j) % mod;
}
add(helper[i][j], helper[i][j - 1]);
}
}
for (int i = 0; i < 6; ++i) nCr[i][i] = nCr[i][0] = 1;
for (int i = 1; i < 6; ++i)
for (int j = 1; j < i; ++j) nCr[i][j] = nCr[i - 1][j] + nCr[i - 1][j - 1];
}
int n, q, a, b, val;
char type;
int main() {
pre();
scanf("%d", &n), scanf("%d", &q);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
build(0, 0, n - 1);
for (int i = 0; i < q; ++i) {
scanf(" %c", &type);
scanf("%d", &a), scanf("%d", &b), scanf("%d", &val);
--a, --b;
if (type == '=') {
assign(0, 0, n - 1, a, b, val);
} else {
node res = get(0, 0, n - 1, a, b);
printf("%d\n", res.sum[val]);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[200100];
int main() {
int n, a, b;
scanf("%d %d %d", &n, &a, &b);
scanf("%s", s);
char l = '*';
int cont = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '.') {
if (a > b && a > 0 && l != 'a') {
a--, cont++, s[i] = 'a';
} else if (b > 0 && l != 'b') {
b--, cont++, s[i] = 'b';
} else if (a > 0 && l != 'a') {
a--, cont++, s[i] = 'a';
}
}
l = s[i];
}
printf("%d\n", cont);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x[1000003], p = 1, t, q, n, m;
int main() {
cin >> n;
for (q = 1; q <= n; q++) {
cin >> t;
while (t--) x[p] = q, p++;
}
cin >> m;
while (m--) cin >> t, cout << x[t] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int k, t;
long long C[20][20];
inline long long calc(int w, vector<int>& v) {
static long long f[20];
memset(f, 0, sizeof f);
*f = 1;
for (int x : v) {
static long long g[20];
memset(g, 0, sizeof g);
for (int d = 0; d <= x; ++d)
for (int i = w; i >= d; --i) g[i] += f[i - d] * C[w - i + d][d];
memcpy(f, g, sizeof f);
}
return f[w];
}
string solve(int w, int k, vector<int>& v, bool flag = 0) {
if (!w) return "";
for (int s = flag; s < 16; ++s)
if (v[s]) {
--v[s];
long long tot = calc(w - 1, v);
if (tot >= k) {
char vs = s < 10 ? (s ^ '0') : (s - 10 + 'a');
return vs + solve(w - 1, k, v);
}
k -= tot;
++v[s];
}
exit(233);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> k >> t;
**C = 1;
for (int i = 1; i < 20; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
vector<int> vc;
for (int i = 0; i < 16; ++i) vc.push_back(t);
for (int w = 1;; ++w) {
--vc[1];
long long tot = calc(w - 1, vc) * 15;
++vc[1];
if (tot >= k) {
cout << solve(w, k, vc, 1) << '\n';
return 0;
}
k -= tot;
}
return 114514;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int M = 222;
int head[N * 2];
struct Edge {
int v, w, nxt;
} es[4 * N * N];
const int inf = 0x3f3f3f3f;
int cnt;
int res[N][N];
int h[2 * N], q[2 * N], tail;
bool makeh(int s, int g) {
memset(h, 0, sizeof(h));
h[s] = 1;
tail = 0;
q[tail++] = s;
for (int j = 0; j < tail; j++) {
int u = q[j];
if (u == g) return true;
for (int i = head[u]; ~i; i = es[i].nxt) {
int v = es[i].v, w = es[i].w;
if (w && h[v] == 0) h[v] = h[u] + 1, q[tail++] = v;
}
}
return false;
}
int dfs(int u, int g, int maxf) {
if (u == g) return maxf;
int ans = 0;
for (int i = head[u]; ~i; i = es[i].nxt) {
int v = es[i].v, w = es[i].w;
if (w && h[v] == h[u] + 1) {
int f = dfs(v, g, min(maxf - ans, w));
ans += f;
es[i].w -= f;
es[i ^ 1].w += f;
if (ans == maxf) return maxf;
}
}
if (ans == 0) h[u] = -1;
return ans;
}
int Dinic(int s, int g) {
int ans = 0;
while (makeh(s, g)) ans += dfs(s, g, inf);
return ans;
}
inline void add_edge(int u, int v, int w) {
es[cnt].w = w;
es[cnt].v = v;
es[cnt].nxt = head[u];
head[u] = cnt++;
es[cnt].w = 0;
es[cnt].v = u;
es[cnt].nxt = head[v];
head[v] = cnt++;
}
int main() {
int n, m;
cin >> n >> m;
memset(head, -1, sizeof(head));
int sum = 0;
int pp = 0;
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
pp += t;
add_edge(0, i, t);
}
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
sum += t;
add_edge(i + n, 2 * n + 1, t);
}
for (int i = 1; i <= n; i++) add_edge(i, i + n, inf);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v + n, inf);
add_edge(v, u + n, inf);
}
int ans = Dinic(0, 2 * n + 1);
if (ans != sum || pp != sum)
puts("NO");
else {
puts("YES");
for (int u = 1; u <= n; u++)
for (int i = head[u]; ~i; i = es[i].nxt) {
int v = es[i].v;
if (v >= n + 1 && v <= 2 * n) res[u][v - n] = es[i ^ 1].w;
}
for (int x = 1; x <= n; x++, puts(""))
for (int y = 1; y <= n; y++) printf("%d ", res[x][y]);
}
}
| 5 |
// Problem: A. Do Not Be Distracted!
// Contest: Codeforces - Codeforces Round #719 (Div. 3)
// URL: https://codeforces.com/contest/1520/problem/A
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// Disclaimer: Don't copy my template, it may lead to plagiarism.
/* Author: Soumy Jain
Handle: soumy_jain || soumyjain
"Beautiful flowers too, eventually wither and fall. That's the fate of all living beings."
"I hate perfection. To be perfect is to be unable to improve any furthur." - Mayuri Kurotsuchi | Bleach
"I smile to show the pressure of heroes and to trick the fear inside of me."
"Gravel may be gravel, but me? I'm the gravel that shatters diamonds."
"If you were to write a story with me in the lead role, it would certainly be...a TRAGEDY." - Kaneki Ken | Tokyo
Ghoul
*/
/******************************************************************************/
// clang-format off
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define SPEEDHACK ios_base::sync_with_stdio(false);cin.tie(NULL);
#define ff first
#define ss second
#define sz(v) (ll)(v).size()
#define file freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define MOD 1000000007 // 998244353
using namespace std;
/******************************************************************************/
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(ll x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(ull x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template<typename T, typename V>
void __print(const pair<T, V> &x) { cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}'; }
template<typename T>
void __print(const T &x) { int f = 0; cerr << '{'; for (auto &i : x) cerr << (f++ ? "," : ""), __print(i); cerr << "}"; }
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) { __print(t); if (sizeof...(v)) cerr << ", "; _print(v...); }
#ifndef ONLINE_JUDGE
#define dbg(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define dbg(x...)
#endif
// clang-format on
/***********************************MAIN***************************************/
// Are you ready to face the wrath of test cases? Good luck noob Soumy!
void work()
{
ll n;
cin >> n;
string s;
cin >> s;
map<char, ll> M;
for (int i = 0; i < n; i++)
{
if (M[s[i]] >= 1)
{
cout << "NO\n";
return;
}
M[s[i]]++;
while (i + 1 < n && s[i] == s[i + 1])
{
i++;
M[s[i]]++;
}
}
cout << "YES\n";
}
int main()
{
SPEEDHACK
// file
ll t = 1;
cin >> t;
while (t--)
{
work();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
string s, ans1, ans2;
int cnt[15], tot;
void calc(int x1, int x2) {
string s1, s2;
int t1[15], t2[15];
memcpy(t1, cnt, sizeof(cnt));
memcpy(t2, cnt, sizeof(cnt));
t1[x1]--;
t2[x2]--;
if (t1[x1] < 0 || t2[x2] < 0) return;
s1 = string(1, '0' + x1);
s2 = string(1, '0' + x2);
int tmp = 1;
for (int i = 0; i <= 9; i++) {
int now = min(t1[i], t2[9 - i]);
t1[i] -= now;
t2[9 - i] -= now;
s1 += string(now, '0' + i);
s2 += string(now, '0' + (9 - i));
tmp += now;
}
int now = min(t1[0], t2[0]);
tmp += now;
s1 = string(now, '0') + s1;
s2 = string(now, '0') + s2;
t1[0] -= now;
t2[0] -= now;
for (int i = 0; i < 10; i++) {
s1 += string(t1[i], '0' + i);
s2 += string(t2[i], '0' + i);
}
reverse(s1.begin(), s1.end());
reverse(s2.begin(), s2.end());
if (tmp > tot) {
tot = tmp;
ans1 = s1;
ans2 = s2;
}
return;
}
int main() {
cin >> s;
memset(cnt, 0, sizeof(cnt));
int len = s.length();
for (int i = 0; i < len; i++) cnt[s[i] - '0']++;
tot = cnt[0];
for (int i = 0; i < 10; i++) ans1 += string(cnt[i], '0' + i);
reverse(ans1.begin(), ans1.end());
ans2 = ans1;
for (int i = 1; i < 10; i++) {
calc(i, 10 - i);
}
cout << ans1 << endl;
cout << ans2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int inf = int(2e9);
const int _inf = -inf;
const int mod = inf + 7;
using namespace std;
bool bad[2002][2002];
vector<int> g[2002];
bool used[2002];
queue<int> q;
int cnt;
vector<int> res;
void bfs(int v) {
used[v] = 1;
cnt++;
res.push_back(v);
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to] && !bad[v][to]) {
bfs(to);
}
}
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
bad[u][v] = 1;
bad[v][u] = 1;
}
int mx = 0;
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
cnt = 0;
res.clear();
bfs(i);
bool flag = 1;
for (int j = 0; j < res.size(); ++j) {
for (int k = j + 1; k < res.size(); ++k) {
if (bad[res[j]][res[k]]) flag = 0;
}
}
if (flag) mx = max(mx, (int)res.size());
}
}
cout << mx;
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int cycl[N], set_val[N], cycl_size[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, m, n;
cin >> h >> m >> n;
vector<int> strt;
bool vis[h];
memset(vis, false, sizeof vis);
int kk = 0;
set<int> dmm[h + 1];
for (long long i = 0; i < m; i++) {
if (vis[i]) {
continue;
}
int ii = i;
int jp = 0;
while (1) {
if (vis[ii]) {
break;
}
set_val[ii] = jp;
cycl[ii] = kk;
dmm[kk].insert(jp);
vis[ii] = true;
ii += m;
ii %= h;
jp++;
}
cycl_size[kk] = jp;
kk++;
}
map<int, int> hash;
map<int, int> final;
long long cnt = 0;
while (n--) {
char ch;
cin >> ch;
if (ch == '+') {
int id, t;
cin >> id >> t;
hash[id] = t;
if (dmm[cycl[t]].find(set_val[t]) != dmm[cycl[t]].end()) {
final[id] = set_val[t];
dmm[cycl[t]].erase(set_val[t]);
continue;
}
set<int>::iterator it, it1;
it = dmm[cycl[t]].lower_bound(set_val[t]);
int xx1;
if (it == dmm[cycl[t]].end()) {
it = dmm[cycl[t]].begin();
xx1 = cycl_size[cycl[t]] + *it - set_val[t];
int jj = *it;
final[id] = jj;
dmm[cycl[t]].erase(jj);
} else {
xx1 = *it - set_val[t];
int jj = *it;
final[id] = jj;
dmm[cycl[t]].erase(jj);
}
cnt += (long long)xx1;
} else {
int id;
cin >> id;
dmm[cycl[hash[id]]].insert(final[id]);
}
}
cout << cnt << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, lo, hi, x, sm = 0, fg = 0;
cin >> n >> hi;
lo = ceil(hi / 2.0);
vector<pair<int, int> > v;
for (long long i = 1; i < n + 1; i++) {
cin >> x;
v.push_back({x, i});
}
sort(v.begin(), v.end());
vector<int> ans;
for (long long i = n - 1; i >= 0; i--) {
if (v[i].first < lo) {
sm += v[i].first;
if (sm < lo)
ans.push_back(v[i].second);
else if (sm >= lo && sm <= hi) {
ans.push_back(v[i].second);
fg = 1;
break;
}
}
if (v[i].first <= hi && v[i].first >= lo) {
ans.push_back(v[i].second);
fg = 1;
break;
}
}
if (!fg)
cout << "-1\n";
else {
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (auto a : ans) cout << a << " ";
cout << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N;
string S;
cin >> N >> S;
vector<int> cnt(26);
for (int i = 0; i < N; i += 2) {
cnt[S[i] - 'a'] += 1;
}
vector<int> p(10);
for (int i = 0; i < 26; i++) {
p[cnt[i]] += 1;
}
int res = 2 * p[1];
for (int i = 2; i <= 9; i++) {
if (p[i] == 1) {
res += 4;
} else if (p[i] >= 2) {
res += 5 + 2 * p[i] - 1;
}
}
cout << res - 1 << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
int cont = 1;
while (k % 2 == 0) {
k /= 2;
cont++;
}
cout << cont << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define each(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define exist(s,e) ((s).find(e)!=(s).end())
#define range(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) range(i,0,n)
#define clr(a,b) memset((a), (b) ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF =1LL << 62;
const int inf =1 << 29;
enum {kRabbit = 0, kCat};
enum {kMigishita = 0, kMigiue};
#define F first
#define S second
int main(void){
vi t(2);
for(int n, m; cin >> n >> t[kRabbit] >> t[kCat] >> m;){
vector<vvi> mats(2, vvi(n, vi(n)));
//(num) -> (y, x)
vector<map<int, pii>> dic(2);
rep(i, 2){
rep(y, n){
rep(x, n){
int num;
cin >> num;
mats[i][y][x] = num;
dic[i][num] = mp(y, x);
}
}
}
vvi rowCnt(2, vi(n));
vvi colCnt(2, vi(n));
vvi nanameCnt(2, vi(2));
string res = "UNKNOWN";
rep(i, m){
int num; cin >> num;
rep(j, 2){
if(dic[j].find(num) == dic[j].end()) continue;
int y = dic[j][num].F,
x = dic[j][num].S;
rowCnt[j][y]++;
colCnt[j][x]++;
int delta = 0;
if(y == x){
if(++nanameCnt[j][0] == n) delta++;
}
if(y == n - 1 - x){
if(++nanameCnt[j][1] == n) delta++;
}
if(rowCnt[j][y] == n) delta++;
if(colCnt[j][x] == n) delta++;
if(delta >= 1 && n == 1) delta = 1;
t[j] -= delta;
}
if(res != "UNKNOWN") continue;
if(t[0] <= 0){
if(t[1] <= 0){
res = "DRAW";
}
else res = "USAGI";
}
else if(t[1] <= 0) res = "NEKO";
}
if(res == "UNKNOWN") res = "DRAW";
cout << res << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <stack>
#include <utility>
#include <numeric>
#include <algorithm>
#include <functional>
#include <cctype>
#include <complex>
#include <string>
#include <cstring>
#include <sstream>
using namespace std;
#define all(c) c.begin(),c.end()
#define rep(i,n) for(int i=0;i<(int)n;i++)
typedef long long ll;
typedef complex<double> point;
typedef pair<int,int> pii;
// →↑←↓
const int dx[] = {1,0,-1,0};
const int dy[] = {0,-1,0,1};
const double EPS = 1e-9;
struct singer{
int cost,pop;
singer() {};
singer(int cost,int pop) : cost(cost),pop(pop) {};
};
int main(){
while(true){
int LIMIT,N,M,X;
cin >> LIMIT >> N >> M >> X;
if(LIMIT == 0) break;
vector<singer> secret(N);
vector<singer> normal(M);
for(int i=0;i<N;i++){
string name;
cin >> name >> secret[i].cost >> secret[i].pop;
}
for(int i=0;i<M;i++){
string name;
cin >> name >> normal[i].cost >> normal[i].pop;
}
vector<vector<int> > vec(M+1,vector<int>(LIMIT+1));
for(int i=0;i<N;i++){
for(int j=i;j<N;j++){
if(i == j){
int cost = secret[i].cost;
int pop = secret[i].pop;
if(cost > LIMIT) continue;
vec[0][cost] = max(vec[0][cost],pop);
}else{
int cost = secret[i].cost + secret[j].cost;
int pop = secret[i].pop + secret[j].pop;
if(cost > LIMIT) continue;
vec[0][cost] = max(vec[0][cost],pop);
}
}
}
for(int i=0;i<M;i++){
vector<vector<int> > next = vec;
for(int j=0;j<M;j++){
for(int k=0;k<=LIMIT;k++){
if(vec[j][k] == 0) continue;
if(k + normal[i].cost > LIMIT) continue;
next[j+1][k+normal[i].cost] = max(vec[j+1][k+normal[i].cost],
vec[j][k]+normal[i].pop);
}
}
vec = next;
}
int maxi = 0;
for(int i=X;i<=M;i++){
for(int j=0;j<=LIMIT;j++){
maxi = max(maxi,vec[i][j]);
}
}
cout << maxi << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
#define rep(i,x,y) for (int i=(x); i<=(y); i++)
#define ll long long
#define N 405
#define mod 1000000007
using namespace std;
int n,c,a[N],b[N],sum[N][N],f[2][N];
void upd(int &x,int y){ x+=y; if (x>=mod) x-=mod; }
void pre(){
rep (i,1,N-1){//sum[i][j]=1^j+2^j+3^j+...+i^j;
sum[i][0]=1;
rep (j,1,N-1) sum[i][j]=(ll)sum[i][j-1]*i%mod;//i^j
rep (j,0,N-1) upd(sum[i][j],sum[i-1][j]);
}
}
int main(){
scanf("%d%d",&n,&c);
pre();
rep (i,1,n) scanf("%d",&a[i]);
rep (i,1,n) scanf("%d",&b[i]);
int nk=0,k=1;
f[0][0]=1;//f[i][j]表示前i个小朋友分了j颗糖
rep (i,0,n-1){
k^=1; nk^=1; memset(f[nk],0,sizeof(f[nk]));
rep (j,0,c) for (int t=0; t+j<=c; t++)//这一轮分了t颗糖
upd(f[nk][t+j],(ll)f[k][j]*(sum[b[i+1]][t]+mod-sum[a[i+1]-1][t])%mod);
}
printf("%d\n",f[nk][c]);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>s;
if(s=="snuke")
{
cout<<char(j-1+'A');
cout<<i;
cout<<endl;
return 0;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
int tree[MAXN];
int n;
int lowbit(int x) { return x & (-x); }
void add(int pos, int val) {
while (pos <= n) {
tree[pos] += val;
pos += lowbit(pos);
}
}
int read(int x) {
int s = 0;
while (x > 0) {
s += tree[x];
x -= lowbit(x);
}
return s;
}
long long sum[MAXN];
long long num[MAXN];
int N;
long long M;
long long solve(long long mid) {
;
memset(tree, 0, sizeof(tree));
;
long long ans = 0;
for (int i = 1; i <= N; i++) {
if (sum[i] >= mid) ans++;
long long t = sum[i] - mid;
int a = upper_bound(num + 1, num + n + 1, t) - num - 1;
int b = lower_bound(num + 1, num + n + 1, sum[i]) - num;
ans += read(a);
add(b, 1);
}
return ans;
}
int main() {
while (cin >> N >> M) {
sum[0] = 0;
long long l, r;
for (int i = 1; i <= N; i++) {
cin >> sum[i];
sum[i] += sum[i - 1];
num[i] = sum[i];
}
sort(num + 1, num + N + 1);
n = unique(num + 1, num + N + 1) - num - 1;
long long best = -1;
l = -1e18;
r = 1e18;
while (l <= r) {
long long mid = (l + r) >> 1;
if (solve(mid) >= M) {
best = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << best << endl;
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
char s[100005];
int n;
queue<int>que;
int main() {
cin >> (s + 1);
n = strlen(s + 1);
if(s[1] == '0' || s[n] == '1') {
puts("-1");
return 0;
}
int i;
for(i = 2; i < n - 1; ++i) if(s[i] != s[n - i]) {
puts("-1");
return 0;
}
for(i = 2; i <= n; ++i) if(s[i] != '0') que.push(i);
que.push(n);
for(i = 1; i < n; ++i) {
if(i == que.front()) que.pop();
cout << i << " " << que.front() << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, cnt5, cnt10;
const long long mod = 1e9 + 7;
long long a[55];
long long dp[55][55][2];
long long Fact[55];
long long fast(long long b, long long e) {
if (!e) return 1;
if (e & 1) return b * fast(b * b % mod, e >> 1) % mod;
return fast(b * b % mod, e >> 1);
}
void init() {
Fact[0] = Fact[1] = 1;
for (long long i = 2; i < 55; i++) Fact[i] = i * Fact[i - 1] % mod;
}
long long nCr(long long n, long long r) {
if (r > n) return 0;
return Fact[n] * fast(Fact[r], mod - 2) % mod * fast(Fact[n - r], mod - 2) %
mod;
}
long long solve(long long fives, long long tens, bool f) {
if (f == 1 && fives + tens == 0) return 0;
long long &ret = dp[fives][tens][f];
if (~ret) return ret;
ret = 5 * 55 * 55 * 55;
if (f == 1) {
if (fives < cnt5) ret = min(ret, solve(fives + 1, tens, 0) + 1);
if (tens < cnt10 && k > 1) ret = min(ret, solve(fives, tens + 1, 0) + 1);
} else {
for (long long i = 0; i <= min(fives, k); i++) {
if (i > k) continue;
long long lft = (k - i) / 2;
if (i || left)
ret = min(ret, solve(fives - i, tens - min(tens, lft), 1) + 1);
}
}
return ret;
}
long long dp2[55][55][205][2];
long long path;
long long solve2(long long fives, long long tens, long long num, bool f) {
if (num > path) return 0;
if (f == 1 && fives + tens == 0) return 1;
long long &ret = dp2[tens][fives][num][f];
if (~ret) return ret;
ret = 0;
if (f == 1) {
for (long long i = 0; i <= cnt5 - fives; i++) {
for (long long j = 0; j <= cnt10 - tens; j++) {
if ((i + j) > 0 && i + j * 2 <= k) {
ret = (ret + nCr(cnt5 - fives, i) * nCr(cnt10 - tens, j) % mod *
solve2(fives + i, tens + j, num + 1, f ^ 1) % mod) %
mod;
}
}
}
} else {
for (long long i = 0; i <= fives; i++) {
for (long long j = 0; j <= tens; j++) {
if ((i + j) > 0 && i + j * 2 <= k) {
ret = (ret + nCr(fives, i) * nCr(tens, j) % mod *
solve2(fives - i, tens - j, num + 1, f ^ 1) % mod) %
mod;
}
}
}
}
return ret;
}
int main() {
init();
cin >> n >> k;
k /= 50;
for (long long i = 0; i < n; i++)
cin >> a[i], cnt5 += (a[i] == 50), cnt10 += (a[i] == 100);
if (!k || (k == 1 && (cnt10 || cnt5 > 1))) return puts("-1\n0");
memset(dp, -1, sizeof dp);
path = solve(cnt5, cnt10, 0);
if (path > 200) return puts("-1\n0");
cout << path << '\n';
memset(dp2, -1, sizeof dp2);
cout << solve2(cnt5, cnt10, 0, 0) << '\n';
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int INF = 2000000000;
const long long LINF = 2000000000000000000;
template <typename T>
void print(vector<T>& a) {
for (int i = 0; i < a.size(); i++) cout << a[i] << ' ';
cout << '\n';
}
template <typename T>
void print(deque<T>& a) {
for (int i = 0; i < a.size(); i++) cout << a[i] << ' ';
cout << '\n';
}
template <typename T>
void print(vector<vector<T>>& a) {
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << ' ';
cout << '\n';
}
}
template <typename T>
void input(vector<T>& a) {
for (int i = 0; i < a.size(); i++) cin >> a[i];
}
template <typename T>
void input(deque<T>& a) {
for (int i = 0; i < a.size(); i++) cin >> a[i];
}
template <typename T>
void input(vector<vector<T>>& a) {
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < a[i].size(); j++) cin >> a[i][j];
}
int n, t;
int K = 600;
unsigned long long ans = 0;
vector<unsigned long long> a;
unsigned long long cnt[1001010];
int l = 1, r = 0;
struct query {
int l, r;
int idx;
};
bool cmp(query a, query b) {
return a.l / K < b.l / K || a.l / K == b.l / K && a.r < b.r;
}
void add(int i) {
ans -= cnt[a[i]] * cnt[a[i]] * a[i];
cnt[a[i]]++;
ans += cnt[a[i]] * cnt[a[i]] * a[i];
}
void del(int i) {
ans -= cnt[a[i]] * cnt[a[i]] * a[i];
cnt[a[i]]--;
ans += cnt[a[i]] * cnt[a[i]] * a[i];
}
void solve() {
scanf("%d%d", &n, &t);
a = vector<unsigned long long>(n);
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
vector<query> q(t);
for (int i = 0; i < t; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].l--, q[i].r--, q[i].idx = i;
}
sort((q).begin(), (q).end(), cmp);
vector<unsigned long long> answer(t);
for (auto to : q) {
while (l > to.l) add(--l);
while (l < to.l) del(l++);
while (r < to.r) add(++r);
while (r > to.r) del(r--);
answer[to.idx] = ans;
}
for (auto to : answer) printf("%I64d\n", to);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tst = 1;
while (tst--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101;
int a[maxn];
int n;
void enter() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
}
void solve() {
int problem = 0, per = 0, t = -350;
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (t + a[i] > 360) break;
problem++;
t += a[i];
if (t > 0) per += t;
}
printf("%d %d\n", problem, per);
}
int main() {
enter();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> Ind[100007 + 7];
int a[100007 + 7], b[100007 + 7], n, m, s, e;
int Low[307 + 7];
int BS(int val, int x) {
int lo = 0;
int hi = Ind[val].size();
hi--;
int mid;
int ret = -1;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (Ind[val][mid] < x)
lo = mid + 1;
else
ret = Ind[val][mid], hi = mid - 1;
}
return ret;
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &e);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]), Ind[b[i]].push_back(i);
int part = s / e;
Low[0] = 0;
for (int i = 1; i <= part; i++) Low[i] = -1;
int ans = 0;
int vl;
for (int i = 1; i <= n; i++) {
for (int j = part - 1; j >= 0; j--) {
if (Low[j] >= 0) {
int fn = BS(a[i], Low[j] + 1);
if (fn != -1) {
if (Low[j + 1] == -1)
Low[j + 1] = fn;
else
Low[j + 1] = min(fn, Low[j + 1]);
vl = (j + 1) * e + i + fn;
if (vl <= s && ans < j + 1) {
ans = j + 1;
}
}
} else
continue;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
set<long long> ss;
for (int i = 1; i <= 1e6; i++) {
long long need = i * 2;
long long cards = (i * (i + 1)) / 2;
long long lft = cards - i;
need += lft * 3;
if (need > 1e9) break;
ss.insert(-need);
}
while (t--) {
long long n;
cin >> n;
long long cnt = 0;
while (true) {
set<long long>::iterator it = ss.lower_bound(-n);
if (it == ss.end()) break;
cnt++;
n += *it;
}
cout << cnt << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tt;
cin >> tt;
while (tt--) {
string s1, s2;
cin >> s1 >> s2;
long long i = s1.size(), j = s2.size();
while (i > 0 && j > 0) {
if (s1[i - 1] == s2[j - 1]) {
i--;
j--;
} else {
i -= 2;
}
}
if (j <= 0) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
}
| 4 |
//36
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int paper[10][10]={{}};
for(int x,y,s;((cin>>x).ignore()>>y).ignore()>>s;){
static const int dx[]={0,1,0,-1};
static const int dy[]={1,0,-1,0};
if(s==1){
paper[y][x]++;
for(int i=0;i<4;i++){
int ny=y+dy[i];
int nx=x+dx[i];
if(0<=ny&&ny<10&&0<=nx&&nx<10){
paper[ny][nx]++;
}
}
}else{
for(int i=-1;i<=1;i++){
for(int j=-1;j<=1;j++){
int ny=y+i;
int nx=x+j;
if(0<=ny&&ny<10&&0<=nx&&nx<10){
paper[ny][nx]++;
}
}
}
if(s==3){
for(int i=0;i<4;i++){
int ny=y+dy[i]*2;
int nx=x+dx[i]*2;
if(0<=ny&&ny<10&&0<=nx&&nx<10){
paper[ny][nx]++;
}
}
}
}
}
cout<<count(paper[0],paper[0]+100,0)<<endl<<*max_element(paper[0],paper[0]+100)<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, type, size[10000];
string s, s1;
void fin() {
cout << "Impossible";
exit(0);
}
int f(int i) {
if (i == 0)
return 0;
else
return 1;
}
int main() {
cin >> n;
getline(cin, s);
getline(cin, s);
int ans = 1;
int cursize = 0;
int cur = 0;
for (int i = 0; i < s.length(); i++) {
cursize++;
if (s[i] <= 'Z' && s[i] >= 'A') type = 0;
if (s[i] <= 'z' && s[i] >= 'a') type = 0;
if (s[i] == ' ') type = 1;
if (s[i] == '!' || s[i] == '?' || s[i] == '.') {
cur++;
cursize = -1;
}
size[cur] = cursize + 1;
}
int now = 0;
for (int i = 0; i < cur; i++) {
if (now + size[i] + f(now) > n) {
ans++;
now = size[i];
} else
now += (size[i] + f(now));
if (size[i] > n) fin();
}
cout << ans;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
typedef long long LL;
int N,M;
LL A[100001];
vector<LL>v;
typedef pair<LL,LL>P;
priority_queue<P>q;
priority_queue<P,vector<P>,greater<P> >qq;
int main(){
cin>>N>>M;
REP(i,N){
cin>>A[i];
v.push_back(A[i]);
}
sort(v.begin(),v.end());
reverse(v.begin(),v.end());
int mid=N-1;
REP(i,N){
if(v[i]<=i){
mid=i;
break;
}
}
REP(i,mid){
if(A[i]<=mid){
qq.push(P(max((LL)i,A[i]),i));
}
}
for(int i=mid;i<N;i++){
if(A[i]>=mid){
q.push(P(min((LL)i,A[i]),i));
}
}
REP(i,M){
if(q.empty())break;
if(qq.empty())break;
P p=q.top();q.pop();
P pp=qq.top();qq.pop();
if(pp.first>p.first)continue;
//cout<<pp.second<<" "<<p.second<<endl;
LL temp=A[p.second];
A[p.second]=A[pp.second];
A[pp.second]=temp;
}
LL ans=0;
REP(i,N){
ans+=(LL)abs(i-A[i]);
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
const double PI = 3.1415926535897932384626433832795;
template <class T>
T min(T &a, T &b) {
return (a < b) ? a : b;
}
template <class T>
T max(T &a, T &b) {
return (a > b) ? a : b;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T abs(T &a) {
return (a < 0) ? (-a) : a;
}
inline void read(int &x) { scanf("%d", &x); }
inline void readln(int &x) { scanf("%d\n", &x); }
inline void write(int x) { printf("%d", x); }
inline void writeln(int x) { printf("%d\n", x); }
inline void read(long long &x) { scanf("%lld", &x); }
inline void readln(long long &x) { scanf("%lld\n", &x); }
inline void write(long long x) { printf("%lld", x); }
inline void writeln(long long x) { printf("%lld\n", x); }
inline void read(double &x) { scanf("%lf", &x); }
inline void readln(double &x) { scanf("%lf\n", &x); }
inline void write(double x) { printf("%.15lf", x); }
inline void writeln(double x) { printf("%.15lf\n", x); }
inline void read(char *s) { scanf("%s", s); }
inline void readln(char *s) { scanf("%s\n", s); }
inline void write(char *s) { printf("%s", s); }
inline void writeln(char *s) { printf("%s\n", s); }
inline int readInt() {
int x;
read(x);
return x;
}
inline long long readLong() {
long long x;
read(x);
return x;
}
inline double readDouble() {
double x;
read(x);
return x;
}
inline void showTime() {}
int n;
int t;
string s;
int lh;
int sc[1000007];
int hc[1000007];
int cnts(int a, int b) {
if (b >= n) b = n - 1;
return sc[b + 1] - sc[a];
}
int cnth(int a, int b) {
if (b >= n) b = n - 1;
return hc[b + 1] - hc[a];
}
bool good(int k) {
int curt = t;
int leftest = -1;
for (int i = 0; i <= lh; i++) {
--curt;
if (k < 0) curt -= 2;
if (curt < 0) return false;
int maxlen = curt / 2;
if (i + maxlen >= lh &&
k + cnts(i, i + maxlen) - cnth(i, i + maxlen) >= 0) {
return true;
}
if (s[i] == 'H') {
--k;
} else if (s[i] == 'S') {
++k;
}
}
return false;
}
int main() {
srand((unsigned)time(NULL));
cin >> n >> t;
cin >> s;
for (int i = 0; i < ((int)((s).size())); i++)
if (s[i] == 'H') lh = i;
hc[0] = 0;
sc[0] = 0;
for (int i = 0; i < ((int)((s).size())); i++) {
hc[i + 1] = hc[i];
if (s[i] == 'H') ++hc[i + 1];
sc[i + 1] = sc[i];
if (s[i] == 'S') ++sc[i + 1];
}
int k = 0;
int step = (1 << 20);
while (step) {
if (!good(k + step)) k += step;
step >>= 1;
}
if (!good(k)) ++k;
if (k <= n)
cout << k;
else
cout << -1;
}
| 2 |
#include<iostream>
#include<string>
using namespace std;
int main(){
int n,a,b;
while(true){
cin>>n;
if(n==0)
break;
b=0;
for(int i=0;i<n/4;i++){
cin>>a;
b+=a;
}
cout<<b<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e17;
const int maxn = 3000 + 10;
long long dp[maxn][maxn];
long long n, k, ans, price[maxn];
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++)
if (i < j) dp[i][j] = -inf;
cin >> n >> k;
k <<= 1;
for (int i = 1; i <= n; i++) cin >> price[i];
for (int day = 1; day <= n; day++)
for (int buy = 0; buy <= k; buy++) {
dp[day][buy] = dp[day - 1][buy];
if (buy & 1)
dp[day][buy] = max(dp[day][buy], dp[day - 1][buy - 1] - price[day]);
else if (buy)
dp[day][buy] = max(dp[day][buy], dp[day - 1][buy - 1] + price[day]);
ans = max(ans, dp[day][buy]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
long long s, n, x;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> x, s += x;
long long a = (s - n * (n - 1) / 2) / n;
s -= n * (n - 1) / 2 + a * n;
for (int i = 1; i <= n; i++) {
cout << a + i - (i > s) << ' ';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v, vans;
long long int visited[200005] = {0}, cnt = 0, ans[200005] = {0};
long long int dfs(long long int x) {
visited[x] = 1;
vans.push_back(x);
long long int i, j, k, l;
cnt++;
if (visited[v[x]] == 0) {
ans[v[x]] = dfs(v[x]);
} else {
return cnt;
}
}
int main() {
long long int q;
cin >> q;
while (q--) {
v.clear();
vans.clear();
cnt = 0;
memset(visited, 0, sizeof(visited));
long long int i, j, k, l, n;
cin >> n;
long long int a;
v.push_back(0);
for (i = 1; i <= n; i++) {
cin >> a;
v.push_back(a);
}
for (i = 1; i <= n; i++) {
cnt = 0;
if (v[i] == i) {
ans[i] = 1;
} else if (visited[i] == 0) {
vans.clear();
ans[i] = dfs(i);
}
}
for (i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll ;
#define maxn 100010
int n ;
ll a[maxn],b[maxn] ;
ll c[maxn*2],presum[maxn*2] ;
ll sum, ans, suma, sumb ;
int main(void) {
//freopen("1.txt","r",stdin) ;
scanf("%d",&n) ;
for(int i=0; i<n; i++) {
scanf("%lld%lld", &a[i], &b[i]) ;
suma += a[i] ;
sumb += b[i] ;
}
ans = min(suma, sumb ) ;
for(int i=0; i<n; i++ ) {
c[i*2] = a[i] ;
c[i*2+1] = b[i] ;
}
sort(c,c+2*n) ;
presum[0] = c[0] ;
for(int i=1; i<=2*n; i++) {
presum[i] = presum[i-1]+c[i] ;
}
for(int i=0; i<n; i++) {
int pos = n - 2 ;
int tmp = 0 ;
if( a[i]>c[pos] ) tmp += a[i] ;
else pos ++ ;
if( b[i]>c[pos] ) tmp += b[i] ;
else pos ++ ;
ans = min( ans, tmp + presum[pos-1]) ;
}
printf("%lld\n",ans ) ;
return 0 ;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, l, x, y;
int marks[100001];
int main() {
cin >> n >> l >> x >> y;
for (int i = 0; i < n; ++i) {
cin >> marks[i];
}
bool foundx = false;
bool foundy = false;
bool foundxy = false;
int middle_mark;
for (int i = 0; i < n && (!foundy || !foundx); ++i) {
if (binary_search(marks, marks + n, marks[i] + x)) {
foundx = true;
}
if (binary_search(marks, marks + n, marks[i] + y)) {
foundy = true;
}
if (binary_search(marks, marks + n, marks[i] + x + y)) {
foundxy = true;
middle_mark = marks[i] + x;
}
if (binary_search(marks, marks + n, marks[i] + x - y) &&
marks[i] + x <= l) {
foundxy = true;
middle_mark = marks[i] + x;
}
if (binary_search(marks, marks + n, marks[i] - x + y) &&
marks[i] - x >= 0) {
foundxy = true;
middle_mark = marks[i] - x;
}
}
if (foundx && foundy) {
cout << 0;
return 0;
}
if (foundx) {
cout << 1 << endl << y;
return 0;
}
if (foundy) {
cout << 1 << endl << x;
return 0;
}
if (foundxy) {
cout << 1 << endl << middle_mark;
return 0;
}
cout << 2 << endl << x << " " << y;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int i,j;
string s;
cin>>s;
i=0,j=s.size()-1;
while(s.at(i)!='A')i++;
while(s.at(j)!='Z')j--;
cout<<j-i+1<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5;
int INF = 2e9;
long long qpow(long long a, long long n) {
long long re = 1;
while (n) {
if (n & 1) {
re = re * a;
}
n >>= 1;
a = a * a;
}
return re;
}
long long a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
sort(a + 1, a + n + 1);
long long cnt1 = 0, cnt2 = 0, cnt3 = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == a[1]) {
cnt1++;
}
}
if (a[2] != a[1]) {
for (int i = 1; i <= n; i++) {
if (a[i] == a[2]) {
cnt2++;
}
}
}
if (a[3] != a[2]) {
for (int i = 1; i <= n; i++) {
if (a[i] == a[3]) {
cnt3++;
}
}
}
long long ans;
if (cnt1 >= 3) {
ans = cnt1 * (cnt1 - 1) * (cnt1 - 2) / 6;
} else if (cnt1 + cnt2 >= 3) {
if (cnt1 == 1) {
ans = cnt2 * (cnt2 - 1) / 2LL;
} else {
ans = cnt2;
}
} else {
ans = cnt3;
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 600;
const int INF = 100000000;
int n;
int ara[MAXN];
int dp[MAXN][MAXN];
int query(int lower, int upper) {
if (dp[lower][upper] != -1) return dp[lower][upper];
if (lower == upper) return dp[lower][upper] = 1;
if (upper == lower + 1) {
if (ara[lower] == ara[upper])
return dp[lower][upper] = 1;
else
return dp[lower][upper] = 2;
}
int mini = INF;
if (ara[lower] == ara[upper]) mini = query(lower + 1, upper - 1);
for (int i = lower; i < upper; ++i) {
if (ara[i] == ara[lower])
mini = min(mini, query(lower, i) + query(i + 1, upper));
}
return dp[lower][upper] = mini;
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &ara[i]);
memset(dp, -1, sizeof(dp));
printf("%d\n", query(0, n - 1));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n + 5);
int impares = n - n / 2;
int pares = n / 2;
int s = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] != 0) {
if (v[i] % 2 == 0) {
pares -= 1;
} else {
impares -= 1;
}
}
}
vector<int> g(n);
vector<int> h(n);
int a = 0, b = 0, c = 0, d = 0;
for (int i = 0; i < n; i++) {
if (v[i] == 0) {
a += 1;
}
if (v[i] != 0) {
if (b != 0) {
if (v[i] % 2 == b % 2) {
if (v[i] % 2 == 1) {
g[c] = a;
c += 1;
} else {
h[d] = a;
d += 1;
}
a = 0;
} else {
s += 1;
a = 0;
}
if (v[i] % 2 == 1) {
b = 1;
} else
b = 2;
} else {
if (v[i] % 2 == 1) {
b = 1;
} else
b = 2;
a = 0;
}
}
}
sort(g.begin(), g.begin() + c);
sort(h.begin(), h.begin() + d);
int k = 0;
for (int i = 0; i < c; i++) {
if (impares - g[i] < 0) {
break;
} else {
impares -= g[i];
k += 1;
}
}
s += 2 * (c - k);
int q = 0;
for (int i = 0; i < d; i++) {
if (pares - h[i] < 0) {
break;
} else {
pares -= h[i];
q += 1;
}
}
s += 2 * (d - q);
int m = 0;
if (v[0] == 0) {
for (int i = 0; i < n; i++) {
if (v[i] == 0) {
m += 1;
}
if (v[i] != 0) {
if (v[i] % 2 == 0) {
if (pares - m < 0) {
s += 1;
} else
pares -= m;
}
if (v[i] % 2 == 1) {
if (impares - m < 0) {
s += 1;
} else
impares -= m;
}
break;
}
}
}
int t = 0;
if (v[n - 1] == 0) {
for (int i = n - 1; i > 0; i--) {
if (v[i] == 0) {
t += 1;
}
if (v[i] != 0) {
if (v[i] % 2 == 0) {
if (pares - t < 0) {
s += 1;
} else
pares -= t;
}
if (v[i] % 2 == 1) {
if (impares - t < 0) {
s += 1;
} else
impares -= t;
}
break;
}
}
}
if (s == 0) {
if (n > 1) s = 1;
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 15;
int nx[maxn][maxn], ny[maxn][maxn];
int n, m, ans, ask;
int a[maxn][maxn];
double dp[maxn][maxn];
double slove(int x, int y) {
if (x == 1 && y == 1) return dp[x][y] = 0;
if (dp[x][y] != 1e9) return dp[x][y];
int num = 6;
double res = 0;
int xx = x, yy = y;
for (int i = 1; i <= 6; i++) {
int px = nx[xx][yy], py = ny[xx][yy];
xx = px, yy = py;
if (!px || !py)
num--;
else
res += min(slove(px, py), slove(px - a[px][py], py)) / 6.0;
}
return dp[x][y] = (res + 1.0) * 6.0 / num;
}
int main() {
n = 10;
for (int i = 1; i <= 10; i++)
for (int j = 1; j <= 10; j++) cin >> a[i][j];
for (int i = 10; i >= 1; i--) {
if (i & 1) {
for (int j = 10; j >= 2; j--) {
ny[i][j] = j - 1;
nx[i][j] = i;
}
nx[i][1] = i - 1;
ny[i][1] = 1;
} else {
for (int j = 1; j <= 9; j++) {
ny[i][j] = j + 1;
nx[i][j] = i;
}
nx[i][10] = i - 1;
ny[i][10] = 10;
}
}
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
dp[i][j] = 1e9;
}
}
printf("%.10lf", slove(10, 1));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> divisors;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
divisors.push_back(i);
if (i * i < n) divisors.push_back(n / i);
}
}
divisors.push_back(n);
vector<int> ans;
int val;
for (auto it1 : divisors) {
for (auto it2 : divisors) {
if (it1 == it2) continue;
val = n;
val /= it1;
val /= it2;
if (val >= 2 && ((val * it1) * it2) == n && val != it1 && val != it2) {
ans.push_back(it1);
ans.push_back(it2);
ans.push_back(val);
break;
}
}
if (!ans.empty()) break;
}
if (!ans.empty()) {
cout << "YES\n";
for (auto it : ans) cout << it << " ";
} else
cout << "NO";
cout << "\n";
}
}
| 3 |
#include<bits/stdc++.h>
#define ls p<<1
#define rs p<<1|1
#define fast ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define mm make_pair
#define pi 2*acos(0.0)
#define lcm(a,b) (a*b)/__gcd(a,b)
#define cp(i,ans) printf("%.if",ans);
#define cpp(i,ans) cout.precision(i);cout<<fixed<<ans<<endl;
#define lowbit(x) (x)&(-x)
#define out(x) {cout<<x<<endl;return 0;}
#define all(v) v.begin(),v.end()
#define mem(x,i) memset(x,i,sizeof(x))
#define mec(x,y) memcpy(x,y,sizeof(y))
#define eps 1e-8
#define ull unsigned long long
#define cps CLOCKS_PER_SEC
using namespace std;
typedef long long ll;
const int mod=998244353;
const int inf=0x3f3f3f3f;
ll gcd(ll x,ll y){if(y==0) return x;else return gcd(y,x%y);}
ll ksm(ll a,ll b){ll r=1;while(b){if(b&1) r=(r*a)%mod;a=a*a%mod;b>>=1;}return r;}
void exgcd(ll a, ll b, ll &x, ll &y, ll &d){if(!b) d=a,x=1,y=0;else exgcd(b,a%b,y,x,d),y-=a/b*x;}
ll inv(ll a, ll p){ll x,y,d;exgcd(a,p,x,y,d);x=(x%p+p)%p;return x;}
inline int read()
{
char c=getchar();int x=0,f=1;
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
return x*f;
}
const int maxn=100+100;
int n,m,k,t;
int a[maxn],cnt[maxn];
int main()
{
cin>>t;
while(t--){
cin>>n;
mem(cnt,0);
FOR(i,1,n) cin>>a[i];
FOR(i,1,n) cnt[a[i]]++;
int ans=0;
FOR(i,1,100) ans=max(ans,cnt[i]);
cout<<ans<<endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define fr first
#define sc second
#define mk make_pair
#define pb push_back
#define ll long long
#define OK puts("OK")
#define sz(s) (int)s.size()
#define all(s) s.begin(), s.end()
using namespace std;
const int N = 3e5+10;
const int inf = 1e9+7;
int n, k, q;
char a[N], c;
int t[4*N];
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = 1;
} else {
int tm = (tl + tr) / 2;
build(v + v, tm + 1, tr);
build(v + v + 1, tl, tm);
if (a[v] == '1') t[v] = t[v + v];
if (a[v] == '0') t[v] = t[v + v + 1];
if (a[v] == '?') t[v] = t[v + v + 1] + t[v + v];
}
}
void upd(int p, char c) {
a[n - p] = c;
int v = n - p;
while (v > 0) {
if (a[v] == '1') t[v] = t[v + v];
if (a[v] == '0') t[v] = t[v + v + 1];
if (a[v] == '?') t[v] = t[v + v + 1] + t[v + v];
v /= 2;
}
}
void solve() {
cin >> k;
n = (1 << k);
for (int i = 1; i < n; i++)
cin >> a[i];
reverse(a + 1, a + n);
// for (int i = 1; i < n; i++)
// cout << a[i];
// cout << endl;
build(1, 1, n);
cin >> q;
while (q--) {
int p;
cin >> p >> c;
upd(p, c);
cout << t[1] << endl;
}
}
int main() {
int test = 1;
//cin >> test;
while (test--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5555;
const int INF = 1000000000;
const double EPS = 1e-9;
int a[N], c[N], ans[N], n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < n; ++i) {
int mx = 0, mx_idx = 0;
for (int j = 0; j <= n; ++j) {
c[j] = 0;
}
for (int j = i; j < n; ++j) {
++c[a[j]];
if (c[a[j]] > mx || c[a[j]] == mx && a[j] < mx_idx) {
mx_idx = a[j];
mx = c[a[j]];
}
++ans[mx_idx];
}
}
for (int i = 1; i <= n; ++i) {
printf("%d ", ans[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, S;
cin >> N >> K >> S;
for (int i = 0; i < K; i++) printf("%d ", S);
int val = (S == 1000000000 ? 1 : S + 1);
for (int i = 0; i < N - K; i++) printf("%d ", val);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
double x[111111];
double sX, sY;
int n, K;
double Solve(int l, int r) {
if (l > r) return 0;
return min(hypot(x[l] - sX, sY), hypot(x[r] - sX, sY)) + x[r] - x[l];
}
int main() {
scanf("%d%d", &n, &K);
K--;
for (int i = 0; i < n; ++i) scanf("%lf", x + i);
scanf("%lf%lf", &sX, &sY);
double ans = 1e100;
if (K == n) {
sort(x, x + n);
ans = Solve(0, n - 1);
return printf("%.9f\n", ans), 0;
}
K = x[K];
sort(x, x + n);
K = lower_bound(x, x + n, K) - x;
for (int l = 1; l < n; ++l)
if (l <= K) {
int rl = 0, rr = l - 1;
double a = x[K] - x[l], b = x[n - 1] - x[K], t;
t = 2 * b + a + hypot(x[l] - sX, sY) + Solve(rl, rr);
ans = min(ans, t);
t = 2 * a + b + hypot(x[n - 1] - sX, sY) + Solve(rl, rr);
ans = min(ans, t);
}
for (int r = 0; r < n; ++r)
if (K <= r) {
int rl = r + 1, rr = n - 1;
double a = x[K] - x[0], b = x[r] - x[K], t;
t = 2 * b + a + hypot(x[0] - sX, sY) + Solve(rl, rr);
ans = min(ans, t);
t = 2 * a + b + hypot(x[r] - sX, sY) + Solve(rl, rr);
ans = min(ans, t);
}
printf("%.9f\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using pll = pair<ll, ll>;
template <typename T>
using vec = vector<T>;
using vi = vec<int>;
using vl = vec<ll>;
template <typename T>
using que = queue<T>;
template <typename T>
using deq = deque<T>;
template <typename T>
T id(T b) {
return b;
};
template <typename T>
void chmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void chmin(T &x, T y) {
if (x > y) x = y;
}
template <typename S, typename K>
bool contains(S &s, K k) {
return s.find(k) != s.end();
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
constexpr ll TEN(int n) {
if (n == 0)
return 1LL;
else
return 10LL * TEN(n - 1);
}
class Segtree {
using ll = long long;
int n;
vector<ll> dat;
const ll empty = LLONG_MAX;
inline ll concat(ll a, ll b) { return a + b; }
ll query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return 0;
if (a <= l && r <= b)
return dat[k];
else
return concat(query(a, b, 2 * k + 1, l, (l + r) / 2),
query(a, b, 2 * k + 2, (l + r) / 2, r));
}
public:
Segtree() = default;
Segtree(int n_) {
n = 1;
while (n < n_) n *= 2;
dat.assign(2 * n - 1, 0);
}
void update(int k, ll a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = concat(dat[2 * k + 1], dat[2 * k + 2]);
}
}
ll query(int a, int b) { return query(a, b, 0, 0, n); }
};
const int MAX_N = 100000;
int n;
map<int, set<int>> a;
int main() {
fastio();
cin >> n;
for (int i = 0; i < int(n); i++) {
int x;
cin >> x;
a[x].insert(i);
}
Segtree st(2 * n);
for (int i = 0; i < int(2 * n); i++) {
st.update(i, 1);
}
assert(st.query(0, 2 * n) == 2 * n);
ll ans = 0;
int pos = 0;
while (!a.empty()) {
auto &[x, ps] = *a.begin();
auto it = ps.lower_bound(pos);
if (it == ps.end()) {
it = ps.begin();
}
int pos2 = *it;
if (pos <= pos2) {
ans += st.query(pos, pos2 + 1);
} else {
ans += st.query(pos, pos2 + n + 1);
}
st.update(pos2, 0);
st.update(pos2 + n, 0);
pos = pos2;
ps.erase(pos2);
if (ps.empty()) {
a.erase(x);
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v;
int dp[200][405];
int solve(int idx, int t) {
if (idx == n) {
return 0;
}
if (dp[idx][t] != -1) return dp[idx][t];
int mn = INT_MAX;
for (int i = t; i <= max(t, v[idx]); i++) {
mn = min(mn, abs(v[idx] - i) + solve(idx + 1, i + 1));
}
return dp[idx][t] = mn;
}
int main() {
int tc;
cin >> tc;
while (tc--) {
memset(dp, -1, sizeof dp);
cin >> n;
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
int ans = solve(0, 1);
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
int j=0,k;
for(int i=0;i<N;i++){
int A,B;
cin>>A>>B;
if(j<A){
j=A;
k=B;
}
}
cout<<j+k<<endl;
} | 0 |
#include<iostream>
using namespace std;
typedef long long ll;
signed main(){
ll n,N,t0,t1;
cin >> N;
for(ll w=1;w<=3500;w++){
for(ll h=1;h<=3500;h++){
t0 = w*h*N;
t1 = 4*h*w-N*w-N*h;
if(t1!=0&&t0%t1==0&&t0/t1>0){
printf("%lld %lld %lld\n",h,w,t0/t1);
return 0;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const char s[] = "aeiou";
string str;
vector<string> rec[N][5];
string ans1[100010][2], ans2[100010][2];
int check(char ch) {
for (int i = 0; i < 5; i++) {
if (ch == s[i]) return i;
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, sz, p, cnt, num, sum, ans, now;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> str;
sz = str.size();
cnt = 0;
for (int j = sz - 1; j >= 0; j--) {
num = check(str[j]);
if (~num) {
cnt++;
if (cnt == 1) p = num;
}
}
rec[cnt][p].push_back(str);
}
cnt = sum = 0;
for (int i = 1; i <= 1000000; i++) {
num = 0;
for (int j = 0; j < 5; j++) {
num += (int)rec[i][j].size();
cnt += (int)rec[i][j].size() / 2;
}
sum += num / 2;
}
ans = min(sum / 2, cnt);
cout << ans << '\n';
now = 0;
for (int i = 1; i <= 1000000 && now < ans; i++) {
for (int j = 0; j < 5 && now < ans; j++) {
sz = (int)rec[i][j].size();
for (int k = 1; k < sz && now < ans; k += 2) {
now++;
ans2[now][0] = rec[i][j][k - 1];
ans2[now][1] = rec[i][j][k];
rec[i][j][k] = rec[i][j][k - 1] = "";
}
}
}
now = 0;
str = "";
for (int i = 1; i <= 1000000 && now < ans; i++) {
for (int j = 0; j < 5 && now < ans; j++) {
sz = (int)rec[i][j].size();
for (int k = 0; k < sz && now < ans; k++) {
if (rec[i][j][k] == "") continue;
if (str == "")
str = rec[i][j][k];
else {
now++;
ans1[now][0] = str;
ans1[now][1] = rec[i][j][k];
str = "";
}
}
}
str = "";
}
for (int i = 1; i <= ans; i++) {
cout << ans1[i][0] << " " << ans2[i][0] << '\n';
cout << ans1[i][1] << " " << ans2[i][1] << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
string ans[5] = {"byte", "short", "int", "long", "BigInteger"};
int res = 0;
cin >> s;
if (s[0] == '-') {
if (s.length() > 4 || (s.length() == 4 && s > "-128")) res++;
if (s.length() > 6 || (s.length() == 6 && s > "-32768")) res++;
if (s.length() > 11 || (s.length() == 11 && s > "-2147483648")) res++;
if (s.length() > 20 || (s.length() == 20 && s > "-9223372036854775808"))
res++;
} else {
if (s.length() > 3 || (s.length() == 3 && s > "127")) res++;
if (s.length() > 5 || (s.length() == 5 && s > "32767")) res++;
if (s.length() > 10 || (s.length() == 10 && s > "2147483647")) res++;
if (s.length() > 19 || (s.length() == 19 && s > "9223372036854775807"))
res++;
}
cout << ans[res];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
string s;
getline(cin, s);
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == ' ') {
if (s[i + 1] == ' ')
continue;
else if (s[i + 1] == ',' || s[i + 1] == '!' || s[i + 1] == '?' ||
s[i + 1] == '.')
continue;
else
cout << s[i];
} else if (s[i] == ',' || s[i] == '!' || s[i] == '?' || s[i] == '.') {
if (s[i + 1] == ' ')
cout << s[i];
else
cout << s[i] << " ";
} else
cout << s[i];
}
if (s[s.size() - 1] >= 'a' && s[s.size() - 1] <= 'z')
cout << s[s.size() - 1] << "\n";
else
cout << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
vector<int> prime;
int mark[N + 100];
void sieve() {
for (int i = 2; i <= N; i++) {
if (!mark[i]) {
prime.push_back(i);
mark[i] = i;
}
for (auto it : prime) {
if (i * it > N) {
break;
}
mark[i * it] = it;
if (i % it == 0) {
break;
}
}
}
}
int main() {
sieve();
int n;
scanf("%d", &n);
vector<int> cnt[N + 100];
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
int pre = 0;
while (mark[a]) {
if (pre == 0 || pre != mark[a]) {
cnt[mark[a]].push_back(1);
} else {
cnt[mark[a]].back()++;
}
pre = mark[a];
a /= mark[a];
}
}
for (int i = 1; i <= N; i++) {
sort(cnt[i].begin(), cnt[i].end());
}
long long ans = 1;
for (int i = 1; i <= N; i++) {
if ((int)cnt[i].size() < n - 1) {
continue;
} else if ((int)cnt[i].size() == n - 1) {
int cur = 1;
for (int j = 0; j < cnt[i][0]; j++) {
cur *= i;
}
ans *= cur;
} else {
int cur = 1;
for (int j = 0; j < cnt[i][1]; j++) {
cur *= i;
}
ans *= cur;
}
}
printf("%lld\n", ans);
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int nmax = 200010;
long long res, rs1;
vector<vector<pair<int, int> > > vr;
vector<vector<int> > rs;
int n, md, a, b, l, t, m;
int ch[nmax], ans[nmax];
void dfs(int v, int p) {
for (int i = 0; i < vr[v].size(); ++i) {
int to = vr[v][i].first;
if (to != p) {
ch[1] += vr[v][i].second;
dfs(to, v);
}
}
}
void dfs1(int v, int p) {
for (int i = 0; i < vr[v].size(); ++i) {
int to = vr[v][i].first;
if (to != p) {
ans[to] = ans[v] - vr[v][i].second + (1 - vr[v][i].second);
rs[ans[to]].push_back(to);
dfs1(to, v);
}
}
}
int main() {
cin >> n;
vr.resize(n + 3);
rs.resize(n + 1);
for (int i = 0; i < n - 1; ++i) {
scanf("%d %d", &a, &b);
vr[a].push_back(make_pair(b, 0));
vr[b].push_back(make_pair(a, 1));
}
dfs(1, 1);
ans[1] = ch[1];
dfs1(1, 1);
rs[ch[1]].push_back(1);
for (int i = 0; i < n + 1; ++i) {
if (rs[i].size()) {
sort(rs[i].begin(), rs[i].end());
printf("%d\n", i);
for (int j = 0; j < rs[i].size(); ++j) {
printf("%d ", rs[i][j]);
}
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
private:
struct Node {
int heightDelta;
int dA, dB, dBdA, dCdB, dCdBdA;
};
int n;
string s;
vector<Node> tree;
Node open = {1, 1, 0, 0, 1, 1};
Node close = {-1, 0, 2, 2, 1, 1};
Node merge(Node l, Node r) {
Node res;
res.heightDelta = l.heightDelta + r.heightDelta;
const int ld = l.heightDelta;
res.dA = max(l.dA, ld + r.dA);
res.dB = max(l.dB, -2 * ld + r.dB);
res.dBdA = max(max(l.dBdA, -2 * ld + ld + r.dBdA), l.dA + (-2 * ld + r.dB));
res.dCdB = max(max(l.dCdB, ld - 2 * ld + r.dCdB), l.dB + ld + r.dA);
res.dCdBdA = max(l.dCdBdA, ld - 2 * ld + ld + r.dCdBdA);
res.dCdBdA =
max(res.dCdBdA, max(l.dBdA + ld + r.dA, l.dA + ld - 2 * ld + r.dCdB));
return res;
}
void build(int v, int L, int R, int l, int r) {
if (l > r) return;
if (l == r) {
if (s[l] == '(')
tree[v] = open;
else
tree[v] = close;
} else {
int mid = L + (R - L) / 2;
build(2 * v + 1, L, mid, l, min(mid, r));
build(2 * v + 2, mid + 1, R, max(mid + 1, l), r);
tree[v] = merge(tree[2 * v + 1], tree[2 * v + 2]);
}
}
void change(int v, int L, int R, int pos) {
if (R < pos || L > pos) return;
if (L == pos && R == pos) {
if (s[pos] == '(')
tree[v] = open;
else
tree[v] = close;
} else {
int mid = L + (R - L) / 2;
change(2 * v + 1, L, mid, pos);
change(2 * v + 2, mid + 1, R, pos);
tree[v] = merge(tree[2 * v + 1], tree[2 * v + 2]);
}
}
public:
void init(string _s) {
s = _s;
n = (int)s.size();
tree.resize(4 * n);
build(0, 0, n - 1, 0, n - 1);
}
void change(int pos, char c) {
if (s[pos] == c) return;
s[pos] = c;
change(0, 0, n - 1, pos);
}
int getDiameter() { return tree[0].dCdBdA; }
};
int n, qn;
string s;
int main() {
scanf("%d %d\n", &n, &qn);
getline(cin, s);
SegmentTree tree;
tree.init(s);
printf("%d\n", tree.getDiameter());
for (int i = 0; i < qn; i++) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
swap(s[l], s[r]);
tree.change(l, s[l]);
tree.change(r, s[r]);
printf("%d\n", tree.getDiameter());
}
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
int main(){
int N, M, K;
while(cin >> N >> M >> K){
vector<long long> A(N);
for(auto& t : A) cin >> t;
auto dp = A;
for(int i=2;i<=K;i++){
deque<pair<int, long long>> qu;
for(int j=0;j<N;j++){
long long cur = 0;
if(!qu.empty()) cur = qu.front().second;
if(!qu.empty() && qu.front().first + M == j) qu.pop_front();
while(!qu.empty() && qu.back().second <= dp[j]) qu.pop_back();
qu.emplace_back(j, dp[j]);
if(cur > 0) cur += i * A[j];
dp[j] = cur;
}
}
long long res = 0;
for(auto& t : dp) res = max(res, t);
cout << res << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t, i, j, k, l, r, n, m, ans, sum, mx, mn, cnt;
cin >> t;
string s;
while (t--) {
cin >> i >> j >> l >> r;
if (j >= i)
cout << j << "\n";
else if (l <= r)
cout << "-1\n";
else {
i -= j;
r = l - r;
ans = j + (i + r - 1) / r * l;
cout << ans << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 400010;
int n;
int d[MaxN], w[MaxN];
int a[MaxN];
void add(int x, int p) {
for (; x < MaxN; x += x & -x) a[x] += p;
}
int get(int x) {
int p = 0;
for (; x; x -= x & -x) p += a[x];
return p;
}
int get(int x, int y) { return get(y) - get(x - 1); }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
d[x] = y;
d[y] = x + 2 * n;
add(y, 1);
add(x + 2 * n, 1);
add(y + 2 * n, 1);
}
for (int i = 1; i <= 2 * n; ++i) {
add(d[i], -1);
w[i] = get(i + 1, d[i] - 1);
}
long long ans = 0;
for (int i = 1; i <= 2 * n; ++i) {
int j = d[i];
if (j > 2 * n) j -= 2 * n;
ans += (long long)w[i] * w[j];
ans += (long long)w[j] * (n - w[i] - w[j] - 1);
}
cout << (long long)n * (n - 1) * (n - 2) / 6 - ans / 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
const int MAXN = 2 * 1000 * 100 + 10;
int a[MAXN], t1[MAXN];
int cnt[MAXN];
set<pair<int, int>> s;
vector<int> ans;
bool choose(int ind) {
int tm = 0;
set<pair<int, int>> tmp;
set<pair<int, int>>::iterator it = s.begin();
while (it != s.end()) {
if (a[it->second] >= ind) {
tmp.insert(*it);
}
it++;
}
it = tmp.begin();
if (tmp.size() < ind) return false;
for (int i = 0; i < ind; i++) {
tm += it->first;
if (tm > t) return false;
it++;
}
return true;
}
void ch(int ind) {
int tm = 0;
set<pair<int, int>> tmp;
set<pair<int, int>>::iterator it = s.begin();
while (it != s.end()) {
if (a[it->second] >= ind) {
tmp.insert(*it);
}
it++;
}
it = tmp.begin();
for (int i = 0; i < ind; i++) {
ans.push_back(it->second + 1);
it++;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> t;
for (int i = 0; i <= n; i++) {
cnt[i] = 0;
}
for (int i = 0; i < n; i++) {
cin >> a[i] >> t1[i];
s.insert({t1[i], i});
}
int l = 0, r = n + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (choose(mid))
l = mid;
else
r = mid;
}
ch(l);
cout << l << endl << l << endl;
while (!ans.empty()) {
cout << ans.back() << " ";
ans.pop_back();
}
cout << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define F first
#define S second
using namespace std;
const int N=1e5+5;
int n,m;
long long ans;
pair<int,int> p[N];
int main()
{
cin>>n>>m;
for(int i=0;i<n;i++)cin>>p[i].F>>p[i].S;
sort(p,p+n);
for(int i=0;i<n;i++)
{
if(p[i].S>m)
{
ans+=(long long)p[i].F*m;
cout<<ans;
return 0;
}
else
{
m-=p[i].S;
ans+=(long long)p[i].F*p[i].S;
}
}
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a;
cin >> a;
int prosli = -1;
int res = 0;
for (int i = 0; i < n; i++) {
if (prosli != -1) {
if (a[i] == 'P')
res = max(res, i - prosli);
else
prosli = i;
} else {
if (a[i] == 'A') prosli = i;
}
}
cout << res << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 1000000007;
const long long maxn = 600005;
long long pows[maxn], powInv[maxn], pfInv[maxn], dpf[maxn];
long long a[maxn];
map<long long, long long> zip, unzip;
struct dt {
long long ans, sum0, sum1, cnt;
};
struct segt {
dt d;
long long l, r;
} T[maxn << 2];
dt combine(dt l, dt r) {
dt res;
res.ans =
(((l.ans + r.ans +
((((((l.sum0 * r.sum1) % p + p) % p) * powInv[l.cnt]) % p + p) % p)) %
p +
p) %
p);
res.sum0 = (((l.sum0 + (((r.sum0 * pows[l.cnt]) % p + p) % p)) % p + p) % p);
res.sum1 =
(((l.sum1 + (((r.sum1 * powInv[l.cnt]) % p + p) % p)) % p + p) % p);
res.cnt = l.cnt + r.cnt;
return res;
}
void build(long long o, long long l, long long r) {
T[o].l = l, T[o].r = r;
if (l == r)
T[o].d.ans = T[o].d.cnt = T[o].d.sum0 = T[o].d.sum1 = 0;
else {
long long m = l + r >> 1;
build(o << 1, l, m), build(o << 1 | 1, m + 1, r);
T[o].d = combine(T[o << 1].d, T[o << 1 | 1].d);
}
}
void update(long long l, long long dx, long long o) {
if (T[o].l == T[o].r) {
a[l] += dx;
T[o].d.sum0 = ((((((pows[a[l]] - 1) % p + p) % p) * unzip[l]) % p + p) % p);
T[o].d.sum1 = (((unzip[l] * pfInv[a[l]]) % p + p) % p);
T[o].d.cnt = (((a[l]) % p + p) % p);
if (a[l] <= 1)
T[o].d.ans = 0;
else
T[o].d.ans =
((((((unzip[l] * unzip[l]) % p + p) % p) *
(((dpf[a[l]] - dpf[1] - powInv[1] * (a[l] - 1)) % p + p) % p)) %
p +
p) %
p);
} else {
long long m = T[o].l + T[o].r >> 1;
if (l <= m)
update(l, dx, o << 1);
else
update(l, dx, o << 1 | 1);
T[o].d = combine(T[o << 1].d, T[o << 1 | 1].d);
}
}
void solve() {
long long n, q;
cin >> n;
vector<long long> as(1);
vector<long long> P(n + 1);
for (long long i = (1); i <= (n); i++) cin >> P[i], as.emplace_back(P[i]);
vector<tuple<long long, long long, long long>> queries;
cin >> q;
for (long long tq = (1); tq <= (q); tq++) {
long long i, x;
cin >> i >> x;
queries.emplace_back(i, x, tq);
as.emplace_back(x);
}
sort(as.begin() + 1, as.end());
as.erase(unique(as.begin() + 1, as.end()), as.end());
for (long long i = (1); i <= (as.size() - 1); i++)
zip[as[i]] = i, unzip[i] = as[i];
build(1, 1, maxn - 5);
for (long long i = (1); i <= (n); i++) update(zip[P[i]], 1, 1);
cout << T[1].d.ans << endl;
for (auto [ti, tx, tq] : queries) {
update(zip[P[ti]], -1, 1);
update(zip[tx], 1, 1);
P[ti] = tx;
cout << T[1].d.ans << endl;
}
}
long long inv(long long aa, long long pp) {
return (aa == 1 ? 1 : (1 - pp * inv(pp % aa, aa)) / aa + pp);
}
void findPows() {
pows[0] = 1, powInv[0] = 1;
for (long long i = (1); i <= (maxn - 3); i++) {
pows[i] = (((pows[i - 1] * 2) % p + p) % p), powInv[i] = inv(pows[i], p),
pfInv[i] = (((pfInv[i - 1] + powInv[i]) % p + p) % p);
dpf[i] = (((dpf[i - 1] + pfInv[i]) % p + p) % p);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
findPows();
cerr << "Done.\n";
long long T = 1;
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int sum = 0;
vector<long long int> v;
vector<long long int> s;
for (long long int i = 0; i < n - 1; i++) {
int x;
cin >> x;
sum += x;
if (x > 0) {
v.push_back(x);
} else {
s.push_back(abs(x));
}
}
long long int y;
cin >> y;
sum += y;
if (y > 0) {
v.push_back(y);
} else if (y < 0) {
s.push_back(abs(y));
}
if (sum > 0) {
cout << "first";
} else if (sum < 0) {
cout << "second";
} else {
int flag = 0;
for (long long int i = 0; i < min(v.size(), s.size()); i++) {
if (s[i] > v[i]) {
flag = 1;
cout << "second";
break;
} else if (s[i] < v[i]) {
flag = 1;
cout << "first";
break;
} else {
flag = 0;
continue;
}
}
if (flag == 0) {
if (s.size() != v.size()) {
if (s.size() > v.size()) {
cout << "second";
} else if (s.size() < v.size()) {
cout << "first";
}
} else {
if (y > 0) {
cout << "first";
} else {
cout << "second";
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
int k;
cin >> s >> k;
int n=s.length();
set<string> t;
vector<string> v;
int i=0;
while(k>=i){
for(int j=0;j<n-i;j++){
string u;
for(int m=0+j;m<=i+j;m++){
u+=s[m];
}
t.insert(u);
}
i++;
}
for(string x:t){
v.push_back(x);
}
cout << v[k-1] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
int a[200008];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n - 1; i++)
if (i == 0 || a[i] != a[i - 1]) {
int j = a[i] + a[i], p;
while (j <= a[n - 1]) {
p = lower_bound(a, a + n, j) - a;
ans = (ans < a[p - 1] % a[i]) ? a[p - 1] % a[i] : ans;
j += a[i];
}
ans = (ans < a[n - 1] % a[i]) ? a[n - 1] % a[i] : ans;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char gchar() {
static char tbuf1[1000], *tmp_st = tbuf1, *tmp_ed = tbuf1;
if (tmp_st == tmp_ed) {
int len = fread(tbuf1, 1, 1000, stdin);
if (len == 0) return -1;
tmp_ed = tbuf1 + len;
tmp_st = tbuf1;
}
return *(tmp_st++);
}
inline bool gn(int &x) {
char c, sg = 0;
while (c = gchar(), (c > '9' || c < '0') && c != '-' && c != -1)
;
if (c == -1) return 0;
for ((c == '-' ? sg = 1, c = gchar() : 0), x = 0; c >= '0' && c <= '9';
c = gchar())
x = (x << 1) + (x << 3) + c - '0';
if (sg) x = -x;
return 1;
}
inline int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
const int NN = 100010;
int root[NN], siz[NN];
inline int Root(int u) {
return (u == root[u]) ? u : (root[u] = Root(root[u]));
}
int main() {
int n, m, k, u, v;
gn(n);
gn(m);
gn(k);
for (int i = 1; i <= n; i++) root[i] = i, siz[i] = 1;
long long ans = 1ll;
int lump = n;
while (m--) {
gn(u);
gn(v);
u = Root(u);
v = Root(v);
if (u != v) {
lump--;
if (siz[u] < siz[v]) {
siz[v] += siz[u];
root[u] = v;
} else {
siz[u] += siz[v];
root[v] = u;
}
}
}
for (int i = 1; i <= n; i++) {
if (root[i] == i) {
ans = ans * siz[i] % k;
}
}
if (lump == 1)
ans = 1 % k;
else
ans = ans * power(n, lump - 2, k) % k;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int N = 10e5;
int main() {
int n, ans, mx, mn, c_mx, c_mn, k, clr, cmx;
int freq[N + 1];
mx = 0;
cmx = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> clr;
freq[clr] += 1;
if (freq[clr] >= 1 && freq[clr] > mx) {
mx = freq[clr];
}
cmx = max(cmx, clr);
k = 0;
c_mx = 0;
c_mn = 0;
mn = 10e5;
for (int j = 1; j <= cmx; j++) {
if (freq[j]) {
mn = min(mn, freq[j]);
}
}
for (int j = 1; j <= cmx; j++) {
if (freq[j]) {
k++;
}
if (freq[j] == mx) {
c_mx++;
}
if (freq[j] == mn) {
c_mn++;
}
}
if (mx == 1) {
ans = i;
} else if (mx - mn == 1 && c_mx == 1 && c_mn == k - 1) {
ans = i;
} else if (mn == 1 && c_mn == 1 && c_mx == k - 1) {
ans = i;
} else if (c_mx == c_mn && mx == mn && k == 1) {
ans = i;
}
}
cout << ans;
return 0;
}
| 2 |
/*
* ALDS1_8_A.cpp
*
* Created on: May 2, 2018
* Author: 13743
*/
#include<cstdio>
#include<cstdlib>
struct Node {
int key;
Node *pa, *lc, *rc;
};
Node* root = NULL;
void insert(int k) {
Node* y = NULL;
Node* x = root;
Node* z = new Node;
while(x != NULL) {
y = x;
if(k < y->key) x = y->lc;
else x = y->rc;
}
z->pa = y;
z->lc = NULL;
z->rc = NULL;
z->key = k;
if(y == NULL) {
root = z;
}
else if(k < y->key) {
y->lc = z;
}
else {
y->rc = z;
}
}
void preorder(Node* u) {
if(u == NULL) return;
printf(" %d", u->key);
preorder(u->lc);
preorder(u->rc);
}
void inorder(Node* u) {
if(u == NULL) return;
inorder(u->lc);
printf(" %d", u->key);
inorder(u->rc);
}
void print() {
inorder(root);
printf("\n");
preorder(root);
printf("\n");
}
int main() {
int m;
scanf("%d", &m);
char s[100];
int ke;
for(int i=0; i<m; i++) {
scanf("%s", s);
if(s[0] == 'i') {
scanf("%d", &ke);
insert(ke);
}
else {
print();
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[2000010], b[2000010], c[2000010], d[2000010];
long long n, m, k, x, s;
int maxpotion(long long manaleft) {
long long l = 0, r = k;
while (l < r) {
long long mid = (l + r + 1) / 2;
if (d[mid] <= manaleft)
l = mid;
else
r = mid - 1;
}
return c[l];
}
int main() {
cin >> n >> m >> k >> x >> s;
a[0] = x;
for (int i = 1; i <= m; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= k; i++) cin >> c[i];
for (int i = 1; i <= k; i++) cin >> d[i];
long long res = n * x;
for (int i = 0; i <= m; i++) {
if (b[i] > s) continue;
long long manaleft = s - b[i];
res = min(res, a[i] * (n - maxpotion(manaleft)));
}
cout << res;
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <utility>
#define EPS 1e-10
using namespace std;
typedef long long ll;
struct Point{
double x,y;
Point(double x = 0.0,double y = 0.0): x(x),y(y) {}
Point operator + (Point p){
return Point(x + p.x,y + p.y);
}
Point operator - (Point p){
return Point(x - p.x,y - p.y);
}
Point operator * (double lambda){
return Point(x * lambda,y * lambda);
}
Point operator / (double lambda){
return Point(x / lambda,y / lambda);
}
Point operator - (){
return Point(-x,-y);
}
double norm(){
return x * x + y * y;
}
double abs_(){
return sqrt(norm());
}
bool operator == (const Point &p)const
{
return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
}
bool operator < (const Point &p)const
{
if(abs(x - p.x) < EPS) return y < p.y;
else return x < p.x;
}
};
typedef Point Vector;
struct Segment{
Point p1,p2;
Segment(Point p1 = Point(),Point p2 = Point()): p1(p1),p2(p2) {}
};
typedef Segment Line;
struct Circle{
Point c;
double r;
Circle(Point c = Point(),double r = 0.0): c(c),r(r) {}
};
typedef vector<Point> Polygon;
double dot(Vector a,Vector b){
return a.x * b.x + a.y * b.y;
}
double det(Vector a,Vector b){
return a.x * b.y - b.x * a.y;
}
Vector rot(Vector a,double theta){//rotate.
double x1 = cos(theta) * a.x - sin(theta) * a.y;
double y1 = sin(theta) * a.x + cos(theta) * a.y;
return Point(x1,y1);
}
vector <Point> commonTangents(Circle o1,Circle o2){
double rdif = o1.r - o2.r,rsum = o1.r + o2.r;
Vector a = o2.c - o1.c,b = a / a.abs_() * o1.r;
vector <Point> res;
res.clear();
double alpha;
if(abs(abs(rdif) - a.abs_()) < EPS){
if(rdif < 0) alpha = acos(-1);
else alpha = acos(1);
res.push_back(o1.c + rot(b,alpha));
}else if(abs(rdif) < a.abs_() - EPS){
alpha = acos(rdif / a.abs_());
res.push_back(o1.c + rot(b,alpha));
res.push_back(o1.c + rot(b,-alpha));
}
if(abs(rsum - a.abs_()) < EPS){
alpha = acos(1);
res.push_back(o1.c + rot(b,alpha));
}else if(rsum < a.abs_() - EPS){
alpha = acos(rsum / a.abs_());
res.push_back(o1.c + rot(b,alpha));
res.push_back(o1.c + rot(b,-alpha));
}
return res;
}
Circle a,b;
int main(){
scanf("%lf%lf%lf%lf%lf%lf",&a.c.x,&a.c.y,&a.r,&b.c.x,&b.c.y,&b.r);
vector <Point> ans = commonTangents(a,b);
sort(ans.begin(),ans.end());
for(int i=0;i<(int)ans.size();i++){
printf("%.10f %.10f\n",ans[i].x,ans[i].y);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int P = 720;
int main() {
int n, t, a, b;
cin >> n >> t >> a >> b;
int bo = 7 - t;
for (int i = 2; i <= n; ++i) {
cin >> a >> b;
int p = P / (a * b * (7 - a) * (7 - b));
if (p == 6) {
if (bo != 1 && bo != 6) {
cout << "NO";
return 0;
}
} else if (p == 10) {
if (bo != 2 && bo != 5) {
cout << "NO";
return 0;
}
} else {
if (bo != 3 && bo != 4) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
#define endl "\n"
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
typedef long long int ll;
ll mod=10000007;
vector<ll> even;
vector<ll> odd;
ll a[1000][1000];
int main(){
IOS
ll n,k,x,t,i,j,ans=0;
cin>>t;
while(t--){
memset(a,0,sizeof(a));
cin>>n;
if(n==2)
cout<<-1<<endl;
else{
for(i=n*n;i>=1;i--)
if(i%2==0)
even.push_back(i);
else
odd.push_back(i);
for(i=0;i<n;i++)
for(j=0;j<n;j++){
if(odd.size()!=0){
x=odd[odd.size()-1];
odd.pop_back();
}
else{
x=even[even.size()-1];
even.pop_back();
}
a[i][j]=x;
}
for(i=0;i<n;i++){
for(j=0;j<n;j++){
cout<<a[i][j]<<" ";
}
cout<<endl;
}
even.clear();
odd.clear();
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
long long a[maxn], s[maxn];
long long gcd(long long n, long long m) { return m == 0 ? n : gcd(m, n % m); }
int main() {
long long n;
long long ans = 0;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
ans += s[n];
for (int i = 1; i < n; i++) {
ans += 2 * ((s[n] - s[i]) - (n - i) * a[i]);
}
long long d = gcd(ans, n);
printf("%lld %lld\n", ans / d, n / d);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct Edge {
int u, v;
long long w;
} edge[20005];
int rk[205][205];
long long G[205][205], val[205];
int n, m;
bool cmp(int a, int b) { return val[a] < val[b]; }
void floyd() {
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
}
double solve() {
floyd();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
rk[i][j] = j;
val[j] = G[i][j];
}
sort(rk[i] + 1, rk[i] + 1 + n, cmp);
}
long long ans = INF;
for (int i = 1; i <= n; ++i) ans = min(ans, G[i][rk[i][n]] * 2);
for (int i = 1, u, v; i <= m; ++i) {
u = edge[i].u, v = edge[i].v;
for (int p = n, j = n - 1; j >= 1; --j) {
if (G[v][rk[u][j]] > G[v][rk[u][p]]) {
ans = min(ans, G[u][rk[u][j]] + G[v][rk[u][p]] + edge[i].w);
p = j;
}
}
}
return ans / 2.0;
}
int main() {
scanf("%d%d", &n, &m);
memset(G, 0x3f, sizeof(G));
for (int i = 1; i <= n; ++i) G[i][i] = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
G[edge[i].u][edge[i].v] = G[edge[i].v][edge[i].u] = edge[i].w;
}
printf("%.2lf\n", solve());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, s, x;
scanf("%I64d", &t);
scanf("%I64d", &s);
scanf("%I64d", &x);
if (x == t)
printf("YES");
else if ((x - t) < s)
printf("NO");
else if ((((x - t) % s) == 0) || (((x - t) % s) == 1))
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
long long int n;
cin >> n;
if (n == 1) {
cout << 1 << "\n";
return 0;
}
int fl = 0;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
fl = 1;
break;
}
}
if (!fl)
cout << 1 << "\n";
else {
if (n % 2) {
int fl = 0;
long long int m = n - 2;
for (long long int i = 2; i * i <= m; i++) {
if (m % i == 0) {
fl = 1;
break;
}
}
if (!fl)
cout << 2 << "\n";
else
cout << 3 << "\n";
} else
cout << 2 << "\n";
}
return 0;
}
| 2 |
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int t[101],n,s;
vector<int> r;
while(1){
scanf("%d,%d",&n,&s);
if(n==0&&s==0) break;
t[n]=s;
r.push_back(s);
}
sort(r.begin(),r.end());
r.erase(unique(r.begin(),r.end()),r.end());
while(scanf("%d",&n)>0){
printf("%d\n",r.end()-find(r.begin(),r.end(),t[n]));
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 111111;
int a[MAXN], b[MAXN], n, tot;
bool fail;
int main(int argc, char* argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
sort(a, a + n);
for (int i = 0; i < n; ++i)
if (i > 0 && a[i] != a[i - 1]) {
b[++tot] = 1;
if (a[i] > a[i - 1] + 1) fail = true;
} else
++b[tot];
for (int i = 1; i < tot; ++i)
if (b[i] < 2) fail = true;
for (int i = 0; i < tot; ++i) {
if (b[i + 1] < b[i]) {
fail = true;
break;
}
b[i + 1] -= b[i];
}
if (fail || b[tot] != 0)
puts("NO");
else
puts("YES");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long res = 0;
long long f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
res = res * 10 + ch - '0';
ch = getchar();
}
return res * f;
}
long long s, n, k;
long long t;
signed main() {
t = read();
while (t--) {
s = read(), n = read(), k = read();
if (s < k) {
printf("No\n");
continue;
}
if (s == k) {
printf("Yes\n");
continue;
}
long long k2 = k * 2;
long long tmp = min(s % k2, k - 1);
if (s / k2 * k + tmp < n)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
int bit[N][N];
void add(int x, int y, int v) {
for (int i = x; i < N; i += i & -i)
for (int j = y; j < N; j += j & -j) bit[i][j] += v;
}
int sum(int x, int y) {
int res = 0;
for (int i = x; i > 0; i -= i & -i)
for (int j = y; j > 0; j -= j & -j) res += bit[i][j];
return res;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, q, x1, x2, y1, y2, t;
cin >> n >> m >> q;
while (q--) {
cin >> t >> x1 >> y1 >> x2 >> y2;
if (t != 3) {
int v = x1 * m + y1;
v = (t == 1) ? v : -v;
add(x1, y1, v);
add(x1, y2 + 1, -v);
add(x2 + 1, y1, -v);
add(x2 + 1, y2 + 1, v);
} else {
if (sum(x1, y1) == sum(x2, y2))
cout << "Yes\n";
else
cout << "No\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << max(abs(y2 - y1), abs(x2 - x1));
return 0;
}
| 1 |
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#define maxn 100005
#define LL long long
#define INF (LL)(1e16)
using namespace std;
LL n,m,val,l,r,x[maxn],g[maxn],s[maxn];
bool vis[maxn];
struct node { int v,i; };
vector<node> G[maxn];
void nosol()
{
printf("0\n");
exit(0);
}
void dfs(int u,LL z,LL w)
{
g[u]=z,x[u]=w;
for(int i=0;i<G[u].size();i++)
{
int v=G[u][i].v,k=G[u][i].i;
if(!vis[k])
{
vis[k]=true;
if(g[v]==-INF)
{
g[v]=s[k]-z; x[v]=-w;
if(x[v]<0) r=min(r,g[v]),l=max(l,-z);
else r=min(r,z),l=max(l,-g[v]);
dfs(v,g[v],x[v]);
}
else
{
if(x[v]+x[u]==0)
{
if(g[v]+z!=s[k])
nosol();
if(x[v]<0) r=min(r,g[v]),l=max(l,-z);
else r=min(r,z),l=max(l,-g[v]);
}
if(x[v]==x[u])
{
if(x[v]<0) r=min(r,min(g[v],z));
else l=max(l,max(-g[v],-z));
if((s[k]-g[v]-z)%2) nosol();
LL temp=(s[k]-g[v]-z)/(2*x[u]);
if(temp<=0) nosol();
if(temp==val||val==-1) val=temp;
else nosol();
}
}
}
}
}
int main()
{
scanf("%lld%lld",&n,&m);
for(int i=1;i<=m;i++)
{
int u; node p;
scanf("%d%d%lld",&u,&p.v,&s[i]);
p.i=i;
G[u].push_back(p);
swap(u,p.v);
G[u].push_back(p);
}
val=-1,r=INF,l=0;
for(LL i=1;i<=n;i++) g[i]=-INF;
dfs(1,0,1);
if(val==-1) printf("%lld\n",max(r-l-1,0ll));
else if(l<val&&val<r) printf("1\n");
else printf("0\n");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1000 * 100 + 1000;
int n;
pair<int, int> a[MAXN], b[MAXN];
int ans[MAXN];
int p[MAXN];
bool comp(const pair<int, int>& x, const pair<int, int>& y) {
return (x.first >= y.first);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
p[i] = x;
a[i] = make_pair(x, i);
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
b[i] = make_pair(x, i);
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++) {
ans[b[i].second] = a[n - i + 1].second;
}
for (int i = 1; i <= n; i++) cout << p[ans[i]] << " ";
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <algorithm>
using namespace std;
struct Rect {
int h;
int pos;
};
int c[500][501];
int h, w;
int main() {
while (cin >> h >> w, h|w) {
vector<string> ms(h);
for (int i = 0; i < h; i++) {
cin >> ms[i];
}
for (int x = 0; x < w; x++) {
c[0][x] = (ms[0][x] == '*') ? 0 : 1;
}
for (int y = 1; y < h; y++) {
for (int x = 0; x < w; x++) {
c[y][x] = (ms[y][x] == '*') ? 0 : c[y-1][x] + 1;
}
}
int ans = 0;
for (int y = 0; y < h; y++) {
stack<Rect> s;
c[y][w] = 0;
for (int x = 0; x <= w; x++) {
Rect r;
r.h = c[y][x];
r.pos = x;
if (s.empty() || s.top().h < r.h) {
s.push(r);
} else if (s.top().h > r.h) {
int j = x;
while (!s.empty() && s.top().h >= r.h) {
Rect r0 = s.top(); s.pop();
ans = max(ans, r0.h * (x - r0.pos));
j = r0.pos;
}
r.pos = j;
s.push(r);
}
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
int n, r;
double ans[1005] = {};
int x[1005] = {};
double f(int a, int b) {
return ans[a] + sqrt(4 * r * r - (x[a] - x[b]) * (x[a] - x[b]));
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
for (int i = 1; i <= n; i++) {
ans[i] = (double)r;
for (int j = 1; j <= i - 1; j++) {
if ((x[i] - x[j] >= -2 * r) && (x[i] - x[j] <= 2 * r)) {
if (ans[i] < f(j, i)) ans[i] = f(j, i);
}
}
printf("%.10f ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int MD = 1000000007;
int n, a[N];
long long s[N], k;
int ft[N];
long long all[N];
int gt(int first) {
int res = 0;
for (int i = first; i >= 0; i &= i + 1, --i) res += ft[i];
return res;
}
void upd(int first, int v) {
for (int i = first; i < N; i |= i + 1) ft[i] += v;
}
long long chk(long long first) {
memset(ft, 0, sizeof ft);
for (int _tmp = (n), i = (0); i <= _tmp; ++i) all[i] = s[i];
sort(all, all + n + 1);
upd(lower_bound(all, all + n + 1, s[0]) - all, +1);
long long res = 0;
for (int _tmp = (n), i = (1); i <= _tmp; ++i) {
res += gt(upper_bound(all, all + n + 1, s[i] - first) - all - 1);
upd(lower_bound(all, all + n + 1, s[i]) - all, +1);
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int _tmp = (n), i = (1); i <= _tmp; ++i) {
cin >> a[i];
s[i] = a[i] + s[i - 1];
}
long long l = -1e14, r = 1e14, rs = 0;
while (l <= r) {
long long m = (l + r) / 2;
if (chk(m) >= k) {
l = m + 1;
rs = m;
} else {
r = m - 1;
}
}
cout << rs << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.