solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int mid, n;
int cnt[MAXN];
int a[MAXN][2];
bool flag = true;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i][0];
if (a[i][0] > mid) mid = a[i][0];
cnt[a[i][0]]++;
a[i][1] = cnt[a[i][0]];
}
for (int i = 1; i <= mid - 1; i++)
if (cnt[i] < cnt[i + 1]) {
flag = false;
break;
}
if (flag) {
cout << cnt[1] << endl;
for (int i = 0; i < n; i++) cout << a[i][1] << " ";
} else
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int check = 0;
for (int i = 0; i < n; i++)
if (i && arr[i] % 2 != arr[i - 1] % 2) {
check = 1;
break;
}
if (check) sort(arr, arr + n);
for (int i : arr) cout << i << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int INF = 1e9 + 7;
vector<int> adjList[MAXN];
long long a[MAXN], dp[MAXN][2];
void dfs(int start, int par) {
long long maxdp = 0, maxrdp = 0;
for (auto u : adjList[start]) {
if (u != par) {
dfs(u, start);
maxdp = max(maxdp, dp[u][0]);
maxrdp = max(maxrdp, dp[u][1]);
}
}
long long val = a[start] + maxdp - maxrdp;
dp[start][0] = maxdp, dp[start][1] = maxrdp;
if (val < 0)
dp[start][0] += abs(val);
else
dp[start][1] += val;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int c, d;
cin >> c >> d;
adjList[c].push_back(d);
adjList[d].push_back(c);
}
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
dfs(1, -1);
cout << dp[1][0] + dp[1][1];
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
#define real long double
#define fr(i,l,n) for(ll i=l;i<n;i++)
#define br cout<<"\n"
#define al(fu) (fu).begin(), (fu).end()
#define prl(c) cout<<(c)<<"\n"
#define prv(v) {fr(qz,0,v.size()) cout<<(v)[qz]<<' '; br;}
#define alr(fu) (fu).rbegin(), (fu).rend()
#define mod 1000000007LL
#define mod1 998244353LL
#define nfi 1000000000000000013LL
#define skoree ios::sync_with_stdio(0); cin.tie(0)
#define danet(b) cout<<(b?"YES":"NO")
#define Danet(b) cout<<(b?"Yes":"No")
using namespace std;
char aq(char a){
if(a=='0') return '1';
else return '0';
}
int main(){
skoree;
ll o0o;
cin>>o0o;
while(o0o--){
ll n;
cin>>n;
vector<string> a(n),b(n);
fr(i,0,n) cin>>a[i];
fr(i,0,n) cin>>b[i];
fr(i,0,n) if(a[0][i]!=b[0][i]){
fr(j,0,n) a[j][i]=aq(a[j][i]);
}
bool bb=1;
fr(i,1,n) if(a[i]!=b[i]){
fr(j,0,n) a[i][j]=aq(a[i][j]);
if(a[i]!=b[i]) bb=0;
}
danet(bb);br;
}
return 0;
}
/*
*/
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const double PI = 3.141592653589793;
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
string s;
int maxlen;
struct dt {
int kiri, kanan;
bool dariKiri;
} posAns;
int memo[5005][5005];
int dp(int kiri, int kanan) {
if (kiri >= kanan) return 1;
int &ret = memo[kiri][kanan];
if (ret != -1) return ret;
return ret = (s[kiri] == s[kanan] ? dp(kiri + 1, kanan - 1) : 0);
}
int main() {
fasterios();
long long t;
cin >> t;
while (t--) {
cin >> s;
maxlen = 0;
int n = s.length();
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
memo[i][j] = -1;
}
}
if (dp(0, n - 1)) {
cout << s << '\n';
continue;
}
posAns = {-1, n, 0};
int curLen = 0;
for (int kiri = -1, kanan = n; kiri <= kanan; kiri++, kanan--) {
for (int i = kanan - 1; i >= kiri + 1; i--) {
if (dp(kiri + 1, i)) {
int curcount = curLen + (i - kiri);
if (curcount > maxlen) {
maxlen = curcount;
posAns = {kiri, kanan, 0};
}
break;
}
}
for (int i = kiri + 1; i <= kanan - 1; i++) {
if (dp(i, kanan - 1)) {
int curcount = curLen + (kanan - i);
if (curcount > maxlen) {
maxlen = curcount;
posAns = {kiri, kanan, 1};
}
break;
}
}
if (s[kiri + 1] != s[kanan - 1]) break;
curLen += 2;
}
string ans = "";
for (int i = 0; i <= posAns.kiri; i++) {
ans += s[i];
}
if (!posAns.dariKiri) {
for (int i = posAns.kanan - 1; i >= posAns.kiri + 1; i--) {
if (dp(posAns.kiri + 1, i)) {
for (int j = posAns.kiri + 1; j <= i; j++) {
ans += s[j];
}
break;
}
}
} else {
for (int i = posAns.kiri + 1; i <= posAns.kanan - 1; i++) {
if (dp(i, posAns.kanan - 1)) {
for (int j = i; j <= posAns.kanan - 1; j++) {
ans += s[j];
}
break;
}
}
}
for (int i = posAns.kanan; i < n; i++) ans += s[i];
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
double p[100005];
struct fuck {
double l, r;
} t[100005 * 4], ans;
int read() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
fuck merge(fuck x, fuck y) {
return x.l == -1
? y
: (fuck){x.l * y.l / (1 - x.r * (1 - y.l)),
y.r + (1 - y.r) * x.r * y.l / (1 - (1 - y.l) * x.r)};
}
void build(int z, int l, int r) {
if (l == r) {
t[z].l = t[z].r = p[l];
return;
}
int mid = (l + r) >> 1;
build(z << 1, l, mid);
build(z << 1 | 1, mid + 1, r);
t[z] = merge(t[z << 1], t[z << 1 | 1]);
}
void change(int z, int l, int r, int x, double y) {
if (l == r) {
t[z].l = t[z].r = y;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
change(z << 1, l, mid, x, y);
else
change(z << 1 | 1, mid + 1, r, x, y);
t[z] = merge(t[z << 1], t[z << 1 | 1]);
}
void search(int z, int l, int r, int x, int y) {
if (l >= x && r <= y) {
ans = merge(ans, t[z]);
return;
}
if (l > y || r < x) return;
int mid = (l + r) >> 1;
search(z << 1, l, mid, x, y);
search(z << 1 | 1, mid + 1, r, x, y);
}
int main() {
n = read();
q = read();
for (int i = 1, a, b; i <= n; i++) {
a = read();
b = read();
p[i] = 1.0 * a / b;
}
build(1, 1, n);
for (int i = 1; i <= q; i++) {
int op = read();
if (op == 1) {
int x = read(), a = read(), b = read();
change(1, 1, n, x, 1.0 * a / b);
} else {
int x = read(), y = read();
ans.l = ans.r = -1;
search(1, 1, n, x, y);
printf("%.6lf\n", ans.l);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000 + 1;
int n;
pair<int, int> a[N];
vector<pair<int, pair<int, int>>> dif;
int dist(pair<int, int> a, pair<int, int> b) {
return (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
}
bitset<N> b[N];
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cout << fixed << setprecision(10);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i].first >> a[i].second;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
dif.push_back(pair<int, pair<int, int>>(dist(a[i], a[j]), {i, j}));
sort(dif.begin(), dif.end(), greater<pair<int, pair<int, int>>>());
for (auto el : dif) {
b[el.second.first][el.second.second] = true;
b[el.second.second][el.second.first] = true;
if ((b[el.second.first] & b[el.second.second]).any()) {
cout << sqrt(el.first) / 2 << '\n';
return 0;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long x, n, i, j, k, l, a[500007], sum, cnt;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i], a[i] += a[i - 1];
for (i = 1; i < n; i++) {
if (a[i] * 3 == a[n] * 2) cnt = cnt + x;
if (a[i] * 3 == a[n]) x++;
}
cout << cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string str;
cin >> n >> str;
vector<char> v(n);
v[str.size() - 1] = str[str.size() - 1];
if (str.size() > 1) {
v[(str.size() - 1) / 2] = str[0];
if (str.size() > 2) {
v[0] = str[str.size() - 2];
int mid = (str.size() - 1) / 2;
int first = mid;
int last = mid;
for (size_t i = 1; i < n - 2; i++) {
if (i % 2) {
first = (str.size() % 2) ? --first : ++first;
v[first] = str[i];
} else {
last = (str.size() % 2) ? ++last : --last;
v[last] = str[i];
}
}
}
}
for (size_t i = 0; i < v.size(); i++) {
cout << v[i];
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n, ans = 0;
cin >> n;
if (n % 2 == 0)
ans = n / 2;
else
ans = -1 - n / 2;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[100001], n, temp, arr1[100002], arr2[100010];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
memset(arr1, 0, sizeof(arr1));
int j = 0, n1 = n;
for (int i = 0; i < n; i++) {
if (arr[i] != n1) {
arr1[arr[i]] = 1;
cout << endl;
} else {
cout << arr[i] << " ";
n1 = n1 - 1;
for (j = n1; j >= 1; j--) {
if (arr1[j] == 1) {
n1 = n1 - 1;
cout << j << " ";
} else {
cout << endl;
break;
}
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
cin >> x;
return x;
}
int ask(int x, int y) {
cout << "? " << x + 1 << " " << y + 1 << endl;
return nxt() - 1;
}
const int N = 1111;
set<int> a[N];
void delete_edge(int u, int v) {
a[u].erase(v);
a[v].erase(u);
}
int findLeaf(int v, int p = -1) {
if ((int)a[v].size() == 1) {
return v;
}
for (int x : a[v]) {
if (x != p) {
int res = findLeaf(x, v);
if (res != -1) {
return res;
}
}
}
return -1;
}
pair<int, int> findFurthest(int v, int p = -1, int d = 0) {
pair<int, int> res = {d, v};
for (int x : a[v]) {
if (x == p) {
continue;
}
res = max(res, findFurthest(x, v, d + 1));
}
return res;
}
int getSz(int v, int p = -1) {
int res = 1;
for (int x : a[v]) {
if (x != p) {
res += getSz(x, v);
}
}
return res;
}
bool used[N];
bool markPath(int v, int finish) {
used[v] = true;
if (v == finish) {
return true;
}
for (int x : a[v]) {
if (used[x]) {
continue;
}
if (markPath(x, finish)) {
return true;
}
}
used[v] = false;
return false;
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n = nxt();
for (int i = 0; i < n - 1; ++i) {
int u = nxt() - 1, v = nxt() - 1;
a[u].insert(v);
a[v].insert(u);
}
int l = 0;
while (n > 1) {
if (n == 2) {
assert((int)a[l].size() == 1);
int u = l, v = *a[l].begin();
l = ask(u, v);
delete_edge(u, v);
break;
}
int u = findFurthest(l).second;
int v = findFurthest(u).second;
l = ask(u, v);
memset(used, 0, sizeof(used));
markPath(u, v);
vector<int> to_del;
for (int x : a[l]) {
if (used[x]) {
to_del.push_back(x);
}
}
for (int x : to_del) {
delete_edge(l, x);
}
n = getSz(l);
}
cout << "! " << l + 1 << endl;
return 0;
}
| 5 |
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <cmath>
#include <bitset>
#include <iomanip>
#include <queue>
#include <stack>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <chrono>
#include <random>
#include <cstring>
using namespace std;
//#pragma comment(linker, "/stack:36777216")
//#pragma GCC optimize("O3")
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline void boostIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
}
bool isPrime(int x) {
if (x <= 4 || x % 2 == 0 || x % 3 == 0) return x == 2 || x == 3;
for (int i = 5; i * i <= x; i += 6) if (x % i == 0 || x % (i + 2) == 0) return 0; return 1;
}
typedef long long int ll;
typedef long double ld;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
#define fori(n) for(int i = 0; i < (n); ++i)
#define forj(n) for(int j = 0; j < (n); ++j)
#define fork(n) for(int k = 0; k < (n); ++k)
#define forx(n) for(int x = 0; x < (n); ++x)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define ff first
#define ss second
#define debug(x) cerr << #x << " = " << x << endl;
#define debug_p(x) cerr << #x << " " << x.ff << " " << x.ss << endl;
#define debug_v(x) cerr << #x << " "; for (auto ii : x) cout << i << " "; cout << endl;
#define debug_vp(x) cerr << #x << " "; for (auto ii : x) cout << '[' << ii.ff << " " << ii.ss << ']'; cout << endl;
#define mp make_pair
#define rand kjsdflsdfsdlsjdlkfsdjflsjdfl
#define compress(x) sort(all(x)); x.erase(unique(all(x)), x.end());
#define Return cerr<<endl<<"RUNTIME: "<<1.0*clock()/CLOCKS_PER_SEC << " s" <<endl; return 0;
#define PI 3.14159265
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
template<typename T> inline T getint() {
T val = 0;
char c;
bool neg = false;
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
neg |= c == '-';
}
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val * (neg ? -1 : 1);
}
/////////////////////
#define int long long
int Mod = 1e9 + 7;
#define endl '\n'
/////////////////////
//int inf = 1e18 + 7;
int32_t main() {
boostIO();
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int q; cin >> q;
vector<int> Banned(5e5 + 10);
set<pair<int, int>> SetW;
set<pair<int, int>> SetI;
int I = 1;
vector<int> ans;
while (q--) {
int t; cin >> t;
if (t == 1) {
int m; cin >> m;
SetW.insert(mp(-m, I));
SetI.insert(mp(I, -m));
++I;
}
else if (t == 2) {
pair<int, int> p;
while (1) {
p = *SetI.begin();
SetI.erase(SetI.begin());
if (Banned[p.ff] == 0) {
Banned[p.ff] = 1;
break;
}
}
p.ss = -p.ss;
ans.push_back(p.ff);
}
else if(t == 3) {
pair<int, int> p;
while (1) {
p = *SetW.begin();
SetW.erase(SetW.begin());
if (Banned[p.ss] == 0) {
Banned[p.ss] = 1;
break;
}
}
p.ff = -p.ff;
ans.push_back(p.ss);
}
}
for (auto x : ans) {
cout << x << " ";
}
cout << endl;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1009;
const int MOD = 998244353;
int dp[N];
int arr[N];
int n, sum = 0;
int C[N][N];
void binomialCoeff(int n) {
int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= i; j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
}
long long solve() {
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
long long sum = 0;
if (arr[i] <= 0)
dp[i] = 0;
else {
for (int j = arr[i] + i + 1; j <= n; j++) {
sum += (long long)(C[j - i - 1][arr[i]]) * (dp[j]) % MOD;
sum = sum % MOD;
}
dp[i] = sum;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += dp[i];
ans = ans % MOD;
}
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
binomialCoeff(n);
long long ans = solve();
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, a, b, n;
cin >> n;
vector<long long> ar(n + 1);
for (long long i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar.begin(), ar.begin() + n);
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (ar[i] > 0) {
long long flag = 0;
for (long long j = 0; j < n; j++) {
if ((ar[j] % ar[i] == 0) && ar[j] != 0) {
if (i != j) ar[j] = 0;
flag = 1;
}
}
if (flag > 0) cnt++;
}
ar[i] = 0;
}
cout << cnt << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, h, MOD = 1000000007;
cin >> n >> h;
vector<int> T(n + 2, h);
for (int i = (1); i <= (n); ++i) cin >> T[i];
long long int ans = 1;
for (int i = (1); i <= (n + 1); ++i) {
if (T[i] > T[i - 1] + 1 || T[i] < T[i - 1] - 1) {
cout << 0;
return 0;
} else if (T[i] == T[i - 1] || T[i] == T[i - 1] + 1)
ans = (ans * (h - T[i] + 1)) % MOD;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
std::unordered_map<long long, long long> mp;
int n, m, q, a[1005][1005];
long long xxx = 1e9;
inline int lowbit(int x, int k) {
x /= k;
return (x & -x) * k;
}
inline bool f(int x, int k) {
bool ans = 1;
x /= k;
while (x) ans ^= 1, x &= x - 1;
return ans;
}
long long getsum(int x, int y) {
if (x <= n && y <= m) return a[x][y];
if (!x || !y) return 0;
int xx = x % (2 * n), yy = y % (2 * m);
if ((xx == 0 && x > n) || (y > n && yy == 0)) return 1ll * x * y / 2;
long long ans = 0;
if (x > n) {
if (xx == x) return 1ll * y * (x - n) - getsum(x - n, y) + getsum(n, y);
ans = getsum(x - xx, y);
if (f(x - xx, n))
ans += getsum(xx, y);
else
ans += 1ll * xx * y - getsum(xx, y);
} else {
if (yy == y) return 1ll * x * (y - m) - getsum(x, y - m) + getsum(x, m);
ans = getsum(x, y - yy);
if (f(y - yy, m))
ans += getsum(x, yy);
else
ans += 1ll * x * yy - getsum(x, yy);
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%1d", a[i] + j);
a[i][j] += a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
}
int x1, x2, y1, y2;
long long ans;
while (q--) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
ans = getsum(x2, y2) + getsum(x1 - 1, y1 - 1);
ans -= getsum(x2, y1 - 1) + getsum(x1 - 1, y2);
printf("%lld\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
const int maxn = (int)(1e5) + 10;
int n, m, p, q;
vector<pair<int, int> > g[maxn];
vector<int> comp[maxn];
long long len[maxn];
bool used[maxn];
int curC, Size[maxn];
void dfs(int v, int pr = -1) {
if (used[v]) return;
used[v] = true;
comp[curC].push_back(v);
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
len[curC] += g[v][i].second;
dfs(to, v);
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &p, &q);
while (m--) {
int v, u, w;
scanf("%d%d%d", &v, &u, &w);
--v;
--u;
g[v].push_back(make_pair(u, w));
g[u].push_back(make_pair(v, w));
}
curC = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs(i);
len[curC] /= 2;
curC++;
}
}
bool hmt1 = false;
for (int i = 0; i < curC; i++) {
Size[i] = (int)((comp[i]).size());
if ((int)((comp[i]).size()) > 1) hmt1 = true;
}
if (p == 0) {
if (curC == q) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
if (q > curC) {
cout << "NO\n";
return 0;
}
set<pair<long long, int> > st;
for (int i = 0; i < curC; i++) {
st.insert(make_pair(len[i], i));
}
vector<pair<int, int> > ans;
int v = -1, u = -1;
for (int it = 0; it < curC - q && p >= 0; it++) {
pair<long long, int> a = *st.begin();
st.erase(st.begin());
pair<long long, int> b = *st.begin();
st.erase(st.begin());
ans.push_back(make_pair(comp[a.second].back(), comp[b.second].back()));
long long addLen = min((long long)(1e9), a.first + b.first + 1);
a.first += b.first + addLen;
Size[a.second] += Size[b.second];
if (Size[a.second] > 1) {
u = comp[b.second].back();
v = comp[a.second].back();
}
st.insert(a);
p--;
}
if (p < 0) {
cout << "NO\n";
return 0;
}
if (p > 0) {
if (v == -1 && !hmt1) {
cout << "NO\n";
return 0;
}
if (hmt1 && v == -1) {
for (int i = 0; i < curC; i++) {
if ((int)((comp[i]).size()) > 1) {
v = comp[i].front();
u = comp[i].back();
}
}
}
cout << "YES\n";
for (int i = 0; i < (int)((ans).size()); i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
for (int i = 0; i < p; i++) {
cout << v + 1 << " " << u + 1 << endl;
}
} else {
cout << "YES\n";
for (int i = 0; i < (int)((ans).size()); i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void caminsminims(vector<vector<int> > &v, int n) {
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) v[i][j] = min(v[i][j], v[i][k] + v[k][j]);
}
bool algumassagran(vector<vector<int> > &v) {
int n = int(v.size());
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (v[i][j] == 1000000000) return true;
return false;
}
bool numbitsparell(int n) {
int num = 0;
while (n > 0) {
if (n % 2 == 1) num++;
n /= 2;
}
return num % 2 == 0;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > v(n, vector<int>(n, 1000000000));
for (int k = 0; k < n; k++) v[k][k] = 0;
int cost = 0;
vector<int> aritat(n, 0);
vector<int> conectado(n, 0);
for (int k = 0; k < m; k++) {
int i, j, w;
cin >> i >> j >> w;
i--;
j--;
cost += w;
if (i != j) {
aritat[i]++;
aritat[j]++;
}
conectado[i] = 1;
conectado[j] = 1;
v[i][j] = v[j][i] = min(v[i][j], w);
}
bool error = false;
if (m > 0 and conectado[0] == 0) error = true;
{
vector<vector<int> > nextv;
vector<int> nextaritat;
for (int i = 0; i < n; i++) {
if (conectado[i] == 1) {
nextaritat.push_back(aritat[i]);
nextv.push_back(vector<int>());
vector<int> &vv = nextv.back();
for (int j = 0; j < n; j++) {
if (conectado[j] == 1) vv.push_back(v[i][j]);
}
}
}
v = nextv;
aritat = nextaritat;
}
n = int(v.size());
caminsminims(v, n);
int numaritatsenar = 0;
for (int i = 0; i < n; i++)
if (aritat[i] % 2 == 1) numaritatsenar++;
if (error or numaritatsenar % 2 == 1 or algumassagran(v)) {
cout << -1 << endl;
} else {
{
vector<vector<int> > nextv;
for (int i = 0; i < n; i++) {
if (aritat[i] % 2 == 1) {
nextv.push_back(vector<int>());
vector<int> &vv = nextv.back();
for (int j = 0; j < n; j++) {
if (aritat[j] % 2 == 1) vv.push_back(v[i][j]);
}
}
}
v = nextv;
}
n = int(v.size());
int numconjunts = (1 << n);
vector<int> minim(numconjunts, 1000000000);
minim[0] = 0;
for (int c = 0; c < numconjunts - 1; c++) {
if (numbitsparell(c)) {
for (int i = 0; i < n; i++) {
if (((1 << i) & c) == 0) {
for (int j = i + 1; j < n; j++) {
if (((1 << j) & c) == 0) {
int nextc = c + (1 << i) + (1 << j);
minim[nextc] = min(minim[nextc], minim[c] + v[i][j]);
}
}
}
}
}
}
cout << cost + minim[numconjunts - 1] << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 600010;
char s[M];
int wa[M], wb[M], wv[M], wc[M];
int r[M], sa[M], rak[M], height[M], SIGMA = 0;
int cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void da(int *r, int *sa, int n, int m) {
int i, j, p, *first = wa, *second = wb, *t;
for (i = 0; i < m; i++) wc[i] = 0;
for (i = 0; i < n; i++) wc[first[i] = r[i]]++;
for (i = 1; i < m; i++) wc[i] += wc[i - 1];
for (i = n - 1; i >= 0; i--) sa[--wc[first[i]]] = i;
for (j = 1, p = 1; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; i++) second[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) second[p++] = sa[i] - j;
for (i = 0; i < n; i++) wv[i] = first[second[i]];
for (i = 0; i < m; i++) wc[i] = 0;
for (i = 0; i < n; i++) wc[wv[i]]++;
for (i = 1; i < m; i++) wc[i] += wc[i - 1];
for (i = n - 1; i >= 0; i--) sa[--wc[wv[i]]] = second[i];
for (t = first, first = second, second = t, p = 1, first[sa[0]] = 0, i = 1;
i < n; i++)
first[sa[i]] = cmp(second, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
void calheight(int *r, int *sa, int n) {
int i, j, k = 0;
for (i = 1; i <= n; i++) rak[sa[i]] = i;
for (i = 0; i < n; height[rak[i++]] = k) {
for (k ? k-- : 0, j = sa[rak[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
}
struct BIT {
int tree[M];
BIT() {}
void clear() { memset((tree), (0), sizeof(tree)); }
void update(int idx, int val) {
while (idx < M) {
tree[idx] += val;
idx += idx & (-idx);
}
}
int query(int idx) {
int sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= idx & (-idx);
}
return sum;
}
};
char A[M];
stack<int> S;
set<int> _set;
BIT B;
int match[M];
int L[M];
int R[M];
int temp[M];
int len;
int proper(int l, int r) {
if (r < l) return 0;
return l == 0 ? B.query(r) : B.query(r) - B.query(l - 1);
}
int calc(int pos, int lenth) {
int nxt = *_set.upper_bound(pos);
return proper(pos, min(nxt - 1, pos + lenth - 1));
}
long long function_name_goes_here() {
int i, j, k;
long long sum = 0;
memset((match), (-1), sizeof(match));
for (i = 0; i < len; i++) {
if (A[i] == '(')
S.push(i);
else {
if (S.empty() || A[S.top()] == ')')
_set.insert(i);
else
match[S.top()] = i, S.pop();
}
}
while (!S.empty()) _set.insert(S.top()), S.pop();
for (i = 0; i < len; match[i] == -1 ? i++ : i = match[i] + 1)
if (match[i] != -1) B.update(match[i], 1);
for (i = 0; i < len; i++) {
if (match[i] != -1) {
int a = calc(i, L[i]), b = calc(i, R[i]);
sum += b - a;
_set.insert(match[i]);
B.update(match[i], -1);
for (j = i + 1; j < match[i]; match[j] == -1 ? j++ : j = match[j] + 1) {
B.update(match[j], 1);
}
}
}
return sum;
}
int main() {
int i, j, k;
scanf("%d", &len);
scanf("%s", A);
SIGMA = 0;
for (i = 0; i < len; i++)
r[i] = A[i], SIGMA = max(SIGMA, r[i]), R[i] = len - i;
r[len] = 0;
da(r, sa, len + 1, SIGMA + 1);
calheight(r, sa, len);
_set.insert(len);
L[sa[0]] = 0;
for (i = 1; i <= len; i++) L[sa[i]] = height[i];
B.clear();
cout << function_name_goes_here() << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int depth[n];
int match_len = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
match_len++;
}
if (match_len % 2 == 0) {
depth[i] = 0;
} else {
depth[i] = 1;
}
if (s[i] == ')') {
match_len--;
}
}
for (auto x : depth) {
cout << x;
}
cout << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n < 3) {
cout << "No";
exit(0);
}
cout << "Yes" << endl;
if (n % 2) {
cout << (n + 1) / 2;
for (int i = 1; i <= n; i += 2) cout << " " << i;
cout << endl;
cout << (n - 1) / 2;
for (int i = 2; i <= n; i += 2) cout << " " << i;
} else {
cout << n / 2;
for (int i = 1; i <= n; i += 2) cout << " " << i;
cout << endl;
cout << n / 2;
for (int i = 2; i <= n; i += 2) cout << " " << i;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const bound = 2e6 + 2, N = 5e5 + 2;
long long OO = 1e18;
int oo = 1e9, mod = oo + 7;
double eps = 1e-6;
int got[51][51], used[51];
vector<pair<double, int> > an[51];
double has[51], inside[51];
int main() {
int n, w, m;
scanf("%d%d%d", &n, &w, &m);
double need = n * w * 1.0 / m;
for (int(i) = 0; (i) < (n); (i)++) inside[i] = w;
for (int(i) = 0; (i) < (m); (i)++) {
if (need - has[i] <= eps) break;
for (int(j) = 0; (j) < (n); (j)++) {
if (fabs(need - has[i]) <= eps) break;
if (got[i][j] || used[j] == 2) continue;
if (inside[j] - 0 <= eps) continue;
double fow = need - has[i];
if (fow <= inside[j]) {
inside[j] -= fow;
has[i] = need;
got[i][j] = 1;
an[i].push_back({fow, j});
used[j]++;
} else if (inside[j] > eps) {
has[i] += inside[j];
an[i].push_back({inside[j], j});
got[i][j] = 1;
inside[j] = 0;
used[j]++;
}
}
}
for (int(i) = 0; (i) < (m); (i)++)
if (fabs(has[i] - need) > eps) {
puts("NO");
return 0;
}
puts("YES");
for (int(i) = 0; (i) < (m); (i)++) {
for (auto el : an[i]) {
printf("%d %.6f ", el.second + 1, el.first);
}
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline int min(int a, int b) { return a < b ? a : b; }
int main() {
int n, c = 0;
scanf("%d", &n);
char s[n + 2];
scanf("%s", s);
for (int i = 0; i < n; ++i) {
char x = s[i];
if (x == '-') {
if (c == 0) ++c;
--c;
} else {
++c;
}
}
printf("%d", c);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
ofstream fout;
FILE *outt, *inn;
ifstream fin("1.txt");
int n, d, m;
int a[101];
int main() {
cin >> n >> d;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cin >> m;
int sum = 0;
sort(a, a + n);
int i = 0;
while (i < min(n, m)) {
sum += a[i];
i++;
}
if (m > n) {
sum = sum - (m - n) * d;
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, i, j, k, n, m, x, y, z, p, q, d = 8;
string s;
cin >> t;
while (t--) {
cin >> x >> y;
k = (sqrt(8 * y + 1) - 1) / 2;
n = sqrt(8 * y + 1);
if (n * n != 8 * y + 1) k++;
p = k + 1;
q = (y - (k * (k + 1)) / 2) + k;
for (i = x; i > 0; i--) {
if (i == p || i == q)
cout << "b";
else
cout << "a";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5003;
const int MAXL = 1 << 20;
struct cmp_thing {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
};
int v[MAXN];
int main() {
srand(time(NULL));
int e = 0;
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &v[i]);
--v[i];
}
vector<int> ans(n, 0);
set<pair<int, int>, cmp_thing> freqs;
vector<vector<int> > afreqs(n, vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
int maxfreq = 0;
int maxv = 0;
for (int j = i; j < n; ++j) {
int x = v[j];
++afreqs[i][x];
if (afreqs[i][x] > maxfreq) {
maxfreq = afreqs[i][x];
maxv = x;
} else if (afreqs[i][x] == maxfreq and x < maxv) {
maxv = x;
}
++ans[maxv];
}
}
for (int i = 0; i < n; ++i) {
if (i > 0) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 1e6 + 10;
int key[] = {8, -1, -1, 3, 6, 9, 4, 7, 0, 5};
int main() {
string str;
cin >> str;
int l = 0, r = str.length() - 1;
int flag = 1;
while (l <= r) {
if (key[str[l] - '0'] != str[r] - '0') flag = 0;
l++, r--;
}
if (flag)
puts("Yes");
else
puts("No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<int> squares;
vector<int> distssquares;
vector<int> distsnot;
int n, a, b, c;
int main() {
scanf("%d", &n);
long long r = 0;
int last = 0;
for (int i = 0; i <= 31623; i++) {
squares.insert(i * i);
last = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (squares.count(a)) {
if (!a)
distssquares.push_back(2);
else
distssquares.push_back(1);
} else {
int mini = 1000000000;
set<int>::iterator it = squares.lower_bound(a);
mini = min(mini, abs((*it) - a));
it = prev(it);
mini = min(mini, abs((*it) - a));
distsnot.push_back(mini);
}
}
sort(distsnot.begin(), distsnot.end());
sort(distssquares.begin(), distssquares.end());
if ((int)distssquares.size() < n / 2) {
for (int i = 0; i < (n / 2 - (int)distssquares.size()); i++) {
r += distsnot[i];
}
} else {
for (int i = 0; i < (n / 2 - (int)distsnot.size()); i++) {
r += distssquares[i];
}
}
printf("%lld\n", r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long mod = 1000000007;
struct modified_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
long long operator()(uint64_t x) const {
static const uint64_t random =
steady_clock::now().time_since_epoch().count();
return splitmix64(x + random);
}
};
long long N;
vector<long long> grph[2001];
vector<long long> dis[2001];
set<long long> st;
bool vis[2001];
long long ans = 0;
bool flag = true;
vector<long long> vp;
void dfs(long long i, long long p1) {
vis[i] = true;
st.insert(i);
for (auto x : grph[i]) {
if (!vis[x]) {
dfs(x, i);
}
}
}
void solve() {
long long a, b, k, c, n, d, m, x, y, l, r;
cin >> n >> m;
memset(vis, false, sizeof(vis));
for (long long i = 0; i < m; i++) {
cin >> a >> b;
grph[a].push_back(b);
grph[b].push_back(a);
}
cin >> k;
for (long long i = 0; i < k; i++) {
cin >> a >> b;
dis[a].push_back(b);
dis[b].push_back(a);
}
long long ans1 = 0;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
flag = true;
ans = 0;
st.clear();
dfs(i, -1LL);
for (auto p : st) {
for (auto p1 : dis[p]) {
if (st.find(p1) != st.end()) {
flag = false;
}
}
}
if (flag) {
long long fm = st.size();
ans1 = max(ans1, fm);
}
}
}
cout << ans1 << "\n";
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long a, b, c, n, tt, d, m, k, x, y;
tt = 1;
while (tt--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long choose(long long n, long long k);
bool isprime(long long n);
void setprime(bool isprime[], long long n);
long long myfun(long long s) {
long long sum = s;
while (s) {
sum += s % 10;
s /= 10;
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a;
for (long long i = max((long long)1, n - 1000); i <= n; i++) {
long long temp = myfun(i);
if (temp == n) {
a.push_back(i);
}
}
cout << a.size() << endl;
for (long long i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
return 0;
}
long long choose(long long n, long long k) {
if (k == 0) return 1;
return (n * choose(n - 1, k - 1)) / k;
}
bool isprime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
void setprime(bool isprime[], long long n) {
for (long long i = 0; i < n; i++) isprime[i] = true;
isprime[0] = false;
isprime[1] = false;
for (long long i = 2; i < n; i++) {
for (long long j = 2; i * j < n; j++) isprime[i * j] = false;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define FOR(i, a, b) for (int i = a; i < int(b); i++)
#define FOREACH(i, v) for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); i++)
#define SIZE(v) ((int)(v).size())
#define pb push_back
#define mp make_pair
#define st first
#define nd second
#define ll long long
#define llint long long
#define pii pair<long long, int>
#define UNVISITED -1
template<typename T>
string to_string(const vector<T>& vc, int w) {
if(vc.empty()) return "";
if(w + 1 == vc.size()) return to_string(vc[w]);
return to_string(vc[w]) + "," + to_string(vc, w + 1);
}
template<typename T>
string to_string(const vector<T>& vc) {
return "{" + to_string(vc, 0) + "}";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef DEBUG
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
class DebugStream {}LOG;
template <typename T>DebugStream &operator<<(DebugStream &s, const T&) { return s; }
#ifdef DEBUG
#define LOG clog
#endif
int main() {
int T; scanf("%d", &T);
REP(t, T) {
int n, m; scanf("%d %d", &n, &m);
map<int, vector<bool> > dic;
REP(i, m) {
int r, c; scanf("%d %d", &r, &c);
if(dic.count(c) == 0) dic[c] = vector<bool>(2, false);
dic[c][r - 1] = true;
}
vector<bool> last = vector<bool>(2, true);
int x = 0;
bool possible = true;
for(auto y : dic) {
if(last[0] == true && last[1] == true) {
x = y.first;
last = y.second;
}
else {
if(y.second[0] == true && y.second[1] == true) {
possible = false;
break;
}
int sum1 = (x + last[1])%2;
int sum2 = (y.first + y.second[1])%2;
if(sum1 == sum2) {
possible = false;
break;
}
x = y.first;
last = vector<bool>(2, true);
}
}
if(last != vector<bool>(2, true)) possible = false;
if(possible) printf("YES\n");
else printf("NO\n");
}
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 3e3 + 10;
int a[maxn], b[maxn];
long long dp[maxn][maxn];
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i] -= i;
b[i] = a[i];
}
sort(b + 1, b + n + 1);
memset(dp, 0, sizeof(dp));
for (long long i = 1; i <= n; ++i) {
long long minn = dp[i - 1][1];
for (int j = 1; j <= n; ++j) {
minn = min(minn, dp[i - 1][j]);
dp[i][j] += minn + abs(a[i] - b[j]);
}
}
long long ans = dp[n][1];
for (int i = 2; i <= n; ++i) ans = min(ans, dp[n][i]);
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[100005];
long long b[100005];
bool c[100005] = {false};
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
return x.first > y.first;
}
int main() {
long long n, k, money;
cin >> n >> k >> money;
for (long long i = 0; i < n - 1; i++) {
cin >> a[i].first;
a[i].second = i;
b[i] = a[i].first;
}
cin >> a[n - 1].first;
sort(a, a + n - 1, cmp);
long long second = 0;
for (long long i = 0; i < k - 1; i++) {
c[a[i].second] = true;
second += a[i].first;
}
for (long long i = 0; i < n - 1; i++) {
long long p = second;
if (c[i] == true) {
p = p - b[i];
p = p + a[k - 1].first;
}
if (p + b[i] > money) {
cout << i + 1 << endl;
return 0;
}
}
cout << n << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxm = 3e5 + 5;
long long a[maxm];
long long d[maxm];
long long n;
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
stack<long long> s, ss;
s.push(1);
ss.push(1);
d[1] = 0;
for (long long i = 2; i <= n; i++) {
d[i] = d[i - 1] + 1;
while (!s.empty() && a[i] >= a[s.top()]) {
long long x = a[s.top()];
s.pop();
if (a[i] != x && !s.empty()) {
d[i] = min(d[i], d[s.top()] + 1);
}
}
while (!ss.empty() && a[i] <= a[ss.top()]) {
long long x = a[ss.top()];
ss.pop();
if (a[i] != x && !ss.empty()) {
d[i] = min(d[i], d[ss.top()] + 1);
}
}
s.push(i);
ss.push(i);
}
cout << d[n] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int INF = 0x3f3f3f3f;
int x;
int n;
int a[1005], b[1005];
void ok(int l, int r, int k){
if(l > r || l < 1 || r > n) return ;
int ans = 0, ii;
for(int i = l; i <= r; i ++ ){
if(a[i] > ans){
ans = a[i];
ii = i;
}
}
b[ii] = k;
ok(l, ii - 1, k + 1), ok(ii + 1, r, k + 1);
}
int main(){
int t;
cin >> t;
while(t -- ){
memset(a, 0, sizeof a);
memset(b, 0, sizeof b);
cin >> n;
for(int i = 1; i <= n; i ++ ){
cin >> a[i];
}
ok(1, n, 0);
for(int i = 1; i <= n; i ++ ){
cout << b[i] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(205);
const int MAXM(50005);
struct edge {
int u, v, g, s;
bool operator<(const edge &p) const { return g < p.g; }
} e[MAXM];
multiset<int, greater<int> > b;
multiset<int, greater<int> >::iterator it;
pair<int, int> par[MAXN];
int find_head(int u) {
return (par[u].first == u) ? u : find_head(par[u].first);
}
set<pair<int, int> > a[MAXN];
void dfs(int node, int p) {
for (typeof(a[node].begin()) it = a[node].begin(); it != a[node].end(); it++)
if (it->first != p) {
par[it->first].first = node;
par[it->first].second = it->second;
dfs(it->first, node);
}
}
int main() {
int n, m;
long long gold, silver;
cin >> n >> m >> gold >> silver;
for (int i = 0; i < m; i++)
scanf("%d%d%d%d", &e[i].u, &e[i].v, &e[i].g, &e[i].s);
sort(e, e + m);
for (int i = 1; i <= n; i++) par[i].first = i;
int cnt = 0;
long long ans = -1;
for (int i = 0; i < m; i++) {
int u = find_head(e[i].u);
int v = find_head(e[i].v);
if (u != v) {
dfs(e[i].u, -1);
a[e[i].u].insert(pair<int, int>(e[i].v, e[i].s));
a[e[i].v].insert(pair<int, int>(e[i].u, e[i].s));
par[e[i].u].first = e[i].v;
par[e[i].u].second = e[i].s;
b.insert(e[i].s);
cnt++;
} else if (e[i].u != e[i].v) {
bool chk[MAXN] = {0};
int t = e[i].u, lca;
while (true) {
chk[t] = 1;
if (par[t].first == t) break;
t = par[t].first;
}
t = e[i].v;
while (true) {
if (chk[t]) {
lca = t;
break;
}
t = par[t].first;
}
t = e[i].u;
int maxu = -1, idx1 = -1;
while (t != lca) {
if (par[t].second > maxu) {
maxu = par[t].second;
idx1 = t;
}
t = par[t].first;
}
t = e[i].v;
int maxv = -1, idx2 = -1;
while (t != lca) {
if (par[t].second > maxv) {
maxv = par[t].second;
idx2 = t;
}
t = par[t].first;
}
if (max(maxu, maxv) > e[i].s) {
if (maxu > maxv) {
a[idx1].erase(pair<int, int>(par[idx1].first, par[idx1].second));
a[par[idx1].first].erase(pair<int, int>(idx1, par[idx1].second));
it = b.find(par[idx1].second);
b.erase(it);
b.insert(e[i].s);
dfs(e[i].u, -1);
a[e[i].u].insert(pair<int, int>(e[i].v, e[i].s));
a[e[i].v].insert(pair<int, int>(e[i].u, e[i].s));
par[e[i].u].first = e[i].v;
par[e[i].u].second = e[i].s;
} else {
a[idx2].erase(pair<int, int>(par[idx2].first, par[idx2].second));
a[par[idx2].first].erase(pair<int, int>(idx2, par[idx2].second));
it = b.find(par[idx2].second);
b.erase(it);
b.insert(e[i].s);
dfs(e[i].v, -1);
a[e[i].u].insert(pair<int, int>(e[i].v, e[i].s));
a[e[i].v].insert(pair<int, int>(e[i].u, e[i].s));
par[e[i].v].first = e[i].u;
par[e[i].v].second = e[i].s;
}
}
}
if (cnt == n - 1) {
if (ans == -1)
ans = gold * e[i].g + silver * (*b.begin());
else
ans = min(ans, gold * e[i].g + silver * (*b.begin()));
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2000000000000000000LL;
const int inf = 0x3f3f3f3f;
const long double EPS = 1e-9;
const long long MOD = 1e9 + 7;
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int test;
cin >> test;
while (test--) {
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int n, mn, mx, diff;
int a[100];
vector<int> v;
long long backtrack(long long s, int i) {
if (i == n) {
if (s >= mn && s <= mx) {
if (v[v.size() - 1] - v[0] >= diff) return 1;
return 0;
} else
return 0;
}
int r1 = 0, r2 = 0;
if (a[i + 1] + s <= mx) {
v.push_back(a[i + 1]);
r1 = backtrack(a[i + 1] + s, i + 1);
v.pop_back();
}
r2 = backtrack(s, i + 1);
return r1 + r2;
}
int main(void) {
n = ({
int a;
scanf("%d", &a);
a;
}),
mn = ({
int a;
scanf("%d", &a);
a;
}),
mx = ({
int a;
scanf("%d", &a);
a;
}),
diff = ({
int a;
scanf("%d", &a);
a;
});
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
long long r = backtrack(0, 0);
cout << r << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s1, s2;
s1 = "";
s2 = "";
int a1 = 0, a2 = 0;
a1 = n % 10;
n /= 10;
a2 = n % 10;
if (a2 == 2) cout << "twenty";
if (a2 == 3) cout << "thirty";
if (a2 == 4) cout << "forty";
if (a2 == 5) cout << "fifty";
if (a2 == 6) cout << "sixty";
if (a2 == 7) cout << "seventy";
if (a2 == 8) cout << "eighty";
if (a2 == 9) cout << "ninety";
if (a2 == 1 && a1 == 0) cout << "ten";
if (a2 == 1 && a1 == 1) cout << "eleven";
if (a2 == 1 && a1 == 2) cout << "twelve";
if (a2 == 1 && a1 == 3) cout << "thirteen";
if (a2 == 1 && a1 == 4) cout << "fourteen";
if (a2 == 1 && a1 == 5) cout << "fifteen";
if (a2 == 1 && a1 == 6) cout << "sixteen";
if (a2 == 1 && a1 == 7) cout << "seventeen";
if (a2 == 1 && a1 == 8) cout << "eighteen";
if (a2 == 1 && a1 == 9) cout << "nineteen";
if (a1 != 0 && a2 > 1) cout << '-';
if (a2 == 0 && a1 == 0) cout << "zero";
if (a2 != 1 && a1 == 1) cout << "one";
if (a2 != 1 && a1 == 2) cout << "two";
if (a2 != 1 && a1 == 3) cout << "three";
if (a2 != 1 && a1 == 4) cout << "four";
if (a2 != 1 && a1 == 5) cout << "five";
if (a2 != 1 && a1 == 6) cout << "six";
if (a2 != 1 && a1 == 7) cout << "seven";
if (a2 != 1 && a1 == 8) cout << "eight";
if (a2 != 1 && a1 == 9) cout << "nine";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void setIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 3e5 + 5;
const int M = 1e5 + 5;
const int L = 2e1 + 1;
const long long inf = 9e17;
const long long mod = 1e9 + 7;
int xyz = 1;
int n;
int val[N];
int ans[N];
vector<int> con[N];
void dfs(int pos, int prn) {
for (int adj : con[pos])
if (adj != prn) dfs(adj, pos);
int big = 0;
int cnt = 0;
for (int adj : con[pos])
if (adj != prn) cnt++, big = max(val[adj], big);
val[pos] = cnt ? big + cnt : 1;
}
void rep(int &f, int &s, int v) {
if (v > f) swap(f, v);
if (v > s) swap(s, v);
}
void rrt(int pos, int prn) {
int f = 0;
int s = 0;
for (int adj : con[pos]) rep(f, s, val[adj]);
ans[pos] = f + s + (int)con[pos].size() - (s > 0) - (f > 0) + 1;
multiset<int> act;
for (int adj : con[pos])
if (adj != prn) act.insert(val[adj]);
for (int adj : con[pos])
if (adj != prn) {
int old = val[pos];
act.erase(act.find(val[adj]));
val[pos] = (int)act.size() ? *prev(act.end()) + con[pos].size() - 1 : 1;
rrt(adj, pos);
val[pos] = old;
act.insert(val[adj]);
}
}
void run() {
cin >> n;
for (int i = 1; i <= n; i++) con[i].clear();
for (int i = 2; i <= n; i++) {
int u;
int v;
cin >> u >> v;
con[u].push_back(v);
con[v].push_back(u);
}
dfs(1, 0);
rrt(1, 0);
cout << *max_element(ans + 1, ans + 1 + n) << "\n";
}
int main() {
setIO();
cin >> xyz;
while (xyz--) run();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t = 1;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> arr(n, 0);
for_each(arr.begin(), arr.end(), [](long long int& x) { cin >> x; });
bool less = true;
if (arr[1] > arr[0]) {
less = false;
}
vector<long long int> result;
result.push_back(arr[0]);
result.push_back(arr[1]);
for (long long int i = 2; i < arr.size(); i++) {
if (arr[i] > result[result.size() - 1] && less) {
result.push_back(arr[i]);
less = false;
}
if (arr[i] > result[result.size() - 1] && !less) {
result.pop_back();
result.push_back(arr[i]);
}
if (arr[i] < result[result.size() - 1] && less) {
result.pop_back();
result.push_back(arr[i]);
}
if (arr[i] < result[result.size() - 1] && !less) {
result.push_back(arr[i]);
less = true;
}
}
cout << result.size() << "\n";
for_each(result.begin(), result.end(),
[](long long int x) { cout << x << " "; });
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e6 + 10;
const long long mod = 1e9 + 7;
long long power(long long x, long long y) {
x = x % mod, y = y % (mod - 1);
long long ans = 1;
while (y > 0) {
if (y & 1) {
ans = (1ll * x * ans) % mod;
}
y >>= 1;
x = (1ll * x * x) % mod;
}
return ans;
}
long long add(long long a, long long b) { return (a % mod + b % mod) % mod; }
long long mul(long long a, long long b) { return (a % mod * b % mod) % mod; }
long long n, k;
const long long K = 210;
vector<long long> a(N);
vector<long long> b(N);
vector<long long> adj[N];
long long vis[N];
long long cnt, ans;
void dfs(long long x) {
if (vis[x]) return;
vis[x] = 1;
for (auto i : adj[x]) dfs(i);
}
int32_t main() {
long long n;
cin >> n;
long long temp = 0;
a.resize(n + 1);
for (long long i = 1; i <= n; i++) {
cin >> a[i];
adj[i].push_back(a[i]);
}
b.resize(n + 1);
for (long long i = 1; i <= n; i++) cin >> b[i];
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
cnt++;
}
}
if (cnt == 1) cnt = 0;
for (long long i = 1; i <= n; i++) ans += b[i];
if (!(ans & 1)) temp++;
cout << temp + cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool dp[1 << 25], finded[1 << 25], D[10][10] = {0};
int num[5][5] = {0}, submask[5][5][5][5] = {0};
bool rec(int mask) {
if (finded[mask]) return dp[mask];
if (mask == 0) return dp[mask] = false;
bool loss = false;
for (int x1 = 0; x1 < 5; ++x1)
for (int y1 = 0; y1 < 5; ++y1)
for (int x2 = x1; x2 < 5; ++x2)
for (int y2 = 0; y2 < 5; ++y2)
if ((mask & submask[x1][y1][x2][y2]) == submask[x1][y1][x2][y2])
if (!rec(mask ^ submask[x1][y1][x2][y2]))
return finded[mask] = dp[mask] = true;
finded[mask] = true;
return dp[mask] = loss;
}
int main() {
char c;
int cmask = 0;
memset(finded, false, sizeof(dp));
for (int i = 0; i < 5; i++)
for (int j = max(0, i - 2); j < 3 + i && j < 5; j++) {
cin >> c;
if (c == 'O') D[i][j] = true, cmask |= (1 << (5 * i + j));
}
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) num[i][j] = 1 << (5 * i + j);
for (int x1 = 0; x1 < 5; ++x1)
for (int y1 = 0; y1 < 5; ++y1)
for (int x2 = x1; x2 < 5; ++x2)
for (int y2 = 0; y2 < 5; ++y2) {
submask[x1][y1][x2][y2] = (1 << 27) - 1;
if (x1 == x2) {
int cmask = 0, y = max(y1, y2);
for (int i = min(y1, y2); i <= y; i++) cmask |= num[x1][i];
submask[x1][y1][x2][y2] = cmask;
} else if (y1 == y2) {
int cmask = 0, x = max(x1, x2);
for (int i = min(x1, x2); i <= x; i++) cmask |= num[i][y1];
submask[x1][y1][x2][y2] = cmask;
} else if (x1 - x2 == y1 - y2) {
int cmask = 0, x = min(x1, x2), y = min(y1, y2), Y = max(y1, y2);
for (int i = min(y1, y2); i <= Y; i++)
cmask |= (num[(x + i - y)][i]);
submask[x1][y1][x2][y2] = cmask;
}
}
if (rec(cmask))
cout << "Karlsson\n";
else
cout << "Lillebror\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[3100];
int main() {
int out = 0, n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) a[i]--;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[j] > i) out++;
if (a[j] == i) break;
}
}
cout << (out / 2) * 4 + (out % 2) << ".0000000" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char face[200];
long long dp[200][2][2];
int main() {
while (~scanf("%s", face + 1)) {
int len = strlen(face + 1);
memset(dp, 0, sizeof(dp));
int Aflag, Bflag;
dp[1][0][0] = 1;
dp[1][1][1] = 1;
if (face[1] == 'A') {
if (face[len] == 'A') {
Aflag = 0;
Bflag = 0;
}
if (face[len] == 'B') {
Aflag = 1;
Bflag = 0;
}
}
if (face[1] == 'B') {
if (face[len] == 'A') {
Aflag = 0;
Bflag = 2;
}
if (face[len] == 'B') {
Aflag = 3;
Bflag = 2;
}
}
for (int i = 2; i <= len; i++) {
if (face[i] == 'A') {
if (face[i - 1] == 'A') {
dp[i][0][0] = dp[i - 1][0][0] + dp[i - 1][1][0];
dp[i][0][1] = dp[i - 1][0][1] + dp[i - 1][1][1];
}
if (face[i - 1] == 'B') {
dp[i][0][0] = dp[i - 1][1][0];
dp[i][0][1] = dp[i - 1][1][1];
dp[i][1][0] = dp[i - 1][0][0];
dp[i][1][1] = dp[i - 1][0][1];
}
}
if (face[i] == 'B') {
if (face[i - 1] == 'A') {
dp[i][0][0] = dp[i - 1][0][0] + dp[i - 1][1][0];
dp[i][0][1] = dp[i - 1][0][1] + dp[i - 1][1][1];
dp[i][1][0] = dp[i - 1][1][0];
dp[i][1][1] = dp[i - 1][1][1];
}
if (face[i - 1] == 'B') {
dp[i][0][0] = dp[i - 1][1][0];
dp[i][0][1] = dp[i - 1][1][1];
dp[i][1][0] = dp[i - 1][1][0];
dp[i][1][1] = dp[i - 1][1][1];
}
}
}
long long ans = 0;
switch (Aflag) {
case 0:
ans += dp[len][0][0];
break;
case 1:
ans += dp[len][0][1];
break;
case 2:
ans += dp[len][0][0] + dp[len][0][1];
break;
default:
break;
}
switch (Bflag) {
case 0:
ans += dp[len][1][0];
break;
case 1:
ans += dp[len][1][1];
break;
case 2:
ans += dp[len][1][0] + dp[len][1][1];
break;
default:
break;
}
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int p = 1e9 + 7;
const int maxn = 1e6 + 10;
int fen[maxn] = {};
void upd(int p, int val) {
for (int i = p; i <= maxn; i += i & -i) fen[i] += val;
}
int get(int p) {
int ans = 0;
for (int i = p; i; i -= i & -i) ans += fen[i];
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<pair<int, int>> seg(n), process;
for (int i = 0; i <= n - 1; i++) cin >> seg[i].first >> seg[i].second;
sort(seg.begin(), seg.end());
vector<vector<pair<int, int>>> v(m);
for (int i = 0; i <= m - 1; i++) {
int t;
cin >> t;
int tmp[t];
cin >> tmp[0];
process.push_back({0, tmp[0]});
v[i].push_back({0, tmp[0]});
for (int j = 1; j <= t - 1; j++) {
cin >> tmp[j];
process.push_back({tmp[j - 1], tmp[j]});
v[i].push_back({tmp[j - 1], tmp[j]});
}
process.push_back({tmp[t - 1], 1e6 + 10});
v[i].push_back({tmp[t - 1], 1e6 + 10});
}
sort(process.rbegin(), process.rend());
int pos = seg.size() - 1;
map<pair<int, int>, int> res;
for (auto [x, y] : process) {
for (int i = pos; i >= 0; i--) {
if (seg[i].first <= x) break;
upd(seg[i].second, 1);
pos--;
}
res[{x, y}] = get(y - 1);
}
for (int i = 0; i <= m - 1; i++) {
int kq = n;
for (auto [x, y] : v[i]) {
kq = kq - res[{x, y}];
}
cout << kq << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b[100005], p[100005], l, r, ans;
long long sum;
bool cmp(int a, int b) { return a > b; }
bool check(int num, int a) {
for (int i = 1; i <= num; i++) {
if (b[i] >= p[num - i + 1])
continue;
else {
if ((b[i] + a) >= p[num - i + 1])
a -= (p[num - i + 1] - b[i]);
else
return false;
}
}
return true;
}
int main() {
scanf("%d%d%d", &n, &m, &a);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= m; i++) scanf("%d", &p[i]);
sort(b + 1, b + 1 + n, cmp);
sort(p + 1, p + 1 + m);
l = 0;
r = min(n, m);
while ((r - l) > 1) {
int mid = (l + r) >> 1;
if (check(mid, a))
l = mid;
else
r = mid;
}
if (check(r, a))
ans = r;
else
ans = l;
printf("%d ", ans);
for (int i = 1; i <= ans; i++) sum += p[i];
sum -= a;
if (sum < 0) sum = 0;
printf("%lld", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int f[105][3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, i, a;
cin >> n;
f[0][0] = f[0][1] = f[0][2] = 0;
for (i = 1; i <= n; i++) {
cin >> a;
f[i][0] = min(f[i - 1][0], min(f[i - 1][1], f[i - 1][2])) + 1;
if (a == 0)
f[i][1] = f[i][2] = 1e9;
else if (a == 1) {
f[i][1] = min(f[i - 1][0], f[i - 1][2]);
f[i][2] = 1e9;
} else if (a == 2) {
f[i][1] = 1e9;
f[i][2] = min(f[i - 1][0], f[i - 1][1]);
} else {
f[i][1] = min(f[i - 1][0], f[i - 1][2]);
f[i][2] = min(f[i - 1][0], f[i - 1][1]);
}
}
cout << min(f[n][0], min(f[n][1], f[n][2]));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, a[5], b[5];
cin >> a[1] >> a[2] >> a[3] >> b[1] >> b[2] >> b[3];
for (int i = 1; i <= 3; ++i) {
if (a[i] >= b[i])
ans += (a[i] - b[i]) / 2;
else
ans += (a[i] - b[i]);
}
if (ans >= 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, k, val, ans;
vector<int> a;
vector<vector<int>> G;
vector<int> sz, cnt_one, dp;
vector<array<pair<int, int>, 2>> mx;
void calc_dp(int v, int pr) {
sz[v] = 1;
cnt_one[v] += (a[v] >= val ? 1 : 0);
for (auto u : G[v]) {
if (u != pr) {
calc_dp(u, v);
sz[v] += sz[u];
cnt_one[v] += cnt_one[u];
if (sz[u] == cnt_one[u]) {
dp[v] += sz[u];
} else {
if (mx[v][0].first <= dp[u]) {
mx[v][1] = mx[v][0];
mx[v][0] = make_pair(dp[u], u);
} else if (mx[v][1].first <= dp[u]) {
mx[v][1] = make_pair(dp[u], u);
}
}
}
}
dp[v] += mx[v][0].first;
if (a[v] < val) {
dp[v] = 0;
} else {
dp[v]++;
}
}
void calc_ans(int v, int pr) {
ans = max(ans, dp[v]);
for (auto u : G[v]) {
if (u != pr) {
array<pair<int, int>, 2> was_mx_v = mx[v];
array<pair<int, int>, 2> was_mx_u = mx[u];
int was_dp_v = dp[v];
int was_dp_u = dp[u];
int was_sz_v = sz[v];
int was_sz_u = sz[u];
int was_cnt_one_v = cnt_one[v];
int was_cnt_one_u = cnt_one[u];
dp[v] -= mx[v][0].first;
if (sz[u] == cnt_one[u]) {
dp[v] -= dp[u];
} else if (u == mx[v][0].second) {
swap(mx[v][0], mx[v][1]);
}
dp[v] += mx[v][0].first;
sz[v] -= sz[u];
cnt_one[v] -= cnt_one[u];
if (a[v] < val) {
dp[v] = 0;
}
dp[u] -= mx[u][0].first;
if (sz[v] == cnt_one[v]) {
dp[u] += dp[v];
} else {
if (mx[u][0].first <= dp[v]) {
mx[u][1] = mx[u][0];
mx[u][0] = make_pair(dp[v], v);
} else if (mx[u][1].first <= dp[v]) {
mx[u][1] = make_pair(dp[v], v);
}
}
dp[u] += mx[u][0].first;
sz[u] += sz[v];
cnt_one[u] += cnt_one[v];
if (a[u] < val) {
dp[u] = 0;
}
calc_ans(u, v);
mx[v] = was_mx_v;
mx[u] = was_mx_u;
dp[v] = was_dp_v;
dp[u] = was_dp_u;
sz[v] = was_sz_v;
sz[u] = was_sz_u;
cnt_one[v] = was_cnt_one_v;
cnt_one[u] = was_cnt_one_u;
}
}
}
bool check() {
sz.assign(n, 0);
cnt_one.assign(n, 0);
dp.assign(n, 0);
mx.assign(n, {make_pair(0, -1), make_pair(0, -1)});
calc_dp(0, 0);
ans = 0;
calc_ans(0, 0);
return ans >= k;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> k;
a.resize(n);
for (auto &el : a) {
cin >> el;
}
G.resize(n);
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
v--, u--;
G[v].push_back(u);
G[u].push_back(v);
}
int L = 0, R = *max_element(a.begin(), a.end()) + 1;
while (R - L > 1) {
val = (R + L) / 2;
if (check()) {
L = val;
} else {
R = val;
}
}
cout << L << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int grundy[100005];
int sum[100005];
int v[100005], k = 0;
bool vis[100005];
vector<int> lo[100005], hi[100005];
int main() {
int n, mn = 1e9;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int sum = i;
for (int j = 1; 1; j++) {
sum += i + j;
if (sum > n) break;
lo[sum].push_back(i);
hi[sum].push_back(i + j);
}
}
for (int i = 1; i <= n; i++) {
k = 0;
for (int j = 0; j < lo[i].size(); j++) {
int g = sum[hi[i][j]] ^ sum[lo[i][j] - 1];
int m = hi[i][j] - lo[i][j] + 1;
if (i == n && g == 0) mn = min(mn, m);
v[k++] = g;
vis[g] = 1;
}
for (int j = 0; 1; j++) {
if (vis[j]) continue;
grundy[i] = j;
break;
}
for (int j = 0; j < k; j++) vis[v[j]] = 0;
sum[i] = sum[i - 1] ^ grundy[i];
}
if (grundy[n] == 0)
printf("-1\n");
else
printf("%d\n", mn);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int *seq = new int[n];
for (int i = 0; i < n; i++) {
cin >> seq[i];
}
int count = 0;
for (int i = 1; i < n; i++) {
int s = seq[i] + seq[i - 1];
if (s == 5) return cout << "Infinite", 0;
count += s;
if (seq[i] == 2 && seq[i - 1] == 1 && seq[i - 2] == 3) count -= 1;
}
cout << "Finite" << endl << count;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
inline void chmax(T &x, const T &y) {
if (x < y) x = y;
}
int read() {
char c;
while ((c = getchar()) < '-')
;
if (c == '-') {
int x = (c = getchar()) - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return -x;
}
int x = c - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return x;
}
template <typename T>
struct vec {
T *a;
int n;
void clear() {
if (n > 0) delete[] a;
n = 0;
}
void push_back(const T &x) {
if ((n & -n) == n) a = (T *)realloc(a, (n * 2 + 1) * sizeof(T));
a[n++] = x;
}
};
const int N = 40, T = N * 2, K = 105;
struct edge {
int type, to;
};
int n, k, t;
long long dp[T][T];
vec<edge> lk[T];
bool check(int type, int to) {
if (type == -1) return 0 == to;
if (type == 0) return 0 < to;
if (type == 1) return 0 > to;
if (type == 2) return 0 <= to;
return 0 >= to;
}
bool ok(int x, int y, int l, int r) {
for (auto it = lk[x].a, end = it + lk[x].n; it != end; ++it) {
int type = it->type, to = it->to;
if (to == x || to == y)
to = 0;
else if (to < l || to > r)
to = -1;
else
to = 1;
if (!check(type, to)) return 0;
}
for (auto it = lk[y].a, end = it + lk[y].n; it != end; ++it) {
int type = it->type, to = it->to;
if (to == x || to == y)
to = 0;
else if (to < l || to > r)
to = -1;
else
to = 1;
if (!check(type, to)) return 0;
}
return 1;
}
long long DP(int l, int r) {
long long &ans = dp[l][r];
if (ans != -1) return ans;
if (l == 1 && r == t) return ans = 1;
ans = 0;
if (l > 1 && r < t && ok(l - 1, r + 1, l, r)) ans += DP(l - 1, r + 1);
if (l > 2 && ok(l - 2, l - 1, l, r)) ans += DP(l - 2, r);
if (r + 2 <= t && ok(r + 1, r + 2, l, r)) ans += DP(l, r + 2);
return ans;
}
int main() {
cin >> n >> k;
int x, y;
char type[5];
for (int i = 1; i <= k; ++i) {
scanf("%d%s%d", &x, type, &y);
if (*type == '=') {
lk[x].push_back((edge){-1, y});
lk[y].push_back((edge){-1, x});
} else {
int dy = (type[1] == '=') ? 2 : 0;
if (*type == '>') dy ^= 1;
lk[x].push_back((edge){dy, y});
lk[y].push_back((edge){dy ^ 1, x});
}
}
memset(dp, -1, sizeof(dp));
long long ans = 0;
t = n * 2;
for (int i = 2; i <= t; ++i)
if (ok(i - 1, i, i, i - 1)) ans += DP(i - 1, i);
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int l1, l2;
l1 = s1.length();
int i;
int ans = 0;
for (i = 0; i < l1; i += 2) {
if (s1[i] == '(' && s2[i] == '[') ans++;
if (s1[i] == '(' && s2[i] == '8') ans--;
if (s1[i] == '8' && s2[i] == '[') ans--;
if (s1[i] == '8' && s2[i] == '(') ans++;
if (s1[i] == '[' && s2[i] == '8') ans++;
if (s1[i] == '[' && s2[i] == '(') ans--;
}
if (ans > 0)
cout << "TEAM 2 WINS" << endl;
else if (ans < 0)
cout << "TEAM 1 WINS" << endl;
else if (ans == 0)
cout << "TIE" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 6, M = 3e5 + 5, mod = 1e9 + 7;
const double EPS = 1e-3;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int n, f, numP, numC, preB;
long long totB;
int main() {
vector<int> postB;
scanf("%d %d", &n, &f);
for (int i = 0; i < int(n); i++) {
scanf("%d %d", &numP, &numC);
totB += min(numP, numC);
preB = min(numP, numC);
postB.push_back(min(2 * numP, numC) - preB);
}
sort(((postB).begin()), ((postB).end()));
int sz = postB.size();
for (int i = sz - 1; f > 0; --i) totB += postB[i], f--;
printf("%lld\n", totB);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int xs[100100];
int ys[100100];
int rs[100100];
int main() {
int r, d;
int n;
cin >> r >> d;
cin >> n;
for (int i = 1; i <= n; i++) cin >> xs[i] >> ys[i] >> rs[i];
int cnt = 0;
for (int i = 1; i <= n; i++) {
double d1 = xs[i] * xs[i] + ys[i] * ys[i];
double r1 = (r - d + rs[i]) * (r - d + rs[i]);
double r2 = (r - rs[i]) * (r - rs[i]);
if (d1 >= r1 - eps && d1 <= r2 + eps) cnt++;
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 2e5 + 5;
int n, k;
int c[nax];
int f[nax] = {0};
bool gun(int x) {
for (int i = 1; i <= k; i++) {
int g = f[i] / x + (f[i] % x != 0);
if (g > c[i]) return false;
}
return true;
}
int fun(int st, int end) {
if (st > end) return -1;
int mid = (st + end) / 2;
if (gun(mid)) {
int lans = fun(st, mid - 1);
if (lans == -1)
return mid;
else
return lans;
}
return fun(mid + 1, end);
}
void solve() {
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
f[x]++;
v[i] = x;
}
for (int i = 1; i <= k; i++) {
cin >> c[i];
}
sort(v.begin(), v.end());
for (int i = nax - 2; i >= 0; i--) {
f[i] += f[i + 1];
}
int g = fun(1, n);
vector<int> ans[g];
int l = 0;
int i = 0;
while (l < n) {
ans[i].push_back(v[l]);
l++;
i++;
i %= g;
}
cout << g << '\n';
for (int i = 0; i < g; i++) {
cout << ans[i].size() << ' ';
for (auto x : ans[i]) cout << x << ' ';
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tc;
tc = 1;
while (tc--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
//indexed set is using "int" here--------- use ll ...
// typedef tree <int,null_type,less <int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;
typedef long long int ll;
typedef long double ld;
#define FAST \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define rep(g, i, n) for (ll g = i; g < n; g++)
#define rev(g, n, i) for (ll g = n - 1; g >= i; g--)
#define all(v) v.begin(), v.end()
#define pb push_back
#define mxe(v) *max_element(v.begin(), v.end())
#define mne(v) *min_element(v.begin(), v.end())
#define ve vector
#define rem 1000000007
#define PI 3.141592653589793238462643383279502
void primeFactors(ll n, unordered_set <ll> &s1)
{
// Print the number of 2s that divide n
while (n % 2 == 0)
{
s1.insert(2);
n = n/2;
}
// n must be odd at this point. So we can skip
// one element (Note i = i +2)
for (int i = 3; i <= sqrt(n); i = i + 2)
{
// While i divides n, print i and divide n
while (n % i == 0)
{
s1.insert(i);
n = n/i;
}
}
// This condition is to handle the case when n
// is a prime number greater than 2
if (n > 2)
s1.insert(n);
}
bool iscube(ll x)
{
ld z=x;
if (ceil(cbrt(z))==floor(cbrt(z)))
{
return true;
}
return false;
// unordered_set <ll> s1;
// primeFactors(x,s1);
// for (auto y: s1)
// {
// ll xc=x,cnt=0;
// while (xc%y==0)
// {
// xc/=y;
// cnt++;
// }
// if (cnt%3!=0)
// {
// return false;
// }
// }
// return true;
}
int main()
{
FAST;
// freopen("input1.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ll tests;
cin>>tests;
rep (gg,0,tests)
{
ll x;
cin>>x;
ll ans=0;
rep (i,1,1e4+1)
{
ll val=x-i*i*i;
if (val>0&&iscube(val))
{
ans++;
}
}
if (ans>0)
{
cout<<"YES\n";
}
else
{
cout<<"NO\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long PT[103][103 + 1];
void build_pascal_triangle() {
PT[0][0] = 1;
for (int n = 1; n < 103; ++n) {
PT[n][0] = 1;
for (int k = 1; k < n; ++k) {
PT[n][k] = (PT[n - 1][k - 1] + PT[n - 1][k]) % 1000000007;
}
PT[n][n] = 1;
}
}
unsigned long long Choose(int n, int k) {
if (n < 0 || k < 0 || k > n) return 0;
return PT[n][k];
}
int D[10];
int memo[104][10];
int go(int len, int start_dig = 0) {
if (len < 0) return 0;
if (start_dig == 9) return len >= D[9] ? 1 : 0;
int& res = memo[len][start_dig];
if (res < 0) {
res = 0;
int llen = start_dig == 0 ? len - 1 : len;
for (int k = D[start_dig]; k <= len; ++k)
res = (res + go(len - k, start_dig + 1) * Choose(llen, k)) % 1000000007;
}
return res;
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
build_pascal_triangle();
int num_len;
cin >> num_len;
for (int j = 0; j < 10; ++j) cin >> D[j];
unsigned long long res = 0;
for (int len = accumulate(D, D + 10, 0); len <= num_len; ++len) {
memset(memo, -1, sizeof(memo));
int cur = go(len);
res = (res + cur) % 1000000007;
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long mod) {
long long c = 1;
while (b > 0) {
if (b % 2) c *= a, c %= mod;
b /= 2;
a *= a;
a %= mod;
}
return c;
}
long long dp[200005];
long long arr[200005];
long long n, flag;
map<long long, bool> vis;
long long rec(long long x) {
if (x != 1) {
if (vis[x]) return -1;
}
if (x != 1) vis[x] = 1;
long long xx = x;
long long y = 0;
if ((x != 1) && (dp[x] != 0))
return dp[x];
else {
y += arr[x];
x += arr[x];
if (x > n) return y;
y += arr[x];
x -= arr[x];
if (x < 1) return y;
if (x == 1) {
if (xx != 1) dp[xx] = -1;
return -1;
}
}
long long xxx = rec(x);
if (xxx == -1) {
if (xx != 1) dp[xx] = -1;
return -1;
} else {
if (xx != 1) dp[xx] = y + xxx;
return y + xxx;
}
}
int main() {
cin >> n;
long long x = 1, y = 0;
for (long long i = 2; i <= n; i++) cin >> arr[i];
for (long long i = 1; i < n; i++) {
arr[1] = i;
cout << rec(1) << "\n";
vis.clear();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, i = 1;
cin >> a >> b;
while (true) {
if (a < i) {
cout << "Vladik";
break;
}
a = a - i;
i++;
if (b < i) {
cout << "Valera";
break;
}
b = b - i;
i++;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.);
template <class T>
inline T sq(T x) {
return x * x;
}
vector<int> luckys;
int _gen(int m, int n) {
return n ? (m & 1 ? 7 : 4) + _gen(m >> 1, n - 1) * 10 : 0;
}
void gen() {
for (int i = (1); i < (10); ++i) {
for (int j = (0); j < (1 << i); ++j) {
luckys.push_back(_gen(j, i));
}
}
}
double prob(int l1, int r1, int l2, int r2) {
int l3 = max(l1, l2);
int r3 = min(r1, r2);
if (l3 > r3) return .0;
return (double)(r3 - l3 + 1) / (r1 - l1 + 1);
}
void solve() {
gen();
int pl, pr, vl, vr, k;
cin >> pl >> pr >> vl >> vr >> k;
double ans = .0;
if (pl <= luckys[int((luckys).size()) - 1]) {
int l = pl;
int i = 0;
while (luckys[i] < l) ++i;
while (l <= pr && int((luckys).size()) - i >= k) {
int r = min(luckys[i], pr);
int _l = luckys[i + k - 1];
int _r = i + k < int((luckys).size()) ? luckys[i + k] - 1 : 1 << 30;
ans += prob(pl, pr, l, r) * prob(vl, vr, _l, _r);
l = r + 1;
++i;
}
}
if (pr >= luckys[0]) {
int r = pr;
int i = int((luckys).size()) - 1;
while (luckys[i] > r) --i;
while (r >= pl && i + 1 >= k) {
int l = max(luckys[i], pl);
int _l = i - k >= 0 ? luckys[i - k] + 1 : 0;
int _r = luckys[i - k + 1];
ans += prob(pl, pr, l, r) * prob(vl, vr, _l, _r);
if (k == 1)
ans -= prob(pl, pr, luckys[i], luckys[i]) *
prob(vl, vr, luckys[i], luckys[i]);
r = l - 1;
--i;
}
}
printf("%.16lf\n", ans);
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t, n, hold;
cin >> t;
while (t--) {
bool ans = false;
cin >> n;
long long int x;
for (long long int i = 0; i < n; i++) {
cin >> hold;
if (i == 0) x = hold;
if (x != hold) ans = true;
}
if (ans)
cout << 1 << endl;
else
cout << n << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
unsigned int candies;
std::vector<unsigned int> weights;
std::cin >> candies;
for (unsigned int c = 0; c < candies; ++c) {
unsigned int weight;
std::cin >> weight;
weights.push_back(weight);
}
unsigned int good_candies = 0;
unsigned int sums[4] = {0, 0, 0, 0};
for (unsigned int c = 1; c < candies; ++c) {
sums[2 + (c + 1) % 2] += weights[c];
}
for (unsigned int c = 0; c < candies; ++c) {
if ((sums[0] + sums[2]) == (sums[1] + sums[3])) ++good_candies;
if (c + 1 >= candies) break;
sums[c % 2] += weights[c];
sums[2 + c % 2] -= weights[c + 1];
}
std::cout << good_candies << std::endl;
}
| 2 |
#include <bits/stdc++.h>
int main(int argc, char const *argv[]) {
int max_sum;
scanf("%d\n", &max_sum);
int counts[10] = {
0,
};
int c, sum = 0;
while ((c = getchar()) != '\n') {
c -= '0';
counts[c]++;
sum += c;
}
int min_num = 0;
int mods = 0;
while (sum < max_sum) {
while (counts[min_num] < 1) {
min_num++;
}
counts[min_num]--;
sum += 9 - min_num;
mods++;
}
printf("%d\n", mods);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, size[110];
std::vector<int> next[110];
long double frc[110], f[110][110], g[110], h[110];
inline long double C(int x, int y) { return frc[x] / frc[y] / frc[x - y]; }
inline long double calc(int x, int y) { return C(x + y, y); }
void dp(int x, int fa) {
size[x] = 1;
f[x][0] = 1;
for (int y : next[x]) {
if (y == fa) continue;
dp(y, x);
for (int i = 0; i <= size[x] + size[y]; i++) g[i] = h[i] = 0;
for (int i = 0; i <= size[y]; i++) {
for (int j = 1; j <= size[y]; j++) {
g[i] += j <= i ? f[y][j - 1] * 0.5 : f[y][i];
}
}
for (int i = 0; i < size[x]; i++) {
for (int j = 0; j <= size[y]; j++) {
h[i + j] +=
f[x][i] * g[j] * calc(i, j) * calc(size[x] - i - 1, size[y] - j);
}
}
for (int i = 0; i <= size[x] + size[y]; i++) f[x][i] = h[i];
size[x] += size[y];
}
}
int main() {
std::ios::sync_with_stdio(0);
std::cin >> n;
for (int i = 1, u, v; i < n; i++) {
std::cin >> u >> v;
next[u].push_back(v);
next[v].push_back(u);
}
frc[0] = 1;
for (int i = 1; i < 110; i++) frc[i] = frc[i - 1] * i;
for (int i = 1; i <= n; i++) {
memset(f, 0, sizeof(f));
dp(i, 0);
std::cout << std::fixed << std::setprecision(10)
<< (f[i][n - 1] / frc[n - 1]) << std::endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int d1, d2, d3;
scanf("%d %d %d", &d1, &d2, &d3);
long long int min = 100000000000;
int x = d1 + d3 + d2;
if (x < min) min = x;
x = d1 + d3 + d3 + d1;
if (x < min) min = x;
x = d1 * 2 + d2 * 2;
if (x < min) min = x;
x = d2 + d3 + d3 + d2;
if (x < min) min = x;
printf("%d\n", min);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
int ind = 1;
vector<int> v;
for (int i = 1; i < n; ++i) {
if (s[i] != s[i - 1]) {
v.push_back(ind);
ind = 1;
} else {
ind++;
}
}
v.push_back(ind);
int si = v.size();
multiset<pair<long long, long long>, greater<pair<long long, long long>>> st;
vector<int> rem(v);
set<int> fr;
for (int i = 0; i < si; ++i) {
st.insert({rem[i], i});
if (rem[i] > 2) {
fr.insert(i);
}
}
int ans = 0;
ind = 0;
int bc = si - 1;
while ((!st.empty()) and ind < si) {
assert(st.find({rem[ind], ind}) != st.end());
auto tp = *(st.find({rem[ind], ind}));
st.erase(st.find(tp));
ans++;
if (fr.find(ind) != fr.end()) {
fr.erase(ind);
}
if (rem[ind] > 1) {
ind++;
continue;
}
if (!st.empty()) {
if (!fr.empty()) {
auto temp = *(fr.begin());
auto tem = *(st.find({rem[temp], temp}));
st.erase(st.find(tem));
rem[tem.second]--;
st.insert({rem[tem.second], tem.second});
if (rem[tem.second] < 3) {
fr.erase(temp);
}
} else {
st.erase(st.find({rem[bc], bc}));
rem[bc]--;
if (rem[bc]) {
st.insert({rem[bc], bc});
} else {
bc--;
}
}
}
ind++;
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000 * 1000 * 1000 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
const long long inf = 1e18;
int toint(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
long long tolint(string s) {
long long sm;
stringstream ss(s);
ss >> sm;
return sm;
}
long long a, b, c, d, e, f, g, h, m, n, p, q, t, u, w, x, y, z,
ara[100005] = {0}, arr[100005] = {0};
vector<long long> v, v2, v3;
string s;
int main() {
cin.tie(0);
cout.sync_with_stdio(0);
cin >> s;
n = s.size();
a = 0;
long long ans = 0, sum = 0;
for (int i = 0; i < (n); i++) {
if (s[i] == 'b') {
if (a != -1) {
sum++;
} else {
ans = max(ans, sum);
sum = 1;
}
a = -1;
} else {
if (a != 1)
sum++;
else {
ans = max(ans, sum);
sum = 1;
}
a = 1;
}
ans = max(ans, sum);
}
if (ans == n) {
cout << n;
return 0;
}
if (s[0] == s[n - 1]) {
cout << ans;
return 0;
}
char l, r;
l = s[0], r = s[n - 1];
a = 0;
sum = 0;
for (int i = 0; i < (n); i++) {
if (s[i] == 'b') {
if (a != -1) {
sum++;
} else {
break;
}
a = -1;
} else {
if (a != 1)
sum++;
else {
break;
}
a = 1;
}
}
x = sum;
sum = 0;
a = 0;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == 'b') {
if (a != -1) {
sum++;
} else {
break;
}
a = -1;
} else {
if (a != 1)
sum++;
else {
break;
}
a = 1;
}
}
y = sum;
cout << max(ans, x + y);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int MAXM = 1e5 + 10;
int b[MAXM];
char s[MAXN];
int a[26];
map<int, int> mmp;
int main() {
int n;
scanf("%d", &n);
for (int j = 1; j <= n; j++) {
int now = 0;
memset(a, 0, sizeof(a));
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
a[s[i] - 'a']++;
if (a[s[i] - 'a'] == 2) a[s[i] - 'a'] = 0;
}
int w = 0;
for (int i = 0; i < 26; i++) {
w <<= 1;
if (a[i] == 1) {
w += 1;
}
}
b[j] = w;
if (mmp.count(w) == 1) {
mmp[w]++;
} else {
mmp[w] = 1;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int w = b[i];
mmp[w]--;
if (w == 0) {
int www = 1;
if (mmp.count(0) == 1) {
ans += mmp[0];
}
for (int i = 0; i <= 27; i++) {
www = 1 << i;
if (mmp.count(www) == 1) {
ans += mmp[www];
}
}
} else {
int hxk = w;
hxk -= w & -w;
if (hxk == 0) {
if (mmp.count(0) == 1) {
ans += mmp[0];
}
if (mmp.count(w) == 1) {
ans += mmp[w];
}
for (int j = 0; j < 28; j++) {
int bb = 1 << j;
if ((w & bb) == 0) {
if (mmp.count(w + bb) == 1) {
ans += mmp[w + bb];
}
}
}
} else {
if (mmp.count(w) == 1) {
ans += mmp[w];
}
int qust = w;
while (qust) {
int bb = qust & -qust;
if (mmp.count(w - bb) == 1) {
ans += mmp[w - bb];
}
qust -= bb;
}
for (int j = 0; j < 28; j++) {
int bb = 1 << j;
if ((w & bb) == 0) {
if (mmp.count(w + bb) == 1) {
ans += mmp[w + bb];
}
}
}
}
}
}
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t;
int c[1222333];
int a;
int u[1222333];
int sx, sy;
int zz;
int simu(int n, int m, int k) {
memset(u, 0, sizeof(int) * (a + 1));
int f = a;
int df = -1;
for (int i = 1; i <= n; i++) {
int g = f;
for (int j = 1; j <= m; j++) {
u[g]++;
if (u[g] > c[g]) return 1;
if (g == 0) {
sx = i;
sy = j;
df = 1;
}
if (j <= k)
g--;
else
g++;
}
f += df;
}
return 0;
}
void check(int n, int m) {
bool ok = false;
for (int i = 0; i <= m; i++) {
if (i != zz && i != m - zz + 1) continue;
if (simu(n, m, i - 1) == 0) {
printf("%d %d\n", n, m);
printf("%d %d\n", sx, sy);
exit(0);
}
}
}
int main() {
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
int x;
scanf("%d", &x);
c[x]++;
if (x > a) a = x;
}
if (c[0] != 1) {
printf("-1\n");
return 0;
}
for (int z = 1;; z++) {
if (c[z] != 4 * z) {
zz = z;
break;
}
}
for (int i = t; i >= 1; i--) {
if (t % i == 0) check(i, t / i);
}
printf("-1\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 1e5 + 5, oo = 0x3f3f3f3f, mod = 1e9 + 7;
int n, a[N], frq[M], k, l, r, d;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
l = 0;
r = 0;
frq[a[0]]++;
d = 1;
while (r < n && l < n) {
if (r < n - 1 && d < k) {
r++;
if (!frq[a[r]]) d++;
frq[a[r]]++;
} else if (d >= k && frq[a[l]] > 1) {
frq[a[l]]--;
l++;
} else
break;
}
if (d < k)
puts("-1 -1");
else
printf("%d %d", l + 1, r + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool ascending(vector<int> &a) {
for (int i = 0; i < a.size() - 1; ++i)
if (a[i] > a[i + 1]) return false;
return true;
}
bool descending(vector<int> &a) {
for (int i = 0; i < a.size() - 1; ++i)
if (a[i] < a[i + 1]) return false;
return true;
}
bool sorted(vector<int> &a) {
if (a.size() <= 2) return true;
if (ascending(a)) return true;
if (descending(a)) return true;
return false;
}
bool check(vector<int> &a, int l, int r) {
swap(a[l], a[r]);
bool b = sorted(a);
swap(a[r], a[l]);
return !b;
}
void solve(istream &in, ostream &out) {
int n;
in >> n;
if (n <= 2) {
out << -1;
return;
}
vector<int> a(n);
set<int> s;
for (int i = 0; i < n; ++i) {
in >> a[i];
s.insert(a[i]);
}
if (s.size() == 1) {
out << -1;
return;
}
for (int l = 0; l < n - 1; ++l) {
for (int r = l + 1; r < n; ++r) {
if (a[l] != a[r]) {
if (check(a, l, r)) {
out << l + 1 << ' ' << r + 1;
return;
}
}
}
}
out << -1;
}
int main() {
solve(cin, cout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> ST, deltas;
vector<int> L, R;
int m;
void range(int p, int l, int r) {
L[p] = l;
R[p] = r;
if (p >= m) return;
range(2 * p, l, (l + r) / 2);
range(2 * p + 1, (l + r) / 2 + 1, r);
}
void update(int p) {
if (p == 0) return;
ST[p] = max(ST[p], max(ST[2 * p], ST[2 * p + 1]));
update(p / 2);
}
void build() {
for (int i = m - 1; i > 0; --i) ST[i] = max(ST[2 * i], ST[2 * i + 1]);
}
void add_value(int p, int value, int l) {
if (R[p] < l) return;
if (p >= m) {
ST[p] += deltas[p];
deltas[p] = 0;
} else {
ST[p] += deltas[p];
deltas[2 * p] += deltas[p];
deltas[2 * p + 1] += deltas[p];
deltas[p] = 0;
}
if (L[p] >= l) {
ST[p] += value;
update(p / 2);
if (p < m) {
deltas[2 * p] += value;
deltas[2 * p + 1] += value;
}
} else {
add_value(p * 2, value, l);
add_value(p * 2 + 1, value, l);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, ar, p;
cin >> n >> ar >> p;
vector<vector<int> > W(n, vector<int>(2));
for (int i = 0; i < n; ++i) cin >> W[i][0] >> W[i][1];
vector<vector<int> > A(ar, vector<int>(2));
for (int i = 0; i < ar; ++i) cin >> A[i][0] >> A[i][1];
vector<vector<int> > M(p, vector<int>(3));
for (int i = 0; i < p; ++i) cin >> M[i][0] >> M[i][1] >> M[i][2];
sort(W.begin(), W.end());
sort(A.begin(), A.end());
sort(M.begin(), M.end());
m = pow(2, ceil(log2(ar + 1)));
ST = vector<long long int>(2 * m, -1e18);
deltas = vector<long long int>(2 * m, 0);
R = vector<int>(2 * m);
L = vector<int>(2 * m);
range(1, m, 2 * m - 1);
for (int i = 0; i < ar; ++i) ST[m + i] = -A[i][1];
build();
int index = 0;
long long int answer = -1e18;
for (int i = 0; i < n; ++i) {
while (index < p and M[index][0] < W[i][0]) {
vector<int> busca = {M[index][1] + 1, -1};
int pos = lower_bound(A.begin(), A.end(), busca) - A.begin();
add_value(1, M[index][2], m + pos);
++index;
}
answer = max(answer, ST[1] - W[i][1]);
}
cout << answer << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long v[10010];
long long get(long long x) { return x * (x - 1) / 2; }
int main() {
int n, k;
scanf("%d %d", &n, &k);
int big = 0, x;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
big = max(big, x);
v[x]++;
}
if (!k) {
long long ans = 0;
for (int i = 0; i <= big; i++) ans += get(v[i]);
printf("%lld\n", ans);
return 0;
}
long long ans = 0;
for (int i = 0; i <= big; i++) {
if (!v[i]) continue;
for (int j = i + 1; j <= big; j++) {
if (!v[j]) continue;
if (__builtin_popcount(i ^ j) == k) {
ans += v[i] * v[j];
}
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int t = 0;
register char v = getchar();
while (v < '0' || v > '9') v = getchar();
while (v >= '0' && v <= '9') {
t = (t << 3) + (t << 1) + (v ^ 48);
v = getchar();
}
return t;
}
int pos[150002], num;
char s[150002];
int main() {
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%s", s + 1);
n = strlen(s + 1);
num = 0;
for (register int i = 1; i <= n - 2; ++i) {
if (s[i] == 'o' && s[i + 1] == 'n' && s[i + 2] == 'e')
pos[++num] = i + 1, s[i] = 'a';
if (s[i] == 't' && s[i + 1] == 'w' && s[i + 2] == 'o')
if (s[i + 3] == 'o' && i <= n - 3)
pos[++num] = i + 1;
else
pos[++num] = i + 2, s[i + 2] = 'a';
}
printf("%d\n", num);
for (register int i = 1; i <= num; ++i) printf("%d ", pos[i]);
putchar('\n');
}
}
| 3 |
#include <bits/stdc++.h>
int n;
bool occupied[100001] = {false};
int e = 0;
std::vector<std::pair<std::string, int>> input;
std::vector<int> nums[2];
std::vector<int> spots[2];
std::vector<std::pair<std::string, int>> weird;
std::vector<std::string> ans;
bool isWeird(const std::string &name) {
if (name[0] < '1' || name[0] > '9') return true;
int num = name[0] - '0';
for (int i = 1; i < name.size(); ++i) {
if (name[i] < '0' || name[i] > '9') return true;
num = num * 10 + name[i] - '0';
}
return num > n;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::memset(occupied, false, sizeof occupied);
std::cin >> n;
input.resize(n);
ans.reserve(2 * n + 5);
for (int i = 0; i < n; ++i) {
std::cin >> input[i].first >> input[i].second;
e += input[i].second;
}
for (int i = 0; i < n; ++i) {
const std::string &name = input[i].first;
const int &type = input[i].second;
if (isWeird(name))
weird.push_back({name, type});
else {
int num = stoi(name);
occupied[num] = true;
if ((type == 0) != (num > e)) nums[type].push_back(num);
}
}
for (int i = 1; i <= n; ++i)
if (!occupied[i]) spots[i <= e].push_back(i);
if (weird.empty() && !nums[0].empty()) {
const std::string myName = "jg4k9d";
ans.push_back(std::to_string(nums[0].back()) + " " + myName);
weird.push_back({myName, 0});
spots[1].push_back(nums[0].back());
nums[0].pop_back();
}
while (!nums[0].empty() || !nums[1].empty()) {
for (int type : {0, 1})
if (!nums[type].empty() && !spots[type].empty()) {
ans.push_back(std::to_string(nums[type].back()) + " " +
std::to_string(spots[type].back()));
spots[!type].push_back(nums[type].back());
spots[type].pop_back();
nums[type].pop_back();
}
}
std::cout << (ans.size() + weird.size()) << '\n';
for (auto &&x : ans) std::cout << "move " << x << '\n';
for (auto &&x : weird) {
const int &type = x.second;
std::cout << "move " << x.first << " " << spots[type].back() << '\n';
spots[type].pop_back();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& x : v) in >> x;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
for (auto& x : v) out << x << ' ';
return out;
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& p) {
out << p.first << ' ' << p.second;
return out;
}
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend const Modular<U>& abs(const Modular<U>& v) {
return v;
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = (int)1e9 + 7;
using mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
const bool tests = 1;
vector<mint> fact, invFact;
void prepare(long long size) {
if (size <= 0) return;
fact.resize(size + 1);
invFact.resize(size + 1);
fact[0] = 1;
invFact[0] = 1;
for (mint i = 1; i != size + 1; i = i + 1) {
fact[(int)i] = fact[(int)i - 1] * i;
invFact[(int)i] = invFact[(int)i - 1] / i;
}
}
mint nCr(long long n, long long r) {
if (r < 0 || r > n) return 0;
mint ans = fact[n];
ans *= invFact[r];
ans *= invFact[n - r];
return ans;
}
void solve_case() {
long long n;
cin >> n;
long long k;
cin >> k;
if (k == 0) {
cout << "1\n";
return;
}
if (n & 1) {
mint temp = 0;
for (int i = 1; i <= n; i += 2) {
temp += nCr(n, i);
}
temp++;
cout << power(temp, k) << "\n";
} else {
mint ans = 0;
mint x = power((mint)2, n);
mint temp = power(x, k - 1);
mint aux = 0;
for (int i = 0; i < n; i += 2) {
aux += nCr(n, i);
}
mint ext = 1;
for (int i = 1; i <= k; i++) {
ans += (temp * ext);
temp /= x;
ext *= aux;
}
ans += ext;
cout << ans << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
prepare(2e5);
long long testcase = 1;
if (tests) cin >> testcase;
cout << fixed << setprecision(10);
for (long long test = 1; test <= testcase; test++) {
solve_case();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const double EPS = 0.0000000001, PI = 3.14159265358979323;
char a[1010][1010];
int b[1010], w[1010], d[2][1010];
int main() {
int n, m, x, y;
scanf("%d%d%d%d\n", &n, &m, &x, &y);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a[i][j] = getchar();
}
scanf("\n");
}
for (int j = 1; j <= m; ++j) {
int black = 0, white = 0;
for (int i = 1; i <= n; ++i) {
if (a[i][j] == '#') black++;
if (a[i][j] == '.') white++;
}
b[j] = b[j - 1] + black;
w[j] = w[j - 1] + white;
d[0][j] = d[1][j] = INF;
}
d[0][0] = d[1][0] = 0;
for (int i = 1; i <= m; ++i) {
for (int j = x; j <= y; ++j) {
if (i - j < 0) break;
d[0][i] = min(d[0][i], d[1][i - j] + (w[i] - w[i - j]));
d[1][i] = min(d[1][i], d[0][i - j] + (b[i] - b[i - j]));
}
}
cout << min(d[1][m], d[0][m]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, spo, cpo;
int dir, i, l;
char s[2], ss[10];
bool flag;
char cc[205];
while (scanf("%d%d%d", &n, &spo, &cpo) != EOF) {
scanf("%s%s", s, ss);
if (strcmp(ss, "head") == 0) {
if (cpo == 1) dir = n;
dir = 1;
} else {
if (cpo == n) dir = 1;
dir = n;
}
scanf("%s", cc);
l = strlen(cc);
flag = false;
for (i = 0; i < l; i++) {
if (cc[i] == '0') {
if (dir == 1) {
if (spo > cpo && spo < n)
spo++;
else if (spo < cpo && spo > 1)
spo--;
cpo--;
if (cpo == 1) dir = 0;
if (cpo == spo) {
flag = true;
break;
}
} else {
if (spo > cpo && spo < n)
spo++;
else if (spo < cpo && spo > 1)
spo--;
cpo++;
if (cpo == n) dir = 1;
if (cpo == spo) {
flag = true;
break;
}
}
} else {
spo = 0;
if (dir == 1) {
cpo--;
if (cpo == 1) dir = n;
spo = n;
if (cpo == spo) {
flag = true;
break;
}
} else {
cpo++;
if (cpo == n) dir = 1;
spo = 1;
if (cpo == spo) {
flag = true;
break;
}
}
}
}
if (flag == true)
printf("Controller %d\n", i + 1);
else
printf("Stowaway\n");
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
double d[100100][10];
ll val[100100][10],id[100100][10];
ll m[100100];
ll n,k;
int main(){
cin>>n>>k;
for(ll i=1;i<=n;++i)cin>>m[i];
for(ll i=0;i<n;++i){
for(ll j=0;j<10;++j){
d[i+1][j]=d[i][j];
val[i+1][j]=val[i][j];
id[i+1][j]=id[i][j];
}
for(ll j=0;j<10;++j){
if(d[i][j]==0)continue;
if(d[i][j]+log10(m[i+1])>d[i+1][(j*m[i+1])%10]){
d[i+1][(j*m[i+1])%10]=d[i][j]+log10(m[i+1]);
val[i+1][(j*m[i+1])%10]=j;
id[i+1][(j*m[i+1])%10]=i+1;
}
}
if(log10(m[i+1])>d[i+1][m[i+1]%10]){
d[i+1][m[i+1]%10]=log10(m[i+1]);
val[i+1][m[i+1]%10]=-1;
id[i+1][m[i+1]%10]=i+1;
}
}
/*
for(ll i=0;i<=n;++i){
cout<<i<<" "<<m[i]<<endl;
for(ll j=0;j<10;++j){
if(id[i][j])cout<<j<<" "<<id[i][j]<<" "<<val[i][j]<<" "<<d[i][j]<<endl;
}
cout<<endl;
}
*/
if(id[n][k]==0){
cout<<"-1"<<endl;
return 0;
}
vector<ll> res;
ll wh=n,x=k;
while(true){
ll t=wh;
wh=id[wh][x];
x=val[t][x];
//cout<<wh<<" "<<x<<endl;
res.push_back(m[wh]);
--wh;
if(x==-1)break;
}
cout<<res.size()<<endl;
for(ll i : res)cout<<i<<" ";cout<<endl;
return 0;
}
/*
6 4
4 11 8 2 1 13
*/
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 205;
const long long mod = 1000000007;
long long n;
string s;
long long dp[maxn][maxn][maxn][2];
long long len[maxn][2];
long long calc(string& prefix) {
long long sz = prefix.length();
for (long long i = 0; i < sz; i++) {
if (prefix.substr(i) == s.substr(0, sz - i)) {
return sz - i;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
if (s[0] == '(')
len[0][0] = 1;
else
len[0][1] = 1;
string prefix = "";
for (long long i = 0; i < (long long)s.length(); i++) {
prefix += s[i];
prefix += '(';
len[i + 1][0] = calc(prefix);
prefix.pop_back();
prefix += ')';
len[i + 1][1] = calc(prefix);
prefix.pop_back();
}
dp[0][0][0][0] = 1;
for (long long i = 0; i <= 2 * n; i++) {
for (long long j = 0; j <= n; j++) {
for (long long k = 0; k <= (long long)s.length(); k++) {
for (long long l = 0; l <= 1; l++) {
if (dp[i][j][k][l] == 0) continue;
if (j + 1 <= n) {
dp[i + 1][j + 1][len[k][0]]
[l | (len[k][0] == (long long)s.length())] += dp[i][j][k][l];
dp[i + 1][j + 1][len[k][0]]
[l | (len[k][0] == (long long)s.length())] %= mod;
}
if (j > 0) {
dp[i + 1][j - 1][len[k][1]]
[l | (len[k][1] == (long long)s.length())] += dp[i][j][k][l];
dp[i + 1][j - 1][len[k][1]]
[l | (len[k][1] == (long long)s.length())] %= mod;
}
}
}
}
}
long long ans = 0;
for (long long k = 0; k <= (long long)s.length(); k++) {
ans += dp[2 * n][0][k][1];
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline void deBugMode() {}
inline void optimizeIt() {
ios::sync_with_stdio(false);
cin.tie(NULL);
}
inline double ABS(const double &x) { return max(x, -x); }
const int NMax = 2e5 + 5;
const int LIM = 1e9;
const int MOD = 1000000007;
vector<pair<double, double> > ans;
inline void sear(pair<double, double> A, pair<double, double> B,
pair<double, double> C) {
double l = A.first + B.first;
double L = A.second + B.second;
double x = l / 2.0;
double y = L / 2.0;
double cx = 2.0 * x - C.first;
double cy = 2.0 * y - C.second;
pair<double, double> D = {cx, cy};
ans.push_back(D);
}
int main() {
deBugMode();
optimizeIt();
double a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
pair<double, double> A = {a, b};
pair<double, double> B = {c, d};
pair<double, double> C = {e, f};
sear(A, B, C);
sear(A, C, B);
sear(B, C, A);
cout << ans.size() << "\n";
for (auto it : ans) {
cout << it.first << " " << it.second << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long F[1000001], S[1001][1001];
long long modexp(long long base, long long expn) {
long long res = 1;
for (int i = (1 << 20); i >= 1; i >>= 1) {
res *= res;
res %= 1000000007;
if (i & expn) {
res *= base;
res %= 1000000007;
}
}
return res;
}
long long egcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long result = egcd(b, a % b, y, x);
y -= x * (a / b);
return result;
}
long long modinv(long long a) {
long long x, y;
egcd(a, 1000000007, x, y);
while (x < 0) x += 1000000007;
return (x % 1000000007);
}
long long choose(int num, int den1, int den2 = 0) {
long long den3 = num - den1 - den2;
long long res = F[num];
res *= modinv(F[den1]);
res %= 1000000007;
res *= modinv(F[den2]);
res %= 1000000007;
res *= modinv(F[den3]);
res %= 1000000007;
return res;
}
int main() {
F[0] = 1;
for (int N = 1; N <= 1000000; ++N) F[N] = (N * F[N - 1]) % 1000000007;
S[0][0] = 1;
for (int N = 1; N <= 1000; ++N) S[N][0] = S[0][N] = 0;
for (int N = 1; N <= 1000; ++N)
for (int K = 1; K <= 1000; ++K)
S[N][K] = (K * (S[N - 1][K - 1] + S[N - 1][K])) % 1000000007;
cin >> n >> m >> k;
int colMax = min(k, n);
long long A[1001];
for (int K = 0; K <= colMax; ++K) {
A[K] = 0;
for (int i = 0; K + i <= colMax; ++i) {
long long add = choose(k - K, i, i);
add *= (S[n][K + i] * S[n][K + i]) % 1000000007;
A[K] += add;
A[K] %= 1000000007;
}
}
long long res = 0;
if (m == 1)
res = modexp(k, n);
else
for (int K = 0; K <= colMax; ++K) {
res += ((A[K] * choose(k, K)) % 1000000007) * modexp(K, (m - 2) * n);
res %= 1000000007;
}
cout << res << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct dsu_save {
int u, v, szu, szv;
dsu_save() {}
dsu_save(int _u, int _szu, int _v, int _szv) {
u = _u, v = _v, szu = _szu, szv = _szv;
}
};
struct dsu_RB {
vector<int> p, sz;
int comp;
stack<dsu_save> st;
dsu_RB() {}
dsu_RB(int n) {
p.resize(n + 1), sz.resize(n + 1);
for (int i = 0; i <= n; ++i) p[i] = i, sz[i] = 1;
comp = n;
}
int find(int v) { return (v == p[v]) ? v : find(p[v]); }
bool join(int a, int b) {
a = find(a), b = find(b);
if (a == b) return 0;
comp--;
if (sz[b] > sz[a]) swap(a, b);
st.push(dsu_save(a, sz[a], b, sz[b]));
p[b] = a, sz[a] += sz[b];
return 1;
}
void RB() {
if (st.empty()) return;
dsu_save to = st.top();
st.pop();
comp++, p[to.u] = to.u, p[to.v] = to.v;
sz[to.u] = to.szu, sz[to.v] = to.szv;
}
};
struct query {
int u, v;
bool ok;
query(int _u, int _v) { u = _u, v = _v; }
};
int node[500010];
struct tree {
vector<vector<query> > Q;
dsu_RB dsu;
int T;
tree() {}
tree(int _T, int n) {
T = _T + 5, Q.resize(4 * T + 10);
dsu = dsu_RB(n);
}
void _add(int u, int s, int e, int l, int r, query& q) {
if (e < l or r < s) return;
if (l <= s and e <= r) {
Q[u].push_back(q);
return;
}
int mid = (s + e) >> 1;
_add(2 * u, s, mid, l, r, q);
_add(2 * u + 1, mid + 1, e, l, r, q);
}
void add(int u, int v, int l, int r) {
query q(u, v);
_add(1, 0, T - 1, l, r, q);
}
void dfs(int u, int s, int e, vector<int>& ans) {
for (auto& q : Q[u]) q.ok = dsu.join(q.u, q.v);
if (s == e) {
ans[s] = dsu.sz[dsu.find(node[s])];
} else {
int mid = (s + e) >> 1;
dfs(2 * u, s, mid, ans);
dfs(2 * u + 1, mid + 1, e, ans);
}
for (auto& q : Q[u])
if (q.ok) dsu.RB();
}
vector<int> solve() {
vector<int> ans(T);
dfs(1, 0, T - 1, ans);
return ans;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q, k;
cin >> n >> q >> k;
tree tree(q, n);
vector<pair<int, int> > G[q];
map<pair<int, int>, int> mp, in_time;
int t = 1, day = 0;
vector<int> to;
for (int i = 0; i < q; ++i) {
int type;
cin >> type;
if (type == 3) {
day++;
if (day >= k) {
for (auto p : G[day - k]) {
mp[p]--;
if (!mp[p]) {
tree.add(p.first, p.second, in_time[p], t);
mp.erase(mp.find(p));
in_time.erase(in_time.find(p));
}
}
}
}
if (type == 2) {
int u;
cin >> u;
node[t] = u, to.push_back(t);
}
if (type == 1) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
query q(u, v);
pair<int, int> p = {u, v};
G[day].push_back(p);
mp[p]++;
if (!in_time[p]) in_time[p] = t;
}
t++;
}
for (auto p : mp)
tree.add(p.first.first, p.first.second, in_time[p.first], t);
vector<int> ans = tree.solve();
for (int i : to) cout << ans[i] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline bool is_open(char c) {
return c == '<' || c == '{' || c == '[' || c == '(';
}
inline bool is_match(char o, char c) {
return (o == '<' && c == '>') || (o == '{' && c == '}') ||
(o == '[' && c == ']') || (o == '(' && c == ')');
}
int main() {
string s;
cin >> s;
stack<char> st;
bool fail = false;
int ans = 0;
for (int i = 0; i < s.size(); i++) {
if (is_open(s[i]))
st.push(s[i]);
else {
if (st.size() == 0) {
fail = true;
break;
}
if (!is_match(st.top(), s[i])) ans++;
st.pop();
}
}
if (st.size() != 0) fail = true;
if (fail)
cout << "Impossible\n";
else
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5e3 + 10;
const int MOD = 1e9 + 7;
int n;
char s[MAX_N];
int dp[26][MAX_N];
int sum[MAX_N];
int cb[MAX_N][MAX_N];
int main() {
int i, l, j;
scanf("%d", &n);
scanf("%s", s + 1);
cb[0][0] = 1;
for (i = 1; i <= n; i++) {
cb[i][0] = 1;
for (j = 1; j <= i; j++) {
cb[i][j] = cb[i - 1][j - 1] + cb[i - 1][j];
if (cb[i][j] >= MOD) cb[i][j] -= MOD;
}
}
s[i] = '#';
for (i = 1; i <= n; i++) {
if (s[i] == s[i - 1]) continue;
if (!dp[s[i] - 'a'][1]) {
dp[s[i] - 'a'][1] = 1;
sum[1]++;
}
for (l = 2; l <= n; l++) {
sum[l] -= dp[s[i] - 'a'][l];
if (sum[l] < 0) sum[l] += MOD;
dp[s[i] - 'a'][l] = sum[l - 1] - dp[s[i] - 'a'][l - 1];
if (dp[s[i] - 'a'][l] < 0) dp[s[i] - 'a'][l] += MOD;
sum[l] += dp[s[i] - 'a'][l];
if (sum[l] >= MOD) sum[l] -= MOD;
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
ans += (long long)((long long)sum[i] * (long long)cb[n - 1][i - 1]) % MOD;
if (ans >= MOD) ans -= MOD;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, m, c, w = 0, g = 0;
cin >> x;
int *arr = new int[x];
srand(time(NULL));
for (int i = 0; i < x; i++) {
cin >> m >> c;
if (m > c)
w++;
else if (c > m)
g++;
}
if (w == g)
cout << "Friendship is magic!^^" << endl;
else if (g > w)
cout << "Chris" << endl;
else if (w > g)
cout << "Mishka" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 7;
const int M = 1e4 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
int f[N][N], a[N], n, dp[N][N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) f[i][i] = a[i], dp[i][i] = a[i];
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
f[i][j] = f[i + 1][j] ^ f[i][j - 1];
}
}
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
dp[i][j] = max(dp[i][j], f[i + 1][j] ^ f[i][j - 1]);
}
}
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", dp[l][r]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0 && a == 0) return 1;
if (b == 0) return a;
if (a == 0) return b;
return gcd(b, a % b);
}
void reduce(long long &a, long long &b) {
long long g = gcd(a, b);
if (g == 0) return;
a /= g;
b /= g;
}
bool isless(long long p, long long q, long long x) {
if (q > 0)
return p <= (q * x);
else
return p >= (q * x);
}
bool isgreat(long long p, long long q, long long x) {
if (q > 0) return p >= (q * x);
return p <= (q * x);
}
int main() {
long long h1, k1;
cin >> h1 >> k1;
long long h2, k2;
cin >> h2 >> k2;
int n;
cin >> n;
long long a, b, c;
b = h1 - h2;
a = k2 - k1;
reduce(a, b);
c = -(a * h1 + b * k1);
int cnt = 0;
if (h1 > h2) swap(h1, h2);
if (k1 > k2) swap(k1, k2);
while (n--) {
long long a1, b1, c1;
cin >> a1 >> b1 >> c1;
long long p1 = (c1 * b - c * b1);
long long p2 = (a1 * c - a * c1);
long long q2 = (a * b1 - a1 * b);
long long q1 = q2;
reduce(p1, q1);
reduce(p2, q2);
if (q1 && isless(p1, q1, h2) && isgreat(p1, q1, h1) && isless(p2, q2, k2) &&
isgreat(p2, q2, k1)) {
cnt++;
}
}
cout << cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y);
long long mpower(long long x, long long y, long long p);
long long modInv(long long a, long long m);
long long gcdExtended(long long a, long long b, long long *x, long long *y);
bool isPrime(long long n);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, i, j, k, l, h, p, q, r, x, y, z, a, b, c, d, f, n, m, nn, mm,
M = 1000000007;
char ch, ch2, ch3;
string s, s1, s2, s3;
cin >> t;
while (t--) {
vector<long long> v, w;
set<long long> S, SS;
cin >> nn >> mm;
cin >> x >> y;
cin >> a >> b;
z = 0;
for (i = 0; i <= x; i++) {
n = nn;
m = mm;
l = x;
r = y;
l -= i;
c = i * a;
if (c > n) {
break;
}
d = n - c;
p = min(r, d / b);
r -= p;
q = i + p;
if (a < b) {
p = min(l, m / a);
q += p;
m -= p * a;
q += min(r, m / b);
} else {
p = min(r, m / b);
q += p;
m -= p * b;
q += min(l, m / a);
}
z = max(z, q);
}
cout << z << "\n";
}
return 0;
}
long long modInv(long long a, long long m) {
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
long long res = (x % m + m) % m;
return res;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long mpower(long long x, long long y, long long p) {
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;
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
long long p = sqrt(n);
for (int i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1 << 30;
const long long LINF = 1LL << 62;
const double EPS = 1e-9;
const long long MOD = 1e9 + 7;
int main() {
long long n = 0;
cin >> n;
cout << n / 2520LL << ("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
char s[2100][2100];
vector<int> adj[2100], rev[2100];
int arr[2100];
vector<int> vec[2100];
int root[2100];
int find_root(int u) {
if (root[u] == u) return u;
return root[u] = find_root(root[u]);
}
void merge(int u, int v) {
if (find_root(u) == find_root(v)) return;
u = root[u];
vector<int> tmp = vec[root[v]];
vec[root[v]].clear();
v = root[v], root[v] = u;
for (int p : tmp) vec[u].push_back(p);
}
int id[2100], flag[2100];
int dfs(int u) {
flag[u] = 1;
for (int v : adj[u]) {
if (flag[v] == 1) return 1;
if (flag[v]) continue;
if (dfs(v)) return 1;
}
flag[u] = -1;
return 0;
}
int val[2100], vst[2100], dig[2100];
int a[2100], b[2100];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (int i = 1; i <= n; i++) {
root[i] = i;
vec[i].push_back(i);
}
for (int i = 1; i <= m; i++) {
root[i + n] = i + n;
vec[i + n].push_back(i + n);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == '=') merge(i, j + n);
}
}
int nn = 0;
for (int i = 1; i <= n + m; i++)
if (find_root(i) == i) arr[++nn] = i, id[i] = nn;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int u = id[root[i]];
int v = id[root[j + n]];
if (s[i][j] == '>') {
adj[v].push_back(u);
rev[u].push_back(v);
}
if (s[i][j] == '<') {
adj[u].push_back(v);
rev[v].push_back(u);
}
}
}
for (int i = 1; i <= nn; i++) {
if (flag[i]) continue;
int ok = dfs(i);
if (ok) {
puts("No");
return 0;
}
}
puts("Yes");
int tot = nn + 10;
queue<int> q;
for (int i = 1; i <= nn; i++) {
dig[i] = adj[i].size();
if (dig[i] == 0) {
q.push(i);
val[i] = tot;
vst[i] = 1;
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : rev[u]) {
dig[v]--;
if (dig[v] == 0) {
val[v] = val[u] - 1;
q.push(v);
}
}
}
int mn = 1e6;
for (int i = 1; i <= nn; i++) {
int u = arr[i];
mn = min(mn, val[i]);
for (int v : vec[u]) {
if (v <= n)
a[v] = val[i];
else {
b[v - n] = val[i];
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", a[i] - mn + 1);
printf("\n");
for (int i = 1; i <= m; i++) mn = min(mn, b[i]);
for (int i = 1; i <= m; i++) printf("%d ", b[i] - mn + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> tasks[128];
int main() {
int N, T;
cin >> N >> T;
for (int i = 0; i < N; i++) {
int t, q;
cin >> t >> q;
tasks[t].push_back(q);
}
for (int i = 1; i < T; i++) {
sort(tasks[i].begin(), tasks[i].end());
while (tasks[i].size() >= 2) {
int x = tasks[i].back();
tasks[i].pop_back();
x += tasks[i].back();
tasks[i].pop_back();
tasks[i + 1].push_back(x);
}
if (tasks[i].size() > 0) {
tasks[i + 1].push_back(tasks[i].back());
tasks[i].pop_back();
}
}
sort(tasks[T].rbegin(), tasks[T].rend());
cout << tasks[T][0] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, s1, s2;
int a[100010];
bool test(int d) {
int l = a[n] - d, r = a[n] + d;
for (int i = n - 1; i >= 1; i--) {
if (a[i] >= l && a[i] <= r)
l = a[i] - d, r = a[i] + d;
else {
l = max(l, a[i] - d);
r = min(r, a[i] + d);
}
}
return ((s1 >= l && s1 <= r) || (s2 >= l && s2 <= r));
}
int main() {
scanf("%d%d%d", &n, &s1, &s2);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (s1 > s2) swap(s1, s2);
int L = s2 - s1, R = 1e9;
while (L <= R) {
int mid = (L + R) / 2;
if (test(mid))
R = mid - 1;
else
L = mid + 1;
}
printf("%d", L);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long v[200005];
for (int i = 0; i < n; i++) scanf("%lld", &v[i]);
sort(v, v + n);
long long melhor = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && v[i] == v[i - 1]) continue;
long long base = v[i];
long long cont = 0;
int j = i;
while (1) {
while (base + v[i] <= v[j]) base += v[i];
int pos = lower_bound(v + j, v + n, base + v[i]) - (v + j) + j;
cont += (pos - j) * base;
base += v[i];
j = pos;
if (v[n - 1] < base + v[i]) {
cont += (n - j) * base;
break;
}
}
if (cont > melhor) melhor = cont;
}
printf("%lld\n", melhor);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long long int bini = 0, bnew = 0, ans = 0, l;
cin >> s;
l = s.length();
while (l >= 0) {
if (s[l] == 'b') {
bini = (bini % 1000000007 + 1 % 1000000007) % 1000000007;
} else if (s[l] == 'a') {
ans = (ans % 1000000007 + bini % 1000000007) % 1000000007;
bini = ((bini % 1000000007) * 2 % 1000000007) % 1000000007;
}
l--;
}
ans = ans % 1000000007;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t[5010][10010];
void add(int x, int y, int v) {
for (int Y = y; x <= 5000; x += (x & -x))
for (y = Y; y <= 10000; y += (y & -y)) t[x][y] += v;
}
void cle(int x, int y) {
for (int Y = y; x <= 5000; x += (x & -x))
for (y = Y; y <= 10000; y += (y & -y)) t[x][y] = 0;
}
int query(int x, int y) {
int ans = 0;
for (int Y = y; x; x -= (x & -x))
for (y = Y; y; y -= (y & -y)) ans += t[x][y];
return ans;
}
int ans[100010], n, Q, ord;
struct node {
int x, y, dir, len;
} q[100010];
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d", &ord);
if (ord == 1)
scanf("%d%d%d%d", &q[i].dir, &q[i].x, &q[i].y, &q[i].len);
else
scanf("%d%d", &q[i].x, &q[i].y), q[i].dir = 0;
}
for (int i = 1; i <= Q; i++) {
if (!q[i].dir)
ans[i] += query(q[i].x, q[i].x + q[i].y);
else if (q[i].dir == 1)
add(q[i].x, q[i].x + q[i].y + q[i].len + 1, -1),
add(q[i].x + q[i].len + 1, q[i].x + q[i].y + q[i].len + 1, 1);
else if (q[i].dir == 4)
add(q[i].x - q[i].len, q[i].x + q[i].y - q[i].len, 1),
add(q[i].x + 1, q[i].x + q[i].y - q[i].len, -1);
}
for (int i = 1; i <= Q; i++) {
if (q[i].dir == 1)
cle(q[i].x, q[i].x + q[i].y + q[i].len + 1),
cle(q[i].x + q[i].len + 1, q[i].x + q[i].y + q[i].len + 1);
else if (q[i].dir == 4)
cle(q[i].x - q[i].len, q[i].x + q[i].y - q[i].len),
cle(q[i].x + 1, q[i].x + q[i].y - q[i].len);
}
for (int i = 1; i <= Q; i++) {
if (!q[i].dir)
ans[i] += query(q[i].x, q[i].y - q[i].x + 5000);
else if (q[i].dir == 2)
add(q[i].x, q[i].y - q[i].x - q[i].len + 5000, 1),
add(q[i].x + q[i].len + 1, q[i].y - q[i].x - q[i].len + 5000, -1);
else if (q[i].dir == 3)
add(q[i].x - q[i].len, q[i].y - q[i].x + q[i].len + 5001, -1),
add(q[i].x + 1, q[i].y - q[i].x + q[i].len + 5001, 1);
}
for (int i = 1; i <= Q; i++) {
if (q[i].dir == 2)
cle(q[i].x, q[i].y - q[i].x - q[i].len + 5000),
cle(q[i].x + q[i].len + 1, q[i].y - q[i].x - q[i].len + 5000);
else if (q[i].dir == 3)
cle(q[i].x - q[i].len, q[i].y - q[i].x + q[i].len + 5001),
cle(q[i].x + 1, q[i].y - q[i].x + q[i].len + 5001);
}
for (int i = 1; i <= Q; i++) {
if (!q[i].dir)
ans[i] += query(q[i].x, q[i].y);
else if (q[i].dir == 1)
add(q[i].x, q[i].y, 1), add(q[i].x + q[i].len + 1, q[i].y, -1);
else if (q[i].dir == 2)
add(q[i].x, q[i].y + 1, -1), add(q[i].x + q[i].len + 1, q[i].y + 1, 1);
else if (q[i].dir == 3)
add(q[i].x - q[i].len, q[i].y, 1), add(q[i].x + 1, q[i].y, -1);
else if (q[i].dir == 4)
add(q[i].x - q[i].len, q[i].y + 1, -1), add(q[i].x + 1, q[i].y + 1, 1);
}
for (int i = 1; i <= Q; i++)
if (!q[i].dir) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 15;
const int inf = 1e9;
const int md = 1e9 + 7;
const int shift = 1 << 17;
int n, m;
vector<vector<int> > g;
set<pair<int, int> > br;
int timer;
int tin[maxn], fup[maxn];
int used[maxn];
void dfs(int v, int p = -1) {
used[v] = 1;
tin[v] = fup[v] = timer++;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == p) continue;
if (used[to])
fup[v] = min(fup[v], tin[to]);
else {
dfs(to, v);
fup[v] = min(fup[v], fup[to]);
if (fup[to] > tin[v]) {
br.insert(make_pair(to, v));
br.insert(make_pair(v, to));
}
}
}
}
int color[maxn];
int first[maxn];
int d[maxn];
vector<int> eu;
int z[shift * 2];
void dfs2(int v, int c, int len, int p = -1) {
used[v] = 1;
color[v] = c;
d[v] = len;
eu.push_back(v);
if (first[v] == -1) first[v] = eu.size() - 1;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == p) continue;
if (used[to]) continue;
if (br.find(make_pair(v, to)) != br.end())
dfs2(to, c + 1, len + 1, v);
else
dfs2(to, c, len, v);
eu.push_back(v);
}
}
void build() {
for (int i = 0; i < eu.size(); ++i) z[i + shift] = eu[i];
for (int i = eu.size(); i < shift; ++i) z[i + shift] = n + 1;
for (int i = shift - 1; i > 0; --i)
if (d[z[i * 2]] < d[z[i * 2 + 1]])
z[i] = z[i * 2];
else
z[i] = z[i * 2 + 1];
}
int get(int v, int tl, int tr, int l, int r) {
if (l > r) return n + 1;
if (l == tl && r == tr) return z[v];
int tm = (tl + tr) / 2;
int ans1 = get(v * 2, tl, tm, l, min(r, tm));
int ans2 = get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
return d[ans1] < d[ans2] ? ans1 : ans2;
}
int main() {
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; ++i) {
int v, u;
cin >> v >> u;
--v, --u;
g[v].push_back(u);
g[u].push_back(v);
}
dfs(0);
memset(used, 0, sizeof(used));
memset(first, -1, sizeof(first));
dfs2(0, 0, 0);
d[n + 1] = inf;
build();
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
int s, l;
cin >> s >> l;
--s, --l;
int L = first[s];
int R = first[l];
if (L > R) swap(L, R);
int lca = get(1, 0, shift - 1, L, R);
cout << d[s] + d[l] - 2 * d[lca] << endl;
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.