solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c, d;
int main() {
for (cin >> t; t; t--) {
cin >> a >> b >> c >> d;
cout << b << " " << c << " " << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int average;
long long sum = 0;
int max = 0, n, temp, ave;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &temp);
if (temp > max) max = temp;
sum += temp;
}
if (sum % (n - 1) == 0)
average = sum / (n - 1);
else
average = sum / (n - 1) + 1;
cout << ((average) > (max) ? (average) : (max));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10000];
int main() {
bool f = false;
int n, temp = 0;
cin >> n;
for (int i = 0; i < n; cin >> a[i], i++)
;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
ans++;
ans += temp;
temp = 0;
f = true;
continue;
}
if (f) {
temp = 1;
f = false;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
long long lcm(long long a, long long b) { return (a * 1LL * b) / gcd(a, b); }
const long long N = 1e5 + 10;
long long n, m, a[N], vis[N][2];
vector<long long> g[N][2];
void bfs(long long id, long long k) {
queue<long long> q;
for (long long i = 1; i <= n; i++)
if (a[i] == id) vis[i][k] = 1, q.push(i);
while (q.size()) {
long long u = q.front();
q.pop();
for (long long to : g[u][k])
if (!vis[to][k]) {
vis[to][k] = 1;
if (a[to] != 1) q.push(to);
}
}
}
void solve() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1, x, y; i <= m; i++) {
cin >> x >> y;
g[x][0].push_back(y);
g[y][1].push_back(x);
}
bfs(1, 0), bfs(2, 1);
for (long long i = 1; i <= n; i++) {
cout << (vis[i][0] && vis[i][1]) << "\n";
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
c_p_c();
long long tc = 1;
for (long long t = 1; t <= tc; t++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int MOD = 998244353;
int n, k;
int v[MAXN];
long long int dp[MAXN][MAXN];
long long int sDp[MAXN][MAXN];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
sort(v + 1, v + n + 1);
int maxBeauty = (v[n] - v[1]) / (k - 1);
long long int ans = 0;
for (int i = 1; i <= n; i++) sDp[i][1] = i;
for (int beauty = 1; beauty <= maxBeauty; beauty++) {
int p = 1;
for (int i = 1; i <= n; i++) {
while (v[i] - v[p] >= beauty) p++;
for (int j = 2; j <= k; j++) {
dp[i][j] = sDp[p - 1][j - 1];
sDp[i][j] = sDp[i - 1][j] + dp[i][j];
if (sDp[i][j] >= MOD) sDp[i][j] -= MOD;
}
}
ans += sDp[n][k];
if (ans >= MOD) ans -= MOD;
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, k, a, b, c, d, x, y, left, right, up, down;
cin >> t;
while (t--) {
cin >> n;
left = down = -1e5;
right = up = 1e5;
while (n--) {
cin >> x >> y >> a >> b >> c >> d;
if (a == 0) left = max(left, x);
if (b == 0) up = min(up, y);
if (c == 0) right = min(right, x);
if (d == 0) down = max(down, y);
}
if (left <= right && down <= up)
cout << "1 " << right << " " << down << "\n";
else
cout << "0\n";
}
}
| 3 |
#include <bits/stdc++.h>
int a, i, x, y, val[1000005], ans[1000005], ch[1000005], type[1000005],
g[1000005][3];
char s[10];
void dfs(int p) {
if (type[p] == 1) {
dfs(g[p][0]);
dfs(g[p][1]);
if (val[g[p][0]] == 1 && val[g[p][1]] == 1) {
ch[g[p][0]] = 1;
ch[g[p][1]] = 1;
val[p] = 1;
} else if (val[g[p][0]] == 0 && val[g[p][1]] == 1) {
ch[g[p][0]] = 1;
val[p] = 0;
} else if (val[g[p][0]] == 1 && val[g[p][1]] == 0) {
ch[g[p][1]] = 1;
val[p] = 0;
} else {
val[p] = 0;
}
} else if (type[p] == 2) {
dfs(g[p][0]);
dfs(g[p][1]);
if (val[g[p][0]] == 0 && val[g[p][1]] == 0) {
ch[g[p][0]] = 1;
ch[g[p][1]] = 1;
val[p] = 0;
} else if (val[g[p][0]] == 0 && val[g[p][1]] == 1) {
ch[g[p][1]] = 1;
val[p] = 1;
} else if (val[g[p][0]] == 1 && val[g[p][1]] == 0) {
ch[g[p][0]] = 1;
val[p] = 1;
} else {
val[p] = 1;
}
} else if (type[p] == 3) {
dfs(g[p][0]);
dfs(g[p][1]);
val[p] = val[g[p][0]] ^ val[g[p][1]];
ch[g[p][0]] = 1;
ch[g[p][1]] = 1;
} else if (type[p] == 4) {
dfs(g[p][0]);
val[p] = !val[g[p][0]];
ch[g[p][0]] = 1;
} else if (type[p] == 5) {
val[p] = g[p][0];
}
return;
}
void dfs2(int p) {
if (type[p] < 4) {
if (ch[g[p][0]] == 1) {
ans[g[p][0]] = ans[p];
} else
ans[g[p][0]] = 0;
if (ch[g[p][1]] == 1) {
ans[g[p][1]] = ans[p];
} else
ans[g[p][1]] = 0;
dfs2(g[p][0]);
dfs2(g[p][1]);
} else if (type[p] == 4) {
ans[g[p][0]] = ans[p];
dfs2(g[p][0]);
}
}
int main(void) {
scanf("%d", &a);
for (i = 1; i <= a; i++) {
scanf("%s", s);
if (s[0] == 'A') {
scanf("%d%d", &x, &y);
g[i][0] = x;
g[i][1] = y;
type[i] = 1;
} else if (s[0] == 'O') {
scanf("%d%d", &x, &y);
g[i][0] = x;
g[i][1] = y;
type[i] = 2;
} else if (s[0] == 'X') {
scanf("%d%d", &x, &y);
g[i][0] = x;
g[i][1] = y;
type[i] = 3;
} else if (s[0] == 'N') {
scanf("%d", &x);
g[i][0] = x;
type[i] = 4;
} else if (s[0] == 'I') {
scanf("%d", &x);
g[i][0] = x;
type[i] = 5;
}
}
dfs(1);
ans[1] = 1;
dfs2(1);
for (i = 1; i <= a; i++) {
if (type[i] == 5) {
if (ans[i] == 1)
printf("%d", 1 - val[1]);
else
printf("%d", val[1]);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, b, ans1 = 0, ans0 = 0;
cin >> n >> k >> x;
for (int i = 0; i < n - k; i++) {
b = 0;
cin >> b;
ans1 += b;
}
for (int i = 0; i < k; i++) {
b = 0;
cin >> b;
ans0 += b;
}
if (ans0 < x * k) {
cout << ans1 + ans0;
} else {
cout << ans1 + (k * x);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct wnr {
char val;
char pos;
};
void solve() {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int cnt1 = 0;
long long int cnt2 = 0;
long long int cnt3 = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
cnt1++;
} else if (a[i] == 2) {
cnt2++;
} else if (a[i] == 3) {
cnt3++;
}
}
int b[3];
b[0] = cnt1;
b[1] = cnt2;
b[2] = cnt3;
sort(b, b + 3);
cout << b[0] + b[1] << endl;
}
int main() {
{ solve(); }
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int dem = 0, n = s.length(), r = 0, flag = 0;
for (int i = 0; i < n; i++) {
if (dem == 1 && s[i] == 'C') {
r = i + 1;
flag = 1;
break;
}
if (dem == 0 && s[i] < 58) {
dem++;
r = i;
}
}
if (flag) {
int h = 0;
for (int i = r; i < n; i++) h = h * 10 + (s[i] - '0');
string ans = "";
while (h != 0) {
if (h % 26 == 0)
ans = 'Z' + ans, h -= 26;
else
ans = char((h % 26) - 1 + 'A') + ans, h -= h % 26;
h /= 26;
}
cout << ans;
for (int i = 1; i < r - 1; i++) cout << s[i];
cout << "\n";
} else {
int a = 0, dem = 1;
for (int i = r - 1; i >= 0; i--) {
a += (s[i] - 'A' + 1) * pow(26, (r - i - 1));
}
cout << "R";
for (int i = r; i < n; i++) cout << s[i];
cout << "C" << a << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 1005;
int n, m, dp[2][50 * maxn], res[maxn];
int main() {
n = 1000;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
memset(dp[i & 1], 0, sizeof(dp[i & 1]));
for (int j = 1; j <= 50 * n; j++) {
if (j >= 1) {
dp[i & 1][j] |= dp[~i & 1][j - 1];
}
if (j >= 5) {
dp[i & 1][j] |= dp[~i & 1][j - 5];
}
if (j >= 10) {
dp[i & 1][j] |= dp[~i & 1][j - 10];
}
if (j >= 50) {
dp[i & 1][j] |= dp[~i & 1][j - 50];
}
res[i] += dp[i & 1][j];
}
}
scanf("%d", &m);
if (m <= n) {
printf("%d\n", res[m]);
} else {
printf("%I64d\n", res[n] + 49ll * (m - n));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {}
int main(void) {
cin.tie(0), cout.tie(0)->sync_with_stdio(0);
long long m, b;
cin >> m >> b;
long long ans = 0;
for (long long i = 0;; i++) {
long long x = m * i;
long long y = b - i;
if (y < 0) {
break;
}
long long temp = (x + 1) * (y + 1) * (x + y) / 2;
if (temp > ans) {
ans = temp;
}
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> c[N];
vector<int> s[20][N];
int dp[20][N];
int h[N];
vector<int> v[N];
int sh(int x, int y) {
for (int i = 17; i + 1; --i)
if (y & (1 << i)) x = dp[i][x];
return x;
}
int ac(int x, int y) {
if (h[x] > h[y])
x = sh(x, h[x] - h[y]);
else
y = sh(y, h[y] - h[x]);
for (int i = 17; i + 1 && x != y; --i)
if (dp[i][x] != dp[i][y]) x = dp[i][x], y = dp[i][y];
if (x == y)
return x;
else
return dp[0][x];
}
void dfs(int prec, int node) {
h[node] = h[prec] + 1;
dp[0][node] = prec;
s[0][node] = c[node];
for (auto it : v[node])
if (it != prec) dfs(node, it);
}
vector<int> get(vector<int> a, vector<int> b) {
if (a.empty()) return b;
if (b.empty()) return a;
int *p = new int[a.size() + b.size()];
merge(a.begin(), a.end(), b.begin(), b.end(), p);
vector<int> as;
for (int *r = p, cn = 1; cn <= a.size() + b.size() && cn <= 10; ++r, ++cn)
as.push_back(*r);
while (as.size() && !(*as.begin())) as.erase(as.begin());
return as;
}
int main(void) {
int n, m, q;
scanf("%d%d%d\n", &n, &m, &q);
int a, b;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= m; ++i) {
scanf("%d", &a);
c[a].push_back(i);
}
for (int i = 1; i <= n; ++i) {
sort(c[i].begin(), c[i].end());
while (c[i].size() > 10) c[i].erase(c[i].end() - 1);
}
dfs(0, 1);
for (int i = 1; i < 18; ++i)
for (int j = 1; j <= n; ++j) {
dp[i][j] = dp[i - 1][dp[i - 1][j]];
s[i][j] = get(s[i - 1][j], s[i - 1][dp[i - 1][j]]);
}
while (q--) {
int a, b, mx;
scanf("%d%d%d", &a, &b, &mx);
int anc = ac(a, b);
int disa = h[a] - h[anc];
int disb = h[b] - h[anc];
vector<int> ans;
for (int i = 17; i + 1; --i)
if ((1 << i) & disa) {
ans = get(ans, s[i][a]);
a = dp[i][a];
while (ans.size() > mx) ans.erase(ans.end() - 1);
}
for (int i = 17; i + 1; --i)
if ((1 << i) & disb) {
ans = get(ans, s[i][b]);
b = dp[i][b];
while (ans.size() > mx) ans.erase(ans.end() - 1);
}
ans = get(ans, c[anc]);
while (ans.size() > mx) ans.erase(ans.end() - 1);
printf("%d ", ans.size());
for (auto it : ans) printf("%d ", it);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int size = 1e5 + 5;
long long arr[size], cnt, n, ans = 0LL;
int main() {
cin >> n;
if (n % 3 == 0) {
n /= 3;
for (long long j = 1LL; j * j <= n; j++) {
if (n % j == 0) arr[cnt++] = j;
}
for (long long i = 0LL; i < cnt; i++) {
for (long long j = 0LL; j < cnt; j++) {
long long a = arr[i], b = arr[j], c = n / a / b;
if (n % (a * b) == 0 && (a + b + c) % 2 == 0 && a + b > c &&
a + c > b && b + c > a)
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<long long> nums;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
nums.push_back(a);
}
sort(nums.begin(), nums.end(), greater<int>());
int maxAppearance = 0;
while (n / pow(4, maxAppearance) > 1) {
maxAppearance++;
}
maxAppearance++;
long long ans = 0;
int powCount = 0;
int numLevel = pow(4, 0);
for (int i = 0; i < n; i++) {
if (numLevel <= 0) {
powCount++;
maxAppearance--;
numLevel = pow(4, powCount) - pow(4, powCount - 1);
}
ans += maxAppearance * nums[i];
numLevel--;
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
#define all(A) begin(A), end(A)
#define rall(A) rbegin(A), rend(A)
#define sz(A) int(A.size())
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef vector <int> vi;
typedef vector <ll> vll;
typedef vector <pii> vpii;
typedef vector <pll> vpll;
// Based on tourist template: https://codeforces.com/contest/1423/submission/94770723
int mod = 1e9 + 7;
class Mint {
private:
int value;
template <typename T>
static 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;
}
public:
constexpr Mint (): value(0) {}
template <class U>
Mint (const U& x) { value = normalize(x); }
template <class U>
static int normalize (const U& x) {
int ret;
if (-mod <= x and x < mod) ret = x;
else ret = x % mod;
if (ret < 0) ret += mod;
return ret;
}
static void set_mod (int new_mod) { mod = new_mod; }
const int& operator ()() const { return value; }
Mint& operator += (const Mint& other) { if ((value += other.value) >= mod) value -= mod; return *this; }
Mint& operator -= (const Mint& other) { if ((value -= other.value) < 0) value += mod; return *this; }
Mint& operator ++ () { return *this += 1; }
Mint& operator -- () { return *this -= 1; }
Mint operator ++ (int) { Mint ret(*this); *this += 1; return ret; }
Mint operator -- (int) { Mint ret(*this); *this -= 1; return ret; }
Mint operator - () const { return Mint(-value); }
Mint& operator *= (const Mint& other) { value = normalize(1LL * value * other.value); return *this; }
Mint& operator /= (const Mint& other) { return *this *= Mint(inverse(other.value, mod)); }
friend bool operator == (const Mint& lhs, const Mint& rhs) { return lhs.value == rhs.value; }
template <class U>
friend bool operator == (const Mint& lhs, U rhs) { return lhs == Mint(rhs); }
template <class U>
friend bool operator == (U lhs, const Mint& rhs) { return Mint(lhs) == rhs; }
friend bool operator != (const Mint& lhs, const Mint& rhs) { return not (lhs == rhs); }
template <class U>
friend bool operator != (const Mint& lhs, U rhs) { return not (lhs == rhs); }
template <class U>
friend bool operator != (U lhs, const Mint& rhs) { return not (lhs == rhs); }
friend bool operator < (const Mint& lhs, const Mint& rhs) { return lhs.value < rhs.value; }
friend Mint operator + (const Mint& lhs, const Mint& rhs) { return Mint(lhs) += rhs; }
template <class U>
friend Mint operator + (const Mint& lhs, U rhs) { return Mint(lhs) += rhs; }
template <class U>
friend Mint operator + (U lhs, const Mint& rhs) { return Mint(lhs) += rhs; }
friend Mint operator - (const Mint& lhs, const Mint& rhs) { return Mint(lhs) -= rhs; }
template <class U>
friend Mint operator - (const Mint& lhs, U rhs) { return Mint(lhs) -= rhs; }
template <class U>
friend Mint operator - (U lhs, const Mint& rhs) { return Mint(lhs) -= rhs; }
friend Mint operator * (const Mint& lhs, const Mint& rhs) { return Mint(lhs) *= rhs; }
template <class U>
friend Mint operator * (const Mint& lhs, U rhs) { return Mint(lhs) *= rhs; }
template <class U>
friend Mint operator * (U lhs, const Mint& rhs) { return Mint(lhs) *= rhs; }
friend Mint operator / (const Mint& lhs, const Mint& rhs) { return Mint(lhs) /= rhs; }
template <class U>
friend Mint operator / (const Mint& lhs, U rhs) { return Mint(lhs) /= rhs; }
template <class U>
friend Mint operator / (U lhs, const Mint& rhs) { return Mint(lhs) /= rhs; }
friend Mint power (Mint a, ll b) {
assert(b >= 0);
Mint ret = 1;
while (b != 0) {
if (b & 1) ret *= a;
a *= a;
b >>= 1;
}
return ret;
}
friend std::ostream& operator << (std::ostream& stream, const Mint& number) { return stream << number(); }
friend std::istream& operator >> (std::istream& stream, Mint& number) {
ll x;
stream >> x;
number.value = Mint::normalize(x);
return stream;
}
};
// Modular Number Theory
struct MNT {
vector <Mint> fact;
vector <Mint> inv_fact;
void preprocess_factorial (int n) {
fact.resize(n + 1);
inv_fact.resize(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = fact[i - 1] * i;
ll z = 1;
inv_fact[n] = 1 / fact[n];
for (int i = n - 1; i >= 0; i--) inv_fact[i] = inv_fact[i + 1] * (i + 1);
}
Mint comb (int a, int b) {
if (a < b) return 0;
return fact[a] * inv_fact[b] * inv_fact[a - b];
}
};
int main () {
ios::sync_with_stdio(false); cin.tie(0);
int n, k;
cin >> n >> k;
vi sa(n);
vi pos(n);
for (int i = 0; i < n; i++) {
cin >> sa[i];
pos[sa[i]] = i;
}
int lt = 0;
for (int i = 0; i + 1 < n; i++) {
int x = sa[i] + 1;
int y = sa[i + 1] + 1;
if (x == n) continue;
if (y == n or pos[x] > pos[y]) lt += 1;
}
Mint::set_mod(998244353);
MNT mnt;
mnt.preprocess_factorial(n + k);
cout << mnt.comb(k - lt + n - 1, n) << '\n';
return (0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int c = 1;
for (int i = 0; i < n - 1; i++) {
if (s[i + 1] == s[i]) {
c++;
if (c == 7) {
cout << "YES" << endl;
break;
}
} else {
c = 1;
}
}
if (c < 7) cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e9 + 7;
const long long mod = (long long)1e9 + 7;
const int maxn = 5001;
const double eps = 1e-9;
int n, a[maxn], ans = inf;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int cnt = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
cnt++;
}
}
if (cnt) {
cout << n - cnt;
return 0;
}
for (int i = 0; i < n; i++) {
int g = a[i];
for (int j = i + 1; j < n; j++) {
g = gcd(g, a[j]);
if (g == 1) {
ans = min(ans, j - i);
break;
}
}
}
if (ans == inf) {
cout << -1;
} else {
cout << ans + n - 1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Segment {
int coverTime, coverSize;
Segment() { coverTime = coverSize = 0; }
Segment(int coverTime, int coverSize)
: coverTime(coverTime), coverSize(coverSize) {}
Segment operator+(const Segment &rhs) const {
return Segment(0, coverSize + rhs.coverSize);
}
};
const int MAXNODE = 200000 << 2;
struct SegmentTree {
int n;
Segment seg[MAXNODE];
static int LEFT(int idx) { return idx << 1; }
static int RIGHT(int idx) { return (idx << 1) | 1; }
void _build(int idx, int lower, int upper) {
if (lower == upper) {
seg[idx] = Segment();
return;
}
int middle = (lower + upper) >> 1;
_build(LEFT(idx), lower, middle);
_build(RIGHT(idx), middle + 1, upper);
seg[idx] = seg[LEFT(idx)] + seg[RIGHT(idx)];
}
void init(int n) {
this->n = n;
_build(1, 0, n - 1);
}
int x, v;
void _modify(int idx, int lower, int upper) {
if (lower == upper) {
if (!seg[idx].coverTime) {
seg[idx].coverSize = 1;
}
seg[idx].coverTime += v;
if (!seg[idx].coverTime) {
seg[idx].coverSize = 0;
}
return;
}
int middle = (lower + upper) >> 1;
if (x <= middle) {
_modify(LEFT(idx), lower, middle);
} else if (middle < x) {
_modify(RIGHT(idx), middle + 1, upper);
} else {
_modify(LEFT(idx), lower, middle);
_modify(RIGHT(idx), middle + 1, upper);
}
seg[idx] = seg[LEFT(idx)] + seg[RIGHT(idx)];
}
void modify(int x, int v) {
this->x = x;
this->v = v;
_modify(1, 0, n - 1);
}
int l, r;
Segment _calc(int idx, int lower, int upper) {
if (l <= lower && upper <= r) {
return seg[idx];
}
int middle = (lower + upper) >> 1;
if (r <= middle) {
return _calc(LEFT(idx), lower, middle);
} else if (middle < l) {
return _calc(RIGHT(idx), middle + 1, upper);
} else {
return _calc(LEFT(idx), lower, middle) +
_calc(RIGHT(idx), middle + 1, upper);
}
}
Segment calc(int l, int r) {
this->l = l;
this->r = r;
return _calc(1, 0, n - 1);
}
Segment calc(int x) {
this->l = this->r = x;
return _calc(1, 0, n - 1);
}
};
const int DX[4] = {-1, -1, 1, 1};
const int DY[4] = {-1, 1, 1, -1};
map<string, int> dirMap;
void init() {
dirMap["UL"] = 0;
dirMap["UR"] = 1;
dirMap["DR"] = 2;
dirMap["DL"] = 3;
}
const int MAXN = 100010;
int n, m, cnt[2][MAXN << 1];
vector<pair<pair<int, int>, int> > dirLst;
SegmentTree sgt[2];
bool cover(int x, int y, int dir) {
int pos = dir & 1 ? x + y : x - y + m - 1;
if (cnt[dir & 1][pos] > 1) return false;
cnt[dir & 1][pos]++;
sgt[dir & 1].modify(pos, 1);
return true;
}
void uncover(int x, int y, int dir) {
int pos = dir & 1 ? x + y : x - y + m - 1;
cnt[dir & 1][pos]--;
sgt[dir & 1].modify(pos, -1);
}
pair<pair<int, int>, int> nextDir(int x, int y, int dir) {
int step = min(DX[dir] > 0 ? n - 1 - x : x, DY[dir] > 0 ? m - 1 - y : y);
x += DX[dir] * step;
y += DY[dir] * step;
if (DX[dir] > 0 && x == n - 1 || DX[dir] < 0 && !x) dir ^= 3;
if (DY[dir] > 0 && y == m - 1 || DY[dir] < 0 && !y) dir ^= 1;
return make_pair(make_pair(x, y), dir);
}
bool parity;
bool fullyCover() {
for (int row = parity; row < n; row += 2) {
int column = 0;
pair<pair<int, int>, int> state = nextDir(row, column, 2);
if (!cnt[0][row - column + m - 1] &&
sgt[1].calc(row + column, state.first.first + state.first.second)
.coverSize != abs(row - state.first.first) + 1) {
return false;
}
}
for (int column = parity; column < m; column += 2) {
int row = 0;
pair<pair<int, int>, int> state = nextDir(row, column, 2);
if (!cnt[0][row - column + m - 1] &&
sgt[1].calc(row + column, state.first.first + state.first.second)
.coverSize != abs(row - state.first.first) + 1) {
return false;
}
}
return true;
}
bool isValid(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
void fix(int &x, int &y, int &dir) {
if (isValid(x + DX[dir], y + DY[dir])) return;
if (!x && !y)
dir = 2;
else if (!x && y == m - 1)
dir = 3;
else if (x == n - 1 && !y)
dir = 1;
else if (x == n - 1 && y == m - 1)
dir = 0;
else if (!x || x == n - 1)
dir ^= 3;
else
dir ^= 1;
}
int main() {
init();
scanf("%d%d", &n, &m);
int x, y, dir;
char dirStr[5];
scanf("%d%d%s", &x, &y, dirStr);
x--;
y--;
parity = (x + y) & 1;
dir = dirMap[dirStr];
fix(x, y, dir);
sgt[0].init(n + m);
sgt[1].init(n + m);
long long res = 1;
while (cover(x, y, dir)) {
dirLst.push_back(make_pair(make_pair(x, y), dir));
pair<pair<int, int>, int> state = nextDir(x, y, dir);
res += abs(x - state.first.first);
x = state.first.first;
y = state.first.second;
dir = state.second;
}
if (!fullyCover()) {
puts("-1");
} else {
for (int o = ((int)(dirLst).size()) - 1; o >= 0; o--) {
int x = dirLst[o].first.first, y = dirLst[o].first.second,
dir = dirLst[o].second;
uncover(x, y, dir);
pair<pair<int, int>, int> state = nextDir(x, y, dir);
int x0 = state.first.first, y0 = state.first.second;
res -= abs(x - x0);
if (cnt[dir & 1][dir & 1 ? x + y : x - y + m - 1]) continue;
int l = dir & 1 ? x - y + m - 1 : x + y,
r = dir & 1 ? x0 - y0 + m - 1 : x0 + y0;
if (l > r) swap(l, r);
Segment segment = sgt[dir & 1 ^ 1].calc(l, r);
if (segment.coverSize == r - l + 1) continue;
for (;; x0 -= DX[dir], y0 -= DY[dir]) {
if (!sgt[dir & 1 ^ 1]
.calc(dir & 1 ? x0 - y0 + m - 1 : x0 + y0)
.coverSize) {
res += abs(x - x0);
break;
}
if (x0 == x && y0 == y) break;
}
break;
}
printf("%I64d\n", res);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
int ans = n / k;
if (ans % 2)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 200000;
const long long MOD = 1000000007;
const long long OO = 0x3f3f3f3f;
const double EPS = 1e-9;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long x = a & b;
cout << (a ^ x) + (b ^ x) << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
int solve(vector<int> v) {
reverse(v.begin(), v.end());
int res = 0;
for (int i = (0); i < (int(v.size()) - 1); ++i) {
if (v[i] == 0) {
continue;
}
++res;
--v[i + 1];
}
return res;
}
int main() {
string s;
cin >> s;
int n = s.size();
vector<int> v;
for (int i = (0); i < (n); ++i) {
if (i == 0 || s[i] != s[i - 1]) {
v.push_back(1);
} else {
++v[int(v.size()) - 1];
}
}
if (s[0] == s.back()) {
v[0] += v[int(v.size()) - 1];
v.pop_back();
}
for (int i = (0); i < (v.size()); ++i) {
v[i] = min(v[i], 2);
}
if (count(v.begin(), v.end(), 2) == v.size()) {
cout << v.size();
return 0;
}
int x = 0;
while (v.back() == 2) {
++x;
v.pop_back();
}
vector<int> y = vector<int>(x, 2);
v.insert(v.begin(), y.begin(), y.end());
int res = solve(v);
v.pop_back();
v.insert(v.begin(), 1);
reverse(v.begin(), v.end());
res = max(res, solve(v));
cout << res;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000, mod = 1000000007;
const double eps = 0.000001;
int main() {
long long n, s = 0;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
s += (i + 1) * (a[i] - 1);
}
cout << s + n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5;
template <class T>
inline void _read(T& x) {
char ch = getchar();
bool mark = false;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') mark = true;
for (x = 0; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (mark) x = -x;
}
struct node {
int Next[26], pre, fail;
} T[maxn];
int tot = 1;
void Build_AC_Automaton() {
queue<int> Q;
Q.push(1);
int i, j;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (i = 0; i < 26; i++)
if (T[x].Next[i]) {
int v = T[x].Next[i];
for (j = T[x].fail; j && !T[j].Next[i]; j = T[j].fail)
;
T[v].fail = j ? T[j].Next[i] : 1;
Q.push(v);
}
}
}
int n, qq;
struct query {
int L, R, id;
query(int L, int R, int id) : L(L), R(R), id(id) {}
};
vector<query> Q[maxn];
char s[maxn];
int lim, len[maxn], End[maxn], id[maxn];
vector<int> A[maxn], word[maxn], sons[maxn];
long long ans[maxn], f[maxn], sum[maxn];
void dfs(int x) {
int i;
for (i = 0; i < sons[x].size(); i++) {
dfs(sons[x][i]);
f[x] += f[sons[x][i]];
}
for (i = 0; i < word[x].size(); i++) sum[word[x][i]] += f[x];
}
void SolveLongWords() {
for (int i = 1; i <= n; i++)
if (len[i] > lim) {
int j;
memset(f, 0, sizeof(f));
memset(sum, 0, sizeof(sum));
for (j = End[i]; j; j = T[j].pre) f[j] = 1;
dfs(1);
for (j = 2; j <= n; j++) sum[j] += sum[j - 1];
for (j = 0; j < Q[i].size(); j++)
ans[Q[i][j].id] = sum[Q[i][j].R] - sum[Q[i][j].L - 1];
}
}
int Sum[maxn], delta[maxn];
void Add(int x, int d) {
for (int i = x; id[i] == id[x]; i++) Sum[i] += d;
for (int i = id[x] + 1; i <= id[n]; i++) delta[i] += d;
}
int Query(int x) { return Sum[x] + delta[id[x]]; }
void DFS(int x) {
int i, j;
for (i = 0; i < word[x].size(); i++) Add(word[x][i], 1);
for (i = 0; i < A[x].size(); i++) {
int t = A[x][i];
for (j = 0; j < Q[t].size(); j++)
ans[Q[t][j].id] += Query(Q[t][j].R) - Query(Q[t][j].L - 1);
}
for (i = 0; i < sons[x].size(); i++) DFS(sons[x][i]);
for (i = 0; i < word[x].size(); i++) Add(word[x][i], -1);
}
int main() {
int i, j;
_read(n);
_read(qq);
lim = (int)sqrt(n);
for (i = 1; i <= n; i++) {
scanf("%s", s + 1);
int cur = 1;
len[i] = strlen(s + 1);
for (j = 1; j <= len[i]; j++) {
int x = s[j] - 'a';
if (!T[cur].Next[x]) T[cur].Next[x] = ++tot, T[tot].pre = cur;
cur = T[cur].Next[x];
if (len[i] <= lim) A[cur].push_back(i);
}
End[i] = cur;
word[cur].push_back(i);
}
Build_AC_Automaton();
for (i = 1; i <= tot; i++) sons[T[i].fail].push_back(i);
for (i = 1; i <= qq; i++) {
int L, R, k;
_read(L);
_read(R);
_read(k);
Q[k].push_back(query(L, R, i));
}
SolveLongWords();
for (i = 1; i <= n; i++) id[i] = (i - 1) / lim + 1;
DFS(1);
for (i = 1; i <= qq; i++) cout << ans[i] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
vector<int> a(N), p(N), q(N);
int sum = 0;
for (int i = 0; i < N; i++) {
scanf("%d%d", &a[i], &p[i]);
sum += a[i];
}
int ans = 0;
for (int i = 0; i < N;) {
int jump = i;
for (int j = i; j < N; j++, jump++) {
if (p[j] < p[i]) break;
ans += a[j] * p[i];
}
i = jump;
}
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct State {
long long cnt;
long long left;
long long right;
long long res;
State() : cnt(0), left(0), right(0), res(0) {}
State(long long cnt, long long left, long long right, long long res)
: cnt(cnt), left(left), right(right), res(res) {}
};
int A[1 << 18];
int T[1 << 18];
int L[1 << 18];
int R[1 << 18];
long long X[1 << 18];
long long Z[1 << 18];
State RMQ[2 << 18];
int I[18 + 1];
void update(int level, int pos, int a, int value) {
int from = pos << level;
int to = (pos + 1) << level;
if (a < from || to <= a) return;
State& parent = RMQ[I[level] + pos];
if (level == 0) {
parent.cnt = value;
parent.left = 0;
parent.right = value * (Z[a + 1] - Z[a]);
parent.res = 0;
return;
}
int mid = (to + from) >> 1;
update(level - 1, pos + pos, a, value);
update(level - 1, pos + pos + 1, a, value);
State& left = RMQ[I[level - 1] + pos + pos];
State& right = RMQ[I[level - 1] + pos + pos + 1];
parent.cnt = left.cnt + right.cnt;
parent.left = left.left + right.left + right.cnt * (Z[mid] - Z[from]);
parent.right = right.right + left.right + left.cnt * (Z[to] - Z[mid]);
parent.res =
left.res + right.res + left.right * right.cnt + right.left * left.cnt;
}
State find(int level, int pos, int a, int b) {
int from = pos << level;
int to = (pos + 1) << level;
if (b <= from || to <= a) return State();
if (a <= from && to <= b) return RMQ[I[level] + pos];
int mid = (to + from) >> 1;
State left = find(level - 1, pos + pos, a, b);
State right = find(level - 1, pos + pos + 1, a, b);
return State(
left.cnt + right.cnt,
left.left + right.left + right.cnt * (Z[mid] - Z[from]),
right.right + left.right + left.cnt * (Z[to] - Z[mid]),
left.res + right.res + left.right * right.cnt + right.left * left.cnt);
}
int main() {
int n;
scanf("%d", &n);
int i;
for (i = (0); i < (n); ++i) scanf("%d", &A[i]);
int m;
scanf("%d", &m);
for (i = (0); i < (m); ++i) scanf("%d%d%d", &T[i], &L[i], &R[i]);
vector<long long> x;
for (i = (0); i < (n); ++i) {
X[i] = A[i];
x.push_back(X[i]);
}
for (i = (0); i < (m); ++i)
if (T[i] == 1) {
int a = L[i] - 1;
X[a] += R[i];
x.push_back(X[a]);
}
sort((x).begin(), (x).end());
x.resize(unique((x).begin(), (x).end()) - x.begin());
int cnt = int((x).size());
for (i = (0); i < (cnt); ++i) Z[i] = x[i];
Z[cnt] = Z[cnt - 1];
I[0] = 0;
for (i = (0); i < (18); ++i) I[i + 1] = I[i] + (1 << (18 - i));
for (i = (0); i < (n); ++i) {
X[i] = A[i];
int a = lower_bound((x).begin(), (x).end(), X[i]) - x.begin();
update(18, 0, a, 1);
}
for (i = (0); i < (m); ++i)
if (T[i] == 1) {
int a = L[i] - 1;
int b = lower_bound((x).begin(), (x).end(), X[a]) - x.begin();
update(18, 0, b, 0);
X[a] += R[i];
b = lower_bound((x).begin(), (x).end(), X[a]) - x.begin();
update(18, 0, b, 1);
} else {
int a = lower_bound((x).begin(), (x).end(), L[i]) - x.begin();
int b = lower_bound((x).begin(), (x).end(), R[i] + 1) - x.begin();
printf("%lld\n", find(18, 0, a, b).res);
}
return 0;
};
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
const int MOD = 998244353;
char s[3005], t[3005];
int dp[3005][3005];
int main() {
scanf("%s%s", s + 1, t + 1);
int lens = strlen(s + 1);
int lent = strlen(t + 1);
for (int i = 1; i <= lens; i++) {
if (i > lent || s[1] == t[i]) dp[i][i] = 2;
}
for (int k = 2; k <= lens; k++) {
for (int l = 1; l + k - 1 <= lens; l++) {
int r = l + k - 1;
if (l > lent || s[k] == t[l]) dp[l][r] = (dp[l][r] + dp[l + 1][r]) % MOD;
if (r > lent || s[k] == t[r]) dp[l][r] = (dp[l][r] + dp[l][r - 1]) % MOD;
}
}
int ans = 0;
for (int i = lent; i <= lens; i++) ans = (ans + dp[1][i]) % MOD;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char _buf[100000], *_op(_buf), *_ed(_buf);
inline int getint() {
int _s = 0;
char _ch = (_op == _ed && (_ed = (_op = _buf) + fread(_buf, 1, 100000, stdin),
_op == _ed)
? EOF
: *_op++);
while (!('0' <= _ch && _ch <= '9'))
_ch = (_op == _ed && (_ed = (_op = _buf) + fread(_buf, 1, 100000, stdin),
_op == _ed)
? EOF
: *_op++);
while (('0' <= _ch && _ch <= '9'))
_s = _s * 10 + _ch - 48,
_ch = (_op == _ed && (_ed = (_op = _buf) + fread(_buf, 1, 100000, stdin),
_op == _ed)
? EOF
: *_op++);
return _s;
}
const int N = 2e5 + 1, INF = 0x3f3f3f3f;
int n, ans;
vector<int> e[N];
inline void add_edge(int x, int y) { e[x].push_back(y), e[y].push_back(x); }
inline void dfs(int u, int fa = 0, int d = 0) {
ans += d;
for (int v : e[u])
if (v ^ fa) dfs(v, u, d ^ 1);
}
int main() {
n = getint();
for (int i = 2; i <= n; i++) add_edge(getint(), getint());
dfs(1), cout << min(ans, n - ans) - 1;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int t;
string s;
cin >> t;
while (t--) {
cin >> s;
int dem1 = 0, dem2 = 0, dem3 = 0;
int len = s.length();
for (int i = 0; i < len; i++) {
if (s[i] == 'A')
dem1++;
else if (s[i] == 'B')
dem2++;
else
dem3++;
}
if (dem1 == dem2 && dem3 == 0)
cout << "YES" << endl;
else if (dem2 == dem3 && dem1 == 0)
cout << "YES" << endl;
else if (dem1 + dem3 == dem2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
long long abs() const { return x * x + y * y; }
long double arg() const { return atan2(y, x); }
Point operator*(double o) const { return Point(x * o, y * o); }
Point operator+(const Point& o) const { return Point(x + o.x, y + o.y); }
Point operator-(const Point& o) const { return Point(x - o.x, y - o.y); }
Point operator/(double o) const { return Point(x / o, y / o); }
bool operator<(const Point& o) const {
return x < o.x - 1e-9 || (x < o.x + 1e-9 && y < o.y - 1e-9);
}
friend bool operator==(const Point& r1, const Point& r2) {
return r1.x == r2.x && r1.y == r2.y;
}
Point scale(double o) const { return *this * (o / abs()); }
Point rotY() const { return Point(-y, x); }
Point rotX() const { return Point(y, -x); }
long long cross(Point b) const { return x * b.y - b.x * y; }
long long dot(Point b) const { return x * b.x + y * b.y; }
long double disToSeg(Point& a, Point& b) {
return fabs(((*this) - a).cross(b - a) / (b - a).abs());
}
pair<long long, long long> getVec() {
if (x == 0) return {0, y > 0 ? 1 : -1};
if (y == 0) return {x < 0 ? -1 : 1, 0};
long long gg = gcd1(::abs(x), ::abs(y));
long long px = x / gg, py = y / gg;
return {px, py};
}
void readin() { scanf("%lld%lld", &x, &y); }
} p[100035];
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) {
p[i].readin();
}
if (n & 1) etp();
k = n / 2;
for (int(i) = 0; (i) < (int)(k); (i)++) {
Point A = p[i] - p[i + 1], B = p[i + k] - p[(i + k + 1) % n];
if (A.cross(B) != 0) etp();
if (A.abs() != B.abs()) etp();
}
puts("yes");
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m, id, mem1, mem2, sz;
long long sum = 0, mx = 0, cnt1, cnt2;
cin >> n >> m;
int a[m];
for (i = 0; i < m; i++) cin >> a[i];
if (m == 1) {
cout << 0;
return 0;
}
for (i = 0; i < m - 1; i++) sum += abs(a[i] - a[i + 1]);
vector<int> v[n + 1];
for (i = 0; i < m; i++) {
if (i == 0) {
if (a[i] != a[i + 1]) v[a[i]].push_back(a[i + 1]);
} else if (i == m - 1) {
if (a[i] != a[i - 1]) v[a[i]].push_back(a[i - 1]);
} else {
if (a[i] != a[i - 1]) v[a[i]].push_back(a[i - 1]);
if (a[i] != a[i + 1]) v[a[i]].push_back(a[i + 1]);
}
}
for (i = 1; i <= n; i++) {
sz = v[i].size();
if (sz == 0) continue;
sz /= 2;
sort(v[i].begin(), v[i].end());
mem1 = i;
mem2 = v[i][sz];
cnt1 = 0;
cnt2 = 0;
for (j = 0; j < v[i].size(); j++) {
cnt1 += abs(v[i][j] - mem1);
cnt2 += abs(v[i][j] - mem2);
}
mx = max(mx, cnt1 - cnt2);
}
sum += -mx;
cout << sum;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 101010;
int n, m, t[MAXM][10], r[MAXM][10];
int main() {
cin >> m >> n;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) cin >> t[i][j];
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
r[i][j] = max(r[i - 1][j], r[i][j - 1]) + t[i][j];
for (int i = 1; i < m; i++) cout << r[i][n] << ' ';
cout << r[m][n] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f;
template <typename T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <typename T>
T read(T &first) {
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (first = 0; isdigit(ch); ch = getchar()) first = 10 * first + ch - '0';
return first *= f;
}
template <typename T>
void write(T first) {
if (first < 0) {
putchar('-');
first = -first;
}
static char s[20];
int top = 0;
for (; first; first /= 10) s[++top] = first % 10 + '0';
if (top == 0)
putchar('0');
else
while (top) putchar(s[top--]);
}
const int MAXN = 30, MAXM = 1e5 + 5;
int N, M, A[MAXN];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void nosol() {
puts("0");
for (int i = 0; i < N; ++i) {
for (int j = 0; j < A[i]; ++j) {
putchar(i + 'a');
}
}
putchar('\n');
}
void input() {
read(N);
for (int i = 0; i < N; ++i) {
read(A[i]);
}
}
void solve() {
int odd = 0, oddp;
for (int i = 0; i < N; ++i) {
M += A[i];
if (A[i] & 1) {
if (odd != 0) {
nosol();
return;
}
odd = A[i];
oddp = i;
}
}
int ans;
if (odd != 0) {
A[oddp] = 0;
for (; odd > 0; odd -= 2, A[oddp] += 2) {
int other = odd << 1;
bool flag = true;
for (int i = 0; i < N; ++i) {
if (A[i] % other != 0) {
flag = false;
break;
}
}
if (flag) break;
}
if (odd < 0) {
nosol();
return;
}
ans = odd;
} else {
ans = A[0];
for (int i = 1; i < N; ++i) {
ans = gcd(ans, A[i]);
}
}
static int q[MAXM];
static bool vis[MAXM];
static char color[MAXM];
std::cerr << "ans"
" = "
<< ans << std::endl;
int s = ans == 1 ? 0 : M / ans;
std::cerr << "s"
" = "
<< s << std::endl;
for (int i = 0, j = 0; i < M; ++i) {
if (vis[i]) continue;
int front = 0, rear = 0;
q[rear++] = i;
vis[i] = true;
while (front != rear) {
int u = q[front++];
if (!vis[M - u - 1]) {
q[rear++] = M - u - 1;
vis[M - u - 1] = true;
}
if (!vis[(2 * s - u - 1 + M) % M]) {
q[rear++] = (2 * s - u - 1 + M) % M;
vis[(2 * s - u - 1 + M) % M] = true;
}
}
int id;
std::cerr << "rear"
" = "
<< rear << std::endl;
if (rear & 1) {
assert(odd == rear);
id = oddp;
} else {
while (A[j] == 0) {
++j;
}
A[j] -= rear;
assert(j < N && A[j] >= 0);
id = j;
}
for (int k = 0; k < rear; ++k) {
color[q[k]] = id + 'a';
}
}
printf("%d\n", ans);
for (int i = 0; i < M; ++i) {
putchar(color[i]);
}
putchar('\n');
}
int main() {
input();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, t, p, v;
cin >> n;
n = n + 1;
v = 0;
if (n == 1)
cout << "0" << endl;
else if (n % 2 == 0) {
cout << n / 2 << endl;
} else {
cout << n << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100005];
scanf("%s", s);
int counter[10], ext = 0, len = strlen(s), cnt = 0;
memset(counter, 0, sizeof counter);
for (int i = 0; i < len; i++) {
if (s[i] == '?' && i > 0)
ext++;
else if (s[i] >= 'A' && s[i] <= 'J') {
counter[s[i] - 65]++;
}
}
int ans = 1;
for (int i = 0; i < 10; i++) {
if (counter[i]) cnt++;
}
if (cnt) {
if (s[0] >= 'A' && s[0] <= 'J')
ans = 9;
else
ans = 10;
}
for (int i = 1; i < cnt; i++) {
ans *= (10 - i);
}
if (s[0] == '?') ans *= 9;
printf("%d", ans);
for (int i = 0; i < ext; i++) printf("0");
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2>& p) {
out << "{" << p.first << ", " << p.second << "} ";
return out;
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& arr) {
for (auto& i : arr) in >> i;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& arr) {
for (auto i : arr) out << i << " ";
out << endl;
return out;
}
const int INF = 1e9;
void stuff() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
}
const int MAXN = 1001;
int f[1001][1001][2];
char g[1001][1001][2];
int n;
int i, j, k, x = 0;
void print(int x, int y) {
if (x == 1 && y == 1) return;
if (g[x][y][k])
print(x - 1, y), cout << 'D';
else
print(x, y - 1), cout << 'R';
}
int main() {
cin >> n;
for (i = 2; i <= n; ++i)
f[0][i][0] = f[0][i][1] = f[i][0][0] = f[i][0][1] = 999999999;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) {
cin >> k;
if (!k)
x = i;
else {
for (; !(k & 1); k >>= 1) ++f[i][j][0];
for (; !(k % 5); k /= 5) ++f[i][j][1];
}
for (k = 0; k < 2; ++k)
if ((g[i][j][k] = f[i - 1][j][k] < f[i][j - 1][k]))
f[i][j][k] += f[i - 1][j][k];
else
f[i][j][k] += f[i][j - 1][k];
}
k = f[n][n][1] < f[n][n][0];
if (x && f[n][n][k] > 1) {
cout << 1 << endl;
for (i = 2; i <= x; ++i) cout << 'D';
for (i = 2; i <= n; ++i) cout << 'R';
for (i = x + 1; i <= n; ++i) cout << 'D';
} else
cout << f[n][n][k] << endl, print(n, n);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
inline long long readll() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
inline void write(int x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
const int maxn = 2007, INF = 0x3f3f3f3f;
const int MOD = 998244353;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long long P = 19260817;
inline int mod1(int x) { return x < MOD ? x : x - MOD; }
inline int mod2(int x) { return x < 0 ? x + MOD : x; }
inline void add(int &x, int y) { x = mod1(x + y); }
inline void sub(int &x, int y) { x = mod2(x - y); }
struct node {
int x, y, dis;
friend bool operator<(const node &a, const node &b) {
if (a.dis != b.dis) return a.dis < b.dis;
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
};
inline void chkmin(node &a, node b) { a = min(a, b); }
int n, m, K;
int fal[maxn][maxn];
int far[maxn][maxn];
int fau[maxn][maxn];
int fad[maxn][maxn];
int find(int x, int *fa) { return x == fa[x] ? x : fa[x] = find(fa[x], fa); }
void solve(int x, int y) {
if (fal[x][y] == y) {
printf("%d %d\n", x, y);
fal[x][y] = y - 1;
far[x][y] = y + 1;
fau[y][x] = x - 1;
fad[y][x] = x + 1;
return;
}
node ans = (node){0, 0, INF};
for (int i = x; i <= min(x + (int)sqrt(K), n); i++) {
int t = y;
t = find(t, fal[i]);
if (t) chkmin(ans, (node){i, t, abs(i - x) + abs(t - y)});
t = y;
t = find(t, far[i]);
if (t) chkmin(ans, (node){i, t, abs(i - x) + abs(t - y)});
if (y == fal[i][y]) break;
}
for (int i = x; i >= max(x - (int)sqrt(K), 1); i--) {
int t = y;
t = find(t, fal[i]);
if (t) chkmin(ans, (node){i, t, abs(i - x) + abs(t - y)});
t = y;
t = find(t, far[i]);
if (t) chkmin(ans, (node){i, t, abs(i - x) + abs(t - y)});
if (y == fal[i][y]) break;
}
for (int i = y; i <= min(y + (int)sqrt(K), m); i++) {
int t = x;
t = find(t, fau[i]);
if (t) chkmin(ans, (node){t, i, abs(t - x) + abs(i - y)});
t = x;
t = find(t, fad[i]);
if (t) chkmin(ans, (node){t, i, abs(t - x) + abs(i - y)});
if (x == fau[i][x]) break;
}
for (int i = y; i >= max(y - (int)sqrt(K), 1); i--) {
int t = x;
t = find(t, fau[i]);
if (t) chkmin(ans, (node){t, i, abs(t - x) + abs(i - y)});
t = x;
t = find(t, fad[i]);
if (t) chkmin(ans, (node){t, i, abs(t - x) + abs(i - y)});
if (x == fau[i][x]) break;
}
printf("%d %d\n", ans.x, ans.y);
fal[ans.x][ans.y] = ans.y - 1;
far[ans.x][ans.y] = ans.y + 1;
fau[ans.y][ans.x] = ans.x - 1;
fad[ans.y][ans.x] = ans.x + 1;
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
fal[i][j] = j, far[i][j] = j;
fau[j][i] = i, fad[j][i] = i;
}
}
for (int i = 1, x, y; i <= K; i++) {
scanf("%d%d", &x, &y);
solve(x, y);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num;
cin >> num;
if (num == 1) {
cout << 1 << endl;
return 0;
}
cout << num;
for (int i = 1; i < num; i++) {
cout << " " << i;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 20;
const int MAX_MASK = (1 << MAX_N);
int dp[2][MAX_MASK][MAX_N + 1];
void Clear(int id) {
for (int mask = 0; mask < MAX_MASK; ++mask) {
for (int i = 0; i <= MAX_N; ++i) {
dp[id][mask][i] = 0;
}
}
}
void Relax(int id) {
for (int mask = 0; mask < MAX_MASK; ++mask) {
for (int i = MAX_N - 1; i >= 0; --i) {
dp[id][mask][i] += dp[id][mask][i + 1];
}
}
}
int cost[MAX_MASK];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<string> a(n);
vector<int> masks(m);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int j = 0; j < m; ++j) {
masks[j] = 0;
for (int i = 0; i < n; ++i) {
if (a[i][j] == '1') {
masks[j] += (1 << i);
}
}
}
int curPtr = 0;
Clear(curPtr);
for (int j = 0; j < m; ++j) {
++dp[curPtr][masks[j]][n];
}
Relax(curPtr);
for (int k = 1; k <= n; ++k) {
int nxtPtr = 1 - curPtr;
Clear(nxtPtr);
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = n - 1; i >= 0; --i) {
int newMask = mask ^ (1 << i);
dp[nxtPtr][mask][i] += dp[curPtr][newMask][i + 1];
}
}
swap(curPtr, nxtPtr);
Relax(curPtr);
for (int mask = 0; mask < (1 << n); ++mask) {
cost[mask] += min(k, n - k) * dp[curPtr][mask][0];
}
}
int result = n * m;
for (int mask = 0; mask < (1 << n); ++mask) {
result = min(result, cost[mask]);
}
cout << result << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long x[100000], y[100000];
int main() {
long long n, j;
cin >> n >> j;
j %= (2 * n);
long long x1, y1;
cin >> x1 >> y1;
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &x[i], &y[i]);
}
for (int i = 0; i < j; i++) {
int k = i % n;
x1 = 2ll * x[k] - x1;
y1 = 2ll * y[k] - y1;
}
cout << x1 << " " << y1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, l, r;
long long num;
vector<long long> ans;
bool intersect(long long l1, long long r1, long long l2, long long r2) {
return min(r1, r2) >= max(l1, l2);
}
void cal(long long left) {
if (left == n) return;
if (intersect(l, r, num + 1, num + 2 * (n - left))) {
for (long long i = left + 1; i <= n; ++i) {
num++;
if (num >= l && num <= r) ans.push_back(left);
num++;
if (num >= l && num <= r) ans.push_back(i);
}
} else
num += 2 * (n - left);
cal(left + 1);
}
int main(void) {
int t;
cin >> t;
while (t--) {
ans.clear();
num = 0;
cin >> n >> l >> r;
cal(1);
for (auto x : ans) cout << x << " ";
if (r == n * (n - 1) + 1) cout << 1 << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const int N = 2e5 + 5;
vector<int> day[N];
int l[N], r[N];
vector<pair<int, int> > adj[N];
void dfs(int u, int p) {
for (auto v : adj[u]) {
if (v.first != p) {
if (l[u] - 1 > 0) {
l[u]--;
day[l[u]].push_back(v.second);
l[v.first] = r[v.first] = l[u];
dfs(v.first, u);
} else {
r[u]++;
day[r[u]].push_back(v.second);
l[v.first] = r[v.first] = r[u];
dfs(v.first, u);
}
}
}
}
void solve() {
int n;
cin >> n;
int u, v;
for (int i = 1; i < n; ++i) {
cin >> u >> v;
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
}
dfs(1, 0);
int cnt = 0;
for (int i = 1; i < N; ++i) {
if (day[i].size() != 0) cnt++;
}
cout << cnt << endl;
for (int i = 1; i < cnt + 1; ++i) {
cout << day[i].size() << " ";
for (auto x : day[i]) {
cout << x << " ";
}
cout << endl;
}
return;
}
int main() {
boost();
int tc = 1;
while (tc--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read();
const int maxn = 4e5 + 5;
int n;
int id[maxn][2], last;
pair<int, int> q[maxn], edge[maxn << 1];
vector<int> v[maxn << 2];
struct EDGE {
int tim, ty, first, second;
} e[maxn << 1];
bool operator<(const EDGE& a, const EDGE& b) {
if (a.first != b.first) return a.first < b.first;
if (a.second != b.second) return a.second < b.second;
return a.tim < b.tim;
}
namespace UF {
int top;
int fa[maxn], siz[maxn], stk[maxn];
void Init(int n) {
top = 0;
for (int i = 1; i <= n; ++i) fa[i] = i, siz[i] = 0;
}
int Find(int first) { return fa[first] == first ? first : Find(fa[first]); }
void Merge(int e) {
int first = Find(edge[e].first), second = Find(edge[e].second);
if (first == second) return;
if (siz[first] < siz[second]) swap(first, second);
if (siz[first] == siz[second]) stk[++top] = first, ++siz[first];
stk[++top] = second, fa[second] = first;
}
void Cancel(int l) {
for (int i = stk[top]; top != l; --top, i = stk[top])
if (fa[i] == i)
--siz[i];
else
fa[i] = i;
}
} // namespace UF
namespace SEG {
bool vis[maxn << 1];
void Insert(int rt, int l, int r, int ql, int qr, int e) {
if (l >= ql && r <= qr) {
v[rt].push_back(e);
return;
}
if (((l + r) >> 1) >= ql) Insert((rt << 1), l, ((l + r) >> 1), ql, qr, e);
if (((l + r) >> 1) < qr)
Insert((rt << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, e);
}
void Divide(int rt, int l, int r) {
using namespace UF;
int pre = top;
for (int i = v[rt].size() - 1; i >= 0; --i)
if (vis[v[rt][i]]) Merge(v[rt][i]);
if (l == r) {
if (q[l].first) {
int first = (q[l].first + last - 1) % n + 1,
second = (q[l].second + last - 1) % n + 1;
printf("%d", last = (Find(first) == Find(second)));
} else
vis[id[l][last]] ^= 1;
} else {
Divide((rt << 1), l, ((l + r) >> 1));
Divide((rt << 1 | 1), ((l + r) >> 1) + 1, r);
}
Cancel(pre);
}
} // namespace SEG
inline void Work() {
n = read();
int m = read(), opt_cnt = 0, edge_cnt = 0;
for (int i = 1; i <= m; ++i) {
int op = read(), first = read(), second = read();
if (op == 1) {
if (first > second) swap(first, second);
e[++opt_cnt] = (EDGE){i, 0, first, second};
first = first % n + 1, second = second % n + 1;
if (first > second) swap(first, second);
e[++opt_cnt] = (EDGE){i, 1, first, second};
} else
q[i] = make_pair(first, second);
}
sort(e + 1, e + opt_cnt + 1);
edge[++edge_cnt] = make_pair(e[1].first, e[1].second);
for (int i = 2; i <= opt_cnt + 1; ++i) {
id[e[i - 1].tim][e[i - 1].ty] = edge_cnt;
if (e[i - 1].first == e[i].first && e[i - 1].second == e[i].second) {
SEG::Insert(1, 1, m, e[i - 1].tim + 1, e[i].tim, edge_cnt);
} else {
if (e[i - 1].tim < m) SEG::Insert(1, 1, m, e[i - 1].tim + 1, m, edge_cnt);
edge[++edge_cnt] = make_pair(e[i].first, e[i].second);
}
}
UF::Init(n);
SEG::Divide(1, 1, m);
}
int main() {
Work();
return 0;
}
inline int read() {
char c;
bool type = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') type = 0;
int ans = c ^ 48;
while ((c = getchar()) >= '0' && c <= '9')
ans = (ans << 3) + (ans << 1) + (c ^ 48);
return type ? ans : -ans;
}
| 9 |
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline bool repr(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool repl(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
struct Cg {
inline char operator()() { return getchar(); }
};
struct Cp {
inline void operator()(char x) { putchar(x); }
};
inline bool IS(char x) { return x == 10 || x == 13 || x == ' '; }
template <typename T>
struct Fr {
T P;
inline Fr &operator,(int &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator int() {
int x;
*this, x;
return x;
}
inline Fr &operator,(long long &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator long long() {
long long x;
*this, x;
return x;
}
inline Fr &operator,(char &x) {
for (x = P(); IS(x); x = P())
;
return *this;
}
inline operator char() {
char x;
*this, x;
return x;
}
inline Fr &operator,(char *x) {
char t = P();
for (; IS(t); t = P())
;
if (~t) {
for (; !IS(t) && ~t; t = P()) *x++ = t;
}
*x++ = 0;
return *this;
}
inline Fr &operator,(double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator double() {
double x;
*this, x;
return x;
}
inline Fr &operator,(long double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator long double() {
long double x;
*this, x;
return x;
}
inline Fr &operator,(unsigned int &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned int() {
unsigned int x;
*this, x;
return x;
}
inline Fr &operator,(unsigned long long &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned long long() {
unsigned long long x;
*this, x;
return x;
}
};
Fr<Cg> in;
template <typename T>
struct Fw {
T P;
inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(char x) {
P(x);
return *this;
}
inline Fw &operator()(char x) {
P(x);
return *this;
}
inline Fw &operator,(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
inline Fw &operator()(long double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
};
Fw<Cp> out;
#pragma GCC target("popcnt")
const int N = 200007, M = 1050007, V = 5050007, inf = 0x3f3f3f3f;
std::vector<std::pair<int, int> > q[N];
int n, m, pm, s[N], ans[M], p[V / 10], lo[V], lp[V], f[7], fc, fs[133], g[V][8],
ua[15];
char mu[V];
int main() {
for (int i = 2, iend = V - 1; i <= iend; i++) {
if (!lo[i]) p[pm++] = i, lo[i] = i, mu[i] = -1, lp[i] = i;
for (int j = 0; i * p[j] < V; j++) {
lp[i * p[j]] = p[j];
if (lo[i] % p[j] == 0)
lo[i * p[j]] = lo[i] / p[j];
else
lo[i * p[j]] = lo[i] * p[j];
if (i % p[j] == 0) {
break;
}
mu[i * p[j]] = -mu[i];
}
}
lo[1] = 1, lp[1] = 1, mu[1] = 1;
in, n, m;
for (int i = 1, iend = n; i <= iend; i++) in, s[i];
for (int i = 1, iend = m; i <= iend; i++) {
int l, r;
in, l, r;
q[r].push_back(std::make_pair(l, i));
}
for (int i = 1, iend = n; i <= iend; i++) {
int t = lo[s[i]];
fc = 0;
while (t > 1) f[fc++] = lp[t], t /= lp[t];
fs[0] = 1;
for (int j = 0, jend = fc; j < jend; j++) fs[1 << j] = f[j];
for (int j = 1, jend = (1 << fc) - 1; j <= jend; j++) {
fs[j] = fs[j & (j - 1)] * fs[j & -j];
}
for (int j = 0, jend = 1 << fc; j < jend; j++) {
int x = fs[j], y = fc - __builtin_popcount(j);
for (int k = 0, kend = 8; k < kend; k++) repr(ua[k + y], g[x][k]);
g[x][y] = i;
}
for (__typeof((q[i]).end()) j = (q[i]).begin(); j != (q[i]).end(); ++j) {
for (int k = 0, kend = 15; k < kend; k++)
if (ua[k] >= j->first) {
ans[j->second] = k;
break;
}
}
}
for (int i = 1, iend = m; i <= iend; i++) out, ans[i], '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << 4 * (n - 3) * (long long)pow(4, n - 4) * 3 * 3 +
(long long)pow(4, n - 2) * 2 * 3
<< endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int L, b, f, N;
vector<pair<int, int> > cars;
int len[105];
int main(int argc, char *argv[]) {
scanf("%d%d%d", &L, &b, &f);
scanf("%d", &N);
for (int i = 0, _i = N; i < _i; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x == 1) {
len[i + 1] = y;
if (cars.empty()) {
if (y > L) {
printf("-1\n");
continue;
}
cars.push_back(pair<int, int>(0, i + 1));
printf("0\n");
continue;
}
if (cars[0].first >= f + y) {
cars.insert(cars.begin(), pair<int, int>(0, i + 1));
printf("%d\n", 0);
continue;
}
bool good = false;
for (int j = 0; j < cars.size() - 1; j++) {
if (cars[j].first + len[cars[j].second] + b + y + f <=
cars[j + 1].first) {
cars.insert(
cars.begin() + j + 1,
pair<int, int>(cars[j].first + len[cars[j].second] + b, i + 1));
good = true;
printf("%d\n", cars[j].first + len[cars[j].second] + b);
break;
}
}
if (good) continue;
int last = cars.size() - 1;
if (cars[last].first + len[cars[last].second] + b + y <= L) {
cars.push_back(pair<int, int>(
cars[last].first + len[cars[last].second] + b, i + 1));
printf("%d\n", cars[last].first + len[cars[last].second] + b);
continue;
}
printf("-1\n");
} else {
for (int i = 0, _i = cars.size(); i < _i; ++i) {
if (cars[i].second == y) {
cars.erase(cars.begin() + i);
break;
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)(1e9) + 7;
const int SIZE = 2020;
int d, n;
int a[SIZE];
vector<int> path[SIZE];
long long f[SIZE];
bool vis[SIZE];
void dfs(int x, int root) {
f[x] = 1;
for (int i = 0; i < path[x].size(); i++) {
int son = path[x][i];
if (vis[son] || !(a[son] >= a[root] && a[son] <= a[root] + d) ||
(a[son] == a[root] && son < root))
continue;
vis[son] = 1;
dfs(son, root);
f[x] = (f[x] * (f[son] + 1)) % MOD;
}
}
int main() {
int x, y;
while (cin >> d >> n) {
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
path[i].clear();
}
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
x--, y--;
path[x].push_back(y);
path[y].push_back(x);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
f[j] = 0;
vis[j] = 0;
}
vis[i] = 1;
dfs(i, i);
ans = (ans + f[i]) % MOD;
}
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a, b, flag = 0;
cin >> n;
string s;
for (i = 0; i < n; i++) {
cin >> s >> a >> b;
if (a >= 2400 && b > a) {
flag = 1;
}
}
if (flag == 0)
cout << "NO";
else
cout << "YES";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
int n, ma, l[410000], v[410000], ll, vv, b[410000], bt, xx, al[410000],
av[410000];
long long f[410000], ff, af[410000];
struct nod {
int ii, oo;
bool operator<(const nod &a) const { return ii < a.ii; }
} a[210000];
inline void upd(int x) {
if (vv < v[x]) {
v[x] = vv;
f[x] = ff;
return;
}
if (vv > v[x]) return;
f[x] += ff;
if (f[x] >= p) f[x] -= p;
}
inline void add(int x) {
while (x <= bt) {
upd(x);
x += x & (-x);
}
}
inline void getl(int x) {
if (v[x] < vv) {
vv = v[x];
ff = f[x];
return;
}
if (v[x] > vv) return;
ff += f[x];
if (ff >= p) ff -= p;
}
inline void ask(int x) {
while (x) {
getl(x);
x -= x & (-x);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].oo, &a[i].ii);
b[++bt] = a[i].ii;
b[++bt] = a[i].oo;
}
b[++bt] = 0;
sort(b + 1, b + bt + 1);
bt = unique(b + 1, b + bt + 1) - b - 1;
for (int i = 1; i <= bt; i++) v[i] = 0x7fffffff;
sort(a + 1, a + n + 1);
xx = lower_bound(b + 1, b + bt + 1, 0) - b;
ll = 0;
vv = 0;
ff = 1;
add(xx);
for (int i = 1; i <= n; i++) {
xx = lower_bound(b + 1, b + bt + 1, a[i].ii) - b;
ll = -1;
vv = ff = 0;
ask(xx);
ll++;
vv += a[i].ii - a[i].oo;
al[i] = ll;
av[i] = vv + a[i].oo;
af[i] = ff;
xx = lower_bound(b + 1, b + bt + 1, a[i].oo) - b;
add(xx);
}
vv = 0x7fffffff;
ff = 0;
ma = a[1].ii;
for (int i = 2; i <= n; i++)
if (a[i].ii > ma) ma = a[i].ii;
for (int i = 1; i <= n; i++)
if (a[i].oo > ma) {
if (av[i] < vv) {
vv = av[i];
ff = af[i];
continue;
}
if (av[i] > vv) continue;
ff += af[i];
if (ff >= p) ff -= p;
}
printf("%I64d\n", ff);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int n, q;
set<pii> sv[2];
set<int> cor[2];
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> q;
int x, y;
char c;
while (q--) {
int res;
cin >> x >> y >> c;
bool b = c == 'U';
if (!b) swap(x, y);
if (cor[b].count(-x)) {
cout << "0\n";
continue;
}
auto it = sv[b].lower_bound({x, 0});
auto it2 = cor[!b].lower_bound(-y);
res = y;
if (it != sv[b].end()) res = it->first - x + it->second;
if ((it != sv[b].end() && it2 != cor[!b].end() &&
it->first > n + 1 + *it2) ||
(it == sv[b].end() && it2 != cor[!b].end()))
res = n + 1 + *it2 - x;
sv[b].insert({x, res});
cor[b].insert(-x);
cout << res << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 50;
const long long mod = 998244353;
long long dp[maxn][2];
long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long k;
long long ac(vector<long long> a) {
int len = a.size();
for (int i = 0; i < len - 1; i++) {
if (a[i] == a[i + 1] && a[i] != -1) return 0;
}
if (len == 1) {
if (a[0] == -1)
return k;
else
return 1;
}
long long l = -1, r = -1, ans = 1;
for (int i = 0; i < len; i++) {
if (a[i] == -1) {
l = i;
r = l;
while (r < len - 1 && a[r + 1] == -1) r++;
int n = r - l + 1;
if (l == 0 && r == len - 1)
return k * ksm(k - 1, len - 1) % mod;
else if (l == 0 || r == len - 1) {
ans = ans * ksm(k - 1, n) % mod;
} else if (a[l - 1] == a[r + 1])
ans = ans * dp[n][1] % mod;
else {
ans = ans * dp[n][0] % mod;
}
i = r;
}
}
return ans;
}
vector<long long> odd, even;
int main() {
int n;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
long long a;
cin >> a;
if (i & 1)
odd.push_back(a);
else
even.push_back(a);
}
dp[1][1] = k - 1;
dp[1][0] = k - 2;
for (int i = 2; i <= n; i++) {
dp[i][1] = (k - 1) * dp[i - 1][0] % mod;
dp[i][0] = (dp[i - 1][1] + (k - 2) * dp[i - 1][0]) % mod;
}
cout << ac(odd) * ac(even) % mod << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[1001][11][11];
void fill(vector<long long int> a, long long int d, long long int l,
long long int s, long long int m) {
for (int i = m - 1; i >= 0; i--) {
a[i] = l;
long long int ch = dp[s][d][l];
d = l - d;
l = ch;
s--;
}
cout << "YES" << endl;
for (int i = 0; i < m; i++) cout << a[i] << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int m;
string w;
set<long long int> weight;
cin >> w;
for (int i = 0; i < 10; i++) {
if (w[i] - 48) weight.insert(i + 1);
}
weight.insert(0);
cin >> m;
vector<long long int> a(m);
dp[0][0][0] = 1;
for (long long int s = 1; s <= m; s++) {
for (long long int d = 1; d <= 10; d++) {
for (auto l : weight) {
for (auto ch : weight) {
if (l - d >= 0 && dp[s - 1][l - d][ch] && ch != l) {
dp[s][d][l] = (ch) ? ch : -1;
if (s == m) {
fill(a, d, l, s, m);
return 0;
}
break;
}
}
}
}
}
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const unsigned int mod = 1e7 + 7;
const long long int N = 1e5;
map<long long int, bool> visit;
map<long long int, vector<long long int>> v;
map<long long int, long long int> cnt;
map<long long int, long long int>::iterator it;
void dfs(long long int x) {
cout << x << " ";
visit[x] = true;
for (int i = 0; i < v[x].size(); i++) {
if (visit[v[x][i]] == false) dfs(v[x][i]);
}
}
int main() {
long long int l, n, m, k = 0, q = 0, p = 0, t = 0, z = 0, w = INT_MAX,
pre = 1e5, mid, a[2009] = {0}, dp[1000] = {0},
h[26] = {0}, t1, t2, now, r = 0, i = 0, j = 0,
flag = 0, temp = 0, e = -1e4, o = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> p >> q;
v[p].push_back(q);
v[q].push_back(p);
cnt[p]++;
cnt[q]++;
visit[p] = false;
visit[q] = false;
}
for (it = cnt.begin(); it != cnt.end(); it++) {
if (it->second == 1) q = it->first;
}
dfs(q);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
#define rint register int
#define rll register ll
#define pii pair<int, int>
#define pll pair<ll, ll>
//#define p1 first
//#define p2 second
#define fors(i, a, b) for (register int i = (a); i <= (b); ++i)
#define _fors(i, a, b) for (ll i = (a); i >= (b); --i)
#define mp(a, b) make_pair(a, b)
#define mt(a, b, c) make_tuple(a, b, c)
#define mem(A, b) memset(A, b, sizeof(A))
#define all(X) (X).begin(), (X).end()
#define pb push_back
static struct FastInput {
static constexpr int BUF_SIZE = 1 << 20;
char buf[BUF_SIZE];
size_t chars_read = 0;
size_t buf_pos = 0;
FILE *in = stdin;
char cur = 0;
inline char get_char() {
if (buf_pos >= chars_read) {
chars_read = fread(buf, 1, BUF_SIZE, in);
buf_pos = 0;
buf[0] = (chars_read == 0 ? -1 : buf[0]);
}
return cur = buf[buf_pos++];
}
inline void tie(int) {}
inline explicit operator bool() {
return cur != -1;
}
inline static bool is_blank(char c) {
return c <= ' ';
}
inline bool skip_blanks() {
while (is_blank(cur) && cur != -1) {
get_char();
}
return cur != -1;
}
inline FastInput& operator>>(char& c) {
skip_blanks();
c = cur;
return *this;
}
inline FastInput& operator>>(string& s) {
if (skip_blanks()) {
s.clear();
do {
s += cur;
} while (!is_blank(get_char()));
}
return *this;
}
template <typename T>
inline FastInput& read_integer(T& n) {
// unsafe, doesn't check that characters are actually digits
n = 0;
if (skip_blanks()) {
int sign = +1;
if (cur == '-') {
sign = -1;
get_char();
}
do {
n += n + (n << 3) + cur - '0';
} while (!is_blank(get_char()));
n *= sign;
}
return *this;
}
template <typename T>
inline typename enable_if<is_integral<T>::value, FastInput&>::type operator>>(T& n) {
return read_integer(n);
}
#if !defined(_WIN32) || defined(_WIN64)
inline FastInput& operator>>(__int128& n) {
return read_integer(n);
}
#endif
template <typename T>
inline typename enable_if<is_floating_point<T>::value, FastInput&>::type operator>>(T& n) {
// not sure if really fast, for compatibility only
n = 0;
if (skip_blanks()) {
string s;
(*this) >> s;
sscanf(s.c_str(), "%lf", &n);
}
return *this;
}
} fast_input;
#define cin fast_input
static struct FastOutput {
static constexpr int BUF_SIZE = 1 << 20;
char buf[BUF_SIZE];
size_t buf_pos = 0;
static constexpr int TMP_SIZE = 1 << 20;
char tmp[TMP_SIZE];
FILE *out = stdout;
inline void put_char(char c) {
buf[buf_pos++] = c;
if (buf_pos == BUF_SIZE) {
fwrite(buf, 1, buf_pos, out);
buf_pos = 0;
}
}
~FastOutput() {
fwrite(buf, 1, buf_pos, out);
}
inline FastOutput& operator<<(char c) {
put_char(c);
return *this;
}
inline FastOutput& operator<<(const char* s) {
while (*s) {
put_char(*s++);
}
return *this;
}
inline FastOutput& operator<<(const string& s) {
for (int i = 0; i < (int) s.size(); i++) {
put_char(s[i]);
}
return *this;
}
template <typename T>
inline char* integer_to_string(T n) {
// beware of TMP_SIZE
char* p = tmp + TMP_SIZE - 1;
if (n == 0) {
*--p = '0';
} else {
bool is_negative = false;
if (n < 0) {
is_negative = true;
n = -n;
}
while (n > 0) {
*--p = (char) ('0' + n % 10);
n /= 10;
}
if (is_negative) {
*--p = '-';
}
}
return p;
}
template <typename T>
inline typename enable_if<is_integral<T>::value, char*>::type stringify(T n) {
return integer_to_string(n);
}
#if !defined(_WIN32) || defined(_WIN64)
inline char* stringify(__int128 n) {
return integer_to_string(n);
}
#endif
template <typename T>
inline typename enable_if<is_floating_point<T>::value, char*>::type stringify(T n) {
sprintf(tmp, "%.17f", n);
return tmp;
}
template <typename T>
inline FastOutput& operator<<(const T& n) {
auto p = stringify(n);
for (; *p != 0; p++) {
put_char(*p);
}
return *this;
}
} fast_output;
#define cout fast_output
#define endl '\n'
const int _ = 1e3 + 5;
const int mod = 998244353;
int a[_];
int m, n;
int qpow(int aa, int p) {
int ret = 1;
while (p) {
if (p & 1) ret = 1LL * ret * aa % mod;
aa = 1LL * aa * aa % mod;
p >>= 1;
}
return ret;
}
signed main() {
//freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
ios::sync_with_stdio(false);
cin.tie(0);
int start_time = clock();
/*
int T;
cin >> T;
while (T--) {
}*/
cin >> m;
fors(i, 1, m) cin >> a[i];
sort(a + 1, a + m + 1);
fors(i, 1, m) n += a[i];
int ret = 0, f = 0, g = 1, b = 0, d = -1, t;
fors(i, 1, m) {
for (; b < a[i]; b++) {
g = 1LL * g * (2 * n - b) % mod;
f = 1LL * (n - b) * f % mod;
f = (f + g) % mod;
d = 1LL * d * (n - b) % mod;
}
t = 1LL * f * qpow(d, mod-2) % mod;
ret = (ret + t) % mod;
//cout << ret << endl;
}
for (; b < n; b++) {
g = 1LL * g * (2 * n - b) % mod;
f = 1LL * (n - b) * f % mod;
f = (f + g) % mod;
d = 1LL * d * (n - b) % mod;
}
t = 1LL * f * qpow(d, mod-2) % mod;
ret = (ret - t) % mod;
ret = (ret + mod) % mod;
cout << ret << endl;
//cout << "time = " << clock() - start_time << endl;
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
int compare(const void* a, const void* b) { return (*(int*)a - *(int*)b); }
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b) return gcd(b, a % b);
return gcd(a, b % a);
}
int main() {
int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
int r = 0;
while (x1 != x2 || y1 != y2) {
if (x1 == 0) {
if (y1 < n)
y1++;
else
x1 = 1;
} else if (y1 == n) {
if (x1 < n)
x1++;
else
y1 = n - 1;
} else if (x1 == n) {
if (y1 > 0)
y1--;
else
x1 = n - 1;
} else {
if (x1 > 0)
x1--;
else
y1 = 1;
}
r++;
}
cout << min(r, 4 * n - r);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2009;
bool s[MAX][MAX];
int a, b, c, d, n, m, x, y;
void dfs(int i, int j) {
s[i][j] = 0, m++;
if (i > a || (i == a && j > b)) a = i, b = j;
if (i < c || (i == c && j < d)) c = i, d = j;
if (i + 1 < n && s[i + 1][j]) dfs(i + 1, j);
if (j + 1 < n && s[i][j + 1]) dfs(i, j + 1);
if (j && s[i][j - 1]) dfs(i, j - 1);
if (i && s[i - 1][j]) dfs(i - 1, j);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> s[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (s[i][j]) {
m = 0, a = -1, b = 20000, c = 20000, d = -1;
dfs(i, j);
double e = (a - c) * (a - c) + (b - d) * (b - d);
double m1 = e / 2.0;
double m2 = 3.14 * e / 4;
if (abs(m1 - m) < abs(m2 - m))
y++;
else
x++;
}
cout << x << " " << y;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T absll(T X) {
if (X < 0)
return -1 * X;
else
return X;
}
int main() {
int N;
scanf("%d", &N);
string str;
cin >> str;
int zeros = 0, ones = 0;
for (int i = 0; i < N; i++) {
if (str[i] == '0') {
++zeros;
} else {
++ones;
}
}
string res = "";
if (ones > 0) {
res = "1";
for (int i = 0; i < zeros; i++) {
res = res + "0";
}
cout << res << endl;
} else {
res = "0";
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e5 + 50;
int n, Select[maxn], cal[] = {0, 1, 2, 1, 4, 3, 2, 1, 5, 6, 2, 1, 8, 7, 5, 9,
8, 7, 3, 4, 7, 4, 2, 1, 10, 9, 3, 6, 11, 12, 14};
vector<int> vi;
map<int, int> Memory;
int GetMex(vector<int>& vi) {
if (!vi.size()) return 0;
sort(vi.begin(), vi.end());
if (*vi.begin() != 0) return 0;
for (int i = 1; i < vi.size(); ++i)
if (vi[i] - vi[i - 1] > 1) return vi[i - 1] + 1;
return vi.back() + 1;
}
int DFS(int mask) {
if (Memory.count(mask)) return Memory[mask];
vector<int> ret;
for (int i = 0; i < n; ++i)
if (mask >> i & 1) {
int j = i;
int newmask = mask;
while (j < n) {
newmask &= ~(1 << j);
j += (i + 1);
}
ret.push_back(DFS(newmask));
}
return Memory[mask] = GetMex(ret);
}
int Solve(int Limit) {
int sg = 0;
memset(Select, 0, sizeof(Select));
for (int i = 2; i * i <= Limit; ++i)
if (!Select[i]) {
long long j = i;
int cur = 0;
while (j <= Limit) {
if (j < maxn) Select[j] = 1;
++cur;
j *= i;
}
vi.push_back(cur);
}
int sum = 0;
for (auto it : vi) sum += it;
int cs = Limit - sum;
sg = (cs & 1) ? 1 : 0;
for (int i = 0; i < vi.size(); ++i) {
n = vi[i];
sg ^= cal[n];
}
return sg;
}
int main(int argc, char* argv[]) {
n = read();
if (Solve(n))
puts("Vasya");
else
puts("Petya");
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
using namespace std;
const int N = 1e5 + 1, M = 1e7 + 1;
set<int> s[N];
set<int>::iterator p, p1, p2;
int a[N], n, m;
struct node {
int l, r, ls, rs, s;
node() { ls = rs = s = 0; }
} h[M];
int tot, root[N];
void update(int &t, int l, int r, int y, int x) {
if (t == 0) t = ++tot;
h[t].l = l, h[t].r = r, h[t].s += x;
if (l == r) return;
int mid = (l + r) / 2;
if (y <= mid)
update(h[t].ls, l, mid, y, x);
else
update(h[t].rs, mid + 1, r, y, x);
}
long long query(int t, int l, int r) {
if (t == 0) return 0;
if (h[t].l >= l && h[t].r <= r) {
return h[t].s;
}
int mid = (h[t].l + h[t].r) / 2;
long long ans = 0;
if (l <= mid) ans += query(h[t].ls, l, r);
if (r > mid) ans += query(h[t].rs, l, r);
return ans;
}
void add(int x, int y, int z) {
if (x < 1 || y < 1 || x > n || y > n) return;
for (; x <= n; x += x & -x) update(root[x], 1, n, y, z);
}
long long sum(int x, int y, int z) {
long long ans = 0;
for (; x > 0; x -= x & -x) ans += query(root[x], y, z);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
srand(time(0));
cin >> n >> m;
for (int i = 1; i <= n; i++) s[i].insert(0), s[i].insert(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[a[i]].insert(i);
p1 = p2 = p = s[a[i]].find(i);
add(i, *(--p1), i - *(--p2));
}
while (m--) {
int op, aa, bb;
cin >> op >> aa >> bb;
if (op == 1) {
p1 = p2 = p = s[a[aa]].find(aa);
p1--, p2++;
add(aa, *p1, *p1 - aa);
add(*p2, aa, aa - *p2);
add(*p2, *p1, *p2 - *p1);
s[a[aa]].erase(p);
a[aa] = bb;
s[bb].insert(aa);
p1 = p2 = p = s[bb].find(aa);
p1--, p2++;
add(aa, *p1, aa - *p1);
add(*p2, aa, *p2 - aa);
add(*p2, *p1, *p1 - *p2);
} else
cout << sum(bb, aa, bb) - sum(aa - 1, aa, bb) << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
string W[200000];
map<string, int> mp;
string F[200000], T[200000];
signed long long sc[400000];
vector<int> E[300000];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N;
for (i = 0; i < N; i++) {
cin >> W[i];
for (__typeof(W[i].begin()) it = W[i].begin(); it != W[i].end(); it++)
*it = tolower(*it);
mp[W[i]] = 0;
}
cin >> M;
for (i = 0; i < M; i++) {
cin >> F[i] >> T[i];
for (__typeof(F[i].begin()) it = F[i].begin(); it != F[i].end(); it++)
*it = tolower(*it);
for (__typeof(T[i].begin()) it = T[i].begin(); it != T[i].end(); it++)
*it = tolower(*it);
mp[F[i]] = mp[T[i]] = 0;
}
i = 0;
for (__typeof(mp.begin()) it = mp.begin(); it != mp.end(); it++) {
it->second = i;
sc[i] = 10000000LL * count(it->first.begin(), it->first.end(), 'r') +
it->first.size();
i++;
}
for (i = 0; i < M; i++) E[mp[T[i]]].push_back(mp[F[i]]);
priority_queue<pair<signed long long, int> > Q;
for (i = 0; i < mp.size(); i++) Q.push(make_pair(-sc[i], i));
while (!Q.empty()) {
signed long long s = -Q.top().first;
int k = Q.top().second;
Q.pop();
if (s != sc[k]) continue;
for (i = 0; i < E[k].size(); i++) {
int tar = E[k][i];
if (sc[tar] > sc[k]) {
sc[tar] = sc[k];
Q.push(make_pair(-sc[tar], tar));
}
}
}
signed long long tr = 0, tl = 0;
for (i = 0; i < N; i++) {
signed long long s = sc[mp[W[i]]];
tr += s / 10000000;
tl += s % 10000000;
}
(void)printf("%lld %lld\n", tr, tl);
}
int main(int argc, char **argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < argc - 1; i++) s += argv[i + 1], s += '\n';
for (i = 0; i < s.size(); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 11;
struct Node {
long long x, idx;
friend bool operator<(const Node& a, const Node& b) { return a.x < b.x; }
};
Node arr[N];
long long sum[N];
long long f[N];
int n, m;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &arr[i].x), arr[i].idx = i;
sort(arr + 1, arr + n + 1);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + arr[i].x;
for (int i = 1; i <= n; ++i)
f[i] = f[i - 1] + arr[i].x * (i - 1) - sum[i - 1];
scanf("%d", &m);
long long ans = f[m], st = m;
for (int i = m + 1; i <= n; ++i) {
long long tmp =
f[i] - ((sum[i] - sum[i - m]) * (i - m) - sum[i - m] * m) - f[i - m];
if (tmp < ans) ans = tmp, st = i;
}
st = st - m + 1;
for (int i = 0; i < m; ++i) {
printf("%d", arr[i + st].idx);
if (i != m - 1)
printf(" ");
else
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int main() {
int x1, x2, y1, y2, r1, r2;
cin >> x1 >> y1 >> r1;
cin >> x2 >> y2 >> r2;
double dist = sqrt(1. * (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) * 1.);
cout.precision(20);
if (dist >= r1 + r2)
cout << (dist - r1 - r2) * 0.5;
else if (dist >= max(r1, r2))
cout << 0;
else
cout << max(0., max(r1, r2) - dist - min(r1, r2)) * 0.5;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline ll read() {
ll x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const ll N = 1e5 + 10;
ll n, root, sz[N], c[N], f[N];
ll k, mn, mx;
struct edge {
ll y, next;
} a[N * 2];
ll len, last[N];
inline void ins(ll x, ll y) {
a[++len] = (edge){y, last[x]};
last[x] = len;
}
inline void dfs(ll x, ll fa) {
sz[x] = f[x] = 1;
for (ll k = last[x], y; k; k = a[k].next)
if ((y = a[k].y) ^ fa) {
dfs(y, x);
sz[x] += sz[y];
f[x] = f[x] > sz[y] ? f[x] : sz[y];
mn += sz[y] & 1;
mx += min(sz[y], n - sz[y]);
}
f[x] = f[x] > n - sz[x] ? f[x] : n - sz[x];
}
inline void DFS(ll x, ll fa) {
sz[x] = 1;
for (ll k = last[x], y; k; k = a[k].next)
if ((y = a[k].y) ^ fa) {
DFS(y, x);
sz[x] += sz[y];
}
c[sz[x]]++;
}
ll son[N], tot, A[N], B[N];
vector<ll> d[N];
inline void solve(ll x, ll fa) {
sz[x] = 1;
for (ll k = last[x], y; k; k = a[k].next)
if ((y = a[k].y) ^ fa) {
solve(y, x);
sz[x] += c[y];
}
son[tot = 1] = x;
d[x].push_back(x);
for (ll k = last[x], y; k; k = a[k].next)
if ((y = a[k].y) ^ fa) son[++tot] = y;
ll st = 1, ed = tot, tt = (sz[x] - c[x]) / 2;
for (ll i = 1; i <= tt; i++) {
while (d[son[st]].empty()) st++;
A[i] = d[son[st]].back();
d[son[st]].pop_back();
while (d[son[ed]].empty()) ed--;
B[i] = d[son[ed]].back();
d[son[ed]].pop_back();
}
for (ll i = 1; i <= tt; i++) printf("%lld %lld\n", A[i], B[tt - i + 1]);
for (ll i = st > 2 ? st : 2; i <= ed; i++) {
if (d[son[i]].size() > d[x].size()) swap(d[son[i]], d[x]);
for (ll j : d[son[i]]) d[x].push_back(j);
}
}
int main() {
n = read();
k = read();
for (ll i = 1, x, y; i < n; i++) {
x = read();
y = read();
ins(x, y);
ins(y, x);
}
dfs(1, 0);
root = 1;
for (ll i = 2; i <= n; i++)
if (f[i] < f[root]) root = i;
if (!(mn <= k && k <= mx) || (k - mn) & 1) {
puts("NO");
exit(0);
}
DFS(root, 0);
ll p = n - 1;
for (; p > 1; p--)
if (mx - 2 * c[p] >= k) {
mx -= 2 * c[p];
c[p - 2] += c[p];
} else
break;
for (ll i = 1; i <= n; i++) c[i] = min(sz[i], p - (p + sz[i]) % 2);
c[root] = 0;
for (ll i = 1; i <= n; i++)
if (c[i] == p && mx > k) {
c[i] -= 2;
mx -= 2;
}
puts("YES");
solve(root, 0);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
int bit[N];
void update(int pos) {
for (; pos < N; pos += pos & -pos) bit[pos]++;
}
int query(int pos) {
int ans = 0;
for (; pos; pos -= pos & -pos) ans += bit[pos];
return ans;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> vet(n + 1);
for (int i = 0; i <= n; i++) vet[i] = i;
for (int i = 1; i <= n / 2 and i <= k; i++) swap(vet[i], vet[n - i + 1]);
long long ans = 0;
for (int i = n; i; i--) {
ans += query(vet[i]);
update(vet[i]);
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int inf = (int)1e9;
const double inf1 = 1e-9;
int main() {
int n;
scanf("%d", &n);
vector<int> mas;
int i = 1;
int k = 2;
vector<bool> b(2 * inf);
bool t = false;
while (i < 2 * inf) {
mas.push_back(i);
b[i] = true;
i += k;
++k;
}
for (int j = 0; j < mas.size(); ++j) {
if (n - mas[j] < 0) break;
if (b[n - mas[j]] == true) {
t = true;
break;
}
}
if (t)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
struct ListNode {
int val;
ListNode* next;
ListNode(int x) : val(x), next(NULL) {}
};
int nxt() {
int x;
cin >> x;
return x;
}
long long nxtLong() {
long long x;
cin >> x;
return x;
}
string nxtStr() {
string x;
cin >> x;
return x;
}
char nxtChar() {
char x;
cin >> x;
return x;
}
double nxtDouble() {
double x;
cin >> x;
return x;
}
long double nxtLDouble() {
long double x;
cin >> x;
return x;
}
TreeNode* makeTree(int n) {
queue<TreeNode*> tree_nodes;
TreeNode* root;
if (n) {
root = new TreeNode(nxt());
tree_nodes.push(root);
} else {
return NULL;
}
while (!tree_nodes.empty()) {
TreeNode* node = tree_nodes.front();
tree_nodes.pop();
bool left;
cin >> left;
if (left) {
node->left = new TreeNode(nxt());
tree_nodes.push(node->left);
}
bool right;
cin >> right;
if (right) {
node->right = new TreeNode(nxt());
tree_nodes.push(node->right);
}
}
return root;
}
ListNode* makeLinkedList(int n) {
ListNode* list = new ListNode(0);
ListNode* dummy = list;
for (int i = 0; i < n; ++i) {
list->next = new ListNode(nxt());
list = list->next;
}
return dummy->next;
}
const int N = 100005;
bool primes(int n) {
if (n == 2 || n == 3) {
return true;
}
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
void solve() {
int n = nxt();
vector<int> div;
for (int i = 2; i <= sqrt(n); ++i) {
if (n % i == 0) {
div.push_back(i);
if (i != n / i) {
div.push_back(n / i);
}
}
}
div.push_back(n);
sort((div).begin(), (div).end());
vector<int> prime;
int st = 2, ans = 0;
int temp = n;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
prime.push_back(i);
while (n % i == 0) {
n /= i;
}
}
}
if (n > 1) {
prime.push_back(n);
}
if (div.size() - prime.size() >= prime.size()) {
ans = 0;
} else {
ans = 2 * prime.size() - div.size();
}
int sz = prime.size();
unordered_map<int, bool> used(N);
vector<int> connect(sz);
if (div.size() == 3 && primes(div[0]) && primes(div[1])) {
for (auto x : div) {
cout << x << ' ';
}
cout << endl << 1 << endl;
return;
}
for (int i = 0; i < sz; ++i) {
int p = prime[i], q = prime[(i + 1) % sz];
for (int j = 0; j < div.size(); ++j) {
if (!used[div[j]] && div[j] % p == 0 && div[j] % q == 0) {
used[div[j]] = true;
connect[i] = div[j];
break;
}
}
}
for (int i = 0; i < sz; ++i) {
cout << prime[i] << ' ';
used[prime[i]] = true;
for (int j = 0; j < div.size(); ++j) {
if (!used[div[j]] && div[j] % prime[i] == 0) {
used[div[j]] = true;
cout << div[j] << ' ';
}
}
if (prime.size() > 1) {
cout << connect[i] << ' ';
}
}
cout << endl << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(9);
int t = nxt();
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[100];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
for (int j = 0; j < n; ++j) {
if (arr[j] < 0 && j % 2 == 0) arr[j] = -arr[j];
if (arr[j] > 0 && j % 2 != 0) arr[j] = -arr[j];
}
for (int k = 0; k < n; ++k) {
cout << arr[k] << " ";
}
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int N = 1.5e5;
int n, m, sz[N];
vector<int> adjListFull[N];
vector<int> adjList[N];
set<int> bad;
pii dp[N];
bool dfsBuild(int v, int p) {
bool good = bad.count(v);
for (int u : adjListFull[v]) {
if (u == p) continue;
bool tgood = dfsBuild(u, v);
good = good || tgood;
if (tgood) {
adjList[v].emplace_back(u);
adjList[u].emplace_back(v);
sz[v] += sz[u] + 1;
}
}
return good;
}
int border = INT_MAX;
int border_depth = -1;
void dfs(int v, int p, int d) {
if (d == border_depth) {
border = min(v, border);
}
if (d > border_depth) {
border = v;
border_depth = d;
}
for (int u : adjList[v]) {
if (u == p) continue;
dfs(u, v, d + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int a, b;
for (int i = 1; i < n; i++) {
cin >> a >> b;
adjListFull[a].emplace_back(b);
adjListFull[b].emplace_back(a);
}
for (int i = 0; i < m; i++) {
cin >> a;
bad.insert(a);
}
int s = *bad.begin();
dfsBuild(s, -1);
dfs(s, -1, 0);
int ob = border;
dfs(border, -1, 0);
border = min(ob, border);
cout << border << '\n';
cout << 2 * sz[s] - border_depth << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
int arr[200005];
int tree[800020][2];
void build_tree(int node, int a, int b, int i, int lim) {
if (a > b) return;
if (a == b) {
tree[node][i] = arr[a];
return;
}
build_tree(node * 2, a, (a + b) / 2, i, lim);
build_tree(node * 2 + 1, 1 + (a + b) / 2, b, i, lim);
tree[node][i] = 0;
if (a == (a + b) / 2)
tree[node][i] = min(tree[node * 2][i], lim);
else
tree[node][i] = tree[node * 2][i];
if (1 + (a + b) / 2 == b)
tree[node][i] += min(tree[node * 2 + 1][i], lim);
else
tree[node][i] += tree[node * 2 + 1][i];
}
void update_tree(int node, int a, int b, int i, int j, int value, int t,
int lim) {
if (a > b || a > j || b < i) return;
if (a >= i && b <= j) {
tree[node][t] += value;
return;
}
update_tree(node * 2, a, (a + b) / 2, i, j, value, t, lim);
update_tree(1 + node * 2, 1 + (a + b) / 2, b, i, j, value, t, lim);
tree[node][t] = 0;
if (a == (a + b) / 2)
tree[node][t] = min(tree[node * 2][t], lim);
else
tree[node][t] = tree[node * 2][t];
if (1 + (a + b) / 2 == b)
tree[node][t] += min(tree[node * 2 + 1][t], lim);
else
tree[node][t] += tree[node * 2 + 1][t];
}
int query_tree(int node, int a, int b, int i, int j, int t, int lim) {
if (a > b || a > j || b < i) return 0;
if (a >= i && b <= j) {
if (a == b) return min(tree[node][t], lim);
return tree[node][t];
}
int q1 = query_tree(node * 2, a, (a + b) / 2, i, j, t, lim);
int q2 = query_tree(1 + node * 2, 1 + (a + b) / 2, b, i, j, t, lim);
int res = q1 + q2;
return res;
}
int main() {
cin >> n >> k >> a >> b >> q;
build_tree(1, 0, n + 1, 0, a);
build_tree(1, 0, n + 1, 1, b);
for (int i = 0; i < q; i++) {
int tipo;
cin >> tipo;
if (tipo - 1) {
int dia;
cin >> dia;
cout << query_tree(1, 1, n + 1, 1, dia - 1, 1, b) +
query_tree(1, 1, n + 1, dia + k, n, 0, a)
<< endl;
} else {
int dia, val;
cin >> dia >> val;
update_tree(1, 1, n + 1, dia, dia, val, 0, a);
update_tree(1, 1, n + 1, dia, dia, val, 1, b);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long suma = 0, sumb = 0, sumc = 0, x;
for (long long i = 0; i < n; i++) cin >> x, suma += x;
for (long long i = 0; i < n - 1; i++) cin >> x, sumb += x;
for (long long i = 0; i < n - 2; i++) cin >> x, sumc += x;
cout << suma - sumb << endl << sumb - sumc;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
int a[N], ans[N];
int main() {
int n, i, k, x, f;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", a + i);
for (i = 1; i < n; i++) {
for (k = 1; k < n;) {
x = (i + k - 1) / k;
f = 0;
if (a[x - 1] > a[i]) {
ans[k]++;
f = 1;
}
if (x <= 1) break;
k = (i + x - 2) / (x - 1);
if (f) ans[k]--;
}
}
for (i = 1; i < n; i++) {
ans[i] += ans[i - 1];
printf("%d ", ans[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, c = 0, ma = 0;
cin >> t;
long int k, k1;
cin >> k;
c = 1;
for (i = 0; i < t - 1; i++) {
cin >> k1;
if (k1 <= 2 * k)
c += 1;
else {
ma = max(ma, c);
c = 1;
}
k = k1;
}
ma = max(ma, c);
cout << ma;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char buf[100020];
char f[30][10];
int main() {
while (scanf("%s", buf) != EOF) {
string s(buf);
int K;
scanf("%d", &K);
for (int i = 0; i < (int)(K); ++i) scanf("%s", f[i]);
map<char, int> to;
for (int i = 0; i < (int)(K); ++i) {
to[f[i][0]] = i + 1;
to[f[i][1]] = i + 1;
}
int N = (int)((s).size());
int prev = -1, res = 0;
map<char, int> acc;
for (int i = 0; i < (int)(N + 1); ++i) {
if (prev >= -1 && (to[s[i]] != prev || i == N)) {
if ((int)((acc).size()) == 2) {
int temp = 1 << 29;
for (__typeof((acc).begin()) it = (acc).begin(); it != (acc).end();
++it)
temp = min(temp, it->second);
res += temp;
}
acc.clear();
}
if (i == N) break;
if (to[s[i]] >= 1) {
acc[s[i]]++;
prev = to[s[i]];
} else {
prev = -1;
}
}
printf("%d\n", res);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char alphz[27] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
float Euclidean(long long x1, long long x2, long long y1, long long y2) {
return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
}
long long GCD(long long a, long long b) { return !b ? a : GCD(b, a % b); }
long long LCM(long long a, long long b) { return (a * b) / GCD(a, b); }
void PrimeFactor(long long n) {
while (n % 2 == 0) {
n /= 2;
}
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
n /= i;
}
}
if (n > 2) {
};
}
bool Is_Square(long long x) {
long long l = 0, r = x;
while (l <= r) {
long long mid = l + (r - l) / 2;
if (mid * mid == x) return true;
if (mid * mid > x)
r = mid - 1;
else
l = mid + 1;
}
return false;
}
long long Power(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = Power(x, y / 2);
if (y % 2 == 0)
return (temp * temp);
else
return (x * temp * temp);
}
bool Is_Prime(int x) {
if (x == 2)
return 1;
else if (x % 2 == 0 || x < 2)
return 0;
for (int i = 3; i * i <= x; i += 2)
if (x % i == 0) return 0;
return 1;
}
bool Is_Palin(string s) {
int i = 0, j = (int)s.size() - 1;
while (i < j) {
if (s[i] != s[j]) return 0;
i++, j--;
}
return 1;
}
vector<int> a;
int n, mem[101][51][51][2];
int solv(vector<int> a, int idx, int od, int ev) {
if (idx >= n) return 0;
int prev;
if (!idx)
prev = a[0] & 1;
else
prev = a[idx - 1] & 1;
int& ret = mem[idx][od][ev][prev];
if (ret != -1) return ret;
int ans = 1e5, mo = 1e5;
if (a[idx] == 0) {
int OD = od;
if (od > 0) {
a[idx] = 1;
od--;
ans = solv(a, idx + 1, od, ev);
if (idx) ans += a[idx - 1] & 1 ? 0 : 1;
a[idx] = 0;
}
if (ev) {
a[idx] = 2;
ev--;
mo = solv(a, idx + 1, OD, ev);
if (idx) mo += a[idx - 1] & 1 ? 1 : 0;
a[idx] = 0;
}
ans = min(ans, mo);
} else {
ans = solv(a, idx + 1, od, ev);
if (idx) {
if ((a[idx] & 1) == (a[idx - 1] & 1))
ans += 0;
else
ans += 1;
}
}
return ret = ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
a.resize(n);
set<int> evSet, odSet;
int ev = 0, od = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] != 0 && a[i] % 2 == 0)
evSet.insert(a[i]);
else if (a[i] != 0 && a[i] % 2 != 0)
odSet.insert(a[i]);
}
for (int i = 1; i <= n; i++) {
if (i % 2 == 0) {
if (evSet.find(i) == evSet.end()) ev++;
} else {
if (odSet.find(i) == odSet.end()) od++;
}
}
memset(mem, -1, sizeof(mem));
int ans = solv(a, 0, od, ev);
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int ceil2(long long int a, long long int b) {
return (a + b - 1) / b;
}
int hcf(int n1, int n2) {
if (n2 != 0)
return hcf(n2, n1 % n2);
else
return n1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, input;
vector<int> ice;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
ice.push_back(input);
}
map<int, long long int> pos_odd;
map<int, long long int> pos_even;
int xorx = 0;
long long int soluchan = 0;
for (int i = 0; i < n; i++) {
xorx = xorx ^ ice[i];
if (i % 2 == 1) {
pos_odd[xorx]++;
if (xorx != 0) {
soluchan += (pos_odd[xorx] - 1);
} else {
soluchan += (pos_odd[xorx]);
}
} else {
pos_even[xorx]++;
soluchan += (pos_even[xorx] - 1);
}
}
cout << soluchan << endl;
ice.clear();
pos_even.clear();
pos_odd.clear();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, m, x, y, k;
cin >> n;
int b[n];
for (i = 0; i < n; i++) {
cin >> b[i];
}
cin >> m;
int a[m][2];
for (i = 0; i < m; i++) {
cin >> a[i][0];
cin >> a[i][1];
}
for (i = 0; i < m; i++) {
x = a[i][0];
y = a[i][1];
if (x >= 2 && x <= n - 1) {
b[x - 2] = b[x - 2] + y - 1;
b[x] = b[x] + b[x - 1] - y;
b[x - 1] = 0;
} else if (x < 2) {
b[x] = b[x] + b[x - 1] - y;
b[x - 1] = 0;
} else if (x > n - 1) {
b[x - 2] = b[x - 2] + y - 1;
b[x - 1] = 0;
}
}
for (i = 0; i < n; i++) {
cout << b[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q, x, y;
set<int> s;
set<int>::iterator it;
int a[200001];
int main() {
cin >> n >> k >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < q; i++) {
cin >> x >> y;
y--;
if (x == 1) {
s.insert(-1 * a[y]);
if (s.size() > k) {
it = s.end();
it--;
s.erase(it);
}
} else {
if (s.count(-1 * a[y])) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n <= 3) {
cout << "-1\n";
continue;
}
for (int i = 1 + !(n & 1); i <= n; i += 2) cout << i << ' ';
cout << n - 3 << ' ' << n - 1 << ' ';
for (int i = n - 5; i > 0; i -= 2) cout << i << ' ';
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll power(ll x, ll y, ll p)
{
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
if (x == 0) return 0; // In case x is divisible by p;
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = (res*x) % p;
// y must be even now
y = y>>1; // y = y/2
x = (x*x) % p;
}
return res;
}
ll cal(ll a,ll b){
ll ans=1e18;
for(ll i=0;i<=100;i++){
if(b+i<=1)continue;
ll fans=i;
ll t=a;
while(t>0){
t/=(i+b);
fans++;
}
ans=min(ans,fans);
}
return ans;
}
ll dfs3(vector<set<int>>&e1,vector<set<int>>&e2,vector<set<int>>&e3,int i,vector<ll>&a1,vector<ll>&a2,vector<ll>&a3,vector<ll>&a4,vector<ll>&b1,vector<ll>&b2,vector<ll>&b3,vector<ll>&b4,ll &n1,ll &n2,ll &n3, ll &n4){
ll ans1=1e18;
if(b3[i]!=-1)return b3[i];
for(int j=0;j<n4;j++){
if(e3[i].find(j)==e3[i].end()){
ans1=min(ans1,a3[i]+a4[j]);
}
}
return b3[i]=ans1;
}
ll dfs2(vector<set<int>>&e1,vector<set<int>>&e2,vector<set<int>>&e3,int i,vector<ll>&a1,vector<ll>&a2,vector<ll>&a3,vector<ll>&a4,vector<ll>&b1,vector<ll>&b2,vector<ll>&b3,vector<ll>&b4,ll &n1,ll &n2,ll &n3, ll &n4){
ll ans1=1e18;
if(b2[i]!=-1)return b2[i];
for(int j=0;j<n3;j++){
if(e2[i].find(j)==e2[i].end()){
ans1=min(ans1,a2[i]+dfs3(e1,e2,e3,j,a1,a2,a3,a4,b1,b2,b3,b4,n1,n2,n3,n4));
}
}
return b2[i]=ans1;
}
ll dfs1(vector<set<int>>&e1,vector<set<int>>&e2,vector<set<int>>&e3,int i,vector<ll>&a1,vector<ll>&a2,vector<ll>&a3,vector<ll>&a4,vector<ll>&b1,vector<ll>&b2,vector<ll>&b3,vector<ll>&b4,ll &n1,ll &n2,ll &n3, ll &n4){
ll ans1=1e18;
if(b1[i]!=-1)return b1[i];
for(int j=0;j<n2;j++){
if(e1[i].find(j)==e1[i].end()){
ans1=min(ans1,a1[i]+dfs2(e1,e2,e3,j,a1,a2,a3,a4,b1,b2,b3,b4,n1,n2,n3,n4));
}
}
return b1[i]=ans1;
}
void build (vector<ll>&ans,vector<ll>&arr,ll l,ll s,ll e){
if(s>e)return;
ll in=0;
ll m=0;
for(int i=s;i<=e;i++){
if(arr[i]>m){
m=arr[i];
in=i;
}
}
ans[in]=l;
build(ans,arr,l+1,s,in-1);
build(ans,arr,l+1,in+1,e);
}
ll find(map<ll,map<ll,ll>>&a,ll st,ll e){
int x;
if(a.find(st)!=a.end()){
if(a[st].find(e)!=a[st].end()){
x=a[st][e];
}
else{
cout<<"? "<<st<<" "<<e<<endl;
cin>>x;
}
}
else{
cout<<"? "<<st<<" "<<e<<endl;
cin>>x;
}
return a[st][e]=x;
}/*int spf[10000001];
void pre()
{
for(int i=1;i<=1e7;i++){
spf[i]=i;
}
for(int i=2;i*i<=1e7;i++){
if(spf[i]==i){
for(int j=i*i;j<=1e7;j+=i){
if(spf[j]==j){
spf[j]=i;
}
}
}
}
}*/
int getpar(int x,vector<int>&par){
if(par[x]==x)return x;
else {
return par[x]=getpar(par[x],par);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t=1;
cin>>t;
//pre();
//cout<<p.size()<<endl;
while(t--){
ll n;
cin>>n;
vector<ll>arr(n);
for(int i=0;i<n;i++){
cin>>arr[i];
}
ll osum=arr[0];
ll esum=arr[1];
ll oans=arr[0]*n;
ll o=1,e=1;
ll eans=arr[1]*n;
ll ans=eans+oans;
ll mo=arr[0],me=arr[1];
for(int i=2;i<n;i++){
if(i%2==0){
o++;
mo=min(mo,arr[i]);
oans=osum+arr[i]+mo*(n-o);
ans=min(ans,oans+eans);
osum+=arr[i];
}
else {
e++;
me=min(me,arr[i]);
eans=esum+arr[i]+me*(n-e);
ans=min(ans,oans+eans);
esum+=arr[i];
}
//cout<<i<<" "<<ans<<" "<<oans<<" "<<eans<<" "<<osum<<" "<<esum<<endl;
}
cout<<ans<<endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int l = 8 * n + 1;
double m = sqrt(l);
int k = sqrt(l);
if (m == k)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void dbg(char* fmt, ...) {}
const int N = 7;
const int M = 50;
const int POW3 = 3 * 3 * 3 * 3 * 3 * 3 * 3;
int pow3[N + 1];
int dp[M][N][POW3];
int getBit(int mask, int pos) {
if (pos < 0) return 2;
mask /= pow3[pos];
return mask % 3;
}
void setMask(int& mask, int pos, int val) {
if (pos < 0) throw 42;
mask += (val - getBit(mask, pos)) * pow3[pos];
}
void updateDP(int col, int row, int mask, int val) {
int& res = dp[col][row][mask];
res = min(res, val);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n > m) swap(n, m);
pow3[0] = 1;
for (int i = 1; i < N; ++i) pow3[i] = pow3[i - 1] * 3;
memset(dp, 0x7f, sizeof(dp));
int startMask = 0;
for (int i = 0; i < n; ++i) startMask = startMask * 3 + 2;
dp[0][0][startMask] = 0;
for (int col = 0; col < m; ++col)
for (int row = 0; row <= n; ++row)
for (int mask = 0; mask < pow3[n]; ++mask) {
if (dp[col][row][mask] > n * m) continue;
if (row == n) {
dp[col + 1][0][mask] = dp[col][n][mask];
} else {
int upBit = getBit(mask, row - 1);
int leftBit = getBit(mask, row);
int newMask = mask;
if (leftBit != 1) {
setMask(newMask, row, (leftBit == 0 || upBit == 0) ? 2 : 1);
updateDP(col, row + 1, newMask, dp[col][row][mask]);
}
newMask = mask;
setMask(newMask, row, 0);
if (upBit == 1) setMask(newMask, row - 1, 2);
updateDP(col, row + 1, newMask, dp[col][row][mask] + 1);
}
}
int res = n * m;
for (int mask = 0; mask < pow3[n]; ++mask) {
bool good = true;
for (int i = 0; i < n; ++i) good &= (getBit(mask, i) != 1);
if (good) res = min(res, dp[m][0][mask]);
}
printf("%d\n", n * m - res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
while (T--) {
int n;
cin >> n;
vector<int> a(n), b(n), apos(n + 1), bpos(n + 1);
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
apos[a[i]] = i;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
bpos[b[i]] = i;
}
for (int i = 0; i < n; i++) {
int x = (bpos[a[i]] - i + n) % n;
mp[x]++;
}
int ans = 0;
for (auto it : mp) {
ans = max(ans, it.second);
}
cout << ans;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct seg {
int s, e, num;
} a[maxn];
int ox[maxn];
bool used[maxn];
bool cmp(seg a, seg b) {
if (a.e == b.e)
return a.s > b.s;
else
return a.e > b.e;
}
int main() {
ios::sync_with_stdio(false);
memset(ox, 0, sizeof(ox));
memset(used, 0, sizeof(used));
int n, k;
int mn = 0x3f3f3f3f, mx = -1;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].s >> a[i].e;
if (a[i].s < mn) mn = a[i].s;
if (a[i].e > mx) mx = a[i].e;
a[i].num = i;
for (int j = a[i].s; j <= a[i].e; j++) {
ox[j]++;
}
}
vector<int> ans;
sort(a + 1, a + n + 1, cmp);
for (int i = mn; i <= mx; i++) {
if (ox[i] > k) {
int cnt = ox[i] - k;
for (int j = 1; j <= n; j++) {
if (i >= a[j].s && i <= a[j].e && !used[j]) {
for (int k = a[j].s; k <= a[j].e; k++) ox[k]--;
ans.push_back(a[j].num);
used[j] = true;
cnt--;
}
if (cnt == 0) break;
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 1e5 + 5, md = 998244353;
inline int add(int x, int y) {
x += y;
if (x >= md) x -= md;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += md;
return x;
}
inline int mul(int x, int y) { return 1ll * x * y % md; }
inline int fpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x);
y >>= 1;
x = mul(x, x);
}
return ans;
}
struct event_t {
int pos, v, dis, _a, _b;
event_t(int a = 0, int b = 0, int c = 0, int d = 0, int e = 0)
: pos(a), v(b), dis(c), _a(d), _b(e) {}
} e[N << 1];
bool operator<(const event_t a, const event_t b) {
return 1ll * a.dis * b.v < 1ll * b.dis * a.v;
}
struct mat {
int a[2][2];
} p[N << 2];
mat operator*(const mat a, const mat b) {
mat ans;
memset(ans.a, 0, sizeof(ans.a));
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ans.a[i][j] = add(ans.a[i][j], mul(a.a[i][k], b.a[k][j]));
}
}
}
return ans;
}
int a[N], v[N], P[N];
int n, tot, inv, lasv = 0, ans;
void update(int u) { p[u] = p[u << 1] * p[u << 1 | 1]; }
void build(int u, int l, int r) {
if (l == r) {
p[u].a[0][1] = p[u].a[1][1] = P[l];
p[u].a[0][0] = p[u].a[1][0] = sub(1, P[l]);
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
update(u);
}
void change(int u, int L, int R, int x, int a, int b) {
if (L == R) {
p[u].a[a][b] = 0;
return;
}
int mid = (L + R) >> 1;
if (mid >= x)
change(u << 1, L, mid, x, a, b);
else
change(u << 1 | 1, mid + 1, R, x, a, b);
update(u);
}
int main() {
read(n);
inv = fpow(100, md - 2);
for (int i = 1; i <= n; i++)
read(a[i]), read(v[i]), read(P[i]), P[i] = mul(P[i], inv);
for (int i = 2; i <= n; i++) {
e[++tot] = event_t(i, v[i - 1] + v[i], a[i] - a[i - 1], 1, 0);
if (v[i - 1] < v[i])
e[++tot] = event_t(i, v[i] - v[i - 1], a[i] - a[i - 1], 0, 0);
if (v[i - 1] > v[i])
e[++tot] = event_t(i, v[i - 1] - v[i], a[i] - a[i - 1], 1, 1);
}
sort(e + 1, e + tot + 1);
build(1, 1, n);
for (int i = 1; i <= tot; i++) {
int nowv = mul(e[i].dis, fpow(e[i].v, md - 2));
ans = add(ans, mul(add(p[1].a[0][0], p[1].a[0][1]), sub(nowv, lasv)));
lasv = nowv;
change(1, 1, n, e[i].pos, e[i]._a, e[i]._b);
}
ans = sub(ans, mul(add(p[1].a[0][0], p[1].a[0][1]), lasv));
print(ans, '\n');
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t = 1;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
long long int i, j, k, m, n, ans = 0, cn = 0, op = 0;
cin >> n;
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == '(') {
if (op)
op--;
else
cn++;
} else {
cn--;
if (cn < 0) ans = max(ans, -1 * cn);
}
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
std::vector<int> edges[100000];
std::vector<int> cycle;
int vis[100000];
int depth[100001];
int far[100000];
int bad[100000];
bool dfs_cycle(int node, int ign) {
if (node == ign) return false;
if (vis[node] == 2) return false;
if (vis[node] == 1) {
cycle.erase(cycle.begin(), std::find(cycle.begin(), cycle.end(), node));
return true;
}
vis[node] = 1;
cycle.push_back(node);
for (int child : edges[node]) {
if (dfs_cycle(child, ign)) return true;
}
cycle.pop_back();
vis[node] = 2;
return false;
}
int dfs_far(int node) {
if (vis[node]) return far[node];
vis[node] = 1;
for (int child : edges[node]) {
int x = depth[child] ? child : dfs_far(child);
if (depth[x] > depth[far[node]]) {
far[node] = x;
}
}
return far[node];
}
int main() {
int N, M;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int U, V;
scanf("%d %d", &U, &V);
U--, V--;
edges[U].push_back(V);
}
for (int i = 0; i < N; i++) {
if (dfs_cycle(i, -1)) break;
}
for (int i = 0; i < cycle.size(); i++) {
depth[cycle[i]] = i;
}
std::fill(vis, vis + N, 0);
std::fill(far, far + N, N);
for (int node : cycle) {
depth[node] += cycle.size();
dfs_far(node);
}
for (int i = 0; i < cycle.size(); i++) {
assert(far[cycle[i]] != N);
int a = (i + 1) % cycle.size(), b = depth[far[cycle[i]]] % cycle.size();
bad[a]++;
bad[b]--;
if (a > b) {
bad[0]++;
}
}
for (int i = 1; i < cycle.size(); i++) {
bad[i] += bad[i - 1];
}
for (int i = 0; i < cycle.size(); i++) {
if (!bad[i]) {
std::fill(vis, vis + N, 0);
for (int j = 0; j < N; j++) {
if (dfs_cycle(j, cycle[i])) {
printf("-1\n");
return 0;
}
}
printf("%d\n", cycle[i] + 1);
return 0;
}
}
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, leaf, po;
vector<int> v[100005];
int main() {
scanf("%d", &n);
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = (2); i <= (n); i++) {
int a, b;
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = (1); i <= (n); i++)
if (v[i].size() == 1) leaf++;
po = 1;
for (int i = (1); i <= (n - leaf); i++) po = (po + po) % 1000000007;
printf("%d\n", (1LL * po * (n - leaf) + 2LL * po * leaf) % 1000000007);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
int n, m;
pair<int, int> edg[maxn];
vector<int> adj[maxn], radj[maxn];
bool mark[maxn];
int comp[maxn];
vector<int> srt;
void dfs(int v) {
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) {
mark[u] = true;
dfs(u);
}
}
srt.push_back(v);
}
void sfd(int v, int cnt) {
comp[v] = cnt;
for (int i = 0; i < radj[v].size(); i++) {
int u = adj[v][i];
if (comp[u] == 0) {
sfd(u, cnt);
}
}
}
bool twosat() {
for (int i = 1; i <= 2 * m; i++) {
if (!mark[i]) {
mark[i] = true;
dfs(i);
}
}
int cnt = 1;
while (srt.size()) {
int top = srt[srt.size() - 1];
srt.pop_back();
if (comp[top] == 0) {
comp[top] = cnt;
sfd(top, cnt);
cnt++;
}
}
for (int i = 1; i <= m; i++) {
if (comp[i] == comp[i + m]) {
return false;
}
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
edg[i].first = a;
edg[i].second = b;
}
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
int sa = edg[i].first, fa = edg[i].second, sb = edg[j].first,
fb = edg[j].second;
if (sa > fa) {
swap(sa, fa);
}
if (sb > fb) {
swap(sb, fb);
}
if (((sa > sb) && (sa < fb) && (fa > fb)) ||
((sb > sa) && (sb < fa) && (fb > fa))) {
adj[i + m].push_back(j);
adj[j + m].push_back(i);
adj[i].push_back(j + m);
adj[j].push_back(i + m);
radj[j].push_back(i + m);
radj[i].push_back(j + m);
radj[j + m].push_back(i);
radj[i + m].push_back(j);
}
}
}
if (!twosat()) {
cout << "Impossible";
return 0;
}
for (int i = 1; i <= m; i++) {
if (comp[i + m] < comp[i]) {
cout << "i";
} else {
cout << "o";
}
}
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
const int inf = (int)1e9 + 1000;
const long long infLL = 10000000000000001LL;
const int mod = (int)1e9 + 7;
const double eps = 1e-7;
const double pi = 3.141592653589793;
const int maxlen = (int)1e5 + 10;
const int base = (int)1e9;
const int dd = (int)100 + 10;
struct segm {
int l, r;
};
void solve() {
int n;
cin >> n;
vector<int> p(n);
vector<int> q(n);
for (int i = 0; i < n; i++) cin >> q[i];
p[0] = q[0];
set<int> used;
used.insert(q[0]);
for (int i = 1; i < n; i++)
if (q[i] != q[i - 1]) {
p[i] = q[i];
used.insert(p[i]);
}
set<int> w;
for (int i = 1; i <= n; i++)
if (!used.count(i)) w.insert(i);
int r = 0;
for (int i = 0; i < n; i++) {
if (!p[i]) {
p[i] = *w.begin();
w.erase(w.begin());
}
r = max(p[i], r);
if (q[i] != r) {
cout << -1 << '\n';
return;
}
}
for (int i = 0; i < n; i++) cout << p[i] << ' ';
cout << '\n';
}
int main() {
int t;
cin >> t;
while (t-- > 0) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unsigned power(unsigned val, unsigned _pow = 0) {
if (_pow <= 0) return 1;
return val * power(val, _pow - 1);
}
int str2int(const string &str) {
stringstream ss(str);
int num;
if ((ss >> num).fail()) {
}
return num;
}
int n, m, temp;
bool comp(pair<int, pair<string, int> > x, pair<int, pair<string, int> > y) {
return x.first < y.first;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n;
char inp[9 + 5];
scanf("%d", &n);
while (n--) {
scanf("%s", &inp);
int length = strlen(inp + 4), abbrev = atoi(inp + 4), digitsBef = 0,
pow = 10;
for (int i = 0; i < length - 1; ++i) {
digitsBef += pow;
pow *= 10;
}
for (; abbrev < 1989 + digitsBef;) abbrev += pow;
printf("%d\n", abbrev);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch - '0' < 0 || ch - '0' > 9) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch - '0' >= 0 && ch - '0' <= 9) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int Q, cnt;
double f[500010][45];
int fa[500010], son[500010];
double quick_pow(double x, int p) {
double an = 1, po = x;
while (p) {
if (p & 1) an *= po;
po *= po;
p >>= 1;
}
return an;
}
int main() {
int bl = 37;
cnt = 1;
for (int i = 0; i <= bl; i++) f[1][i] = 1;
Q = read();
while (Q--) {
int op = read(), x = read();
if (op == 1) {
cnt++;
fa[cnt] = x;
son[x]++;
double las = f[x][0];
f[x][0] = quick_pow(0.5, son[x]);
for (int i = 0; i <= bl; i++) f[cnt][i] = 1;
for (int i = 1; i <= bl; i++) {
int u = fa[x];
if (!u) break;
double tmp = f[u][i];
f[u][i] /= (0.5 + 0.5 * las);
f[u][i] *= (f[x][i - 1] * 0.5 + 0.5);
las = tmp;
x = u;
}
} else {
double ans = 0;
for (int i = 1; i <= bl; i++) ans += (double)i * (f[x][i] - f[x][i - 1]);
printf("%.8lf\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e10 + 6;
const long long MOD = 1e9 + 7;
const long long mod = 998244353;
const int MX = 1e6 + 5;
const int LG = 25;
template <typename t>
void fff(const char* x, t&& val1) {
cout << x << " : " << val1 << "\n";
}
template <typename t1, typename... t2>
void fff(const char* x, t1&& val1, t2&&... val2) {
const char* xd = strchr(x + 1, ',');
cout.write(x, xd - x) << " : " << val1 << " | ";
fff(xd + 1, val2...);
}
vector<pair<long long, long long> > v;
void solve(long long n, long long val) {
long long p = pow(2, n);
long long k = 1;
for (int i = 1; i <= n; i++) {
k *= 2;
for (int j = 1; j <= pow(2, n); j += k) {
for (int l = 0; l < k / 2; l++) {
v.push_back({j + val + l, j + k / 2 + val + l});
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
long long k = 1;
while (k < n) {
k *= 2;
}
k /= 2;
long long j = n - k;
long long k1 = 1;
while (k1 < j) {
k1 *= 2;
}
solve(log2(k), 0);
solve(log2(k1), n - k1);
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 1e5 + 10;
class Matrix {
public:
int a[2][2];
Matrix() { memset((a), (0), sizeof(a)); }
inline static Matrix ones() {
Matrix ret;
ret[0][0] = ret[1][1] = 1;
return ret;
}
inline static Matrix E() {
Matrix ret;
ret[0][0] = ret[0][1] = ret[1][0] = 1;
return ret;
}
bool operator!=(Matrix m) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (a[i][j] != m[i][j]) return true;
}
}
return false;
}
Matrix operator+(Matrix b) {
Matrix ret = *this;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
ret[i][j] += b[i][j];
if (ret[i][j] >= INF) ret[i][j] -= INF;
}
}
return ret;
}
Matrix operator*(Matrix b) {
Matrix ret;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ret[i][j] = (ret[i][j] + 1LL * a[i][k] * b[k][j]) % INF;
}
}
}
return ret;
}
Matrix operator^(int b) {
Matrix ret;
ret[0][0] = ret[1][1] = 1;
Matrix o = *this;
while (b) {
if (b & 1) ret = ret * o;
o = o * o;
b >>= 1;
}
return ret;
}
int* operator[](int i) { return a[i]; }
};
class SegmentTree {
public:
int ql, qr;
Matrix qx;
Matrix val[N * 4];
Matrix setv[N * 4];
void set(int l, int r, Matrix m = Matrix()) { ql = l, qr = r, qx = m; }
void maintain(int o) { val[o] = val[o << 1] + val[o << 1 | 1]; }
void pushdown(int o) {
if (setv[o] != Matrix::ones()) {
val[o << 1] = val[o << 1] * setv[o];
val[o << 1 | 1] = val[o << 1 | 1] * setv[o];
setv[o << 1] = setv[o << 1] * setv[o];
setv[o << 1 | 1] = setv[o << 1 | 1] * setv[o];
setv[o] = Matrix::ones();
}
}
void build(int l, int r, int o = 1) {
setv[o] = Matrix::ones();
if (l == r) {
int x;
scanf("%d", &x);
val[o] = Matrix::E() ^ (x - 1);
return;
}
int mid = (l + r) >> 1;
build(l, mid, o << 1);
build(mid + 1, r, o << 1 | 1);
maintain(o);
}
void update(int l, int r, int o = 1) {
if (ql <= l && r <= qr) {
setv[o] = setv[o] * qx;
val[o] = val[o] * qx;
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (ql <= mid) update(l, mid, o << 1);
if (mid < qr) update(mid + 1, r, o << 1 | 1);
maintain(o);
}
Matrix query(int l, int r, int o = 1) {
if (ql <= l && r <= qr) {
return val[o];
}
pushdown(o);
Matrix ret;
int mid = (l + r) >> 1;
if (ql <= mid) ret = ret + query(l, mid, o << 1);
if (mid < qr) ret = ret + query(mid + 1, r, o << 1 | 1);
maintain(o);
return ret;
}
} st;
int main() {
int n, q;
scanf("%d%d", &n, &q);
st.build(1, n);
while (q--) {
int op, l, r, x;
scanf("%d%d%d", &op, &l, &r);
if (op == 1) {
scanf("%d", &x);
st.set(l, r, Matrix::E() ^ x);
st.update(1, n);
} else {
st.set(l, r);
printf("%d\n", st.query(1, n)[0][0]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const maxsize = 100001;
int d[maxsize] = {};
int main() {
int n;
cin >> n;
vector<int> v;
v.reserve(n);
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
v.push_back(a);
}
for (int i = 0; i < (n + 1) / 2; ++i) {
if (i != n - 1 - i) {
int x = v[i] - (i + 1);
int y = v[n - 1 - i] - (i + 1);
if (x >= 0) d[x] += 1;
if (y >= 0) d[y] += 1;
} else {
int x = v[i] - (i + 1);
if (x >= 0) d[x] += 1;
}
}
int m = *std::max_element(&d[0], &d[0] + maxsize);
cout << n - m << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
char s;
map<char, int> Map;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> s;
Map[s]++;
}
if ((Map['B'] != 0 || Map['W'] != 0 || Map['G'] != 0) && Map['C'] == 0 &&
Map['M'] == 0 && Map['Y'] == 0)
cout << "#Black&White";
else
cout << "#Color";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101010;
int a[maxn];
int op[maxn], cl[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (a[n] == 1) {
cout << "NO";
return 0;
}
if (n == 1) {
puts("YES");
cout << 0;
return 0;
}
if (a[n - 1] == 1) {
puts("YES");
for (int i = 1; i < n; i++) printf("%d->", a[i]);
printf("%d", a[n]);
return 0;
}
for (int i = 1; i <= n - 2; i++) {
if (!a[i]) {
puts("YES");
for (int j = 1; j < i; j++) printf("%d->", a[j]);
int cnt = 0;
for (int j = i; j <= n - 2; j++) {
printf("(%d->", a[j]);
cnt++;
}
printf("%d", a[n - 1]);
while (cnt) {
printf(")");
cnt--;
}
printf("->%d", a[n]);
return 0;
}
}
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
vector<int> inc;
int N;
cin >> N;
for (int i = 1; i <= N; i *= 2) {
inc.push_back(i);
N -= i;
}
if (N > 0) inc.push_back(N);
sort(inc.begin(), inc.end());
cout << inc.size() - 1 << "\n";
for (int i = 0; i < inc.size() - 1; ++i) {
cout << inc[i + 1] - inc[i] << " ";
}
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[10];
int main() {
map<int, int> A;
map<int, char> B;
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int x, y, z = 0;
scanf("%d%d%s", &x, &y, s);
if (A.find(x) != A.end()) {
puts("0");
continue;
}
if (s[0] == 'L') {
auto it = A.lower_bound(x);
if (it == A.begin()) {
z = x;
} else {
--it;
if (B[it->first] == 'L') {
z = x - it->first + it->second;
} else {
z = x - it->first;
}
}
} else {
auto it = A.lower_bound(x);
if (it == A.end()) {
z = n + 1 - x;
} else {
if (B[it->first] == 'U') {
z = it->first - x + it->second;
} else {
z = it->first - x;
}
}
}
printf("%d\n", z);
A[x] = z;
B[x] = s[0];
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int n4a = count((a).begin(), (a).end(), '4');
int n4b = count((b).begin(), (b).end(), '4');
int diff = 0;
for (typeof(a.size()) i = 0; i < (a.size()); ++i)
if (a[i] != b[i]) diff++;
if (n4a == n4b)
cout << diff / 2 << endl;
else {
diff -= abs(n4a - n4b);
cout << diff / 2 + abs(n4a - n4b) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
bool check(string& s, int obst) {
int L = 0, R = 0, p = 0;
for (int((i)) = (0), _n_ = ((s.size() - 1) - 1); ((i)) <= _n_; ((i))++) {
s[i] == 'R' ? ((p + 1 < obst) ? p++ : 1) : p--;
L = min(L, p);
R = max(R, p);
}
return p == L;
}
int main() {
string s;
cin >> s;
if (s[s.size() - 1] == 'R') {
for (int((i)) = (0), _n_ = ((s.size()) - 1); ((i)) <= _n_; ((i))++)
s[i] = s[i] == 'L' ? 'R' : 'L';
}
if (check(s, 1000001)) {
printf("%d\n", (1));
42;
return 0;
}
int b = 1000001, g = 0;
while (g + 1 < b) {
int m = (g + b) >> 1;
if (check(s, m))
g = m;
else
b = m;
}
printf("%d\n", (g));
42;
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.