solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[10000], b[10000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < n; i++) {
if (a[i] % b[i] == 0) {
cout << 0 << endl;
} else {
cout << b[i] - (a[i] % b[i]) << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = 10;
ll n, res, na, a[5];
map<string, ll> ms;
ll adj[N][N];
void init() {
cin >> n;
string s1, s2, s3;
for (ll _ = 1; _ <= (ll)(n); ++_) {
cin >> s1 >> s2 >> s3;
ll n1, n3;
if (ms.count(s1))
n1 = ms[s1];
else
n1 = ms[s1] = ++na;
if (ms.count(s3))
n3 = ms[s3];
else
n3 = ms[s3] = ++na;
adj[n1][n3] = 1;
}
cin >> a[1] >> a[2] >> a[3];
}
ll liking(ll g) {
ll ret = 0;
for (ll i = 0; i < 7; i++)
if (g & (1 << i))
for (ll j = 0; j < 7; j++)
if (g & (1 << j)) ret += adj[i + 1][j + 1];
return ret;
}
ll constexpr mask = (1 << 7) - 1;
void solve() {
ll mn = LONG_LONG_MAX;
for (ll i = 1; i < (1 << 7); i++)
for (ll j = mask ^ i; j; j = (j - 1) & (mask ^ i)) {
ll cur = 0;
cur += liking(i);
cur += liking(j);
cur += liking(mask ^ i ^ j);
ll n1 = __builtin_popcount(i), n2 = __builtin_popcount(j),
n3 = 7 - n1 - n2;
if (n1 == 0 || n2 == 0 || n3 == 0) continue;
ll ra = a[1] / n1, rb = a[2] / n2, rc = a[3] / n3;
ll diff = max({ra, rb, rc}) - min({ra, rb, rc});
if (diff < mn) {
mn = diff;
res = cur;
} else if (diff == mn) {
res = max(res, cur);
}
}
cout << mn << ' ' << res;
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cout << fixed << setprecision(20);
init();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, bool> mp;
vector<int> ans;
vector<int> arr;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int p;
cin >> p;
arr.push_back(p);
}
reverse(arr.begin(), arr.end());
for (int i = 0; i < n; i++) {
int k = arr[i];
if (mp[k] == false) {
ans.push_back(k);
mp[k] = true;
}
}
reverse(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 10;
const int M = 27;
int Cnt[N][M], Odd[N], Len[N], n, m, Ans;
char S[N][N];
bool Cmp(int a, int b) {
if (Odd[a] > 1 || Odd[b] > 1) return false;
for (int i = 0; i < 26; i++) {
if (Cnt[a][i] != Cnt[b][i]) return false;
}
return true;
}
void Manacher() {
int Po = 0, mx = 0;
Len[0] = 1;
for (int i = 1; i <= 2 * n; i++) {
if (i <= mx)
Len[i] = min(mx - i, Len[2 * Po - i]);
else
Len[i] = 1;
while (i - Len[i] >= 0 && i + Len[i] <= 2 * n + 1 &&
Cmp(i + Len[i], i - Len[i]))
Len[i]++;
if (Odd[i] > 1) Len[i] = 1;
if (mx < i + Len[i]) {
Po = i;
mx = i + Len[i];
}
Ans += (Len[i]) / 2;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", S[i] + 1);
}
for (int L = 1; L <= m; L++) {
for (int i = 1; i <= n; i++) {
for (int k = 0; k < 26; k++) {
Cnt[i * 2 - 1][k] = Odd[i * 2 - 1] = 0;
}
}
for (int R = L; R <= m; R++) {
for (int i = 1; i <= n; i++) {
Cnt[2 * i - 1][S[i][R] - 'a']++;
if (Cnt[2 * i - 1][S[i][R] - 'a'] & 1)
Odd[2 * i - 1]++;
else
Odd[2 * i - 1]--;
}
Manacher();
}
}
printf("%d\n", Ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp[30005][500];
int gem[30005];
int d;
int f(int x, int y) {
if (dp[x][y] != -1) return dp[x][y];
int res = gem[x];
int step = y - 250 + d;
if (step - 1 > 0 && x + step - 1 <= 30000) {
res = max(res, gem[x] + f(x + step - 1, y - 1));
}
if (x + step <= 30000) {
res = max(res, gem[x] + f(x + step, y));
}
if (x + step + 1 <= 30000) {
res = max(res, gem[x] + f(x + step + 1, y + 1));
}
return dp[x][y] = res;
}
int main() {
int n;
scanf("%d %d", &n, &d);
memset(gem, 0, sizeof gem);
for (int i = 0; i < n; i++) {
int index;
scanf("%d", &index);
gem[index]++;
}
memset(dp, -1, sizeof dp);
printf("%d\n", f(d, 250));
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, k, c, g, g2, cur = 1;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &c);
g = gcd(c, k);
g2 = gcd(g, cur);
cur = cur / g2 * g;
if (cur % k == 0) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, k;
long long best = 1e12 + 1;
vector<long long> ans;
long long get_xor(vector<long long> arr) {
long long ans = 0;
for (int i = 0; i < arr.size(); ++i) ans ^= arr[i];
return ans;
}
void check(vector<long long> arr) {
long long val = get_xor(arr);
if (val < best) {
best = val;
ans = arr;
}
}
int main() {
cin >> l >> r >> k;
k = min(k, r - l + 1);
check({l});
if (k >= 2) {
check({l, l + 1});
if (l + 2 <= r) check({l + 1, l + 2});
}
if (k >= 3) {
long long h = 1;
while (2 * h <= l) h *= 2;
if (h * 3 <= r) check({l, h * 3, l ^ (h * 3)});
}
if (k >= 4) {
check({l, l + 1, l + 2, l + 3});
if (l + 4 <= r) check({l + 1, l + 2, l + 3, l + 4});
}
cout << best << '\n' << ans.size() << '\n';
for (int i = 0; i < ans.size(); ++i)
cout << ans[i] << " \n"[i == ans.size() - 1];
};
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
int n;
multiset<int> S;
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); i++) {
int x;
scanf("%d", &x);
S.insert(x);
}
int cur = *S.rbegin();
int l = cur;
int r = cur;
S.erase(S.find(cur));
while (S.size() > 0) {
if (S.find(l + 1) != S.end()) {
l = l + 1;
S.erase(S.find(l));
} else if (S.find(l - 1) != S.end()) {
l = l - 1;
S.erase(S.find(l));
} else {
cout << "NO" << endl;
return 0;
}
swap(l, r);
}
if (abs(l - r) != 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int lim[500010], a[500010], num[500010];
bool isans[500010];
bool check(int mid) {
memset(num, 0, sizeof(num));
for (int i = 1; i <= mid; i++) num[a[i]]++;
for (int i = 1; i <= 500000; i++)
if (num[i] < lim[i]) return false;
return true;
}
int main() {
int n = inp();
int k = inp();
int m = inp();
int s = inp();
for (int i = 1; i <= n; i++) a[i] = inp();
for (int i = 1; i <= s; i++) lim[inp()]++;
int l = k;
int r = n + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (r == n + 1) {
printf("-1\n");
return 0;
}
check(l);
int lans, rans;
int ans = 2147483647;
num[0] = 1;
for (int l = 1; l <= n; l++) {
num[a[l - 1]]--;
while ((num[a[l - 1]] < lim[a[l - 1]] || r < l + k - 1) && r <= n) {
num[a[++r]]++;
}
if (r > n) break;
if ((l - 1) / k + (n - r) / k + 1 >= m) {
if ((l - 1) % k + (n - r) % k + (r - l + 1 - k) < ans) {
ans = (l - 1) % k + (n - r) % k + (r - l + 1 - k);
lans = l;
rans = r;
}
}
}
if (ans == 2147483647) {
printf("-1\n");
return 0;
}
int num = std::max((n - ans - m * k) / k, 0);
printf("%d\n", ans + num * k);
for (int i = 1; i <= (lans - 1) % k; i++) printf("%d ", i);
int cur = (lans - 1) % k + 1;
for (int i = 1; num > 0 && cur < lans; i++) {
for (int j = 1; j <= k; j++) printf("%d ", cur++);
num--;
}
for (int i = lans; i <= rans; i++)
if (lim[a[i]]) {
lim[a[i]]--;
isans[i] = true;
}
int left = k - s;
for (int i = lans; i <= rans; i++) {
if (isans[i]) continue;
if (!left)
printf("%d ", i);
else
left--;
}
for (int i = 1; i <= (n - rans) % k; i++) printf("%d ", rans + i);
cur = (n - rans) % k + rans + 1;
for (int i = 1; i <= num; i++)
for (int j = 1; j <= k; j++) printf("%d ", cur++);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long double eps = 1e-9;
const long long int maxn = 1e5 + 1;
const long long int inf = 1e18;
const long long int minf = -inf;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
bool solve() {
string str;
getline(cin, str);
for (long long int i = str.length() - 1; i >= 0; i--) {
int n = int(str[i]);
if (n >= 65 && n <= 90 || n >= 97 && n <= 122) {
if (n == int('A') || n == int('a') || n == int('E') || n == int('e') ||
n == int('I') || n == int('i') || n == int('O') || n == int('o') ||
n == int('U') || n == int('u') || n == int('Y') || n == int('y'))
cout << "YES";
else
cout << "NO";
return true;
} else
continue;
}
return true;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
if (solve()) {
} else {
}
}
cerr << "Time Elapsed: " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T1, class T2>
inline int chkmin(T1& a, const T2& val) {
return val < a ? a = val, 1 : 0;
}
template <class T1, class T2>
inline int chkmax(T1& a, const T2& val) {
return a < val ? a = val, 1 : 0;
}
template <class T>
inline T isqrt(T k) {
T r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
template <class T>
inline T icbrt(T k) {
T r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return (int)fpow(a, p - 2, p); }
const int maxn = 1 << 20;
const int mod = 998244353;
void fft(int a[], int p, int r, int n) {
for (int m = n, h; h = m / 2, m >= 2; r = (long long)r * r % p, m = h) {
for (int i = 0, w = 1; i < h; i++, w = (long long)w * r % p) {
for (int j = i; j < n; j += m) {
int k = j + h, x = a[j] - a[k];
if (x < 0) x += p;
a[j] += a[k];
if (a[j] >= p) a[j] -= p;
a[k] = (long long)w * x % p;
}
}
}
for (int i = 0, j = 1; j < n - 1; j++) {
for (int k = n / 2; k > (i ^= k); k /= 2)
;
if (j < i) swap(a[i], a[j]);
}
}
int n, k;
int c[maxn];
int fa[maxn];
int fb[maxn];
void multiply(vector<int>& a, vector<int>& b, int c[], int p) {
int na = int((a).size()), nb = int((b).size());
int n = 1, d = p - 1;
while (n < na + nb - 1) n <<= 1, d >>= 1;
fill_n(fa, n, 0), fill_n(fb, n, 0);
for (int i = (0); i < (na); i++) fa[i] = a[i];
for (int i = (0); i < (nb); i++) fb[i] = b[i];
int w1 = fpow(3, d, p);
int w2 = inv(w1, p);
fft(fa, p, w1, n);
fft(fb, p, w1, n);
for (int i = (0); i < (n); i++) fa[i] = mult(fa[i], fb[i], p);
fft(fa, p, w2, n);
int rem = inv(n, p);
for (int i = (0); i < (n); i++) c[i] = mult(fa[i], rem, p);
}
struct Num {
vector<int> a, b;
Num() {}
Num(vector<int> a, vector<int> b) : a(a), b(b) {}
Num(const Num& rhs) : a(rhs.a), b(rhs.b) {}
};
Num merge(Num& x, Num& y) {
Num res;
int ka = max(int((x.a).size()) + int((y.a).size()) - 1,
int((x.b).size()) + int((y.b).size()) + 1);
ka = min(ka, k + 1);
int kb = max(int((x.a).size()) + int((y.b).size()) - 1,
int((x.b).size()) + int((y.a).size()) - 1);
kb = min(kb, k + 1);
res.a.resize(ka, 0);
res.b.resize(kb, 0);
multiply(x.a, y.a, c, mod);
for (int i = (0); i < (min(k + 1, int((x.a).size()) + int((y.a).size()) - 1));
i++)
addmod(res.a[i], c[i], mod);
multiply(x.b, y.b, c, mod);
static int cof[] = {1, 6, 1};
for (int i = (0); i < (int((x.b).size()) + int((y.b).size()) - 1); i++)
for (int j = (0); j < (3); j++) {
if (i + j < ka) {
addmod(res.a[i + j], mult(c[i], cof[j], mod), mod);
}
}
multiply(x.a, y.b, c, mod);
for (int i = (0); i < (min(k + 1, int((x.a).size()) + int((y.b).size()) - 1));
i++) {
addmod(res.b[i], c[i], mod);
}
multiply(x.b, y.a, c, mod);
for (int i = (0); i < (min(k + 1, int((x.b).size()) + int((y.a).size()) - 1));
i++) {
addmod(res.b[i], c[i], mod);
}
return res;
}
Num pow(Num x, int k) {
Num res = x, tmp = x;
k--;
while (k) {
if (k & 1) res = merge(res, tmp);
tmp = merge(tmp, tmp);
k >>= 1;
}
return res;
}
void solve() {
cin >> n >> k;
vector<int> a, b;
a.push_back(1), a.push_back(1), b.push_back(1);
Num res = pow(Num(a, b), n + 1);
while (int((res.b).size()) < k + 1) res.b.push_back(0);
for (int i = (1); i < (k + 1); i++)
cout << mult(res.b[i], fpow(inv(2, mod), n, mod), mod) << " \n"[i == k];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("in.txt", "r")) {
freopen("in.txt", "r", stdin);
}
solve();
cerr << "\nTime elapsed: " << 1000.0 * clock() / CLOCKS_PER_SEC << " ms\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long si = s.size();
string ans = "";
string ns = "No solution";
long long upd = 0;
long long la = -1;
if (si < 3) {
cout << ns;
return 0;
}
for (long long i = 1; i < si - 2; i++) {
if (s[i] == '@') la = i;
if (s[i] == '@' && (s[i + 1] == '@' || s[i + 2] == '@')) {
upd = 1;
}
}
if (s[si - 2] == '@') la = si - 2;
if (s[0] == '@' || s[si - 1] == '@' || la == -1) {
cout << ns << endl;
return 0;
}
if (upd == 1) {
cout << ns << endl;
return 0;
} else {
for (long long i = 0; i < si;) {
if (s[i] == '@') {
if (i == la) {
while (i < si) {
ans += s[i];
i++;
}
cout << ans << endl;
return 0;
}
ans += s[i];
i++;
ans += s[i];
if (i != si - 1) {
ans += ',';
}
i++;
} else {
ans += s[i];
i++;
}
}
cout << ans << endl;
return 0;
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[101010];
int a[101010];
int main() {
cin.sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p[i];
--p[i];
a[p[i]] = i;
}
int len = 1;
int bestlen = 1;
for (int i = 1; i < n; ++i) {
if (a[i] > a[i - 1]) {
++len;
} else {
len = 1;
}
bestlen = max(len, bestlen);
}
cout << n - bestlen << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC target("avx,tune=native")
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
inline string getstr(string &s, int l, int r) {
string ret = "";
for (int i = l; i <= r; i++) ret.push_back(s[i]);
return ret;
}
int modpow(int x, int y, int md = mod) {
if (y == 0) return 1;
int ret = modpow(x, y >> 1, md);
ret = (long long)ret * ret % md;
if (y & 1) ret = (long long)ret * x % md;
return ret;
}
int n, m, t, ans;
int a[10001];
int cnt[10005];
int in[11];
inline int calc(int use) {
int ret = 1;
for (int i = 1; i <= use; i++) {
ret = (long long)ret * cnt[in[i]] % mod;
}
return ret;
}
void dfs(int use, int last, bitset<128> now) {
ans += calc(use);
if (ans >= mod) ans -= mod;
for (register int i = last + 1; i <= m / 2; i++) {
if (cnt[i]) {
if (now[i] || now[m - i]) continue;
bitset<128> bs =
now | (now >> i) | (now << i) | (now >> (m - i)) | (now << (m - i));
in[use + 1] = i;
dfs(use + 1, i, bs);
}
}
}
bitset<128> bs;
int main() {
bs.reset();
bs.set(0);
cin >> n >> m >> t;
for (int i = 0; i < t; i++) cin >> a[i], cnt[min(m - a[i] % m, a[i] % m)]++;
dfs(0, 0, bs);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int sum = 0, mx;
bool flag;
if (a[0] < 0)
flag = 0;
else
flag = 1;
for (int i = 0; i < n; i++) {
mx = a[i];
while (i < n && flag == 0 && a[i] < 0) mx = max(mx, a[i++]);
while (i < n && flag == 1 && a[i] > 0) mx = max(mx, a[i++]);
flag = !flag;
sum += mx;
i--;
}
cout << sum << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
const double PI = 3.1415926535897932384626433832795;
template <class T>
T min(T &a, T &b) {
return (a < b) ? a : b;
}
template <class T>
T max(T &a, T &b) {
return (a > b) ? a : b;
}
template <class T>
T sqr(T &a) {
return a * a;
}
template <class T>
T abs(T &a) {
return (a < 0) ? (-a) : a;
}
inline void read(int &x) { scanf("%d", &x); }
inline void readln(int &x) { scanf("%d\n", &x); }
inline void write(int x) { printf("%d", x); }
inline void writeln(int x) { printf("%d\n", x); }
inline void read(long long &x) { scanf("%lld", &x); }
inline void readln(long long &x) { scanf("%lld\n", &x); }
inline void write(long long x) { printf("%lld", x); }
inline void writeln(long long x) { printf("%lld\n", x); }
inline void read(double &x) { scanf("%lf", &x); }
inline void readln(double &x) { scanf("%lf\n", &x); }
inline void write(double x) { printf("%.15lf", x); }
inline void writeln(double x) { printf("%.15lf\n", x); }
inline void read(char *s) { scanf("%s", s); }
inline void readln(char *s) { scanf("%s\n", s); }
inline void write(char *s) { printf("%s", s); }
inline void writeln(char *s) { printf("%s\n", s); }
inline int readInt() {
int x;
read(x);
return x;
}
inline long long readLong() {
long long x;
read(x);
return x;
}
inline double readDouble() {
double x;
read(x);
return x;
}
void showTime() {}
inline void prepareInputOutput() {}
const long double EPS = 1e-12;
int main() {
prepareInputOutput();
long double y1, y2, yw, xb, yb, r;
cin >> y1 >> y2 >> yw >> xb >> yb >> r;
long double a = xb;
long double b1 = (yw - r) - (y1 + r);
long double b2 = (yw - r) - yb;
long double b = b1 + b2;
long double d = b1 / (b1 + b2);
long double x = xb * d;
long double A = (yw - r) - (y1 + r);
long double B = -x;
long double C = -B * (y1 + r);
long double dist = abs(B * y2 + C) / sqrt(A * A + B * B);
if (dist < r - EPS) {
writeln(-1);
} else {
writeln((double)x);
}
showTime();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int head[404040], nxt[404040], to[404040], L[404040], deep[404040], mx[404040];
int E, N, M, pa[404040], qq[404040], dist[2][404040], qf, qb, vst[404040];
pair<int, int> p[404040];
vector<pair<pair<int, int>, int> > T;
void add(int u, int v) {
to[E] = v, nxt[E] = head[u], head[u] = E++;
to[E] = u, nxt[E] = head[v], head[v] = E++;
}
void dfs(int u) {
pair<int, int> q;
mx[u] = u, L[u] = -1;
int m1 = u, m2 = 0;
for (int e = head[u]; ~e; e = nxt[e]) {
int v = to[e];
if (deep[v] >= 0) continue;
deep[v] = deep[u] + 1, pa[v] = u;
dfs(v);
if (deep[mx[v]] > deep[m2]) m2 = mx[v];
if (deep[m2] > deep[m1]) swap(m1, m2);
if (L[u] < L[v]) L[u] = L[v], q = p[v];
}
if (m2 && L[u] < deep[m1] + deep[m2] - deep[u] * 2)
L[u] = deep[m1] + deep[m2] - deep[u] * 2, q = make_pair(m1, m2);
p[u] = q, mx[u] = m1;
}
void DFS(int u, int k) {
for (int e = head[u]; ~e; e = nxt[e]) {
int v = to[e];
if (dist[k][v] >= 0) continue;
dist[k][v] = dist[k][u] + 1;
if (k == 1 && dist[0][v] + dist[1][v] == L[1])
T.push_back(make_pair(make_pair(p[1].second, v), v));
DFS(v, k);
}
}
int main() {
int u, v;
cin >> N;
memset(mx, -1, sizeof mx);
memset(head, -1, sizeof head);
memset(deep, -1, sizeof deep);
memset(dist, -1, sizeof dist);
for (int i = 1; i < N; i++) gn(u, v), add(u, v);
deep[1] = 0;
dfs(1);
dist[0][p[1].first] = 0, dist[1][p[1].second] = 0;
DFS(p[1].first, 0);
DFS(p[1].second, 1);
for (int i = 1; i <= N; i++)
if (dist[0][i] + dist[1][i] == L[1]) {
vst[i] = 1;
qq[qb++] = i;
}
long long ans = 1LL * L[1] * (L[1] + 1) / 2;
while (qf < qb) {
int u = qq[qf++];
for (int e = head[u]; ~e; e = nxt[e]) {
int v = to[e];
if (vst[v]) continue;
vst[v] = 1;
qq[qb++] = v;
if (dist[0][v] > dist[1][v])
T.push_back(make_pair(make_pair(p[1].first, v), v));
else
T.push_back(make_pair(make_pair(p[1].second, v), v));
ans += max(dist[0][v], dist[1][v]);
}
}
println(ans);
reverse(T.begin(), T.end());
for (int i = 0; i < T.size(); i++) {
printf("%d %d %d\n", T[i].first.first, T[i].first.second, T[i].second);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long MOD = 998244353;
const long long MAX = 2e5 + 1;
inline long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
inline long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
inline long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long pwr(long long x, long long n) {
if (n == 0) {
return 1;
}
if (n & 1) {
return mul(x, pwr(mul(x, x), (n - 1) / 2));
} else {
return pwr(mul(x, x), n / 2);
}
}
long long modInv(long long n) { return pwr(n, mod - 2); }
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int toDigit(char ch) { return (ch - '0'); }
int main() {
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
int nn = n / k;
int kn = min(nn, m);
int ans2 = m - kn;
if (ans2 == 0) {
cout << kn << "\n";
continue;
} else {
k--;
m -= kn;
float mm = m;
float sk = ceil(mm / k);
cout << kn - sk << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, l, j, count = 0;
cin >> s;
l = s.length();
for (i = 0, j = l - 1; i < l / 2; i++, j--) {
if (s[i] != s[j]) count++;
}
if (count == 1 || (count == 0 && l % 2 == 1))
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
struct {
inline operator int() {
int x;
return scanf("%d", &x), x;
}
inline operator long long() {
long long x;
return scanf("%lld", &x), x;
}
template <class T>
inline void operator()(T &x) {
x = *this;
}
template <class T, class... A>
inline void operator()(T &x, A &...a) {
x = *this;
this->operator()(a...);
}
} read;
const int maxn = 707, mod = 1000000007;
char s[maxn];
int count[maxn][10];
long long f[maxn][maxn * 10];
long long a[maxn];
int main() {
scanf("%s", s + 1);
int n = int(strlen(s + 1));
for (int i = 1; i <= n; i++) {
for (int x = 0; x < 10; x++) count[i][x] = count[i - 1][x];
++count[i][s[i] - '0'];
}
for (int i = 1; i <= n; i++) a[i] = (a[i - 1] * 10 + 1) % mod;
long long ans = 0;
for (int X = 1; X <= 9; X++) {
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int x = X; x < 10; x++) cnt += count[i - 1][x];
f[i][0] = X * f[i - 1][0] % mod;
for (int j = 1; j <= i * 10; j++)
f[i][j] = ((10 - X) * f[i - 1][j - 1] + X * f[i - 1][j]) % mod;
for (int x = 0; x < s[i] - '0'; x++) ++f[i][cnt + (x >= X)];
}
for (int j = 0; j <= n * 10; j++) (ans += f[n][j] * a[j]) %= mod;
}
for (int x = 1; x <= 9; x++) {
int tot = 0;
for (int i = 1; i <= n; i++) tot += s[i] - '0' >= x;
ans += a[tot];
}
ans %= mod;
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
class step {
public:
int st, r, l;
} step[100005];
int main() {
int n, m, s, f;
int i, j, l, r, t;
while (cin >> n >> m >> s >> f) {
int t_now = 1;
for (i = 0; i < m; i++) cin >> step[i].st >> step[i].l >> step[i].r;
for (i = 0; i < m; i++) {
if (s == f) break;
if (t_now != step[i].st) {
if (s < f) {
cout << "R";
s++;
} else {
cout << "L";
s--;
}
i--;
} else if (s < f && (s + 1 < step[i].l || s > step[i].r)) {
cout << "R";
s++;
} else if (s > f && (s - 1 > step[i].r || s < step[i].l)) {
cout << "L";
s--;
} else
cout << "X";
t_now++;
}
while (s != f) {
if (s < f) {
cout << "R";
s++;
} else {
cout << "L";
s--;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int d;
int main() {
if (0) {
freopen("project1.inp", "r", stdin);
freopen("project1.out", "w", stdout);
}
ios_base::sync_with_stdio(false);
cin >> s;
for (int i = 0; i < s.size(); ++i)
for (int j = i + 1; j < s.size(); ++j)
for (int l = j + 1; l < s.size(); ++l)
if (s[i] == 'Q' && s[j] == 'A' && s[l] == 'Q') ++d;
cout << d;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1011;
const int Mod = 998244353;
long long f[Maxn], sum[Maxn];
int n, a[Maxn], c[Maxn][Maxn];
void init() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
c[0][0] = 1;
for (int i = 1; i <= n; i++) {
c[i][0] = 1;
c[i][1] = i;
}
for (int i = 2; i <= n; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % Mod;
}
}
}
int main() {
init();
f[n] = 0;
sum[n] = 0;
for (int i = n - 1; i >= 1; i--) {
if (a[i] <= 0 || a[i] > n) {
sum[i] = sum[i + 1];
continue;
}
for (int j = n; j > i; j--) {
f[i] = ((f[i] + (sum[j + 1] + 1) * c[j - 1 - i][a[i] - 1]) % Mod) % Mod;
}
sum[i] = (sum[i + 1] + f[i]) % Mod;
}
cout << sum[1];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int v;
vector<int> a;
int main() {
cin >> v;
for (int z = 0; z < v; ++z) {
a.clear();
for (int i = 0; i < 250; ++i) {
int b;
cin >> b;
a.push_back(b);
}
sort(a.begin(), a.end());
int x = a[125] * 2 / 3, y = a[125] * 4 / 3;
int l = 0, m = 0, r = 0;
for (int b : a) {
if (b <= x)
l++;
else if (b >= y)
r++;
else
m++;
}
if (m > l + r + 20)
cout << "poisson\n";
else
cout << "uniform\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long n, k;
scanf("%lld%lld", &n, &k);
long long cnt = 1;
if (n == 1) {
printf("0\n");
continue;
}
for (int i = 1; i <= 64; i++) {
if (cnt > k) {
printf("%lld\n", i - 1 + (n - cnt - 1) / k + 1);
break;
}
cnt *= 2;
if (cnt >= n) {
printf("%d\n", i);
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int r, c, n, k, x, y, a[100][100], ans;
int f(int xa, int ya, int xb, int yb) {
int s = 0;
for (int i = xa; i <= xb; i++)
for (int j = ya; j <= yb; j++) s += a[i][j];
return s;
}
int main() {
cin >> r >> c >> n >> k;
for (int i = 1; i <= n; i++) cin >> x >> y, a[x][y] = 1;
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++) {
for (int i2 = i; i2 <= r; i2++)
for (int j2 = j; j2 <= c; j2++) {
if (f(i, j, i2, j2) >= k) ans++;
}
}
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int n = 0, f = 1, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = n * 10 + ch - '0';
ch = getchar();
}
return n * f;
}
char a[2000005], b[2000005];
int n;
int c[2000005];
int get(int x) {
int cur = 0, res = 0;
for (int i = 1; i <= n; i++) {
cur += x * c[i];
res = max(res, cur);
if (cur < 0) cur = 0;
}
return res;
}
int main() {
int s1 = 0, s2 = 0;
n = read();
scanf("%s%s", a + 1, b + 1);
for (int i = 1; i <= n; i++) {
if (a[i] != b[i] && a[i] == '0')
c[i] = -1, s1++;
else if (a[i] != b[i] && a[i] == '1')
c[i] = 1, s2++;
}
if (s1 != s2) {
printf("-1\n");
return 0;
}
printf("%d\n", max(get(1), get(-1)));
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4.2,sse4.1,ssse3,sse3,sse2,sse")
#pragma GCC target("avx")
#pragma GCC target("avx2")
using namespace std;
const int maxn = (int)2e5;
alignas(32) int a[maxn];
alignas(32) int b[maxn];
alignas(32) int posA[maxn];
alignas(32) int posB[maxn];
alignas(32) int special[maxn];
alignas(32) short result[128];
bool check(int lb, int rb, int i) {
return lb <= special[i] && special[i] <= rb;
}
int getCount(int la, int ra, int lb, int rb) {
int count = 0;
if (la / 128 == ra / 128) {
for (int i = la; i <= ra; i++) count += check(lb, rb, i);
return count;
} else {
while (la % 128 != 0) {
count += check(lb, rb, la);
la++;
}
while (ra % 128 != 128 - 1) {
count += check(lb, rb, ra);
ra--;
}
ra++;
for (int i = 0; i < 128; i++) result[i] = 0;
for (int i = la; i + 128 <= ra; i += 128) {
for (int j = 0; j < 128; j++) {
result[j] += check(lb, rb, i + j);
}
}
for (int i = 0; i < 128; i++) count += result[i];
}
return count;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
for (int i = 0; i < n; i++) cin >> b[i], b[i]--;
for (int i = 0; i < n; i++) posA[a[i]] = i;
for (int i = 0; i < n; i++) posB[b[i]] = i;
for (int i = 0; i < n; i++) special[i] = posB[a[i]];
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int la, ra, lb, rb;
cin >> la >> ra >> lb >> rb;
la--, ra--, lb--, rb--;
int count = getCount(la, ra, lb, rb);
cout << count << '\n';
} else {
int x, y;
cin >> x >> y;
x--, y--;
swap(b[x], b[y]);
posB[b[x]] = x;
posB[b[y]] = y;
special[posA[b[x]]] = x;
special[posA[b[y]]] = y;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string num1;
string num2;
int sum = 0;
stringstream no1;
stringstream no2;
int number1, number2;
cin >> num1 >> num2;
no1 << num1;
no1 >> number1;
no2 << num2;
no2 >> number2;
int res = number1 + number2;
stringstream ss;
ss << res;
string res2 = ss.str();
for (int i = 0; i < num1.size(); ++i) {
if (num1[i] == '0') {
num1.erase(i, 1);
--i;
}
}
for (int i = 0; i < num2.size(); ++i) {
if (num2[i] == '0') {
num2.erase(i, 1);
--i;
}
}
for (int i = 0; i < res2.size(); ++i) {
if (res2[i] == '0') {
res2.erase(i, 1);
--i;
}
}
stringstream no11;
stringstream no22;
stringstream res3;
int finalres;
res3 << res2;
res3 >> finalres;
no11 << num1;
no11 >> number1;
no22 << num2;
no22 >> number2;
if (number1 + number2 == finalres)
cout << "YES" << endl;
else if (res == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10005, M = N * 3, Inf = 0x3f3f3f3f;
int n, m, s, t;
int a[N], b[N], c[N], l[N], r[N], idx, st[N];
int eid = 1, he[N], nw[N], d[N], q[N];
struct edge {
int v, nx, c;
} e[M * 2];
void add(int u, int v, int c) {
e[++eid] = {v, he[u], c}, he[u] = eid;
e[++eid] = {u, he[v], 0}, he[v] = eid;
}
int bfs() {
memset(d, 0, sizeof d), memcpy(nw, he, sizeof he);
q[1] = s, d[s] = 1;
for (int l = 1, r = 1; l <= r; l++) {
int u = q[l];
for (int i = he[u], v; v = e[i].v; i = e[i].nx)
if (e[i].c && !d[v]) q[++r] = v, d[v] = d[u] + 1;
}
return d[t];
}
long long dfs(int u, long long lim, long long re = 0) {
if (u == t) return lim;
for (int &i = nw[u], v; v = e[i].v; i = e[i].nx)
if (e[i].c && d[v] == d[u] + 1) {
long long t = dfs(v, min((long long)e[i].c, lim));
e[i].c -= t, e[i ^ 1].c += t, re += t, lim -= t;
if (!lim) break;
}
if (lim) d[u] = 0;
return re;
}
int main() {
cin >> n >> m;
s = ++idx, t = ++idx;
for (int i = (1); i <= (n); i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
for (int i = (1); i <= (n); i++) {
scanf("%d%d", &l[i], &r[i]);
add(s, ++idx, Inf * 2), st[i] = idx + 1 - l[i];
for (int j = (l[i]); j <= (r[i]); j++)
add(idx, idx + 1, Inf - a[i] * j * j - b[i] * j - c[i]), idx++;
add(idx, t, Inf * 2);
}
int u, v, d;
while (m--) {
scanf("%d%d%d", &u, &v, &d);
for (int i = (max(l[u] - d, l[v]) - 1); i <= (min(r[u] - d, r[v])); i++)
add(st[u] + i + d, st[v] + i, Inf * 2);
}
long long as = (long long)Inf * n;
while (bfs()) as -= dfs(s, Inf * 2);
cout << as;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, r, c;
node(){};
node(int T, int C, int R) {
t = T;
c = C;
r = R;
}
};
int n, m, a[405], dp[405][405];
long long ans;
vector<node> G[405];
inline void read(int &x) {
x = 0;
int f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
x *= f;
}
int main() {
read(n), read(m);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= m; i++) {
int s, t, c, r;
read(s), read(t), read(c), read(r);
G[s].push_back(node(t, c, r));
}
for (int l = 1; l <= n; l++) {
for (int r = l + 1; r <= n; r++) {
dp[r][0] = a[r] - a[l];
int pos = 0;
for (int k = 1; k <= n; k++) {
dp[r][k] = a[r] - a[l];
while (pos + 1 <= r && dp[pos + 1][k - 1] < a[r] - a[pos + 1]) pos++;
dp[r][k] = min(dp[r][k], min(dp[pos + 1][k - 1], a[r] - a[pos]));
}
}
for (int i = 0; i < G[l].size(); i++) {
int t = G[l][i].t, c = G[l][i].c, r = G[l][i].r;
ans = max(ans, 1ll * dp[t][r] * c);
}
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
stringstream ssin;
const long long LINF = 0x7fffffffffffffffll;
const int N = 200, M = 2e5 + 5, mod = 1e9 + 7, INF = 0x3f3f3f3f;
long long n, m, _;
long long a[N][N];
vector<long long> v;
inline long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int main() {
_ = read();
while (_--) {
n = read();
m = read();
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) a[i][j] = read();
long long ans = 0;
for (int i = 0; 2 * i < n; ++i) {
for (int j = 0; 2 * j < m; ++j) {
v.clear();
v.push_back(a[i][j]);
if (i != n - i - 1) v.push_back(a[n - i - 1][j]);
if (j != m - j - 1) v.push_back(a[i][m - j - 1]);
if (i != n - i - 1 && j != m - j - 1)
v.push_back(a[n - i - 1][m - j - 1]);
sort(v.begin(), v.end());
int x = v[(v.size() - 1) / 2];
for (auto y : v) ans += abs(x - y);
}
}
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> v[100001];
for (int i = 0; i < n; i++) {
int p;
cin >> p;
v[p].push_back(i);
}
vector<pair<int, int> > v1;
for (int i = 1; i < 100001; i++) {
int len = v[i].size();
if (len) {
if (len == 1) {
v1.push_back(make_pair(i, 0));
continue;
}
int diff = v[i][1] - v[i][0];
bool ok = 1;
for (int j = 1; j < len - 1; j++)
if (v[i][j + 1] - v[i][j] != diff) {
ok = 0;
break;
}
if (ok) v1.push_back(make_pair(i, diff));
}
}
int len = v1.size();
cout << len << '\n';
for (int i = 0; i < len; i++)
cout << v1[i].first << ' ' << v1[i].second << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1234567], r[1234567], rr[1234567];
int n, m, k, x, y, b = 0, q, p;
int main() {
cin >> n >> b >> p;
p *= n;
while (n > 1) {
x += b * 2 * (n / 2) + (n / 2);
if (n % 2)
n /= 2, n++;
else
n /= 2;
}
cout << x << " " << p;
}
| 1 |
#include <bits/stdc++.h>
template <class T>
inline void swap(T &x, T &y) {
T tmp = x;
x = y, y = tmp;
}
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), c = ch;
while (ch < '0' || ch > '9') c = ch, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
if (c == '-') x = -x;
}
const int INF = 0x3f3f3f3f;
const int MAXN = 100 + 10;
int n, d, num[MAXN];
int main() {
read(n), read(d);
for (int i = 1; i <= n; ++i) read(num[i]);
std::sort(num + 1, num + 1 + n);
int l = 1, r = n, ans = 0;
while (l <= r) {
int tmp1 = r, tmp2;
while (num[tmp1] - num[l] > d) --tmp1;
tmp2 = r - tmp1;
int tmp3 = l, tmp4;
while (num[r] - num[tmp3] > d) ++tmp3;
tmp4 = tmp3 - l;
if (tmp2 == 0 && tmp4 == 0) break;
if (tmp2 >= tmp4)
++l;
else
--r;
++ans;
}
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long t = 0;
for (int x = a; x <= b; x++) {
long long l1 = max(b, c - x);
long long r1 = min(c, d - x);
if (l1 <= r1) t += (r1 - l1 + 1) * (x - c) + (r1 - l1 + 1) * (l1 + r1) / 2;
long long l2 = max(b, d + 1 - x);
long long r2 = c;
if (l2 <= r2) t += (r2 - l2 + 1) * (d - c + 1);
}
cout << t;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void r1(T &x) {
x = 0;
char c(getchar());
int f(1);
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = (x * 10) + (c ^ 48);
x *= f;
}
const int mod = 1e9 + 7;
template <typename T, typename... Args>
inline void r1(T &t, Args &...args) {
r1(t);
r1(args...);
}
const int maxn = 2e5 + 5;
const int maxm = maxn << 1;
int n, m;
int d[maxn], S, T;
const int inf = 1e9;
int head[maxn], cnt(1);
struct Edge {
int to, next, w;
} edg[maxn << 1];
int reset[maxn];
void add1(int u, int v, int w) {
edg[++cnt] = (Edge){v, head[u], w}, head[u] = cnt;
reset[cnt] = w;
}
void add(int u, int v, int w) { add1(u, v, w), add1(v, u, w); }
vector<pair<int, int> > vc[maxn];
bool bfs() {
for (int i = 1; i <= n; ++i) d[i] = inf;
static queue<int> q;
while (!q.empty()) q.pop();
q.push(S), d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = edg[i].next) {
int to = edg[i].to, w = edg[i].w;
if (d[to] == inf && w) {
d[to] = d[u] + 1;
q.push(to);
}
}
}
return d[T] != inf;
}
int head1[maxn];
int dfs(int p, int sum) {
if (p == T) return sum;
int res(sum);
for (int &i = head1[p]; i; i = edg[i].next) {
int to = edg[i].to, w = edg[i].w;
if (d[to] == d[p] + 1 && w) {
int s = dfs(to, min(res, w));
if (s) edg[i].w -= s, res -= s, edg[i ^ 1].w += s;
if (!res) return sum;
}
}
if (res == sum) d[p] = inf;
return sum - res;
}
void Add(int u, int v, int w) {
vc[v].push_back(make_pair(u, w)), vc[u].push_back(make_pair(v, w));
}
int a[maxn];
const int N = 25;
inline bool cmp(int a, int b) { return d[a] < d[b]; }
int Maxflow(int S, int T) {
::S = S, ::T = T;
int res(0);
while (bfs()) {
for (int i = 1; i <= n; ++i) head1[i] = head[i];
int ans;
while ((ans = dfs(S, inf))) res += ans;
}
return res;
}
void Solve(int l, int r) {
if (l >= r) return;
int res = Maxflow(a[l], a[r]);
Add(a[l], a[r], res);
sort(a + l, a + r + 1, cmp);
int cut(0);
for (int i = l; i <= r; ++i)
if (d[a[i]] == inf) {
cut = i;
break;
}
for (int i = 1; i <= cnt; ++i) edg[i].w = reset[i];
Solve(l, cut - 1), Solve(cut, r);
}
int Ans[maxn], ed(0);
int Res(0);
map<pair<int, int>, int> vis;
int U, V, Mx(2e9);
int dfs2(int p, int pre) {
int flag(0);
for (int i = 0; i < vc[p].size(); ++i) {
int to = vc[p][i].first;
if (to == pre || vis.count(make_pair(p, to))) continue;
if (vc[p][i].second < Mx) {
Mx = vc[p][i].second;
U = p, V = to;
}
dfs2(to, p), flag = 1;
}
return flag;
}
void dfs1(int p) {
Mx = inf, U = V = 0;
if (!dfs2(p, 0)) return Ans[++ed] = p, void();
vis[make_pair(U, V)] = vis[make_pair(V, U)] = 1;
Res += Mx;
int x = U, y = V;
dfs1(x), dfs1(y);
}
signed main() {
int i, j;
r1(n, m);
for (i = 1; i <= m; ++i) {
int u, v, w;
r1(u, v, w);
add(u, v, w);
}
for (i = 1; i <= n; ++i) a[i] = i;
Solve(1, n);
dfs1(1);
printf("%d\n", Res);
for (i = 1; i <= ed; ++i) printf("%d%c", Ans[i], " \n"[i == ed]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
int readint() {
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 cys = 1000000009;
int n, m, tot;
long long d[105][105], siz[105], tmp[105], ans[105], v[20005], nxt[20005],
h[105], fac[105], inv[105], rt[105], f[105][105], rs[105];
bool vis[105];
long long mod(long long x) { return x >= cys ? x - cys : x; }
long long qpow(long long x, long long p) {
long long ret = 1;
for (; p; p >>= 1, x = x * x % cys)
if (p & 1) ret = ret * x % cys;
return ret;
}
void addedge(int x, int y) {
v[++tot] = y;
nxt[tot] = h[x];
h[x] = tot;
v[++tot] = x;
nxt[tot] = h[y];
h[y] = tot;
}
void dfs(int u, int r) {
memset(d[u], 0, sizeof(d[u]));
d[u][0] = 1;
siz[u] = 1;
if (r) rt[u] = r;
int cnt = 0;
for (int p = h[u]; p; p = nxt[p]) {
if (vis[v[p]]) {
cnt++;
continue;
}
vis[v[p]] = 1;
dfs(v[p], r);
for (int i = 0; i <= siz[u] + siz[v[p]]; i++) tmp[i] = 0;
for (int i = 0; i < siz[u]; i++)
for (int j = 0; j <= siz[v[p]]; j++)
tmp[i + j] = mod(tmp[i + j] + d[u][i] * d[v[p]][j] % cys * fac[i + j] %
cys * inv[i] % cys * inv[j] % cys);
siz[u] += siz[v[p]];
for (int i = 0; i <= siz[u]; i++) d[u][i] = tmp[i];
}
if (cnt <= 1) d[u][siz[u]] = d[u][siz[u] - 1];
if (u == r) rs[u] = siz[u];
}
int main() {
n = readint();
m = readint();
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % cys;
inv[n] = qpow(fac[n], cys - 2);
for (int i = n - 1; i >= 1; i--) inv[i] = inv[i + 1] * (i + 1) % cys;
for (int i = 1; i <= m; i++) addedge(readint(), readint());
ans[0] = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vis[i] = true;
dfs(i, i);
for (int j = 0; j <= n; j++) f[i][j] = d[i][j];
} else {
for (int j = 1; j <= n; j++)
if (rt[j] == rt[i]) vis[j] = 0;
vis[i] = true;
dfs(i, 0);
for (int j = 0; j <= n; j++) f[rt[i]][j] = mod(f[rt[i]][j] + d[i][j]);
}
}
for (int i = 1; i <= n; i++) {
if (rt[i] == i) {
for (int j = 0; j < rs[i]; j++)
f[i][j] = f[i][j] * fac[rs[i] - j - 1] % cys * inv[rs[i] - j] % cys;
for (int j = 0; j <= n; j++) tmp[j] = 0;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++)
tmp[j + k] = mod(tmp[j + k] + ans[j] * f[i][k] % cys * fac[j + k] %
cys * inv[j] % cys * inv[k] % cys);
for (int j = 0; j <= n; j++) ans[j] = tmp[j];
}
}
for (int i = 0; i <= n; i++) printf("%lld\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int i, j, k;
int x, y, z;
scanf("%d", &n);
if (n & 1)
printf("-1\n");
else {
z = 0;
for (k = 0; k < n; ++k) {
x = z;
for (i = 0; i < n; i += 2) {
y = x;
for (j = 0; j < n; j += 2) {
if (y == 1)
printf("bb");
else
printf("ww");
y ^= 1;
}
printf("\n");
y = x;
for (j = 0; j < n; j += 2) {
if (y == 1)
printf("bb");
else
printf("ww");
y ^= 1;
}
printf("\n");
x ^= 1;
}
z ^= 1;
printf("\n\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<vector<int> > ex;
map<vector<int>, pair<pair<int, int>, int> > ans;
int n, m, ret = 0;
vector<int> init, tmp, last;
int out[10][10];
void dfs(vector<int> cur, int xx, int yy, int now, int rem) {
if (yy == m) {
xx++;
yy = 0;
}
if (now + rem / 5 <= ret) return;
if (xx == n) {
last = cur;
ret = now;
return;
}
if (xx <= n - 3 && yy <= m - 3) {
if (((cur[xx] >> yy) & 7) == 7 && ((cur[xx + 1] >> (yy + 1)) & 1) &&
((cur[xx + 2] >> (yy + 1)) & 1)) {
tmp = cur;
tmp[xx] ^= (7 << yy);
tmp[xx + 1] ^= (1 << (yy + 1));
tmp[xx + 2] ^= (1 << (yy + 1));
if (ex.count(tmp) == 0) {
ex.insert(tmp);
ans[tmp] = make_pair(make_pair(xx, yy), 1);
dfs(tmp, xx, yy + 1, now + 1, rem - 5);
}
}
if (((cur[xx + 2] >> yy) & 7) == 7 && ((cur[xx] >> (yy + 1)) & 1) &&
((cur[xx + 1] >> (yy + 1)) & 1)) {
tmp = cur;
tmp[xx + 2] ^= (7 << yy);
tmp[xx] ^= (1 << (yy + 1));
tmp[xx + 1] ^= (1 << (yy + 1));
if (ex.count(tmp) == 0) {
ex.insert(tmp);
ans[tmp] = make_pair(make_pair(xx, yy), 2);
dfs(tmp, xx, yy + 1, now + 1, rem - 6);
}
}
if (((cur[xx + 1] >> yy) & 7) == 7 && ((cur[xx] >> yy) & 1) &&
((cur[xx + 2] >> yy) & 1)) {
tmp = cur;
tmp[xx] ^= (1 << yy);
tmp[xx + 1] ^= (7 << yy);
tmp[xx + 2] ^= (1 << yy);
if (ex.count(tmp) == 0) {
ex.insert(tmp);
ans[tmp] = make_pair(make_pair(xx, yy), 3);
dfs(tmp, xx, yy + 1, now + 1, rem - 5);
}
}
if (((cur[xx + 1] >> yy) & 7) == 7 && ((cur[xx] >> (yy + 2)) & 1) &&
((cur[xx + 2] >> (yy + 2)) & 1)) {
tmp = cur;
tmp[xx] ^= (1 << (yy + 2));
tmp[xx + 1] ^= (7 << yy);
tmp[xx + 2] ^= (1 << (yy + 2));
if (ex.count(tmp) == 0) {
ex.insert(tmp);
ans[tmp] = make_pair(make_pair(xx, yy), 4);
dfs(tmp, xx, yy + 1, now + 1, rem - 6);
}
}
}
dfs(cur, xx, yy + 1, now, rem - ((cur[xx] >> yy) & 1));
return;
}
int main() {
scanf("%d%d", &n, &m);
init.clear();
for (int i = 0; i < n; i++) init.push_back((1 << m) - 1);
ex.insert(init);
ans[init] = make_pair(make_pair(-1, -1), 0);
last = init;
dfs(init, 0, 0, 0, n * m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) out[i][j] = 0;
int t = ret;
while (last != init) {
pair<pair<int, int>, int> stp = ans[last];
int xx = stp.first.first, yy = stp.first.second;
if (stp.second == 1) {
out[xx][yy] = out[xx][yy + 1] = out[xx][yy + 2] = out[xx + 1][yy + 1] =
out[xx + 2][yy + 1] = t;
last[xx] |= (7 << yy);
last[xx + 1] |= (1 << (yy + 1));
last[xx + 2] |= (1 << (yy + 1));
} else if (stp.second == 2) {
out[xx][yy + 1] = out[xx + 1][yy + 1] = out[xx + 2][yy] =
out[xx + 2][yy + 1] = out[xx + 2][yy + 2] = t;
last[xx] |= (1 << (yy + 1));
last[xx + 1] |= (1 << (yy + 1));
last[xx + 2] |= (7 << yy);
} else if (stp.second == 3) {
out[xx][yy] = out[xx + 1][yy] = out[xx + 2][yy] = out[xx + 1][yy + 1] =
out[xx + 1][yy + 2] = t;
last[xx] |= (1 << yy);
last[xx + 1] |= (7 << yy);
last[xx + 2] |= (1 << yy);
} else {
out[xx][yy + 2] = out[xx + 1][yy + 2] = out[xx + 2][yy + 2] =
out[xx + 1][yy + 1] = out[xx + 1][yy] = t;
last[xx] |= (1 << (yy + 2));
last[xx + 1] |= (7 << yy);
last[xx + 2] |= (1 << (yy + 2));
}
t--;
}
printf("%d\n", ret);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (out[i][j] == 0)
putchar('.');
else
putchar('A' + out[i][j] - 1);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int eu, ev, tp, f[100005], p[100005], ans[100005], siz[100005], pS[100005 * 4];
struct edge {
int u, v, typ;
} q[100005 * 36];
map<pair<int, int>, int> mp;
vector<pair<int, int> > e[100005 * 4];
void add(int, int, int, int, int);
void dfs(int, int, int);
inline int find(int);
int main() {
int i, n, m;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d %d", &eu, &ev);
if (!mp[make_pair(eu, ev)])
mp[make_pair(eu, ev)] = i;
else {
add(mp[make_pair(eu, ev)], i - 1, 1, m, 1);
mp[make_pair(eu, ev)] = 0;
}
}
while (!mp.empty()) {
i = (--mp.end())->second;
if (i) {
eu = (--mp.end())->first.first;
ev = (--mp.end())->first.second;
add(i, m, 1, m, 1);
}
mp.erase(--mp.end());
}
for (i = 1; i <= n; ++i) {
f[i] = i;
siz[i] = 1;
}
dfs(1, m, 1);
for (i = 1; i <= m; ++i) puts(ans[i] ? "YES" : "NO");
return 0;
}
void add(int a, int b, int l, int r, int rt) {
int m = (l + r) >> 1;
if (a <= l && r <= b) {
e[rt].push_back(make_pair(eu, ev));
return;
}
if (a <= m) add(a, b, l, m, rt << 1);
if (b > m) add(a, b, m + 1, r, rt << 1 | 1);
}
void dfs(int l, int r, int rt) {
int i, eu, ev, u, v, m = (l + r) >> 1, n = e[rt].size(), fl = 0;
pS[rt] = tp;
for (i = 0; i < n; ++i) {
eu = e[rt][i].first;
ev = e[rt][i].second;
u = find(eu);
v = find(ev);
if (u == v) {
fl = 1;
break;
}
if (p[eu]) {
u = find(p[eu]);
v = find(ev);
if (u ^ v) {
if (siz[u] < siz[v]) swap(u, v);
siz[u] += siz[v];
f[v] = u;
q[++tp].u = u;
q[tp].v = v;
q[tp].typ = 0;
}
} else {
p[eu] = ev;
q[++tp].u = eu;
q[tp].typ = 1;
}
if (p[ev]) {
u = find(p[ev]);
v = find(eu);
if (u ^ v) {
if (siz[u] < siz[v]) swap(u, v);
siz[u] += siz[v];
f[v] = u;
q[++tp].u = u;
q[tp].v = v;
q[tp].typ = 0;
}
} else {
p[ev] = eu;
q[++tp].u = ev;
q[tp].typ = 1;
}
}
if (!fl) {
if (l == r)
ans[l] = 1;
else {
dfs(l, m, rt << 1);
dfs(m + 1, r, rt << 1 | 1);
}
}
while (tp ^ pS[rt]) {
if (q[tp].typ == 0) {
u = q[tp].u;
v = q[tp].v;
siz[u] -= siz[v];
f[v] = v;
} else {
u = q[tp].u;
p[u] = 0;
}
--tp;
}
}
inline int find(int u) {
while (u ^ f[u]) u = f[u];
return u;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
long long d1[500001], b1[500001];
long long d2[500001], b2[500001];
vector<int> adj[500001];
vector<int> r[500001];
int cs[500001];
int bc[500001];
void kurorz(vector<int>& v) {
if (v.empty()) return;
for (int i = 0; i < v.size(); i++)
if (v[i] > v.back()) swap(v[i], v.back());
int orz = v.back();
int mx = 0;
for (int i = 0; i < v.size() - 1; i++) mx = max(mx, v[i]);
for (int i = 0; i < v.size() - 1; i++) cs[v[i]]++;
int ptr = 0;
for (int i = 0; i <= mx; i++) {
for (int j = 0; j < cs[i]; j++) v[ptr++] = i;
cs[i] = 0;
}
}
vector<pair<int, int> > s;
vector<pair<int, int> > t;
int cnt[500001], duh[500001];
void kuroni(int id, int p) {
s.clear();
if (bc[id] == 0) return;
int mx = 0;
for (auto cur : adj[id]) {
if (cur == p) continue;
if (cur == bc[id]) continue;
int ptr = 0;
for (auto t : r[cur]) {
cnt[t]++;
duh[t] = max(duh[t], (int)r[cur].size() - ptr);
mx = max(mx, t);
ptr++;
}
}
int ptr = 0;
for (auto t : r[bc[id]]) {
if (t > mx) break;
cnt[t]++;
duh[t] = max(duh[t], (int)r[bc[id]].size() - ptr);
ptr++;
}
for (int i = 0; i <= mx; i++) {
for (int j = 0; j < cnt[i]; j++) s.push_back({i, duh[i]});
cnt[i] = duh[i] = 0;
}
ptr = -1;
for (auto t : r[bc[id]]) {
ptr++;
if (t <= mx) continue;
s.push_back({t, r[bc[id]].size() - ptr});
}
}
void dfs(int id, int p) {
for (auto cur : adj[id]) {
if (cur == p) continue;
dfs(cur, id);
if (d2[id] < d1[cur] + 1) {
d2[id] = d1[cur] + 1;
b2[id] = cur;
}
if (d2[id] > d1[id]) {
swap(d1[id], d2[id]);
swap(b1[id], b2[id]);
}
if (d1[cur] >= d1[bc[id]]) bc[id] = cur;
r[id].push_back(d1[cur] + 1);
}
kurorz(r[id]);
}
vector<int> v;
long long ans[1000001];
long long ans2[1000001];
void dfs2(int id, int p, long long pd) {
bool duh = false;
for (auto cur : adj[id]) {
if (cur == p) continue;
if (cur == b1[id])
dfs2(cur, id, max(pd, d2[id]) + 1);
else
dfs2(cur, id, max(pd, d1[id]) + 1);
if (adj[cur].size() >= 3) duh = true;
}
v.clear();
for (auto cur : adj[id]) {
if (cur == p) continue;
v.push_back(1 + d1[cur]);
}
kurorz(v);
if (id != 1) v.push_back(pd);
for (int i = (int)v.size() - 1; i >= 1; i--) {
if (v[i] < v[i - 1]) swap(v[i - 1], v[i]);
}
int sz = v.size();
if (v.size() >= 2) {
int x = v.back();
int y = v[v.size() - 2];
ans[x + y] = max(ans[x + y], 2LL);
}
ans[1] = max(ans[1], (long long)v.size() + 1);
kuroni(id, p);
int zs = s.size();
for (int i = (int)s.size() - 1; i >= 1; i--) {
s[i - 1].second = max(s[i - 1].second, s[i].second);
}
s.push_back({(long long)1e9, 0});
for (int i = 0; i < (int)v.size() - 1; i++) {
int cur = v[i];
ans[cur * 2] = max(ans[cur * 2], (long long)sz - i);
if (v[i + 1] != v[i])
ans[cur * 2 + 1] = max(ans[cur * 2 + 1], (long long)sz - i);
}
for (int i = 0; i < (int)v.size(); i++) {
int cur = v[i];
int j =
lower_bound(s.begin(), s.end(), (pair<int, int>){cur, 0}) - s.begin();
ans2[cur * 2] = max(ans2[cur * 2], (long long)(sz - i) + s[j].second - 1);
}
for (int i = 0; i < (int)s.size() - 1; i++) {
int cur = s[i].first;
int j = lower_bound(v.begin(), v.end(), cur) - v.begin();
ans2[cur * 2] = max(ans2[cur * 2], (long long)(sz - j) + s[i].second - 1);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
dfs2(1, 0, 0);
for (int i = 2 * n - 1; i >= 1; i--) ans[i] = max(ans[i + 1], ans[i]);
for (int i = 2 * n - 2; i >= 2; i--) ans2[i] = max(ans2[i + 2], ans2[i]);
for (int i = 1; i <= n; i++) {
ans[i] = max(ans[i], ans2[i]);
cout << max(ans[i], 1LL) << ' ';
}
cout << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e6 + 3;
long long fac[800005];
long long mpe(long long base, long long exponent, long long modulus) {
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = result * base % modulus;
exponent = exponent >> 1;
base = base * base % modulus;
}
return result;
}
long long com(long long n, long long r) {
long long tmp = fac[n];
tmp *= mpe(fac[r], M - 2, M);
tmp %= M;
tmp *= mpe(fac[n - r], M - 2, M);
tmp %= M;
return tmp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
long long n, c;
cin >> n >> c;
fac[0] = 1;
for (long long i = 1; i < 800005; ++i) {
fac[i] = fac[i - 1] * i;
fac[i] %= M;
}
long long an = 0;
for (long long i = 0; i < n; ++i) {
an += com(c + i, i + 1);
an %= M;
}
cout << an;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
int Set(int N, int pos) { return (N | (1 << pos)); }
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return R;
}
const long long mod = 1000000007;
string str[105];
int ara[105];
int vis[205];
int got[204];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> str[i];
}
for (int i = 0; i < m; i++) {
cin >> ara[i];
got[ara[i] - 1] = 1;
}
for (int i = 1; i < m; i++) {
if (str[ara[i - 1] - 1].length() != str[ara[i] - 1].length()) {
cout << "No\n";
return 0;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < str[ara[i] - 1].size(); j++) {
int d = str[ara[i] - 1][j];
if (vis[j] == -1) continue;
if (vis[j] == 0) {
vis[j] = d;
} else if (vis[j] != d) {
vis[j] = -1;
}
}
}
string s;
for (int i = 0; i < str[ara[0] - 1].size(); i++) {
if (vis[i] == -1)
s += "?";
else
s += (char)vis[i];
}
for (int i = 0; i < n; i++) {
if (got[i] == 0) {
int match = 1;
if (str[i].size() != s.size()) continue;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '?') continue;
if (s[j] != str[i][j]) {
match = 0;
break;
}
}
if (match) {
cout << "No\n";
return 0;
}
} else {
if (s.size() != str[i].size()) {
cout << "No\n";
return 0;
}
}
}
cout << "Yes\n";
cout << s << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool checkStr(string& s) {
for (int j = 1; j < s.length(); j++)
if ((s[j] == s[j - 1]) && (s[j] == 'O')) {
s[j] = '+';
s[j - 1] = '+';
return true;
}
return false;
}
int main() {
int n;
bool mark = false;
string s[10000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (mark) continue;
if (checkStr(s[i])) {
mark = true;
}
}
if (mark) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << s[i] << endl;
} else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
const int MOD = INF + 7;
const int NMAX = 100;
int n, m;
long long z[NMAX][NMAX][NMAX][2];
long long rec(int row, int l, int r, bool fl) {
if (row == 0) return 1;
if (z[row][l][r][fl] != -1) return z[row][l][r][fl];
long long res = 1;
for (int nl = l; nl < r; nl++)
for (int nr = nl + 1; nr <= r; nr++) {
bool nfl = nl == l && nr == r;
if (nfl && !fl) continue;
res = (res + rec(row - 1, nl, nr, true)) % MOD;
}
return z[row][l][r][fl] = res;
}
int tupo() {
memset(z, -1, sizeof(z));
long long ans = 0;
for (int i = 0; i < (int)(n); i++)
for (int r = 0; r < (int)(m); r++)
for (int l = 0; l < (int)(r); l++) {
long long r1 = rec(i, l, r, false);
long long r2 = rec(n - i - 1, l, r, true);
ans = (ans + r1 * r2) % MOD;
}
return (int)ans;
}
long long sum_up[2][2100][2100], ups[2][2100][2100], upsk[2][2100][2100];
int solve() {
for (int t = 0; t < (int)(2); t++) {
{
int i = 0;
for (int j = 2; j <= m; j++) {
long long up = 1;
ups[t][i][j] = (up + ups[t][i][j - 1]) % MOD;
upsk[t][i][j] = (up * j + upsk[t][i][j - 1]) % MOD;
sum_up[t][i][j] = 1;
}
}
for (int i = 1; i <= n; i++)
for (int j = 2; j <= m; j++) {
int brd = j - t;
long long up =
(ups[0][i - 1][brd] * (j + 1) - upsk[0][i - 1][brd] + MOD) % MOD;
ups[t][i][j] = (up + ups[t][i][j - 1]) % MOD;
upsk[t][i][j] = (up * j + upsk[t][i][j - 1]) % MOD;
sum_up[t][i][j] = (up + sum_up[t][i - 1][j]) % MOD;
}
}
long long ans = 0;
for (int i = 0; i < (int)(n); i++)
for (int len = 2; len <= m; len++)
ans = (ans + sum_up[0][i][len] * sum_up[1][n - 1 - i][len] % MOD *
(m - len + 1)) %
MOD;
return (int)ans;
}
int main() {
cin >> n >> m;
cout << solve() << endl;
return 0;
for (n = 1; n <= 10; n++) {
for (m = 1; m <= 10; m++) cout << tupo() << ' ';
cout << endl;
}
cout << endl;
for (n = 1; n <= 10; n++) {
for (m = 1; m <= 10; m++) cout << solve() << ' ';
cout << endl;
}
cout << endl;
for (int sum = 1; sum <= 10; sum++) {
for (n = 1; n < sum; n++) {
m = sum - n;
cout << tupo() << ' ';
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans[11] = {0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244};
long long n;
cin >> n;
if (n < 11) {
cout << ans[n] << endl;
} else {
cout << (n - 11ll) * 49ll + 292ll << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
static char c;
int f = 0;
while (!isdigit(c = getchar()))
if (c == '-') f = 1;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
if (f) x = -x;
}
void read(long long &x) {
static char c;
int f = 0;
while (!isdigit(c = getchar()))
if (c == '-') f = 1;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
if (f) x = -x;
}
void read(unsigned int &x) {
static char c;
while (!isdigit(c = getchar()))
;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
}
void read(unsigned long long &x) {
static char c;
while (!isdigit(c = getchar()))
;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
}
void chkmax(int &x, int y) {
if (y > x) x = y;
}
void chkmin(int &x, int y) {
if (y < x) x = y;
}
void chkmax(long long &x, long long y) {
if (y > x) x = y;
}
void chkmin(long long &x, long long y) {
if (y < x) x = y;
}
void chkmax(unsigned int &x, unsigned int y) {
if (y > x) x = y;
}
void chkmin(unsigned int &x, unsigned int y) {
if (y < x) x = y;
}
void chkmax(unsigned long long &x, unsigned long long y) {
if (y > x) x = y;
}
void chkmin(unsigned long long &x, unsigned long long y) {
if (y < x) x = y;
}
long long sq(long long x) { return x * x; }
const int N = 4e5 + 10;
int n, m;
vector<int> Edge[N];
int _Fat[N], col[N];
long long def[N], _def;
int cnt;
vector<pair<int, int> > O[N];
namespace LCT {
struct Node {
int fat, son[2];
long long alls, ligs, ligs2, alls2;
} t[N];
void Init() {
for (int i = 1; i <= n + 1; ++i)
t[i].fat = t[i].son[0] = t[i].son[1] = t[i].ligs = t[i].ligs2 = 0,
t[i].alls = t[i].alls2 = 1;
}
void Update(int now) {
int ls = t[now].son[0], rs = t[now].son[1];
t[now].alls = t[ls].alls + t[rs].alls + t[now].ligs + 1;
t[now].alls2 = sq(t[now].alls);
}
int NoRt(int now) {
for (int D : {0, 1})
if (t[t[now].fat].son[D] == now) return true;
return false;
}
int GDir(int now) { return t[t[now].fat].son[1] == now; }
void Rorate(int now) {
int Fat = t[now].fat, Gat = t[Fat].fat;
int Fdir = GDir(now), Gdir = GDir(Fat);
if (NoRt(Fat)) t[Gat].son[Gdir] = now;
t[now].fat = Gat, t[Fat].fat = now;
t[t[now].son[Fdir ^ 1]].fat = Fat;
t[Fat].son[Fdir] = t[now].son[Fdir ^ 1];
t[now].son[Fdir ^ 1] = Fat;
Update(Fat), Update(now);
}
void Splay(int now) {
while (NoRt(now)) {
int Fat = t[now].fat;
if (NoRt(Fat)) (GDir(now) ^ GDir(Fat)) ? Rorate(now) : Rorate(Fat);
Rorate(now);
}
}
void Access(int now) {
for (int i = 0; now; now = t[i = now].fat) {
int &rs = t[now].son[1];
Splay(now);
t[now].ligs -= t[i].alls, t[now].ligs2 -= t[i].alls2;
t[now].ligs += t[rs].alls, t[now].ligs2 += t[rs].alls2;
rs = i, Update(now);
}
}
int Findroot(int now) {
Access(now), Splay(now);
while (t[now].son[0]) now = t[now].son[0];
return Splay(now), now;
}
void Link(int now, long long &res) {
Splay(now), res -= t[now].ligs2 + t[t[now].son[1]].alls2;
int Fat = _Fat[now];
int Rt = Findroot(Fat);
Splay(Rt), res -= t[t[Rt].son[1]].alls2;
Splay(Fat), t[now].fat = Fat;
Update(now), t[Fat].ligs += t[now].alls, t[Fat].ligs2 += t[now].alls2,
Update(Fat);
Access(now), Splay(Rt), res += t[t[Rt].son[1]].alls2;
}
void Cut(int now, long long &res) {
Access(now), res += t[now].ligs2;
int Fat = _Fat[now];
int Rt = Findroot(Fat);
Access(now), Splay(Rt), res -= t[t[Rt].son[1]].alls2;
Splay(now), t[now].son[0] = t[t[now].son[0]].fat = 0, Update(Fat);
Splay(Rt), res += t[t[Rt].son[1]].alls2;
}
}; // namespace LCT
using namespace LCT;
void Modify(int now, long long &res) {
if (t[now].fat)
Cut(now, res);
else
Link(now, res);
}
void Work() {
read(n), read(m);
for (int i = 1; i <= n; ++i) {
read(col[i]);
O[col[i]].push_back(make_pair(i, 0));
}
for (int i = 1; i < n; ++i) {
int u, v;
read(u), read(v);
Edge[u].push_back(v), Edge[v].push_back(u);
}
const auto &GetF = []() -> void {
function<void(int, int)> dfs;
dfs = [&dfs](int now, int fa) -> void {
_Fat[now] = fa;
for (int v : Edge[now])
if (v != fa) dfs(v, now);
};
dfs(1, n + 1);
};
GetF();
for (int i = 1; i <= m; ++i) {
int u, c;
read(u), read(c);
O[col[u]].push_back(make_pair(u, i));
O[col[u] = c].push_back(make_pair(u, i));
}
Init();
for (int i = 1; i <= n; ++i) Modify(i, _def);
for (int i = 1; i <= n; ++i) {
if (!O[i].size()) continue;
for (int o = 0; o < O[i].size(); ++o) {
int now = O[i][o].first, tim = O[i][o].second;
Modify(now, def[tim]);
}
for (int o = O[i].size() - 1; ~o; --o) {
int now = O[i][o].first;
Modify(now, _def);
}
}
long long Ans = 0;
for (int i = 0; i <= m; ++i) printf("%lld\n", Ans -= def[i]);
}
int main() { Work(); }
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
char a[105][105];
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int res = 0;
for (int i = 0; i < n; i++) {
int b[10];
memset(b, 0, sizeof(b));
int len = strlen(a[i]);
for (int j = 0; j < len; j++) {
b[a[i][j] - '0'] = 1;
}
int f = false;
for (int j = 0; j <= k; j++)
if (b[j] == 0) {
f = true;
break;
}
if (!f) res++;
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int a, b, i, n, q, p[240];
for (cin >> q; q--; cout << (a * b ? "NO" : "YES") << endl)
for (cin >> n, a = b = i = 0;
i++<n; a += i> 1 && p[i] - 1 ^ p[i - 1] && p[i] + n - 1 ^ p[i - 1],
b += i > 1 && p[i] + 1 ^ p[i - 1] && p[i] - n + 1 ^ p[i - 1])
cin >> p[i];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 5;
const long long int p = 31;
const long long int m = 1e9 + 9;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
long long int x, y, z;
cin >> x >> y >> z;
long long int x1, y1, z1;
cin >> x1 >> y1 >> z1;
long long int a1, a2, a3, a4, a5, a6;
cin >> a1 >> a2 >> a3 >> a4 >> a5 >> a6;
long long int ans = 0;
if (y < 0) {
ans += a1;
}
if (y > y1) {
ans += a2;
}
if (x < 0) {
ans += a5;
}
if (x > x1) {
ans += a6;
}
if (z < 0) {
ans += a3;
}
if (z > z1) {
ans += a4;
}
cout << ans;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double c[1010][1010];
double dp[1010][1010];
int belong[1010][1010];
int all[1010];
int has[1010];
int tag[1010];
int cnt_all;
int cmp(int a, int b) { return a > b; }
int V;
void getc() {
c[1][0] = c[1][1] = 1;
for (int i = 2; i <= 1000; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
}
}
int cnt_t, s;
int n, m;
int main() {
scanf("%d%d", &n, &m);
getc();
for (int i = 1; i <= m; i++) {
scanf("%d", &belong[i][0]);
for (int j = 1; j <= belong[i][0]; j++) {
scanf("%d", &belong[i][j]);
all[++cnt_all] = belong[i][j];
}
}
sort(all + 1, all + cnt_all + 1, cmp);
for (int i = n; i >= 1; i--) {
if (all[i] != all[i - 1]) {
V = all[i];
break;
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= belong[i][0]; j++) {
if (belong[i][j] > V)
has[i]++, s++;
else if (belong[i][j] == V)
tag[i] = 1, cnt_t++;
}
}
dp[0][0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (tag[i]) {
if (j > 0)
dp[i][j] = dp[i - 1][j] / c[belong[i][0]][has[i]] +
dp[i - 1][j - 1] / c[belong[i][0]][has[i] + 1];
else
dp[i][j] = dp[i - 1][j] / c[belong[i][0]][has[i]];
} else
dp[i][j] = dp[i - 1][j] / c[belong[i][0]][has[i]];
}
}
printf("%.9lf\n", dp[m][n - s] / c[cnt_t][n - s]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long t, i, as, answer[262144];
char c;
long long int key(long long as) {
long long i, temp = 0;
for (i = 1; i <= 18; i++, as /= 10) temp = (temp << 1) + (as & 1);
return temp;
}
int main() {
cin >> t;
for (i = 1; i <= t; i++) {
cin >> c >> as;
switch (c) {
case '+':
answer[key(as)]++;
break;
case '-':
answer[key(as)]--;
break;
case '?':
cout << answer[key(as)] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 5;
vector<int> vec[MAXN];
int A[MAXN], B[MAXN];
int n, k;
void solve() {
cin >> n >> k;
for (int i = (1); i < (n + 1); ++i) {
cin >> A[i];
}
for (int i = (1); i < (n + 1); ++i) {
cin >> B[i];
}
for (int i = (1); i < (n + 1); ++i) {
vec[A[i]].push_back(B[i]);
}
vector<int> T;
int need = 0;
for (int i = (1); i < (k + 1); ++i) {
if (vec[i].empty()) {
need++;
} else {
sort((vec[i]).begin(), (vec[i]).end());
vec[i].pop_back();
for (int x : vec[i]) {
T.push_back(x);
}
}
}
assert((int)(T).size() >= need);
sort((T).begin(), (T).end());
long long ans = 0;
for (int i = (0); i < (need); ++i) {
ans += T[i];
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long f[1000010], fac_inv[1000010], inv[1000010];
void init() {
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
if (i >= mod) break;
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
}
fac_inv[0] = 1;
for (int i = 1; i < 1000010; ++i) fac_inv[i] = fac_inv[i - 1] * inv[i] % mod;
}
long long Pow(long long x, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * x % mod;
x = x * x % mod;
n >>= 1;
}
return ans;
}
long long n_k(int n, int k) {
f[0] = 0;
for (int i = 1; i <= k + 2; ++i) f[i] = (f[i - 1] + Pow(i, k)) % mod;
if (n <= k + 2) return f[n];
long long cur = 1, ans = 0;
for (int i = 1; i <= k + 2; ++i) cur = cur * (n - i) % mod;
for (int i = 1; i <= k + 2; ++i) {
long long inv1 = (n - i < 1000010) ? inv[n - i] : Pow(n - i, mod - 2);
long long inv2 = fac_inv[i - 1] * fac_inv[k + 2 - i] % mod;
int sign = (k + 2 - i) % 2 ? -1 : 1;
ans = (ans + sign * inv1 * inv2 % mod * f[i] % mod * cur % mod) % mod;
}
ans = ans + mod;
if (ans >= mod) ans -= mod;
return ans;
}
int main() {
init();
int n, k;
cin >> n >> k;
cout << n_k(n, k) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[3000], b[3000];
vector<pair<int, int>> ans;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
int l = i + 1;
while (b[l] != a[i]) {
++l;
}
for (int j = l; j > i; --j) {
int t = b[j];
b[j] = b[j - 1];
b[j - 1] = t;
ans.push_back(make_pair(j - 1, j));
}
}
}
cout << ans.size() << endl;
if (ans.size() != 0) {
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].first + 1 << ' ' << ans[i].second + 1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
const int mod = 7340033;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int sum(int a, int b) {
add(a, b);
return a;
}
int mult(int a, int b) { return (1ll * a * b) % mod; }
int q, n, k, dp[30][N], t[N];
int main() {
for (int it = 0; it < 30; it++) {
dp[it][0] = 1;
if (it == 0) continue;
for (int i = 0; i <= 1000; i++) {
t[i] = 0;
for (int j = 0; j <= i; j++)
add(t[i], mult(dp[it - 1][j], dp[it - 1][i - j]));
}
for (int i = 1; i <= 1000; i++)
for (int j = 0; j < i; j++) add(dp[it][i], mult(t[j], t[i - j - 1]));
}
scanf("%d", &q);
while (q--) {
scanf("%d%d", &n, &k);
int cur = 0;
while ((n & 1) && n > 1) {
cur++;
n >>= 1;
}
printf("%d\n", dp[cur][k]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100, MAXL = 20;
int n, m, q, niv[MAXN], c[MAXN], pai[MAXN], dp[MAXN][MAXL];
vector<int> g[MAXN], ids[MAXN];
bool calc[MAXN][MAXL];
vector<int> memo[MAXN][MAXL];
void dfs(int v, int p = -1) {
for (auto u : g[v])
if (u != p) pai[u] = v, niv[u] = niv[v] + 1, dfs(u, v);
}
void add(int v, int id) {
ids[v].push_back(id);
sort(ids[v].begin(), ids[v].end());
if (ids[v].size() > 10) ids[v].pop_back();
}
int ancestral(int v, int x) {
if (x == 0) return pai[v];
if (dp[v][x] != -1) return dp[v][x];
return dp[v][x] = ancestral(ancestral(v, x - 1), x - 1);
}
vector<int> join(vector<int> a, vector<int> b) {
vector<int> ret;
for (auto u : a) ret.push_back(u);
for (auto u : b) ret.push_back(u);
sort(ret.begin(), ret.end());
while (ret.size() > 10) ret.pop_back();
return ret;
}
vector<int> f(int v, int x) {
if (calc[v][x]) return memo[v][x];
calc[v][x] = 1;
if (x == 0) return memo[v][x] = ids[v];
return memo[v][x] = join(f(v, x - 1), f(ancestral(v, x - 1), x - 1));
}
int lca(int a, int b) {
if (niv[a] < niv[b]) swap(a, b);
for (int i = MAXL - 1; i >= 0; i--)
if (niv[a] - (1 << i) >= niv[b]) a = ancestral(a, i);
if (a == b) return a;
for (int i = MAXL - 1; i >= 0; i--)
if (niv[a] - (1 << i) >= 0 && ancestral(a, i) != ancestral(b, i))
a = ancestral(a, i), b = ancestral(b, i);
return pai[a];
}
vector<int> resp(int a, int b) {
int x = lca(a, b);
vector<int> ret;
for (int i = MAXL - 1; i >= 0; i--)
if (niv[a] - (1 << i) >= niv[x])
ret = join(ret, f(a, i)), a = ancestral(a, i);
for (int i = MAXL - 1; i >= 0; i--)
if (niv[b] - (1 << i) >= niv[x])
ret = join(ret, f(b, i)), b = ancestral(b, i);
ret = join(ret, ids[x]);
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d %d %d", &n, &m, &q);
for (int i = 1, a, b, c; i < n; i++)
scanf("%d %d", &a, &b), g[a].emplace_back(b), g[b].emplace_back(a);
for (int i = 1; i <= m; i++) scanf("%d", &c[i]), add(c[i], i);
dfs(1);
while (q--) {
int u, v, a;
scanf("%d %d %d", &u, &v, &a);
vector<int> ans = resp(u, v);
if (ans.size() == 0)
puts("0");
else {
int sz = min((int)ans.size(), a);
printf("%d ", sz);
for (int i = 0; i <= min((int)ans.size() - 1, a - 1); i++)
printf("%d ", ans[i]);
puts("");
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ht(1234567), sum(1234567);
int main() {
long long a, b, n;
cin >> a >> b >> n;
sum[0] = a;
for (long long i = 0; i < 1234567; i++) {
ht[i] = a + i * b;
sum[i + 1] = sum[i] + a + (i + 1) * b;
}
while (n--) {
long long l, t, m, ans;
cin >> l >> t >> m;
l--;
if (t < ht[l])
ans = -1;
else {
long long mx = upper_bound(ht.begin() + l, ht.end(), t) - ht.begin();
long long prod = m * t;
if (l > 0) prod += sum[l - 1];
ans = upper_bound(sum.begin() + l, sum.begin() + mx, prod) - sum.begin();
ans--;
if (ans < l)
ans = -1;
else
ans++;
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using u64 = uint64_t;
using u32 = uint32_t;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vpi = vector<pi>;
static constexpr int INF = (int)1e9;
static constexpr ll INFL = (ll)1e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<string> s(n), t(m);
for (auto& si : s) cin >> si;
for (auto& ti : t) cin >> ti;
int q, y;
cin >> q;
while (q--) cin >> y, --y, cout << s[y % n] << t[y % m] << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(k), b(k), ada(k), sudah(n, 0), wis(k, 0);
vector<vector<int>> g(n);
for (int i = 0; i < k; i++) {
cin >> a[i] >> b[i];
ada[i] = 2;
a[i] -= 1, b[i] -= 1;
g[a[i]].push_back(i);
g[b[i]].push_back(i);
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
for (int i = 0; i < k; i++) pq.push({ada[i], i});
int jaw = 0;
while (!pq.empty()) {
auto now = pq.top();
pq.pop();
if (ada[now.second] != now.first || wis[now.second]) continue;
if (now.first == 0) {
jaw += 1;
wis[now.second] = 1;
continue;
}
wis[now.second] = 1;
if (!sudah[a[now.second]]) {
sudah[a[now.second]] = 1;
for (int i : g[a[now.second]]) {
ada[i] -= 1;
pq.push({ada[i], i});
}
}
if (!sudah[b[now.second]]) {
sudah[b[now.second]] = 1;
for (int i : g[b[now.second]]) {
ada[i] -= 1;
pq.push({ada[i], i});
}
}
}
cout << jaw << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int n, k;
string s[2007];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> s[i];
int inf = n * n + 1;
vector<vector<int>> dist(n, vector<int>(n, inf));
deque<pair<int, int>> q;
if (s[0][0] == 'a')
dist[0][0] = 0;
else
dist[0][0] = 1;
q.emplace_back(0, 0);
while (!q.empty()) {
int x, y;
tie(x, y) = q.front();
q.pop_front();
if (x < n - 1) {
int di = s[x + 1][y] != 'a';
if (dist[x][y] + di < dist[x + 1][y]) {
dist[x + 1][y] = dist[x][y] + di;
if (di == 0)
q.emplace_front(x + 1, y);
else
q.emplace_back(x + 1, y);
}
}
if (y < n - 1) {
int di = s[x][y + 1] != 'a';
if (dist[x][y] + di < dist[x][y + 1]) {
dist[x][y + 1] = dist[x][y] + di;
if (di == 0)
q.emplace_front(x, y + 1);
else
q.emplace_back(x, y + 1);
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (dist[i][j] <= k) s[i][j] = 'a';
string res(2 * n - 1, '?');
set<pair<int, int>> active;
active.emplace(0, 0);
for (int _ = 0; _ < 2 * n - 1; _++) {
vector<bool> have(26);
for (const auto &p : active) {
have[s[p.first][p.second] - 'a'] = true;
}
int want = -1;
for (int i = 0; i < 26; i++)
if (have[i]) {
want = i;
break;
}
res[_] = (char)(want + 'a');
set<pair<int, int>> ne;
for (const auto &p : active) {
if (s[p.first][p.second] - 'a' != want) continue;
if (p.first < n - 1) ne.emplace(p.first + 1, p.second);
if (p.second < n - 1) ne.emplace(p.first, p.second + 1);
}
active = ne;
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
vector<int> edges[MAX];
int arr[MAX];
int sol = 0;
bool dfs(int a, int prev) {
bool res = true;
for (auto e : edges[a]) {
if (e == prev) continue;
if (dfs(e, a)) res = false;
}
if (res) {
sol++;
if (a > 1)
swap(arr[a], arr[prev]);
else
swap(arr[1], arr[edges[1][0]]);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b;
cin >> n;
for (int i = 1; i <= n; i++) arr[i] = i;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
dfs(1, 0);
cout << sol * 2 << "\n";
for (int i = 1; i <= n; i++) cout << arr[i] << " ";
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, sum, p;
cin >> m;
for (int i = 5; i < 400006; i += 5) {
p = 5, sum = 0;
while (i / p) sum += i / p, p *= 5;
if (sum == m) {
cout << "5\n"
<< i << ' ' << i + 1 << ' ' << i + 2 << ' ' << i + 3 << ' ' << i + 4;
return 0;
}
}
cout << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0);
const long long N = 1e9 + 5;
long long i, j, x, y, z, t;
int main() {
char c[4];
cin >> c[1] >> x;
cin >> c[2] >> y;
z = c[1] + 1 - 'a';
t = c[2] + 1 - 'a';
long long ar[9][9] = {0};
for (i = 1; i < 9; i++) {
ar[z][i] = 1;
}
for (i = 1; i < 9; i++) {
ar[i][x] = 1;
}
ar[t][y] = 1;
for (int i = 1; i <= 8; i++) {
for (int j = 1; j <= 8; j++) {
if ((abs(i - t) == 2 && abs(j - y) == 1) ||
(abs(i - t) == 1 && abs(j - y) == 2)) {
ar[i][j] = 1;
}
if ((abs(i - z) == 2 && abs(j - x) == 1) ||
(abs(i - z) == 1 && abs(j - x) == 2)) {
ar[i][j] = 1;
}
}
}
long long ans = 0;
for (int i = 1; i <= 8; i++) {
for (int j = 1; j <= 8; j++)
if (ar[i][j] == 0) {
ans++;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
auto clk = clock();
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
for (long long i = 0; i < n; i++) cout << s[2 * i];
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(8);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
bool r[N], c[N], f[N][N];
int main() {
int n, ans;
char s[N];
scanf("%d ", &n);
for (int i = 0; i < n; ++i) {
gets(s);
for (int j = 0; j < n; ++j)
if (s[j] == '1') f[i + 1][j + 1] = true;
}
ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = n; j > i; --j)
if (f[i][j] ^ r[i] ^ c[j]) {
ans++;
r[i] ^= 1;
c[j] ^= 1;
}
f[i][i] ^= r[i] ^ c[i];
}
memset(r, false, sizeof(r));
memset(c, false, sizeof(c));
for (int i = n; i > 0; --i)
for (int j = 1; j <= i; ++j)
if (f[i][j] ^ r[i] ^ c[j]) {
ans++;
r[i] ^= 1;
c[j] ^= 1;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int count = 0, maxi = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1])
count++;
else {
maxi = max(maxi, count);
count = 0;
}
}
maxi = max(maxi, count);
cout << maxi + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, d;
cin >> n >> d;
string s;
cin >> s;
int dp[n];
for (int i = 0; i < n; i++) {
dp[i] = INT_MAX;
}
if (s[0] == '1') {
dp[0] = 0;
} else {
cout << -1 << "\n";
return;
}
int i = 0;
while (i < n) {
if (s[i] != '1') {
i++;
continue;
}
for (int j = d; j >= 1; j--) {
if (i + j < n) {
if (s[i + j] == '1') {
dp[i + j] = min(dp[i + j], dp[i] + 1);
}
}
}
i++;
}
if (dp[n - 1] == INT_MAX || dp[n - 1] < 0) {
cout << -1;
} else {
cout << dp[n - 1];
}
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ret = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ret = (ret << 1) + (ret << 3) + ch - '0';
ch = getchar();
}
return ret * f;
}
inline long long readl() {
long long ret = 0;
int f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ret = (ret << 1) + (ret << 3) + ch - '0';
ch = getchar();
}
return ret * f;
}
int n, t, k;
long long m, C[75][75], ans;
inline void pre() {
C[0][0] = 1;
for (register int i = 1; i <= 67; i++) {
C[i][0] = 1;
for (register int j = 1; j <= i; j++)
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
inline long long calc(int k, long long m) {
if (m == -1) return 0;
long long ret = 0;
while (k) {
int pos = k;
while (C[pos][k] <= m) pos++;
pos--;
ret |= 1ll << pos;
m -= C[pos][k];
k--;
}
return ret;
}
int main() {
pre();
m = readl();
k = read();
k--;
if (!k)
printf("1\n");
else {
ans = calc(k, m - 1) + 1ll;
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> prefix_function(const string &s) {
const int n = s.size();
vector<int> pi(n, 0);
int j;
for (int i = 1; i < n; ++i) {
j = pi[i - 1];
while ((j > 0) && (s[i] != s[j])) j = pi[j - 1];
if (s[i] == s[j]) ++j;
pi[i] = j;
}
return pi;
}
vector<int> z_function(const string &s) {
const int n = s.size();
vector<int> z(n, 0);
int j;
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) {
z[i] = min(r - i + 1, z[i - l]);
}
while ((i + z[i] < n) && (s[z[i]] == s[i + z[i]])) ++z[i];
if (i + z[i] > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
int main() {
string s;
cin >> s;
int mx = s[0];
int mx_count = 1;
for (int i = 1; i < s.size(); ++i) {
if (s[i] > mx) {
mx = s[i];
mx_count = 1;
} else if (s[i] == mx) {
++mx_count;
}
}
string ans(mx_count, mx);
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807LL;
const long long SMALL_INF = 2009000999;
const long long NSIZE = 2 * 1e+5 + 1000;
const long long MOD = 998244353;
const long double EPS = 1e-12;
const long long MAX = 1e+6 + 1000;
const long double PI = atan(1) * 4;
bool checkPlusPos(char sym, int pos) {
if (sym == '+') {
return !(pos % 2);
} else {
return pos % 2;
}
}
int getPlusCnt(int init_l, int l, int r, vector<int> &p) {
if (init_l % 2 == 0) {
return l == 0 ? p[r] : p[r] - p[l - 1];
} else {
return l == 0 ? (r - l + 1) - p[r] : (r - l + 1) - (p[r] - p[l - 1]);
}
}
int getMinusCnt(int init_l, int l, int r, vector<int> &p) {
return (r - l + 1) - getPlusCnt(init_l, l, r, p);
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, q;
cin >> n >> q;
string second(n, '?');
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> second[i];
p[i] = checkPlusPos(second[i], i);
if (i > 0) {
p[i] += p[i - 1];
}
}
while (q--) {
int segl, segr;
cin >> segl >> segr;
segl--;
segr--;
int pluspos = getPlusCnt(segl, segl, segr, p);
int minpos = getMinusCnt(segl, segl, segr, p);
if (pluspos == minpos) {
cout << 0 << endl;
continue;
}
vector<int> ans;
if ((segr - segl + 1) % 2 == 0) {
ans.push_back(segl + 1);
segl++;
}
pluspos = getPlusCnt(segl, segl, segr, p);
minpos = getMinusCnt(segl, segl, segr, p);
int l = segl, r = segr;
while (l < r) {
int m = (r + l + 1) / 2;
if (pluspos > minpos) {
if (getPlusCnt(segl, m, segr, p) - getMinusCnt(segl, m, segr, p) <
(pluspos - minpos) / 2 + 1)
r = m - 1;
else
l = m;
} else {
if (getMinusCnt(segl, m, segr, p) - getPlusCnt(segl, m, segr, p) <
(minpos - pluspos) / 2 + 1)
r = m - 1;
else
l = m;
}
}
ans.push_back(l + 1);
cout << ans.size() << endl;
for (auto i : ans) cout << i << " ";
cout << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n, c0, c1, h;
cin >> n >> c0 >> c1 >> h;
string s;
cin >> s;
bool change1 = false;
bool change0 = false;
bool isEqual = false;
int ans = 0;
if (c0 == c1)
isEqual = true;
else if (c0 > c1 && c1 + h <= c0)
change0 = true;
else if (c1 > c0 && c0 + h <= c1)
change1 = true;
for (char ch : s) {
if (isEqual && ch == '0')
ans += c0;
else if (isEqual && ch == '1')
ans += c1;
else if (ch == '0' && change0)
ans += (c1 + h);
else if (ch == '1' && change1)
ans += (c0 + h);
else if (ch == '0')
ans += c0;
else
ans += c1;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a[2050] = {0}, Ti = 0, node = 1;
int main() {
cin >> n;
for (int i = 1; i <= n + 1; i++) node *= 2;
node--;
for (int i = 2; i <= node; i++) cin >> a[i];
for (int i = node; i > 1; i -= 2) {
Ti += abs(a[i] - a[i - 1]);
a[i / 2] += max(a[i], a[i - 1]);
}
cout << Ti << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 128;
int k, x, y, z, i, j;
bool g[maxn][maxn];
void G(int a, int b) { g[a][b] = g[b][a] = true; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> k;
for (G(0, 3), G(0, 4), x = 3, y = 4, z = 5; k;
x += 3, y += 3, z += 3, k /= 2) {
G(x, x + 3);
G(x, y + 3);
G(y, y + 3);
G(y, x + 3);
G(z, z + 3);
if (k & 1) G(y, z);
}
G(1, z);
for (cout << 100 << endl, i = 0; i < 100; cout << endl, i++)
for (j = 0; j < 100; j++)
if (g[i][j])
cout << 'Y';
else
cout << 'N';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double sum[400010], ans[400010];
void build(int p, int l, int r) {
if (l == r) {
ans[p] = 2;
sum[p] = 1;
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
sum[p] = min(1e9, sum[p << 1] * sum[p << 1 | 1]);
ans[p] = min(1e9, ans[p << 1] + sum[p << 1] * (ans[p << 1 | 1] - 1));
}
void update(int p, int l, int r, int x, double z) {
if (l == r) {
ans[p] = z + 1;
sum[p] = z;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(p << 1, l, mid, x, z);
else
update(p << 1 | 1, mid + 1, r, x, z);
sum[p] = min(1e9, sum[p << 1] * sum[p << 1 | 1]);
ans[p] = min(1e9, ans[p << 1] + sum[p << 1] * (ans[p << 1 | 1] - 1));
}
struct qq {
double as, sum;
};
qq ask(int p, int l, int r, int x, int y) {
int mid = (l + r) >> 1;
if (x <= l && y >= r) return (qq){ans[p], sum[p]};
if (y <= mid) return ask(p << 1, l, mid, x, y);
if (x > mid) return ask(p << 1 | 1, mid + 1, r, x, y);
qq t = ask(p << 1, l, mid, x, y), t2 = ask(p << 1 | 1, mid + 1, r, x, y);
return (qq){min(1e9, t.as + t.sum * (t2.as - 1)), min(t.sum * t2.sum, 1e9)};
}
int main() {
scanf("%d%d", &n, &m);
build(1, 1, n);
for (int i = 1, a, b; i <= n; i++)
scanf("%d%d", &a, &b), update(1, 1, n, i, 1.0 * (b - a) / a);
for (int i = 1, ty, l, r, a, b, x; i <= m; i++) {
scanf("%d", &ty);
if (ty & 1)
scanf("%d%d%d", &x, &a, &b), update(1, 1, n, x, 1.0 * (b - a) / a);
else
scanf("%d%d", &l, &r), printf("%.6lf\n", 1.0 / ask(1, 1, n, l, r).as);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 110000;
int a[nn], k, n;
int hasn[nn];
int main() {
while (cin >> n >> k) {
memset(hasn, 0, sizeof(hasn));
for (int i = 0; i < n; i++) {
cin >> a[i];
hasn[a[i]]++;
}
vector<int> tem;
for (int i = 0; i < (1 << 14); i++) {
int num = 0;
for (int j = 0; j < 14; j++) {
if (i & (1 << j)) num++;
}
if (num == k) tem.push_back(i);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
hasn[a[i]]--;
for (int j = 0; j < tem.size(); j++) {
ans += hasn[a[i] ^ tem[j]];
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
map<int, string> dic;
dic.insert(make_pair(0, "zero"));
dic.insert(make_pair(1, "one"));
dic.insert(make_pair(2, "two"));
dic.insert(make_pair(3, "three"));
dic.insert(make_pair(4, "four"));
dic.insert(make_pair(5, "five"));
dic.insert(make_pair(6, "six"));
dic.insert(make_pair(7, "seven"));
dic.insert(make_pair(8, "eight"));
dic.insert(make_pair(9, "nine"));
dic.insert(make_pair(10, "ten"));
dic.insert(make_pair(11, "eleven"));
dic.insert(make_pair(12, "twelve"));
dic.insert(make_pair(13, "thirteen"));
dic.insert(make_pair(14, "fourteen"));
dic.insert(make_pair(15, "fifteen"));
dic.insert(make_pair(16, "sixteen"));
dic.insert(make_pair(17, "seventeen"));
dic.insert(make_pair(18, "eighteen"));
dic.insert(make_pair(19, "nineteen"));
dic.insert(make_pair(20, "twenty"));
dic.insert(make_pair(30, "thirty"));
dic.insert(make_pair(40, "forty"));
dic.insert(make_pair(50, "fifty"));
dic.insert(make_pair(60, "sixty"));
dic.insert(make_pair(70, "seventy"));
dic.insert(make_pair(80, "eighty"));
dic.insert(make_pair(90, "ninety"));
if (s < 21)
cout << dic[s] << endl;
else if (s % 10 == 0)
cout << dic[s] << endl;
else
cout << dic[s / 10 * 10] << '-' << dic[s % 10] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int dx[8] = {1, 0, 0, -1, -1, -1, 1, 1},
dy[8] = {0, -1, 1, 0, -1, 1, -1, 1};
int n, m;
int b[200005 * 2];
struct node {
int x, y, tag;
} a[200005];
long long sum[200005 * 2];
long long dp[200005 * 2];
bool cmp(node x, node y) { return x.x < y.x; }
void solve() {
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y >> a[i].tag;
b[++cnt] = a[i].x;
b[++cnt] = a[i].y;
}
sort(b + 1, b + 1 + cnt);
cnt = unique(b + 1, b + 1 + cnt) - (b + 1);
for (int i = 1; i <= n; i++) {
a[i].x = lower_bound(b + 1, b + 1 + cnt, a[i].x) - b;
a[i].y = lower_bound(b + 1, b + 1 + cnt, a[i].y) - b;
}
sort(a + 1, a + 1 + n, cmp);
int now = 1;
long long ans = 0;
for (int i = 1; i <= cnt; i++) {
while (i == a[now].x && now <= n) {
dp[i] = (b[a[now].x] - b[a[now].y] + mod) % mod;
dp[i] = (dp[i] + sum[a[now].x - 1] - sum[a[now].y - 1] + mod) % mod;
if (a[now].tag == 1) ans = (ans + dp[i]) % mod;
now++;
}
sum[i] = (sum[i - 1] + dp[i]) % mod;
}
ans += b[a[n].x] + 1;
ans %= mod;
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
;
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
int f[2010][2010][2];
int n, m;
int sr[2010][2010], sc[2010][2010];
int gr[2010], gc[2010];
int br[2010][2010], bc[2010][2010];
char s[2010][2010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
if (n == 1 && m == 1) return 0 * puts("1");
for (int i = 1; i <= n; i++) gr[i] = 1;
for (int j = 1; j <= m; j++) gc[j] = 1;
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--) {
br[i][j] = br[i][j + 1] + (s[i][j] == 'R');
bc[i][j] = bc[i + 1][j] + (s[i][j] == 'R');
}
f[1][1][0] = f[1][1][1] = sr[1][1] = sc[1][1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i == 1 && j == 1) continue;
while (gr[i] < j && br[i][gr[i] + 1] > m - j) gr[i]++;
f[i][j][0] = (sr[i][j - 1] - sr[i][gr[i] - 1] + 1000000007) % 1000000007;
while (gc[j] < i && bc[gc[j] + 1][j] > n - i) gc[j]++;
f[i][j][1] = (sc[i - 1][j] - sc[gc[j] - 1][j] + 1000000007) % 1000000007;
sr[i][j] = (sr[i][j - 1] + f[i][j][1]) % 1000000007;
sc[i][j] = (sc[i - 1][j] + f[i][j][0]) % 1000000007;
}
printf("%d\n", (f[n][m][0] + f[n][m][1]) % 1000000007);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int n, siz[1 << N], f[1 << N];
long long a[N], s[1 << N];
bool can[1 << N];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (!a[i]) --i, --n;
}
for (int i = 1; i < (1 << n); i++) {
siz[i] = siz[i >> 1] + (i & 1);
for (int j = 0; j < n; j++)
if (i >> j & 1) s[i] += a[j];
if ((s[i] + siz[i]) & 1) {
long long lo = s[i] - siz[i] + 1, hi = s[i] + siz[i] - 1;
for (int j = i; ((--j) &= i) && !can[i];)
if (lo <= 2 * s[j] && 2 * s[j] <= hi) can[i] = 1;
}
}
for (int i = 1; i < (1 << n); i++)
if (can[i] && !f[i]) {
f[i] = 1;
int s = (1 << n) - 1 - i;
for (int j = s; j; j = (j - 1) & s) f[i | j] = max(f[i | j], f[j] + 1);
}
cout << n - f[(1 << n) - 1];
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, x;
cin >> n >> m;
bool b[n + 1];
memset(b, true, sizeof b);
map<int, int> mymap;
while (m--) {
cin >> x;
for (int i = x; i <= n; i++) {
if (b[i] == true) {
b[i] = false;
mymap.insert({i, x});
}
}
}
for (auto it : mymap) cout << it.second << " ";
}
| 0 |
#include <bits/stdc++.h>
const long base = 151;
const long long MM = 1ll * 1000000007 * 1000000007;
using namespace std;
int BIT(int i, long long x) { return (x & (1 << i)); }
long long ONBIT(int i, long long x) { return (x | (1 << i)); }
long long OFFBIT(int i, long long x) { return (x & ~(1 << i)); }
long long FLIPBIT(int i, long long x) { return (x ^ (1 << i)); }
long long NUMBIT(long long x) { return __builtin_popcount(x); }
template <class T>
T GCD(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T LCM(T a, T b) {
return a / GCD(a, b) * b;
}
void read() {
int x, y, u, v;
long long ans = 1;
cin >> x >> y >> u >> v;
int s1 = u - x;
int s2 = v - y;
long long tmp = min(s1, s2) - 1;
ans += (tmp + 1) * (abs(s2 - s1) + 1);
ans += (tmp + 1) * tmp;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long te;
cin >> te;
while (te--) read();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void rc(char &a) {
a = 0;
register int x = getchar_unlocked();
while (x < 'a' || x > 'z') {
if (x == '\n') {
a = '0';
return;
}
x = getchar_unlocked();
}
a = x;
}
const int maxn = 100100;
int key;
int main() {
string ans = "";
char cur;
while (true) {
rc(cur);
if (cur == '0') break;
if (cur == 'a') {
if (key == 0)
ans += "a";
else if (key == 1) {
ans += "a";
key = 2;
} else {
ans += "a";
}
} else {
if (key == 1)
ans += (cur - 1);
else if (key == 0) {
ans += (cur - 1);
key = 1;
} else {
ans += cur;
}
}
}
if (key == 0) {
ans = ans.substr(0, ans.size() - 1) + "z";
printf("%s\n", ans.c_str());
return 0;
}
printf("%s\n", ans.c_str());
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long N = 100000;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
bool hoga = 1;
for (long long i = n - 2; i >= 0; i--) {
if (a[i] == a[i + 1]) {
i--;
} else {
a[i + 1]--;
if (a[i] == a[i + 1]) i--;
}
}
map<long long, long long> freq;
for (long long i = 0; i < a.size(); i++) {
freq[a[i]]++;
}
vector<long long> temp;
for (auto x : freq) {
while (freq[x.first] >= 2) {
temp.push_back(x.first);
freq[x.first] -= 2;
}
}
sort(temp.begin(), temp.end());
long long res = 0;
while (temp.size() >= 2) {
res += (temp[temp.size() - 1] * temp[temp.size() - 2]);
temp.pop_back();
temp.pop_back();
}
cout << res << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool vis[27];
int main() {
char str[1010];
int n;
scanf("%d %s", &n, str);
for (int i = 0; i < n; i++) {
if (vis[str[i] - 'a'] == 0) vis[str[i] - 'a'] = 1;
}
int ans = 0, f = 0;
for (int i = 0; i < 26; i++)
if (vis[i]) ans++;
if (ans >= 2) {
printf("YES\n");
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n && f < 2; i++) {
if (!vis[str[i] - 'a']) {
vis[str[i] - 'a'] = 1;
printf("%c", str[i]);
f++;
}
}
} else
printf("NO\n");
return 0;
}
| 1 |
#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;
}
int n, l[100 + 5], r[100 + 5], From = 0, To = 0;
queue<int> q1;
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
l[i] = read();
r[i] = read();
if (!l[i])
if (!From)
From = i;
else
q1.push(i);
}
for (int i = From;;) {
if (!r[i]) {
if (!q1.size()) break;
r[i] = q1.front(), q1.pop(), l[r[i]] = i;
}
i = r[i];
}
for (int i = 1; i <= n; ++i) printf("%d %d\n", l[i], r[i]);
return 0;
}
| 3 |
#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;
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) 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 = 1000000007) {
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; }
vector<int> mp[100035];
long long X[100035];
int d[100035];
void dfs(int x, int pa) {
d[x] = d[pa] + 1;
for (int c : mp[x])
if (c != pa) {
dfs(c, x);
}
}
int Ans;
inline void dfs1(int x, int pa, vector<pair<int, long long>> &vp) {
assert(vp.size() < 50);
int cd = d[x];
for (auto &p : vp) {
addmod(Ans, p.second * (cd - d[p.first]) % 1000000007);
cd = d[p.first];
}
for (int c : mp[x])
if (c != pa) {
vector<pair<int, long long>> tmp;
tmp.push_back({x, X[c]});
for (auto &p : vp) {
long long z = tmp.back().second;
long long y = gcd1(z, p.second);
if (y == z) {
tmp[tmp.size() - 1].first = p.first;
} else {
tmp.push_back({p.first, y});
}
}
dfs1(c, x, tmp);
}
}
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%lld", X + i);
for (int i = 0, u, v; i < n - 1; i++) {
scanf("%d%d", &u, &v);
mp[u].push_back(v);
mp[v].push_back(u);
};
dfs(1, 0);
vector<pair<int, long long>> tmp;
tmp.push_back({0, X[1]});
dfs1(1, 0, tmp);
printf("%d\n", Ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1010, inf = 0x3f3f3f3f;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, -1, 1};
bool vis[Maxn][Maxn], a[Maxn][Maxn];
bool r[Maxn], c[Maxn], flag[Maxn][2];
int n, m, ans;
inline bool check(int x, int y) {
return (x < 1 || y < 1 || x > n || y > m || vis[x][y] || !a[x][y]);
}
void dfs(int x, int y) {
vis[x][y] = 1;
for (int i = 0; i < 4; ++i) {
int u = x + dx[i], v = y + dy[i];
if (check(u, v)) continue;
dfs(u, v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
char s[Maxn];
scanf("%s", s + 1);
for (int j = 1; j <= m; ++j)
if (s[j] == '#') {
a[i][j] = 1;
r[i] = c[j] = 1;
}
}
for (int i = 1; i <= n; ++i) {
int pos = 0;
for (int j = 1; j <= m; ++j)
if (a[i][j]) {
pos = j;
break;
}
if (!pos) continue;
for (int j = pos + 2; j <= m; ++j)
if (a[i][j] && !a[i][j - 1]) {
puts("-1");
return 0;
}
}
for (int j = 1; j <= m; ++j) {
int pos = 0;
for (int i = 1; i <= n; ++i)
if (a[i][j]) {
pos = i;
break;
}
if (!pos) continue;
for (int i = pos + 2; i <= n; ++i)
if (a[i][j] && !a[i - 1][j]) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] || (!r[i] && !c[j])) flag[i][0] = flag[j][1] = 1;
for (int i = 1; i <= n; ++i)
if (!flag[i][0]) {
puts("-1");
return 0;
}
for (int i = 1; i <= m; ++i)
if (!flag[i][1]) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (vis[i][j] || !a[i][j]) continue;
dfs(i, j), ++ans;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <algorithm>
#include <numeric>
#include <utility>
#include <random>
#include <chrono>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using PII = pair<int, int>;
using PIL = pair<int, LL>;
using PLL = pair<LL, LL>;
// const int mod = 1e9 + 7;
// const int mod = 998244353;
inline void quickread() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
unordered_set<int> edges[3010];
unordered_set<int> euler[3010];
vector<int> path;
int deg[3010];
int n, m, x, y;
void tour(int u) {
if (!euler[u].empty()) {
int v = *euler[u].begin();
euler[u].erase(v);
euler[v].erase(u);
tour(v);
}
path.push_back(u);
}
inline bool check() {
for (int i = 1; i <= n; ++i) {
if (!euler[i].empty()) {
return false;
}
}
return true;
}
inline void duplicate() {
for (int i = 1; i <= n; ++i) {
euler[i] = edges[i];
}
}
inline void feed(int u, const vector<int>& candidates) {
if (candidates.size()) {
path.push_back(-1);
for (int v: candidates) {
path.push_back(v);
path.push_back(u);
}
}
}
inline void work() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
edges[x].insert(y);
edges[y].insert(x);
++deg[x];
++deg[y];
}
bool found = false;
for (int u = 1; u <= n && !found; ++u) {
// cout << "u = " << u << endl;
vector<int> candidates;
for (int v: edges[u]) {
if (deg[v] & 1) {
candidates.push_back(v);
}
}
duplicate();
for (int v: candidates) {
euler[u].erase(v);
euler[v].erase(u);
}
path.clear();
tour(u);
if (check()) {
feed(u, candidates);
found = true;
break;
}
for (int i = 0; i < candidates.size(); ++i) {
int vgood = candidates[i];
// cout << "vgood = " << vgood << endl;
duplicate();
for (int v: candidates) {
if (v != vgood) {
euler[u].erase(v);
euler[v].erase(u);
}
}
path.clear();
tour(u);
if (check()) {
candidates.erase(candidates.begin() + i);
feed(u, candidates);
found = true;
break;
}
}
}
if (!found) {
cout << 0 << "\n";
}
else {
cout << path.size() << "\n";
for (int o: path) {
cout << o << " ";
}
cout << "\n";
}
}
int main() {
// freopen("input.txt", "r", stdin);
quickread();
work();
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
long long l, r, inv, ver;
} TVertex;
vector<TVertex> tree;
vector<long long> m1, m2;
long long MAXN;
long long lower(long long x) {
long long l = -1;
long long r = m2.size();
for (; r - l > 1;) {
long long m = (r + l) / 2;
if (m2[m] < x) {
l = m;
} else {
r = m;
}
}
return l;
}
long long upper(long long x) {
long long l = -1;
long long r = m2.size();
for (; r - l > 1;) {
long long m = (l + r) / 2;
if (m2[m] > x) {
r = m;
} else {
l = m;
}
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> a(1 << n);
tree.resize(1 << (n + 1));
for (long long i = 0; i < (1 << n); ++i) {
cin >> a[i];
}
vector<pair<long long, long long> > lvl(n + 1);
TVertex zero;
zero.inv = 0;
zero.ver = 0;
MAXN = (1 << n);
for (long long i = 0; i < MAXN; ++i) {
zero.l = i;
zero.r = i;
tree[MAXN + i] = zero;
}
for (long long i = MAXN - 1; i > 0; --i) {
tree[i].l = tree[i * 2].l;
tree[i].r = tree[i * 2 + 1].r;
tree[i].inv = tree[i * 2].inv + tree[i * 2 + 1].inv;
tree[i].ver = tree[i * 2].ver + tree[i * 2 + 1].ver;
long long l1 = tree[i].l, r1 = tree[i * 2].r;
long long l2 = tree[i * 2 + 1].l, r2 = tree[i].r;
m1.clear();
m2.clear();
for (long long j = l1; j <= r1; ++j) {
m1.push_back(a[j]);
}
for (long long j = l2; j <= r2; ++j) {
m2.push_back(a[j]);
}
sort(m2.begin(), m2.end());
for (long long j = 0; j < (long long)m1.size(); ++j) {
long long ind1 = upper(m1[j]);
long long ind2 = lower(m1[j]);
tree[i].inv += ind2 + 1;
tree[i].ver += (long long)m2.size() - ind1;
}
}
long long pwr1 = 1;
long long pwr2 = 2;
for (long long i = 0; i <= n; ++i) {
long long cinv = 0, cver = 0;
for (long long j = pwr1; j < pwr2; ++j) {
cinv += tree[j].inv;
cver += tree[j].ver;
}
pwr1 = pwr2;
pwr2 *= 2;
lvl[n - i].first = cinv;
lvl[n - i].second = cver;
}
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
long long q;
cin >> q;
if (q == 0) {
cout << lvl[n].first << endl;
continue;
}
long long delt = lvl[q].second - lvl[q].first;
for (long long i = q; i > 0; --i) {
swap(lvl[i].first, lvl[i].second);
}
for (long long i = q + 1; i <= n; ++i) {
lvl[i].first += delt;
lvl[i].second -= delt;
}
cout << lvl[n].first << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10100;
int N, X;
int flist[MAXN];
int nfac;
long long gcf(long long left, long long right) {
if (right == 0) return left;
return gcf(right, left % right);
}
long long mpow(long long b, long long p, long long m) {
long long res = 1;
long long p2 = b;
for (int i = 0; i < 23; i++) {
if (p & (1 << i)) res = (res * p2) % m;
p2 = (p2 * p2) % m;
}
return res;
}
bool works(int base) {
for (int i = 0; i < nfac; i++)
if (mpow(base, flist[i], N + 1) == 1) return false;
return mpow(base, N, N + 1) == 1;
}
bool prime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
int main() {
cin >> N >> X;
if (N == 1) {
if (X == 2) {
cout << "-1\n";
return 0;
}
cout << X - 1 << "\n";
return 0;
}
nfac = 0;
for (int i = 1; i < N; i++) {
if (N % i == 0) {
flist[nfac] = i;
nfac++;
}
}
if (!prime(N + 1)) {
cout << "-1\n";
return 0;
}
for (int i = X - 1; i >= 2; i--) {
if (works(i)) {
cout << i << "\n";
return 0;
}
}
cout << "-1\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
long long h;
cin >> h;
;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long res = 1;
for (long long i = 1; i < n; i++) {
vector<long long> v;
for (long long j = 0; j <= i; j++) {
v.push_back(a[j]);
}
sort(v.begin(), v.end(), greater<long long>());
long long cur = 0;
long long ans = 0;
for (long long j = 0; j < v.size() - 1; j++) {
cur += v[j];
if (cur <= h) {
ans += 2;
}
j++;
}
if (v.size() % 2 != 0) {
if (cur + v[v.size() - 1] <= h) {
ans += 1;
}
}
res = max(res, ans);
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double PI = atan(1.0) * 4;
const int inf = 0x3f3f3f3f;
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
int sgn(T first) {
return (first > eps) - (first < -eps);
}
const int maxn = 100100;
const int mod = 1000000007;
char str[maxn], str2[maxn];
string pp[maxn];
int n;
int weishu[20], num[20], zhuanyi[maxn];
void init() {
scanf("%s", str);
scanf("%d", &n);
for (int i = (1); i <= (int)(n); i++) {
cin >> pp[i];
zhuanyi[i] = pp[i][0] - '0';
}
for (int i = (0); i <= (int)(9); i++) {
weishu[i] = 10;
num[i] = i;
}
}
void solve() {
for (int i = (n); i >= (int)(1); i--) {
long long t1 = 1, t2 = 0;
int len = pp[i].size();
for (int j = (3); j <= (int)(len - 1); j++) {
int temp = pp[i][j] - '0';
t1 = (t1 * weishu[temp]) % mod;
t2 = (t2 * weishu[temp] % mod + num[temp]) % mod;
}
weishu[zhuanyi[i]] = t1;
num[zhuanyi[i]] = t2;
}
long long ans = 0;
int len = strlen(str);
for (int i = (0); i <= (int)(len - 1); i++) {
int temp = str[i] - '0';
ans = (ans * weishu[temp] % mod + num[temp]) % mod;
}
printf("%I64d\n", ans);
}
int main() {
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
cin >> n >> k;
long long b = -(2 * n + 3);
long long c = n * n + n - 2 * k;
long long t = sqrt(b * b - 4 * c);
long long x1 = (-b + t) / 2;
long long x2 = (-b - t) / 2;
if (x2 >= 0)
cout << x2;
else
cout << x1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class FL, class CO>
struct MCMF {
static const int N = 10000;
static const int M = 20000;
int minf = 1e9;
int head[N], pre[N], to[M], ne[M];
int es, s, t, n;
bool vis[N];
FL cap[M], mflow;
CO cost[M], dis[N], mcost;
void init(int _n) {
fill(head, head + 1 + (n = _n), -1);
es = 0;
}
void add(int u, int v, FL c, CO w) {
to[es] = v;
cap[es] = c;
cost[es] = w;
ne[es] = head[u];
head[u] = es++;
to[es] = u;
cap[es] = 0;
cost[es] = -w;
ne[es] = head[v];
head[v] = es++;
}
bool spfa() {
fill(dis, dis + 1 + n, minf);
fill(vis, vis + 1 + n, false);
queue<int> Q;
Q.push(s);
vis[s] = true;
dis[s] = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
vis[u] = false;
;
for (int i = head[u]; i != -1; i = ne[i]) {
int v = to[i];
if (cap[i] > 0 && dis[u] + cost[i] < dis[v]) {
dis[v] = dis[u] + cost[i];
pre[v] = i;
if (!vis[v]) {
vis[v] = true;
Q.push(v);
}
}
}
}
return dis[t] != minf;
}
pair<FL, CO> solve(int _s, int _t) {
s = _s;
t = _t;
mflow = mcost = 0;
while (spfa()) {
FL tmp = minf;
int v;
for (int i = t; i != s; i = to[v ^ 1]) {
tmp = min(tmp, cap[v = pre[i]]);
}
for (int i = t; i != s; i = to[v ^ 1]) {
v = pre[i];
cap[v] -= tmp;
cap[v ^ 1] += tmp;
}
mcost += tmp * dis[t];
mflow += tmp;
}
return make_pair(mflow, mcost);
}
};
int main() {
pair<int, int> qu[100];
int n, q;
scanf("%d%d", &n, &q);
MCMF<int, long long> x;
int s, t;
s = 2 * n;
t = s + 1;
x.init(t);
for (int i = 0; i < n; i++) {
qu[i].first = 0;
qu[i].second = n - 1;
for (int j = 0; j < n; j++) {
x.add(s, i, 1, j * 2 + 1);
}
}
for (int i = 0; i < n; i++) x.add(i + n, t, 1, 0);
int l, r, v, ty;
while (q--) {
scanf("%d%d%d%d", &ty, &l, &r, &v);
if (ty == 1) {
for (int i = l - 1; i < r; i++) {
qu[i].first = max(qu[i].first, v - 1);
}
} else {
for (int i = l - 1; i < r; i++) {
qu[i].second = min(qu[i].second, v - 1);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = qu[i].first; j <= qu[i].second; j++) {
x.add(j, i + n, 1, 0);
}
}
pair<int, long long> tmp = x.solve(s, t);
if (tmp.first != n)
printf("-1\n");
else
printf("%I64d\n", tmp.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, ans, max, maxy;
cin >> n;
int b[n], d[n];
for (i = 0; i < n; i++) {
cin >> b[i] >> d[i];
}
sort(b, b + n);
sort(d, d + n);
ans = max = maxy = 0;
for (i = 0, j = 0; i < n;) {
if (d[j] <= b[i]) {
max--;
j++;
} else {
max++;
if (max > ans) {
ans = max;
maxy = b[i];
}
i++;
}
}
printf("%d %d\n", maxy, ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int DE = 0;
const int Maxn = 200005;
int n, K, m, T;
pair<int, int> dp[2][Maxn];
int a[Maxn], b[Maxn];
int main() {
int i, j;
while (~scanf("%d%d%d%d", &K, &n, &m, &T))
while (K--) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) b[i] = a[i];
sort(b + 1, b + n + 1);
m = unique(b + 1, b + n + 1) - b - 1;
for (i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
for (i = 1; i <= m; i++) dp[0][i] = make_pair(T + 1, 1);
dp[0][0] = make_pair(0, 0);
for (i = 1; i <= m; i++) {
int t = i & 1;
for (j = 1; j <= m; j++)
dp[t ^ 1][j] = min(dp[t ^ 1][j], dp[t ^ 1][j - 1]);
for (j = 0; j <= m; j++) dp[t][j] = make_pair(T + 1, 1);
for (j = 1; j <= n; j++) {
pair<int, int> th = dp[t ^ 1][a[j] - 1];
if (th.second >= j) th.first++;
th.second = j;
dp[t][a[j]] = min(dp[t][a[j]], th);
}
if (DE) {
printf("i=%d\t", i);
for (j = 1; j <= m; j++)
printf("(%d,%d) ", dp[t][j].first, dp[t][j].second);
printf("\n");
}
for (j = 1; j <= m; j++)
if (dp[t][j].first < T) break;
if (j > m) break;
}
printf("%d\n", i - 1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 10, mod = 1e9 + 7, inf = 1e9 + 10;
struct Flow {
int cap[maxn];
int mark[maxn], colo = 0, h[maxn], pp[maxn], to[maxn], tp[maxn], nxt[maxn],
qu[maxn], C = 0;
Flow() { memset(tp, -1, sizeof tp); }
void add_edge(int a, int b, int c) {
nxt[C] = tp[a], cap[C] = c, to[C] = b, tp[a] = C;
C++;
nxt[C] = tp[b], cap[C] = 0, to[C] = a, tp[b] = C;
C++;
}
bool bfs(int src, int snk) {
memset(h, -1, sizeof h);
int L = 0, R = 1;
qu[0] = src;
h[src] = 0;
while (L < R) {
int u = qu[L++];
if (u == snk) return 1;
for (int id = tp[u]; id != -1; id = nxt[id]) {
if (h[to[id]] == -1 && cap[id] != 0)
h[to[id]] = 1 + h[u], qu[R++] = to[id];
}
}
return 0;
}
int dfs(int u, int snk, int f) {
if (u == snk) return f;
int ans = 0;
while (pp[u] != -1) {
int id = pp[u];
if (cap[id] != 0 && h[u] + 1 == h[to[id]]) {
int num = dfs(to[id], snk, min(f - ans, cap[id]));
ans += num;
cap[id] -= num, cap[id ^ 1] += num;
if (ans == f) break;
}
pp[u] = nxt[pp[u]];
}
return ans;
}
int flow(int src, int snk) {
int ans = 0;
while (bfs(src, snk)) {
memcpy(pp, tp, sizeof tp);
ans += dfs(src, snk, inf);
}
return ans;
}
int FLW[maxn], pr[maxn];
int bfs2(int src, int snk) {
int L = 0, R = 1;
mark[src] = colo;
qu[0] = src;
FLW[src] = inf;
while (L < R && mark[snk] != colo) {
int u = qu[L++];
for (int id = tp[u]; id != -1; id = nxt[id]) {
int y = to[id];
if (mark[y] != colo && cap[id] != 0) {
mark[y] = colo, FLW[y] = min(FLW[u], cap[id]), pr[y] = id,
qu[R++] = y;
if (y == snk) break;
}
}
}
if (mark[snk] != colo) return 0;
int ans = FLW[snk];
while (snk != src) {
int id = pr[snk];
cap[id] -= ans, cap[id ^ 1] += ans;
snk = to[id ^ 1];
}
return ans;
}
int flow2(int src, int snk) {
int ans = 0;
while (true) {
colo++;
int num = bfs2(src, snk);
if (num == 0) break;
ans += num;
}
return ans;
}
};
const int maxk = 10, MAX = 25;
int ANS[(1 << maxk) + 10], n, k;
Flow flw;
int CAP[maxk][maxn];
void go(int pos, int msk, int first) {
if (pos == k) {
ANS[msk] = first;
return;
}
memcpy(CAP[pos], flw.cap, sizeof CAP[pos]);
go(pos + 1, msk, first);
flw.cap[2 * pos] = MAX;
go(pos + 1, msk ^ (1 << pos), first + flw.flow2(0, n - 1));
memcpy(flw.cap, CAP[pos], sizeof CAP[pos]);
}
int arr[maxk], sm[1 << maxk];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
srand(time(0));
vector<pair<pair<int, int>, int> > vvv;
int m, q;
cin >> n >> m >> k >> q;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
vvv.push_back({{a, b}, c});
}
random_shuffle(vvv.begin() + k, vvv.end());
for (auto x : vvv) {
flw.add_edge(x.first.first, x.first.second, x.second);
}
go(0, 0, flw.flow(0, n - 1));
while (q--) {
for (int i = 0; i < k; i++) {
cin >> arr[i];
}
int ans = inf;
for (int msk = 0; msk < (1 << k); msk++) {
if (msk == 0)
sm[msk] = 0;
else
sm[msk] = arr[__builtin_ctz(msk)] + sm[msk - (msk & -msk)];
ans = min(ans, sm[msk] + ANS[((1 << k) - 1) ^ msk]);
}
cout << ans << "\n";
}
return 0;
}
| 12 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.