solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, a[122][5], qqt[5];
int p[] = {500, 1000, 1500, 2000, 2500, 3000};
int check(int x) {
vector<int> qt = {qqt[0], qqt[1], qqt[2], qqt[3], qqt[4]};
for (int i = 0; i < 5; ++i) {
if (a[0][i] == -1 || (a[0][i] != -1 && a[1][i] == -1) ||
(a[0][i] != -1 && a[1][i] != -1 && a[0][i] <= a[1][i]))
continue;
qt[i] += x;
}
long long all = n + x;
vector<int> val;
for (int i = 0; i < 5; ++i) {
if (qt[i] * 1ll * 2 > all)
val.push_back(500);
else if (qt[i] * 1ll * 4 > all)
val.push_back(1000);
else if (qt[i] * 1ll * 8 > all)
val.push_back(1500);
else if (qt[i] * 1ll * 16 > all)
val.push_back(2000);
else if (qt[i] * 1ll * 32 > all)
val.push_back(2500);
else
val.push_back(3000);
}
int p1 = 0, p2 = 0;
for (int i = 0; i < 5; ++i) {
if (a[0][i] != -1) p1 += val[i] - val[i] * a[0][i] / 250;
if (a[1][i] != -1) p2 += val[i] - val[i] * a[1][i] / 250;
}
return p2 - p1;
}
int solve() {
for (int i = 0; i < 100000; ++i) {
int c = check(i);
if (c < 0) return i;
}
return 1000000008;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < 5; ++j) {
scanf("%d", &a[i][j]);
if (a[i][j] != -1) ++qqt[j];
}
int ans = solve();
if (ans > 10000000)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, count = 0, x;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i++) {
if (count * (a[i] + 1) <= i) count++;
}
cout << count << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> ma;
int main() {
int n;
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
if (ma[s] > 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
ma[s]++;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> seen;
int main() {
int n, res = 0;
char ch;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ch;
if (seen[ch] != 0) res++;
seen[ch]++;
}
if (res > 25)
cout << -1;
else {
int ans = n - res;
if (ans > (26 - res))
cout << -1;
else
cout << res;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000001000;
const long long INFLL = INF * 1LL * INF;
const int mod = 1000 * 1000 * 1000 + 7;
const int mod9 = 1000 * 1000 * 1000 + 9;
const int modr = 99990001;
const long double PI = 3.1415926535897932385;
template <class T>
void zero(T val, T& first) {
first = val;
}
template <class T, class... Targs>
void zero(T val, T& first, Targs&... Fargs) {
first = val;
zero(val, Fargs...);
}
template <class T, class T2>
std::istream& operator>>(std::istream& is, pair<T, T2>& p) {
return is >> p.first >> p.second;
}
template <class T>
std::istream& readN(T& first, int n, int st = 0) {
for (int i = st, iend = (st + n - 1); i <= iend; i++) cin >> first[i];
return cin;
}
template <class T>
std::istream& readS(set<T>& first, int n) {
T second = *first.rbegin();
for (int i = 0, iend = (n - 1); i <= iend; i++) {
cin >> second;
first.insert(second);
}
return cin;
}
template <class T>
std::istream& read(T& first) {
return cin >> first;
}
template <class T, class... Targs>
std::istream& read(T& first, Targs&... Fargs) {
return read(first), read(Fargs...);
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, pair<T, T2> p) {
return os << p.first << " " << p.second;
}
template <class T>
std::ostream& operator<<(std::ostream& os, vector<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, set<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, multiset<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, map<T, T2> v) {
bool f = true;
for (pair<T, T2> second : v) {
if (!f) os << ' ';
os << second.first << "=>" << second.second;
f = false;
}
return os;
}
template <class T>
std::ostream& outV(T first, char del = ' ') {
bool f = true;
for (auto second : first) {
if (!f) cout << del;
cout << second;
f = false;
}
return cout;
}
template <class T>
std::ostream& outN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n == -1 ? (int)first.size() - 1 : st + n - 1);
i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outAN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n - 1); i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outA2(T first, int n, int m) {
for (int i = 0, iend = (n - 1); i <= iend; i++) {
for (int j = 0, jend = (m - 1); j <= jend; j++)
cout << first[i][j] << (j == m - 1 ? '\n' : ' ');
}
return cout;
}
template <class T>
std::ostream& out(T first) {
return cout << first;
}
template <class T, class... Targs>
std::ostream& out(T first, Targs... Fargs) {
return out(first) << " ", out(Fargs...);
}
template <typename T>
void srt(T& a, int st, int fn, bool isArr) {
sort(a + st, a + fn + 1);
}
template <class T>
void srt(T& a, int st = 0, int fn = 0) {
sort(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
template <typename T>
T rev_num(T a) {
T r = 0;
for (; a; a /= 10) r = r * 10 + a % 10;
return r;
}
template <typename T>
void rev(T& a, int st, int fn, bool isArr) {
reverse(a + st, a + fn + 1);
}
template <class T>
void rev(T& a, int st = 0, int fn = 0) {
reverse(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
long long sqr(long long a) { return a * a; };
long long sqr(int a) { return a * 1LL * a; };
long double sqr(long double a) { return a * a; };
long long sqDist(pair<long long, long long> first,
pair<long long, long long> second) {
return sqr(first.first - second.first) + sqr(first.second - second.second);
}
long double dist(pair<long long, long long> first,
pair<long long, long long> second) {
return sqrtl(sqDist(first, second));
}
long long phi(int n) {
int res = n;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
res -= res / i;
}
if (n > 1) res -= res / n;
return res;
}
long long bpm(long long a, long long n = -2, long long m = mod) {
n = n < 0 ? n + m : n;
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
vector<int> ero_p, ero_l;
void ero(int n) {
ero_l.resize(n + 1);
ero_l[0] = -1;
for (int i = 2, iend = (n); i <= iend; i++)
if (!ero_l[i]) {
ero_p.push_back(i);
ero_l[i] = i;
for (long long j = i * 1LL * i; j <= n; j += i) {
ero_l[j] = i;
}
}
}
long long gcd_cb(long long a, long long b, long long& first,
long long& second) {
if (!b) {
first = 1;
second = 0;
return a;
}
long long x1, y1, g;
g = gcd_cb(b, a % b, x1, y1);
first = y1;
second = x1 - a / b * y1;
return g;
}
vector<long long> fact;
void fact_prec(int n = 20) {
fact.resize(n + 1);
fact[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
fact[i] = fact[i - 1] * i;
}
}
vector<long double> factd;
void fact_precd(int n = 146) {
factd.resize(n + 1);
factd[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
factd[i] = factd[i - 1] * i;
}
}
string str(long long a) {
string r = "";
for (; a; a /= 10) r += a % 10 + '0';
rev(r);
return r;
}
template <class T>
int bitc(T first) {
int r = 0;
for (T d = first; d > 0; d >>= 1) {
r += d & 1;
}
return r;
}
int sum_num(long long n) {
int d = 0;
for (; n; n /= 10) d += n % 10;
return d;
}
const int N = 100005;
int main() {
int n, a, b;
read(n, a, b);
string s;
read(s);
s += '*';
int sum = 0;
int len = 0;
for (auto c : s) {
if (c == '.') {
len++;
} else {
if (a > b) {
swap(a, b);
}
int mn = min(len / 2, a);
int mx = min(len - len / 2, b);
sum += mn + mx;
a -= mn;
b -= mx;
len = 0;
}
}
out(sum) << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long pwmd(long long a, long long n) {
if (!n) return 1;
long long pt = pwmd(a, n / 2);
pt *= pt, pt %= 998244353;
if (n & 1) pt *= a, pt %= 998244353;
return pt;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
if (i == n) {
cout << 10 << endl;
} else {
long long ans;
ans = 10 * 9 * pwmd(10, n - i - 1) * 2;
ans += 10 * 9 * 9 * (n - i - 1) * pwmd(10, n - i - 2);
ans %= 998244353;
cout << ans << " ";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class first>
inline bool getbit(T a, first i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class first>
inline T setbit(T a, first i) {
T t = 1;
return (a | (t << i));
}
template <class T, class first>
inline T resetbit(T a, first i) {
T t = 1;
return (a & (~(t << i)));
}
template <class T, class first>
inline T togglebit(T a, first i) {
T t = 1;
return (a ^ (t << i));
}
template <typename T>
T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
T BIGMOD(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T Bigmod(T base, T power, T mod) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % mod;
base = (base * base) % mod;
power >>= 1;
}
return ret;
}
template <typename T>
T ModInverse(T number, T mod) {
return Bigmod(number, mod - 2, mod);
}
template <typename T>
T GCD(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T EUCLIDE(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
double DEG(double x) { return (180.0 * x) / ((2.0 * acos(0.0))); }
double RAD(double x) { return (x * (double)(2.0 * acos(0.0))) / (180.0); }
template <typename T>
T DIS(T x1, T y1, T x2, T y2) {
return sqrt((double)((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
long long isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
void P_ARR(int *ar, int a, int b) {
if (a > b) swap(a, b);
if (a <= b) cout << ar[a];
for (int i = a + 1; i <= b; i++) cout << " " << ar[i];
cout << endl;
}
int ase[1007 + 7];
int ar[1007 + 7];
int main() {
int m, t, r;
scanf("%d%d%d", &m, &t, &r);
int v = 303;
for (int i = 1; i <= m; i++) {
int(x);
scanf("%d", &x);
ase[x + v] = 1;
}
for (int i = 0; i <= 1007; i++) {
if (ase[i]) {
int cnt = 0;
for (int j = 0; j <= t - 1; j++) {
if (i - j >= 0) cnt += ar[i - j];
}
for (int j = 0; j <= r - cnt - 1; j++) {
if (i - j >= 0) ar[i - j] = 1;
}
}
}
int flag = 1;
for (int i = 0; i <= 1007 - 1; i++) {
if (ase[i]) {
int cnt = 0;
for (int j = 0; j <= t - 1; j++) {
if (i - j >= 0) cnt += ar[i - j];
}
if (cnt < r) {
flag = 0;
break;
}
}
}
int res = 0;
for (int i = 0; i <= 1007; i++) res += ar[i];
if (flag == 0)
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long INF64 = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL;
long long n;
int t, k;
vector<long long> fib;
int a[90];
void Load() {
fib.push_back(1);
fib.push_back(2);
while (fib.back() <= 1e18)
fib.push_back(fib.back() + fib[(int)fib.size() - 2]);
scanf("%d", &t);
}
int dp[90][3][3];
int rec(int pos, int b1, int b0) {
if (pos == -1) return 1;
if (dp[pos][b1][b0] != -1) return dp[pos][b1][b0];
dp[pos][b1][b0] = 0;
if (a[pos] + b1 <= 1) dp[pos][b1][b0] += rec(pos - 1, b0, 0);
if (pos >= 2 && a[pos] + b1 > 0) dp[pos][b1][b0] += rec(pos - 1, b0 + 1, 1);
return dp[pos][b1][b0];
}
void Solve() {
for (int T = 0; T < t; T++) {
scanf("%I64d", &n);
if (n == 1) {
printf("1\n");
continue;
}
if (n == 2) {
printf("1\n");
continue;
}
memset(dp, 0xFF, sizeof(dp));
for (int i = 0; i < (int)fib.size(); i++) {
a[i] = 0;
if (fib[i] > n) {
k = i - 1;
int j = i - 1;
while (j >= 0) {
if (fib[j] <= n) {
a[j] = 1;
n -= fib[j];
}
j--;
}
break;
}
}
printf("%d\n", rec(k, 0, 0));
}
}
int main() {
Load();
Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
double m;
double a[1010], b[1010];
double check(double mid) {
double fuel = mid;
for (int i = 1; i <= n; i++) {
double mass = m + fuel;
int cur = i;
int nxt = (i + 1) % (n + 1) == 0 ? 1 : (i + 1);
if (mass <= fuel * a[cur]) {
fuel = fuel - mass / a[cur];
} else {
return false;
}
mass = m + fuel;
if (mass <= fuel * b[nxt]) {
fuel = fuel - mass / b[nxt];
} else {
return false;
}
}
return true;
}
int main() {
cin >> n;
cin >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
double inf = 1e9;
double l = 0, r = 1e9 + 10;
for (int i = 0; i < 400; i++) {
double mid = (r + l) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
if (l > inf) {
cout << -1 << endl;
} else {
printf("%.7f\n", l);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const long long INF = 1e18;
template <typename T>
inline bool chkmax(T &aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T &aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
const int mn = 1e6 + 4;
const int MAXFACT = mn;
int fact[MAXFACT + 1], invfact[MAXFACT + 1];
int mod_pow(int a, int n) {
const int mod = MOD;
int ret = 1;
int p = a % mod;
while (n) {
if (n & 1) ret = (ret * (long long)p) % mod;
p = (p * (long long)p) % mod;
n >>= 1;
}
return ret;
}
inline int mod_inv(int a) { return mod_pow(a, MOD - 2); }
inline int add(int a, int b) {
int res = a + b;
if (res >= MOD) res -= MOD;
return res;
}
inline int mul(int a, int b) { return (a * (long long)b) % MOD; }
int fast_max(vector<int> a, int k) {
int n = a.size();
int ans = 0;
int offset = 0;
for (int i = 0; i < n; ++i)
if (ans < a[i]) {
ans = a[i];
offset = 0;
} else {
offset = offset + 1;
if (offset == k) return ans;
}
return ans;
}
bool isgood(vector<int> a, int k) {
int n = a.size();
int ans = 0;
int offset = 0;
for (int i = 0; i < n; ++i)
if (ans < a[i]) {
ans = a[i];
offset = 0;
} else {
offset = offset + 1;
if (offset == k) return false;
}
return true;
}
int bf(int n, int k) {
vector<int> v;
for (int x = 1; x <= n; x++) v.push_back(x);
int ans = 0;
do {
if (isgood(v, k)) ans++;
} while (next_permutation(v.begin(), v.end()));
return ans;
}
int g1[mn];
int g[mn];
int makeg(int lim, int k) {
for (int n = 0; n <= lim; n++) {
int gn;
if (n == 0)
gn = 1;
else {
int sum1 = (n - k - 1 >= 0) ? g1[n - k - 1] : 0;
int sum3 = 1 + (MOD - sum1);
gn = mul(fact[n], sum3);
}
g[n] = gn;
g1[n] =
add(n > 0 ? g1[n - 1] : 0, mul(gn, mod_inv(mul(n + k + 1, fact[n]))));
}
return g[lim];
}
void init() {
int got = 1;
for (int x = 0; x <= MAXFACT; x++) {
fact[x] = got;
got = mul(got, x + 1);
}
got = mod_pow(got, MOD - 2);
for (int x = MAXFACT; x >= 0; x--) {
got = mul(got, x + 1);
invfact[x] = got;
}
}
int binom(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return mul(fact[n], mul(invfact[k], invfact[n - k]));
}
int solve(int n, int k) {
makeg(n, k);
int final = 0;
for (int x = 0; x <= n - (k + 2); x++) {
int ans = mul(mul(binom(n - 1, x + k + 1), binom(x + k, x)), g[x]);
int ans2 = mul(ans, mul(fact[k], fact[n - (x + k + 1)]));
final += ans2;
if (final >= MOD) final -= MOD;
}
return final;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
init();
int n, k;
scanf("%d%d", &n, &k);
int ans = solve(n, k);
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, f, g, n, m, k, t, x, h, w, q;
long long mod = 1e9 + 7;
map<long long, long long> mp;
void solve() {
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int L = 0, R = n - 1;
int answer = 0;
while (arr[L] == arr[R]) {
L++;
}
answer = R - L;
L = 0;
R = n - 1;
while (arr[L] == arr[R]) {
R--;
}
answer = max(answer, R - L);
cout << answer << endl;
}
int main() {
ios_base::sync_with_stdio(false);
int cases = 1;
while (cases--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<string> > subset(vector<string> &s) {
vector<vector<string> > vi;
int n = s.size();
int num = 1 << n;
int a[n + 1];
for (int i = 1; i <= num; i++) {
int j = i;
int m = n - 1;
memset(a, 0, sizeof(a));
while (j > 0) {
int x = j & 1;
j >>= 1;
a[m] = x;
m--;
}
vector<string> vo;
for (int k = 0; k < n; k++) {
if (a[k] == 1) {
vo.push_back(s[k]);
}
}
if (vo.size() > 0) vi.push_back(vo);
}
return vi;
}
void disp(vector<string> &v) {
cout << v.size() << " ";
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << "\n";
}
int main() {
int n, m;
cin >> n >> m;
vector<string> v;
set<pair<string, string> > se;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
for (int i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
se.insert(make_pair(s1, s2));
se.insert(make_pair(s2, s1));
}
vector<vector<string> > vo = subset(v);
vector<string> ma;
int mai = -1;
bool f = true;
for (int i = 0; i < vo.size(); i++) {
vector<string> to = vo[i];
f = true;
for (int j = 0; j < to.size() && f; j++) {
for (int k = j + 1; k < to.size() && f; k++) {
if (se.find(make_pair(to[j], to[k])) != se.end()) {
f = false;
}
}
}
int y = to.size();
if (f && (y > mai)) {
mai = to.size();
ma = to;
sort(ma.begin(), ma.end());
}
}
cout << mai << "\n";
for (int i = 0; i < ma.size(); i++) {
cout << ma[i] << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[1010];
int brr[1010];
int w;
int n;
bool myfunc(double mid) {
double x = w + mid;
for (int i = 0; i < n; i++) {
x = x - x / arr[i];
x = x - x / brr[i + 1];
}
return x >= w;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
cin >> w;
long long flag = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 1) flag = 1;
}
for (int i = 0; i < n; i++) {
cin >> brr[i];
if (brr[i] == 1) flag = 1;
}
brr[n] = brr[0];
if (flag) {
cout << -1 << endl;
} else {
double low = 0;
double high = 1e9 + 7;
while ((low + 1e-7) < high) {
double mid = (low + high) / 2.00;
if (myfunc(mid)) {
high = mid;
} else {
low = mid;
}
}
if (high > 1e9 + 1)
cout << -1 << endl;
else
printf("%.6lf\n", high);
}
}
| 3 |
#include <bits/stdc++.h>
const int Maxn = 300000;
const int Maxm = 600000;
const int Maxq = 1200000;
long long w[Maxn + 5];
long long f[Maxn + 5][20][2][2];
long long f_x[2], f_y[2], d[Maxn + 5];
long long n;
long long fa[Maxn + 5][20], dep[Maxn + 5];
long long head[Maxn + 5], arrive[Maxn << 1 | 5], val_1[Maxn << 1 | 5],
val_2[Maxn << 1 | 5], nxt[Maxn << 1 | 5], tot;
void add_edge(long long from, long long to, long long w_1, long long w_2) {
arrive[++tot] = to;
nxt[tot] = head[from];
val_1[tot] = w_1;
val_2[tot] = w_2;
head[from] = tot;
}
void init_dfs_1(long long u) {
dep[u] = dep[fa[u][0]] + 1;
for (long long i = 1; fa[fa[u][i - 1]][i - 1]; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
for (long long i = head[u]; i; i = nxt[i]) {
long long v = arrive[i];
if (v == fa[u][0]) {
continue;
}
fa[v][0] = u;
init_dfs_1(v);
w[u] = std::min(w[u], w[v] + val_1[i] + val_2[i]);
}
}
void init_dfs_2(long long u) {
for (long long i = head[u]; i; i = nxt[i]) {
long long v = arrive[i];
if (v == fa[u][0]) {
continue;
}
w[v] = std::min(w[v], w[u] + val_1[i] + val_2[i]);
init_dfs_2(v);
}
}
void work_dfs(long long u) {
for (long long i = head[u]; i; i = nxt[i]) {
long long v = arrive[i];
if (v == fa[u][0]) {
continue;
}
work_dfs(v);
f[v][0][0][0] = std::min(val_1[i], w[v] + val_2[i] + w[u]);
f[v][0][0][1] = std::min(w[v] + val_2[i], w[u] + val_1[i]);
f[v][0][1][0] = std::min(w[v] + val_1[i], w[u] + val_2[i]);
f[v][0][1][1] = std::min(val_2[i], w[v] + val_1[i] + w[u]);
}
}
long long find_lca(long long u, long long v) {
if (dep[u] < dep[v]) {
std::swap(u, v);
}
for (long long i = 19; i >= 0; i--) {
if (dep[fa[u][i]] >= dep[v]) {
u = fa[u][i];
}
}
if (u == v) {
return u;
}
for (long long i = 19; i >= 0; i--) {
if (fa[u][i] != fa[v][i]) {
u = fa[u][i], v = fa[v][i];
}
}
return fa[u][0];
}
void solve() {
long long u, v, op_u, op_v;
scanf("%lld%lld", &u, &v);
op_u = (u & 1) ^ 1, op_v = (v & 1) ^ 1;
u = (u + 1) >> 1, v = (v + 1) >> 1;
long long lca = find_lca(u, v);
f_x[op_u] = f_y[op_v] = 0;
f_x[op_u ^ 1] = w[u], f_y[op_v ^ 1] = w[v];
for (long long i = 19; i >= 0; i--) {
if (dep[fa[u][i]] >= dep[lca]) {
long long tmp_0 = f_x[0], tmp_1 = f_x[1];
f_x[0] = std::min(tmp_0 + f[u][i][0][0], tmp_1 + f[u][i][1][0]);
f_x[1] = std::min(tmp_0 + f[u][i][0][1], tmp_1 + f[u][i][1][1]);
u = fa[u][i];
}
}
for (long long i = 19; i >= 0; i--) {
if (dep[fa[v][i]] >= dep[lca]) {
long long tmp_0 = f_y[0], tmp_1 = f_y[1];
f_y[0] = std::min(tmp_0 + f[v][i][0][0], tmp_1 + f[v][i][1][0]);
f_y[1] = std::min(tmp_0 + f[v][i][0][1], tmp_1 + f[v][i][1][1]);
v = fa[v][i];
}
}
printf("%lld\n", std::min(f_x[0] + f_y[0], f_y[1] + f_x[1]));
}
signed main() {
memset(f, 0x3f, sizeof f);
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
}
for (long long i = 1; i < n; i++) {
long long u, v, a, b;
scanf("%lld%lld%lld%lld", &u, &v, &a, &b);
add_edge(u, v, a, b), add_edge(v, u, a, b);
}
init_dfs_1(1);
init_dfs_2(1);
work_dfs(1);
for (long long i = 1; i < 20; i++) {
for (long long j = 1; j <= n; j++) {
f[j][i][0][0] =
std::min(f[j][i - 1][0][0] + f[fa[j][i - 1]][i - 1][0][0],
f[j][i - 1][0][1] + f[fa[j][i - 1]][i - 1][1][0]);
f[j][i][0][1] =
std::min(f[j][i - 1][0][0] + f[fa[j][i - 1]][i - 1][0][1],
f[j][i - 1][0][1] + f[fa[j][i - 1]][i - 1][1][1]);
f[j][i][1][0] =
std::min(f[j][i - 1][1][0] + f[fa[j][i - 1]][i - 1][0][0],
f[j][i - 1][1][1] + f[fa[j][i - 1]][i - 1][1][0]);
f[j][i][1][1] =
std::min(f[j][i - 1][1][0] + f[fa[j][i - 1]][i - 1][0][1],
f[j][i - 1][1][1] + f[fa[j][i - 1]][i - 1][1][1]);
}
}
long long T;
scanf("%lld", &T);
for (long long t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 12;
const int ooi = 1000000 + 7;
const long long ool = 1e18 + 7;
const int apsz = 26;
const long long mod = 1e9 + 7;
int n, m;
void init() {}
void solve() {
vector<vector<int> > unit;
vector<vector<int> > best;
vector<vector<int> > mat;
int needc;
vector<pair<int, int> > col_info;
cin >> n >> m;
for (int i = (0); i < (m); ++i) col_info.push_back({-1, i});
for (int i = (0); i < (n); ++i) {
unit.push_back(vector<int>(m));
for (int j = (0); j < (m); ++j)
cin >> unit[i][j], col_info[j].first = max(col_info[j].first, unit[i][j]);
}
for (int j = (0); j < (m); ++j) {
mat.push_back(vector<int>(n));
for (int i = (0); i < (n); ++i) mat[j][i] = unit[i][j];
}
sort(col_info.begin(), col_info.end());
needc = min(n, m);
int has = 0;
for (int i = (m - 1); i >= (0); --i) {
if (has == needc) break;
best.push_back(mat[col_info[i].second]);
has++;
}
long long all = (1 << n);
all--;
int t = 0;
long long ans = 0;
vector<vector<long long> > dp;
for (int i = (0); i < (2); ++i) dp.push_back(vector<long long>(all + 1, 0));
vector<vector<vector<long long> > > sum;
vector<vector<long long> > best_sum;
for (int i = (0); i < (needc); ++i)
best_sum.push_back(vector<long long>(all + 1, 0));
for (int i = (0); i < (needc); ++i) {
sum.push_back(vector<vector<long long> >(n, vector<long long>(all + 1, 0)));
for (int s = (0); s <= (all); ++s) {
for (int p = (0); p < (n); ++p) {
for (int j = (0); j < (n); ++j) {
if (s & (1 << j)) sum[i][p][s] += best[i][(p + j) % n];
}
best_sum[i][s] = max(best_sum[i][s], sum[i][p][s]);
}
}
}
for (int i = (0); i < (needc); ++i) {
for (int s = (0); s <= (all); ++s) dp[t ^ 1][s] = dp[t][s];
for (int s = (0); s <= (all); ++s) {
int bz = all ^ s;
for (int sz = bz; sz; sz = (sz - 1) & bz) {
dp[t ^ 1][s | sz] = max(dp[t ^ 1][s | sz], dp[t][s] + best_sum[i][sz]);
ans = max(ans, dp[t ^ 1][s | sz]);
}
}
t ^= 1;
}
cout << dp[t][all] << endl;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
init();
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111;
const int M = 33333;
const int INF = 2e9 + 9;
int n, m;
int s, t;
int erased_edge;
struct Edge {
int u, v, c;
Edge() {}
Edge(int u, int v, int c) {
this->u = u;
this->v = v;
this->c = c;
}
int to(int node) { return u ^ node ^ v; }
} E[M];
vector<int> a[N];
vector<int> path;
vector<int> findPath() {
queue<int> Q;
vector<int> trace(n + 1, -1);
trace[t] = 0;
Q.push(t);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int e : a[u])
if (erased_edge != e) {
int v = E[e].to(u);
if (trace[v] != -1) continue;
trace[v] = e;
Q.push(v);
}
}
vector<int> ans;
if (trace[s] == -1) return ans;
for (int u = s; u != t; u = E[trace[u]].to(u)) {
ans.push_back(trace[u]);
}
return ans;
}
vector<int> solveOneEdge() {
int best = INF;
int ans = -1;
for (int e : path) {
erased_edge = e;
if (findPath().empty() && best > E[e].c) {
best = E[e].c;
ans = e;
}
}
vector<int> res;
res.push_back(best);
res.push_back(ans);
return res;
}
int timer = 0;
int parent_edge[N], parent_cost[N];
int num[N], low[N];
bool containST[N];
void dfs(int u) {
;
num[u] = ++timer;
low[u] = INF;
containST[u] = u == t;
for (int e : a[u]) {
if (e == erased_edge || e == parent_edge[u]) continue;
int v = E[e].to(u);
if (num[v]) {
;
low[u] = min(low[u], num[v]);
} else {
parent_edge[v] = e;
parent_cost[v] = E[e].c;
dfs(v);
low[u] = min(low[u], low[v]);
containST[u] |= containST[v];
}
}
}
vector<int> solveTwoEdge() {
int best = INF;
int ans1 = -1, ans2 = -1;
for (int e : path) {
erased_edge = e;
timer = 0;
fill(parent_edge + 1, parent_edge + n + 1, 0);
fill(num + 1, num + n + 1, 0);
fill(containST + 1, containST + n + 1, 0);
parent_edge[s] = -1;
;
dfs(s);
for (int v = 1; v <= n; ++v)
if (v != s && low[v] >= num[v] && containST[v]) {
if (best > E[erased_edge].c + parent_cost[v]) {
best = E[erased_edge].c + parent_cost[v];
ans1 = erased_edge;
ans2 = parent_edge[v];
};
;
}
}
vector<int> res;
res.push_back(best);
res.push_back(ans1);
res.push_back(ans2);
return res;
}
int main() {
ios_base ::sync_with_stdio(0);
cin >> n >> m;
cin >> s >> t;
for (int i = 1; i <= m; ++i) {
int u, v, c;
cin >> u >> v >> c;
E[i] = Edge(u, v, c);
a[u].push_back(i);
a[v].push_back(i);
}
::path = findPath();
;
if (::path.empty()) {
cout << 0 << "\n" << 0 << "\n";
return 0;
}
vector<int> one = solveOneEdge();
vector<int> two = solveTwoEdge();
int mn = min(one[0], two[0]);
if (mn == INF) {
cout << "-1\n";
return 0;
}
if (one[0] < two[0]) {
cout << one[0] << "\n" << 1 << "\n" << one[1] << "\n";
return 0;
}
cout << two[0] << "\n" << 2 << "\n" << two[1] << " " << two[2] << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c, i, j, p = 0;
cin >> n >> m;
for (i = n + 1; i <= m; i++) {
c = 0;
for (j = 2; j <= sqrt(i); j++)
if (i % j == 0) {
c = 1;
break;
}
if (c == 0) {
p = i;
break;
}
}
if (p == m)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAX_SIZE = 20, MAX_A = 2 * 1000;
int arr[MAX_A], ex[MAX_SIZE][MAX_SIZE];
int n;
int answer[MAX_SIZE][MAX_SIZE];
set<pair<int, int>> q;
int main() {
cin >> n;
for (int i = 0; i < n * n; i++) {
int g;
cin >> g;
arr[g] += 1;
}
for (int i = 0; i <= MAX_A; i++) {
if (arr[i] != 0) q.insert(make_pair(arr[i], i));
}
int k = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (ex[i][j] == 0) {
ex[i][j] = ex[i][n - 1 - j] = ex[n - 1 - i][j] =
ex[n - 1 - i][n - 1 - j] = k;
k++;
}
}
}
vector<pair<int, int>> gg;
for (int i = 1; i < k; i++) {
int cc = 0;
for (int p = 0; p < n; p++) {
for (int r = 0; r < n; r++) cc += ex[p][r] == i;
}
gg.push_back(make_pair(cc, i));
}
sort(gg.begin(), gg.end());
reverse(gg.begin(), gg.end());
for (auto ff : gg) {
int i = ff.second;
int cnt = (*q.rbegin()).first, x = (*q.rbegin()).second;
q.erase(*(q.rbegin()));
for (int p = 0; p < n; p++) {
for (int h = 0; h < n; h++) {
if (ex[p][h] == i) {
answer[p][h] = x;
cnt -= 1;
if (cnt < 0) {
cout << "NO";
return 0;
}
}
}
}
if (cnt != 0) {
q.insert(make_pair(cnt, x));
}
}
cout << "YES"
<< "\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << answer[i][j] << ' ';
}
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int a = 0; a < t; a++) {
int n, m, k;
cin >> n >> m >> k;
if (n / k >= m) {
cout << m << "\n";
} else {
cout << n / k - ((m - n / k - 1) / (k - 1) + 1) << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, i, j, k, cnt, tot, f[maxn];
char s[maxn];
int main() {
scanf("%d%s", &n, s + 1);
if (n & 1) return puts("0"), 0;
tot = n >> 1;
f[0] = 1;
for (i = 1; i <= n; i++) {
if (s[i] == '?')
for (j = i >> 1, k = max(1, tot - (n - i)); j >= k; j--)
f[j] = f[j] + f[j - 1];
else
cnt++;
}
if (cnt > tot) return puts("0"), 0;
int ans = f[tot];
for (i = tot - cnt; i; i--) ans *= 25;
printf("%u", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n;
string s[1005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> s[i];
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
if (s[i][1] == s[i][0] && s[i][1] == 'O') {
ans = 1;
s[i][1] = s[i][0] = '+';
break;
} else if (s[i][4] == s[i][3] && s[i][3] == 'O') {
ans = 1;
s[i][4] = s[i][3] = '+';
break;
}
}
if (ans == 1) {
cout << "YES\n";
for (long long i = 1; i <= n; ++i) cout << s[i] << endl;
} else
cout << "NO\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
short ans = 0;
int main() {
cin >> a >> b;
while (b > 0) {
if (b == 1) {
ans = 0;
break;
}
if (b % a != 0) {
ans = 1;
break;
}
++n;
b = b / a;
}
if (ans == 0) {
cout << "YES" << endl;
cout << n - 1;
} else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
set<int> A[200010];
void out(int x) {
while (x % 2 == 0) x /= 2;
printf("%d\n", x);
exit(0);
}
map<int, vector<int> > B[200010];
set<pair<int, int> > C;
void add(int x, int y, int t) {
B[x][t].push_back(y);
if ((int)B[x][t].size() == 2) C.insert(make_pair(t, x));
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
A[x].insert(y);
A[y].insert(x);
}
int now = n - 1;
for (int i = 0; i < n; i++)
if ((int)A[i].size() == 1) {
int x = *A[i].begin(), y = i;
int t = 1;
while ((int)A[x].size() == 2) {
int x1 = *A[x].begin();
if (x1 == y) x1 = *A[x].rbegin();
y = x;
x = x1;
t++;
}
if ((int)A[x].size() == 1) out(now);
add(x, y, t);
}
while (!C.empty()) {
pair<int, int> _x = *C.begin();
C.erase(C.begin());
int x = _x.second, t = _x.first;
int m = (int)B[x][t].size();
for (int i = 1; i < m; i++) {
now -= t;
A[x].erase(B[x][t][i]);
}
if ((int)A[x].size() == 1) out(now);
if ((int)A[x].size() > 2) {
B[x][t].resize(1);
continue;
}
int y = B[x][t][0];
B[x].erase(B[x].find(t));
while ((int)A[x].size() == 2) {
int x1 = *A[x].begin();
if (x1 == y) x1 = *A[x].rbegin();
y = x;
x = x1;
t++;
}
if ((int)A[x].size() == 1) out(now);
add(x, y, t);
}
puts("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a, n, ymax, i, flag, x, y[100001] = {0}, z[100001] = {0};
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
flag = 0;
cin >> a;
z[y[a]]--;
y[a]++;
z[y[a]]++;
ymax = max(ymax, y[a]);
if (z[1] == i) flag = 1;
if (z[i] == 1) flag = 1;
if (z[1] == 1 && z[ymax] * ymax == i - 1) flag = 1;
if (z[ymax - 1] * (ymax - 1) == i - ymax && z[ymax] == 1) flag = 1;
if (flag) x = i;
}
cout << x << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans;
int main() {
while (scanf("%lld", &n) > 0) {
ans = n;
scanf("%lld", &m);
n -= m;
long double x, delta;
if (n > 0) {
delta = sqrt(1 + 8 * n);
x = (delta - 1) / 2;
ans = ceil(x) + m;
}
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int maxint = numeric_limits<int>::max();
bool sortbysec(const pair<int, int>& a, const pair<int, int>& b) {
return (a.second < b.second);
}
bool cmp(pair<char, long long int>& a, pair<char, long long int>& b) {
return a.second > b.second;
}
long long int distance1(long long int x1, long long int y1, long long int x2,
long long int y2) {
return sqrt(pow(x2 - x1, 2) * 1.0 + pow(y2 - y1, 2) * 1.0);
}
long long int distance2(long long int x1, long long int y1, long long int x2,
long long int y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
long long binpoww(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long int binpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long int digSum(long long int n) {
long long int sum = 0;
while (n > 0 || sum > 9) {
if (n == 0) {
n = sum;
sum = 0;
}
sum += n % 10;
n /= 10;
}
return sum;
}
bool prime[20000002];
void SieveOfEratosthenes(long long int n) {
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
bool isPrime(long long int n) {
if (n <= 1) return false;
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
void solve() {
long long int n;
cin >> n;
char ch;
cin >> ch;
string s;
cin >> s;
long long int o = 0, e = 0;
for (long long int i = 0; i < n; i++) {
o += s[i] != ch;
i++;
}
for (long long int i = 1; i < n; i++) {
e += s[i] != ch;
i++;
}
if (o == 0 && e == 0) {
cout << 0 << endl;
} else if (e == 0 || o == 0) {
if (o > 0) {
cout << 1 << endl << 2 << endl;
} else if (e > 0) {
if (n % 2 == 0) {
cout << 1 << endl << n - 1 << endl;
} else if (n % 2 == 1) {
cout << 1 << endl << n << endl;
}
}
} else if (e != 0 && o != 0) {
long long int sz = (n / 2) + 1, f = -1;
for (int i = sz - 1; i < n; i++) {
if (s[i] == ch) {
f = i + 1;
break;
}
}
if (f > 0) {
cout << 1 << endl << f << endl;
} else if (f == -1) {
cout << 2 << endl;
cout << n - 1 << " " << n << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, lzx = 0;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -f;
c = getchar();
}
while (c <= '9' && c >= '0') {
lzx = lzx * 10 + c - '0';
c = getchar();
}
return lzx * f;
}
const long long N = 1e5 + 10, mod = 998244353;
long long ans[N];
long long r[16] = {0, 4, 8, -1, 16, -10, 4, -12,
-48, 26, -44, 15, -16, -4, -4, -1},
f[17] = {0, 0, 0, 24, 4, 240,
204, 1316, 2988, 6720, 26200, 50248,
174280, 436904, 1140888, 3436404, 8348748};
signed main() {
long long n = read();
if (n <= 16)
cout << f[n] << endl;
else {
for (register long long i = 1; i <= 16; i++) ans[i] = f[i];
for (register long long i = 17; i <= n; i++) {
for (register long long j = 0; j < 16; j++)
ans[i] = (ans[i] + r[j] * ans[i - j - 1] % mod + mod) % mod;
}
cout << ans[n] << endl;
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r, k;
cin >> l >> r >> k;
long long tmp = 1;
int flag = 0;
while (tmp <= r) {
if (tmp >= l && tmp <= r) cout << tmp << " ", flag = 1;
if (tmp > r / k) break;
tmp *= k;
}
if (!flag) cout << -1;
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void outarr(Tp _array, const std::size_t _N, const char* _delim = " ") {
Tp end = _array + _N;
for (Tp current = _array; current != end; ++current) {
std::cout << *current << _delim;
}
std::cout << '\n';
}
using ll = std::int64_t;
using pii = std::pair<int, int>;
constexpr int INF = INT_MAX;
constexpr int MOD = 1e9 + 7;
int arr[100001];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
cin >> n;
ll sum = 0;
for (int i = 0; i < (n); ++i) {
int a;
cin >> a;
sum += a;
}
for (int i = 0; i < (n); ++i) {
cin >> arr[i];
}
sort(arr, arr + n, [](const int a, const int b) { return b < a; });
if ((ll)arr[0] + arr[1] >= sum) {
return std::cout << ("YES"), 0;
;
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mxi = 5e5 + 666;
const long long mod = 1e9 + 7;
long long n, k, te, dp[mxi][2];
vector<pair<long long, long long> > t[mxi];
void dfs(int v, int par = -1) {
dp[v][0] = dp[v][1] = 0;
long long sum = 0;
vector<long long> c;
for (auto x : t[v]) {
long long u = x.first, w = x.second;
if (u != par) {
dfs(u, v);
sum += dp[u][1];
c.push_back(w - dp[u][1] + dp[u][0]);
}
}
sort(c.begin(), c.end(), greater<long long>());
dp[v][0] = sum;
long long p = 0;
for (long long i = 0; i < min((long long)c.size(), k - 1); i++) {
p += c[i];
dp[v][0] = max(dp[v][0], p + sum);
}
if (c.size() >= k) p += c[k - 1];
dp[v][1] = max(dp[v][1], p + sum);
dp[v][1] = max(dp[v][1], dp[v][0]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> te;
while (te--) {
cin >> n >> k;
for (long long i = 1; i < n; i++) {
long long v, u, w;
cin >> v >> u >> w;
t[v].push_back({u, w});
t[u].push_back({v, w});
}
dfs(1);
cout << dp[1][1] << "\n";
for (int i = 1; i <= n; i++) t[i].clear();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxnn = 4e3 + 7;
const int inf = 1e7 + 7;
int n;
int nxt[maxnn];
int to[maxnn];
int from[maxnn];
int head[maxnn];
int cnt = 1;
void add(int l, int r) {
to[++cnt] = r;
nxt[cnt] = head[l];
head[l] = cnt;
}
struct dy {
int fu;
int c;
int xh;
int r;
int q;
} a[maxnn];
int ans[maxnn];
int cx[maxnn];
void bfs(int p, int sd) {
a[p].r = sd;
sd++;
cx[p] = 1;
for (int i = head[p]; i; i = nxt[i]) {
bfs(to[i], sd);
cx[p] += cx[to[i]];
}
return;
}
int vis[maxnn];
void bbfs(int p) {
int cs = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) cs++;
if (cs == a[p].c + 1) {
ans[p] = i;
break;
}
}
vis[ans[p]] = 1;
for (int i = head[p]; i; i = nxt[i]) {
bbfs(to[i]);
}
return;
}
bool cmp(dy x, dy y) { return x.r > y.r; }
bool cmp2(dy x, dy y) { return x.xh < y.xh; }
int main() {
scanf("%d", &n);
int s;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].fu, &a[i].c);
a[i].xh = i;
if (a[i].fu != 0)
add(a[i].fu, i);
else
s = i;
}
bfs(s, 1);
int flag = 0;
for (int i = 1; i <= n; i++) {
if (cx[i] <= a[i].c) {
flag = 1;
break;
}
}
if (flag == 1) {
printf("NO\n");
return 0;
}
printf("YES\n");
bbfs(s);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
vector<int> A(n);
vector<long long> Asum(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &A[i]);
if (i == 0)
Asum[i] = A[i];
else
Asum[i] = Asum[i - 1] + A[i];
}
cin >> m;
vector<int> B(m);
vector<long long> Bsum(m);
for (int i = 0; i < m; ++i) {
scanf("%d", &B[i]);
if (i == 0)
Bsum[i] = B[i];
else
Bsum[i] = Bsum[i - 1] + B[i];
}
if (Asum[n - 1] != Bsum[m - 1]) {
cout << "-1";
return 0;
}
int i = 0, j = 0;
int ans = 0;
while (i < n || j < m) {
if (Asum[i] < Bsum[j]) ++i;
if (Asum[i] > Bsum[j]) ++j;
if (Asum[i] == Bsum[j]) {
++ans;
++i;
++j;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int u, v;
int main() {
cin >> u >> v;
if (u > v || (u != 0 && v == 0) || (v - u) % 2)
cout << "-1" << endl;
else if (u == 0 && v == 0)
cout << "0" << endl;
else if (u == v)
cout << "1" << endl << u << endl;
else {
unsigned long long int t = (v - u) / 2;
if ((u & t) == 0) {
cout << "2" << endl;
cout << t << " " << u + t << endl;
} else {
cout << "3" << endl;
cout << t << " " << t << " " << u << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool binary_search(double &mid, double *E, double &err, int n, int k);
int main() {
int n, k;
cin >> n >> k;
double *E = new double[n];
for (int i = 0; i < n; i++) {
cin >> E[i];
}
sort(E, E + n);
double low = E[0], high = E[n - 1], mid = (low + high) / 2, err = 0,
t_err = 0;
while (1) {
bool t = binary_search(mid, E, err, n, k);
if (err <= 1e-8) {
printf("%.9f", mid);
break;
}
if (t) {
high = mid;
mid = (mid + low) / 2;
binary_search(mid, E, err, n, k);
} else {
low = mid;
mid = (mid + high) / 2;
binary_search(mid, E, err, n, k);
}
}
return 0;
}
bool binary_search(double &mid, double *E, double &err, int n, int k) {
double low_sum = 0;
double high_sum = 0;
for (int i = 0; i < n; i++) {
if (E[i] < mid) {
low_sum += mid - E[i];
} else {
high_sum += E[i] - mid;
}
}
if (low_sum == 0 && high_sum == 0) {
err = 0;
return 0;
}
if (low_sum / high_sum > 1.0 * (100 - k) / 100) {
err = low_sum / high_sum - 1.0 * (100 - k) / 100;
return true;
} else {
err = 1.0 * (100 - k) / 100 - low_sum / high_sum;
return false;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, num = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) (x % i == 0 && x / i <= n) ? num++ : 1;
cout << num;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5;
vector<int> g[maxn];
bool used[maxn];
int t = 0, tin[maxn], tup[maxn];
set<pair<int, int> > a;
set<pair<int, int> > b;
void bridges(int v, int p = -1) {
used[v] = true;
tin[v] = tup[v] = t++;
for (int u : g[v]) {
if (u == p) continue;
if (used[u])
tup[v] = min(tup[v], tin[u]);
else {
bridges(u, v);
tup[v] = min(tup[v], tup[u]);
if (tup[u] > tin[v]) {
b.insert({u, v});
b.insert({v, u});
}
}
}
}
int cnt;
bool con[maxn];
void dfs(int v, int p = -1) {
con[v] = true;
cnt++;
for (int u : g[v]) {
if (u != p && !b.count({v, u})) {
if (!con[u]) {
a.insert({v, u});
dfs(u, v);
} else if (!a.count({u, v}))
a.insert({v, u});
}
}
}
void fin(int v) {
used[v] = true;
for (int u : g[v]) {
if (!used[u]) {
if (b.count({v, u})) a.insert({u, v});
fin(u);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> u(m), v(m);
for (int i = 0; i < m; i++) {
cin >> u[i] >> v[i];
u[i]--, v[i]--;
g[u[i]].push_back(v[i]);
g[v[i]].push_back(u[i]);
}
int mx = 0, rt = 0;
for (int i = 0; i < n; i++)
if (!used[i]) bridges(i);
for (int i = 0; i < n; i++) {
if (!con[i]) {
cnt = 0;
dfs(i);
if (cnt > mx) mx = cnt, rt = i;
}
}
for (int i = 0; i < n; i++) used[i] = false;
fin(rt);
cout << mx << "\n";
for (int i = 0; i < m; i++) {
if (!a.count({u[i], v[i]})) swap(u[i], v[i]);
cout << u[i] + 1 << " " << v[i] + 1 << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
set<vector<int>> involved[100005];
map<vector<int>, int> indexing;
vector<int> adj[100005];
void dfs(int u, int dad, int cnt) {
if (!cnt) return;
cout << u << ' ';
for (auto i : adj[u])
if (i != dad) {
dfs(i, u, cnt - 1);
break;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T, n;
for (cin >> T; T--; cout << '\n') {
cin >> n;
for (int i = 1; i <= n; ++i) {
involved[i].clear();
adj[i].clear();
}
indexing.clear();
set<pair<int, int>> pq;
vector<int> freq(n + 2);
map<pair<int, int>, int> pairs;
for (int i = 1; i <= n - 2; ++i) {
vector<int> v(3);
cin >> v[0] >> v[1] >> v[2];
sort(v.begin(), v.end());
for (auto j : v) involved[j].insert(v);
for (auto j : v) ++freq[j];
for (int j = 0; j < 3; ++j)
for (int k = j + 1; k < 3; ++k) ++pairs[{v[j], v[k]}];
indexing[v] = i;
}
for (auto _p : pairs)
if (_p.second == 1) {
auto p = _p.first;
adj[p.first].push_back(p.second);
adj[p.second].push_back(p.first);
}
for (int i = 1; i <= n; ++i) pq.insert({freq[i], i});
dfs(1, 0, n);
cout << '\n';
while (pq.size()) {
auto now = pq.begin()->second;
pq.erase(pq.begin());
auto poly = *involved[now].begin();
cout << indexing[poly] << ' ';
for (auto i : poly)
if (i != now) {
pq.erase({freq[i]--, i});
involved[i].erase(poly);
}
for (auto i : poly)
if (i != now && freq[i]) pq.insert({freq[i], i});
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10, maxC = 23, maxMSK = 4194304 + 20;
int c[maxC], cs[maxC][maxC];
long long MSK[maxMSK], CMM;
pair<int, int> lst[maxC];
char ch[maxN];
int main() {
int n, k, t;
scanf("%d%d%d", &n, &k, &t);
scanf("%s", ch);
for (int i = 0; i < n; i++) CMM |= (1 << (ch[i] - 'A'));
CMM ^= ((1 << k) - 1);
for (int i = 0; i < k; i++) scanf("%d", &c[i]);
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) scanf("%d", &cs[i][j]);
for (int i = 0; i < k; i++) lst[i] = {n, i};
for (int i = n - 1; i >= 0; i--) {
int bef = 0, msk = 0;
for (int j = 0; j < k && lst[j].first < n; j++) {
int num = cs[ch[i] - 'A'][lst[j].second] - bef;
MSK[msk] += num;
MSK[msk ^ (1 << (ch[i] - 'A'))] -= num;
bef = cs[ch[i] - 'A'][lst[j].second];
msk |= (1 << lst[j].second);
if (lst[j].second == (ch[i] - 'A')) break;
}
if (!(((msk) >> ((ch[i] - 'A'))) & 1)) {
MSK[msk] -= bef;
MSK[msk ^ (1 << (ch[i] - 'A'))] += bef;
}
for (int j = 0; j < k; j++) swap(lst[j].first, lst[j].second);
sort(lst, lst + k);
lst[ch[i] - 'A'].second = i;
for (int j = 0; j < k; j++) swap(lst[j].first, lst[j].second);
sort(lst, lst + k);
}
for (int i = 0; i < k; i++) {
for (int j = (1 << k) - 1; j >= 0; j--) {
if ((((j) >> (i)) & 1)) MSK[j] += MSK[j ^ (1 << i)];
}
}
int ans = 0;
for (int i = 0; i < (1 << k); i++) {
if (i & CMM) continue;
if ((CMM | i) == ((1 << k) - 1)) continue;
for (int j = 0; j < k; j++) {
if ((((i) >> (j)) & 1)) MSK[i] += c[j];
}
if (MSK[i] <= t) ans++;
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int read(int &x) { return scanf("%d", &x); }
int read(int &x, int &y) { return scanf("%d%d", &x, &y); }
int read(int &x, int &y, int &z) { return scanf("%d%d%d", &x, &y, &z); }
int read(long long &x) { return scanf("%lld", &x); }
char buff[1000010];
int read(string &s) {
int r = scanf("%s", buff);
s = buff;
return r;
}
struct Line {
long long m, b;
int id;
long long eval(long long x) const { return m * x + b; }
};
struct cmp {
long long x;
cmp(long long x) : x(x) {}
bool operator()(Line a, Line b) const { return a.eval(x) < b.eval(x); }
};
void setOrder(const vector<Line> &V, vector<int> &O, long long t) {
for (int i = 0; i < V.size(); ++i) {
if (i == 0)
O[V[i].id] = 0;
else if (V[i - 1].eval(t) == V[i].eval(t)) {
O[V[i].id] = O[V[i - 1].id];
} else {
O[V[i].id] = O[V[i - 1].id] + 1;
}
}
}
long long getMinT(vector<Line> V) {
int N = V.size();
long long lo = 0, hi = 1000000000, ret = -1;
while (lo <= hi) {
long long mi = (lo + hi) / 2;
sort(V.begin(), V.end(), cmp(mi));
vector<int> ORD(N);
setOrder(V, ORD, mi);
sort(V.begin(), V.end(), cmp(0));
vector<int> MX(N), MX2(N);
int mx = 0;
for (int i = 0, j = 0; i < N; ++i) {
while (j < N && V[i].eval(0) == V[j].eval(0)) {
mx = max(mx, ORD[V[j].id]);
j++;
}
if (V[i].id >= N / 2) continue;
MX[mx]++;
}
for (int i = N / 2; i < N; ++i) {
MX2[ORD[i]]++;
}
bool ok = 1;
for (int i = N - 1, x = 0; i >= 0 && ok; --i) {
x += MX[i];
if (x < MX2[i]) {
ok = 0;
} else {
x -= MX2[i];
}
}
if (ok) {
ret = mi;
hi = mi - 1;
} else {
lo = mi + 1;
}
}
return ret;
}
const long long INF = 1000000000000000000LL;
struct MinCostFlow {
int n;
vector<int> head;
struct Edge {
int from, to, cap, cost, flow, last;
};
MinCostFlow(int n) : n(n), head(n, -1) {}
vector<Edge> edges;
void add_rib(int a, int b, int u, int c) {
edges.push_back({a, b, u, c, 0, head[a]});
head[a] = edges.size() - 1;
edges.push_back({b, a, 0, -c, 0, head[b]});
head[b] = edges.size() - 1;
}
void reset() {
for (Edge &e : edges) e.flow = 0;
}
pair<long long, long long> run(int s, int t, long long k = INF) {
long long flow = 0, cost = 0;
while (flow < k) {
vector<int> id(n, 0);
vector<long long> d(n, INF);
vector<int> q(n);
vector<size_t> p_rib(n, -1);
int qh = 0, qt = 0;
q[qt++] = s;
d[s] = 0;
while (qh != qt) {
int v = q[qh++];
id[v] = 2;
if (qh == n) qh = 0;
for (int i = head[v]; i != -1; i = edges[i].last) {
Edge &e = edges[i];
if (e.flow < e.cap && d[v] + e.cost < d[e.to]) {
d[e.to] = d[v] + e.cost;
if (id[e.to] == 0) {
q[qt++] = e.to;
if (qt == n) qt = 0;
} else if (id[e.to] == 2) {
if (--qh == -1) qh = n - 1;
q[qh] = e.to;
}
id[e.to] = 1;
p_rib[e.to] = i;
}
}
}
if (d[t] == INF) break;
long long addflow = k - flow;
for (int i = p_rib[t]; i != -1; i = p_rib[edges[i ^ 1].to]) {
addflow = min(addflow, (long long)edges[i].cap - edges[i].flow);
}
for (int i = p_rib[t]; i != -1; i = p_rib[edges[i ^ 1].to]) {
edges[i].flow += addflow;
edges[i ^ 1].flow -= addflow;
cost += edges[i].cost * addflow;
}
flow += addflow;
}
return make_pair(flow, cost);
}
};
vector<int> GO(vector<Line> V, long long T) {
vector<int> O(V.size());
sort(V.begin(), V.end(), cmp(T));
setOrder(V, O, T);
return O;
}
int main() {
int N;
read(N);
N *= 2;
vector<Line> V(N);
for (int i = 0; i < N; ++i) {
Line &v = V[i];
read(v.m);
read(v.b);
v.id = i;
}
long long T = getMinT(V);
if (T == -1) {
cout << -1 << endl;
return 0;
}
vector<int> AT0 = GO(V, 0);
int szOrderAt0 = *max_element(AT0.begin(), AT0.end()) + 1;
vector<int> ATT = GO(V, T);
int szOrderAtT = *max_element(ATT.begin(), ATT.end()) + 1;
int source = N + szOrderAt0 + szOrderAtT;
int sink = source + 1;
MinCostFlow MF(N + szOrderAt0 + szOrderAtT + 2);
for (int i = 0; i < N / 2; ++i) {
MF.add_rib(source, i, 1, 0);
MF.add_rib(i, AT0[i] + N, 1, 1);
MF.add_rib(i, ATT[i] + N + szOrderAt0, 1, 1);
}
for (int i = 1; i < szOrderAt0; ++i) {
MF.add_rib(N + i, N + i - 1, N, 0);
}
for (int i = 1; i < szOrderAtT; ++i) {
MF.add_rib(N + szOrderAt0 + i, N + szOrderAt0 + i - 1, N, 0);
}
for (int i = N / 2; i < N; ++i) {
MF.add_rib(AT0[i] + N, i, 1, 0);
MF.add_rib(ATT[i] + N + szOrderAt0, i, 1, 0);
MF.add_rib(i, sink, 1, 0);
}
for (int i = 0; i < N; ++i) {
MF.add_rib(AT0[i] + N, ATT[i] + N + szOrderAt0, N, 1);
}
auto p = MF.run(source, sink, N / 2);
cout << T << " " << p.second << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000100;
int n;
char s[maxn];
int z[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> s[i];
if (s[i] == 'N')
s[i] = 'S';
else if (s[i] == 'E')
s[i] = 'W';
else if (s[i] == 'S')
s[i] = 'N';
else
s[i] = 'E';
}
for (int i = n - 1; i < 2 * n - 2; i++) cin >> s[i];
reverse(s, s + n - 1);
n = 2 * n - 2;
int l = 0, r = 0;
for (int i = 1; i < n; i++) {
if (z[i - l] + i < r)
z[i] = z[i - l];
else {
l = i;
r = max(r, i);
while (r < n && s[r] == s[r - l]) r++;
z[i] = r - l;
}
}
for (int i = n / 2; i < n; i++)
if (z[i] >= n - i) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5100;
int n, m;
int a[N], g[N], pf[N], gf[N];
int b[N];
int dp[N];
inline int gcd(int x, int y) {
while (x) {
const int nx = y % x;
const int ny = x;
x = nx;
y = ny;
}
return y;
}
inline int f(int x) {
int ret = 0;
int* j = b;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
j = lower_bound(j, b + m, i);
int d = (j == b + m || *j != i ? 1 : -1);
while (x % i == 0) {
ret += d;
x /= i;
}
}
if (x != 1) {
j = lower_bound(j, b + m, x);
if (j == b + m || *j != x)
++ret;
else
--ret;
}
return ret;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 0; i < m; ++i) scanf("%d", b + i);
sort(b, b + m);
g[1] = a[1];
gf[1] = pf[1] = f(a[1]);
for (int i = 2; i <= n; ++i) {
g[i] = gcd(g[i - 1], a[i]);
pf[i] = pf[i - 1] + f(a[i]);
if (g[i] == g[i - 1])
gf[i] = gf[i - 1];
else
gf[i] = f(g[i]);
}
for (int i = n; i > 0; --i) {
dp[i] = pf[n] - i * gf[i];
for (int j = i + 1; j <= n; ++j)
dp[i] = max(dp[i], dp[j] + i * gf[j] - i * gf[i]);
}
int ans = pf[n];
for (int i = n; i > 0; --i) ans = max(ans, dp[i]);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long int;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
ll gcd(ll a, ll b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
ll bs(ll s, ll e, ll a[], ll v) {
ll m = (s + e) / 2;
if (v > a[m])
return bs(m + 1, e, a, v);
else if (v < a[m])
return bs(s, m - 1, a, v);
return m;
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void testingio() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
fastio();
int a, b;
cin >> a >> b;
int x = min(a, b);
int y = (max(a, b) - x) / 2;
cout << x << " " << y;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
long long f[maxn], a[maxn], b[maxn], s[maxn];
struct Linear_basis {
long long p[70];
int cnt, flag;
void init() {
memset(p, 0, sizeof(p));
cnt = 0;
flag = 1;
}
void Insert(long long x) {
for (int i = 63; i >= 0; i--) {
if ((x >> i) & 1) {
if (!p[i]) {
p[i] = x;
break;
}
x ^= p[i];
}
}
if (x > 0)
cnt++;
else if (x == 0)
flag = 0;
}
long long check(long long x) {
for (int i = 63; i >= 0; i--) {
if ((x >> i) & 1) {
x ^= p[i];
}
}
return x;
}
} sol;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
f[i] = a[i] ^ b[i];
sol.Insert(f[i]);
}
for (int i = 1; i <= n; i++) s[i] = s[i - 1] ^ a[i];
if (sol.check(s[n]))
printf("1/1\n");
else {
long long ans = 1ll << sol.cnt;
printf("%lld/%lld\n", ans - 1ll, ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
int abs(int a) { return a > 0 ? a : -a; }
using namespace std;
char arr[11][11];
int y, x;
int main() {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
scanf("%c ", &arr[i][j]);
}
}
scanf("%d %d", &y, &x);
y--;
x--;
int ny = y % 3;
int nx = x % 3;
bool full = true;
for (int i = ny * 3; i < ny * 3 + 3; i++) {
for (int j = nx * 3; j < nx * 3 + 3; j++) {
if (arr[i][j] == '.') {
full = false;
arr[i][j] = '!';
}
}
}
if (full) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (arr[i][j] == '.') arr[i][j] = '!';
}
}
}
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (i == 3 || i == 7 || j == 3 || j == 7) {
printf(" ");
} else {
int ni = i, nj = j;
if (ni >= 3) ni--;
;
if (ni >= 7) ni--;
;
if (nj >= 3) nj--;
;
if (nj >= 7) nj--;
;
printf("%c", arr[ni][nj]);
}
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m;
int s[100009], nt[200009], e[200009];
int out[100009], vis[100009][2], v, ss;
int cnt, flag[100009];
struct node {
int x, y;
} pre, nt1;
int dfs(int k) {
flag[k] = 1;
for (int i = s[k]; ~i; i = nt[i]) {
if (flag[e[i]] == 1)
return 1;
else if (flag[e[i]] == 0) {
if (dfs(e[i])) return 1;
}
}
flag[k] = 2;
return 0;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
cnt = 0;
memset(s, -1, sizeof s);
for (int i = 1; i <= n; i++) {
scanf("%d", &out[i]);
for (int j = 0; j < out[i]; j++) {
scanf("%d", &v);
nt[cnt] = s[i], s[i] = cnt, e[cnt++] = v;
}
}
scanf("%d", &ss);
memset(vis, 0, sizeof vis);
memset(flag, 0, sizeof flag);
pre.x = ss, pre.y = 0;
vis[ss][0] = -1;
queue<node> q;
q.push(pre);
while (!q.empty()) {
pre = q.front();
q.pop();
for (int i = s[pre.x]; ~i; i = nt[i]) {
if (!vis[e[i]][pre.y ^ 1]) {
vis[e[i]][pre.y ^ 1] = pre.x;
nt1.x = e[i], nt1.y = pre.y ^ 1;
q.push(nt1);
}
}
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if ((!out[i]) && vis[i][1]) {
printf("Win\n");
int now = 1, k = i;
vector<int> ans;
while (k != -1) {
ans.push_back(k);
k = vis[k][now];
now ^= 1;
}
for (int j = ans.size() - 1; j >= 0; j--) {
if (j)
printf("%d ", ans[j]);
else
printf("%d\n", ans[j]);
}
flag = 1;
break;
}
}
if (!flag) {
if (dfs(ss))
printf("Draw\n");
else
printf("Lose\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int a[N];
void solve() {
int n;
cin >> n;
map<int, int> m;
set<int> s;
int ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
s.insert(x);
m[x]++;
ans = max(ans, m[x]);
}
int k = s.size();
if (k == ans)
cout << ans - 1;
else
cout << min(ans, k);
}
int main() {
int t;
cin >> t;
while (t--) solve(), cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long *a = new long long[n];
for (long long i = 0; i < n; i++) cin >> a[i];
set<long long> s;
for (long long i = 0; i < n; i++) s.insert(a[i]);
long long count = 0;
for (auto a : s) {
if (a != 0) count++;
}
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long t;
cin >> t;
while (t--) {
long long x;
cin >> x;
cout << 1 << " " << x - 1 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
typedef struct {
char palavra[15];
} AArry;
typedef struct {
char palavra[15];
int pos;
} AHash;
int n, key, i, j, k;
AHash nome[400000];
char lista[400000][11];
int sum;
int h(char x[]) {
int s = strlen(x);
sum = 0;
int i;
int k;
for (i = 0; i < s; i++) {
sum = sum * 31 + x[i];
}
sum = (int)fabs((double)sum);
return sum % 400000;
}
int main(void) {
scanf("%d", &n);
i = 0;
while (i < n) {
scanf(" %[^\n]", lista[i]);
i++;
}
while (i >= 0) {
key = h(lista[i]);
for (j = key, k = 0; k < 400000; j++, k++) {
j = j % 400000;
if (nome[j].pos == 0) {
strcpy(nome[j].palavra, lista[i]);
nome[j].pos = 1;
printf("%s\n", lista[i]);
break;
} else {
if (strcmp(nome[j].palavra, lista[i]) == 0) break;
}
}
i--;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<long long int> s1, s2;
vector<long long int> v1, v2;
bool ans = false;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int x[5], y[5], a[4], b[4], c[4], d[4];
x[4] = 0;
y[4] = 0;
for (int i = 0; i < 4; i++) {
cin >> x[i] >> y[i];
s1.insert(x[i]);
s2.insert(y[i]);
x[4] += x[i];
y[4] += y[i];
}
x[4] /= 4;
y[4] /= 4;
for (auto it1 : s1) {
v1.push_back(it1);
}
for (auto it1 : s2) {
v2.push_back(it1);
}
for (int i = 0; i < 4; i++) {
cin >> a[i] >> b[i];
if (a[i] >= v1[0] && a[i] <= v1[1]) {
if (b[i] >= v2[0] && b[i] <= v2[1]) {
ans = true;
}
}
}
if (!ans) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 4; j++) {
c[j] = (a[(j + 1) % 4] - a[j]) * (y[i] - b[j]) -
(b[(j + 1) % 4] - b[j]) * (x[i] - a[j]);
}
bool ch = true;
for (int j = 0; j < 4; j++) {
x[i] = a[(j + 2) % 4];
y[i] = b[(j + 2) % 4];
d[j] = (a[(j + 1) % 4] - a[j]) * (y[i] - b[j]) -
(b[(j + 1) % 4] - b[j]) * (x[i] - a[j]);
c[j] *= d[j];
if (c[j] < 0) ch = false;
}
if (ch) ans = true;
}
}
if (ans)
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long Co(long long c[], long long b[]) {
long long prime = 1000003;
long long ans;
ans = (b[0] * c[0]) % prime;
ans += prime;
ans = ans % prime;
for (int i = 1; i < 11; i++) {
ans += b[i] * c[i];
ans = ans % prime;
ans += prime;
ans = ans % prime;
}
return ans;
}
long long poly(long long c[], long long x) {
long long ans;
ans = c[10];
for (int i = 9; i >= 0; i--) {
ans *= x;
ans = ans % 1000003;
ans += c[i];
ans += 1000003;
ans = ans % 1000003;
}
return ans;
}
int main() {
long long a[11];
for (long long i = 0; i < 11; i++) {
cout << '?' << " " << i << endl;
cout.flush();
cin >> a[i];
}
long long a0[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
long long a1[] = {288490, 10, 499979, 40, 499949, 200051,
999968, 714305, 874997, 222224, 700002};
long long a2[] = {966058, 884904, 258984, 206246, 229308, 179863,
736210, 190429, 361624, 345236, 641153};
long long a3[] = {570243, 545454, 393253, 44286, 339435, 125150,
644108, 731008, 361144, 778423, 467511};
long long a4[] = {975668, 247866, 366198, 824416, 397192, 365192,
815575, 879997, 462537, 275649, 389728};
long long a5[] = {5700, 4516, 230635, 968077, 876884, 46558,
820987, 851403, 694703, 559146, 941409};
long long a6[] = {673781, 61516, 487069, 217358, 919974, 96591,
770667, 647916, 929778, 401795, 793573};
long long a7[] = {905550, 799308, 83507, 356946, 856599, 777781,
46180, 928773, 951218, 682178, 611981};
long long a8[] = {479598, 854781, 166940, 340874, 422918, 395140,
646877, 370636, 525200, 526407, 270644};
long long a9[] = {730019, 650746, 292548, 630822, 426911, 850697,
488601, 274604, 617921, 258042, 779107};
long long a10[] = {404910, 950915, 220896, 410947, 30845, 962989,
30845, 410947, 220896, 950915, 404910};
long long coef[11];
coef[0] = Co(a, a0);
coef[1] = Co(a, a1);
coef[2] = Co(a, a2);
coef[3] = Co(a, a3);
coef[4] = Co(a, a4);
coef[5] = Co(a, a5);
coef[6] = Co(a, a6);
coef[7] = Co(a, a7);
coef[8] = Co(a, a8);
coef[9] = Co(a, a9);
coef[10] = Co(a, a10);
long long i = 0;
while (i < 1000003) {
if (poly(coef, i) == 0) {
break;
}
i++;
}
if (i < 1000003) {
cout << '!' << " " << i;
} else {
cout << '!' << " " << -1;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool checkBit(long long int n, long long int i) { return (n & (1LL << i)); }
long long int setBit(long long int n, long long int i) {
return (n | (1LL << i));
}
long long int resetBit(long long int n, long long int i) {
return (n & (~(1LL << i)));
}
int bit[64][2];
void solve() {
memset(bit, 0, sizeof(bit));
long long int l, r;
cin >> l >> r;
for (long long int i = 61; i >= 0; i--) {
if (checkBit(l, i)) {
bit[i][0] = 1;
}
if (checkBit(r, i)) {
bit[i][1] = 1;
}
}
int st_l, st_r;
st_l = -1, st_r = -1;
for (int i = 61; i >= 0; i--) {
if (bit[i][0] == 1 and st_l == -1) {
st_l = i;
}
if (bit[i][1] == 1 and st_r == -1) {
st_r = i;
}
}
if (st_l != st_r) {
int mx = 0;
for (int i = 61; i >= 0; i--) {
if (bit[i][1] == 1) mx++;
}
long long int temp2 = 0;
for (long long int i = st_r - 1; i >= 0; i--) {
temp2 += (1LL << i);
}
int mx2 = 0;
for (int i = 61; i >= 0; i--) {
if (checkBit(temp2, i)) {
mx2++;
}
}
if (mx > mx2) {
cout << r << "\n";
} else
cout << temp2 << "\n";
} else {
int mx = 0;
for (int i = 61; i >= 0; i--) {
if (bit[i][1] == 1) mx++;
}
long long int temp2 = 0;
int pos = -1;
for (long long int i = st_r; i >= 0; i--) {
if (bit[i][0] != bit[i][1]) {
pos = i - 1;
break;
} else {
if (bit[i][1] == 1) {
temp2 += (1LL << i);
}
}
}
for (long long int i = pos; i >= 0; i--) {
temp2 += (1LL << i);
}
int mx2 = 0;
for (int i = 61; i >= 0; i--) {
if (checkBit(temp2, i)) {
mx2++;
}
}
if (mx > mx2) {
cout << r << "\n";
} else
cout << temp2 << "\n";
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
vector<int> ans;
vector<pii> edgs;
int n, m;
bool marked[int(1e6)];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
ans.reserve(int(1e6));
int tsk;
cin >> tsk;
while (tsk--) {
cin >> n >> m;
edgs.resize(m);
for (auto &i : edgs) cin >> i.first >> i.second;
for (int i = 0; i < m; ++i)
if (!marked[edgs[i].first] && !marked[edgs[i].second]) {
marked[edgs[i].first] = marked[edgs[i].second] = true;
ans.push_back(i);
}
if (ans.size() >= n) {
ans.resize(n);
cout << "Matching\n";
for (auto i : ans) cout << i + 1 << ' ';
cout << '\n';
} else {
ans.clear();
for (int i = 1; i <= 3 * n; ++i)
if (!marked[i]) ans.push_back(i);
if (ans.size() > n) ans.resize(n);
cout << "IndSet\n";
for (auto i : ans) cout << i << ' ';
cout << '\n';
}
ans.clear();
for (int i = 1; i <= 3 * n; ++i) marked[i] = 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7;
int main() {
long long n, a, b;
cin >> n >> a >> b;
int flag = 0;
long long i, check;
for (i = 0; i <= N; i++) {
if ((n - a * i) % b == 0) {
check = (n - a * i) / b;
if (check >= 0 && check <= N) {
flag = 1;
break;
}
}
}
if (flag) {
cout << "YES" << endl;
cout << i << " " << check << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool myfunction(int i, int j) { return (i < j); }
long long t, a, b;
bool getAns(long long b, long long a, bool who) {
if (b == 0 || a == 0) return !who;
if (getAns(a, b % a, !who) == who) return who;
long long p = b / a;
if (p % (a + 1) % 2 == 0)
return who;
else
return !who;
}
int main() {
cin >> t;
while (t--) {
scanf("%I64d%I64d", &a, &b);
if (getAns(max(a, b), min(a, b), 1))
cout << "First" << endl;
else
cout << "Second" << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[2], b[2], c[2], m[2];
int main() {
for (int i = (0); i <= (1); i++) scanf("%d %d %d", &a[i], &b[i], &c[i]);
if (a[0] * b[1] != a[1] * b[0])
printf("1\n");
else {
if (a[0] != 0 && a[1] != 0) {
m[0] = a[1];
m[1] = a[0];
} else if (b[0] != 0 && b[1] != 0) {
m[0] = b[1];
m[1] = b[0];
} else {
for (int i = (0); i <= (1); i++) {
if (a[i] == 0 && b[i] == 0) {
if (c[i]) {
printf("0\n");
return 0;
}
}
}
printf("-1\n");
return 0;
}
if (c[0] * m[1] == c[1] * m[0])
printf("-1\n");
else
printf("0\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, m, i;
string c, b;
map<string, pair<string, string>> a;
cin >> n >> m;
for (i = 0; i < m; ++i) {
cin >> c >> b;
a[c] = {c, b};
}
for (i = 0; i < n; ++i) {
cin >> c;
if (c.length() > a[c].second.length())
cout << a[c].second;
else
cout << c;
cout << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], r[100005];
int c[10], d[10];
int i, j, k, n, m, x, y, z, t, s1, s2, s;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b, b + n);
reverse(b, b + n);
for (i = 0; i < m && i < k; i++) {
c[b[i]]++;
s += b[i];
}
t = i;
for (; i < n; i++) {
d[b[i]]++;
}
for (i = 0; i < 10; i++) {
z += c[i] + d[i];
}
if (m == k) {
for (i = 0; i < m; i++) {
printf("1 ");
}
for (i = 0; i < m; i++) {
printf("2 ");
}
printf("\n");
return 0;
}
for (i = 0; i < n; i++) {
x = a[i];
if (m < k) {
if (c[x] > 0) {
c[x]--;
printf("1 ");
} else {
printf("2 ");
}
} else {
if (d[x] > 0) {
d[x]--;
printf("1 ");
} else {
printf("2 ");
}
}
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n;
cin >> n;
vector<long long int> a(3), b(3);
for (long long int i = 0; i < 3; i++) {
cin >> a[i];
}
for (long long int i = 0; i < 3; i++) {
cin >> b[i];
}
long long int mx = min(a[0], b[1]) + min(a[1], b[2]) + min(a[2], b[0]);
long long int mn = 0;
for (long long int i = 0; i < 3; i++) {
mn = max(mn, a[i] - b[(i + 2) % 3] - b[i]);
}
cout << mn << " " << mx << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int main() {
int i;
scanf("%d %d", &N, &K);
int* A = new int[2 * N + 1];
for (i = 1; i <= 2 * N; i++) A[i] = i;
for (i = 1; i <= K; i++) swap(A[2 * i - 1], A[2 * i]);
for (i = 1; i <= 2 * N; i++) cout << A[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int N = 2000, M = 2000;
bool isQuad[N][M];
int prefixSum[N][M];
char grid[N][M];
int n, m;
inline pii quadLine(int i) {
if (i < n) return pii(i, 0);
return pii(n - 1, i - (n - 1));
}
inline bool inGrid(pii c) {
return (c.first >= 0 && c.first < n && c.second >= 0 && c.second < m);
}
inline pii operator+(pii const &a, pii const &b) {
return pii(a.first + b.first, a.second + b.second);
}
struct MinQueue {
deque<pii> q;
inline void insert(int t, int x) {
while (!q.empty() && q.back().second >= x) q.pop_back();
q.push_back(pii(t, x));
}
inline void advanceTo(int t) {
while (!q.empty() && q.front().first <= t) q.pop_front();
}
inline int min() const {
assert(!q.empty());
return q.front().second;
}
};
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%c", &grid[i][j]);
scanf("\n");
}
for (int i = 1; i < n - 1; i++)
for (int j = 1; j < m - 1; j++)
isQuad[i][j] =
(grid[i - 1][j] == grid[i][j] && grid[i + 1][j] == grid[i][j] &&
grid[i][j - 1] == grid[i][j] && grid[i][j + 1] == grid[i][j]);
int nQuadLines = n + m - 1;
for (int i = nQuadLines - 1; i >= 0; i--) {
pii cell = quadLine(i);
while (inGrid(cell)) {
int &ps = prefixSum[cell.first][cell.second];
if (isQuad[cell.first][cell.second])
++ps;
else
ps = 0;
pii next = cell + pii(-1, -1);
if (inGrid(next)) prefixSum[next.first][next.second] += ps;
cell = cell + pii(-1, 1);
}
}
int sum = 0;
MinQueue q;
for (int i = 0; i < nQuadLines; i++) {
pii cell = quadLine(i);
int j = 0, sqSize = 0;
while (inGrid(cell)) {
q.insert(j, prefixSum[cell.first][cell.second]);
sqSize = min(sqSize + 1, q.min());
sum += sqSize + 1;
q.advanceTo(j - sqSize);
cell = cell + pii(-1, 1), j++;
}
}
printf("%d\n", sum);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[1000000];
scanf("%s", s);
long long sum = 0;
long long ans = 0;
int len = strlen(s);
if (s[len - 1] == '4' || s[len - 1] == '8' || s[len - 1] == '0') ans++;
for (int j = 0; j < len - 1; j++) {
sum = 0;
if (s[j] == '4' || s[j] == '8' || s[j] == '0') {
ans++;
}
sum = (s[j] - 48) * 10 + s[j + 1] - 48;
if (sum % 4 == 0) {
ans += j + 1;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 5;
int n;
int a[maxn];
int sum[maxn][maxn];
int dp[maxn][maxn][3];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i][1] = sum[i - 1][1] + (a[i] == 1);
sum[i][2] = sum[i - 1][2] + (a[i] == 2);
}
sum[n + 1][2] = sum[n][2];
for (int i = 1; i <= n; i++) {
dp[i][i][1] = (a[i] == 1);
dp[i][i][2] = (a[i] == 2);
for (int j = i + 1; j <= n; j++) {
if (a[j] == 1)
dp[i][j][1] = max(dp[i][j - 1][1], dp[i][j - 1][2]) + (a[j] == 1);
else
dp[i][j][1] = dp[i][j - 1][1];
dp[i][j][2] = dp[i][j - 1][2] + (a[j] == 2);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
ans = max(ans, sum[i - 1][1] + sum[n][2] - sum[j][2] +
max(dp[i][j][1], dp[i][j][2]));
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100005], sp_min[17][100005], sp_max[17][100005];
vector<int> ans;
bool pre(int tt, int x) {
int t1 = log2(x - tt + 1), t2, t3;
t2 = min(sp_min[t1][tt], sp_min[t1][x - (1 << t1) + 1]);
t3 = max(sp_max[t1][tt], sp_max[t1][x - (1 << t1) + 1]);
if (t3 - t2 <= k) return 1;
return 0;
}
int bin(int tt) {
int l = tt, r = n, mid;
while (l < r) {
mid = r - ((r - l) / 2);
if (pre(tt, mid)) {
l = mid;
} else
r = mid - 1;
}
return l;
}
int main() {
ios_base::sync_with_stdio(false);
int i, j, x, maxval;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
sp_min[0][i] = a[i];
sp_max[0][i] = a[i];
}
for (i = 1; i < 17; i++) {
for (j = 1; j + (1 << i) - 1 <= n; j++) {
sp_min[i][j] = min(sp_min[i - 1][j], sp_min[i - 1][j + (1 << (i - 1))]);
sp_max[i][j] = max(sp_max[i - 1][j], sp_max[i - 1][j + (1 << (i - 1))]);
}
}
maxval = -1;
for (i = 1; i <= n; i++) {
x = bin(i);
if (x - i + 1 > maxval) {
maxval = x - i + 1;
ans.clear();
ans.push_back(i);
} else if (x - i + 1 == maxval)
ans.push_back(i);
}
cout << maxval << " " << ans.size() << endl;
for (i = 0; i < ans.size(); i++)
cout << ans[i] << " " << ans[i] + maxval - 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, f[1000005], g[1000005];
char s[1000005], s2[1000005];
namespace PAM {
int fa[1000005] = {1, 1}, ch[1000005][26], len[1000005] = {0, -1}, last, sz = 1,
anc[1000005], dif[1000005];
void extend(int x) {
int p = last, c = s[x] - 'a';
while (s[x] != s[x - len[p] - 1]) p = fa[p];
if (!ch[p][c]) {
int q = fa[p];
len[++sz] = len[p] + 2;
while (s[x] != s[x - len[q] - 1]) q = fa[q];
fa[sz] = ch[q][c], dif[sz] = len[sz] - len[fa[sz]];
anc[sz] = dif[sz] == dif[fa[sz]] ? anc[fa[sz]] : fa[sz];
ch[p][c] = sz;
}
last = ch[p][c];
}
} // namespace PAM
using namespace PAM;
int main() {
scanf("%s", s + 1), n = strlen(s + 1);
for (int i = 1; i <= n; i += 2) s2[i] = s[(i + 1) / 2];
for (int i = 2; i <= n; i += 2) s2[i] = s[n - i / 2 + 1];
for (int i = 1; i <= n; i++) s[i] = s2[i];
f[0] = 1;
for (int i = 1; i <= n; i++) {
extend(i);
for (int x = last; x; x = anc[x]) {
g[x] = f[i - len[anc[x]] - dif[x]];
if (anc[x] != fa[x]) g[x] = (g[x] + g[fa[x]]) % mod;
if (!(i & 1)) f[i] = (f[i] + g[x]) % mod;
}
}
printf("%d\n", f[n]);
}
| 10 |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
using ll = long long;
constexpr int inf=1e9+7;
constexpr ll longinf=1LL<<60 ;
constexpr ll mod=1e9+7 ;
template<typename T, typename S>
struct LazySegmentTree{
private:
int n;
vector<T> node;
vector<S> lazy;
T E0;
S E1;
inline void updatef(S& lazy,S& value){
lazy += value;
}
inline void calculatef(T& node,S& lazy,int len){
node += lazy ; //区間maxとか
}
inline T queryf(T& x,T& y){
return min(x, y);
}
public:
LazySegmentTree(int sz,T nodeE,S lazyE ):E0(nodeE), E1(lazyE){
n=1;
while(n<sz)n<<=1;
node.resize(2*n-1,E0);
lazy.resize(2*n-1,E1);
}
LazySegmentTree(vector<T>& v,T E0,S E1 ):E0(E0),E1(E1){
n=1;
int sz=v.size();
while(n<sz)n<<=1;
node.resize(2*n-1,E0);
lazy.resize(2*n-1,E1);
rep(i,sz)node[i+n-1] = v[i];
for(int i=n-2; i>=0; --i){
node[i] = queryf(node[2*i+1],node[2*i+2]);
}
}
void eval(int k,int l,int r){
if(lazy[k]==E1)return ;
calculatef(node[k], lazy[k], r-l);
if(r-l>1){
updatef(lazy[2*k+1], lazy[k]);
updatef(lazy[2*k+2], lazy[k]);
}
lazy[k]=E1;
}
void update(int a, int b, S x,int k=0,int l=0,int r=-1){
if(r<0)r=n;
eval(k,l,r);
if(r<=a||b<=l)return;
if(a<=l&&r<=b){
updatef(lazy[k], x);
eval(k,l,r);
}
else {
update(a,b,x,2*k+1,l,(l+r)/2);
update(a,b,x,2*k+2,(l+r)/2,r);
node[k]=queryf(node[2*k+1], node[2*k+2]);
}
}
T query(int a,int b,int k=0,int l=0,int r=-1){
if(r<0)r=n;
eval(k,l,r);
if(r<=a||b<=l)return E0;
if(a<=l&&r<=b)return node[k];
T xl=query(a,b,2*k+1,l,(l+r)/2);
T xr=query(a,b,2*k+2,(l+r)/2,r);
return queryf(xl, xr);
}
};
void solve(){
int n;
cin>>n;
vector<int> a(n);
rep(i,n)cin>>a[i];
using LSG = LazySegmentTree<int,int>;
vector<LSG> sg(n,LSG(0,0,0));
vector<int> dp(n+1, inf);
dp[n]=0;
sg[n-1]=LSG(dp,inf,0);
int N = 1;
while(N<n+1)N<<=1;
for(int i=n-2;i>=1;--i){
int r = i+a[i];
rep(j,n+1)dp[j]=inf;
for(int j=i+1;j<=r;j++){
int res = sg[j].query(r+1, N);
dp[j]=min(res,inf);
}
sg[i]=LSG(dp,inf,0);
for(int j=i+1;j<=r;j++)sg[j].update(0,N,1);
}
int r = a[0];
int ans = inf;
for(int i=1;i<=r;i++)ans = min(ans,sg[i].query(r+1, N));
cout<<ans<<endl;
}
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
int t;
cin>>t;
while(t--)solve();
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
long long a, b, k;
cin >> k >> a >> b;
if (a <= 0 and b >= 0) {
cout << b / k + 1 - a / k << endl;
return 0;
}
if (b < 0) {
a = -a;
b = -b;
swap(a, b);
}
a--;
cout << b / k - a / k << endl;
return 0;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 500007, __ = _ << 1, inf = 0x3f3f3f3f;
struct cxk {
int v, len;
cxk(int v_ = inf, int len_ = 0) { v = v_, len = len_; }
int f(int x) { return min(x + len, v); }
friend cxk operator+(cxk a, cxk b) {
return cxk(min(a.v + b.len, b.v), a.len + b.len);
}
};
struct sgt {
static const int _t = __ << 2;
cxk t[_t];
int mx[_t];
void up(int x) {
t[x] = t[(x << 1)] + t[(x << 1 | 1)];
mx[x] = max(mx[(x << 1)], mx[(x << 1 | 1)]);
}
void plant(int x, int l, int r) {
t[x] = cxk(), mx[x] = -inf;
if (l == r) return;
plant((x << 1), l, ((l + r) >> 1)),
plant((x << 1 | 1), ((l + r) >> 1) + 1, r), up(x);
}
void change(int x, int l, int r, int tar, int dlt) {
if (l == r) {
t[x].len++, t[x].v = dlt, mx[x] = max(mx[x], dlt);
return;
}
if (tar <= ((l + r) >> 1))
change((x << 1), l, ((l + r) >> 1), tar, dlt);
else
change((x << 1 | 1), ((l + r) >> 1) + 1, r, tar, dlt);
up(x);
}
int findlen(int x, int l, int r, int tl, int tr) {
if (tl <= l && r <= tr) return t[x].len;
if (tr <= ((l + r) >> 1))
return findlen((x << 1), l, ((l + r) >> 1), tl, tr);
if (tl > ((l + r) >> 1))
return findlen((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr);
return findlen((x << 1), l, ((l + r) >> 1), tl, tr) +
findlen((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr);
}
int findmx(int x, int l, int r, int tl, int tr) {
if (tl <= l && r <= tr) return mx[x];
if (tr <= ((l + r) >> 1))
return findmx((x << 1), l, ((l + r) >> 1), tl, tr);
if (tl > ((l + r) >> 1))
return findmx((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr);
return max(findmx((x << 1), l, ((l + r) >> 1), tl, tr),
findmx((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr));
}
cxk findcxk(int x, int l, int r, int tl, int tr) {
if (tl <= l && r <= tr) return t[x];
if (tr <= ((l + r) >> 1))
return findcxk((x << 1), l, ((l + r) >> 1), tl, tr);
if (tl > ((l + r) >> 1))
return findcxk((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr);
return findcxk((x << 1), l, ((l + r) >> 1), tl, tr) +
findcxk((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr);
}
} t;
int n, val[_], rk[_] = {0};
pair<int, int> temp[_];
int able(int x) { return t.findmx(1, 1, n, 1, x) <= -t.findlen(1, 1, n, 1, x); }
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty();
for (int i = 1; i <= n; i++) val[i] = ty(), temp[i] = make_pair(val[i], i);
sort(temp + 1, temp + n + 1);
for (int i = 1; i <= n; i++) rk[temp[i].second] = i;
t.plant(1, 1, n);
for (int i = 1; i <= n; i++) {
t.change(1, 1, n, rk[i], temp[rk[i]].first);
int l = 1, r = n, ans = -1;
while (r >= l) {
int mid = (l + r) >> 1;
if (able(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
if (ans < 0)
cout << t.findcxk(1, 1, n, 1, n).f(0) << lf;
else {
int ps = t.findlen(1, 1, n, 1, ans);
if (ans >= n)
cout << -ps << lf;
else
cout << t.findcxk(1, 1, n, ans + 1, n).f(-ps) << lf;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int min(int x, int y) { return x < y ? x : y; }
int dp[101][10001];
char s[10001];
int que[10001];
int ans[10001];
int f_abs(int x, int l) {
if (x < 0) x = -x;
x = min(x, l - x);
return x;
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int i, j, top;
memset(ans, 0, sizeof(ans));
top = 999;
for (i = 0; i < n; i++) {
scanf("%s", s);
if (!top) continue;
top = 0;
for (j = 0; j < m; j++) {
dp[i][j] = -1;
if (s[j] == '1') {
que[top++] = j;
dp[i][j] = 0;
}
}
if (!top) continue;
int now = 0;
for (j = 0; j < m; j++) {
if (s[j] == '1')
now++, dp[i][j] = 0;
else
dp[i][j] = min(f_abs(j - que[(now + top - 1) % top], m),
f_abs(j - que[now % top], m));
}
}
if (!top) {
printf("-1\n");
continue;
}
int res = -1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
ans[j] += dp[i][j];
}
}
for (i = 0; i < m; i++) {
if (res == -1 || res > ans[i]) res = ans[i];
}
printf("%d\n", res);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct rect {
int x1, x2, y1, y2;
int maxval;
rect() {}
rect(int a, int b, int c, int d) {
x1 = a;
y1 = b;
x2 = c;
y2 = d;
}
};
vector<rect> rec;
int n, m;
string s[1111];
vector<int> mustx, musty;
vector<int> vx, vy;
void Print(rect fuk) {
cout << fuk.x1 + 1 << " ";
cout << fuk.y1 + 1 << " ";
cout << fuk.x2 + 1 << " ";
cout << fuk.y2 + 1 << endl;
}
bool haveedge(int a, int b, int c, int d) {
if (abs(a - c) + 1 < 3) return 0;
if (abs(b - d) + 1 < 3) return 0;
for (int j = b; j < d + 1; j++)
if (s[a][j] == '.' || s[c][j] == '.') return 0;
for (int i = a; i < c + 1; i++)
if (s[i][b] == '.' || s[i][d] == '.') return 0;
return 1;
}
int Paint(rect a, rect b) {
vector<pair<int, pair<int, int> > > ex, ey;
ex.push_back({a.x1, {a.y1, a.y2}});
ex.push_back({a.x2, {a.y1, a.y2}});
ex.push_back({b.x1, {b.y1, b.y2}});
ex.push_back({b.x2, {b.y1, b.y2}});
ey.push_back({a.y1, {a.x1, a.x2}});
ey.push_back({a.y2, {a.x1, a.x2}});
ey.push_back({b.y1, {b.x1, b.x2}});
ey.push_back({b.y2, {b.x1, b.x2}});
sort(ex.begin(), ex.end());
;
sort(ey.begin(), ey.end());
;
for (int i = 1; i < ex.size(); i++) {
if (ex[i].first == ex[i - 1].first) {
pair<int, int> a, b;
a = ex[i].second;
b = ex[i - 1].second;
if (a.first > b.second + 1 || b.first > a.second + 1) continue;
b.first = min(b.first, a.first);
b.second = max(b.second, a.second);
ex[i - 1].second = b;
ex.erase(ex.begin() + i, ex.begin() + i + 1);
i--;
}
}
for (int i = 1; i < ey.size(); i++) {
if (ey[i].first == ey[i - 1].first) {
pair<int, int> a, b;
a = ey[i].second;
b = ey[i - 1].second;
if (a.first > b.second + 1 || b.first > a.second + 1) continue;
b.first = min(b.first, a.first);
b.second = max(b.second, a.second);
ey[i - 1].second = b;
ey.erase(ey.begin() + i, ey.begin() + i + 1);
i--;
}
}
int ret = 0;
for (int i = 0; i < ex.size(); i++)
ret += ex[i].second.second - ex[i].second.first + 1;
for (int i = 0; i < ey.size(); i++)
ret += ey[i].second.second - ey[i].second.first + 1;
for (int i = 0; i < ex.size(); i++) {
for (int j = 0; j < ey.size(); j++) {
if (ex[i].first >= ey[j].second.first &&
ex[i].first <= ey[j].second.second)
if (ey[j].first >= ex[i].second.first &&
ey[j].first <= ex[i].second.second) {
ret--;
}
}
}
return ret;
}
int paint(rect fuk) {
int a = fuk.x1;
int b = fuk.y1;
int c = fuk.x2;
int d = fuk.y2;
int ret = 0;
for (int j = b; j < d + 1; j++) {
if (s[a][j] == '#') {
s[a][j] = 'f';
ret++;
}
if (s[c][j] == '#') {
s[c][j] = 'f';
ret++;
}
}
for (int i = a; i < c + 1; i++) {
if (s[i][b] == '#') {
s[i][b] = 'f';
ret++;
}
if (s[i][d] == '#') {
s[i][d] = 'f';
ret++;
}
}
return ret;
}
void unpaint(rect fuk) {
int a = fuk.x1;
int b = fuk.y1;
int c = fuk.x2;
int d = fuk.y2;
for (int j = b; j < d + 1; j++) s[a][j] = '#', s[c][j] = '#';
for (int i = a; i < c + 1; i++) s[i][b] = '#', s[i][d] = '#';
}
int ltmskx[1111], ltmsky[1111];
int lgmskx[1111111], lgmsky[1111111];
bool cmp(int a, int b) { return rec[a].maxval > rec[b].maxval; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
int tot = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') tot++;
}
}
for (int i = 0; i < n; i++) {
int cnt = 0;
bool f = 0;
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') {
cnt++;
if (cnt > 4) {
f = 1;
break;
}
if (i - 1 < 0 || s[i - 1][j] == '.') {
f = 1;
break;
}
if (i + 1 >= n || s[i + 1][j] == '.') {
f = 1;
break;
}
}
}
if (f) mustx.push_back(i);
}
for (int j = 0; j < m; j++) {
int cnt = 0;
bool f = 0;
for (int i = 0; i < n; i++) {
if (s[i][j] == '#') {
cnt++;
if (cnt > 4) {
f = 1;
break;
}
if (j - 1 < 0 || s[i][j - 1] == '.') {
f = 1;
break;
}
if (j + 1 >= m || s[i][j + 1] == '.') {
f = 1;
break;
}
}
}
if (f) musty.push_back(j);
}
if (mustx.size() > 4 || musty.size() > 4) {
cout << "NO" << endl;
;
return 0;
}
for (int i = 0; i < mustx.size(); i++)
for (int j = -1; j < 2; j++) {
int x = mustx[i] + j;
if (x >= 0 && x < n) vx.push_back(x);
}
for (int i = 0; i < musty.size(); i++)
for (int j = -1; j < 2; j++) {
int y = musty[i] + j;
if (y >= 0 && y < m) vy.push_back(y);
}
sort(vx.begin(), vx.end());
;
vx.erase(unique(vx.begin(), vx.end()), vx.end());
sort(vy.begin(), vy.end());
;
vy.erase(unique(vy.begin(), vy.end()), vy.end());
for (int i = 0; i < vx.size(); i++)
for (int j = 0; j < mustx.size(); j++) {
if (vx[i] == mustx[j]) {
ltmskx[i] = (1 << j);
break;
}
}
for (int i = 0; i < vy.size(); i++)
for (int j = 0; j < musty.size(); j++) {
if (vy[i] == musty[j]) {
ltmsky[i] = (1 << j);
break;
}
}
int mx = 0;
for (int x1 = 0; x1 < vx.size(); x1++)
for (int x2 = x1 + 1; x2 < vx.size(); x2++) {
for (int y1 = 0; y1 < vy.size(); y1++)
for (int y2 = y1 + 1; y2 < vy.size(); y2++) {
if (haveedge(vx[x1], vy[y1], vx[x2], vy[y2])) {
lgmskx[rec.size()] = ltmskx[x1] | ltmskx[x2];
lgmsky[rec.size()] = ltmsky[y1] | ltmsky[y2];
if (mustx.size() - __builtin_popcount(lgmskx[rec.size()]) > 2)
continue;
if (musty.size() - __builtin_popcount(lgmsky[rec.size()]) > 2)
continue;
rec.push_back(rect(vx[x1], vy[y1], vx[x2], vy[y2]));
rec[rec.size() - 1].maxval =
paint(rect(vx[x1], vy[y1], vx[x2], vy[y2]));
mx = max(mx, rec[rec.size() - 1].maxval);
unpaint(rect(vx[x1], vy[y1], vx[x2], vy[y2]));
}
}
}
vector<int> realrec;
for (int i = 0; i < rec.size(); i++) {
if (rec[i].maxval + mx >= tot) {
realrec.push_back(i);
}
}
sort(realrec.begin(), realrec.end(), cmp);
for (int pi = 0; pi < realrec.size(); pi++)
for (int pj = pi; pj < realrec.size(); pj++) {
int i = realrec[pi];
int j = realrec[pj];
if ((lgmskx[i] | lgmskx[j]) != (1 << mustx.size()) - 1) continue;
if ((lgmsky[i] | lgmsky[j]) != (1 << musty.size()) - 1) continue;
int mxres = rec[i].maxval + rec[j].maxval;
if (mxres < tot) continue;
int res = Paint(rec[i], rec[j]);
if (res == tot) {
cout << "YES" << endl;
;
Print(rec[i]);
Print(rec[j]);
return 0;
}
}
cout << "NO" << endl;
;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int A[55];
int main() {
int n;
long long int m;
cin >> n >> m;
if (n == 1) {
printf("%d\n", 1);
return 0;
}
long long int tot = 1LL << (n - 1);
int l = 1;
int r = n;
for (int i = 1; i < n + 1; i++) {
if (m > tot / 2) {
A[r] = i;
m -= tot / 2;
r--;
} else {
A[l] = i;
l++;
}
tot /= 2;
}
for (int i = 1; i < n + 1; i++) {
printf("%d ", A[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[10000];
long long int k, w[26];
cin >> s >> k;
long long int max = 0;
for (int i = 0; i < 26; i++) {
cin >> w[i];
if (w[i] > max) max = w[i];
}
long long int ans = 0;
for (int i = 0; i < strlen(s); i++) ans += w[s[i] - 'a'] * (i + 1);
for (int i = strlen(s); i < k + strlen(s); i++) ans += max * (i + 1);
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, mi, mx;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
long long a[n];
for (int i = 0; i < n && cin >> a[i]; i++)
;
cout << abs(a[0] - a[1]) << " " << abs(a[0] - a[n - 1]) << endl;
for (int i = 1; i < n - 1; i++) {
cout << min(abs((a[i]) - (a[i - 1])), abs((a[i]) - (a[i + 1]))) << " "
<< max(abs((a[i]) - (a[n - 1])), abs((a[i]) - (a[0]))) << endl;
}
cout << abs((a[n - 1]) - (a[n - 2])) << " " << abs(a[n - 1] - a[0]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const long long mod = 1e9 + 7;
const int MAX = 300009;
long long n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long t = 9, ans = 0, c = 1;
while (n - t > 0) {
ans += t * c;
n -= t;
t *= 10;
c++;
}
ans += max(0ll, n * c);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char mp[5][5];
int main() {
for (int i = 0; i < 3; i++) {
scanf("%s", mp[i]);
getchar();
}
int flag = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j <= i; j++) {
if (mp[i][j] != mp[2 - i][2 - j]) {
flag = 1;
break;
}
}
if (flag == 1) break;
}
if (flag == 0)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int solve(string& s, int i, int n, char p, string& ans) {
ans = s.substr(0, i);
int j;
char c = s[i];
char d;
int fix = 0;
for (d = c + 1; d <= p; d++) {
if (i - 1 >= 0 && s[i - 1] == d) continue;
if (i - 2 >= 0 && s[i - 2] == d) continue;
fix = 1;
break;
}
if (!fix) return 0;
ans.push_back(d);
for (j = i + 1; j < n; j++) {
fix = 0;
for (char ch = 'a'; ch <= p; ch++) {
if (j - 1 >= 0 && ans[j - 1] == ch) continue;
if (j - 2 >= 0 && ans[j - 2] == ch) continue;
ans.push_back(ch);
fix = 1;
break;
}
if (!fix) return 0;
}
return 1;
}
int main() {
int n, p, i, j;
cin >> n >> p;
string s;
cin >> s;
string ans;
for (i = n - 1; i >= 0; i--) {
if (solve(s, i, n, (char)(p - 1 + 'a'), ans)) {
cout << ans << '\n';
return 0;
}
}
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long n, r1, c1, r2, c2, m;
char a[50][50];
vector<pair<long long, long long> > x, y;
bool first = true;
long long vis[50][50];
long long dr[4] = {-1, +1, 0, 0};
long long dc[4] = {0, 0, -1, +1};
void ff(long long i, long long j) {
if (i < 0 or i >= n or j < 0 or j >= m) return;
if (first)
x.push_back({i, j});
else
y.push_back({i, j});
for (long long k = 0; k < 4; k++) {
if (i + dr[k] < 0 or i + dr[k] >= n or j + dc[k] < 0 or j + dc[k] >= m)
continue;
if (vis[i + dr[k]][j + dc[k]]) continue;
if (a[i + dr[k]][j + dc[k]] == '0') {
vis[i + dr[k]][j + dc[k]] = 1;
ff(i + dr[k], j + dc[k]);
}
}
}
void Input() {
cin >> n >> r1 >> c1 >> r2 >> c2;
m = n;
}
void Solve() {
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) cin >> a[i][j];
r1--, c1--, r2--, c2--;
memset(vis, 0, sizeof(vis));
ff(r1, c1);
memset(vis, 0, sizeof(vis));
first = false;
ff(r2, c2);
long long ans = INT_MAX;
for (auto it : x)
for (auto jt : y)
ans =
min(ans, abs(it.first - jt.first) * abs(it.first - jt.first) +
abs(it.second - jt.second) * abs(it.second - jt.second));
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
while (T--) {
Input();
Solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
class ShortestPath {
public:
vector<vector<pair<long long int, long long int>>> weighted;
set<pair<long long int, pair<long long int, long long int>>> triplets;
private:
vector<vector<long long int>> parent;
set<pair<long long int, long long int>> vis;
long long int dis = -1, lastNode = -1;
void findShortestDijkstra(long long int src, long long int dest) {
queue<pair<long long int, pair<long long int, long long int>>> q;
q.push({0, {1, 1}});
while (!q.empty()) {
auto dist = q.front().first, from = q.front().second.second,
par = q.front().second.first;
q.pop();
if (par == dest) {
dis = dist;
lastNode = from;
break;
}
for (auto x : weighted[par]) {
long long int node = x.first, wt = x.second;
if (vis.count({node, par})) continue;
auto sea = make_pair(from, make_pair(par, node));
if (!(triplets.find(sea) != triplets.end())) {
parent[node][par] = dist + wt;
q.push({dist + wt, {node, par}});
vis.insert({node, par});
}
}
}
}
public:
vector<long long int> dijkstra() {
long long int n = weighted.size() - 1;
parent.clear(), parent.resize(n + 1, vector<long long int>(n + 1, 0));
parent[1][1] = 0;
findShortestDijkstra(1, n);
if (dis == -1) {
return vector<long long int>{-1};
}
long long int node = lastNode;
vector<long long int> res = {n, node};
while (node != 1) {
dis--;
for (long long int i = 1; i < n; i++) {
if (parent[node][i] == dis) {
res.emplace_back(i);
node = i;
break;
}
}
}
reverse(res.begin(), res.end());
return res;
}
};
vector<vector<pair<long long int, long long int>>> buildAdjList(
long long int n, long long int e) {
vector<vector<pair<long long int, long long int>>> adj(n + 1);
for (long long int i = 0; i < e; i++) {
long long int u, v;
cin >> u >> v;
adj[u].push_back({v, 1});
adj[v].push_back({u, 1});
}
return adj;
}
void solve() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, e, k;
cin >> n >> e >> k;
ShortestPath s;
s.weighted = buildAdjList(n, e);
for (long long int i = 0; i < k; i++) {
long long int t1, t2, t3;
cin >> t1 >> t2 >> t3;
s.triplets.insert({t1, {t2, t3}});
}
vector<long long int> res = s.dijkstra();
if (res[0] != -1) {
cout << res.size() - 1 << "\n";
}
for (auto it : res) cout << it << " ";
;
cout << "\n";
return;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int t;
char num[5] = {'0', '1', '2', '5', '8'};
int h, m;
string s;
vector<string> times;
string reverse(string str)
{
string res;
for (int i = str.size() - 1; i >= 0; i--)
{
if(str[i] == '2')
res += '5';
else if(str[i] == '5')
res += '2';
else
res += str[i];
}
return res;
}
bool inNum(){
bool same[5] = {false};
for (int i = 0; i < 5; ++i) {
if(i != 2){
for (int j = 0; j < 5; ++j) {
if(s[i] == num[j])
same[i] = true;
}
}
}
return same[0] && same[1] && same[3] && same[4];
}
bool isRight(string string1){
int minute = stoi(reverse(string1.substr(0, 2)));
int hour = stoi(reverse(string1.substr(3, 2)));
int hour2 = stoi(string1.substr(0, 2));
int minute2 = stoi(string1.substr(3, 2));
if(minute <= m - 1 && hour <= h - 1 && hour2 <= h - 1 && minute2 <= m - 1)
return true;
else return false;
}
int main() {
cin >> t;
for (int j1 = 0; j1 < 5; ++j1) {
for (int j2 = 0; j2 < 5; ++j2) {
for (int j3 = 0; j3 < 5; ++j3) {
for (int j4 = 0; j4 < 5; ++j4) {
string temp = {num[j1], num[j2], ':', num[j3], num[j4]};
times.push_back(temp);
}
}
}
}
for (int i = 0; i < t; ++i) {
cin >> h >> m;
cin >> s;
if(inNum() && isRight(s)){
cout << s << endl;
} else{
int is0 = true;
int hour2 = stoi(s.substr(0, 2));
int minute2 = stoi(s.substr(3, 2));
int ans = 0;
for (int j = 1; j < 625; ++j) {
int hour = stoi(times[j].substr(0, 2));
int minute = stoi(times[j].substr(3, 2));
if(isRight(times[j])){
if(hour > hour2 || (hour == hour2 && minute > minute2)){
ans = j;
is0 = false;
break;
}
}
}
if(is0) cout << "00:00" << endl;
else cout << times[ans] << endl;
}
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAX = 100002;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const double MOD = 1000000007;
using ull = unsigned long long;
int main() {
int n, ei = 0, oi = 0, o = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
(x & 1) ? ++o, oi = i : ei = i;
}
cout << (o == 1 ? oi : ei);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
struct node {
int w, pos, opt;
};
node x[N * 2];
int tot;
int s[N], d[N], e[N], k[N];
int c[N * 4];
int n;
int g[N];
bool check(int i, int j) {
if (d[i] > 0 && d[j] > 0) {
if (s[i] > s[j]) return true;
}
if (d[i] < 0 && d[j] < 0) {
if (s[i] < s[j]) return true;
}
return false;
}
bool cmp(node a, node b) { return a.w < b.w; }
int lowbit(int xx) { return xx & (-xx); }
void add(int xx, int w) {
for (; xx <= tot; xx += lowbit(xx)) c[xx] += w;
}
int sum(int xx) {
int ret = 0;
for (; xx; xx -= lowbit(xx)) ret += c[xx];
return ret;
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &s[i], &d[i]);
e[i] = s[i] + d[i];
s[i] = s[i] * N - i;
e[i] = e[i] * N - i;
k[i] = i;
tot++;
x[tot].w = s[i];
x[tot].pos = i;
x[tot].opt = 1;
tot++;
x[tot].w = e[i];
x[tot].pos = i;
x[tot].opt = 2;
}
for (i = 1; i <= n - 1; i++) {
for (j = i + 1; j <= n; j++) {
if (check(k[i], k[j])) {
swap(k[i], k[j]);
}
}
}
int pos;
sort(x + 1, x + 1 + tot, cmp);
for (i = 1; i <= tot; i++) {
pos = x[i].pos;
if (x[i].opt == 1)
s[pos] = i;
else
e[pos] = i;
}
for (i = 1; i <= n; i++) add(s[i], 1);
int ans = 0;
int l, r;
for (i = 1; i <= n; i++) {
j = k[i];
l = s[j];
r = e[j];
if (l > r) swap(l, r);
if (d[j] == 0) continue;
ans += sum(r - 1) - sum(l);
add(s[j], -1);
add(e[j], 1);
}
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
int main() {
int i, j, p;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &p);
for (j = 1; j * (j + 1) / 2 <= p; j++)
;
ans ^= j - 1;
}
ans ? puts("NO") : puts("YES");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, d[100001], i = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> d[i];
}
while (i * (i + 1) / 2 < k) {
i++;
}
k -= i * (i - 1) / 2;
cout << d[k];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, vs, a, sum;
cin >> n >> k >> x;
vs = n - k;
sum = x * k;
for (int i = 1; i <= vs; i++) {
cin >> a;
sum += a;
}
cout << sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000000 + 10;
int a[maxn], b[maxn], c[maxn];
int ok_a[maxn], ok_b[maxn];
int main() {
int n, m, p;
scanf("%d %d %d", &n, &m, &p);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
if (a[i] % p == 0) {
ok_a[i] = 1;
}
}
for (int i = 0; i < m; i++) {
scanf("%d", b + i);
if (b[i] % p == 0) {
ok_b[i] = 1;
}
}
int pos1 = 0, pos2 = 0;
for (int i = 0; i < n; i++) {
if (!ok_a[i]) {
pos1 = i;
break;
}
}
for (int i = 0; i < m; i++) {
if (!ok_b[i]) {
pos2 = i;
break;
}
}
int ans = pos1 + pos2;
printf("%d\n", ans);
getchar();
getchar();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int64_t, int64_t> pi[1 << 18];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t t;
cin >> t;
while (t--) {
int64_t n;
cin >> n;
int64_t ans = 0;
for (int64_t i = 1; i <= n; i++) {
cin >> pi[i].first >> pi[i].second;
ans += pi[i].second;
}
sort(pi + 1, pi + 1 + n);
int64_t b = 0;
for (int64_t i = 1; i <= n; i++) {
b = max(b, pi[i].first - i + 1);
}
priority_queue<int64_t> pq;
int64_t pos = 1;
while (b < n) {
while (pos <= n and pi[pos].first <= b) {
pq.push(pi[pos].second);
pos++;
}
ans -= pq.top();
pq.pop();
b++;
}
cout << ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, a, b) for (int i = (int)(a); i >= (int)b; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
#define per(i, r, l) for (int i = (r); i >= (l); i--)
#define ms(x, y) memset(x, y, sizeof(x))
#define SZ(x) int(x.size())
#define fk cerr<<"fk"<<endl
#define db(x) cerr<<(#x)<<'='<<(x)<<endl
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef long long i64;
typedef vector<i64> vi64;
typedef vector<vi64> vvi64;
typedef pair<i64, i64> pi64;
typedef double ld;
template<class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; }
//1.integer overflow (1e5 * 1e5) (2e9 + 2e9)
//2.runtime error
//3.boundary condition
const int N=4000;
int tc,n,a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout<<fixed;
#ifdef LOCAL_DEFINE
freopen("input.txt", "r", stdin);
#endif
cin>>tc;
while(tc--){
int maxx=-1;
cin>>n;
for1(i, n){
cin>>a[i];
uax(maxx,a[i]);
}
int ans=-1;
for(int j=1; j<=n; ++j){
int sum=0;
for(int i=1; i<=j; ++i) sum+=a[i];
int now=j+1,res=0;
bool ok=true;
while(now<=n){
res+=a[now];
++now;
if(res>sum){
ok=false;
break;
}
if(res==sum){
res=0;
}
}
if(res) ok=false;
if(ok){
ans=sum;
break;
}
}
int cnt=0,ns=0;
for(int i=1; i<=n; ++i){
ns+=a[i];
if(ns==ans){
ns=0;
++cnt;
}
}
cout<<n-cnt<<'\n';
}
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 7;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const double EPS = 1e-8;
int c[26];
char s[N], t[N];
void count(int n, char s[], int c[]) {
memset(c, 0, sizeof(c[0]) * 26);
for (int i = (0); i < (n); ++i) ++c[s[i] - 'a'];
}
void solve() {
int n = strlen(s), m = strlen(t), L = -1, last = -1;
count(n, s, c);
for (int i = (0); i < (min(n, m)); ++i) {
for (int j = (t[i] - 'a' + 1); j < (26); ++j)
if (c[j] > 0) {
L = i;
break;
}
if (!c[t[i] - 'a']) break;
--c[t[i] - 'a'], last = i;
}
if (n > m && last == m - 1) L = m;
if (L == -1) {
puts("-1");
return;
}
count(n, s, c);
for (int i = (0); i < (L); ++i) putchar(t[i]), --c[t[i] - 'a'];
for (int j = (0); j < (26); ++j)
if (c[j] > 0 && ('a' + j) > t[L]) {
putchar('a' + j), --c[j];
break;
}
for (int i = (L + 1); i < (n); ++i)
for (int j = (0); j < (26); ++j)
if (c[j] > 0) {
putchar('a' + j), --c[j];
break;
}
}
int main() {
scanf("%s %s", s, t);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265359;
const int ans = 0x10, mod = 1000000007;
int n, dp[100500][64];
char f[100500][8];
void count(int x, int y, int mask, int nmask) {
if (x == n) return;
if (y >= 3)
dp[x + 1][nmask] = (dp[x + 1][nmask] + dp[x][mask]) % mod;
else {
int tmask = 1 << y;
if (f[x][y] == 'X' || f[x][y] == 'O' || mask & tmask)
count(x, y + 1, mask, nmask);
else {
if (y < 2 && f[x][y + 1] != 'X' && f[x][y + 1] != 'O' &&
!(mask & (1 << (y + 1)))) {
if (f[x][y + 2] == 'O' || (y > 0 && f[x][y - 1] == 'O'))
count(x, y + 2, mask, nmask | ans);
else
count(x, y + 2, mask, nmask);
}
if (x < n - 1 && f[x + 1][y] != 'X' && f[x + 1][y] != 'O') {
if (f[x + 2][y] == 'O' || (x > 0 && f[x - 1][y] == 'O'))
count(x, y + 1, mask, nmask | tmask | ans);
else
count(x, y + 1, mask, nmask | tmask);
}
}
}
}
int main() {
cin >> n;
for (int i = 0; i < 3; ++i) {
getchar();
for (int j = 0; j < n; ++j) f[j][i] = getchar();
}
dp[0][0] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 32; ++j) count(i, 0, j, j & ans);
cout << dp[n][ans];
return 0;
}
| 6 |
#include <bits/stdc++.h>
const long double pi = 3.1415926535898;
const long long mod = 1e9 + 7;
using namespace std;
long long a[1001][1001];
vector<vector<long long>> v(1001);
long long dp[1001];
long long s, t, n;
long long dij() {
for (long long i = 0; i < n; i++) {
dp[i] = 1e15;
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
dp[s] = 0;
pq.push({0, s});
while (pq.size()) {
long long w = pq.top().first;
long long x = pq.top().second;
pq.pop();
if (w > dp[x]) {
continue;
}
for (auto i : v[x]) {
if (dp[i] > dp[x] + a[x][i]) {
dp[i] = dp[x] + a[x][i];
pq.push({dp[i], i});
}
}
}
return dp[t];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long m, l, x, y, w;
cin >> n >> m >> l >> s >> t;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
a[i][j] = 1e15;
}
}
vector<pair<long long, long long>> e, ans;
for (long long i = 0; i < m; i++) {
cin >> x >> y >> w;
ans.push_back({x, y});
v[x].push_back(y);
v[y].push_back(x);
if (w == 0) {
e.push_back({x, y});
w++;
}
a[x][y] = w;
a[y][x] = w;
}
x = dij();
y = l - x;
for (auto i : e) {
if (y < 0) {
break;
}
a[i.first][i.second] += y;
a[i.second][i.first] += y;
x = dij();
y = l - x;
if (y == 0) {
break;
}
a[i.first][i.second] = 1e15;
a[i.second][i.first] = 1e15;
}
if (dij() != l) {
cout << "NO";
exit(0);
}
cout << "YES\n";
for (auto i : ans) {
cout << i.first << " " << i.second << " " << a[i.first][i.second] << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
if (m == 2) {
if (d == 1)
cout << "4";
else
cout << "5";
} else if ((m % 2 == 0 && m <= 6) || (m % 2 != 0 && m >= 9)) {
if (d <= 6)
cout << "5";
else
cout << "6";
} else if ((m % 2 != 0 && m <= 7) || (m % 2 == 0 && m >= 8)) {
if (d <= 5)
cout << "5";
else
cout << "6";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
ll n;
cin >> n;
vector<ll> p(n);
for (auto& e : p) cin >> e;
vector<ll> v(150002, 0LL);
for (auto e : p) v[e]++;
for (ll i = v.size() - 2; i >= 1; --i) {
if (v[i] == 0) continue;
if (v[i + 1] == 0) v[i + 1]++, v[i]--;
}
for (ll i = 1; i < v.size(); ++i) {
if (v[i] == 0) continue;
if (i != 1 and v[i - 1] == 0) v[i - 1]++, v[i]--;
}
cout << accumulate(v.begin(), v.end(), 0LL, [](ll a, ll b) {
return a += (b > 0);
}) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const long long INF = LLONG_MAX;
void build(long long init, long long l, long long r, long long* st,
long long* ar, long long val, long long n) {
if (l != r) {
build(2 * init + 1, l, (l + r) / 2, st, ar, val, n);
build(2 * init + 2, (l + r) / 2 + 1, r, st, ar, val, n);
st[init] = st[2 * init + 1] * st[2 * init + 2];
if (st[init] >= 10) {
st[init] = st[init] / 10;
}
} else {
long long x = ar[l * val];
while (x > 0) {
st[init] = x;
x = x / 10;
}
}
}
void modify(long long init, long long l, long long r, long long ind,
long long x, long long* st) {
if (l != r) {
if (ind <= (l + r) / 2) {
modify(2 * init + 1, l, (l + r) / 2, ind, x, st);
} else {
modify(2 * init + 2, (l + r) / 2 + 1, r, ind, x, st);
}
st[init] = st[2 * init + 1] * st[2 * init + 2];
if (st[init] >= 10) {
st[init] = st[init] / 10;
}
} else {
while (x > 0) {
st[init] = x;
x = x / 10;
}
}
}
long long getans(long long* st) { return st[0]; }
long long power_2(long long p1, long long p2, long long x = M) {
if (p2 == 0) {
return 1;
}
if (p2 == 1) {
return p1 % x;
}
long long y = power_2(p1, p2 / 2, x);
y = ((((y * y) % x) * power_2(p1, p2 % 2, x)) % x);
return y;
}
long long inv(long long p1) { return power_2(p1, M - 2); }
long long fact(long long n) {
long long i, nlt = 1;
for (i = 1; i <= n; ++i) {
nlt = (nlt * i) % M;
}
return nlt;
}
bool check_pr(long long x, vector<long long>* pr) {
long long n = (*pr).size();
long long i;
for (i = 0; i < n && ((*pr)[i]) * ((*pr)[i]) <= x; ++i) {
if (x % ((*pr)[i]) == 0) {
return false;
}
}
return true;
}
pair<long long, long long> inv(pair<long long, long long> x) {
pair<long long, long long> ans;
ans.first = x.second;
ans.second = x.first;
return ans;
}
void fth(long long st, vector<set<long long> >* edges, bool* visited,
long long* mx, long long dist, long long* vt) {
visited[st] = true;
set<long long>::iterator it;
*vt = ((*mx >= dist) ? (*vt) : st);
*mx = max(*mx, dist);
set<long long> x1 = (*edges)[st];
for (it = x1.begin(); it != x1.end(); ++it) {
if (!visited[*it]) {
fth((*it), edges, visited, mx, dist + 1, vt);
}
}
}
void merge(long long* a, long long* b, long long* c, long long sz,
long long x) {
long long i, j;
long long* d = new long long[x];
fill(d, d + x, 0);
for (i = 1; i <= x; ++i) {
for (j = 1; j <= x; ++j) {
long long val = (((i - 1) * power_2(10, sz, x)) % x + (j - 1)) % x;
d[val] = (d[val] + ((a[(i - 1)] * b[(j - 1)]) % M)) % M;
}
}
for (i = 1; i <= x; ++i) {
c[i - 1] = (c[i - 1] + d[i - 1]) % M;
}
}
long long gcd(long long a, long long b) {
if (a > b) {
return gcd(b, a);
}
if (a == b || a == 0) {
return b;
}
return gcd(b % a, a);
}
int getans_2(double x) {
double fr = x - floor(x);
int i = 1;
while (true) {
if (log10((double)(i + 1)) <= fr) {
++i;
continue;
}
return i;
}
}
bool ans = true;
long long dfs(vector<set<long long> >* edges, long long* visited,
long long* wish, long long* arr, long long h, long long st) {
visited[st] = h;
long long mx = 1e6;
set<long long>::iterator it;
set<long long> x1 = (*edges)[st];
for (it = x1.begin(); it != x1.end(); ++it) {
if (visited[(*it)] == -1) {
long long mx_wh = dfs(edges, visited, wish, arr, h + 1, *it);
mx = min(mx, mx_wh);
}
}
if (mx < h && arr[st] != 0) {
ans = false;
}
return min(mx, visited[wish[st]]);
}
int main() {
vector<pair<long long, long long> > xx;
long long n, m, h, p, l, r, t1, q, x, y, z, a, b, c, sum = 0, mult = 1, t = 0;
long long i, j, k;
string s, s1, s2;
double d, v, e;
t1 = 1;
double pi = 3.14159265359;
a = 1e9 * 1e9;
long long sz = 1e5;
while (t1-- > 0) {
cin >> n >> m;
vector<set<long long> > edges(n + 1);
long long* arr = new long long[n + 1];
fill(arr, arr + n + 1, 0);
for (i = 1; i <= m; ++i) {
cin >> x >> y;
edges[x].insert(y);
edges[y].insert(x);
arr[y] = 1;
}
for (i = 1; i <= n; ++i) {
if (!arr[i]) {
edges[0].insert(i);
edges[i].insert(0);
}
}
fill(arr, arr + n + 1, 0);
long long* visited = new long long[n + 1];
long long* wish = new long long[n + 1];
wish[0] = 0;
for (i = 1; i <= n; ++i) {
cin >> wish[i];
++arr[wish[i]];
}
fill(visited, visited + n + 1, -1);
dfs(&edges, visited, wish, arr, 0, 0);
if (!ans) {
cout << -1;
} else {
vector<pair<long long, long long> > lst;
for (i = 1; i <= n; ++i) {
if (arr[i] > 0) {
lst.push_back(make_pair(visited[i], i));
}
}
sort(lst.begin(), lst.end());
cout << lst.size() << endl;
for (i = 1; i <= lst.size(); ++i) {
cout << lst[lst.size() - i].second << endl;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long Mod = 1e9 + 7;
int n, m;
char A[1005][1005];
int dsu[2005], parent[2005], depth[2005];
vector<int> G[2005];
bool vis[2005], grey[2005], ultimate = true;
void dfs(int u) {
depth[u] = 1;
vis[u] = true;
grey[u] = true;
for (auto it : G[u]) {
if (!vis[it]) {
dfs(it);
} else if (grey[it])
ultimate = false;
depth[u] = max(depth[u], depth[it] + 1);
}
grey[u] = false;
}
int find_parent(int i) {
while (parent[i] != i) i = parent[i];
return i;
}
void merge(int a, int b) {
int p_a = find_parent(a), p_b = find_parent(b);
if (p_a == p_b)
return;
else
parent[p_b] = p_a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n + m; i++) {
dsu[i] = i;
parent[i] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> A[i][j];
if (A[i][j] == '=') {
merge(i, n + j);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (A[i][j] == '=') continue;
int a = find_parent(i), b = find_parent(n + j);
if (A[i][j] == '<') swap(a, b);
G[a].push_back(b);
}
}
for (int i = 0; i < n + m; i++) {
if (find_parent(i) == i && !vis[i]) dfs(i);
}
if (ultimate) {
cout << "Yes" << endl;
for (int i = 0; i < n; i++) cout << depth[find_parent(i)] << " ";
cout << endl;
for (int i = 0; i < m; i++) cout << depth[find_parent(n + i)] << " ";
cout << endl;
} else
cout << "No" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long k;
string s;
cin >> k >> s;
long long n = s.size();
s = 'a' + s;
vector<long long> v;
long long f[n + 2], b[n + 2], cc = 0, ccc = 0, ans = 0;
for (long long int i = 1; i <= n; i++) {
if (s[i] == '1') {
f[i] = cc;
ans += (cc * (cc + 1)) / 2;
cc = 0;
v.push_back(i);
} else {
f[i] = 0;
cc++;
}
if (s[n - i + 1] == '1') {
b[n - i + 1] = ccc;
ccc = 0;
} else {
b[n - i + 1] = 0;
ccc++;
}
}
ccc = 0;
for (long long int i = n; i >= 1; i--) {
if (s[i] != '0') {
break;
}
ccc++;
}
if (k == 0) {
ans += (ccc * (ccc + 1)) / 2;
cout << ans << "\n";
return 0;
}
long long sz = v.size();
ans = 0;
for (long long int i = 0; i < sz; i++) {
if (i + k - 1 < sz) {
ans += ((f[v[i]] + 1) * (b[v[i + k - 1]] + 1));
}
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
using vs = vector<string>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline void prn(vector<T>& v) {
int n = (int)v.size();
for (int i = (0); i < ((n)); i++) cout << v[i] << ' ';
}
template <class T>
inline void printv(vector<T>& v) {
int n = (int)v.size();
for (int i = (0); i < ((n)); i++) cout << v[i] << (i == n - 1 ? '\n' : ' ');
}
template <class T>
inline void printvv(vector<vector<T>>& v) {
for (auto u : v) printv(u);
}
template <class T>
inline void printvm(vector<T>& v) {
int n = (int)v.size();
for (int i = (0); i < ((n)); i++)
cout << v[i].val() << (i == n - 1 ? '\n' : ' ');
}
template <class T>
inline void printvvm(vector<vector<T>>& v) {
for (auto u : v) printvm(u);
}
template <class T>
inline void printlnv(vector<T>& v) {
int n = (int)v.size();
for (int i = (0); i < ((n)); i++) cout << v[i] << '\n';
}
const int MOD = 1000000007;
const int INF = 1000000001;
const ll LINF = 1000000001000000001LL;
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(numeric_limits<double>::max_digits10);
solve();
return 0;
}
void solve() {
int n;
cin >> n;
vi a(n);
for (int i = (0); i < ((n)); i++) cin >> a[i];
vvb dp(n + 1, vb(513, false));
vi dp2(513, INF);
dp[0][0] = true;
dp2[0] = 0;
for (int i = (0); i < ((n)); i++) {
for (int j = (0); j < ((513)); j++) {
if (dp[i][j]) {
dp[i + 1][j] = true;
if (dp2[j] < a[i]) {
dp[i + 1][j ^ a[i]] = true;
chmin(dp2[j ^ a[i]], a[i]);
}
}
}
}
vi ans;
int cnt = 0;
for (int i = (0); i < ((513)); i++)
if (dp[n][i]) {
ans.emplace_back(i);
cnt++;
}
cout << cnt << '\n';
printv(ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5;
const int ALPH = 26;
char s[MAXN + 1];
bool bad[ALPH + 1][ALPH + 1];
int dp[MAXN + 100][30], N;
int main(void) {
scanf("%s", s);
N = strlen(s);
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
char c1, c2;
scanf(" %c %c", &c1, &c2);
bad[c1 - 'a'][c2 - 'a'] = 1;
bad[c2 - 'a'][c1 - 'a'] = 1;
}
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j <= 26; j++) {
dp[i][j] = dp[i + 1][j] + 1;
if (!bad[j][s[i] - 'a']) {
dp[i][j] =
((dp[i][j]) < (dp[i + 1][s[i] - 'a']) ? (dp[i][j])
: (dp[i + 1][s[i] - 'a']));
}
}
}
printf("%d\n", dp[0][26]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a[1001][3], b[1002][3], n, i, j, s1, s2, x, y,
l = 1, h = 0, sum1 = 0, sum2 = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i][1] >> a[i][2];
sum1 = sum1 + a[i][1];
sum2 = sum2 + a[i][2];
}
for (i = 1; i <= n; i++) {
cin >> b[i][1] >> b[i][2];
sum1 = sum1 + b[i][1];
sum2 = sum2 + b[i][2];
}
sum1 = sum1 / n;
sum2 = sum2 / n;
cout << sum1 << " " << sum2;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, a, b;
int deg[N], s[N];
queue<int> q;
vector<pair<int, int>> ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d%d", deg + i, s + i);
for (int i = 0; i < n; ++i)
if (deg[i] == 1) q.push(i);
while (!q.empty()) {
if (deg[q.front()] == 0) {
q.pop();
continue;
}
ans.emplace_back(q.front(), s[q.front()]);
s[s[q.front()]] ^= q.front();
deg[s[q.front()]]--;
if (deg[s[q.front()]] == 1) q.push(s[q.front()]);
q.pop();
}
printf("%d\n", (int)ans.size());
for (auto &i : ans) printf("%d %d\n", i.first, i.second);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 100111;
int n, m;
bool vis[maxn];
int dfn[maxn], dtot, low[maxn];
int g[maxn], gtot, st[maxn], stn;
vector<int> ncon[maxn];
vector<int> con[maxn];
int deg[maxn];
vector<int> G[maxn];
void tarjan(int x) {
dfn[x] = low[x] = ++dtot;
st[stn++] = x;
for (auto u : con[x]) {
if (!dfn[u]) {
tarjan(u);
low[x] = min(low[x], low[u]);
} else if (!g[u]) {
low[x] = min(low[x], dfn[u]);
}
}
if (low[x] == dfn[x]) {
gtot++;
while (true) {
int u = st[--stn];
g[u] = gtot;
G[gtot].push_back(u);
if (u == x) break;
}
}
}
void prework() {
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i);
}
}
for (int i = 1; i <= n; i++) {
for (auto u : con[i]) {
if (g[i] != g[u]) {
ncon[g[i]].push_back(g[u]);
deg[g[u]]++;
}
}
}
}
int comp_node(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
int ret;
scanf("%d", &ret);
if (ret == -1) exit(0);
if (ret == 0)
return y;
else
return x;
}
vector<int> v;
void pop_back(int x) {
G[v[x]].pop_back();
if (G[v[x]].size() == 0) {
for (auto u : ncon[v[x]]) {
deg[u]--;
if (deg[u] == 0) v.push_back(u);
}
swap(v[x], v.back());
v.pop_back();
}
}
void solve() {
for (int i = 1; i <= gtot; i++) {
if (deg[i] == 0) v.push_back(i);
}
assert(v.size() > 0);
assert(G[v[0]].size() > 0);
int x = G[v[0]].back();
while (v.size() > 1) {
for (int i = 0; i < v.size(); i++) {
if (v[i] != g[x]) {
assert(G[v[i]].size() > 0);
int y = G[v[i]].back();
int nxt = comp_node(x, y);
if (nxt == x) {
pop_back(i);
} else {
swap(v[0], v[i]);
pop_back(i);
}
x = nxt;
break;
}
}
}
printf("! %d\n", x);
fflush(stdout);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
con[x].push_back(y);
}
prework();
solve();
return 0;
}
| 12 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.