solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 28;
const long long INF = 1LL << 60;
template <class T>
inline void Rd(T &res) {
res = 0;
char c;
while (c = getchar(), !isdigit(c))
;
do res = (res << 1) + (res << 3) + (c ^ 48);
while (c = getchar(), isdigit(c));
}
template <class T>
void put(T x) {
if (x == 0) return;
put(x / 10);
putchar(x % 10 ^ 48);
}
template <class T>
inline void print(T x) {
if (x == 0) {
putchar(48);
return;
} else if (x < 0)
putchar('-'), x = -x;
put(x);
}
template <class T1, class T2>
inline void Max(T1 &x, const T2 &k) {
if (x < k) x = k;
}
template <class T1, class T2>
inline void Min(T1 &x, const T2 &k) {
if (x > k) x = k;
}
const int M = 255;
const int base = 105;
struct node {
int L, R;
} A[M];
int v[M][M];
int main() {
int n;
cin >> n;
for (int i = 1, x, y; i <= n; ++i) {
scanf("%d%d", &x, &y);
y += x;
A[i].L = x, A[i].R = y;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
int a = A[i].L, c = A[i].R;
int b = A[j].L, d = A[j].R;
if ((a < b && b <= c) || (c < b && b <= a)) v[i][j]++;
if ((b <= c && c < d) || (d <= c && c < b)) v[i][j]++;
if ((a < d && d <= c) || (c < d && d <= a)) v[j][i]++;
if ((b <= a && a < d) || (d <= a && a < b)) v[j][i]++;
ans += max(v[i][j], v[j][i]);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,X,Y; cin >> N >> X >> Y;
int count[2850];
for(int i=1; i<=N-1; i++){
for(int j=i+1; j<=N; j++){
count[min(j-i,abs(X-i)+1+abs(Y-j))]++;
}
}
for(int k=1; k<=N-1; k++) cout << count[k] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
//const ll mod = 1000000007;
int PAIR[6050];
string dp[6050];
int main() {
//cout.precision(10);
int N;
string S;
cin >> N >> S;
S = "#" + S;
queue<int> a, b;
for(int i = 1; i <= 2*N; i++) {
if(S[i] == 'a') a.push(i);
else b.push(i);
}
for(int i = 1; i <= N; i++) {
int A = a.front();
int B = b.front();
a.pop();
b.pop();
PAIR[A] = B;
PAIR[B] = A;
}
for(int i = 1; i <= 2*N; i++) {
//cerr << PAIR[i] << endl;
}
for(int index = 2*N; index >= 1; index--) {
dp[index] = dp[index + 1];
if(PAIR[index] < index) continue;
if(S[index] == 'a') {
string sub = "ab" + dp[PAIR[index] + 1];
dp[index] = max(dp[index], sub);
continue;
}
if(S[index] == 'b') {
string sub = "b";
int plus = 1;
int sub_index = index + 1;
for(; plus > 0; sub_index++) {
if(S[sub_index] == 'b') {
sub = sub + "b";
plus++;
continue;
}
if(sub_index < PAIR[index]) continue;
sub = sub + "a";
plus--;
}
sub = sub + dp[sub_index];
dp[index] = max(dp[index], sub);
}
}
cout << dp[1] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int maxn = 2e5+100;
struct SECTION {
ll l,r;
SECTION() {}
SECTION(ll l,ll r):l(l),r(r) {}
bool operator<(const SECTION& oth) const {
if(l==oth.l) return r < oth.r;
return l < oth.l;
}
bool operator==(const SECTION& oth) const { return l==oth.l&&r==oth.r; }
};
map<ll,int> idx;
vector<SECTION> sec[maxn];
ll N,X,D;
int main() {
std::ios::sync_with_stdio(false);
ll kl=0,kr=0,key,cnt = 0,ans = 0;
cin >> N >> X >> D;
if(D==0) {
if(!X) cout << 1 << endl;
else cout << N+1 << endl;
return 0;
} else if(D<0) {
X*=-1;
D*=-1;
}
ll l,r;
for(int i=0; i<=N; i++) {
key = i*X;
ll bb = key%D;
l = r = key/D;
l+=kl; r+=kr;
if(idx[bb]==0ll) idx[bb] = ++cnt;
sec[idx[bb]].push_back({--l,r});
kl+=i,kr+=N-i-1;
}
for(int i=1; i<=cnt; i++) {
SECTION tp;
sort(sec[i].begin(),sec[i].end());
tp = sec[i][0];
for(SECTION now: sec[i]) {
if(now.l <= tp.r) tp.r = max(tp.r,now.r);
else {
ans += tp.r-tp.l;
tp = now;
}
if(now == sec[i].back()) {
ans += tp.r-tp.l;
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
template <class T>
void out(map<char, T> &a, string s = "(%3c ->%3d)") {
for (auto(it) = (a).begin(); (it) != (a).end(); ++(it))
printf(s.c_str(), it->first, it->second);
printf("\n");
}
template <class T>
void out(vector<T> &a, string s = "%3d ") {
int i, n = a.size();
for ((i) = 0; (i) < (n); (i)++) printf(s.c_str(), a[i]);
printf("\n");
}
template <class T>
void out(T *a, int n, string s = "%3d ") {
int i;
for ((i) = 0; (i) < (n); (i)++) printf(s.c_str(), a[i]);
printf("\n");
}
string inpS;
unordered_map<string, vector<vector<long long> > > cor;
const int two = 0, d1 = 1, star1 = 2, zero = 3, star = 4, allst = 5;
unordered_map<int, char> last;
const char chrs[] = {'0', '1', '2', '*'};
const int nchrs = sizeof(chrs) / sizeof(chrs[0]);
const long long MOD = 1e9 + 7;
inline void moveDP(const int &pat1, const int &pat2,
vector<vector<long long> > &dp, int &it, string &s,
long long &i) {
if (it == pat1 && (s[i] == last[pat2] || s[i] == '?')) {
long long buf = dp[i][pat2] += dp[i - 1][it];
if (buf >= MOD) dp[i][pat2] -= MOD;
}
}
long long i, j, N, M, n, m, k, p;
void MainSolve(string args = "") {
cout << args;
string s;
cin >> s;
vector<vector<long long> > dp((s).length(), vector<long long>(allst, 0));
last[star] = '*';
last[star1] = '1';
last[zero] = '0';
last[d1] = '1';
last[two] = '2';
if (s[0] == '0' || s[0] == '?') dp[0][zero] = 1;
if (s[0] == '1' || s[0] == '?') dp[0][d1] = 1;
if (s[0] == '*' || s[0] == '?') dp[0][star] = 1;
if (s[0] == '2') {
cout << 0 << endl;
return;
}
long long i, n = (s).length();
int it;
for ((i) = (1); (i) < (n); (i)++)
for ((it) = 0; (it) < (dp[i - 1].size()); (it)++) {
moveDP(two, star, dp, it, s, i);
moveDP(d1, star, dp, it, s, i);
moveDP(star1, zero, dp, it, s, i);
moveDP(star1, d1, dp, it, s, i);
moveDP(zero, zero, dp, it, s, i);
moveDP(zero, d1, dp, it, s, i);
moveDP(star, two, dp, it, s, i);
moveDP(star, star1, dp, it, s, i);
moveDP(star, star, dp, it, s, i);
}
long long ans = 0;
for ((i) = 0; (i) < (dp[(s).length() - 1].size()); (i)++) {
it = dp[(s).length() - 1][i];
if (i == star) ans += it, ans %= MOD;
if (i == zero) ans += it, ans %= MOD;
if (i == star1) ans += it, ans %= MOD;
}
cout << ans << endl;
}
string ReadAllLines(char *fileName) {
string s = "";
const int NMAX = 1000;
char buf[NMAX];
buf[0] = 0;
FILE *f = fopen(fileName, "r");
while (fgets(buf, NMAX, f)) s = s + string(buf);
return string(s.begin(), find_if(s.rbegin(), s.rend(), [](char c) {
return c != '\n' && c != '\r' && c != '\t' &&
c != ' ';
}).base());
}
int main() {
MainSolve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long power(unsigned long long x, int y, int p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool cmp(pair<string, int> &a, pair<string, int> &b) {
return a.second < b.second;
}
void sort(map<string, int> &M) {
vector<pair<string, int> > A;
for (auto &it : M) {
A.push_back(it);
}
sort(A.begin(), A.end(), cmp);
for (auto &it : A) {
cout << it.first << ' ' << it.second << endl;
}
}
unsigned long long modInverse(unsigned long long n, int p) {
return power(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n, int r, int p) {
if (n < r) return 0;
if (r == 0) return 1;
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
long long gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long int a, long long int b) { return (a / gcd(a, b)) * b; }
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int fact(long long int n, long long int p) {
return (n == 1 || n == 0) ? 1 : (n * (fact(n - 1, p)));
}
long long int nof(long long int n) {
if (n == 1) {
return 1;
}
long long int ans = 2;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i * i == n) {
ans += 1;
} else {
ans += 2;
}
}
}
return ans;
}
long long int power(long long int num, long long int deg, long long int m) {
if (!deg) return 1;
if (deg % 2) {
return (power(num, deg - 1, m) * num) % m;
} else {
long long int sqrt_res = power(num, deg / 2, m);
return (sqrt_res * sqrt_res) % m;
}
}
void seive() {
vector<long long int> prm;
vector<bool> mark(1000000, false);
long long int size = 1000000;
mark[0] = true;
mark[1] = true;
for (long long int i = 2; i * i < size; i++) {
if (mark[i] == false) {
string s;
s = to_string(i);
for (long long int j = i + i; j < size; j += i) {
mark[j] = true;
}
}
}
for (long long int i = 0; i < 100000; i++) {
if (mark[i] == false) {
prm.push_back(i);
}
}
}
bool stt(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first > b.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
long long int tt = t;
while (t--) {
string s;
cin >> s;
long long int sz = s.length();
long long int pow = 1;
long long int rtrm = 0;
long long int ans = 0;
for (long long int i = sz - 1; i >= 0; i--) {
long long int ltrm =
(((i * (i + 1)) / 2) % 1000000007 * pow) % 1000000007;
long long int total =
(ltrm % 1000000007 + rtrm % 1000000007) % 1000000007;
rtrm = (rtrm + ((sz - i) * pow) % 1000000007) % 1000000007;
pow *= 10;
pow %= 1000000007;
ans += ((s[i] - '0') * total) % 1000000007;
ans %= 1000000007;
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
int ar[n], lock[n];
for (int i = 0; i < n; i++) cin >> ar[i];
vector<int> temp, res;
bool flag = false;
for (int i = 0; i < n - 1; i++) {
if (ar[i] > ar[i + 1]) {
flag = true;
}
}
if (flag == false) {
cout << "YES" << endl;
return;
}
int minn = *min_element(ar, ar + n);
for (int i = 0; i < n; i++) {
if (ar[i] % minn == 0) {
temp.push_back(ar[i]);
}
}
sort(temp.begin(), temp.end());
int j = 0;
for (int i = 0; i < n; i++) {
if (ar[i] % minn != 0) {
res.push_back(ar[i]);
} else
res.push_back(temp[j++]);
}
for (int i = 0; i < n - 1; i++) {
if (res[i] > res[i + 1]) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int N;
char res[102];
vector<string> g[102];
int cnt[102][26];
int r[26];
int tmp[26];
int q[51][2];
int m;
int a[100000];
int b[100000];
int v1[100000];
int v2[100000];
int f[51][2];
int lf[51][2];
int rg[51][2];
void query(int a, int b) {
int i, k;
int len;
int n;
int m;
char buf[102];
printf("? %d %d\n", a + 1, b + 1);
fflush(stdout);
n = (b - a + 1) * (b - a + 2) / 2;
for (i = (0); i < (N + 1); i++) {
g[i].clear();
}
for (i = (0); i < (N + 1); i++) {
int j;
for (j = (0); j < (26); j++) {
cnt[i][j] = 0;
}
}
for (i = (0); i < (n); i++) {
int j;
scanf("%s", buf);
len = strlen(buf);
g[len].push_back((string)buf);
for (j = (0); j < (len); j++) {
cnt[len][buf[j] - 'a']++;
}
}
n = b - a + 1;
for (k = (0); k < (26); k++) {
r[k] = cnt[0][k];
}
for (i = (0); i < ((n + 1) / 2); i++) {
q[i][0] = q[i][1] = -1;
if (i == (n + 1) / 2 - 1) {
for (k = (0); k < (26); k++) {
r[k] = cnt[1][k];
}
} else {
for (k = (0); k < (26); k++) {
r[k] = cnt[1][k] - (cnt[i + 2][k] - cnt[i + 1][k]);
}
}
for (k = (0); k < (i); k++) {
for (m = (0); m < (2); m++) {
if (q[k][m] >= 0) {
r[q[k][m]]--;
}
}
}
m = 0;
for (k = (0); k < (26); k++) {
while (r[k]) {
q[i][m++] = k;
r[k]--;
}
}
}
}
void answer(void) {
printf("! %s\n", res);
fflush(stdout);
exit(0);
}
int main() {
int i;
int v;
int odN;
int lsz;
int rsz;
scanf("%d", &N);
if (N <= 3) {
int i;
for (i = (0); i < (N); i++) {
query(i, i);
res[i] = g[1][0][0];
}
answer();
}
if (N % 2 == 0) {
odN = N - 1;
} else {
odN = N;
}
lsz = (N + 1) / 2;
rsz = (N + 3) / 2;
for (i = (0); i < (N); i++) {
res[i] = 127;
}
query(0, odN - 1);
for (i = (0); i < ((odN + 1) / 2); i++) {
if (q[i][1] == -1) {
res[i] = q[i][0];
continue;
}
a[m] = i;
b[m] = odN - 1 - i;
v1[m] = q[i][0];
v2[m] = q[i][1];
m++;
}
query(0, lsz - 1);
for (i = (0); i < ((lsz + 1) / 2); i++) {
if (q[i][1] == -1) {
res[i] = q[i][0];
continue;
}
a[m] = i;
b[m] = lsz - 1 - i;
v1[m] = q[i][0];
v2[m] = q[i][1];
m++;
}
query(N - rsz, N - 1);
for (i = (0); i < ((rsz + 1) / 2); i++) {
if (q[i][1] == -1) {
res[N - rsz + i] = q[i][0];
continue;
}
a[m] = N - rsz + i;
b[m] = N - 1 - i;
v1[m] = q[i][0];
v2[m] = q[i][1];
m++;
}
for (;;) {
int fg = 0;
for (i = (0); i < (m); i++) {
if (res[a[i]] != 127 && res[b[i]] == 127) {
res[b[i]] = ((int)res[a[i]]) ^ v1[i] ^ v2[i];
fg++;
}
if (res[a[i]] == 127 && res[b[i]] != 127) {
res[a[i]] = ((int)res[b[i]]) ^ v1[i] ^ v2[i];
fg++;
}
}
if (!fg) {
break;
}
}
for (i = (0); i < (N); i++) {
res[i] += 'a';
}
answer();
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
int n, m, v[200002];
int bg[200002], sm[200002];
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
int posm = 0;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
if (v[i] == m) posm = i;
}
for (int i = posm; i <= n; ++i) {
bg[i] = bg[i - 1] + (v[i] > m);
sm[i] = sm[i - 1] + (v[i] < m);
mp[bg[i] - sm[i]]++;
}
for (int i = 1; i < posm; ++i) {
bg[i] = bg[i - 1] + (v[i] > m);
sm[i] = sm[i - 1] + (v[i] < m);
}
long long sol = 0;
for (int i = 1; i <= posm; ++i) {
int dif = (bg[posm - 1] - bg[i - 1]) - (sm[posm - 1] - sm[i - 1]);
sol = sol + mp[-dif];
sol = sol + mp[-dif + 1];
}
cout << sol;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int x;
cin>>x;
cout<<3*x*x;
return 0;
} | 0 |
#include <bits/stdc++.h>
char a[25], b[25];
int main() {
int i, A = 0, B = 0;
scanf("%s%s", a, b);
for (i = 0; i < strlen(a); i = i + 2) {
if (a[i] == '8' && b[i] == '[') A++;
if (a[i] == '[' && b[i] == '8') B++;
if (a[i] == '[' && b[i] == '(') A++;
if (a[i] == '(' && b[i] == '[') B++;
if (a[i] == '(' && b[i] == '8') A++;
if (a[i] == '8' && b[i] == '(') B++;
}
if (A > B)
printf("TEAM 1 WINS\n");
else if (B > A)
printf("TEAM 2 WINS\n");
else
printf("TIE\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int hed[600010], nxt[600010], to[600010], cnt;
inline void addedge(int u, int v) {
nxt[++cnt] = hed[u];
hed[u] = cnt;
to[cnt] = v;
}
int siz[300010], root[300010], ans[300010];
int mx[300010];
int id[6000010], son[6000010][2], tot;
int n, q;
int merge(int x, int y) {
if (!x) return y;
if (!y) return x;
if (mx[id[y]] < mx[id[x]]) id[x] = id[y];
son[x][0] = merge(son[x][0], son[y][0]);
son[x][1] = merge(son[x][1], son[y][1]);
return x;
}
void update(int &x, int l, int r, int p, int v, int i) {
if (!x) x = ++tot;
if (v < mx[id[x]]) id[x] = i;
if (l == r) return;
int mid = (l + r) >> 1;
if (p <= mid)
update(son[x][0], l, mid, p, v, i);
else
update(son[x][1], mid + 1, r, p, v, i);
}
int query(int a, int b, int k, int l, int r) {
if (a > b || l > r || !k) return 0;
if (a == l && b == r) return id[k];
int mid = (l + r) >> 1;
if (b <= mid)
return query(a, b, son[k][0], l, mid);
else if (a > mid)
return query(a, b, son[k][1], mid + 1, r);
else {
int L = query(a, mid, son[k][0], l, mid),
R = query(mid + 1, b, son[k][1], mid + 1, r);
if (!L) return R;
if (!R) return L;
if (mx[L] < mx[R])
return L;
else
return R;
}
}
void dfs(int x) {
siz[x] = 1;
for (int i = hed[x]; i; i = nxt[i]) {
int y = to[i];
dfs(y);
siz[x] += siz[y];
root[x] = merge(root[x], root[y]);
mx[x] = max(mx[x], siz[y]);
}
update(root[x], 1, n, siz[x], mx[x], x);
ans[x] = query((siz[x] + 1) / 2, siz[x], root[x], 1, n);
}
int main() {
scanf("%d%d", &n, &q);
mx[0] = 1e9;
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
addedge(p, i);
}
dfs(1);
while (q--) {
int x;
scanf("%d", &x);
printf("%d\n", ans[x]);
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
string s;
int i;
int main() {
cin>>s;
for(i=1; i<=s.size(); i++)
cout<<"x";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
long long N;
int s(long long x) {
int tot = 0;
while (x) {
tot += x % 10;
x /= 10;
}
return tot;
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin >> N;
long long n = sqrt(N);
for (long long x = max(1LL, n - 1000); x <= n + 1000; x++)
if (N % x == 0 && N / x == x + s(x)) {
cout << x << '\n';
return 0;
}
cout << -1 << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i = 0;
cin >> n;
int a[n];
int sumi = 0, sumo = 0, sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
}
if (sum != 0) {
cout << "YES";
cout << endl << "1" << endl << "1 " << n;
exit(0);
}
int j = 0, flag = 0, x;
if (n == 1) {
if (a[0] == 0) {
cout << "NO";
exit(0);
} else {
cout << "YES";
cout << endl << "1" << endl << "1 1";
exit(0);
}
}
for (i = 0; i < n && flag == 0; i++) {
sumi = sumi + a[i];
if (sumi != 0) {
sumo = 0;
for (j = i + 1; j < n; j++) {
sumo = sumo + a[j];
}
if (sumo != 0) {
flag = 1;
x = i + 1;
break;
}
}
}
if (flag == 0) {
cout << "NO";
} else {
cout << "YES";
cout << endl << '2';
cout << endl << "1 " << x << endl << x + 1 << ' ' << n;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, h;
long long dp[40][40][40];
long long calc(int l, int r, int d) {
if (dp[l][r][d] != -1) return dp[l][r][d];
if (l > r && d == 0)
return dp[l][r][d] = 1;
else if (l > r)
return dp[l][r][d] = 0;
if (l == r && d == 1)
return dp[l][r][d] = 1;
else if (l == r)
return dp[l][r][d] = 0;
long long res = 0;
for (int i = l; i <= r; i++) {
for (int j = 0; j < d - 1; j++)
res += calc(l, i - 1, j) * calc(i + 1, r, d - 1) +
calc(i + 1, r, j) * calc(l, i - 1, d - 1);
res += calc(l, i - 1, d - 1) * calc(i + 1, r, d - 1);
}
return dp[l][r][d] = res;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> h;
long long ans = 0;
for (int i = n; i >= h; i--) {
ans += calc(1, n, i);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
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...);
}
const long long maxn = 2 * (long long)1e5 + 10;
const long double EPS = 1e-9;
const long long INF = (long long)1e18 + 18;
const long long mod = (long long)1e9 + 9;
long long n;
inline bool cmp(pair<long long, long long> l, pair<long long, long long> r) {
if (abs(l.second) == abs(r.second)) return abs(l.first) < abs(r.first);
return abs(l.second) < abs(r.second);
}
string get(long long x, long long y, long long mode) {
string ret;
if (mode) {
if (x > 0 && y > 0) {
ret = "1 " + to_string(x) + " R\n1 " + to_string(y) + " U";
} else if (x < 0 && y > 0) {
ret = "1 " + to_string(-x) + " L\n1 " + to_string(y) + " U";
} else if (x < 0 && y < 0) {
ret = "1 " + to_string(-x) + " L\n1 " + to_string(-y) + " D";
} else
ret = "1 " + to_string(x) + " R\n1 " + to_string(-y) + " D";
} else {
if (x > 0 && y > 0) {
ret = "1 " + to_string(x) + " L\n1 " + to_string(y) + " D";
} else if (x < 0 && y > 0) {
ret = "1 " + to_string(-x) + " R\n1 " + to_string(y) + " D";
} else if (x < 0 && y < 0) {
ret = "1 " + to_string(-x) + " R\n1 " + to_string(-y) + " U";
} else
ret = "1 " + to_string(x) + " L\n1 " + to_string(-y) + " U";
}
return ret;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
long long cnt = 0;
vector<string> ans;
vector<pair<long long, long long> > vec;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
vec.push_back(make_pair(x, y));
}
sort(vec.begin(), vec.end(), cmp);
for (long long i = 0; i < n; i++) {
long long x = vec[i].first, y = vec[i].second;
if (x == 0) {
string s = "1 " + to_string(abs(y)) + (y > 0 ? " U" : " D");
ans.push_back(s);
s = "2";
ans.push_back(s);
s = "1 " + to_string(abs(y)) + (y > 0 ? " D" : " U");
ans.push_back(s);
ans.push_back("3");
cnt += 4;
} else if (y == 0) {
string s = "1 " + to_string(abs(x)) + (x > 0 ? " R" : " L");
ans.push_back(s);
s = "2";
ans.push_back(s);
s = "1 " + to_string(abs(x)) + (x > 0 ? " L" : " R");
ans.push_back(s);
ans.push_back("3");
cnt += 4;
} else {
string s = get(x, y, 1);
ans.push_back(s);
ans.push_back("2");
s = get(x, y, 0);
ans.push_back(s);
ans.push_back("3");
cnt += 6;
}
}
cout << cnt << '\n';
for (auto it : ans) cout << it << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long f[2001][2001];
long long ans;
long long n, m;
int main() {
cin >> n;
cin >> m;
for (int i = 2; i <= m; i++) f[1][i] = 1;
for (int i = 2; i <= n; i++) {
f[i][1] = 1;
for (int j = 2, s = 0; j <= m; j++) {
s += f[i - 1][j];
s = s % mod;
f[i][j] = (f[i][j - 1] + s) % mod;
}
}
ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 2; j <= m; j++) {
ans = ((ans + ((m - j + 1) % mod) * ((f[i][j] - f[i - 1][j] + mod) % mod *
(f[n - i + 1][j]) % mod)) %
mod);
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
const long long LINF = 1e16;
const double pi = 3.1415926535897932;
const string endstr = "\n";
template <typename T>
T gcd(T a, T b) {
return (a == 0) ? b : gcd(b % a, a);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
bool p_comp_fs(const pair<long long, long long> p1,
const pair<long long, long long> p2) {
return p1.first < p2.first;
};
bool p_comp_fg(const pair<long long, long long> p1,
const pair<long long, long long> p2) {
return p1.first > p2.first;
};
bool p_comp_ss(const pair<long long, long long> p1,
const pair<long long, long long> p2) {
return p1.second < p2.second;
};
bool p_comp_sg(const pair<long long, long long> p1,
const pair<long long, long long> p2) {
return p1.second > p2.second;
};
template <typename T>
vector<T> uniquen(vector<T> vec) {
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
int main() {
long long n, z;
cin >> n >> z;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
};
sort(a.begin(), a.end());
long long ans = 0;
long long l = n / 2 - 1, r = n - 1;
while (l >= 0 && l < r) {
if (a[r] - a[l] >= z) {
ans++;
l--;
r--;
continue;
} else {
l--;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long s = n * (n + 1) / 2;
if (s % 2 == 0) {
cout << "0";
} else {
cout << "1";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, dt;
int main() {
double d, l, v1, v2, a, b, c;
while (scanf("%lf %lf %lf %lf", &d, &l, &v1, &v2) == 4) {
a = (l - d) / 2;
b = (v1 + v2) / 2;
c = a / b;
printf("%.6lf\n", c);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e6;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 12;
long long arr[MAX];
map<long long, long long> mm;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cout.tie(NULL);
;
long long tt;
cin >> tt;
while (tt--) {
long long d, l = 0, i;
cin >> d;
long long k = d * d - 4 * d;
if (k >= 0) {
double a = (d + sqrt(k)) / 2;
cout << "Y " << setprecision(10) << a << " " << d - a << "\n";
} else
cout << "N\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long pow(long long a, long long b) {
if (b == 1) {
return a;
}
if (b % 2 == 1) {
return pow(a, b - 1) * a;
} else {
long long x = pow(a, b / 2);
return x * x;
}
}
long long powm(long long a, long long b, long long m) {
if (b == 1) {
return a % m;
}
if (b % 2 == 1) {
return ((pow(a, b - 1) % m) * (a % m)) % m;
} else {
long long x = pow(a, b / 2);
return ((x % m) * (x % m)) % m;
}
}
long long gcd(long long a, long long b) {
long long re = b % a;
if (re == 0) {
return a;
}
return gcd(re, a);
}
int main() {
long long a, s, k, x, y, i, j, l, n;
cin >> n;
s = n * (n + 1);
s = s / 2;
cout << s % 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int row, col, temp, cntp, x, y, x1, y1, i, j, dif, dif2;
int a[5][5];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
cin >> a[i][j];
}
}
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
if (a[i][j] == 1) {
x = abs(i - 2);
y = abs(j - 2);
}
}
}
cout << x + y << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int h = 0, g = 0, f = 0;
while (h < s.size()) {
g = 0;
while (h < s.size() && s[h] == s[h + 1]) {
g++;
h++;
}
if (g % 2 == 1) f++;
h++;
}
cout << f;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int r,c;
cin>>r>>c;
int a[r][c],b[r],d[c],e=0;
for(int s=0;s<c;s++){
d[s]=0;
}
for(int i=0;i<r;i++){
b[i]=0;
for(int j=0;j<c;j++){
cin>>a[i][j];
b[i]+=a[i][j];
d[j]+=a[i][j];
}
}
for(int k=0;k<r;k++){
for(int l=0;l<c;l++){
cout<<a[k][l]<<" ";
}
cout<<b[k]<<endl;
}
for(int o=0;o<c;o++){
cout<<d[o]<<" ";
e+=d[o];
}
cout<<e<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
int n, m;
vector<pair<pair<int, int>, int>> g;
vector<pair<int, int>> v[200009], u[200009];
bool ok;
int w[200009];
bool chk[200009];
vector<int> q;
void Dfs2(int u, int f) {
chk[u] = 1;
for (auto i : v[u])
if (chk[i.first] == 0 && i.first != f && i.second != -1) {
w[i.first] = (w[u] ^ (__builtin_popcount(i.second) % 2));
q.push_back(i.first);
Dfs2(i.first, u);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _;
cin >> _;
while (_--) {
cin >> n >> m;
g.clear();
ok = true;
for (int i = 1; i <= n; ++i) {
v[i].clear();
u[i].clear();
}
fill(chk, chk + n + 1, 0);
for (int i = 1; i <= n - 1; ++i) {
int a, b, c;
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
g.push_back({{a, b}, c});
}
for (int i = 1; i <= m; ++i) {
int a, b, c;
cin >> a >> b >> c;
u[a].push_back({b, c});
u[b].push_back({a, c});
}
for (int i = n; i >= 1; --i) q.push_back(i);
while ((int)q.size()) {
int r = q.back();
q.pop_back();
if (chk[r] == 0) {
chk[r] = 1;
w[r] = 0;
}
for (auto i : u[r])
if (chk[i.first] == 0) {
chk[i.first] = 1;
w[i.first] = (w[r] ^ i.second);
q.push_back(i.first);
}
Dfs2(r, r);
}
for (int i = 1; i <= n; ++i) {
for (auto j : v[i]) {
if (j.second != -1 &&
(w[i] ^ w[j.first]) != (__builtin_popcount(j.second) % 2))
ok = false;
}
for (auto j : u[i]) {
if ((w[i] ^ w[j.first]) != j.second) ok = false;
}
}
if (ok == false)
cout << "NO\n";
else {
cout << "YES\n";
for (auto i : g) {
cout << i.first.first << " " << i.first.second << " ";
if (i.second == -1) {
cout << (w[i.first.first] ^ w[i.first.second]) << "\n";
} else
cout << i.second << "\n";
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1e-10;
inline int readint() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
inline long long readLL() {
long long sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int maxn = 3e4 + 5;
struct Edge {
int from, to, weight;
Edge(int from, int to, int weight) : from(from), to(to), weight(weight) {}
};
struct HeapNode {
int u, dist;
HeapNode(int u, int d) : u(u), dist(d) {}
bool operator<(const HeapNode& h) const { return dist > h.dist; }
};
struct Dijkstra {
int n, m;
vector<Edge> edges;
vector<int> G[maxn];
bool done[maxn];
int dist[maxn];
int p[maxn];
Dijkstra(int n) : n(n) {
for (int i = 0; i < n; i++) G[i].clear();
edges.clear();
}
void AddEdge(int from, int to, int weight) {
edges.push_back(Edge(from, to, weight));
m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s) {
priority_queue<HeapNode> Q;
memset(dist, 0x3f3f3f3f, sizeof(dist));
memset(done, false, sizeof(false));
dist[s] = 0;
Q.push(HeapNode(s, 0));
while (!Q.empty()) {
int u = Q.top().u;
Q.pop();
if (done[u]) continue;
done[u] = true;
for (int i = 0; i < G[u].size(); i++) {
Edge& e = edges[G[u][i]];
int v = e.to, w = e.weight;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
p[v] = G[u][i];
Q.push(HeapNode(v, dist[v]));
}
}
}
}
};
Dijkstra d(maxn);
map<pair<int, int>, int> ss;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k, x, y, s, e = 0;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
cin >> x >> y;
ss[make_pair(x, y)] = i + n + m;
if (x == 1 && y == 1) {
s = i + n + m;
}
if (x == n && y == m) {
e = i + n + m;
}
int t = i + n + m;
int ny = n + y;
if (x > 1) {
if (ss[make_pair(x - 1, y)] != 0) {
d.AddEdge(ss[make_pair(x - 1, y)], t, 0);
d.AddEdge(t, ss[make_pair(x - 1, y)], 0);
}
d.AddEdge(x - 1, t, 0);
d.AddEdge(t, x - 1, 1);
}
if (x < n) {
if (ss[make_pair(x + 1, y)] != 0) {
d.AddEdge(ss[make_pair(x + 1, y)], t, 0);
d.AddEdge(t, ss[make_pair(x + 1, y)], 0);
}
d.AddEdge(x + 1, t, 0);
d.AddEdge(t, x + 1, 1);
}
if (y > 1) {
if (ss[make_pair(x, y - 1)] != 0) {
d.AddEdge(ss[make_pair(x, y - 1)], t, 0);
d.AddEdge(t, ss[make_pair(x, y - 1)], 0);
}
d.AddEdge(ny - 1, t, 0);
d.AddEdge(t, ny - 1, 1);
}
if (y < m) {
if (ss[make_pair(x, y + 1)] != 0) {
d.AddEdge(ss[make_pair(x, y + 1)], t, 0);
d.AddEdge(t, ss[make_pair(x, y + 1)], 0);
}
d.AddEdge(ny + 1, t, 0);
d.AddEdge(t, ny + 1, 1);
}
d.AddEdge(x, t, 0), d.AddEdge(t, x, 1);
d.AddEdge(ny, t, 0), d.AddEdge(t, ny, 1);
}
if (!e) {
d.AddEdge(n, n + m + k + 1, 0);
d.AddEdge(n + m, n + m + k + 1, 0);
if (ss[make_pair(n, m - 1)] != 0) {
d.AddEdge(ss[make_pair(n, m - 1)], n + m + k + 1, e ? 0 : 1);
}
if (ss[make_pair(n - 1, m)] != 0) {
d.AddEdge(ss[make_pair(n - 1, m)], n + m + k + 1, e ? 0 : 1);
}
}
d.dijkstra(s);
if (d.dist[e ? e : n + m + k + 1] == 0x3f3f3f3f) {
cout << "-1" << endl;
} else {
cout << d.dist[e ? e : n + m + k + 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
clock_t time_p = clock();
void Time() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const int INF = 1e9 + 7;
long double pi = 3.1415926535897932;
const long long INF64 = 9e18;
const long long mod = 1e9 + 7;
const int mxN = 1e6 + 36;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (auto &it : a) cin >> it;
long long cnt[mxN];
memset(cnt, 0, sizeof(cnt));
for (auto it : a) cnt[it]++;
long long ans = 0;
for (int i = 0; i < mxN - 1; ++i) {
cnt[i + 1] += cnt[i] / 2;
ans += (cnt[i] % 2);
}
cout << ans << endl;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cerr.precision(15);
cout.precision(15);
cerr << fixed;
cout << fixed;
int t;
solve();
Time();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, l, m, n, a, b, c, d, x, y, z, p, q;
while (cin >> n) {
long long int sum = 0;
for (x = 1; x <= n; x++) {
cin >> a;
sum += a;
}
long long int ans = 0;
n++;
for (i = 1; i <= 5; i++) {
sum++;
if (sum % n != 1) ans++;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a[120005];
int n, m, father[120005], l[120005], deep[120005], num[120005], q[120005][30],
r, o, x, y, s1, s2, lca, ll, t, d, u[30];
int build(int k, int pre) {
father[k] = pre;
deep[k] = deep[pre] + 1;
num[k] = 1;
q[k][1] = father[k];
r = 1;
o = 1;
while (r * 2 <= deep[k]) {
q[k][o + 1] = q[q[k][o]][o];
o++;
r *= 2;
}
for (int i = 0; i < l[k]; i++)
if (a[k][i] != pre) num[k] = num[k] + build(a[k][i], k);
return num[k];
}
void find(int xx, int yy) {
if (father[xx] == father[yy]) {
s1 = xx;
s2 = yy;
return;
}
r = 1;
d = deep[xx];
while (u[r] < d && q[xx][r] != q[yy][r]) r++;
find(q[xx][r - 1], q[yy][r - 1]);
return;
}
int preeee(int xx, int k) {
if (k == 1) return father[xx];
r = 1;
while (u[r + 1] < k) r = r + 1;
return preeee(q[xx][r], k - u[r]);
}
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
l[x]++;
l[y]++;
a[x].push_back(y);
a[y].push_back(x);
}
build(1, 0);
o = 1;
u[o] = 1;
while (u[o] <= n) o++, u[o] = u[o - 1] * 2;
cin >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if ((deep[x] - deep[y]) % 2 != 0)
printf("0\n");
else if (x == y)
printf("%d\n", n);
else if (deep[x] == deep[y]) {
find(x, y);
printf("%d\n", n - num[s1] - num[s2]);
} else {
if (deep[x] < deep[y]) swap(x, y);
t = preeee(x, deep[x] - deep[y]);
if (t == y) {
lca = y;
ll = (deep[x] + deep[y]) / 2 - deep[lca];
if (ll == 1)
printf("%d\n", num[father[x]] - num[x]);
else {
o = preeee(x, ll - 1);
printf("%d\n", num[father[o]] - num[o]);
}
} else {
find(t, y);
lca = father[s1];
ll = (deep[x] + deep[y]) / 2 - deep[lca];
o = preeee(x, ll - 1);
printf("%d\n", num[father[o]] - num[o]);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9, maxn = (int)1e5 + 1;
const double eps = (double)1e-8;
const int mod = (int)1000000009;
int main() {
long long n, m, c, d, k, q, o = 0, kol = 0;
cin >> c >> d >> n >> m >> k;
q = n;
n = n * m - k;
m = q;
kol = 0;
while (o < n) {
if (d * m < c || (d * (n - o) < c)) {
o++;
kol += d;
} else {
o += m;
kol += c;
}
}
cout << kol;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int h,n,a[100009],sum;
int main(){
cin>>h>>n;
for(int i=0;i<n;i++){
cin>>a[i];
sum+=a[i];
}
cout<<((sum>=h)?"Yes":"No")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
int n, l, i, same = 0;
bool ch;
cin >> n >> s;
for (l = 1; l <= n / 2; l++) {
ch = 1;
for (i = 0; i < l; i++) {
if (s[i] != s[i + l]) {
ch = 0;
break;
}
}
if (l > same && ch) same = l;
}
if (same == 0)
cout << n;
else
cout << n - same + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[35][35][55], n, m, k;
inline long long int call(long long int x, long long int y, long long int rem) {
if (rem == 0) return 0;
if (rem == (x * y)) return 0;
if (dp[x][y][rem] != -1) return dp[x][y][rem];
long long int ans = 1e18;
for (long long int i = 1; i < y; i++) {
for (long long int k1 = 0; k1 <= k; k1++) {
ans = min(ans, x * x + call(x, i, k1) + call(x, y - i, k - k1));
}
}
for (long long int i = 1; i < x; i++) {
for (long long int k1 = 0; k1 <= k; k1++) {
ans = min(ans, y * y + call(i, y, k1) + call(x - i, y, k - k1));
}
}
return dp[x][y][rem] = ans;
}
int main() {
long long int t;
cin >> t;
memset(dp, -1, sizeof(dp));
while (t--) {
cin >> n >> m >> k;
cout << call(n, m, k) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long l, r;
};
bool cmp(node a, node b) {
if (a.l != b.l) return a.l < b.l;
return a.r < b.r;
}
long long T, N, S;
node a[200005];
bool can(long long x) {
long long cnt = 0;
long long money = 0;
for (long long i = N; i >= 1; i--) {
if (a[i].r < x)
money += a[i].l;
else if (cnt * 2 > N)
money += a[i].l;
else {
long long pay = max(a[i].l, x);
money += pay;
cnt++;
}
}
if (money <= S && cnt * 2 > N) return 1;
return 0;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> T;
while (T--) {
cin >> N >> S;
for (long long i = 1; i <= N; i++) cin >> a[i].l >> a[i].r;
sort(a + 1, a + N + 1, cmp);
long long ini = 0;
long long fin = 1e9;
while (ini < fin) {
long long mid = (ini + fin + 1) / 2;
if (can(mid))
ini = mid;
else
fin = mid - 1;
}
cout << ini << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 9;
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n);
long long ex = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = max(0LL, a[i] - ex);
long long need = (a[i] + k - 1) / k;
ans += need;
ex = need * k - a[i];
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t(int n, int k) {
int x = 1;
int p = k;
while (p <= n) {
p = k;
p = p + x;
x = x * 2;
}
p = p - x / 2 + x / 4;
return p;
}
int main() {
unsigned int a;
cin >> a;
unsigned int b[a + 1];
unsigned int i = 1;
for (i = 1; i <= a; i++) {
cin >> b[i];
}
unsigned int n = a, tmp, k = 0;
i = 1;
while (i < n) {
tmp = t(n, i);
{
while (b[i] != 0) {
b[i] = b[i] - 1;
b[tmp] = b[tmp] + 1;
k++;
}
cout << k << endl;
}
i++;
}
if ((a == 0) || (a == 1)) cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n], b[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
long long min = b[0];
long long start = 0;
for (long long i = 0; i < n; i++) {
if (a[i] == min) {
start = i;
break;
}
}
long long z = start;
long long ans = 1000000001;
for (long long i = start + 1; i < n; i++) {
if (a[i] == min) {
ans = ans < i - z ? ans : i - z;
z = i;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isprime[1000100];
int main() {
vector<long long> primes;
primes.push_back(2);
for (int i = 0; i <= 1000000; i++) isprime[i] = 1;
isprime[0] = isprime[1] = 0;
for (long long i = 3; i <= 1000000; i += 2) {
if (isprime[i]) {
for (long long j = i * i; j <= 1000000; j += i + i) isprime[j] = 0;
primes.push_back(i);
}
}
long long n;
while (cin >> n) {
long long ans = 1;
for (auto x : primes) {
if (x > n) break;
if (!(n % x)) {
ans *= x;
while (!(n % x)) n /= x;
}
}
ans *= n;
cout << ans << endl;
}
}
| 2 |
#include <stdio.h>
#include <math.h>
#include <vector>
#include <iostream>
using namespace std;
int main(void) {
vector<double> r;
int n;
while (true)
{
cin >> n;
if (n==-1){break;}
double x=1,y=0,s=0,c=0;
for (int i=1; i<n; i++)
{
if(x!=0)
{
s = y/(sqrt(x*x+y*y));
c = x/(sqrt(x*x+y*y));
x -= s;
y += c;
} else {
if (y>=0)
{
x -= 1;
} else {
x += 1;
}
}
}
r.push_back(x);
r.push_back(y);
}
for(int i=0; i<r.size(); i++)
{
cout << r[i] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T rd() {
T nmb = 0;
int sgn = 0;
char chr = getchar();
while (!isdigit(chr)) {
if (chr == '-') sgn = 1;
chr = getchar();
}
while (isdigit(chr)) {
nmb = (nmb << 3) + (nmb << 1) + chr - '0';
chr = getchar();
}
return sgn ? -nmb : nmb;
}
template <typename T>
void wt(T nmb) {
if (nmb > 9) wt(nmb / 10);
putchar(nmb % 10 + '0');
}
template <typename T>
void cmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void cmin(T &x, T y) {
x = x < y ? x : y;
}
void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
const int N = 5e5 + 10, L = 1e6 + 10, K = 30;
int n;
char S[N];
int pos[N];
int lst = 1, cnt = 1;
int ch[L][K], mx[L], pre[L];
void insert(int c) {
int np = ++cnt, p = lst;
mx[np] = mx[p] + 1;
lst = np;
for (; p && !ch[p][c]; p = pre[p]) ch[p][c] = np;
if (!p)
pre[np] = 1;
else {
int q = ch[p][c];
if (mx[q] == mx[p] + 1)
pre[np] = q;
else {
int nq = ++cnt;
memcpy(ch[nq], ch[q], sizeof ch[q]);
mx[nq] = mx[p] + 1;
pre[nq] = pre[q];
pre[np] = pre[q] = nq;
for (; p && ch[p][c] == q; p = pre[p]) ch[p][c] = nq;
}
}
}
vector<int> g[L];
int dfn[L], Cnt;
int siz[L];
void dfs(int x) {
dfn[x] = ++Cnt;
siz[x] = 1;
for (int i = g[x].size() - 1; ~i; --i) {
int k = g[x][i];
dfs(k);
siz[x] += siz[k];
}
}
int dp[N];
int val[L << 2];
void change(int r, int x, int y, int k, int p) {
if (x == y) {
val[r] = p;
return;
}
int m = (x + y) >> 1;
if (k <= m)
change(r << 1, x, m, k, p);
else
change(r << 1 | 1, m + 1, y, k, p);
val[r] = max(val[r << 1], val[r << 1 | 1]);
}
int query(int r, int x, int y, int u, int v) {
if (u <= x && y <= v) return val[r];
int m = (x + y) >> 1;
int res = 0;
if (u <= m) res = query(r << 1, x, m, u, v);
if (m < v) cmax(res, query(r << 1 | 1, m + 1, y, u, v));
return res;
}
void Init() {
n = rd<int>();
scanf("%s", S + 1);
reverse(S + 1, S + n + 1);
for (int i = 1; i <= n; ++i) insert(S[i] - 'a' + 1), pos[i] = lst;
for (int i = 2; i <= cnt; ++i) g[pre[i]].push_back(i);
dfs(1);
S[0] = 'a' - 1;
}
void Solve() {
int p1 = 1, p2 = 1;
for (int i = 1; i <= n; ++i) {
int c1 = S[i - 1] - 'a' + 1, c2 = S[i] - 'a' + 1;
while (p1 && !ch[p1][c1]) p1 = pre[p1];
while (p2 && !ch[p2][c2]) p2 = pre[p2];
p1 = p1 ? ch[p1][c1] : 1;
p2 = p2 ? ch[p2][c2] : 1;
dp[i] = dp[i - 1] + 1;
while (dp[i] > 1) {
while (p1 && mx[pre[p1]] >= dp[i] - 1) p1 = pre[p1];
while (p2 && mx[pre[p2]] >= dp[i] - 1) p2 = pre[p2];
if (dp[i] <= query(1, 1, cnt, dfn[p1], dfn[p1] + siz[p1] - 1) + 1) break;
if (dp[i] <= query(1, 1, cnt, dfn[p2], dfn[p2] + siz[p2] - 1) + 1) break;
change(1, 1, cnt, dfn[pos[i - dp[i] + 1]], dp[i - dp[i] + 1]);
--dp[i];
}
}
int Ans = 0;
for (int i = 1; i <= n; ++i) cmax(Ans, dp[i]);
printf("%d\n", Ans);
}
int main() {
Init();
Solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005 + 5;
int t, n, m, l, r, sum[N], dep[N];
bool solve() {
fill(dep + 1, dep + n + 1, 1);
m = n * (n - 1) / 2 - m;
for (l = 2, r = n; l < r; --r) {
while (l < r && (m - r + l < 0 || dep[l] == dep[l - 1] * 2)) l++;
if (l >= r) break;
m -= r, dep[r]--;
m += l, dep[l]++;
}
return m == 0;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
if (!solve())
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= r; ++i) sum[i] = sum[i - 1] + dep[i];
for (int i = 2; i <= r; ++i) {
for (int j = 0; j < dep[i]; ++j) printf("%d ", sum[i - 2] + 1 + j / 2);
}
printf("\n");
}
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define dbg(...) do{cerr<<__LINE__<<": ";dbgprint(#__VA_ARGS__, __VA_ARGS__);}while(0);
using namespace std;
namespace std{template<class S,class T>struct hash<pair<S,T>>{size_t operator()(const pair<S,T>&p)const{return ((size_t)1e9+7)*hash<S>()(p.first)+hash<T>()(p.second);}};template<class T>struct hash<vector<T>>{size_t operator()(const vector<T> &v)const{size_t h=0;for(auto i : v)h=h*((size_t)1e9+7)+hash<T>()(i)+1;return h;}};}
template<class T>ostream& operator<<(ostream &os, const vector<T> &v){os<<"[ ";rep(i,v.size())os<<v[i]<<(i==v.size()-1?" ]":", ");return os;}template<class T>ostream& operator<<(ostream &os,const set<T> &v){os<<"{ "; for(const auto &i:v)os<<i<<", ";return os<<"}";}
template<class T,class U>ostream& operator<<(ostream &os,const map<T,U> &v){os<<"{";for(const auto &i:v)os<<" "<<i.first<<": "<<i.second<<",";return os<<"}";}template<class T,class U>ostream& operator<<(ostream &os,const pair<T,U> &p){return os<<"("<<p.first<<", "<<p.second<<")";}
void dbgprint(const string &fmt){cerr<<endl;}template<class H,class... T>void dbgprint(const string &fmt,const H &h,const T&... r){cerr<<fmt.substr(0,fmt.find(","))<<"= "<<h<<" ";dbgprint(fmt.substr(fmt.find(",")+1),r...);}
typedef long long ll;typedef vector<int> vi;typedef pair<int,int> pi;const int inf = (int)1e9;const double INF = 1e12, EPS = 1e-9;
int main(){
cin.tie(0); cin.sync_with_stdio(0);
int n, m, X, Y;
cin >> n >> m >> X >> Y;
vi v(n + m); rep(i, n + m) cin >> v[i];
ll ans = 0;
set<int> lens;
map<int,int> cnt;
map<pi,int> cnt2;
set<tuple<int,int,int>> vis;
rep(i, n){
if(i < m){
int a = v[i] - v[i + n], b = v[i + n];
lens.insert(a);
lens.insert(b);
++cnt2[pi(min(a, b), max(a, b))];
}
else{
++cnt[v[i]];
lens.insert(v[i]);
}
}
if(X == 0){
vector<pi> vs;
for(auto i : cnt) if(i.second >= 4) vs.emplace_back(i.first, i.second);
rep(i, vs.size()){
if(vs[i].second >= 12) ans++;
if(vs[i].second >= 8) ans += (int)vs.size() - i - 1;
for(int j = i + 1; j < vs.size(); j++){
if(vs[j].second >= 8) ans++;
ans += (int)vs.size() - j - 1;
}
}
cout << ans << endl;
return 0;
}
for(auto i : cnt2) for(int j : lens){
vi l = {i.first.first, i.first.second, j};
sort(all(l));
if(vis.count(tie(l[0], l[1], l[2]))) continue;
if(l[0] == l[1] && l[1] == l[2]){
int x = min(X, cnt2.count(pi(l[0], l[1])) ? cnt2[pi(l[0], l[1])] : 0);
int y = cnt.count(l[0]) ? cnt[l[0]] : 0;
if(x == X && 2 * x + y >= 12) vis.emplace(l[0], l[1], l[2]);
}
else if(l[0] == l[1]){
int x0 = min(X, cnt2.count(pi(l[0], l[1])) ? cnt2[pi(l[0], l[1])] : 0);
int x1 = min(X, cnt2.count(pi(l[0], l[2])) ? cnt2[pi(l[0], l[2])] : 0);
bool ok = 0;
rep(i, x0+1){
if(X - i > x1) continue;
int a = 2 * i + X - i, c = X - i;
if(a > 8 || c > 4) continue;
if(a + (cnt.count(l[0]) ? cnt[l[0]] : 0) >= 8 &&
c + (cnt.count(l[2]) ? cnt[l[2]] : 0) >= 4){
ok = 1;
break;
}
}
if(ok) vis.emplace(l[0], l[1], l[2]);
}
else if(l[1] == l[2]){
int x0 = min(X, cnt2.count(pi(l[0], l[1])) ? cnt2[pi(l[0], l[1])] : 0);
int x1 = min(X, cnt2.count(pi(l[1], l[2])) ? cnt2[pi(l[1], l[2])] : 0);
bool ok = 0;
rep(i, x0+1){
if(X - i > x1) continue;
int a = i, c = i + 2*(X - i);
if(a > 4 || c > 8) continue;
if(a + (cnt.count(l[0]) ? cnt[l[0]] : 0) >= 4 &&
c + (cnt.count(l[2]) ? cnt[l[2]] : 0) >= 8){
ok = 1;
break;
}
}
if(ok) vis.emplace(l[0], l[1], l[2]);
}
else{
int x0 = min(X, cnt2.count(pi(l[0], l[1])) ? cnt2[pi(l[0], l[1])] : 0);
int x1 = min(X, cnt2.count(pi(l[1], l[2])) ? cnt2[pi(l[1], l[2])] : 0);
int x2 = min(X, cnt2.count(pi(l[0], l[2])) ? cnt2[pi(l[0], l[2])] : 0);
bool ok = 0;
rep(i, x0+1) rep(j, x1+1){
if(X - i - j > x2 || i + j > X) continue;
int a = i + (X - i - j), b = i + j, c = j + (X - i - j);
if(a > 4 || b > 4 || c > 4) continue;
if(a + (cnt.count(l[0]) ? cnt[l[0]] : 0) >= 4 &&
b + (cnt.count(l[1]) ? cnt[l[1]] : 0) >= 4 &&
c + (cnt.count(l[2]) ? cnt[l[2]] : 0) >= 4){
ok = 1;
break;
}
}
if(ok) vis.emplace(l[0], l[1], l[2]);
}
}
cout << vis.size() << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, seed = 131, MAXN = 0;
int main() {
cin.tie(0)->sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
a = " " + a;
b = " " + b;
vector<int> ans;
int uwu1 = 1, uwu2 = n;
for (int i = 0; i <= n - 1; ++i) {
if ((a[uwu1] - '0') ^ (i % 2) == (b[n - i] - '0')) ans.push_back(1);
ans.push_back(n - i);
swap(uwu1, uwu2);
if (i % 2 == 0) uwu2++;
if (i % 2 == 1) uwu2--;
}
cout << ans.size() << " ";
for (int x : ans) cout << x << " ";
cout << '\n';
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int dp[3001][3001];
int a[3000], b[3000];
int N, T, S;
int rec(int idx, int time){
if(idx == N || time == T) return(0);
if(~dp[idx][time]) return(dp[idx][time]);
int ret = max( rec( idx + 1, time), rec( idx, time + 1));
if((time + b[idx] <= S || time >= S) && time + b[idx] <= T){
ret = max( ret, rec( idx + 1, time + b[idx]) + a[idx]);
}
return(dp[idx][time] = ret);
}
int main(){
fill_n( *dp, 3001 * 3001, -1);
cin >> N >> T >> S;
for(int i = 0; i < N; i++){
cin >> a[i] >> b[i];
}
cout << rec(0,0) << endl;
} | 0 |
#include <bits/stdc++.h>
const int N = 1e5;
const int inf = 1e9 + 10;
using namespace std;
void yes() { cout << "YES" << endl; }
void no() { cout << "NO" << endl; }
map<long long int, long long int> cnt;
void prime_factorization(long long int n) {
for (long long int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
++cnt[i];
}
}
if (n > 1) ++cnt[n];
}
void solve() {
long long int x, y, a, b;
cin >> x >> y;
a = x, b = y;
if (x > y) {
cout << x + y;
return;
}
if (x == y) {
cout << x;
return;
}
if (y % x == 0) {
cout << x;
return;
}
cout << (y / x) * x + (y % x) / 2;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 1)
cout << a[1] << endl;
else {
sort(a + 1, a + n + 1);
long long int cross = 0, mn = a[1], second = 0, ans = a[1];
for (int i = 2; i <= n; i++) {
second += mn;
mn = a[i] - second;
a[i] = mn;
ans = max(mn, ans);
}
sort(a + 1, a + n + 1);
cout << ans;
cout << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 1000010;
int n, r[maxn * 4], ans[maxn];
char s[maxn], S[maxn * 4];
int min(int a, int b) { return a < b ? a : b; }
int main() {
scanf("%d%s", &n, s);
S[0] = 2;
for (int i = 0; i < n * 2; i++) {
S[i * 2 + 1] = 1;
S[i * 2 + 2] = s[i % 2 ? n - i / 2 - 1 : i / 2];
}
S[n * 4 + 1] = 1;
int mr = 0, c = 0;
for (int i = 1; i <= n * 4 + 1; i++) {
if (i < mr) r[i] = min(r[c * 2 - i], mr - i);
for (; S[i - r[i]] == S[i + r[i]]; r[i]++)
;
if (i + r[i] > mr) mr = i + r[i], c = i;
}
int m = n + 1 >> 1, p = m;
for (int i = 0; i < m; i++) ans[i] = -1;
for (int i = n / 2 * 4 - 1; i > 1; i -= 4) {
int q = i / 4 + 1 - (r[i] + 1) / 4;
for (p = min(p, i / 4 + 1); p > q;) p--, ans[p] = i / 2 - p * 2;
}
for (int i = 0; i < m; i++) printf("%d%c", ans[i], " \n"[i == m - 1]);
}
| 6 |
#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int N=2e5+10;
const int B=316;
int read(){
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
void print(LL x){
if(x>9) print(x/10);
putchar(x%10+'0');
}
int h,w;
int sx,sy,tx,ty;
char s[1010];
int mp[1010][1010];
int f[1010][1010];
struct P{
int x,y,z;
}p,A;
deque< P > Q;
int xx[4]={-1,0,1,0};
int yy[4]={0,1,0,-1};
int main(){
memset(f,60,sizeof(f));
//cout<<f[1][1]<<endl;
scanf("%d%d%d%d%d%d",&h,&w,&sx,&sy,&tx,&ty);
for(int i=1;i<=h;++i){
scanf("%s",s+1);
for(int j=1;j<=w;++j)
if(s[j]=='#') mp[i][j]=1;
}
p.x=sx;p.y=sy;p.z=0;
Q.push_back(p);
while(!Q.empty()){
p=Q[0];
Q.pop_front();
if(p.z<f[p.x][p.y]){
f[p.x][p.y]=p.z;
for(int k=0;k<4;++k){
A.x=p.x+xx[k];
A.y=p.y+yy[k];
A.z=p.z;
if(mp[A.x][A.y]==0&&A.x>=1&&A.y>=1&&A.x<=h&&A.y<=w) Q.push_front(A);
}
for(int i=p.x-2;i<=p.x+2;++i){
for(int j=p.y-2;j<=p.y+2;++j){
if(mp[i][j]==0&&i>=1&&j>=1&&i<=h&&j<=w){
A.x=i;A.y=j;A.z=p.z+1;
Q.push_back(A);
}
}
}
}
}
if(f[tx][ty]<1e9) cout<<f[tx][ty]<<endl;
else cout<<-1<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void f();
int main() {
int t;
cin >> t;
while (t--) {
f();
}
return 0;
}
void f() {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << max((a + b), (c + d)) << endl;
}
| 2 |
#include <iostream>
using namespace std;
int main() {
int a,b[100010]={0},c[110],ans =0;
cin >> a ;
for(int i=1;i<=a;i++) cin >> b[i];
for(int i=0;i<=a+1;i++){
ans += abs(b[i]-b[i+1]);
}
for(int i=1;i<=a;i++){
cout << ans + abs(b[i-1]-b[i+1]) -abs(b[i-1]-b[i]) -abs(b[i]-b[i+1]) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ships = 0, n, k, a, m;
set<pair<int, int> > xs;
int cal(int l, int r) { return (r - l + 2) / (a + 1); }
int main() {
cin >> n >> k >> a >> m;
xs.insert({n, 1});
ships = cal(1, n);
for (int i = 1; i <= m; i++) {
int x;
int newa = 0, newb = 0;
cin >> x;
auto it = xs.lower_bound({x, -1});
int l = it->second, r = it->first;
if (x - 1 >= l) newa = cal(l, x - 1);
if (x + 1 <= r) newb = cal(x + 1, r);
ships -= cal(l, r);
ships += newb + newa;
if (ships < k) {
cout << i << endl;
return 0;
}
xs.erase(it);
if (x - 1 >= l) xs.insert({x - 1, l});
if (x + 1 <= r) xs.insert({r, x + 1});
}
cout << -1 << endl;
}
| 4 |
#include <algorithm>
#include <cstdio>
using namespace std;
int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}
int main() {
int a, b;
while (scanf("%d%d", &a, &b) == 2) {
if (a < b) swap(a, b);
printf("%d\n", gcd(a, b));
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,K;
cin >>N>>K;
if((N+1)/2 >= K)cout<<"YES";
else cout <<"NO";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100;
const int MM = 100 * 1000;
const int INF = 1 << 29;
const long long D = 1000 * 1000 * 1000 + 7;
int p[MAX + 10];
bool adj[MAX + 10][MAX + 10];
int cnt = 0;
int k;
int main() {
ios::sync_with_stdio(false);
for (int i = 3; i < MAX; i++) p[i] = i * (i - 1) * (i - 2) / 3 / 2;
cin >> k;
for (int i = MAX - 1; i >= 3; i--)
if (p[i] <= k) {
k -= p[i];
for (int j = 0; j < i; j++)
for (int l = j + 1; l < i; l++) adj[j][l] = adj[l][j] = true;
cnt += i;
break;
}
for (int i = cnt; i >= 3; i--) {
if (k <= 10) break;
while (p[i] - p[i - 1] <= k && k > 10) {
k -= p[i] - p[i - 1];
for (int j = cnt - i + 1; j < cnt; j++) adj[cnt][j] = adj[j][cnt] = 1;
cnt++;
}
}
for (int i = 5; i >= 3; i--)
while (p[i] <= k) {
cnt -= 1;
k -= p[i];
for (int j = cnt; j < cnt + i; j++)
for (int l = cnt; l < cnt + i; l++)
if (j != l) adj[j][l] = true;
cnt += i;
}
cout << cnt << endl;
for (int i = 0; i < cnt; i++) {
for (int j = 0; j < cnt; j++) cout << adj[i][j];
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int nextint() {
int temporary;
scanf("%d", &temporary);
return temporary;
}
inline long long nextll() {
long long temporary;
scanf("%lld", &temporary);
return temporary;
}
inline double nextdouble() {
double temporary;
scanf("%lf", &temporary);
return temporary;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
int leftChild(int p) { return p << 1; }
int rightChild(int p) { return (p << 1) + 1; }
inline long long mid(long long l, long long r) { return (l + r) / 2; }
const long long MOD = 1000000007;
const double eps = 1e-7;
const double PI = acos(-1.0);
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long rem = 0;
long long a[n], b[n];
for (long long i = (long long)(0); i < (long long)(n); i++) {
cin >> a[i];
rem += a[i];
}
for (long long i = (long long)(0); i < (long long)(n); i++) {
cin >> b[i];
}
sort(b, b + n);
if (b[n - 1] + b[n - 2] >= rem) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 8, lim = 4 * maxn;
int segtree[lim];
int len[maxn];
vector<int> tlist[maxn];
int ptr;
map<int, int> m;
int mapper(int num) {
int val = m[num];
if (val != 0) return val;
m[num] = ++ptr;
return ptr;
}
int query(int cur, int l, int r, int ql, int qr) {
if (l > qr || r < ql) return 0;
if (l >= ql && r <= qr) return segtree[cur];
int lc = 2 * cur, rc = lc + 1, mid = (l + r) / 2;
return (query(lc, l, mid, ql, qr) + query(rc, mid + 1, r, ql, qr));
}
void update(int cur, int l, int r, int pos, int val) {
if (l > pos || r < pos) return;
if (l == pos && r == pos) {
segtree[cur] += val;
return;
}
int lc = 2 * cur, rc = lc + 1, mid = (l + r) / 2;
update(lc, l, mid, pos, val);
update(rc, mid + 1, r, pos, val);
segtree[cur] = segtree[lc] + segtree[rc];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
pair<int, pair<int, int> > q[n];
vector<int> val;
for (int i = 0; i < n; i++) {
cin >> q[i].first >> q[i].second.first >> q[i].second.second;
val.push_back(q[i].second.second);
}
sort(val.begin(), val.end());
for (auto u : val) mapper(u);
for (int i = 0; i < n; i++) {
q[i].second.second = mapper(q[i].second.second);
tlist[q[i].second.second].push_back(q[i].second.first);
}
for (int i = 0; i < maxn; i++) {
if (tlist[i].size() == 0) continue;
sort(tlist[i].begin(), tlist[i].end());
std::vector<int>::iterator it;
it = std::unique(tlist[i].begin(), tlist[i].end());
tlist[i].resize(std::distance(tlist[i].begin(), it));
}
for (int i = 1; i < maxn; i++) len[i] = len[i - 1] + tlist[i].size();
for (int i = 0; i < n; i++) {
int l = len[q[i].second.second - 1] + 1;
int r =
l + (lower_bound(tlist[q[i].second.second].begin(),
tlist[q[i].second.second].end(), q[i].second.first) -
tlist[q[i].second.second].begin());
if (q[i].first == 1)
update(1, 1, len[maxn - 1], r, 1);
else if (q[i].first == 2)
update(1, 1, len[maxn - 1], r, -1);
else
cout << query(1, 1, len[maxn - 1], l, r) << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
int main() {
long long n, m;
cin >> n >> m;
long long a[100003], b[100003];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
long long ans[100003] = {0}, tot[100003] = {0};
long long fans = 0;
long long dv = 1;
for (long long i = 0; i < n; i++) {
if (a[i] == 0 && b[i] == 0) {
ans[i] = (m - 1);
tot[i] = (2 * m);
fans = (fans + ((((ans[i]) * inv(tot[i])) % 1000000007) * inv(dv)) %
1000000007) %
1000000007;
dv = (dv * m) % 1000000007;
} else if (a[i] == 0 && b[i] != 0) {
tot[i] = m;
ans[i] = m - b[i];
fans = (fans + ((((ans[i]) * inv(tot[i])) % 1000000007) * inv(dv)) %
1000000007) %
1000000007;
dv = (dv * m) % 1000000007;
} else if (a[i] != 0 && b[i] == 0) {
tot[i] = m;
ans[i] = a[i] - 1;
fans = (fans + ((((ans[i]) * inv(tot[i])) % 1000000007) * inv(dv)) %
1000000007) %
1000000007;
dv = (dv * m) % 1000000007;
} else {
if (a[i] > b[i]) {
ans[i] = 1;
tot[i] = 1;
fans = (fans + (1 * inv(dv)) % 1000000007) % 1000000007;
break;
} else if (a[i] == b[i]) {
} else {
break;
}
}
}
cout << fans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, i, f = 0, A, B, C;
cin >> n;
vector<long long> a(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
A = a[i];
B = a[A - 1];
C = a[B - 1];
if (C == i + 1) {
f = 1;
break;
} else
f = 0;
}
if (f == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, l[3001][3001], dp[3001][3001], mod = 1000000007;
char cc;
long long find(long long aa, long long bb, long long qq, long long ww) {
if (l[aa][bb] == 2) return 0;
memset(dp, 0, sizeof(dp));
dp[aa][bb] = 1;
for (int i = aa; i <= qq; i++) {
for (int j = bb; j <= ww; j++) {
if (i == aa && j == bb) continue;
if (l[i][j] == 2) continue;
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
dp[i][j] %= 1000000007;
}
}
return dp[qq][ww] % 1000000007;
}
int main() {
scanf("%lld%lld", &a, &b);
getchar();
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
l[i][j] = (getchar() == '.') ? 1 : 2;
}
getchar();
}
printf("%lld", ((find(1, 2, a - 1, b) * find(2, 1, a, b - 1) % 1000000007 -
find(1, 2, a, b - 1) * find(2, 1, a - 1, b)) %
1000000007 +
1000000007) %
1000000007);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, n, m;
int main() {
cin >> n;
long long arr[n];
map<long long, long long> mp, mp1;
map<long long, long long>::iterator it, itr, ptr;
for (int i = 1; i <= 2 * n; i++) {
cin >> a;
it = mp.find(a);
if (it != mp.end()) {
mp1[a] = i;
} else {
mp[a] = i;
}
}
a = 1;
for (int i = 1; i <= n; i++) {
it = mp.lower_bound(i);
b = it->second;
c += abs(b - a);
a = it->second;
}
a = 1;
for (int i = 1; i <= n; i++) {
it = mp1.lower_bound(i);
b = it->second;
c += abs(b - a);
a = it->second;
}
cout << c;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cstdio>
using namespace std;
int n,m;
int bs[20];
int as[20];
int dp[1<<14];
int combSum[1<<14];
const int INF=1000000000;
int main(){
int tmp[20];
while(scanf("%d %d",&n,&m)&&(n|m)){
memset(combSum,0,sizeof(combSum));
for(int i=0;i<n;i++)
scanf("%d %d",bs+i,as+i);
for(int mask=1;mask<(1<<n);mask++)
for(int i=0;i<n;i++)
if((mask>>i)&1)combSum[mask]+=as[i];
for(int mask=(1<<n)-1;mask>=0;mask--){
int res=INF;
if(mask==(1<<n)-1)res=0;
else{
int cemp=m;
int sz=0;
for(int i=0;i<n;i++){
if((mask>>i)&1)cemp+=bs[i]-as[i];
else tmp[sz++]=i;
}
int revMask=(~mask)&((1<<n)-1);
int sub=revMask;
do{
int nmask=mask|(sub);
int sum=combSum[sub];
if(nmask!=mask&&sum<=cemp)
res=min(res,dp[nmask]+1);
sub=(sub-1)&revMask;
}while(sub!=revMask);
}
dp[mask]=res;
}
if(dp[0]==INF)printf("Impossible\n");
else printf("%d\n",dp[0]);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100];
bool check(int x, int r)
{
int st = 0;
for (int i = 0; i < n; i++){
if (a[i] > x) return false;
if (st + a[i] > x){
--r;
st = 0;
}
st += a[i];
}
return r > 0;
}
int main()
{
int m;
while (scanf("%d %d", &m, &n), n){
for (int i = 0; i < n; i++){
scanf("%d", &a[i]);
}
int l = 1, r = 1500000;
while (l <= r){
int mid = (l + r) / 2;
if (check(mid, m)) r = mid - 1;
else l = mid + 1;
}
printf("%d\n", l);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] == s2[i])
cout << "0";
else
cout << "1";
}
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int x = 0, y = 0, m = 0;
set<tuple<int, int, int> > e;
for (char c : s) {
int temp;
int x2 = x, y2 = y;
if (c == 'N') temp = 0, x2++;
if (c == 'S') temp = 2, x2--;
if (c == 'E') temp = 1, y2++;
if (c == 'W') temp = 3, y2--;
if (e.find({x, y, temp}) != e.end() ||
e.find({x2, y2, (temp + 2) % 4}) != e.end())
m++;
else
m += 5;
e.insert({x, y, temp});
x = x2, y = y2;
}
cout << m << "\n";
}
}
| 3 |
#include <iostream>
using namespace std;
long long n, k, j = 0, t = 0;
long long a[200000], b[200000], c[200000];
int main()
{
cin >> n >> k;
fill(c, c + n + 1, -1);
for (long long i = 0; i < n; i++)
cin >> a[i];
while (c[j] < 0) {
c[j] = t;
b[t] = j;
t++;
j = a[j] - 1;
}
if(k < t)
cout << b[k] + 1 << endl;
else {
k = (k - c[j]) % (t - c[j]) + c[j];
cout << b[k] + 1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int c = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
c = c * 10 + ch - '0';
ch = getchar();
}
return c * f;
}
const int inf = 0x3f3f3f3f;
int dis[30][30], x[30], y[30], _dis[30], _x, _y, n, pos;
int dp[1 << 24], pre[1 << 24];
vector<int> ans;
void path(int i) {
if (i == 0) return;
int x = i ^ pre[i];
ans.push_back(0);
for (int j = 0; j < n; ++j)
if ((1 << j) & x) {
ans.push_back(j + 1);
}
path(pre[i]);
}
int getbit(int i) {
int num = 0;
while (i) {
i >>= 1;
num++;
}
return num - 1;
}
int main() {
_x = read(), _y = read();
n = read();
for (int i = 0; i < n; ++i) x[i] = read(), y[i] = read();
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j)
dis[i][j] = dis[j][i] =
(x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
_dis[i] = (x[i] - _x) * (x[i] - _x) + (y[i] - _y) * (y[i] - _y);
dis[i][i] = 0;
}
int len = 1 << n;
memset(dp, inf, sizeof dp);
dp[0] = 0;
for (int i = 1; i < len; ++i) {
pos = getbit(i);
for (int j = 0; j < pos + 1; ++j)
if (i & (1 << j)) {
if (dp[i] > dp[i ^ ((1 << j) | (1 << pos))] + dis[j][pos] + _dis[j] +
_dis[pos]) {
dp[i] = dp[i ^ ((1 << j) | (1 << pos))] + dis[j][pos] + _dis[j] +
_dis[pos];
pre[i] = i ^ ((1 << j) | (1 << pos));
}
}
}
printf("%d\n", dp[len - 1]);
path(len - 1);
ans.push_back(0);
for (int i = ans.size() - 1; i >= 0; --i) {
printf("%d ", ans[i]);
}
puts("");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int, int> P;
int main() {
int a, b;
cin >> a >> b;
cout << abs(a-b) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int frinds[n];
for (int i = 0; i < n; i++) {
cin >> frinds[i];
}
int x[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i + 1 == frinds[j]) x[i] = j + 1;
}
}
for (int i = 0; i < n; i++) cout << x[i] << " ";
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int d;
bool isprime(int x){
for(int i=2;i<=sqrt(x);i++)
if(x%i == 0) return false;
return true;
}
int main(){
int T,ans1,ans2;
cin>>T;
while(T--){
cin>>d;
for(int i=d+1;;i++){
if(isprime(i)){
ans1 = i;
break;
}
}
for(int i=ans1+d;;i++){
if(isprime(i)){
ans2 = i;
break;
}
}
printf("%d\n",ans1*ans2);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int maxn = 4000000;
struct point {
long long x, y;
point() {}
point(long long a, long long b) : x(a), y(b) {}
long long len2() const { return x * x + y * y; }
} a[maxn], b[maxn];
long long vect(const point& a, const point& b) { return a.y * b.x - a.x * b.y; }
point operator-(const point& a, const point& b) {
return point(a.x - b.x, a.y - b.y);
}
struct cmp {
const point& t;
cmp(const point& a) : t(a) {}
bool operator()(const point& a, const point& b) const {
point ta(a - t);
point tb(b - t);
long long v = vect(ta, tb);
if (v) return v > 0;
return ta.len2() < tb.len2();
}
};
long long mabs(long long a) { return a >= 0 ? a : -a; }
long long len(const point& a) {
long long res = max(mabs(a.x), mabs(a.y));
return res;
}
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
for (int d = 0; d < 4; d++) {
a[cnt++] = point(x + dx[d], y + dy[d]);
}
}
int best = 0;
for (int i = 1; i < cnt; i++) {
if (a[i].x < a[best].x) {
best = i;
} else if (a[i].x == a[best].x && a[i].y < a[best].y) {
best = i;
}
}
swap(a[best], a[0]);
sort(a + 1, a + cnt, cmp(a[0]));
int k = 0;
b[k++] = a[0];
b[k++] = a[1];
for (int i = 2; i < cnt; i++) {
for (; k > 1 && vect(b[k - 1] - b[k - 2], a[i] - b[k - 1]) <= 0; k--)
;
b[k++] = a[i];
}
long long res = 0;
b[k] = b[0];
for (int i = 0; i < k; i++) {
res += len(b[i + 1] - b[i]);
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int DIM = 110 * 1000;
int n;
vector<int> e[DIM];
int top;
int mi[DIM], ma[DIM];
int key[DIM];
int q;
pair<int, int> a[DIM];
int rs[DIM], ls[DIM];
vector<pair<pair<int, int>, int> > pp;
long long aa[DIM], bb[DIM];
int ras[DIM];
double ans[DIM];
void dfs(int u, int pr = -1, int r = 0) {
if (pr != -1) {
if (key[u] < key[pr])
ls[pr] = u;
else
rs[pr] = u;
}
ras[u] = r;
mi[u] = ma[u] = key[u];
for (int i = (0); i < ((int)(e[u].size())); i++) {
int v = e[u][i];
if (v != pr) {
dfs(v, u, r + 1);
mi[u] = min(mi[u], mi[v]);
ma[u] = max(ma[u], ma[v]);
}
}
}
int getl(int x) { return lower_bound(a, a + q, make_pair(x, -1)) - a; }
void add(int l, int r, int val) {
if (l <= r) {
aa[l] += val;
aa[r + 1] -= val;
bb[l]++;
bb[r + 1]--;
}
}
void dfs2(int u, int pr, int lg, int rg) {
if ((int)(e[u].size()) > 1) {
int sg = getl(key[u]) - 1;
add(lg, sg, mi[rs[u]]);
add(sg + 1, rg, ma[ls[u]]);
}
for (int i = (0); i < ((int)(e[u].size())); i++) {
int v = e[u][i];
if (v != pr) {
int sg = getl(key[u]) - 1;
if (ls[u] == v)
dfs2(v, u, lg, min(rg, sg));
else
dfs2(v, u, max(lg, sg + 1), rg);
}
}
}
void solve() {
sort(a, a + q);
dfs(top);
dfs2(top, -1, 0, q - 1);
sort(pp.begin(), pp.end());
long long t = 0, cn = 0;
for (int i = (0); i < (q); i++) {
t += aa[i];
cn += bb[i];
ans[a[i].second] = 1.0 * t / cn;
}
for (int i = (0); i < (q); i++) {
printf("%.10lf\n", ans[i]);
}
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
int pr;
scanf("%d%d", &pr, &key[i]);
pr--;
if (pr >= 0) {
e[pr].push_back(i);
e[i].push_back(pr);
} else
top = i;
}
scanf("%d", &q);
for (int i = (0); i < (q); i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N;
ll A[303];
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N;
FOR(i,N) cin>>A[i];
ll xo=0;
for(i=2;i<N;i++) xo^=A[i];
vector<int> cand;
FOR(i,1<<20) if(i<A[0]) {
ll v=(A[0]-i)^(A[1]+i)^xo;
if((v&((1<<20)-1))==0) cand.push_back(i);
}
ll mi=1LL<<50;
FORR(c,cand) {
for(ll a=c;a<min(mi,A[0]);a+=1<<20) {
ll v=(A[0]-a)^(A[1]+a)^xo;
if(v==0) mi=min(mi,a);
}
}
if(mi==1LL<<50) mi=-1;
cout<<mi<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int b[2], cnt;
int t;
int main() {
cin >> t;
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int flag = 0;
int idx;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
idx = i;
flag = 1;
break;
}
}
if (flag) {
printf("1\n");
printf("%d\n", idx + 1);
} else {
if (n > 1) {
printf("2\n");
printf("1 2\n");
} else
printf("-1\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 1)
cout << "FastestFinger" << endl;
else if (n == 2)
cout << "Ashishgup" << endl;
else if (n % 2)
cout << "Ashishgup" << endl;
else {
set<int> st;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i % 2) st.insert(i);
if ((n / i) % 2) st.insert(n / i);
}
}
if (st.size() == 0)
cout << "FastestFinger" << endl;
else {
int f = 0;
for (auto i : st) {
if (i != n / 2) {
cout << "Ashishgup" << endl;
f = 1;
break;
}
}
if (f == 0) cout << "FastestFinger" << endl;
}
}
}
return 0;
}
| 3 |
#include <iostream>
#include <utility>
#include <string>
#include <vector>
int main(int, char**) {
int n, K;
std::string s;
std::cin >> n >> K >> s;
std::vector<int> is;
char pre{};
for(int i{}; i < n; ++i) {
if(pre != s[i]) is.push_back(i);
pre = s[i];
}
int ans{-1};
size_t r{is.size()};
for(int k{}; k < r; ++k) {
int x;
if(s[is[k]] == '0') {
x = ((k + 2 * K >= r) ? n : is[k + 2 * K]) - is[k];
} else {
x = ((k + 2 * K + 1 >= r) ? n : is[k + 2 * K + 1]) - is[k];
}
ans = std::max(x, ans);
}
std::cout << ans << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > q;
vector<vector<int> > v;
int n, dp[200001];
int main() {
scanf("%d", &n);
v.resize(n + 1);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (i == 1)
v[i].push_back(x), v[i].push_back(i + 1);
else if (i == n)
v[i].push_back(x), v[i].push_back(i - 1);
else
v[i].push_back(x), v[i].push_back(i + 1), v[i].push_back(i - 1);
}
memset(dp, -1, sizeof(dp));
q.push(make_pair(0, 1));
while (!q.empty()) {
int x = q.top().second, y = q.top().first;
q.pop();
dp[x] = -y;
for (int i = 0; i < v[x].size(); i++)
if (dp[v[x][i]] == -1) q.push(make_pair(y - 1, v[x][i]));
while (!q.empty() && dp[q.top().second] != -1) q.pop();
}
for (int i = 1; i <= n; i++) printf("%d ", dp[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using vld = vector<ld>;
using vi = vector<int>;
using vvi = vector<vi>;
vll conv(vi &v) {
vll r(v.size());
for (long long i = 0; i < (long long)(v.size()); i++) r[i] = v[i];
return r;
}
using P = pair<ll, ll>;
template <typename T, typename U>
ostream &operator<<(ostream &o, const pair<T, U> &v) {
o << "(" << v.first << ", " << v.second << ")";
return o;
}
template <size_t...>
struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is>
struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using s = int[];
(void)s{0, (void(os << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...};
}
template <class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr> &os, tuple<Args...> const &t)
-> basic_ostream<Ch, Tr> & {
os << "(";
print_tuple(os, t, gen_seq<sizeof...(Args)>());
return os << ")";
}
ostream &operator<<(ostream &o, const vvll &v) {
for (long long i = 0; i < (long long)(v.size()); i++) {
for (long long j = 0; j < (long long)(v[i].size()); j++)
o << v[i][j] << " ";
cout << endl;
}
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const vector<T> &v) {
o << '[';
for (long long i = 0; i < (long long)(v.size()); i++)
o << v[i] << (i != v.size() - 1 ? ", " : "");
o << "]";
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const set<T> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const unordered_map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++) o << *it;
o << "]";
return o;
}
void printbits(ll mask, ll n) {
for (long long i = 0; i < (long long)(n); i++) {
cout << !!(mask & (1ll << i));
}
cout << endl;
}
static const double EPS = 1e-14;
static const long long INF = 1e18;
static const long long mo = 1e9 + 7;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<P> a(n);
for (long long i = 0; i < (long long)(a.size()); i++) {
cin >> a[i].first;
a[i].second = i;
};
for (long long i = 0; i < (long long)(n); i++) {
vector<P> dis = a;
sort(dis.begin() + i, dis.end());
for (int j = dis[i].second; j > i; j--) {
swap(a[j], a[j - 1]);
cout << j - 1 + 1 << " " << j + 1 << endl;
}
for (long long j = 0; j < (long long)(n); j++) a[j].second = j;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool sort_pair(const pair<int, int> &a, const pair<int, int> &b) {
return a.first < b.first;
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> shots(n);
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
shots[i] = {a, i};
}
sort(shots.rbegin(), shots.rend(), sort_pair);
long result = 0l;
vector<int> indices(n);
for (int i = 0; i < n; ++i) {
result += shots[i].first * i + 1;
indices[i] = shots[i].second;
}
cout << result << endl;
for (int index : indices) {
cout << index + 1 << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[500005];
int sa[500005], height[500005], cnt[500005], x[500005], tmp1[500005],
Rank[500005], st[500005][21], lg[500005], maxn[2000005], dp[500005], n, m;
void MakeSuffixArray() {
m = 127;
for (int i = 1; i <= n; ++i) ++cnt[x[i] = a[i]];
for (int i = 2; i <= m; ++i) cnt[i] += cnt[i - 1];
for (int i = n; i; --i) sa[cnt[x[i]]--] = i;
for (int k = 1; k <= n; k <<= 1) {
int tmp = 0;
for (int i = n - k + 1; i <= n; ++i) tmp1[++tmp] = i;
for (int i = 1; i <= n; ++i)
if (sa[i] > k) tmp1[++tmp] = sa[i] - k;
for (int i = 1; i <= m; ++i) cnt[i] = 0;
for (int i = 1; i <= n; ++i) ++cnt[x[i]];
for (int i = 2; i <= m; ++i) cnt[i] += cnt[i - 1];
for (int i = n; i; --i) sa[cnt[x[tmp1[i]]]--] = tmp1[i], tmp1[i] = 0;
swap(x, tmp1);
tmp = 1;
x[sa[1]] = 1;
for (int i = 2; i <= n; ++i)
x[sa[i]] = (tmp1[sa[i]] == tmp1[sa[i - 1]] &&
tmp1[sa[i] + k] == tmp1[sa[i - 1] + k])
? tmp
: ++tmp;
if (tmp == n) break;
m = tmp;
}
}
void MakeHeightArray() {
int k = 0;
for (int i = 1; i <= n; ++i) Rank[sa[i]] = i;
for (int i = 1; i <= n; ++i) {
if (Rank[i] == 1) continue;
if (k) --k;
int j = sa[Rank[i] - 1];
while (j + k <= n && i + k <= n && a[i + k] == a[j + k]) ++k;
height[Rank[i]] = k;
}
}
int query_st(int l, int r) {
if (l > r) return n;
int lgs = lg[r - l + 1];
return min(st[l][lgs], st[r - (1 << lgs) + 1][lgs]);
}
int query_l(int p, int q) {
int l = 1, r = p, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (query_st(mid + 1, p) >= q)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return ans;
}
int query_r(int p, int q) {
int l = p, r = n, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (query_st(p + 1, mid) >= q)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
return ans;
}
void modify(int l, int r, int x, int now, int val) {
if (l == r) {
maxn[now] = val;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(l, mid, x, (now << 1), val);
else
modify(mid + 1, r, x, ((now << 1) | 1), val);
maxn[now] = max(maxn[(now << 1)], maxn[((now << 1) | 1)]);
}
int query(int l, int r, int x, int y, int now) {
if (l >= x && r <= y) return maxn[now];
int mid = (l + r) >> 1;
int ans = -10086001;
if (x <= mid) ans = max(ans, query(l, mid, x, y, (now << 1)));
if (mid + 1 <= y) ans = max(ans, query(mid + 1, r, x, y, ((now << 1) | 1)));
return ans;
}
bool check(int x, int y) {
int l = query_l(x, y), r = query_r(x, y);
return query(1, n, l, r, 1) < y;
}
int main() {
scanf("%d", &n);
if (n == 1) return puts("1") & 0;
scanf("%s", a + 1);
MakeSuffixArray();
MakeHeightArray();
for (int i = 1; i <= n; ++i) st[i][0] = height[i];
for (int j = 1; j <= 20; ++j)
for (int i = 1; i + (1 << j) - 1 <= n; ++i)
st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
lg[1] = 0;
for (int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
dp[n] = 1;
int pointer = n, ans = 0;
for (int i = n - 1; i; --i) {
while (check(Rank[i], pointer - i) && check(Rank[i + 1], pointer - i) &&
i < pointer)
--pointer, modify(1, n, Rank[pointer + 1], 1, dp[pointer + 1]);
ans = max(ans, dp[i] = pointer - i + 1);
}
printf("%d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
using pii = pair<int, int>;
char s[500100];
vector<int> vec[500100], id[500100];
int mx[500100][2], mn[500100][2];
int MX[500100], MN[500100];
int main() {
int n;
cin >> n;
int N = 0, nn = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
int x = 0, y = 0;
int m = strlen(s);
for (int j = 0; j < m; j++) {
if (s[j] == 'B')
x++;
else
y++;
}
vec[x + 1].push_back(y);
N = max(N, x + 1);
}
memset(mn, 0x3f, sizeof mn);
memset(MN, 0x3f, sizeof MN);
for (int i = 0; i < 500100; i++) MX[i] = -0x3f3f3f3f;
for (int i = 1; i <= N; i++) {
mx[i][0] = mx[i - 1][0];
MX[i] = MX[i - 1];
mn[i][0] = mn[i - 1][0];
for (auto p : vec[i]) {
mx[i][0] = max(mx[i][0], p);
mn[i][0] = min(mn[i][0], p);
MX[i] = max(MX[i], p - i);
}
}
int l = 0x3f3f3f3f, r = 0;
for (int i = N; i >= 1; i--) {
mx[i][1] = mx[i + 1][1];
mn[i][1] = mn[i + 1][1];
MN[i] = MN[i + 1];
for (auto p : vec[i]) {
l = min(l, i);
r = max(r, i);
mx[i][1] = max(mx[i][1], p);
mn[i][1] = min(mn[i][1], p);
MN[i] = min(MN[i], p - i);
}
}
int ans = 0x3f3f3f3f, A = 0, B = 0;
for (int i = 1; i <= N; i++) {
int L = 0, R = 0x3f3f3f3f;
int st = max(i - l, r - i) - 1, ed = 0x3f3f3f3f, ok = 0;
while (st + 1 < ed) {
int md = (st + ed) >> 1;
L = 0, R = 0x3f3f3f3f;
L = max(L, MX[i - 1] + i - md);
L = max(L, mx[i][1] - md);
R = min(R, mn[i - 1][0] + md);
R = min(R, MN[i] + i + md);
if (L <= R) {
ok = R;
ed = md;
} else
st = md;
}
if (ans >= ed) {
ans = ed;
A = i - 1, B = ok;
}
}
cout << ans << endl;
for (int i = 1; i <= A; i++) printf("B");
for (int i = 1; i <= B; i++) printf("N");
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int INF = 2147483647;
const int MOD = 1000000007;
const long long INF64 = 9223372036854775807;
using namespace std;
int main() {
cout << "2000\n";
for (int i = 1; i <= 1000; i++) cout << i << " 1 " << i << " 2\n";
for (int i = 1000; i >= 1; i--) cout << i << " 1 " << i << " 2\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e6 + 1;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const long long int LINF = 1e18;
const long long int N = 100001;
void snake_bite() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
}
bool containsDigit(long long int number, int digit) {
while (number != 0) {
long long int curr_digit = number % 10;
if (curr_digit == digit) return true;
number /= 10;
}
return false;
}
int sum_digit(int x) {
int sum = 0;
while (x) {
sum += x % 10;
x /= 10;
}
return sum;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cout << "1";
cout << " ";
for (int i = 0; i < n - 1; i++) cout << "8";
cout << "9";
}
int main() {
snake_bite();
long int t = 1;
while (t--) {
solve();
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N=1005;
const int M=20005;
ll dp[2][M];
int c,p=1;
int v[N],w[N],s[N],id[N];
bool comp(int i, int j){ return w[i]+s[i]<w[j]+s[j];}
int main()
{
int n,i,j,k;
scanf("%i",&n);
for(i=1;i<=n;i++) scanf("%i %i %i",&w[i],&s[i],&v[i]),id[i]=i;
sort(id+1,id+1+n,comp);
for(j=1;j<=n;j++)
{
i=id[j];
for(k=M-1;~k;k--)
{
dp[c][k]=dp[p][k];
if(k<=s[i]) dp[c][k+w[i]]=max(dp[c][k+w[i]],dp[p][k]+v[i]);
}
c^=1;p^=1;
}
ll ans=0;
for(i=0;i<M;i++) ans=max(ans,dp[p][i]);
printf("%lld\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, ans = 0;
cin >> N;
for (int i = 0; i < N; i++) {
int cnt = 0;
for (int j = 0; j < 3; j++) {
cin >> M;
if (M == 1) cnt++;
}
if (cnt >= 2) ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[8][3];
void input() {
for (int i = 0; i < 8; i++)
for (int j = 0; j < 3; j++) cin >> a[i][j];
}
long long d(int a1[], int a2[]) {
long long n1 = 1;
return n1 * (a1[0] - a2[0]) * (a1[0] - a2[0]) +
n1 * (a1[1] - a2[1]) * (a1[1] - a2[1]) +
n1 * (a1[2] - a2[2]) * (a1[2] - a2[2]);
}
int Find = 0;
void dfs(int k) {
if (Find == 1) return;
if (k == 7) {
set<long long> s;
for (int i = 0; i < 8; i++)
for (int j = i + 1; j < 8; j++) s.insert(d(a[i], a[j]));
if (s.size() == 3) {
Find = 1;
cout << "YES" << endl;
for (int i = 0; i < 8; i++)
cout << a[i][0] << " " << a[i][1] << " " << a[i][2] << endl;
}
return;
}
sort(a[k], a[k] + 3);
do {
dfs(k + 1);
} while (next_permutation(a[k], a[k] + 3));
}
int main() {
input();
Find = 0;
dfs(0);
if (Find == 0) cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
vector<set<int>> E(N);
for(int ii=0; ii<M; ii++){
int a, b;
cin >> a >> b;
a--;
b--;
E[a].insert(b);
E[b].insert(a);
}
vector<int> ans(N, -1);
queue<int> Q;
Q.push(0);
ans[0] = 0;
while(Q.size()){
int pos = Q.front();
Q.pop();
for(auto& next : E[pos]){
if(ans[next]!=-1) continue;
Q.push(next);
ans[next] = pos;
}
}
cout << "Yes" << endl;
for(int ii=1; ii<N; ii++){
cout << ans[ii]+1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n;
vector<pair<long long, long long> > v;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(b, a));
}
sort(v.begin(), v.end());
vector<pair<long long, long long> >::iterator it;
long long count = 1, points = 0;
for (long long i = v.size() - 1; i >= 0; i--) {
if (count > 0) {
count += v[i].first;
points += v[i].second;
count--;
}
if (count <= 0) {
break;
}
}
cout << points;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int tim[100010], ans[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> tim[i];
for (int i = 1; i <= n; i++) {
ans[i] = ans[i - 1] + 20;
int pos = upper_bound(tim + 1, tim + 1 + i, tim[i] - 90) - tim - 1;
ans[i] = min(ans[i], ans[pos] + 50);
pos = upper_bound(tim + 1, tim + 1 + i, tim[i] - 1440) - tim - 1;
ans[i] = min(ans[i], ans[pos] + 120);
cout << ans[i] - ans[i - 1] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 10001;
const int mmax = 10001;
const int kmax = 101;
const long long oo = 1000000000000;
struct kcanh {
int u, v, l, r, vtu, vtv;
};
ifstream fi("HACK.INP");
ofstream fo("HACK.OUT");
vector<pair<long long, int> > adj[nmax];
kcanh canh[kmax];
int s[2];
long long d[2][nmax];
int kq[kmax];
int n, m, t, k;
void doc() {
cin >> n >> m >> k;
cin >> s[0] >> s[1] >> t;
for (int i = 1, u, v, w; i <= m; i++) {
cin >> u >> v >> w;
adj[u].push_back(pair<long long, int>(w, v));
}
for (int i = 1; i <= k; i++) {
long long l, r;
int u, v;
cin >> u >> v >> l >> r;
adj[u].push_back(pair<long long, int>(r, v));
canh[i].u = u;
canh[i].v = v;
canh[i].l = l;
canh[i].r = r;
canh[i].vtu = adj[u].size() - 1;
kq[i] = r;
}
}
void dij(int ng) {
int xp = s[ng];
d[ng][xp] = 0;
set<pair<long long, int> > Q;
Q.insert(pair<long long, int>(0, xp));
while (!Q.empty()) {
pair<long long, int> tt = *Q.begin();
Q.erase(Q.begin());
int u = tt.second;
vector<pair<long long, int> >::iterator it;
for (it = adj[u].begin(); it != adj[u].end(); it++) {
int v = it->second;
long long w = it->first;
if (d[ng][v] > d[ng][u] + w) {
if (d[ng][v] != oo) {
Q.erase(Q.find(pair<long long, int>(d[ng][v], v)));
}
d[ng][v] = d[ng][u] + w;
Q.insert(pair<long long, int>(d[ng][v], v));
}
}
}
}
void xuly() {
for (int i = 1; i <= n; i++) {
d[0][i] = oo;
d[1][i] = oo;
}
dij(0);
dij(1);
bool ok;
while (true) {
if (d[0][t] < d[1][t]) break;
ok = true;
for (int i = 1; i <= k; i++) {
int u = canh[i].u;
int v = canh[i].v;
int l = canh[i].l;
int r = canh[i].r;
int vtu = canh[i].vtu;
if (d[0][u] < d[1][u] && adj[u][vtu].first != l) {
adj[u][vtu].first = l;
kq[i] = l;
ok = false;
}
}
if (ok) break;
for (int i = 1; i <= n; i++) {
d[0][i] = oo;
d[1][i] = oo;
}
dij(0);
dij(1);
}
}
void ghi() {
if (d[0][t] < d[1][t])
cout << "WIN";
else if (d[0][t] == d[1][t])
cout << "DRAW";
else
cout << "LOSE";
if (d[0][t] <= d[1][t]) {
cout << endl;
for (int i = 1; i <= k; i++) cout << kq[i] << " ";
}
}
int main() {
std::ios::sync_with_stdio(false);
doc();
xuly();
ghi();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int inp;
vector<vector<int>> gr(n + m - 1, {0, 0});
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> inp;
if (inp) {
gr[i + j][1]++;
} else {
gr[i + j][0]++;
}
}
}
int ans = 0, i = 0, j = n + m - 2;
while (i <= j) {
if (i != j) {
ans += min({gr[i][0] + gr[j][0], gr[i][1] + gr[j][1]});
}
i++;
j--;
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535;
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long int gas[300001];
long long int dp[300001][2];
long long int path[300001];
vector<pair<long long int, long long int>> adj[300001];
void Traveller(long long int ind, long long int par) {
if (adj[ind].size() == 1 && ind != 1) {
dp[ind][0] = gas[ind];
dp[ind][1] = gas[ind];
}
vector<long long int> a;
dp[ind][0] = gas[ind];
for (auto c : adj[ind]) {
if (c.first != par) {
Traveller(c.first, ind);
long long int qq = dp[c.first][0] - c.second + gas[ind];
dp[ind][0] = max(dp[ind][0], qq);
a.push_back(dp[c.first][0] - c.second);
}
}
sort(a.begin(), a.end(), greater<long long int>());
dp[ind][1] = gas[ind];
if (a.size() > 0) {
dp[ind][1] += a[0];
}
if (a.size() > 1) {
dp[ind][1] += a[1];
}
}
int main() {
FAST();
long long int n;
cin >> n;
for (long long int i = 1; i < n + 1; i++) {
cin >> gas[i];
}
path[1] = 0;
for (long long int i = 1; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back(make_pair(b, c));
adj[b].push_back(make_pair(a, c));
}
Traveller(1, -1);
long long int ans = -1e18;
for (int i = 1; i < n + 1; i++) {
ans = max(ans, dp[i][1]);
ans = max(ans, dp[i][0]);
}
cout << ans << '\n';
return 0;
}
| 1 |
#include <stdio.h>
const int INF=(1<<30);
int main(){
int n,s,a[100010],back=0,ans=INF;
long long int now=0;
scanf("%d%d",&n,&s);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
now+=a[i];
while(now>=s){
if(i-back+1<ans)ans=i-back+1;
now-=a[back];
back++;
if(back>i)break;
}
}
if(ans==INF)printf("0\n");
else printf("%d\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, t, i, s, p;
cin >> t;
for (i = 0; i < t; i++) {
cin >> a >> b;
s = a - b;
s = abs(s);
if (s % 5 == 0) {
cout << s / 5 << endl;
} else if (s % 5 != 0) {
p = s / 5;
s = s % 5;
if (s % 2 == 0) {
cout << p + s / 2 << endl;
} else {
cout << p + s / 2 + s % 2 << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
long long n;
cin >> n;
if (n < 1 || n > 100000) {
cout << 0;
return 0;
}
vector<long long> piles(n);
vector<long long> cost(n);
for (long long i = 0; i < n; i++) {
cin >> piles[i];
}
sort(piles.begin(), piles.end());
long long total = 0;
cost[0] = 0;
for (long long i = 0; i < n - 1; i++) {
cost[i + 1] = piles[i] + cost[i];
total += cost[i + 1];
}
long long q;
cin >> q;
if (q < 1 || q > 100000) {
cout << 0;
return 0;
}
map<long long, long long> caches_solutions;
for (long long i = 0; i < q; i++) {
long long query;
cin >> query;
if (caches_solutions.find(query) != caches_solutions.end()) {
cout << caches_solutions.at(query) << " ";
continue;
}
long long ans = 0;
long long step = 1;
for (long long j = n - 1; j > 0; j -= step) {
ans += cost[j];
step = step * query;
}
caches_solutions[query] = ans;
cout << ans << " ";
}
cout << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned ll
#define uint unsigned
#define pii pair<int,int>
#define pll pair<ll,ll>
#define PB push_back
#define fi first
#define se second
#define For(i,j,k) for (int i=(int)(j);i<=(int)(k);i++)
#define Rep(i,j,k) for (int i=(int)(j);i>=(int)(k);i--)
#define CLR(a,v) memset(a,v,sizeof(a));
#define CPY(a,b) memcpy(a,b,sizeof(a));
using namespace std;
const int N=100005;
struct edge{
int to,next;
}e[N*2];
int head[N],tot,n;
int deg[N],q[N],DS[N],DT[N];
int vis[N],ans1[N],ans2[N];
void add(int x,int y){
e[++tot]=(edge){y,head[x]};
head[x]=tot;
}
int bfs(int S,int *dis){
For(i,1,n) dis[i]=-1;
int h=0,t=1;
q[1]=S; dis[S]=0;
while (h!=t){
int x=q[++h];
for (int i=head[x];i;i=e[i].next)
if (dis[e[i].to]==-1){
dis[e[i].to]=dis[x]+1;
q[++t]=e[i].to;
}
}
return q[t];
}
void work(int *q,int l,int *ans){
*ans=0;
int S=0;
For(i,0,l){
int v=deg[q[i]];
v-=(i!=0)+(i!=l);
For(j,1,v) ans[++*ans]=S+j+1;
ans[++*ans]=S+1;
S+=v+1;
}
}
int main(){
scanf("%d",&n);
For(i,1,n-1){
int x,y;
scanf("%d%d",&x,&y);
add(x,y); add(y,x);
++deg[x]; ++deg[y];
}
int S=bfs(1,DS);
int T=bfs(S,DS);
bfs(T,DT);
For(i,1,n)
if (DS[i]+DT[i]==DS[T]){
q[DS[i]]=i;
for (int j=head[i];j;j=e[j].next)
vis[e[j].to]=1;
}
For(i,1,n)
if (!vis[i])
return puts("-1"),0;
work(q,DS[T],ans1);
reverse(q,q+DS[T]+1);
work(q,DS[T],ans2);
int fl=0;
For(i,1,n){
if (!fl&&ans1[i]!=ans2[i])
fl=(ans1[i]<ans2[i]?1:-1);
printf("%d ",fl==1?ans1[i]:ans2[i]);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 100 * 100 * 100;
int n, k, nest[MN], ans, ff;
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) {
int mi;
cin >> mi;
int x = -1, f, flag = 0, t = 1;
cin >> f;
ans += mi - 1;
if (f == 1) {
flag = 1;
}
for (int j = 1; j < mi; j++) {
int y;
cin >> y;
if (flag && y == t + 1) {
flag++;
}
t++;
}
ff = max(ff, flag - 1);
}
ans += n - 1;
ans -= 2 * ff;
cout << ans;
return 0;
}
| 1 |
/*
please pass my code
use a kruskal's idea
every edge should be between adjacent connected components
(no idea why this is the case, it just seems to work)
*/
#include <stdio.h>
#include <set>
#include <utility>
long long minn(long long a,long long b){return a<=b?a:b;}
int n;
long long d;
int a[200005];
// segment is [i,ptr2[i])
int ptr1[200005];
int ptr2[200005];
long long c1[200005];
long long c2[200005];
std::set<std::pair<int,int>> kruskal;
bool done[200005];
long long ans=0;
int main()
{
#ifdef NOT_DMOJ
freopen("data.txt","r",stdin);
#endif // NOT_DMOJ
scanf("%d%lld",&n,&d);
for (int i=1; i<=n; i++) {
scanf("%d",a+i);
ptr1[i]=i-1;
ptr2[i]=i+1;
c1[i]=c2[i]=a[i];
}
for (int i=2; i<=n; i++) {
//kruskal.insert({c2[i-1]+c1[i],i});
kruskal.insert({c2[i-1],i});
kruskal.insert({c1[i],i});
}
done[1]=1;
done[n+1]=1;
while (!kruskal.empty()) {
// pop lowest edge from set
int i2=kruskal.begin()->second;
kruskal.erase(kruskal.begin());
if (done[i2]) continue;
done[i2]=1;
int i3=ptr2[i2];
int i1=ptr1[i2];
int i0=ptr1[i1];
ans+=c2[i1]+d+c1[i2];
//printf("%d ans+=%d\n",i2,c2[i1]+d+c1[i2]);
// ptr stuff
ptr2[i0]=i1;
ptr2[i1]=i3;
ptr1[i3]=i1;
ptr1[i1]=i0;
// merge i1 with i2
if (c1[i1]>c1[i2]+(i2-i1)*d) {
c1[i1]=c1[i2]+(i2-i1)*d;
kruskal.insert({c2[i0],i1});
kruskal.insert({c1[i1],i1});
}
c2[i1]=minn(c2[i2],c2[i1]+(i3-i2)*d);
kruskal.insert({c2[i1],i3});
kruskal.insert({c1[i3],i3});
//printf("new ends %lld %lld\n",c1[i1],c2[i1]);
}
printf("%lld\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct sort_pred {
bool operator()(const pair<int, int>& left, const pair<int, int>& right) {
return left.second < right.second;
}
};
struct convert {
void operator()(char& c) { c = toupper((unsigned char)c); }
};
struct convertd {
void operator()(char& c) { c = tolower((unsigned char)c); }
};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
vector<int> mark(1);
vector<set<int> > A;
const int MAX_N = 1;
int p[MAX_N];
int root_rank[MAX_N];
void make_set(int x) { p[x] = x; }
int find_root(int x) {
if (p[x] == x) return x;
return p[x] = find_root(p[x]);
}
void unite(int x, int y) {
x = find_root(x);
y = find_root(y);
if (root_rank[x] < root_rank[y])
p[x] = y;
else {
p[y] = x;
if (root_rank[x] == root_rank[y]) {
++root_rank[y];
}
}
}
const int N = 1;
int lp[N + 1];
void DFS(vector<vector<int> > edges, int start) {
stack<int> s;
set<int> _set;
s.push(start);
while (!s.empty()) {
int v = s.top();
s.pop();
vector<int>::iterator it;
for (it = edges[v].begin(); it != edges[v].end(); ++it) {
if (mark[*it] == 0) {
cout << mark[*it] << "!!"
<< "\n";
s.push(*it);
_set.insert(*it);
mark[*it] = 1;
}
}
}
if (_set.size()) A.push_back(_set);
}
vector<int> sieve(const int N) {
vector<int> pr;
for (int i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < (int)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
return pr;
}
map<string, int> m;
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
m[s]++;
}
int max = 0;
string a = "";
for (map<string, int>::iterator it = m.begin(); it != m.end(); ++it) {
if ((it->second) > max) {
max = it->second;
a = it->first;
}
}
cout << a << "\n";
return 0;
}
| 1 |
//11
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
for(int n,k;cin>>n>>k,n|k;){
int f[101][101];
fill_n(f[0],101*101,-1);
while(k--){
int l;
cin>>l;
if(l){
int c,d,e;
cin>>c>>d>>e;
f[c][d]=f[d][c]=(f[d][c]==-1)?e:min(e,f[d][c]);
}else{
int a,b;
cin>>a>>b;
int d[101];
fill_n(d,101,1<<29);
d[a]=0;
bool u[101]={};
while(!u[b]){
int mu=1<<29;
int v;
for(int i=1;i<=n;i++){
if(!u[i]&&d[i]<mu){
mu=d[i];
v=i;
}
}
if(mu==1<<29)break;
u[v]=true;
for(int i=1;i<=n;i++){
if(f[v][i]!=-1){
d[i]=min(d[i],d[v]+f[v][i]);
}
}
}
if(u[b]){
cout<<d[b]<<endl;
}else{
cout<<-1<<endl;
}
}
}
}
return 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.