solution
stringlengths 53
181k
| difficulty
int64 0
13
|
---|---|
#include <bits/stdc++.h>
std::string to_lower(const std::string& login) {
std::string temp;
for (size_t i = 0; i < login.size(); ++i) {
temp += tolower(login[i]);
}
return temp;
}
int main() {
std::string login;
std::cin >> login;
login = to_lower(login);
int n;
std::cin >> n;
std::vector<std::string> oldLogins;
for (int i = 0; i < n; ++i) {
std::string temp;
std::cin >> temp;
oldLogins.push_back(to_lower(temp));
}
for (auto& cur : oldLogins) {
if (login.size() == cur.size()) {
size_t i = 0;
for (; i < login.size(); ++i) {
if (login[i] != cur[i]) {
if (login[i] == '0' || login[i] == 'o') {
if (cur[i] != '0' && cur[i] != 'o') {
break;
}
} else if (login[i] == '1' || login[i] == 'i' || login[i] == 'l') {
if (cur[i] != '1' && cur[i] != 'i' && cur[i] != 'l') {
break;
}
} else {
break;
}
}
}
if (i == login.size()) {
std::cout << "No" << std::endl;
return 0;
}
}
}
std::cout << "Yes" << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 * 4;
inline int get() {
int x;
cin >> x;
return x;
}
inline long long getlong() {
long long x;
cin >> x;
return x;
}
inline string getString() {
string s;
cin >> s;
return s;
}
template <typename T>
inline vector<T> getvector(int len) {
vector<T> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<int> getvector(int len) {
vector<int> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<pair<int, int>> getvector_andPairCnt(int len) {
vector<pair<int, int>> a(len);
int i = 1;
for (auto &it : a) {
it.second = i;
i++;
cin >> it.first;
}
return a;
}
double power_log(double power, double val) { return log(val) / log(power); }
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it : v) os << it << " ";
os << "\n";
return os;
}
template <typename T, typename H>
inline vector<pair<T, H>> getvector_andBiPair(int len) {
vector<pair<T, H>> a(len);
for (auto &it : a) {
cin >> it.first >> it.second;
}
return a;
}
template <typename T>
inline set<T> vector_to_set(const vector<T> &vec) {
set<T> s;
for (auto &it : vec) s.insert(it);
return s;
}
int main() {
int n = get();
auto v = getvector_andBiPair<int, int>(n);
map<int, int> mp;
for (auto it : v) mp[it.first]++;
for (auto it : v) {
int l = 0, r = 0;
l += (n - 1);
l += mp[it.second];
r += (n - 1) - mp[it.second];
cout << l << " " << r << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int st, j, k, n, s, K;
int f[155][155];
int main() {
scanf("%d", &K);
st = 0;
for (int i = 3; i <= 100; i++)
if (i * (i - 1) * (i - 2) / 6 > K) {
n = i;
break;
}
n--;
s = 0;
for (int i = 1; i <= n - 2; i++)
for (int j = i + 1; j <= n - 1; j++)
for (int k = j + 1; k <= n; k++) {
f[i][j] = f[j][i] = f[j][k] = f[k][j] = f[i][k] = f[k][i] = 1;
s++;
}
K = K - s;
st = n;
while (K) {
int tem = 0;
for (int i = 1; i <= n; i++) {
if (tem + i - 1 <= K) {
tem += i - 1;
f[st + 1][i] = f[i][st + 1] = 1;
}
}
K -= tem;
st = st + 1;
}
printf("%d\n", st);
for (int i = 1; i <= st; i++) {
for (int j = 1; j <= st; j++) printf("%d", f[i][j]);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int fa[100001], fb[100001], n, res = 0;
int main() {
cin >> s;
n = s.size();
s = ' ' + s;
for (int i = 1; i <= n; i++) {
fa[i] = fa[i - 1] + (s[i] == 'a' ? 1 : 0);
fb[i] = fb[i - 1] + (s[i] == 'b' ? 1 : 0);
}
for (int i = 0; i <= n; i++) {
res = max(res, fa[i]);
for (int j = i + 1; j <= n; j++) {
res = max(res, fa[i] - fa[0] + fb[j] - fb[i] + fa[n] - fa[j]);
}
}
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M1 = 100030;
const int M2 = 316;
bool pri[M1];
void se() {
int i, j, k;
pri[1] = 1;
for (k = 1, i = 2; i <= M2; i += k, k = 2)
if (!pri[i]) {
for (j = 2 * i; j < M1; j += i) pri[j] = 1;
}
}
int pr(int n) {
int i, j = 0;
for (i = n;; i++)
if (!pri[i])
return j;
else
j++;
}
int main() {
se();
int i, j, k = 100000, n, m, l, p;
cin >> n >> m;
int a[n][m];
for (i = 0; i < n; i++) {
for (p = 0, j = 0; j < m; j++) {
cin >> l;
a[i][j] = pr(l);
p += a[i][j];
}
k = min(k, p);
}
if (k == 0) {
cout << "0\n";
} else {
for (i = 0; i < m; i++) {
for (l = 0, j = 0; j < n; j++) l += a[j][i];
k = min(k, l);
}
cout << k << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e3 + 3;
const long long MOD = 998244353;
int n, k;
int a[MAX_N];
long long ans;
long long dp[MAX_N][MAX_N];
long long pre[MAX_N];
void make_prefix(int x) {
for (int i = 1; i <= n; i++) pre[i] = (pre[i - 1] + dp[x][i]) % MOD;
}
long long calc(long long x) {
int l = 1;
for (int i = 1; i <= n; i++) pre[i] = i;
for (int i = 2; i <= k; i++) {
for (int j = i; j <= n; j++) {
while (a[j] - a[l] >= x) l++;
dp[i][j] = pre[l - 1];
}
make_prefix(i);
l = 1;
}
return pre[n];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= 100000; i++) {
long long tmp = calc(i);
if (tmp == 0) break;
ans = (ans + tmp) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long M1 = 1000000007;
long long M2 = 67280421310721;
long long M3 = 998244353;
long long INF = 1e18;
long long power(long long a, long long b, long long mod) {
long long ans = 1;
long long prod = a;
while (b) {
if (b % 2) ans = (ans * prod) % mod;
prod = (prod * prod) % mod;
b /= 2;
}
return ans;
}
long long inv(long long a, long long mod) { return power(a, mod - 2, mod); }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long fact(long long n, long long mod) {
long long f = 1;
for (long long i = 1; i <= n; i++) f = (f * i) % mod;
return f;
}
long long ncr(long long n, long long r, long long mod) {
if (mod == 1) {
return (fact(n, mod) / fact(r, mod)) / fact(n - r, mod);
}
return (((fact(n, mod) * inv(fact(r, mod), mod)) % mod) *
inv(fact(n - r, mod), mod)) %
mod;
}
void solve() {
long long n;
cin >> n;
long long a[n], b[n], c[n];
long long i;
long long dis = 0;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] - b[i];
dis += b[i] * n - a[i];
}
sort(c, c + n);
for (i = 0; i < n; i++) {
dis += c[i] * (n - i);
}
cout << dis << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
auto start = high_resolution_clock::now();
long long i, t = 1;
for (i = 1; i <= t; i++) solve();
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0, sign = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ans = ans * 10 + (ch - '0');
ch = getchar();
}
return sign * ans;
}
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const double eps = 1e-5;
const int maxn = 1e5 + 5;
const int maxm = 1e5 + 5;
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
inline long long qpow(long long x, long long n) {
long long ans = 1;
while (n) {
if (n & 1) {
ans = (ans * x);
}
x = (x * x);
n >>= 1;
}
return ans;
}
inline long long mqpow(long long x, long long n, long long m) {
long long ans = 1;
while (n) {
if (n & 1) {
ans = (ans * x) % m;
}
x = (x * x) % m;
n >>= 1;
}
return ans % m;
}
int lowbit(int x) { return x & (-x); }
int arr[maxn];
void solve() {
int n = read(), k = read(), f = 0;
arr[0] = arr[n + 1] = -1;
for (int i = 1; i <= n; i++) {
arr[i] = read();
if (arr[i] == k) {
f = 1;
}
}
if (!f) {
puts("no");
return;
}
if (n == 1) {
puts("yes");
return;
}
for (int i = 1; i <= n; i++) {
if (arr[i] >= k) {
if (arr[i - 1] >= k || arr[i + 1] >= k) {
puts("yes");
return;
}
if (i > 1 && arr[i - 2] >= k) {
puts("yes");
return;
}
if (i < n && arr[i + 2] >= k) {
puts("yes");
return;
}
}
}
puts("no");
}
int main() {
int test = 1;
test = read();
while (test--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int num = 1, arr[1000006], sum[1000006] = {0};
for (int i = 0; i < n + 1; ++i) num *= 2;
num -= 2;
int ans = 0;
for (int i = 0; i < num; ++i) {
cin >> arr[i + 2];
}
for (int i = num + 1; i > 1; i -= 2) {
sum[i / 2] = max(sum[i] + arr[i], sum[i - 1] + arr[i - 1]);
ans += (max(sum[i] + arr[i], sum[i - 1] + arr[i - 1]) -
min(sum[i] + arr[i], sum[i - 1] + arr[i - 1]));
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int d[200], i, k, cnt;
bool used[200];
string s;
int main() {
cin >> s >> k;
for (i = 0; i < s.size(); i++) {
d[s[i]]++;
if (!used[s[i]]) cnt++;
used[s[i]] = true;
}
for (i = 0; i < s.size(); i++) {
char mx = 'a';
for (char c = 'a'; c <= 'z'; c++) {
if ((d[c] < d[mx] || !used[mx]) && used[c]) mx = c;
}
if (d[mx] > k || !used[mx]) break;
k -= d[mx];
cnt--;
used[mx] = false;
}
cout << cnt << endl;
for (i = 0; i < s.size(); i++) {
if (used[s[i]]) cout << s[i];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int n, m, w, ans;
int a[600020], c[600020], num[600020], b[600020];
vector<int> vec[202];
char ch[20];
void init() {
for (int i = 0; i <= (1 << w) - 1; ++i) {
int x = 0;
for (int j = w - 1; j >= 0; --j) {
x = x * 3 + ((i >> j) & 1);
}
b[i] = x;
}
for (int i = 0; i <= (1 << w) - 1; ++i) {
for (int j = 0; j <= (1 << w) - 1; ++j) {
int x = b[i], y = b[j];
num[x + y] += c[i] * c[j];
}
}
vec['A'].push_back(0);
vec['A'].push_back(1);
vec['O'].push_back(0);
vec['X'].push_back(0);
vec['X'].push_back(2);
vec['a'].push_back(2);
vec['o'].push_back(1);
vec['o'].push_back(2);
vec['x'].push_back(1);
}
void dfs(int x, int d) {
if (x == w + 1) {
ans += num[d];
return;
}
for (int i = 0; i < (int)vec[ch[x]].size(); ++i) {
dfs(x + 1, d * 3 + vec[ch[x]][i]);
}
}
int main() {
scanf("%d %d %d", &w, &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), c[a[i]]++;
init();
while (m--) {
scanf("%s", ch + 1);
ans = 0, dfs(1, 0);
printf("%d\n", ans);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b == 0) ? a : gcd(b, a % b);
}
long long int power(long long int a, long long int p,
long long int m = 1000000007ll) {
long long int res = 1;
while (p > 0) {
if (p & 1) res = (res * a) % m;
a = (a * a) % m;
p >>= 1;
}
return res;
}
const long double pi = 3.141592653589793238462643383;
long long int nc2(int n) {
if (n == 0) return 0LL;
long long int res = ((long long int)n * ((long long int)n + 1)) / 2;
return res;
}
long long int dp[2][2][1001][2001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
dp[0][1][0][2] = dp[1][0][0][2] = 1;
for (int i = 0; i < n; i++) {
dp[0][0][i][1] = 1;
dp[1][1][i][1] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 2; j <= k; j++) {
dp[0][0][i][j] =
(dp[0][0][i][j] + dp[0][0][i - 1][j] + dp[0][1][i - 1][j] +
dp[1][0][i - 1][j] + dp[1][1][i - 1][j - 1]) %
998244353;
dp[0][1][i][j] =
(dp[0][1][i][j] + dp[0][0][i - 1][j - 1] + dp[0][1][i - 1][j] +
dp[1][0][i - 1][j - 2] + dp[1][1][i - 1][j - 1]) %
998244353;
dp[1][0][i][j] =
(dp[1][0][i][j] + dp[0][0][i - 1][j - 1] + dp[0][1][i - 1][j - 2] +
dp[1][0][i - 1][j] + dp[1][1][i - 1][j - 1]) %
998244353;
dp[1][1][i][j] =
(dp[1][1][i][j] + dp[0][0][i - 1][j - 1] + dp[0][1][i - 1][j] +
dp[1][0][i - 1][j] + dp[1][1][i - 1][j]) %
998244353;
}
}
cout << (dp[0][0][n - 1][k] + dp[0][1][n - 1][k] + dp[1][0][n - 1][k] +
dp[1][1][n - 1][k]) %
998244353
<< '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
using ll = long long;
using ld = long double;
const int MAXMEM = 200 * 1000 * 1024;
char _memory[MAXMEM];
size_t _ptr = 0;
void *operator new(size_t _x) {
_ptr += _x;
return _memory + _ptr - _x;
}
void operator delete(void *) noexcept {}
const string FILENAME = "input";
const int MAXN = 100228;
const int BLOCK = 30;
const int BLOCK1 = 1300;
int n, w, q;
int x[MAXN];
int ans[MAXN];
int mx[MAXN][18];
int mx1[MAXN][18];
int gr[MAXN];
inline int getmax(const int l, const int r) {
int grs = 31 - __builtin_clz(r - l + 1);
return max(mx1[l][grs], mx1[r - (1 << grs) + 1][grs]);
}
inline int getmin(const int l, const int r) {
int grs = 31 - __builtin_clz(r - l + 1);
return min(mx[l][grs], mx[r - (1 << grs) + 1][grs]);
}
inline bool check(const int l, const int r, int k) {
if (l > r || r >= n) {
return false;
}
int f = getmin(l, r);
int f1 = getmax(l, r);
return f + w - f1 >= k;
}
inline int findGroupEnd(const int i, const int k) {
int l = i;
int r = n - 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(i, mid, k)) {
l = mid;
} else {
r = mid - 1;
}
}
return l + 1;
}
int curs[MAXN];
int jump[MAXN];
int target[MAXN];
int val;
void calc(int i) {
if (curs[i] == BLOCK) {
jump[i] = 0;
target[i] = i;
} else {
if (i + curs[i] >= n) {
jump[i] = 1;
target[i] = i + curs[i];
} else {
if (target[curs[i] + i] >= i + BLOCK) {
int t = i + curs[i];
int cnt = 1;
while (curs[t] + t < i + BLOCK) {
cnt++;
t += curs[t];
}
target[i] = t + curs[t];
jump[i] = cnt + 1;
} else {
jump[i] = 1 + jump[curs[i] + i];
target[i] = target[curs[i] + i];
}
}
}
}
void calc1(int i) {
if (curs[i] == BLOCK) {
jump[i] = 0;
target[i] = i;
} else {
if (i + curs[i] >= n) {
jump[i] = 1;
target[i] = i + curs[i];
}
}
}
int gt[MAXN];
int ls[MAXN];
int ft[MAXN];
int ukr;
int nxt[MAXN];
bool used[MAXN];
int st[MAXN];
int uks;
int grs;
int stacker[MAXN];
int ukt = 0;
int curuk[MAXN];
int curval[MAXN];
void dfs(int start) {
ukt = 0;
stacker[ukt] = start;
curuk[start] = gt[start];
ukt++;
uks = 0;
curval[start] = 0;
while (ukt) {
int u = stacker[ukt - 1];
if (curuk[u] == gt[u]) {
used[u] = true;
if (u <= grs) {
if (target[curs[u] + u] >= u + BLOCK) {
while (curval[u] < uks && st[curval[u]] >= u + BLOCK) {
curval[u]++;
}
int l = curval[u];
jump[u] = uks - l;
if (curs[st[l]] == BLOCK) {
target[u] = st[l];
} else {
jump[u]++;
target[u] = st[l] + curs[st[l]];
}
} else {
jump[u] = 1 + jump[curs[u] + u];
target[u] = target[curs[u] + u];
}
}
st[uks] = u;
uks++;
}
if (curuk[u] == -1) {
uks--;
ukt--;
continue;
}
int h = ft[curuk[u]];
curuk[u] = nxt[curuk[u]];
if (!used[h]) {
stacker[ukt] = h;
curval[h] = curval[u];
curuk[h] = gt[h];
ukt++;
}
}
}
void add(int a, int b) {
if (gt[a] == -1) {
gt[a] = ukr;
ls[a] = ukr;
ft[ukr] = b;
nxt[ukr] = -1;
ukr++;
} else {
nxt[ls[a]] = ukr;
ft[ukr] = b;
nxt[ukr] = -1;
ls[a] = ukr;
ukr++;
}
}
void update(int i) {
for (int j = i; j >= max(0, i - BLOCK - 1); j--) {
calc(j);
}
}
bool bad[MAXN];
int curs2[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> w >> q;
for (int i = 0; i < n; i++) {
cin >> x[i];
mx[i][0] = x[i];
mx1[i][0] = x[i];
}
for (int k = 1; k < 18; k++) {
for (int i = 0; i < n; i++) {
int t = min(i + (1 << (k - 1)), n - 1);
mx[i][k] = min(mx[i][k - 1], mx[t][k - 1]);
mx1[i][k] = max(mx1[i][k - 1], mx1[t][k - 1]);
}
}
int cur = 1;
int step = 0;
for (int i = 1; i <= n; i++) {
if (cur + cur <= i) {
cur += cur;
step++;
}
gr[i] = step;
}
vector<pair<int, int> > st;
for (int it = 0; it < q; it++) {
int k;
cin >> k;
st.push_back({k, it});
}
sort((st).begin(), (st).end());
vector<pair<int, pair<int, int> > > g;
vector<pair<int, int> > g1;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= BLOCK; j++) {
int maxk = 0;
if (i + j - 1 >= n) {
maxk = 0;
} else {
int s = getmin(i, i + j - 1);
int s1 = getmax(i, i + j - 1);
maxk = max(0, s + w - s1);
}
g.push_back({maxk + 1, {i, j - 1}});
if (maxk) {
chkmax(curs[i], j);
}
}
if (i + BLOCK1 <= n) {
int s = getmin(i, i + BLOCK1 - 1);
int s1 = getmax(i, i + BLOCK1 - 1);
if (max(0, s + w - s1) != 0) {
g1.push_back({max(0, s + w - s1) + 1, i});
bad[i] = true;
}
}
curs2[i] = findGroupEnd(i, 1) - i;
}
sort((g).begin(), (g).end());
sort((g1).begin(), (g1).end());
val = 1;
int uk = 0;
for (int i = n - 1; i >= 0; i--) {
calc(i);
}
int uk1 = 0;
for (int it = 0; it < q; it++) {
val = st[it].first;
while (uk < (int)(g).size() && g[uk].first <= val) {
int gh = curs[g[uk].second.first];
chkmin(curs[g[uk].second.first], g[uk].second.second);
if (curs[g[uk].second.first] != gh) {
update(g[uk].second.first);
}
uk++;
}
while (uk1 < (int)(g1).size() && g1[uk1].first <= val) {
bad[g1[uk1].second] = false;
curs2[g1[uk1].second] = BLOCK1 - 1;
uk1++;
}
int cur = 0;
int cnt = 0;
while (cur < n) {
if (curs[cur] == BLOCK) {
if (bad[cur]) {
cnt++;
cur = findGroupEnd(cur, val);
} else {
while (!check(cur, cur + curs2[cur] - 1, val)) {
curs2[cur]--;
}
cnt++;
int val = curs2[cur];
cur += val;
}
} else {
cnt += jump[cur];
cur = target[cur];
}
}
ans[st[it].second] = cnt - 1;
}
for (int it = 0; it < q; it++) {
cout << ans[it] << '\n';
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const long long INF = INT_MAX;
const long long INF_LL = LLONG_MAX;
const long double EPS = 1e-9;
const long long MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout.precision(20);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> Num(n);
for (long long i = 0; i < n; ++i) {
cin >> Num[i];
}
vector<long long> Left(n, Num[0]);
vector<long long> Right(n, 0);
bool ok = true;
for (long long i = 1; i < n; ++i) {
if (Num[i] - Right[i - 1] < 0) {
ok = false;
break;
}
Left[i] = min(Left[i - 1], Num[i] - Right[i - 1]);
Right[i] = Num[i] - Left[i];
}
if (ok) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 9;
const long long inf = 1e18 + 18;
const int max6 = 1e6 + 6;
const int modx = 1e9 + 123;
const int mody = 997;
const int base = 137;
int a[2005][2005];
long long f[2005][2005];
long long g[2005][2005];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) cin >> a[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) f[i][j] = f[i - 1][j - 1] + a[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) g[i][j] = g[i - 1][j + 1] + a[i][j];
pair<long long, pair<int, int> > max_odd = {0, {0, 0}};
pair<long long, pair<int, int> > max_even = {0, {0, 0}};
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
int one = min(n - i, n - j);
int two = min(n - i, j - 1);
long long cur = f[i + one][j + one] + g[i + two][j - two] - a[i][j];
if ((i + j) % 2)
max_odd = max(max_odd, {cur, {i, j}});
else
max_even = max(max_even, {cur, {i, j}});
}
cout << max_odd.first + max_even.first << "\n";
cout << max_odd.second.first << " " << max_odd.second.second << " ";
cout << max_even.second.first << " " << max_even.second.second << " ";
}
| 5 |
#include <bits/stdc++.h>
int main() {
int f[2010], a[2010], max, sum, x, i, n;
scanf("%d", &n);
memset(f, 0, sizeof(f));
memset(a, 0, sizeof(a));
for (i = 1; i <= n; i++) {
scanf("%d", &x);
if (x != -1) {
f[i] = x;
a[x] = 1;
}
}
max = 0;
for (i = 1; i <= n; i++)
if (a[i] == 0) {
sum = 1;
x = i;
while (f[x] != 0) {
sum++;
x = f[x];
}
if (sum > max) max = sum;
}
printf("%d\n", max);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, m, a[100111], rep[100111], ans = -1;
int main() {
scanf("%I64d%I64d%I64d", &n, &k, &m);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
rep[a[i] % m]++;
}
for (int i = 0; i < m; i++) {
if (rep[i] >= k) {
ans = i;
}
}
if (ans == -1) {
printf("No\n");
} else {
printf("Yes\n");
for (int i = 0; i < n && k != 0; i++) {
if (a[i] % m == ans) {
printf("%I64d ", a[i]);
k--;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
if (n % 2 == 0) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < n; ++i) cout << i << " ";
cout << endl;
for (int i = 0; i < n; ++i) cout << i << " ";
cout << endl;
for (int i = 0; i < n; ++i) cout << (2 * i) % n << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> par(2, vector<long long>(100005, -1));
vector<vector<char>> visited(2, vector<char>(100005, 0));
void dfs(long long idx, long long state, long long pari,
vector<vector<long long>> &adj) {
visited[state][idx] = 1;
par[state][idx] = pari;
for (auto i : adj[idx]) {
if (!visited[1 - state][i]) {
dfs(i, 1 - state, idx, adj);
}
}
}
vector<char> vis(100005, 0), rec(100005, 0);
bool cyc(long long idx, vector<vector<long long>> &adj) {
vis[idx] = 1;
rec[idx] = 1;
for (auto i : adj[idx]) {
if (rec[i]) return true;
if (!vis[i] && cyc(i, adj)) {
return true;
}
}
rec[idx] = 0;
return false;
}
int main() {
long long(n), (m);
scanf("%lld%lld", &(n), &(m));
;
vector<vector<long long>> adj(n);
for (long long i = 0; i < (n); i++) {
long long(c);
scanf("%lld", &(c));
;
while (c--) {
long long(a);
scanf("%lld", &(a));
;
adj[i].push_back(a - 1);
}
}
long long(s);
scanf("%lld", &(s));
;
--s;
dfs(s, 0, -1, adj);
for (long long i = 0; i < (n); i++) {
if (adj[i].size() == 0 && visited[1][i]) {
printf("Win\n");
vector<long long> re;
long long idx = i, state = 1;
while (idx != -1) {
re.push_back(idx);
idx = par[state][idx];
state = 1 - state;
}
reverse((re).begin(), (re).end());
for (auto i : re) printf("%lld ", i + 1);
printf("\n");
return 0;
}
}
bool t = cyc(s, adj);
if (t) {
printf("Draw\n");
return 0;
}
printf("Lose\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[400001];
vector<int> ch[400001];
int sz[400001];
int mx[400001];
bool ok[400001];
bool ans[400001];
int n;
void dfs(int u, int p) {
sz[u] = 1;
mx[u] = 0;
for (auto v : edge[u]) {
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
mx[u] = max(mx[u], mx[v]);
if (sz[v] * 2 <= n) {
mx[u] = max(mx[u], sz[v]);
}
ch[u].push_back(v);
}
}
if ((sz[u] - mx[u]) * 2 <= n) {
ok[u] = true;
}
}
void dfs1(int u, bool up, int mxu) {
ans[u] = up;
for (auto v : ch[u]) {
ans[u] &= ok[v];
}
vector<int> mxp(ch[u].size());
for (int i = 1; i < ch[u].size(); i++) {
mxp[i] = mxp[i - 1];
mxp[i] = max(mxp[i], mx[ch[u][i - 1]]);
if (sz[ch[u][i - 1]] * 2 <= n) {
mxp[i] = max(mxp[i], sz[ch[u][i - 1]]);
}
}
int mxs = 0;
for (int i = ch[u].size() - 1; i >= 0; i--) {
int mxu1 = mxu;
if ((n - sz[ch[u][i]]) * 2 <= n) {
mxu1 = max(mxu1, (n - sz[ch[u][i]]));
}
int mx1 = max(mxu, max(mxp[i], mxs));
bool ok1 = (2 * (n - sz[ch[u][i]] - mx1)) <= n;
dfs1(ch[u][i], ok1, max(mxu1, max(mxp[i], mxs)));
mxs = max(mxs, mx[ch[u][i]]);
if (sz[ch[u][i]] * 2 <= n) {
mxs = max(mxs, sz[ch[u][i]]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
dfs(0, 0);
dfs1(0, 1, 0);
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long modd = 1000 * 1000 * 1000 + 7;
template <class T>
class depth_first_search_iterator {
public:
stack<pair<T, T>> todo;
function<bool(T)> notvisited;
function<void(T)> mark_visited;
function<set<T>(T)> neighbors;
depth_first_search_iterator() {}
depth_first_search_iterator(T start, function<bool(T)> notv,
function<void(T)> mark_v,
function<set<T>(T)> neigh)
: notvisited(notv),
mark_visited(mark_v),
neighbors(neigh),
end_(false),
current(start),
prev(start) {
todo.push(make_pair(start, start));
operator++();
}
void operator++() {
end_ = true;
while (!todo.empty()) {
current = todo.top().first;
prev = todo.top().second;
todo.pop();
if (notvisited(current)) {
mark_visited(current);
for (const T x : neighbors(current)) {
todo.push(make_pair(x, current));
}
end_ = false;
break;
}
}
}
T operator*() { return current; }
T previous() { return prev; }
bool end() { return end_; }
private:
T current;
T prev;
bool end_;
};
template <class T>
class breadth_first_search_iterator {
public:
queue<pair<T, T>> todo;
function<bool(T)> notvisited;
function<void(T)> mark_visited;
function<set<T>(T)> neighbors;
breadth_first_search_iterator() {}
breadth_first_search_iterator(T start, function<bool(T)> notv,
function<void(T)> mark_v,
function<set<T>(T)> neigh)
: notvisited(notv),
mark_visited(mark_v),
neighbors(neigh),
end_(false),
current(start),
prev(start) {
todo.push(make_pair(start, start));
operator++();
}
void operator++() {
end_ = true;
while (!todo.empty()) {
current = todo.front().first;
prev = todo.front().second;
todo.pop();
if (notvisited(current)) {
mark_visited(current);
for (const T x : neighbors(current)) {
todo.push(make_pair(x, current));
}
end_ = false;
break;
}
}
}
T operator*() { return current; }
T previous() { return prev; }
bool end() { return end_; }
private:
T current;
T prev;
bool end_;
};
template <class T>
class Graph {
public:
vector<T> vertices;
vector<set<int>> neighbors;
depth_first_search_iterator<int> dfs_iterator;
breadth_first_search_iterator<int> bfs_iterator;
vector<bool> visited;
Graph() {}
Graph(int n, T default_val = 0) {
for (int i = 0; i < n; ++i) {
AddVertex(default_val);
}
}
void AddVertex(T val) {
vertices.push_back(val);
neighbors.push_back(set<int>());
}
bool EdgeExists(int i, int j) {
return (neighbors[i].find(j) != neighbors[i].end());
}
void AddEdge(int i, int j) {
if (!EdgeExists(i, j)) {
neighbors[i].insert(j);
if (i != j) {
neighbors[j].insert(i);
}
}
}
T& operator[](int i) { return vertices[i]; }
void RemoveEdge(int i, int j) {
if (EdgeExists(i, j)) {
neighbors[i].erase(find(neighbors[i].begin(), neighbors[i].end(), j));
neighbors[j].erase(find(neighbors[j].begin(), neighbors[j].end(), i));
}
}
void dfs_init(int start) {
visited = vector<bool>(vertices.size(), false);
dfs_iterator = depth_first_search_iterator<int>(
start, [this](int x) { return !visited[x]; },
[this](int x) { visited[x] = true; },
[this](int x) { return neighbors[x]; });
}
void bfs_init(int start) {
visited = vector<bool>(vertices.size(), false);
bfs_iterator = breadth_first_search_iterator<int>(
start, [this](int x) { return !visited[x]; },
[this](int x) { visited[x] = true; },
[this](int x) { return neighbors[x]; });
}
void print_() {
for (int i = (0); i < (0) + (vertices.size()); ++i) {
for (auto x : neighbors[i]) {
if (i <= x) {
cout << i << "-" << x << endl;
}
}
}
}
};
class UnionFind {
public:
vector<int> parent;
vector<int> size;
set<int> roots;
UnionFind(int n) : parent(n), size(n) {
for (int i = (0); i < (0) + (n); ++i) {
roots.insert(i);
}
for (int i = (0); i < (0) + (n); ++i) {
parent[i] = i;
size[i] = 1;
}
}
int Find(int p) {
int root = p;
while (root != parent[root]) {
root = parent[root];
}
while (p != root) {
int newp = parent[p];
parent[p] = root;
p = newp;
}
return root;
}
void Union(int p, int q) {
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ) {
return;
}
if (size[rootP] < size[rootQ]) {
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
roots.erase(rootP);
} else {
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
roots.erase(rootQ);
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cout.precision(17);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> rand_gen(0, modd);
int test_cases = 1;
for (int t = (1); t < (1) + (test_cases); ++t) {
int n;
cin >> n;
int m;
cin >> m;
Graph<pair<int, int>> g(n, make_pair(0, 0));
map<pair<int, int>, int> color;
UnionFind components(n);
bool problem = false;
for (int i = (0); i < (0) + (m); ++i) {
int aa;
cin >> aa;
int bb;
cin >> bb;
int cc;
cin >> cc;
if (aa != bb) {
g.AddEdge(aa - 1, bb - 1);
}
if ((color.find((make_pair(aa - 1, bb - 1))) != color.end())) {
if (color[make_pair(aa - 1, bb - 1)] != cc) {
problem = true;
}
}
if ((color.find((make_pair(bb - 1, aa - 1))) != color.end())) {
if (color[make_pair(bb - 1, aa - 1)] != cc) {
problem = true;
}
}
color[make_pair(aa - 1, bb - 1)] = cc;
components.Union(aa - 1, bb - 1);
}
if (problem) {
cout << "NO" << endl;
continue;
}
for (auto c : components.roots) {
g[c] = make_pair(1, 0);
g.dfs_init(c);
++g.dfs_iterator;
while (!g.dfs_iterator.end()) {
int col;
if ((color.find(
(make_pair(*g.dfs_iterator, g.dfs_iterator.previous()))) !=
color.end())) {
col = color[make_pair(*g.dfs_iterator, g.dfs_iterator.previous())];
} else {
col = color[make_pair(g.dfs_iterator.previous(), *g.dfs_iterator)];
}
g[*g.dfs_iterator] =
make_pair(-g[g.dfs_iterator.previous()].first,
col - g[g.dfs_iterator.previous()].second);
++g.dfs_iterator;
}
}
map<int, set<pair<long long, long long>>> candidates;
for (auto e : color) {
pair<int, int> summ;
summ.first = g[e.first.first].first + g[e.first.second].first;
summ.second = g[e.first.first].second + g[e.first.second].second;
if ((summ.first == 0) && (summ.second != e.second)) {
problem = true;
break;
}
if (summ.first != 0) {
candidates[components.Find(e.first.first)].insert(
make_pair(e.second - summ.second, summ.first));
}
}
if (problem) {
cout << "NO" << endl;
continue;
}
map<int, map<int, int>> breakpoints;
for (int i = (0); i < (0) + (n); ++i) {
breakpoints[components.Find(i)][-g[i].first * g[i].second]++;
}
map<int, double> var;
for (auto c : components.roots) {
if (!candidates[c].empty()) {
pair<long long, long long> answer = *candidates[c].begin();
for (auto x : candidates[c]) {
if (x.first * answer.second != x.second * answer.first) {
problem = true;
break;
}
}
var[c] = 1.0 * answer.first / (1.0 * answer.second);
} else {
long long inclination = 0;
for (auto x : breakpoints[c]) {
inclination -= x.second;
}
for (auto x : breakpoints[c]) {
long long new_inclination = inclination + 2 * x.second;
if (inclination * new_inclination <= 0) {
var[c] = x.first;
break;
}
inclination = new_inclination;
}
}
}
if (problem) {
cout << "NO" << endl;
continue;
}
cout << "YES" << endl;
for (int i = (0); i < (0) + (n); ++i) {
cout << g[i].first * var[components.Find(i)] + g[i].second << " ";
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const long long inf = 0x3f3f3f3f3f3f3f3f;
long long p[maxn], sum[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> p[i];
sum[i] = sum[i - 1] + p[i];
}
sort(sum + 1, sum + n);
long long ans = m * sum[n];
for (int i = 1; i < m; i++) ans -= sum[i];
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
struct crucian {
long long int val, crucian;
} stu[1000];
long long int i, j, k, m, n, sign = 0, sum = 0, value, tem_crucian, previous;
scanf("%lld %lld %lld", &n, &m, &k);
for (i = 0, previous = 0; i < n; i++) {
scanf("%lld %lld", &value, &tem_crucian);
for (j = 0, sign = 0; j < previous; j++) {
if (value == stu[j].val) {
sign = 1;
if (stu[j].crucian > tem_crucian) {
stu[j].crucian = tem_crucian;
}
}
}
if (sign == 0) {
stu[previous].val = value;
stu[previous].crucian = tem_crucian;
previous++;
}
}
for (i = 0; i < previous; i++) {
sum = sum + stu[i].crucian;
if (sum > k) {
printf("%lld\n", k);
return 0;
}
}
printf("%lld\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a;
set<long long int> s;
for (int i = 0; i < n; i++) {
cin >> a;
if (a >= 0) {
s.insert((i + a) % n);
} else {
s.insert(((((i + a) % n) + n) % n));
}
}
if (s.size() == n)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 5;
int n;
vector<int> way[maxn];
int sz[maxn];
pair<int, int> mx[maxn][2];
int ans[maxn];
void upd(int u, pair<int, int> val) {
for (int i = 0; i < 2; i++) {
if (mx[u][i] < val) swap(mx[u][i], val);
}
}
void dfs(int u, int last) {
sz[u] = 1;
for (auto v : way[u]) {
if (v == last) continue;
dfs(v, u);
sz[u] += sz[v];
if (sz[v] <= n / 2)
upd(u, {sz[v], v});
else
upd(u, {mx[v][0].first, v});
}
}
void solve(int u, int last, int ex) {
if (n - sz[u] <= n / 2) ex = max(ex, n - sz[u]);
ans[u] = 1;
if (n - sz[u] > n / 2) {
if (n - sz[u] - ex > n / 2) ans[u] = 0;
}
for (auto v : way[u]) {
if (v == last) continue;
if (sz[v] > n / 2) {
if (sz[v] - mx[v][0].first > n / 2) ans[u] = 0;
}
}
for (auto v : way[u]) {
if (v == last) continue;
solve(v, u,
max(ex, mx[u][0].second == v ? mx[u][1].first : mx[u][0].first));
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
way[u].push_back(v);
way[v].push_back(u);
}
dfs(1, 0);
solve(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double dp[1110][1110];
int in[1110];
int main() {
int n, m;
cin >> n >> m;
for (int i = (0); i < (n); i += 1) cin >> in[i];
for (int i = (0); i < (n); i += 1)
for (int j = (0); j < (n); j += 1)
if (in[i] > in[j]) dp[i][j] = 1;
for (int i = (0); i < (m); i += 1) {
int a, b;
cin >> a >> b;
a--;
b--;
dp[a][b] = dp[b][a] = 0.5;
for (int c = (0); c < (n); c += 1) {
if (c != a && c != b) {
dp[b][c] = dp[a][c] = (dp[b][c] + dp[a][c]) * 0.5;
dp[c][b] = dp[c][a] = 1 - dp[b][c];
}
}
}
double res = 0;
for (int i = (0); i < (n); i += 1)
for (int j = (i); j < (n); j += 1) res += dp[i][j];
printf("%.10f", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dp[4005];
void input() {
int i, j, k, n;
int t, len;
int res = 0;
scanf("%d %d", &n, &k);
for ((i) = 0; (i) < (n); (i)++) {
scanf("%d %d", &t, &len);
for ((j) = (k); (j) >= (0); (j)--) {
if (dp[j] < t) {
res = ((res) > (t - dp[j] - 1) ? (res) : (t - dp[j] - 1));
dp[j] = t + len - 1;
} else
dp[j] += len;
if (j) dp[j] = ((dp[j]) < (dp[j - 1]) ? (dp[j]) : (dp[j - 1]));
}
}
for ((i) = (0); (i) <= (k); (i)++)
res = ((res) > (86400 - dp[i]) ? (res) : (86400 - dp[i]));
printf("%d", res);
}
int main() {
input();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int son[1111111][26], n, pa[1111111], beg[1111111], cnt, dp[1111111],
mn[1111111], k, x[1111111];
bool f[1111111];
char c;
void dfs(int i) {
if (f[i])
beg[i] = ++cnt;
else
beg[i] = cnt;
for (int j = 0; j < 26; j++) {
if (son[i][j]) dfs(son[i][j]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %c", &pa[i], &c);
son[pa[i]][c - 'a'] = i;
}
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &x[i]);
f[x[i]] = 1;
}
dfs(0);
dp[0] = 0;
mn[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = dp[pa[i]] + 1;
if (f[i]) {
dp[i] = min(dp[i], mn[pa[i]] + beg[i]);
mn[i] = min(mn[pa[i]], dp[i] - beg[i] + 1);
} else
mn[i] = min(mn[pa[i]], dp[i] - beg[i]);
}
for (int i = 1; i <= k; i++) printf("%d ", dp[x[i]]);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n + 1], cnt[100001], dp[100001];
memset(cnt, 0, sizeof cnt);
long long m = 0;
for (long long i = 1; i < n + 1; i++) {
cin >> a[i];
cnt[a[i]]++;
m = max(m, a[i]);
}
dp[0] = 0, dp[1] = cnt[1];
for (long long i = 2; i <= m; i++)
dp[i] = max(dp[i - 2] + i * cnt[i], dp[i - 1]);
cout << dp[m];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n;
cin >> m;
long long int a[n], b[m], c[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < m; i++) {
cin >> b[i];
}
c[0] = a[0];
for (long long int i = 1; i < n; i++) {
c[i] = a[i] + c[i - 1];
}
long long int i = 0, j = 0;
while (i < m) {
if (c[j] >= b[i]) {
j == 0 ? cout << j + 1 << " " << (b[i]) << endl
: cout << j + 1 << " " << (b[i] - c[j - 1]) << endl;
i++;
} else {
j++;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
cout << n << " ";
for (int i = 2; i <= n; i++) {
while (n % i == 0) {
n /= i;
cout << n << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int main() {
int n, k;
cin >> n >> k;
char s[MAXN];
cin >> s;
stack<char> c;
int cnt = 0;
char ans[MAXN] = {0};
int len = n;
for (int i = 0; i < n; i++) {
if (!c.empty() && s[i] == ')' && c.top() == '(' && len > k) {
ans[cnt - 1] = 0;
cnt--;
c.pop();
len -= 2;
} else {
c.push(s[i]);
ans[cnt] = s[i];
cnt++;
}
}
printf("%s", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double pi = acos(-1.0);
const double eps = 1e-9;
long long x, second, res, xx, first;
int main() {
cin >> second >> x;
xx = x;
if ((second & 1) != (x & 1)) {
cout << 0;
return 0;
}
res = 1;
while (xx) {
if (xx & 1) res *= 2;
xx /= 2;
}
if (second == x) {
cout << res - 2;
return 0;
}
first = second - x;
if (first < 0) {
cout << 0;
return 0;
}
for (int i = 0; i <= 50; i++) {
long long z = (1ll << (i));
long long zz = (1ll << (i + 1));
if ((x & z) > 0 && (first & zz) > 0) {
cout << 0;
return 0;
}
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int t, x, y;
string line;
map<pair<pair<int, int>, char>, bool> m;
cin >> t;
while (t--) {
cin >> line;
int l = line.length(), sum;
sum = x = y = 0;
m.clear();
for (int i = 0; i < l; i++) {
int temX = x, temY = y;
if (line[i] == 'N') {
temY++;
if (m.find({{x, y}, 'N'}) == m.end()) {
m[{{x, y}, 'N'}] = m[{{temX, temY}, 'S'}] = 1;
sum += 5;
} else
sum += 1;
} else if (line[i] == 'S') {
temY--;
if (m.find({{x, y}, 'S'}) == m.end()) {
m[{{x, y}, 'S'}] = m[{{temX, temY}, 'N'}] = 1;
sum += 5;
} else
sum += 1;
} else if (line[i] == 'E') {
temX++;
if (m.find({{x, y}, 'E'}) == m.end()) {
m[{{x, y}, 'E'}] = m[{{temX, temY}, 'W'}] = 1;
sum += 5;
} else
sum += 1;
} else {
temX--;
if (m.find({{x, y}, 'W'}) == m.end()) {
m[{{x, y}, 'W'}] = m[{{temX, temY}, 'E'}] = 1;
sum += 5;
} else
sum += 1;
}
x = temX, y = temY;
}
cout << sum << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
string s1, s2;
int i, j;
cin >> s1 >> s2;
for (i = j = 0; s2[j]; j++) {
if (s1[i] == s2[j])
i++;
else if (s2[j] != s2[j - 1])
break;
}
if (s1[i] == '\0' && s2[j] == '\0')
cout << "YES";
else
cout << "NO";
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int freq[10];
vector<int> v;
bool cmp(int a, int b) { return a > b; }
int main() {
int n;
cin >> n;
int tmp1;
int total = 0;
for (int i = 0; i < n; i++) {
cin >> tmp1;
freq[tmp1]++;
total += tmp1;
}
total %= 3;
bool ok = false;
if (total == 1) {
if (freq[1] > 0) {
freq[1]--;
} else if (freq[4] > 0) {
freq[4]--;
} else if (freq[7] > 0) {
freq[7]--;
} else if (freq[2] > 1) {
freq[2] -= 2;
} else if (freq[2] > 0 && freq[5] > 0) {
freq[2]--;
freq[5]--;
} else if (freq[5] > 1) {
freq[5] -= 2;
} else if (freq[8] > 0 && freq[5] > 0) {
freq[8]--;
freq[5]--;
} else if (freq[8] > 1) {
freq[8] -= 2;
}
} else if (total == 2) {
if (freq[2] > 0) {
freq[2]--;
} else if (freq[5] > 0) {
freq[5]--;
} else if (freq[8] > 0) {
freq[8]--;
} else if (freq[1] > 1) {
freq[1] -= 2;
} else if (freq[1] > 0 && freq[4] > 0) {
freq[1]--;
freq[4]--;
} else if (freq[4] > 1) {
freq[4] -= 2;
} else if (freq[7] > 0 && freq[1] > 0) {
freq[7]--;
freq[1]--;
} else if (freq[7] > 0 && freq[4] > 0) {
freq[7]--;
freq[4]--;
} else if (freq[7] > 1) {
freq[7] -= 2;
}
}
total = 0;
for (int i = 0; i <= 9; i++) {
for (int j = 1; j <= freq[i]; j++) {
v.push_back(i);
total += i;
}
}
total %= 3;
if (total != 0 || v.empty() || freq[0] == 0) {
cout << -1;
return 0;
}
sort(v.begin(), v.end(), cmp);
if (v[0] == 0) {
cout << 0;
return 0;
}
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
int n, p, k;
struct people {
long long a;
long long s[10];
bool operator<(const people &x) const { return a > x.a; }
} a[N];
long long dp[N][(1 << 7) + 5];
int main() {
cin >> n >> p >> k;
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i].a);
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < p; ++j) {
scanf("%lld", &a[i].s[j]);
}
}
sort(a + 1, a + n + 1);
int allst = (1 << p);
for (int i = 1; i <= n; ++i) {
for (int st = 0; st < allst; ++st) {
dp[i][st] = max(dp[i][st], dp[i - 1][st]);
if (st && dp[i - 1][st] == 0) continue;
for (int j = 0; j < p; ++j) {
if ((1 << j) & st) continue;
dp[i][st | (1 << j)] =
max(dp[i][st | (1 << j)], dp[i - 1][st] + a[i].s[j]);
}
int cnt = __builtin_popcount(st);
if (i - cnt <= k && !(st && dp[i - 1][st] == 0))
dp[i][st] = max(dp[i][st], dp[i - 1][st] + a[i].a);
}
}
cout << dp[n][allst - 1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool b2(const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.first > p2.first.first;
}
bool b1(const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.second < p2.first.second;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
n = n * 2;
long long int sum = 0, sum1 = 0;
int arr[n];
for (int i = 0; i <= n - 1; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < n / 2; i++) sum1 += arr[i];
if (sum1 * 2 == sum)
cout << "-1" << endl;
else {
for (int i = 0; i <= n - 1; i++) cout << arr[i] << " ";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
int m = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
m = max(m, a[i]);
}
int count[m + 1];
for (int i = 0; i < m + 1; i++) {
count[i] = 0;
}
for (int i = 0; i < n; i++) {
count[a[i] - 1]++;
}
sort(count, count + m, greater<int>());
int c = count[0], ans = count[0];
for (int i = 1; i < m; i++) {
if (count[i] >= c) {
if (c > 0) ans = ans + c - 1;
c--;
} else {
ans = ans + count[i];
c = count[i];
}
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n1;
cin >> n1;
while (n1--) {
string str;
vector<int> arr(26, 0);
cin >> str;
int n = str.size();
for (int i = 0; i < n; i++) {
arr[str[i] - 'a']++;
}
int flag = 0;
int flag1 = 0;
for (int i = 0; i < 26; i++) {
if (arr[i] > 1) {
cout << "No" << endl;
flag1 = 1;
break;
} else if (arr[i] == 0 && flag == 1) {
flag = 2;
} else if (arr[i] == 1 && flag == 2) {
cout << "No" << endl;
flag1 = 1;
break;
} else if (arr[i] == 1 && flag == 0) {
flag = 1;
}
}
if (!flag1) cout << "Yes" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long A, B, N;
long long l, t, m;
int main() {
cin >> A >> B >> N;
for (int i = 0; i < N; i++) {
cin >> l >> t >> m;
if (t < A + (l - 1) * B) {
cout << -1 << endl;
} else {
long long left = l, right = (t - A) / B + 1;
while (left <= right) {
long long mid = (left + right) / 2;
long long sum = (mid - l + 1) * (2 * A + B * (mid + l) - 2 * B) / 2;
if (sum <= m * t) {
left = mid + 1;
} else {
right = mid - 1;
}
}
cout << right << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct qq {
int to, dis, next;
} a[2000];
int n, tot, head[1001], vis[1001];
void add(int x, int y, int z) {
a[++tot].to = y;
a[tot].next = head[x];
a[tot].dis = z;
head[x] = tot;
}
int dfs(int x) {
int ans = 0;
vis[x] = 1;
for (int i = head[x]; i; i = a[i].next)
if (!vis[a[i].to]) ans = max(ans, a[i].dis + dfs(a[i].to));
return ans;
}
int main() {
int u, v, w;
cin >> n;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
cout << dfs(0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int n1, n2, ticks, last[52][3][105];
long long target, DP[52][3][105];
long long dp(int i, int carry, int bitcount) {
if (bitcount < 0) return 0;
if (i == 51) return (carry == 0 && bitcount == 0);
long long &ans = DP[i][carry][bitcount];
if (last[i][carry][bitcount] == ticks) return ans;
ans = 0;
int dig = ((target >> i) & 1);
if (carry == dig) ans += dp(i + 1, 0, bitcount);
if (carry == dig && i <= n1 && i <= n2 && bitcount >= 2)
ans += dp(i + 1, 1, bitcount - 2);
if (carry != dig && i <= n1 && bitcount >= 1)
ans += dp(i + 1, carry, bitcount - 1);
if (carry != dig && i <= n2 && bitcount >= 1)
ans += dp(i + 1, carry, bitcount - 1);
last[i][carry][bitcount] = ticks;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long S;
cin >> S;
long long ans = 0;
for (int d1 = 0; d1 <= 50; d1++)
for (int d2 = 0; d2 <= 50; d2++)
for (int bitcount = 0; bitcount <= 100; bitcount++) {
long long lca_multiplier = (1LL << (d1 + 1)) + (1LL << (d2 + 1)) - 3;
if (S < lca_multiplier) continue;
target = S % lca_multiplier;
target -= (1LL << d2) - 1;
if (target < 0) continue;
target += bitcount;
if (target % 2 == 1) continue;
n1 = d1 - 1;
n2 = d2 - 1;
ticks++;
long long temp = dp(1, 0, bitcount);
ans += temp;
}
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[1 << 12];
int main() {
ios_base::sync_with_stdio(false);
int n, i, ans = 0;
cin >> n;
for (i = 2; i < (1 << (n + 1)); i++) cin >> a[i];
for (i = (1 << n) - 1; i >= 1; i--) {
ans += (max(a[2 * i], a[2 * i + 1]) - min(a[2 * i], a[2 * i + 1]));
a[i] += max(a[2 * i], a[2 * i + 1]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
template <typename T>
T gcd(const T& a, const T& b) {
return a == 0 ? b : gcd(b % a, a);
}
template <typename T>
bool isprime(const T& k) {
for (T i = 2; i * i <= k; i++)
if ((k % i) == 0) return false;
return true;
}
template <typename T>
T mabs(const T& x) {
if (x >= 0) return x;
return -x;
}
const int maxn = 110;
int was[maxn];
int a[maxn], d[maxn];
vector<int> g[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
}
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
int x = i + d[i];
int y = i - d[i];
if (x >= 0 && x < n) {
g[i].push_back(x);
g[x].push_back(i);
}
if (y >= 0 && y < n) {
g[i].push_back(y);
g[y].push_back(i);
}
}
for (int i = 0; i < n; i++) {
memset(was, 0, sizeof(was));
queue<int> q;
q.push(i);
was[i] = 1;
for (; q.size();) {
int p = q.front();
q.pop();
for (int i = 0; i < g[p].size(); i++) {
int v = g[p][i];
if (!was[v]) {
was[v] = 1;
q.push(v);
}
}
}
for (int j = 0; j < n; j++)
if (a[j] == i && !was[j]) {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<int> V;
void bfs(int x, int y, int n) {
queue<int> Q;
if (x <= n) Q.push(x);
if (y <= n) Q.push(y);
while (!Q.empty()) {
int a = Q.front();
Q.pop();
V.insert(a);
long long b = ((long long)a * 10LL) + (long long)x;
long long c = ((long long)a * 10LL) + (long long)y;
if (b <= n) Q.push(b);
if (c <= n) Q.push(c);
}
}
void bfs1(int x, int n) {
queue<int> Q;
if (x <= n) Q.push(x);
while (!Q.empty()) {
int a = Q.front();
Q.pop();
V.insert(a);
long long b = ((long long)a * 10LL) + (long long)x;
long long c = ((long long)a * 10LL) + (long long)0LL;
if (b <= n) Q.push(b);
if (c <= n) Q.push(c);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= 9; i++) {
for (int j = i + 1; j <= 9; j++) {
if (i != j) bfs(i, j, n);
}
}
for (int i = 1; i <= 9; i++) bfs1(i, n);
cout << V.size() << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7 + 10;
const int N = 7;
int n;
int l[N], r[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", l + i, r + i);
}
double ans = 0;
for (int msk = 1; msk < (1 << n); ++msk) {
if (__builtin_popcount(msk) > 1) {
int ll = 0, rr = INF;
for (int i = 0; i < n; ++i) {
if (msk & (1 << i)) {
ll = max(ll, l[i]);
rr = min(rr, r[i]);
}
}
for (int k = ll; k <= rr; ++k) {
long long cnt = 1;
for (int i = 0; i < n; ++i) {
if (!(msk & (1 << i))) {
cnt *= max(0, min(k - 1, r[i]) - l[i] + 1);
}
}
ans += cnt * k;
}
continue;
}
for (int msk2 = 0; msk2 < (1 << n); ++msk2) {
if (msk != (1 << n) - 1 && !msk2) continue;
if (msk2 & msk) continue;
int ll1 = 0, rr1 = INF;
int ll2 = 0, rr2 = INF;
for (int i = 0; i < n; ++i) {
if (msk & (1 << i)) {
ll1 = max(ll1, l[i]);
rr1 = min(rr1, r[i]);
}
if (msk2 & (1 << i)) {
ll2 = max(ll2, l[i]);
rr2 = min(rr2, r[i]);
}
}
for (int k = ll2; k <= rr2; ++k) {
long long cnt = 1;
for (int i = 0; i < n; ++i) {
if (msk & (1 << i)) continue;
if (msk2 & (1 << i)) continue;
cnt *= max(0, min(k - 1, r[i]) - l[i] + 1);
}
cnt *= max(0, rr1 - max(ll1, k + 1) + 1);
ans += cnt * k;
}
}
}
for (int i = 0; i < n; ++i) {
ans /= (r[i] - l[i] + 1);
}
printf("%.12f\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
vector<long long int> factors;
int cnt = 0;
for (long long int i = 1; i * i <= n; i++)
if (n % i == 0) {
factors.push_back(i);
cnt += 2;
if (i * i == n) cnt--;
}
if (k <= cnt)
if (k <= (cnt + 1) / 2)
cout << factors[k - 1] << endl;
else
cout << n / factors[cnt - k] << endl;
else
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N], g[N], h[2][N];
char a[N];
int n, m;
int pre[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> m;
dp[0] = 0, g[0] = 0, pre[0] = 0;
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + (a[i] == '?');
if (a[i] != 'a') h[0][i] = h[1][i - 1] + 1;
if (a[i] != 'b') h[1][i] = h[0][i - 1] + 1;
dp[i] = dp[i - 1], g[i] = g[i - 1];
if (h[m & 1][i] >= m) {
if (dp[i] < dp[i - m] + 1)
dp[i] = dp[i - m] + 1, g[i] = g[i - m] + (pre[i] - pre[i - m]);
if (dp[i] == dp[i - m] + 1)
g[i] = min(g[i - m] + pre[i] - pre[i - m], g[i]);
}
}
cout << g[n];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 3;
int si[maxn], di[maxn], n;
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d%d", &si[i], &di[i]);
int prev = si[1], ans = si[1];
for (int i = 2; i <= n; i++) {
int j = 0;
while (si[i] + j * di[i] <= prev) ++j;
prev = si[i] + j * di[i];
ans = prev;
}
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 55;
int n, cnt[N];
vector<pair<int, int> > adj[N];
void dfs(int u, int p, int depth, vector<pair<int, int> > &leaves) {
bool leaf = 1;
for (auto e : adj[u]) {
int v, c;
tie(v, c) = e;
if (v == p) continue;
dfs(v, u, depth + c, leaves);
leaf = 0;
}
if (leaf) leaves.emplace_back(u, depth);
}
int dp[N][N], best[N][N];
int go(int root, int pre, int total, int put) {
vector<pair<int, int> > leaves;
dfs(root, pre, 0, leaves);
int sz = ((int)(leaves).size());
for (int from = (int)(sz + 1) - 1; from >= ((int)0); from--) {
for (int left = (int)(0); left < ((int)put + 1); left++) {
if (from == sz) {
best[from][left] = (left ? -INF : INF);
} else {
best[from][left] = best[from + 1][left];
int l = leaves[from].first, cost = leaves[from].second;
for (int pick = 1; pick <= left; pick++) {
best[from][left] =
max(best[from][left],
min(cost + dp[l][total - pick], best[from + 1][left - pick]));
}
}
}
}
return best[0][put];
}
void dfsSize(int u, int p) {
for (auto e : adj[u]) {
int v, c;
tie(v, c) = e;
if (v == p) continue;
dfsSize(v, u);
cnt[u] += cnt[v];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int _ = 0; _ < (int)(n - 1); _++) {
int u, v, c;
cin >> u >> v >> c;
u--;
v--;
adj[u].emplace_back(v, c);
adj[v].emplace_back(u, c);
}
int s;
cin >> s;
s--;
int m;
cin >> m;
for (int _ = 0; _ < (int)(m); _++) {
int u;
cin >> u;
cnt[u - 1]++;
}
for (int total = 1; total <= m; total++) {
for (int u = 0; u < (int)(n); u++) {
dp[u][total] = go(u, u, total, total);
}
}
dfsSize(s, -1);
int ans = INF;
for (auto e : adj[s]) {
int v, c;
tie(v, c) = e;
ans = min(ans, c + go(v, s, m, cnt[v]));
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
printf("%d %d\n", a[1] - a[0], a[n - 1] - a[0]);
for (i = 1; i < n - 1; i++) {
int mi = min(a[i] - a[i - 1], a[i + 1] - a[i]);
int ma = max(a[i] - a[0], a[n - 1] - a[i]);
printf("%d %d\n", mi, ma);
}
printf("%d %d\n", a[n - 1] - a[n - 2], a[n - 1] - a[0]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void change(string &s) {
for (int i = 0; i < s.length(); i++) {
s[i] = (s[i] < 97) ? tolower(s[i]) : toupper(s[i]);
}
}
int main() {
string s;
cin >> s;
int len = s.length(), capCount = 0;
bool Caps = false;
for (int i = 0; i < len; i++) capCount += ((int)s[i] < 97);
if (capCount == len || (capCount == len - 1 && s[0] >= 97)) change(s);
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, N = 1e5 + 10;
int n, m, f[N];
int main() {
f[1] = 1, f[2] = 2;
for (int i = 3; i < N; ++i) f[i] = (f[i - 1] + f[i - 2]) % mod;
scanf("%d%d", &n, &m);
printf("%d\n", 2ll * (f[n] + f[m] - 1) % mod);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long c, hr, hb, wr, wb;
bool jau1 = false, jau2 = false;
cin >> c >> hr >> hb >> wr >> wb;
long long ats = 0;
for (int i = 0; i <= 1e7; i++) {
if (wb * i <= c) {
ats = max(ats, i * hb + (c - wb * i) / wr * hr);
} else
jau1 = true;
if (wr * i <= c) {
ats = max(ats, i * hr + (c - wr * i) / wb * hb);
} else
jau2 = true;
if (jau1 && jau2) break;
}
cout << ats << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 2000000000;
long long INFF = 8000000000000000000LL;
double PI = acos(-1);
inline string IntToString(int a) {
char x[100];
sprintf(x, "%d", a);
string s = x;
return s;
}
inline int StringToInt(string a) {
char x[100];
int res;
strcpy(x, a.c_str());
sscanf(x, "%d", &res);
return res;
}
inline string GetString(void) {
char x[1000005];
scanf("%s", x);
string s = x;
return s;
}
inline bool angka(char a) { return (a >= '0' && a <= '9'); }
inline bool kecil(char a) { return (a >= 'a' && a <= 'z'); }
inline bool besar(char a) { return (a >= 'A' && a <= 'Z'); }
inline string uppercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (kecil(s[i])) s[i] = s[i] - 'a' + 'A';
return s;
}
inline string lowercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (besar(s[i])) s[i] = s[i] - 'A' + 'a';
return s;
}
int main() {
int n, a;
int level[305], data[305][305];
scanf("%d", &n);
for (int(i) = (1); (i) <= (n); (i)++) {
for (int(j) = (1); (j) <= (n); (j)++) scanf("%d", &data[i][j]);
}
for (int(i) = (1); (i) <= (n); (i)++) {
scanf("%d", &a);
level[a] = i;
}
for (int(i) = (1); (i) <= (n); (i)++) {
for (int(j) = (1); (j) <= (n); (j)++)
if (data[i][j] != i) {
for (int(k) = (1); (k) <= (data[i][j]); (k)++)
if (k != i) {
if (level[k] < level[data[i][j]]) goto hell;
}
printf("%d", data[i][j]);
break;
hell:;
}
if (i < n)
printf(" ");
else
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
map<long long int, long long int> mp;
for (long long int i = 0; i < 101; i++) mp[b + i * a]++;
for (long long int j = 0; j < 101; j++) {
if (mp.find(d + j * c) != mp.end()) {
cout << d + j * c;
return 0;
}
}
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
long long reset(long long n, long long pos) { return n = n & ~(1LL << pos); }
bool check(long long n, long long pos) { return (bool)(n & (1LL << pos)); }
long long mul(long long a, long long b) {
long long c;
c = (a % 1000000007 * b % 1000000007) % 1000000007;
return c;
}
long long add(long long a, long long b) {
long long c;
c = (a % 1000000007 + b % 1000000007) % 1000000007;
return c;
}
long long sub(long long a, long long b) {
long long c;
c = ((a % 1000000007 - b % 1000000007) % 1000000007 + 1000000007) %
1000000007;
return c;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long exgcd(long long x, long long y, long long &a, long long &b) {
int flag = 0;
long long t, la = 1, lb = 0, ra = 0, rb = 1;
while (x % y) {
if (flag == 0)
la -= x / y * ra, lb -= x / y * rb;
else
ra -= x / y * la, rb -= x / y * lb;
t = x, x = y, y = t % y;
flag = 1 - flag;
}
if (flag == 0)
a = ra, b = rb;
else
a = la, b = lb;
return y;
}
long long l, r;
vector<long long> dig;
long long dp[25][11][11];
long long solve(long long pos, long long choto, long long frr) {
long long &ret = dp[pos][choto][frr];
if (ret != -1) return ret;
if (pos == dig.size() - 1) {
if (frr == 0)
return ret = choto;
else if (choto >= frr)
return ret = 1;
else
return ret = 0;
}
ret = 0;
for (long long i = 0; i <= choto; i++) {
long long now_frr = frr;
if (frr == 0) now_frr = i;
ret += solve(pos + 1, 9, now_frr);
}
return ret;
}
long long calc(long long num) {
dig.clear();
for (long long i = 0; i <= 20; i++) {
dig.push_back(num % 10);
num /= 10;
}
reverse(dig.begin(), dig.end());
long long is = 0;
long long ans = 0;
for (long long i = 0; i < dig.size(); i++) {
if (dig[i] == 0)
continue;
else {
ans += solve(i, dig[i] - 1, is);
if (is == 0) is = dig[i];
}
}
if (dig[dig.size() - 1] == is && is != 0) ans++;
return ans;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%lld", &l);
scanf("%lld", &r);
printf("%lld\n", calc(r) - calc(l - 1));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void sc(T &n) {
register int f = 1;
n = 0;
char c = getchar_unlocked();
while (c != '-' && c < '0') c = getchar_unlocked();
if (c == '-') f = -1, c = getchar_unlocked();
while (c >= '0' && c <= '9')
n = (n << 3) + (n << 1) + c - '0', c = getchar_unlocked();
n = n * f;
}
template <typename T>
void pr(T a) {
char s[30];
if (a < 0) {
putchar_unlocked('-');
a *= -1;
}
int i = 0;
do {
s[i++] = a % 10 + '0';
a /= 10;
} while (a);
i--;
while (i >= 0) putchar_unlocked(s[i--]);
}
template <typename T>
T sub(T x, T y) {
if (x < y) return y - x;
return x - y;
}
int main() {
int n, m;
sc(n);
sc(m);
int sz = min(n, m) + 1;
pr(sz);
puts("");
int i = 0, j = min(n, m);
while (sz--) {
pr(i);
putchar_unlocked(' ');
pr(j);
puts("");
i++;
j--;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ld eps = 1e-8;
template <class U, class V>
ostream& operator<<(ostream& out, const pair<U, V>& p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <size_t i, class T>
ostream& print_tuple_utils(ostream& out, const T& tup) {
if constexpr (i == tuple_size<T>::value)
return out << ")";
else
return print_tuple_utils<i + 1, T>(out << (i ? ", " : "(") << get<i>(tup),
tup);
}
template <class... U>
ostream& operator<<(ostream& out, const tuple<U...>& tup) {
return print_tuple_utils<0, tuple<U...>>(out, tup);
}
template <class Con, class = decltype(begin(declval<Con>()))>
typename enable_if<!is_same<Con, string>::value, ostream&>::type operator<<(
ostream& out, const Con& container) {
out << "{";
for (auto it = container.begin(); it != container.end(); ++it)
out << (it == container.begin() ? "" : ", ") << *it;
return out << "}";
}
struct Node {
ll length;
ll min_left, max_right;
ll ans;
friend ostream& operator<<(ostream& out, const Node& u) {
return out << "(" << u.length << ", " << u.min_left << ", " << u.max_right
<< ", " << u.ans << ")";
}
Node() : ans(-1) {}
Node(ll h) : length(0), min_left(2 * h), max_right(2 * h), ans(0) {}
Node(const Node& lhs, const Node& rhs, ll mid_dist) {
if (lhs.ans == -1) {
*this = rhs;
return;
}
if (rhs.ans == -1) {
*this = lhs;
return;
}
ans = max({lhs.ans, rhs.ans,
lhs.min_left + rhs.max_right + mid_dist + lhs.length});
length = lhs.length + rhs.length + mid_dist;
min_left = max(lhs.min_left, rhs.min_left - lhs.length - mid_dist);
max_right = max(rhs.max_right + mid_dist + lhs.length, lhs.max_right);
}
};
const int maxn = 101010;
int n, m;
ll d[maxn], h[maxn];
Node it[maxn * 4];
void build(int i, int l, int r) {
if (r - l == 1) {
it[i] = Node(h[l]);
return;
}
int mid = (l + r) / 2;
build(2 * i, l, mid);
build(2 * i + 1, mid, r);
it[i] = Node(it[2 * i], it[2 * i + 1], d[mid - 1]);
}
Node get(int from, int to, int i, int l, int r) {
if (from >= r or l >= to) return Node();
if (from <= l and r <= to) return it[i];
int mid = (l + r) / 2;
return Node(get(from, to, 2 * i, l, mid), get(from, to, 2 * i + 1, mid, r),
d[mid - 1]);
}
Node query(int l, int r) {
if (0)
cerr << "["
"l"
" = "
<< (l) << "] "
<< "["
"r"
" = "
<< (r) << "] " << endl;
if (l < r) return get(l, r, 1, 0, n);
if (0) cerr << "here" << endl;
auto u = get(l, n, 1, 0, n);
auto v = get(0, r, 1, 0, n);
if (0)
cerr << "["
"u"
" = "
<< (u) << "] " << endl;
if (0)
cerr << "["
"v"
" = "
<< (v) << "] " << endl;
if (0)
cerr << "["
"d[n - 1]"
" = "
<< (d[n - 1]) << "] " << endl;
return Node(u, v, d[n - 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = (int)(0); i < (int)(n); ++i) cin >> d[i];
for (int i = (int)(0); i < (int)(n); ++i) cin >> h[i];
build(1, 0, n);
while (m--) {
int l, r;
cin >> l >> r;
--l;
cout << query(r, l).ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int f(int a, int b) {
if (a % b) return a / b + 1;
return a / b;
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, a, b;
cin >> n >> a >> b;
int ans = 6;
int x = b, left = 4;
while (x + a <= n && left) x += a, left--;
left -= 4 - left;
if (left < 0) left = 0;
int cnt = 1;
x = a;
while (x + a <= n && cnt < left) x += a, cnt++;
ans = min(ans, 2 + f(left, cnt));
if (2 * b <= n) {
x = 2 * b, left = 4;
while (x + a <= n && left) x += a, left--;
cnt = 1, x = a;
while (x + a <= n && cnt < left) x += a, cnt++;
ans = min(ans, 1 + f(left, cnt));
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n, q;
long long a[MAXN], b;
long long sum[MAXN * 2];
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
sum[n + i] = sum[n + i - 1] + a[i];
}
while (q--) {
scanf("%lld", &b);
if (sum[n] <= b) {
puts("1");
continue;
}
int minLen = n;
int start = 0, end = 0;
for (int i = 1, j = 1; i <= (n << 1);) {
while (i <= (n << 1) && sum[i] - sum[j - 1] <= b) {
++i;
}
int len = i - j;
if (len < minLen) {
minLen = len;
start = j;
end = i;
}
while (sum[i] - sum[j - 1] > b) {
++j;
}
}
int minGroup = n;
for (int k = start; k <= end; ++k) {
start = (k - 1) % n + 1;
int group = 0;
for (int i = start; i < n + start;) {
++group;
if (i + minLen > n + start) {
break;
}
for (int j = i + minLen - 1; j <= n + start; ++j) {
if (j == n + start || sum[j] - sum[i - 1] > b) {
i = j;
break;
}
}
}
minGroup = min(minGroup, group);
}
printf("%d\n", minGroup);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int A[100], B[100], N, M, i, j, k, l, m, mc;
int main() {
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", A + i);
scanf("%d", &M);
for (i = 1; i <= M; i++) scanf("%d", B + i);
mc = 0;
m = -1;
for (i = 1; i <= N; i++) {
for (j = 1; j <= M; j++) {
if (B[j] % A[i] == 0) {
l = B[j] / A[i];
if (l == m) {
mc++;
} else if (l > m) {
mc = 1;
m = l;
}
}
}
}
printf("%d\n", mc);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 35;
long long prefix[M][N], bit[M][N];
int get_sum(int p, int left, int right) {
int res = prefix[p][right];
if (left > 0) res -= prefix[p][left - 1];
return res;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int>> arr;
arr.reserve(m);
for (int i = 0; i < m; i++) {
int left, right, q;
scanf("%d %d %d", &left, &right, &q);
for (long long j = 0; (1LL << j) <= q; j++) {
if (q & (1 << j)) {
bit[j][left - 1] += 1;
bit[j][right] += -1;
}
}
arr.push_back({left, right, q});
}
for (int j = 0; j < M; j++) {
int balance = 0;
for (int i = 0; i < n; i++) {
balance += bit[j][i];
prefix[j][i] = (balance > 0);
if (i > 0) prefix[j][i] += prefix[j][i - 1];
}
}
for (auto it : arr) {
for (int j = 0; j < M; j++) {
if (((1LL << j) & it[2]) == 0 &&
get_sum(j, it[0] - 1, it[1] - 1) == it[1] - it[0] + 1) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n; i++) {
long long elem = 0;
for (int j = 0; j < M; j++) {
if (get_sum(j, i, i)) elem |= (1LL << j);
}
printf("%lld ", elem);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (arr[0] < arr[n - 1]) {
cout << "YES" << endl;
;
} else {
cout << "NO" << endl;
;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
char string[101];
int i, count = 0, count1 = 0, count2 = 0;
scanf("%s", string);
for (i = 0; i < strlen(string); i++) {
if (string[i] >= 65 && string[i] <= 90) count++;
if (string[i] >= 97 && string[i] <= 122) count1++;
if (string[i] >= '0' && string[i] <= '9') count2++;
}
if (strlen(string) > 4 && count > 0 && count1 > 0 && count2 > 0)
printf("Correct");
else
printf("Too weak");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int x;
int main() {
int n;
cin >> n;
int i = 1;
while (x <= 1e5) {
x = ((1 << i) - 1) * (1 << (i - 1));
vec.push_back(x);
i++;
}
for (int i = vec.size() - 1; i >= 0; i--) {
if (n % vec[i] == 0 && vec[i] <= n) {
cout << vec[i];
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 410;
char S[MAXN], T[30];
int N, V, M, L;
vector<int> adj[MAXN], radj[MAXN];
void addedge(int x, int y) {
adj[x].push_back(y);
radj[y].push_back(x);
}
vector<int> nodes[MAXN];
int C, bel[MAXN];
bool vis[MAXN];
stack<int> stk;
vector<int> topo;
void dfs1(int x) {
vis[x] = true;
for (int t : adj[x]) {
if (!vis[t]) {
dfs1(t);
}
}
stk.push(x);
}
void dfs2(int x) {
vis[x] = false;
bel[x] = C;
nodes[C].push_back(x);
for (int t : radj[x]) {
if (vis[t]) {
dfs2(t);
}
}
}
void find_scc() {
V = 2 * N;
for (int i = 0; i < V; i++) {
if (!vis[i]) {
dfs1(i);
}
}
while (!stk.empty()) {
int x = stk.top();
stk.pop();
if (vis[x]) {
dfs2(x);
C++;
}
}
}
int must[MAXN];
bool check() {
for (int i = 0; i < N; i++) {
for (int t : adj[2 * i + must[i]]) {
if (must[t / 2] != t % 2) {
return false;
}
}
}
return true;
}
void dfs(int x) {
vis[x] = true;
if (must[x / 2] == -1) {
must[x / 2] = x % 2;
}
for (int t : adj[x]) {
if (!vis[t]) {
dfs(t);
}
}
}
bool make(int x) {
memset((must), (-1), sizeof(must));
memset((vis), (false), sizeof(vis));
for (int i = 0; i <= x; i++) {
dfs(2 * i + T[S[i] - 'a']);
}
for (int i = 0; i <= x; i++) {
must[i] = T[S[i] - 'a'];
}
for (int i = 0; i < C; i++) {
dfs(nodes[i][0]);
}
return check();
}
bool can(int x) {
for (int i = x; i < N; i++) {
bool seen[2] = {false, false}, found = false;
for (int j = (i == x ? S[i] - 'a' + 1 : 0); j < L; j++) {
if (seen[T[j]]) {
continue;
}
seen[T[j]] = true;
S[i] = 'a' + j;
if (make(i)) {
found = true;
break;
}
}
if (!found) {
return false;
}
}
return make(N);
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%s %d %d", T, &N, &M);
L = strlen(T);
for (int i = 0; i < L; i++) {
T[i] = (T[i] == 'V');
}
int pos1, pos2;
char t1, t2;
for (int i = 0; i < M; i++) {
scanf("%d %c %d %c", &pos1, &t1, &pos2, &t2);
pos1 = 2 * (pos1 - 1) + (t1 == 'V');
pos2 = 2 * (pos2 - 1) + (t2 == 'V');
addedge(pos1, pos2);
addedge(pos2 ^ 1, pos1 ^ 1);
}
find_scc();
scanf("%s", S);
for (int i = N; i >= 0; i--) {
if (can(i)) {
puts(S);
return 0;
}
}
puts("-1");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 5;
int c[maxn], res[maxn], dp[maxn][maxn];
int main() {
int n, K;
scanf("%d%d", &n, &K);
for (int i = 0; i < n; ++i) {
scanf("%d", &c[i]);
}
sort(c, c + n);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = K; j >= c[i]; --j) {
for (int k = 0; k + c[i] <= K; ++k) {
if (dp[j - c[i]][k]) dp[j][k] = dp[j][k + c[i]] = 1;
}
}
}
int ans = 0;
for (int i = 0; i <= K; ++i)
if (dp[K][i]) res[ans++] = i;
printf("%d\n", ans);
for (int i = 0; i < ans; ++i) {
printf("%d%c", res[i], (i == (ans - 1) ? '\n' : ' '));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:640000000")
using namespace std;
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
const double PI = acos(-1.0);
template <class T>
inline T _abs(T n) {
return ((n) < 0 ? -(n) : (n));
}
template <class T>
inline T _max(T a, T b) {
return (!((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _min(T a, T b) {
return (((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _swap(T& a, T& b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int a[54][54];
int n;
int call() {
{
for (int i = (int)(0); i <= (int)(n - 1); i++) {
int sum = 0;
for (int j = (int)(0); j <= (int)(n - 1); j++) {
sum += a[i][j];
}
if (sum % 2 == 0) return 0;
}
for (int i = (int)(0); i <= (int)(n - 1); i++) {
int sum = 0;
for (int j = (int)(0); j <= (int)(n - 1); j++) {
sum += a[j][i];
}
if (sum % 2 == 0) return 0;
}
int sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i][i];
}
if (sum % 2 == 0) return 0;
sum = 0;
for (int i = 0, j = n - 1; i < n; i++, j--) {
sum += a[i][j];
}
if (sum % 2 == 0) return 0;
return 1;
}
}
int main() {
while (~scanf("%d", &n)) {
int mid = n / 2;
int in = 1;
int r = 0, c = mid;
memset(a, 0, sizeof(a));
a[r][c] = in++;
for (int i = (int)(in); i <= (int)(n * n); i++) {
c++;
r--;
if (r < 0 && c >= n) {
c--;
r++;
r++;
a[r][c] = i;
} else if (r < 0) {
r = n - 1;
a[r][c] = i;
} else if (c >= n) {
c = 0;
a[r][c] = i;
} else if (a[r][c] != 0) {
c--;
r++;
r++;
a[r][c] = i;
} else
a[r][c] = i;
}
for (int i = (int)(0); i <= (int)(n - 1); i++) {
for (int j = (int)(0); j <= (int)(n - 1); j++) {
if (j) printf(" ");
printf("%d", a[i][j]);
}
printf("\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 5;
int root;
long long dp[maxn][maxn];
int p[maxn][maxn], sz[maxn][maxn];
vector<int> G[maxn];
int n;
void dfs1(int u, int par) {
sz[root][u] = 1;
p[root][u] = par;
for (int v : G[u])
if (v != par) {
dfs1(v, u);
sz[root][u] += sz[root][v];
}
}
long long dfs(int u, int v) {
if (u == v) return 0;
if (dp[u][v] != -1) return dp[u][v];
long long res = sz[u][v] * sz[v][u] + max(dfs(p[u][v], u), dfs(p[v][u], v));
return dp[u][v] = res;
}
int main(int argc, const char *argv[]) {
memset(sz, 0, sizeof(sz));
memset(p, 0, sizeof(p));
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
root = i;
dfs1(root, -1);
}
long long ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ans = max(ans, dfs(i, j));
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int m, n1, n2, cen1[2005], cen2[2005], lca1[1005][1005], lca2[1005][1005],
f[1005][1005], f1[2005], f2[2005], c1[1005], c2[1005];
int qcen1(int w) {
if (cen1[w]) return cen1[w];
return cen1[w] = qcen1(f1[w]) + 1;
}
int qlac1(int w) {
while (cen1[w] == 0) {
w = f1[w];
}
return cen1[w];
}
int qcen2(int w) {
if (cen2[w]) return cen2[w];
return cen2[w] = qcen2(f2[w]) + 1;
}
int qlac2(int w) {
while (cen2[w] == 0) {
w = f2[w];
}
return cen2[w];
}
int main() {
scanf("%d", &m);
scanf("%d", &n1);
for (int i = 2; i <= n1; i++) scanf("%d", &f1[i]);
cen1[1] = 1;
for (int i = 1; i <= m; i++) {
scanf("%d", &c1[i]);
if (i > 1) {
lca1[i - 1][i] = qlac1(c1[i]);
} else {
lca1[i - 1][i] = 1;
}
c1[i] = qcen1(c1[i]);
}
scanf("%d", &n2);
for (int i = 2; i <= n2; i++) scanf("%d", &f2[i]);
cen2[1] = 1;
for (int i = 1; i <= m; i++) {
scanf("%d", &c2[i]);
if (i > 1) {
lca2[i - 1][i] = qlac2(c2[i]);
} else {
lca2[i - 1][i] = 1;
}
c2[i] = qcen2(c2[i]);
}
for (int i = 2; i <= m; i++)
for (int j = i - 2; j >= 0; j--) {
lca1[j][i] = min(lca1[j + 1][i], lca1[j][j + 1]);
lca2[j][i] = min(lca2[j + 1][i], lca2[j][j + 1]);
}
memset(f, 0x3f, sizeof f);
f[0][1] = c2[1] - 1;
f[1][0] = c1[1] - 1;
for (int i = 1; i < m; i++)
for (int j = 0; j < i; j++) {
f[i + 1][j] = min(f[i + 1][j], f[i][j] + c1[i + 1] - lca1[i][i + 1]);
f[i][i + 1] = min(f[i][i + 1], f[i][j] + c2[i + 1] - lca2[j][i + 1]);
f[i + 1][i] = min(f[i + 1][i], f[j][i] + c1[i + 1] - lca1[j][i + 1]);
f[j][i + 1] = min(f[j][i + 1], f[j][i] + c2[i + 1] - lca2[i][i + 1]);
}
int ans = 0x3f3f3f3f;
for (int j = 0; j < m; j++) {
ans = min(ans, f[j][m]);
ans = min(ans, f[m][j]);
}
printf("%d", n1 + n2 - 2 - ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
long long modpow(long long b, long long e, long long mod) {
long long ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1) ans = ans * b % mod;
return ans;
}
const int N = 1e6 + 10;
int p[N];
bool vis[N];
int n;
int dp[2][N];
int cnt[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
vector<int> tam;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
int cur = p[i];
vis[cur] = 1;
int t = 1;
while (cur != i) {
t++;
cur = p[cur];
vis[cur] = 1;
}
tam.push_back(t);
}
}
int mx = 0;
int kk = k;
for (int x : tam) {
int poe = min(kk, x / 2);
kk -= poe;
mx += poe * 2;
}
mx += kk;
mx = min(mx, n);
for (int x : tam) cnt[x]++;
sort(tam.begin(), tam.end());
tam.erase(unique(tam.begin(), tam.end()), tam.end());
int tot = 0;
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
kk = 0;
for (int i = 1; i <= (int)tam.size(); i++) {
int val = tam[i - 1];
int prv = (i - 1) & 1;
int cur = (i & 1);
kk += val * cnt[val];
for (int j = 0; j <= kk; j++) {
if (dp[prv][j] >= 0)
dp[cur][j] = 0;
else if (j - val >= 0 and dp[cur][j - val] >= 0 and
dp[cur][j - val] < cnt[val]) {
dp[cur][j] = dp[cur][j - val] + 1;
} else
dp[cur][j] = -1;
}
if (dp[cur][k] != -1) {
cout << k << " " << mx << "\n";
exit(0);
}
}
int mn = 0;
if (dp[(int)tam.size() & 1][k] != -1) {
mn = k;
} else
mn = min(n, k + 1);
cout << mn << " " << mx << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (int &it : a) cin >> it;
sort(a.begin(), a.end());
int m = n / 2;
int ans = INT_MAX;
for (int i = 0; i < m; i++) {
ans = min(ans, a[i + m] - a[i]);
}
cout << ans << '\n';
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
int read(){
int a=0,fh=1;char c=getchar();
while(c>'9'||c<'0'){if(c=='-')fh=-1;c=getchar();}
while('0'<=c&&c<='9'){
a=a*10+c-48;
c=getchar();
}
return a*fh;
}
#define MN 20005
#define pii pair<int,int>
#define mp make_pair
#define x first
#define y second
#define pb push_back
#define vc vector
int T,n,m,q;
int a[MN];
int f[15][31][MN],st[15][MN];
int Log[MN],g[31];
int _max(int i,int j){return (a[i]+i<a[j]+j)?j:i;}
int askmx(int l,int r){
if(l>r)return 0;
// cerr<<"? "<<l<<" "<<r<<endl;
int lg=Log[r-l+1];
return _max(st[lg][l],st[lg][r-(1<<lg)+1]);
}
signed main(){
n=read();q=read();
Log[0]=-1;for(int i=1;i<=n;++i)Log[i]=Log[i>>1]+1;
for(int i=1;i<=n;++i){
a[i]=min(read(),n-i);
st[0][i]=i;
}
memset(f,0x3f,sizeof(f));
for(int j=0;j<=30;++j)
for(int i=1;i<=n;++i){
f[0][j][i]=min(i+a[i]+j,n);
}
for(int i=1;i<=14;++i)
for(int j=1;j+(1<<i)-1<=n;++j)
st[i][j]=_max(st[i-1][j],st[i-1][j+(1<<i-1)]);
for(int i=1;i<=14;++i){
for(int k=0;k<=30;++k){
if(k)for(int j=1;j+(1<<i)-1<=n;++j)f[i][k][j]=f[i][k-1][j];
else for(int j=1;j+(1<<i)-1<=n;++j)f[i][k][j]=0;
for(int l=0;l<=k;++l){
for(int j=1;j+(1<<i)-1<=n;++j){
int r=f[i-1][l][j];
int p=askmx(j,r);
f[i][k][j]=max(f[i][k][j],min(f[i-1][k-l][p],n));
}
}
}
}
while(q--){
int l=read(),r=read(),k=read();
if(l==r){puts("0");continue;}
int now=0;
for(int i=0;i<=k;++i)g[i]=l;
int ans=n;
for(int i=14;i>=0;--i){
bool ok=0;
for(int j=0;j<=k;++j){
if(f[i][k-j][askmx(l,g[j])]>=r){
ans=min(ans,now+(1<<i));ok=1;
break;
}
}
if(!ok){
now+=(1<<i);
for(int j=k;j>=0;--j){
int p=askmx(l,g[j]);
g[j]=max(g[j],f[i][0][p]);
for(int o=0;o<j;++o){
int p=askmx(l,g[o]);
g[j]=max(g[j],f[i][j-o][p]);
}
assert(g[j]<r);
}
}
}
printf("%d\n",ans);
}
return 0;
} | 13 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
void solve() {
long long x, n;
cin >> x >> n;
if (n == 0) {
cout << x << '\n';
return;
}
if ((x & 1)) {
if (n % 2 != 0) {
long long diff = 1 + n;
if (diff % 4 == 0) {
cout << x - diff << '\n';
} else {
cout << x + n << '\n';
}
} else {
if (n % 4 == 0) {
cout << x << '\n';
} else {
cout << x - 1 << '\n';
}
}
} else {
if (n == 1) {
cout << x - 1 << '\n';
return;
}
if (n % 2 != 0) {
long long diff = abs(1 - n);
if (diff % 4 == 0) {
cout << x - n << '\n';
} else {
cout << x + n + 1 << '\n';
}
} else {
if (n % 4 == 0) {
cout << x << '\n';
} else {
cout << x + 1 << '\n';
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
for (int it = 1; it <= t; it++) {
solve();
}
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
const long long inf = 1e9;
#define fr(i,a,n) for (int i=a;i<n;i++)
#define rfr(i,n,a) for (int i=n;i>=a;i--)
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define pll pair<ll,ll>
#define endl "\n"
typedef vector<int> VI;
typedef vector<ll> VL;
typedef priority_queue<int> Pqi;
typedef priority_queue<ll> Pql;
ll n, m, k;
int main () {
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int t;
cin >> t;
while(t--) {
int x,y;
cin >> x >> y;
int moves = x + y;
moves += max(abs(x-y)-1,0);
cout << moves << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int GCD(long long w, long long e) {
if (e == 0) return w;
return GCD(e, w % e);
}
long long a, b, x, y, l, r, i, k, j, n, m;
int main() {
cin >> a >> b >> x >> y;
l = 0;
r = a + 1;
i = x / GCD(x, y);
j = y / GCD(x, y);
if (i > a || j > b) {
cout << 0 << " " << 0;
return 0;
}
while (l < r) {
m = (l + r) / 2;
if (m * i < a && m * j < b) {
l = m + 1;
if (l * i > a || l * j > b) {
cout << m * i << " " << m * j;
return 0;
}
} else
r = m;
}
cout << r * i << " " << r * j;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
struct node {
int id, type;
node* nxt = nullptr;
node(){};
node(int id, int type) : id(id), type(type){};
};
int n;
node* head[N];
node* tail[N];
vector<int> adj[N];
pair<int, int> res[N];
void dfs(int u, int p) {
vector<node*> p1, p2, p3;
for (int v : adj[u]) {
if (v == p) {
continue;
}
dfs(v, u);
p1.push_back(head[v]);
p2.push_back(head[v]->nxt);
p3.push_back(tail[v]);
}
head[u] = new node(u, 0);
tail[u] = new node(u, 1);
node* cur = head[u];
int sz = p1.size();
for (int i = 0; i < sz; ++i) {
cur->nxt = p1[i];
cur = p1[i];
}
cur->nxt = tail[u];
cur = tail[u];
for (int i = sz - 1; i >= 0; --i) {
cur->nxt = p2[i];
cur = p3[i];
}
tail[u] = cur;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
dfs(1, -1);
node* cur = head[1];
for (int i = 1; i <= 2 * n; ++i) {
if (cur->type == 0) {
res[cur->id].first = i;
} else {
res[cur->id].second = i;
}
cur = cur->nxt;
}
for (int i = 1; i <= n; ++i) {
cout << res[i].first << " " << res[i].second << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 405;
vector<long long int> adj[maxn];
int vis[maxn], used;
int dfs(int s, vector<int> &path) {
path.push_back(s);
vis[s] = 1;
int ans = 1;
for (auto x : adj[s]) {
if (!vis[x]) {
ans += dfs(x, path);
}
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<int> on, to, th;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vector<int> path;
int sz = dfs(i, path);
if (sz > 3) {
cout << -1;
return 0;
}
if (sz == 1) on.push_back(path[0]);
if (sz == 2) {
to.push_back(path[0]);
to.push_back(path[1]);
}
if (sz == 3) {
th.push_back(path[0]);
th.push_back(path[1]);
th.push_back(path[2]);
}
}
}
int g = on.size(), h = to.size();
if (g < h / 2) {
cout << -1;
return 0;
}
for (int i = 0; i < th.size(); i++) {
cout << th[i] << ' ';
if (i % 3 == 2) cout << endl;
}
int k = 0;
for (int i = 0; i < h; i++) {
cout << to[i] << ' ';
if (i % 2 == 1) {
cout << on[k++] << endl;
}
}
int x = 0;
while (k < g) {
if (x != 0 && x % 3 == 0) cout << endl;
cout << on[k] << ' ';
k++;
x++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int lp[1000000 + 5];
int cnt[1000000 + 5];
int main() {
int i, j, v;
int m = 1;
for (i = 2; i <= 1000000; i++)
if (!lp[i])
for (j = i; j <= 1000000; j += i) lp[j] = i;
int n, k;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &v);
while (v != 1) {
int cp = lp[v], c = 0;
while (v % cp == 0) {
v /= cp;
c++;
}
cnt[cp] = max(cnt[cp], c);
}
}
for (i = 2; i <= 1000000; i++)
for (j = 1; j <= cnt[i]; j++) m = ((long long int)m * i) % k;
m = m % k;
if (!m)
puts("Yes");
else
puts("No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void op() { freopen("input.txt", "r", stdin); }
long long n;
bool foo(long long d) {
for (long long i = 1; i < d; i++) {
long long a = (n - 1 - i * (n / d));
if (a % d == 0) {
cout << "YES\n2\n";
cout << i << " " << d << "\n";
cout << a / d << " " << n / d << "\n";
return 1;
}
}
return 0;
}
int main() {
cin >> n;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0 && foo(i)) return 0;
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 0;
while (n > 0) {
long long temp = n;
long long xmax = 0;
while (temp > 0) {
xmax = max(xmax, temp % 10);
temp /= 10;
}
ans++;
n -= xmax;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
long long n;
cin >> n;
map<int, vector<int>> m;
n--;
while (n--) {
int a, b;
cin >> a >> b;
m[a].push_back(b);
m[b].push_back(a);
}
int ans = 0;
for (auto i : m) {
ans += (i.second.size() * (i.second.size() - 1)) / 2;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int z[N];
void z_algo(string &s) {
for (int i = 1, L = 0, R = 0; i < s.size(); i++) {
if (i <= R) z[i] = min(R - i + 1, z[i - L]);
while (i + z[i] < s.size() && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] - 1 > R) R = i + z[i] - 1, L = i;
}
}
string s;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> s;
z_algo(s);
int ma = 0, ans = 0;
for (int i = 1; i < s.size(); i++) {
if (ma >= z[i] && i + z[i] == s.size()) ans = max(ans, z[i]);
ma = max(ma, z[i]);
}
if (!ans)
cout << "Just a legend\n";
else
cout << s.substr(0, ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define ios; ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;
set<pair<int, int> >s;
void f(int x, int y, int i, int p){
if (i == 0){
//cout << x << ' ' << y << endl;
s.insert({x, y});
return;
}
if (p == 1){
f(x - 1, y, i - 1, 0);
f(x + 1, y, i - 1, 0);
}
else{
f(x, y - 1, i - 1, 1);
f(x, y + 1, i - 1, 1);
}
}
void solve(){
//s.clear();
int n;
cin >> n;
if (n % 2 == 0){
cout << (n / 2 + 1) * (n / 2 + 1) << endl;
}
else{
int k = (n + 1) / 2;
cout << (4 * k * (k + 1) / 2) << endl;
}
}
int main(){
ios;
int t = 1;
while(t--){
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m, k, a[maxn][7];
int dp[maxn][35][6], mm[maxn][7];
void initRMQ(int col) {
mm[0][col] = -1;
for (int i = 1; i <= n; i++) {
mm[i][col] = ((i & (i - 1)) == 0) ? mm[i - 1][col] + 1 : mm[i - 1][col];
dp[i][0][col] = a[i][col];
}
for (int j = 1; j <= mm[n][col]; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++)
dp[i][j][col] =
max(dp[i][j - 1][col], dp[i + (1 << (j - 1))][j - 1][col]);
}
}
int rmq(int x, int y, int col) {
int kk = mm[y - x + 1][col];
return max(dp[x][kk][col], dp[y - (1 << kk) + 1][kk][col]);
}
bool C(int i, int j) {
int cnt = 0;
for (int z = 0; z < m; z++) {
cnt += rmq(i, j, z);
}
return cnt <= k;
}
int main() {
int cqqq = (1 << -5);
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
}
for (int i = 0; i < m; i++) initRMQ(i);
int pi, pj, mi = -1, mj = -1;
for (int i = 1, j = 1; i <= n;) {
if (!C(i, j)) {
i++, j++;
continue;
}
while (j + 1 <= n && C(i, j + 1)) {
j++;
}
if (mj - mi <= j - i) {
mj = j, mi = i;
}
i++;
}
for (int z = 0; z < m; z++)
printf("%s%d", (z ? " " : ""), (mi != -1 ? rmq(mi, mj, z) : 0));
printf("\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxint = 2147483646;
const int minint = -2147483646;
const long long maxlll = 9223372036854775805;
const long long minlll = -9223372036854775805;
const ll mody = 998244353;
template <class T>
ostream& operator<<(ostream& os, vector<T> v) {
os << "[";
for (int i = 0; i < v.size(); i++) {
os << v[i];
if (i != v.size() - 1) {
os << ", ";
}
}
os << "]";
return os;
}
template <class T, class U>
ostream& operator<<(ostream& os, unordered_map<T, U> dt) {
os << "{";
for (auto i = dt.begin(); i != dt.end(); i++) {
os << i->first << ": " << i->second;
auto temp = i;
temp++;
if (temp != dt.end()) {
os << ", ";
}
}
os << "}";
return os;
}
template <class T, class U>
ostream& operator<<(ostream& os, pair<T, U> dt) {
os << "(" << dt.first << "," << dt.second << ")";
return os;
}
template <typename T, unsigned int N>
typename std::enable_if<!std::is_same<T, char>::value, std::ostream&>::type
operator<<(std::ostream& os, const T (&a)[N]) {
for (size_t i = 0; i < N; ++i) {
os << a[i];
if (i < N - 1) {
cout << " ";
}
}
os << endl;
return os;
}
template <class T, class U>
ostream& operator<<(ostream& os, map<T, U> dt) {
os << "{";
for (auto i = dt.begin(); i != dt.end(); i++) {
os << i->first << ": " << i->second;
auto temp = i;
temp++;
if (temp != dt.end()) {
os << ", ";
}
}
os << "}";
return os;
}
template <class T, class U>
ostream& operator<<(ostream& os, multimap<T, U> dt) {
os << "{";
for (auto i = dt.begin(); i != dt.end(); i++) {
os << i->first << ": " << i->second;
auto temp = i;
temp++;
if (temp != dt.end()) {
os << ", ";
}
}
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, set<T> dt) {
os << "{";
for (auto i = dt.begin(); i != dt.end(); i++) {
os << *i;
auto temp = i;
temp++;
if (temp != dt.end()) {
os << ", ";
}
}
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, multiset<T> dt) {
os << "{";
for (auto i = dt.begin(); i != dt.end(); i++) {
os << *i;
auto temp = i;
temp++;
if (temp != dt.end()) {
os << ", ";
}
}
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, stack<T> dt) {
stack<T> t;
os << "[";
while (!dt.empty()) {
T temp = dt.top();
os << temp;
dt.pop();
t.push(temp);
if (!dt.empty()) {
os << ", ";
}
}
os << "]";
while (!t.empty()) {
T temp = t.top();
dt.push(temp);
t.pop();
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, queue<T> dt) {
queue<T> t;
os << "[";
while (!dt.empty()) {
T temp = dt.front();
os << temp;
dt.pop();
t.push(temp);
if (!dt.empty()) {
os << ", ";
}
}
os << "]";
while (!t.empty()) {
T temp = t.front();
dt.push(temp);
t.pop();
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, list<T> dt) {
os << "[";
for (auto i = dt.begin(); i != dt.end(); i++) {
os << *i;
auto temp = i;
temp++;
if (temp != dt.end()) {
os << ", ";
}
}
os << "]";
return os;
}
template <class T>
ostream& operator<<(ostream& os, priority_queue<T> dt) {
queue<T> t;
os << "[";
while (!dt.empty()) {
T temp = dt.top();
os << temp;
dt.pop();
t.push(temp);
if (!dt.empty()) {
os << ", ";
}
}
os << "]";
while (!t.empty()) {
T temp = t.front();
dt.push(temp);
t.pop();
}
return os;
}
template <class T = ll>
vector<T> clist(int n) {
std::vector<T> v;
while (n--) {
T k;
cin >> k;
v.push_back(k);
}
return v;
}
template <class T = ll, class U = ll>
vector<pair<T, U>> clist2(int n) {
std::vector<pair<T, U>> v;
while (n--) {
T a;
U b;
cin >> a >> b;
pair<T, U> p(a, b);
v.push_back(p);
}
return v;
}
template <class T = ll>
vector<pair<T, int>> clistind(int n) {
std::vector<pair<T, int>> v;
for (int i = 0; i < n; i++) {
T k;
cin >> k;
pair<T, int> p(k, i);
v.push_back(p);
}
return v;
}
template <class T = ll, class U = ll>
vector<pair<pair<T, U>, int>> clist2ind(int n) {
std::vector<pair<pair<T, U>, int>> v;
for (int i = 0; i < n; i++) {
T a;
U b;
cin >> a >> b;
pair<T, U> p(a, b);
pair<pair<T, U>, int> pp(p, i);
v.push_back(pp);
}
return v;
}
vector<char> cstrtv(string& s) {
vector<char> v;
for (int i = 0; i < s.size(); i++) {
v.push_back(s[i]);
}
return v;
}
template <class T>
struct freq {
map<T, vector<int>> m;
int n;
freq(vector<T>& s) {
n = s.size();
for (int i = 0; i < s.size(); i++) {
if (m.find(s[i]) == m.end()) {
vector<int> v;
m[s[i]] = v;
}
m[s[i]].push_back(i);
}
}
freq(string& s) {
n = s.size();
for (int i = 0; i < s.size(); i++) {
if (m.find(s[i]) == m.end()) {
vector<int> v;
m[s[i]] = v;
}
m[s[i]].push_back(i);
}
}
typename map<T, vector<int>>::iterator begin() { return m.begin(); }
typename map<T, vector<int>>::iterator end() { return m.end(); }
int operator[](T ind) {
if (m.find(ind) == m.end()) {
return 0;
}
return m[ind].size();
}
T mode() {
int maxfrq = 0;
T maxel;
for (auto it = m.begin(); it != m.end(); it++) {
if (it->second.size() > maxfrq) {
maxfrq = it->second.size();
maxel = it->first;
}
}
return maxel;
}
int first(T el) {
if (m[el].size() != 0) {
return m[el][0];
}
return n;
}
int last(T el) {
if (m[el].size() != 0) {
return m[el][m[el].size() - 1];
}
return -1;
}
bool equals(freq<T>& o) {
for (auto it = begin(); it != end(); it++) {
if ((*this)[it->first] != o[it->first]) {
return false;
}
}
for (auto it = o.begin(); it != o.end(); it++) {
if ((*this)[it->first] != o[it->first]) {
return false;
}
}
return true;
}
};
template <class T>
int maxind(vector<T>& v) {
int maxi = 0;
for (int i = 1; i < v.size(); i++) {
maxi = (v[maxi] < v[i]) ? i : maxi;
}
return maxi;
}
template <class T>
T maxel(vector<T>& v) {
return v[maxind(v)];
}
template <class T>
int minind(vector<T>& v) {
int mini = 0;
for (int i = 1; i < v.size(); i++) {
mini = (v[mini] > v[i]) ? i : mini;
}
return mini;
}
template <class T>
T minel(vector<T>& v) {
return v[minind(v)];
}
template <class T>
vector<ll> partialsums(vector<T>& v) {
vector<ll> ps(v.size());
ps[0] = v[0];
for (int i = 1; i < v.size(); i++) {
ps[i] = ps[i - 1] + v[i];
}
return ps;
}
template <class T>
ll sumy(vector<T>& v) {
ll s = 0;
for (int i = 0; i < v.size(); i++) {
s += v[i];
}
return s;
}
template <class T>
vector<int> pminin(vector<T>& v) {
vector<int> ret = {0};
int curi = 0;
for (int i = 1; i < v.size(); i++) {
if (v[i] < v[curi]) {
curi = i;
}
ret.push_back(curi);
}
return ret;
}
template <class T>
vector<int> pmaxin(vector<T>& v) {
vector<int> ret = {0};
int curi = 0;
for (int i = 1; i < v.size(); i++) {
if (v[i] > v[curi]) {
curi = i;
}
ret.push_back(curi);
}
return ret;
}
template <class T>
vector<T> pmin(vector<T>& v) {
vector<T> ret;
vector<int> temp = pminin(v);
for (int i = 0; i < temp.size(); i++) {
ret.push_back(v[temp[i]]);
}
return ret;
}
template <class T>
vector<T> pmax(vector<T>& v) {
vector<T> ret;
vector<int> temp = pmaxin(v);
for (int i = 0; i < temp.size(); i++) {
ret.push_back(v[temp[i]]);
}
return ret;
}
int ind(int i, int n) {
if (i % n >= 0) {
return i % n;
}
return (i % n) + n;
}
ll modsub(ll a, ll b) {
ll ans = a % mody - b % mody;
if (ans < 0) {
return ans + mody;
}
return ans;
}
ll gcdExtended(ll a, ll b, ll* x, ll* y);
ll modinv(ll a) {
ll m = mody;
ll x, y;
ll g = gcdExtended(a, m, &x, &y);
ll res = (x % m + m) % m;
return res;
}
ll gcdExtended(ll a, ll b, ll* x, ll* y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
ll x1, y1;
ll gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
template <class T = ll>
set<T> divisors(T n) {
set<T> s;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
s.insert(i);
} else {
s.insert(i);
s.insert(n / i);
}
}
}
return s;
}
template <class T = ll>
freq<T> pf(T n) {
vector<T> s;
while (n % 2 == 0) {
s.push_back(2);
n = n / 2;
}
for (T i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
s.push_back(i);
n = n / i;
}
}
if (n > 2) {
s.push_back(n);
}
return freq<T>(s);
}
bool isprime[1];
void seive(int n) {
for (int i = 0; i < n + 1; i++) {
isprime[i] = true;
;
}
isprime[0] = false;
isprime[1] = false;
for (int i = 0; i < n + 1; i++) {
if (isprime[i]) {
for (int j = 2 * i; j < n + 1; j += i) {
isprime[j] = false;
}
}
}
}
ll modexp(ll n, ll e) {
if (e == 0) {
return 1;
} else {
if (e % 2) {
return (n * (modexp(n, e - 1))) % mody;
} else {
ll res = modexp(n, e / 2);
return (res * res) % mody;
}
}
}
int countbits(ll n) {
ll count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
string bts(ll n, int p) {
string s = "";
for (int i = 0; i < p; i++) {
s.push_back('0');
}
for (int i = 0; i < p; i++) {
if (n % 2) {
s[p - i - 1] = '1';
}
n /= 2;
}
return s;
}
void binarysearch() {}
ll comb[1][1];
ll choose(int n, int r) {
if (comb[n][r] != -1) {
return comb[n][r];
}
if (r == n) {
return 1;
}
if (r == 0) {
return 1;
}
comb[n][r] = (choose(n - 1, r - 1) + choose(n - 1, r)) % (mody);
return comb[n][r];
}
ll factorial[1];
ll fact(int n) {
if (n == 0) {
return 1;
}
if (factorial[n] != -1) {
return factorial[n];
} else {
factorial[n] = (n * fact(n - 1)) % mody;
return factorial[n];
}
}
struct point {
ll a;
ll b;
ll c;
point(ll aa, ll bb, ll cc) : a(aa), b(bb), c(cc) {}
};
ostream& operator<<(ostream& os, point p) {
os << "(" << p.a << ", " << p.b << ", " << p.c << ")";
return os;
}
bool operator<(const point& a, const point& b) {
if (a.a == b.a) {
if (a.b == b.b) {
return a.c < b.c;
}
return a.b < b.b;
}
return a.a < b.a;
}
vector<point> clist3(int n) {
std::vector<point> v;
while (n--) {
ll a, b, c;
cin >> a >> b >> c;
point p(a, b, c);
v.push_back(p);
}
return v;
}
vector<pair<point, int>> clist3ind(int n) {
std::vector<pair<point, int>> v;
for (int i = 0; i < n; i++) {
ll a, b, c;
cin >> a >> b >> c;
point p(a, b, c);
pair<point, int> pp(p, i);
v.push_back(pp);
}
return v;
}
vector<int> islets(string v) {
vector<int> ret;
int cur = 1;
for (int i = 1; i < v.size(); i++) {
if (v[i] == v[i - 1] && v[i] == 1) {
cur++;
} else {
if (cur > 1) {
ret.push_back(cur);
cur = 1;
}
}
}
ret.push_back(cur);
return ret;
}
struct node;
struct edge;
struct node {
int pos;
int tag = 0;
vector<edge> edges;
node(int valy) : pos(valy) {}
node(int valy, int taggy) : pos(valy), tag(taggy) {}
void add(edge& e) { edges.push_back(e); }
};
struct edge {
node* source;
node* dest;
int weight = 0;
edge(node* sourcey, node* desty) : source(sourcey), dest(desty) {}
edge(node* sourcey, node* desty, int valy)
: source(sourcey), dest(desty), weight(valy) {}
};
struct graph {
vector<node> nodes;
bool d;
graph(int sz, int dd = 0) {
d = dd;
for (int i = 0; i < sz; i++) {
node v(i);
nodes.push_back(v);
}
}
void addnode(int taggy = 0) {
node v(nodes.size(), taggy);
nodes.push_back(v);
}
void addedge(int source, int dest, int weight = 0) {
node& so = nodes[source];
node& de = nodes[dest];
edge e(&so, &de, weight);
nodes[source].add(e);
if (d == 0) {
edge ee(&de, &so, weight);
nodes[dest].add(ee);
}
}
vector<int> dfs() {
vector<int> parent(nodes.size(), -1);
for (int i = 0; i < nodes.size(); i++) {
if (parent[i] == -1) {
stack<int> s;
s.push(i);
parent[i] = i;
while (!s.empty()) {
int cur = s.top();
s.pop();
for (int i = 0; i < nodes[cur].edges.size(); i++) {
if (parent[nodes[cur].edges[i].dest->pos] == -1) {
s.push(nodes[cur].edges[i].dest->pos);
parent[nodes[cur].edges[i].dest->pos] = cur;
}
}
}
}
}
return parent;
}
vector<int> dfscomp() {
vector<int> parent(nodes.size(), -1);
for (int i = 0; i < nodes.size(); i++) {
if (parent[i] == -1) {
stack<int> s;
s.push(i);
parent[i] = i;
int pa = i;
while (!s.empty()) {
int cur = s.top();
s.pop();
for (int i = 0; i < nodes[cur].edges.size(); i++) {
if (parent[nodes[cur].edges[i].dest->pos] == -1) {
s.push(nodes[cur].edges[i].dest->pos);
parent[nodes[cur].edges[i].dest->pos] = pa;
}
}
}
}
}
return parent;
}
};
ostream& operator<<(ostream& os, graph g) {
os << "{";
for (int i = 0; i < g.nodes.size(); i++) {
os << g.nodes[i].pos << ":[";
for (int j = 0; j < g.nodes[i].edges.size(); j++) {
os << g.nodes[i].edges[j].dest->pos << "(" << g.nodes[i].edges[j].weight
<< "), ";
}
os << "]" << endl;
}
os << "}";
return os;
}
map<ll, vector<int>> intervalin(int n) {
map<ll, vector<int>> m;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
m[a].push_back(-i - 1);
m[b].push_back(i + 1);
}
for (auto it = m.begin(); it != m.end(); it++) {
sort(it->second.begin(), it->second.end());
}
return m;
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
int t;
cin >> t;
while (t--) {
ll n, g, b;
cin >> n >> g >> b;
if (g >= b) {
cout << n << endl;
} else {
ll badness = ((n / 2) + b - 1) / b;
ll m = n;
n -= (n / 2);
n -= badness * g;
if (n <= 0) {
cout << m << endl;
continue;
}
ll days = badness * (b + g);
days += (n / g) * (b + g) - b;
if (n % g != 0) {
days += n % g + b;
}
cout << days << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
int n, m;
cin >> n >> m;
map<int, int> type;
vector<int> a(m);
for (int i = 0; i < m; i++) {
cin >> a[i];
type[a[i]] += 1;
}
int sum = accumulate(a.begin(), a.end(), 0);
int mel = 0;
for (auto p : type) {
mel = max(mel, p.second);
}
for (int i = 1; i <= mel; i++) {
int curr = 0;
for (auto p : type) {
curr += p.second / i;
}
if (curr >= n) {
ans = max(ans, i);
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> ih, iv, nih;
vector<int> vh, vv;
vector<pair<int, int> > h[200005], v[200005];
vector<pair<int, int> > nv[200005];
int n, a, b, c, d;
vector<pair<int, pair<int, int> > > pts;
long long sum = 0ll;
int ft[200005];
void update(int p, int v) {
for (; p <= 200000; p += p & -p) ft[p] += v;
}
int query(int p) {
int r = 0;
for (; p; p -= p & -p) r += ft[p];
return r;
}
void update(int p, int q, int v) {
update(p, v);
update(q + 1, -v);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a == c) {
if (!iv.count(a)) {
iv[a] = (int)(vv).size();
vv.push_back(a);
}
v[iv[a]].push_back(make_pair(min(b, d), max(b, d)));
} else {
if (!ih.count(b)) {
ih[b] = (int)(vh).size();
vh.push_back(b);
}
h[ih[b]].push_back(make_pair(min(a, c), max(a, c)));
}
}
for (int i = 0; i < (int)(vh).size(); i++) {
sort((h[i]).begin(), (h[i]).end());
for (int j = 1; j < (int)(h[i]).size(); j++) {
if (h[i][j].first <= h[i][j - 1].second) {
h[i][j] = make_pair(h[i][j - 1].first,
max(h[i][j].second, h[i][j - 1].second));
h[i][j - 1].second = h[i][j - 1].first - 1;
}
}
for (pair<int, int> j : h[i]) {
if (j.first <= j.second) {
sum += (long long)(j.second - j.first + 1);
pts.push_back(make_pair(j.first - 1, make_pair(vh[i], -1)));
pts.push_back(make_pair(j.second, make_pair(vh[i], 1)));
}
}
}
for (int i = 0; i < (int)(vv).size(); i++) {
sort((v[i]).begin(), (v[i]).end());
for (int j = 1; j < (int)(v[i]).size(); j++) {
if (v[i][j].first <= v[i][j - 1].second) {
v[i][j] = make_pair(v[i][j - 1].first,
max(v[i][j].second, v[i][j - 1].second));
v[i][j - 1].second = v[i][j - 1].first - 1;
}
}
for (pair<int, int> j : v[i]) {
if (j.first <= j.second) {
sum += (long long)(j.second - j.first + 1);
nv[i].push_back(j);
}
}
}
sort((pts).begin(), (pts).end());
c = -1;
long long ans = 0ll;
sort((vv).begin(), (vv).end());
for (int i = 0; i < (int)(vv).size(); i++) {
for (pair<int, int> j : nv[i]) {
vh.push_back(j.first);
vh.push_back(j.second);
}
}
sort((vh).begin(), (vh).end());
vh.resize(distance(vh.begin(), unique((vh).begin(), (vh).end())));
for (int i = 0; i < (int)(vh).size(); i++) {
nih[vh[i]] = i + 1;
}
for (int i = 0; i < (int)(pts).size(); i++) {
while (c < (int)(vv).size() - 1 && vv[c + 1] <= pts[i].first) {
c++;
for (pair<int, int> j : nv[iv[vv[c]]]) {
update(nih[j.first], nih[j.second], 1);
}
}
ans += (long long)query(nih[pts[i].second.first]) *
(long long)pts[i].second.second;
}
cout << (sum - ans) << '\n';
}
| 7 |
#include <bits/stdc++.h>
long long read() {
long long res = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) res = res * 10 + ch - 48, ch = getchar();
return res * flag;
}
void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + 48);
}
struct Edge {
long long v, w;
Edge() {}
Edge(long long v, long long w) : v(v), w(w) {}
};
long long n, ans = 0;
void solution() {
n = read();
for (long long i = (1); i <= (n); ++i) {
switch (i % 3) {
case 0:
print(ans + 1), putchar(' '), print(3), putchar('\n');
ans += 2;
break;
case 1:
print(ans), putchar(' '), print(0), putchar('\n');
break;
case 2:
print(ans + 1), putchar(' '), print(0), putchar('\n');
break;
default:
break;
}
}
}
signed main() {
42;
solution();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int iIn1, iIn2, iIn3, iIn4;
cin >> iIn1 >> iIn2 >> iIn3 >> iIn4;
int u = ((int)((int)iIn1 ^ (int)iIn2) & (int)((int)iIn3 | (int)iIn4)) ^
(int)((int)((int)iIn2 & (int)iIn3) | (int)((int)iIn1 ^ (int)iIn4));
cout << u;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, i, a[5], b[5], sum1, sum2, j, crt;
int main() {
for (i = 1; i <= 3; i++) cin >> a[i] >> b[i];
cout << 3 << '\n';
for (i = 1; i <= 3; i++) {
sum1 = 0;
sum2 = 0;
for (j = 1; j <= 3; j++) {
crt = 1;
if (i == j) crt = -1;
sum1 += a[j] * crt;
sum2 += b[j] * crt;
}
cout << sum1 << " " << sum2 << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
int a[MAX];
map<int, int> st;
int ba, be, bi, bans;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
st[a[i]]++;
}
int mi, me, ma;
int ci, ce, ca;
vector<int> v;
for (auto s : st) v.push_back(s.first);
if (st.size() == 1) {
printf("%d\n", n);
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
} else if (st.size() == 2) {
if (v[0] == v[1] - 1) {
printf("%d\n", n);
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
} else {
int k = min(st[v[0]], st[v[1]]);
printf("%d\n", n - k * 2);
for (int i = 0; i < st[v[0]] - k; ++i) printf("%d ", v[0]);
for (int i = 0; i < st[v[1]] - k; ++i) printf("%d ", v[1]);
for (int i = 0; i < k * 2; ++i) printf("%d ", v[0] + 1);
}
} else {
mi = v[0];
me = v[1];
ma = v[2];
ci = st[mi];
ca = st[ma];
ce = st[me];
bans = n;
int op1 = (st[me]) / 2;
int op2 = min(st[ma], st[mi]);
if (op1 > op2) {
ci += op1;
ca += op1;
ce -= 2 * op1;
} else {
ci -= op2;
ca -= op2;
ce += 2 * op2;
}
printf("%d\n", min(st[v[0]], ci) + min(st[v[1]], ce) + min(st[v[2]], ca));
for (int i = 0; i < ci; ++i) printf("%d ", mi);
for (int i = 0; i < ce; ++i) printf("%d ", me);
for (int i = 0; i < ca; ++i) printf("%d ", ma);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long s[55];
int main() {
long long n, k;
cin >> n >> k;
s[0] = 1;
s[1] = 1;
s[2] = 2;
for (long long i = 3; i <= n; i++) {
s[i] = s[i - 1] + s[i - 2];
}
long long r = 1;
while (n > 0) {
if (k > s[n - 1]) {
cout << r + 1 << " " << r << " ";
k = k - s[n - 1];
n = n - 2;
r = r + 2;
} else {
cout << r << " ";
n--;
r++;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
inline int mult(long long a, long long b) { return (a * b) % MOD; }
inline int pot(int n, int k) {
if (k == 0) return 1;
long long a = pot(n, k / 2);
a = mult(a, a);
if (k % 2) a = mult(a, n);
return a;
}
int divide(int a, int b) { return mult(a, pot(b, MOD - 2)); }
inline int sub(int a, int b) {
if (a - b >= 0) return a - b;
return a - b + MOD;
}
inline int add(int a, int b) {
if (a + b >= MOD) return a + b - MOD;
return a + b;
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int ans = 0;
if (n - 2 - i >= 0) {
int un = mult(mult(mult(9, 9), pot(10, n - 2 - i)), n - i - 1);
un = mult(un, 10);
ans = add(ans, un);
}
if (n - i - 1 >= 0) {
int un = mult(9, pot(10, n - 1 - i));
un = mult(un, 20);
ans = add(ans, un);
}
if (!ans) ans = 10;
cout << ans << " ";
}
cout << "\n";
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
cin >> i;
while (i--) {
int j, x;
cin >> j;
vector<int> v;
for (int k = 0; k < j; k++) {
cin >> x;
v.push_back(x);
}
int zero = count(v.begin(), v.end(), 0);
int sum1 = 0;
int y = accumulate(v.begin(), v.end(), sum1);
if (zero >= 1) {
if (y != -zero) {
cout << zero;
} else
cout << zero + 1;
} else if (y == 0)
cout << 1;
else
cout << 0;
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i = 1, h = 0;
cin >> n;
while (i <= n) {
n = n - i;
h++;
i = i + h + 1;
}
cout << h;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 300005;
int n, q;
int a[N], kq[N];
int T[8 * N], lz[8 * N];
struct Query {
int l, r, id;
friend bool operator<(Query x, Query y) { return x.r < y.r; }
} b[N];
void down(int id) {
int x = lz[id];
if (x == 0) return;
T[id * 2] += x;
T[id * 2 + 1] += x;
lz[id * 2] += x;
lz[id * 2 + 1] += x;
lz[id] = 0;
}
int get(int id, int l, int r, int lim, int val) {
if (l == r) return l;
int mid = (l + r) / 2;
down(id);
if (T[id * 2 + 1] >= val && mid < lim) {
return get(id * 2 + 1, mid + 1, r, lim, val);
} else
return get(id * 2, l, mid, lim, val);
}
void up(int id, int l, int r, int pos, int val) {
if (l > pos) return;
if (r <= pos) {
T[id] += val;
lz[id] += val;
down(id);
return;
}
int mid = (l + r) / 2;
down(id);
up(id * 2, l, mid, pos, val);
up(id * 2 + 1, mid + 1, r, pos, val);
T[id] = max(T[id * 2], T[id * 2 + 1]);
}
int get_val(int id, int l, int r, int pos) {
if (l == r) {
return T[id];
}
int mid = (l + r) / 2;
down(id);
if (mid < pos)
return get_val(id * 2 + 1, mid + 1, r, pos);
else
return get_val(id * 2, l, mid, pos);
}
void Solve() {
int j = 1;
for (int i = 1; i <= n; i++) {
if (a[i] >= 0 && T[1] >= a[i]) {
int x = get(1, 1, n, i, a[i]);
up(1, 1, n, x, 1);
}
while (b[j].r == i && j <= q) {
kq[b[j].id] = get_val(1, 1, n, b[j].l);
j++;
}
if (j == q + 1) break;
}
for (int i = 1; i <= q; i++) cout << kq[i] << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] = i - a[i];
for (int i = 1; i <= q; i++) {
cin >> b[i].l >> b[i].r;
b[i].l++;
b[i].r = n - b[i].r;
b[i].id = i;
}
sort(b + 1, b + q + 1);
Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long nmax = 1e3 + 5;
const long long mod = 1e9 + 7;
const long long mod1 = 998244353;
const long long inf = 1e18;
long long n, m, L, s, t, dist[1005], dist1[1005], tab[1005][1005],
pop[1005][1005], tab1[1005][1005];
vector<pair<long long, long long>> nod[1005];
vector<long long> road[1005];
void djkstra(long long s) {
multiset<pair<long long, long long>> dadoamne;
for (auto it : nod[s]) {
dadoamne.insert({it.second, it.first});
dist[it.first] = it.second;
}
while (dadoamne.empty() == false) {
auto it = dadoamne.begin();
for (auto it1 : nod[it->second]) {
if (((it->first) + it1.second) < dist[it1.first]) {
if (dist[it1.first] != inf)
dadoamne.erase(dadoamne.find({dist[it1.first], it1.first}));
dist[it1.first] = (it->first) + it1.second;
dadoamne.insert({dist[it1.first], it1.first});
}
}
dadoamne.erase(it);
}
}
void djkstra2(long long s) {
multiset<pair<long long, long long>> dadoamne;
for (long long i = 0; i < n; i++) dist1[i] = inf;
dist1[s] = 0;
for (auto it : nod[s]) {
dadoamne.insert({it.second, it.first});
dist1[it.first] = it.second;
road[it.first].push_back(s);
}
while (dadoamne.empty() == false) {
auto it = dadoamne.begin();
for (auto it1 : nod[it->second]) {
if (((it->first) + it1.second) < dist1[it1.first]) {
if (dist1[it1.first] != inf) {
dadoamne.erase(dadoamne.find({dist1[it1.first], it1.first}));
road[it1.first].pop_back();
}
dist1[it1.first] = (it->first) + it1.second;
dadoamne.insert({dist1[it1.first], it1.first});
road[it1.first].push_back(it->second);
}
}
dadoamne.erase(it);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> L >> s >> t;
for (long long i = 0; i < n; i++) dist[i] = inf;
dist[s] = 0;
for (long long i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (z == 0) {
nod[x].push_back({y, inf});
nod[y].push_back({x, inf});
tab[x][y] = 1;
tab[y][x] = 1;
} else {
nod[x].push_back({y, z});
nod[y].push_back({x, z});
}
}
djkstra(s);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (nod[i][j].second == inf) nod[i][j].second = 1;
}
}
if (dist[t] < L) return cout << "NO", 0;
for (long long i = 0; i < n; i++) dist1[i] = inf;
dist1[s] = 0;
djkstra2(s);
if (dist1[t] > L) return cout << "NO", 0;
long long curr = t;
while (curr != s) {
long long y = road[curr][0];
if (tab[curr][y] == 1) {
tab1[curr][y] = 1;
tab1[y][curr] = 1;
}
curr = y;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (tab[i][nod[i][j].first] == 1 && tab1[i][nod[i][j].first] == 0)
nod[i][j].second = inf;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (dist1[t] == L) break;
if (tab[i][nod[i][j].first] == 1 && tab1[i][nod[i][j].first] == 1) {
nod[i][j].second += (L - dist1[t]);
for (long long r = 0; r < nod[nod[i][j].first].size(); r++) {
if (nod[nod[i][j].first][r].first == i)
nod[nod[i][j].first][r].second += (L - dist1[t]);
}
djkstra2(s);
}
}
if (dist1[t] == L) break;
}
cout << "YES" << '\n';
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (pop[i][nod[i][j].first] == 0)
cout << i << ' ' << nod[i][j].first << ' ' << nod[i][j].second << '\n';
pop[i][nod[i][j].first] = 1;
pop[nod[i][j].first][i] = 1;
}
}
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.