solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using LL = long long;
template <typename T>
using V = vector<T>;
template <typename T, typename S>
using P = pair<T, S>;
using LD = long double;
template <typename T, typename S>
void check(T& a, const S& b) {
if (a >= b) {
a %= b;
}
}
template <typename T>
T gcd(T u, T v) {
if (u == v) return u;
if (u == 0) return v;
if (v == 0) return u;
if (~u & 1) {
if (v & 1)
return gcd(u >> 1, v);
else
return gcd(u >> 1, v >> 1) << 1;
}
if (~v & 1) return gcd(u, v >> 1);
if (u > v) return gcd((u - v) >> 1, v);
return gcd((v - u) >> 1, u);
}
const int N = 100001;
map<P<int, int>, int> dp[N];
int get(int i, int j, int k, const int& x, const int& y, const V<int>& A) {
if (dp[i].count({j, k})) return dp[i][{j, k}];
auto& ans = dp[i][{j, k}];
if (j >= x && k >= y) return ans = 0;
if (i >= (int)A.size()) return ans = (int)1e9;
ans = (int)1e9;
if (j < x) {
LL temp = min(x * 1LL, j * 1LL * A[i]);
ans = min(ans, 1 + get(i + 1, temp, k, x, y, A));
}
if (k < y) {
LL temp = min(y * 1LL, k * 1LL * A[i]);
ans = min(ans, 1 + get(i + 1, j, temp, x, y, A));
}
return ans;
}
int solve(int a, int b, int h, int w, V<int>& A) {
int x = (a + h - 1) / h;
int y = (b + w - 1) / w;
int ans = (int)1e9;
ans = min(ans, get(0, 1, 1, x, y, A));
for (int i = 0; i < N; i++) dp[i].clear();
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cerr.tie(NULL);
;
int a, b, h, w, n;
cin >> a >> b >> h >> w >> n;
V<int> A(n);
for (int i = 0; i < n; i++) cin >> A[i];
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
int ans = solve(a, b, h, w, A);
ans = min(ans, solve(b, a, h, w, A));
if (ans == (int)1e9) ans = -1;
cout << ans << '\n';
cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> sieve;
vector<long long int> *Sieve(int N) {
const long long int maxn = N;
sieve.resize(maxn);
for (long long int(i) = 0; (i) < (maxn); ++(i)) sieve[i] = 1;
sieve[1] = 0;
sieve[0] = 0;
for (long long int(i) = 2; (i) <= (maxn); (i) += (1))
if (1 == sieve[i])
for (long long int j = i * i; j < maxn; j += i) sieve[j] = 0;
vector<long long int> *primes = new vector<long long int>();
primes->push_back(2);
for (int i = 3; i < maxn; i += 2)
if (sieve[i]) {
primes->push_back(i);
}
return primes;
}
long long int extended_GCD(long long int a, long long int b, long long int &x,
long long int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1;
long long int gcd = extended_GCD(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
long long int ncr(long long int n, long long int k) {
long long int r = 1;
if (k > n - k) k = n - k;
for (long long int i = 0; i < k; i++) {
r *= (n - i);
r /= (i + 1);
}
return r;
}
long long int power(long long int a, long long int b,
long long int m = 1000000007) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
long long int modinv(long long int a, long long int mod = 1000000007) {
long long int x, y;
extended_GCD(a, mod, x, y);
if (x < 0) x += mod;
return x;
}
bool prime(int n) {
int c = 0;
for (int i = 2; (i * i) <= n; i++) {
if (n % i == 0) {
c++;
return false;
}
}
if (c == 0) return true;
}
vector<int> v[200006];
int vis[200006];
int c;
void dfs(int n) {
vis[n] = 1;
c++;
for (int i : v[n]) {
if (!vis[i]) dfs(i);
}
}
int a[100001];
void solve() {
int n, k;
cin >> n >> k;
int a[n];
for (long long int(i) = 0; (i) < (n); ++(i)) cin >> a[i];
int sa = 1, sb = 1;
double ca = 0, cb = k;
int i = 0, j = n - 1;
double ans = 0;
while (i <= j) {
double t1, t2, d1, d2;
d1 = a[i] - ca;
d2 = cb - a[j];
t1 = (double)d1 / sa;
t2 = (double)d2 / sb;
if (t1 <= t2) {
ans += t1;
ca += d1;
i++;
sa++;
cb -= (double)t1 * sb;
} else {
ans += t2;
cb -= d2;
j--;
sb++;
ca += (double)t2 * sa;
}
}
ans += double(cb - ca) / (sa + sb);
cout << fixed << setprecision(10) << ans;
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
int ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
void print(vector<int> x) {
for (int i = 0; i < (int)x.size(); i++)
printf("%d%c", x[i], " \n"[i == (int)x.size() - 1]);
}
int n;
vector<int> ans[1005];
int Acnt = 0;
int getf(int n) {
if (n == 1) return 1;
int l = 0, r = n, ans;
while (l <= r) {
int mid = (l + r) / 2;
if (1LL * mid * (mid + 1) / 2 > n)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return ans - 1;
}
struct Node {
int val, pos;
Node(int A = 0, int B = 0) { val = A, pos = B; }
bool operator<(const Node &x) const {
return val != x.val ? val < x.val : pos > x.pos;
}
bool operator>(const Node &x) const {
return val != x.val ? val > x.val : pos < x.pos;
}
};
Node max(Node x, Node y) { return x > y ? x : y; }
struct BIT {
int len;
Node t[100005];
void init(int l) { len = l, memset(t, 0, sizeof(t)); }
inline int lowbit(int x) { return x & (-x); }
void update(int u, Node v) {
for (int i = u; i <= len; i += lowbit(i)) t[i] = max(t[i], v);
}
Node query(int u) {
Node ans(0, -1);
for (int i = u; i > 0; i -= lowbit(i)) ans = max(ans, t[i]);
return ans;
}
} bit;
int f[100005], pre[100005];
vector<int> a, b, c;
int LIS() {
int n = a.size();
f[0] = 1;
pre[0] = -1;
bit.init(::n);
bit.update(a[0], Node(1, 0));
for (int i = 1; i < n; i++) {
auto [val, pos] = bit.query(a[i]);
f[i] = val + 1, pre[i] = pos;
bit.update(a[i], Node(f[i], i));
}
int maxn = 0;
for (int i = 0; i < n; i++) maxn = max(maxn, f[i]);
return maxn;
}
bool vis[100005];
set<Node> s;
void solve() {
if (a.size() == 0) return;
int n = a.size();
int R = LIS();
if (R > getf(n)) {
int maxid = 0;
for (int i = 0; i < n; i++)
if (f[i] > f[maxid]) maxid = i;
int cur = maxid;
memset(vis, 0, sizeof(vis));
while (cur != -1) {
vis[cur] = 1;
cur = pre[cur];
}
b.clear(), c.clear();
for (int i = 0; i < n; i++) {
if (!vis[i])
b.push_back(a[i]);
else
c.push_back(a[i]);
}
ans[++Acnt] = c;
a = b;
solve();
} else {
int t = getf(n);
while (t--) {
Acnt++;
s.insert(Node(0x3f3f3f3f - Acnt, Acnt));
}
for (int i = 0; i < n; i++) {
auto x = s.upper_bound(Node(a[i], 0));
ans[x->pos].push_back(a[i]);
int P = x->pos;
s.erase(x);
s.insert(Node(a[i], P));
}
}
}
void work() {
s.clear();
Acnt = 0;
n = read();
a.resize(n);
for (int i = 0; i < n; i++) a[i] = read();
if (n == 1) {
printf("1\n1 1\n");
return;
}
solve();
int cnt = 0;
for (int i = 1; i <= Acnt; i++)
if (!ans[i].empty()) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= Acnt; i++) {
if (ans[i].empty()) continue;
printf("%d ", (int)ans[i].size());
for (int j : ans[i]) printf("%d ", j);
puts("");
}
for (int i = 1; i <= Acnt; i++) ans[i].clear();
}
signed main() {
int T = read();
while (T--) work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 60;
constexpr int inf = 1 << 28;
constexpr long long mod = 998244353LL;
using namespace std;
template <typename T>
struct KMP {
int n;
T t;
vector<int> a;
KMP() {}
KMP(const T& _t) : t(_t) {
int n = t.size();
vector<int> kmp(n + 1, -1), mp(n + 1, -1);
for (int i = 0, j = -1; i < n; i++) {
while (j >= 0 && t[i] != t[j]) j = kmp[j];
kmp[i + 1] = mp[i + 1] = ++j;
if (i + 1 < n && t[i + 1] == t[j]) kmp[i + 1] = kmp[j];
}
a = mp;
}
int operator[](int i) { return a[i]; }
vector<int> findAll(const T& s) {
vector<int> res;
int j = 0;
for (int i = 0; i < s.size(); ++i) {
while (j != -1 && t[j] != s[i]) j = a[j];
j++;
if (j == n) {
res.push_back(i - j + 1);
j = a[j];
}
}
return res;
}
};
int count(long long X) {
int res = 0;
while (X > 0) {
res++;
X /= 10;
}
return res;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
vector<KMP<string>> vk(s.size());
for (int i = 0; i < n; i++) {
vk[i] = KMP<string>(s);
reverse(s.begin(), s.end());
s.pop_back();
reverse(s.begin(), s.end());
}
vector<int> dp(n + 1, inf);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
int mn = (i - j + 1) - vk[j][i + 1 - j];
if ((i - j + 1) % mn == 0) {
int sz = count((i - j + 1) / mn) + mn;
chmin(dp[i + 1], dp[j] + sz);
} else {
int sz = 1 + i - j + 1;
chmin(dp[i + 1], dp[j] + sz);
}
}
}
cout << dp[n] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr;
vector<int> arr1;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
arr.push_back(temp);
arr1.push_back(temp);
}
sort(arr.begin(), arr.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if (arr[i] != arr1[i]) ans++;
if (ans > 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000, K = 9, S = 1e5;
int a[N][N], rear[N][K][2], note[S], dist[K][K], m, n, k, s;
void enter() {
cin >> m >> n >> k >> s;
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j) cin >> a[i][j], --a[i][j];
for (int i = 0; i < s; ++i) cin >> note[i], --note[i];
}
void calcRear() {
memset(rear, -1, sizeof rear);
for (int i = 0; i < m; ++i)
for (int j = 0; j < k; ++j) {
for (int y = 0; y < n; ++y)
if (a[i][y] == j) {
rear[i][j][0] = y;
break;
}
for (int y = n - 1; y >= 0; --y)
if (a[i][y] == j) {
rear[i][j][1] = y;
break;
}
}
}
void calcDistance() {
for (int t1 = 0; t1 < k; ++t1)
for (int t2 = t1; t2 < k; ++t2) {
for (int r1 = 0; r1 < m; ++r1)
for (int r2 = 0; r2 < m; ++r2)
for (int d1 = 0; d1 < 2; ++d1)
if (rear[r1][t1][d1] != -1 && rear[r2][t2][d1 ^ 1] != -1)
dist[t1][t2] = max(
dist[t1][t2],
abs(r1 - r2) + abs(rear[r1][t1][d1] - rear[r2][t2][d1 ^ 1]));
dist[t2][t1] = dist[t1][t2];
}
}
void solve() {
int res = 0;
for (int i = 1; i < s; ++i) res = max(res, dist[note[i - 1]][note[i]]);
cout << res << endl;
}
int main() {
ios::sync_with_stdio(false);
enter();
calcRear();
calcDistance();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int MN = 2e3 + 10;
int n, m;
long double dp[MN][MN];
bool R[MN], C[MN];
int r = 0, c = 0;
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = n; ~i; --i)
for (int j = n; ~j; --j) {
if (i == n && j == n) continue;
long double val = 1;
if (i != n) val += (long double)(n - i) * j / n / n * (dp[i + 1][j]);
if (j != n) val += (long double)i * (n - j) / n / n * (dp[i][j + 1]);
if (i != n && j != n)
val += (long double)(n - i) * (n - j) / n / n * (dp[i + 1][j + 1]);
dp[i][j] = val / ((long double)1.0 - ((long double)i * j / n / n));
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
if (!R[a]) ++r;
if (!C[b]) ++c;
R[a] = C[b] = true;
}
cout << setprecision(12) << fixed << dp[r][c] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ans=0;
int main(){
char c=getchar();
if(c==EOF)
return printf("%d\n",ans),0;
ans+=(c=='1');main();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[210], b[210], c;
int main() {
int n, m;
cin >> n >> m;
int j = 0;
int count = 0;
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
cin >> a[i];
}
while (a[0] < m) {
int i = 0;
while (a[i] < m && i < n) {
if (a[i] != a[i + 1]) {
a[i]++;
}
i++;
}
count++;
}
cout << count << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string f0 =
"What are you doing at the end of the world? Are you busy? Will you save "
"us?";
string fi0 = "What are you doing while sending \"";
string fi2 = "\"? Are you busy? Will you send \"";
string fi4 = "\"?";
const int N = 1e5 + 1;
const long long K = 1e18;
long long len[N];
char get(int n, long long k) {
if (k >= len[n]) return '.';
if (n == 0) return f0[k];
if (k < fi0.size()) return fi0[k];
k -= fi0.size();
if (k < len[n - 1]) return get(n - 1, k);
k -= len[n - 1];
if (k < fi2.size()) return fi2[k];
k -= fi2.size();
if (k < len[n - 1]) return get(n - 1, k);
k -= len[n - 1];
return fi4[k];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
len[0] = f0.size();
for (int i = 1; i < N; i++) {
if (len[i - 1] >= K) {
len[i] = len[i - 1];
} else {
len[i] = fi0.size() + fi2.size() + fi4.size() + 2 * len[i - 1];
}
}
int q;
cin >> q;
while (q--) {
int n;
long long k;
cin >> n >> k;
cout << get(n, k - 1);
}
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
long long powm(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
void fukof() {}
void problem() {}
const long long mod = 1e9 + 7;
const long long N = 1000005;
const long long inf = 1e9;
int n, k, ans;
vector<set<int>> g, leaves;
struct comp {
bool operator()(int a, int b) const {
if (leaves[a].size() == leaves[b].size()) return a < b;
return leaves[a].size() > leaves[b].size();
}
};
void solve() {
cin >> n >> k;
g = leaves = vector<set<int>>(n);
int x, y;
for (long long i = 0; i < (n - 1); i++) {
cin >> x >> y;
x--, y--;
g[x].insert(y);
g[y].insert(x);
}
for (long long i = 0; i < (n); i++)
if (g[i].size() == 1) leaves[*g[i].begin()].insert(i);
set<int, comp> st;
for (long long i = 0; i < (n); i++) st.insert(i);
int ans = 0;
while (true) {
int v = *st.begin();
if (leaves[v].size() < k) break;
for (long long i = 0; i < (k); i++) {
int lf = *leaves[v].begin();
g[lf].erase(v);
g[v].erase(lf);
st.erase(v);
st.erase(lf);
leaves[v].erase(lf);
if (leaves[lf].count(v)) leaves[lf].erase(v);
if (g[v].size() == 1) {
int to = *g[v].begin();
st.erase(to);
leaves[to].insert(v);
st.insert(to);
}
st.insert(v);
st.insert(lf);
}
ans++;
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int tc = 1;
cin >> tc;
while (tc--) {
problem();
fukof();
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[101], b[101], c[101];
gets(a);
gets(b);
gets(c);
int count = 0;
int alen, blen, clen;
alen = strlen(a);
blen = strlen(b);
clen = strlen(c);
int flag = 0;
for (int i = 0; i < alen; i++) {
if (a[i] == 'a' || a[i] == 'e' || a[i] == 'o' || a[i] == 'i' ||
a[i] == 'u') {
count++;
}
}
if (count == 5) {
flag++;
}
count = 0;
for (int i = 0; i < blen; i++) {
if (b[i] == 'a' || b[i] == 'e' || b[i] == 'o' || b[i] == 'i' ||
b[i] == 'u') {
count++;
}
}
if (count == 7) {
flag++;
}
count = 0;
for (int i = 0; i < clen; i++) {
if (c[i] == 'a' || c[i] == 'e' || c[i] == 'o' || c[i] == 'i' ||
c[i] == 'u') {
count++;
}
}
if (count == 5) {
flag++;
}
if (flag == 3) {
cout << "YES\n";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
void Main() {
int N, K;
cin >> N >> K;
vector<double> P(N), ans(N);
for (int i = int(0); i < int(N); ++i) cin >> P[i];
int NN = N;
for (int i = int(0); i < int(N); ++i) {
if (P[i] < EPS) NN--;
}
K = min(NN, K);
vector<double> dp((1LL << (N)));
dp[0] = 1;
for (int mask = int(0); mask < int((1LL << (N))); ++mask) {
double sum = 1.0;
for (int i = int(0); i < int(N); ++i)
if (mask & (1LL << (i))) {
sum -= P[i];
}
if (sum > EPS) {
for (int i = int(0); i < int(N); ++i)
if ((mask & (1LL << (i))) == 0) {
dp[mask | (1LL << (i))] += dp[mask] * P[i] / sum;
}
}
}
for (int mask = int(0); mask < int((1LL << (N))); ++mask) {
if (__builtin_popcount(mask) == K) {
for (int i = int(0); i < int(N); ++i)
if (mask & (1LL << (i))) {
ans[i] += dp[mask];
}
}
}
for (int i = int(0); i < int(N); ++i) {
(void)printf(i + 1 < N ? "%.10f " : "%.10f\n", ans[i]);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
Main();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
string kek;
kek.reserve(29999999);
for (int i = 0; i < n; i++) {
string x;
cin >> x;
if (x[0] == '0') {
cout << "0" << endl;
return 0;
}
bool asd = false;
bool topkek = false;
for (auto a : x) {
if (a == '1' && asd || (a != '0' && a != '1')) {
kek.insert(0, x);
topkek = true;
break;
} else if (a == '1')
asd = true;
}
if (!topkek) kek.append(x.length() - 1, '0');
}
if (kek[0] == '0' || kek.length() == 0) kek.insert(0, "1");
cout << kek << endl;
}
| 2 |
#include <bits/stdc++.h>
int t, n, i, j, o, p, v, a[1001];
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
o = 0;
t = 0;
p = a[i];
for (j = i; j >= 0; j--) {
if (a[j] <= p)
o++;
else
break;
p = a[j];
t = 1;
}
p = a[i];
for (j = i + 1; j < n; j++) {
if (a[j] <= p)
o++;
else {
break;
}
p = a[j];
}
if (o > v) v = o;
}
printf("%d", v);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int criba[1000100 + 1];
void crearcriba() {
int w[] = {4, 2, 4, 2, 4, 6, 2, 6};
for (int p = 25; p <= 1000100; p += 10) criba[p] = 5;
for (int p = 9; p <= 1000100; p += 6) criba[p] = 3;
for (int p = 4; p <= 1000100; p += 2) criba[p] = 2;
for (int p = 7, cur = 0; p * p <= 1000100; p += w[cur++ & 7])
if (!criba[p])
for (int j = p * p; j <= 1000100; j += (p << 1))
if (!criba[j]) criba[j] = p;
}
vector<long long> primos;
void buscarprimos() {
crearcriba();
for (int i = (2); i < (1000100 + 1); i++)
if (!criba[i]) primos.push_back(i);
}
long long cota;
vector<long long> divisores;
int main() {
cin.tie(0), ios_base::sync_with_stdio(0), cout.tie(0);
cin >> cota;
buscarprimos();
for (long long i = 1; i * i <= cota; i++) {
if (cota % i == 0) {
if (i != cota / i) {
divisores.push_back(i);
divisores.push_back(cota / i);
} else
divisores.push_back(i);
}
}
sort(divisores.begin(), divisores.end());
long long respuesta;
bool posible = false;
for (int i = divisores.size() - 1; i >= 0; i--) {
posible = true;
for (auto j : primos) {
if (j * j > divisores[i]) break;
if (divisores[i] % (j * j) == 0) {
posible = false;
break;
}
}
if (posible) {
respuesta = divisores[i];
break;
}
}
cout << respuesta << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
using lint = long long;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;
int main() {
cin.tie(nullptr); ios::sync_with_stdio(false);
int n, k; cin >> n >> k;
k = n - k;
if (k == 0) return cout << 0 << endl, 0;
VV<lint> dp(k + 2, V<lint>(n, 1e18));
V<> h(n);
REP(i, n) {
cin >> h[i];
for (int x = k; x >= 2; --x) REP(j, i) {
dp[x][i] = min(dp[x][i], dp[x - 1][j] + (h[j] < h[i] ? h[i] - h[j] : 0));
}
dp[1][i] = h[i];
}
cout << *min_element(begin(dp[k]), end(dp[k])) << endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int mod = 1000000007;
struct Mod {
public:
int num;
Mod() : Mod(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) {
static_assert(mod < INT_MAX / 2,
"mod is too big, please make num 'long long int' from 'int'");
}
Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) {
return Mod((mod + a.num - b.num) % mod);
}
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) {
return Mod(((long long)a.num * b.num) % mod);
}
Mod operator*(const long long int a, const Mod b) { return Mod(a) * b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b) * a; }
Mod operator*(const Mod a, const int b) { return Mod(b) * a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod &a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
Mod mod_pow(const Mod a, const long long int n) {
if (n == 0) return Mod(1);
Mod res = mod_pow((a * a), (n / 2));
if (n % 2) res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) { return Mod(a) / b; }
Mod operator/=(Mod &a, const Mod b) { return a = a / b; }
Mod fact[1024000], factinv[1024000];
void init(const int amax = 1024000) {
fact[0] = Mod(1);
factinv[0] = 1;
for (int i = 0; i < amax - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
template <typename T>
vector<vector<T>> keisann(const vector<vector<T>> l,
const vector<vector<T>> r) {
vector<vector<T>> ans(l.size(), vector<T>(r[0].size()));
assert(l[0].size() == r.size());
for (unsigned int h = 0; h < l.size(); ++h) {
for (unsigned int i = 0; i < r.size(); ++i) {
for (unsigned int w = 0; w < r[0].size(); ++w) {
ans[h][w] += l[h][i] * r[i][w];
}
}
}
return ans;
}
template <typename T>
vector<vector<T>> powgyou(vector<vector<T>> a, const long long int n) {
assert(a.size() == a[0].size());
if (!n) {
vector<vector<T>> e(a.size(), vector<T>(a[0].size()));
for (unsigned int i = 0; i < a.size(); ++i) {
e[i][i] = 1;
}
return e;
}
if (n == 1)
return a;
else {
vector<vector<T>> ans(a.size(), vector<T>(a[0].size(), 0));
ans = powgyou(a, n / 2);
ans = keisann(ans, ans);
if (n % 2) {
ans = keisann(ans, a);
}
return ans;
}
}
int main() {
long long int N;
int M;
cin >> N >> M;
vector<vector<Mod>> ini(1, vector<Mod>(M, 0));
ini[0][0] = Mod(1);
vector<vector<Mod>> gyou(M, vector<Mod>(M));
for (int i = 0; i < M - 1; ++i) {
gyou[i][i + 1] = Mod(1);
}
gyou[0][0] = Mod(1);
gyou[M - 1][0] = Mod(1);
vector<vector<Mod>> po_gy = powgyou(gyou, N);
vector<vector<Mod>> ans = keisann(ini, po_gy);
cout << ans[0][0].num << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 2005;
int l[maxn], r[maxn], a[maxn];
long long dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i] >> a[i];
for (int i = n; i >= 1; i--) {
long long need = a[i];
if (r[i] == l[i + 1]) need += dp[i + 1];
if (1ll * k * (r[i] - l[i] + 1) < need) return cout << -1, 0;
dp[i] = max(1ll * 0, need - 1ll * k * (r[i] - l[i]));
}
long long res = k, ans = 0;
for (int i = 1; i <= n; i++) {
if (res < dp[i]) {
ans += res;
res = k;
}
ans += a[i];
res = ((res - a[i]) % k + k) % k;
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100;
int N;
char S[MAXN], T[MAXN];
int fail[MAXN];
char op(char ch) {
if (ch == 'N') return 'S';
if (ch == 'S') return 'N';
if (ch == 'E') return 'W';
return 'E';
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
N--;
for (int i = 0; i < N; i++) {
char ch;
cin >> ch;
T[N - 1 - i] = op(ch);
}
for (int i = 0; i < N; i++) cin >> S[i];
fail[0] = -1;
for (int i = 1; i < N; i++) {
int cloc = fail[i - 1];
while (cloc >= 0 && T[i - 1] != T[cloc]) {
cloc = fail[cloc];
}
fail[i] = cloc + 1;
}
int tloc = 0;
for (int i = 0; i < N; i++) {
while (tloc >= 0 && S[i] != T[tloc]) tloc = fail[tloc];
tloc++;
}
if (tloc)
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
int p[N], nxt[N];
bool go(int l, int r, int& cur) {
if (l == r) return true;
int pos = l;
vector<pair<int, int> > vec;
while (nxt[pos] < r) {
vec.push_back({pos, nxt[pos]});
pos = nxt[pos];
}
if (nxt[pos] > r) return false;
vec.push_back({pos, nxt[pos]});
reverse(vec.begin(), vec.end());
for (auto pr : vec) {
p[pr.first] = cur--;
if (!go(pr.first + 1, pr.second, cur)) return false;
}
return true;
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", nxt + i);
if (nxt[i] == -1)
nxt[i] = i + 1;
else
--nxt[i];
}
int cur = n;
if (go(0, n, cur))
for (int i = 0; i < n; ++i) printf("%d ", p[i]);
else
printf("-1");
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
typedef struct {
long long x, y, r;
} circle;
int main() {
circle a, b;
long long dsq;
long double d, al, cos_al, be, cos_be, out;
std::cin >> a.x >> a.y >> a.r;
std::cin >> b.x >> b.y >> b.r;
dsq = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
d = sqrt(dsq);
if ((a.r - b.r) * (a.r - b.r) >= dsq)
out = acosl(-1) * std::min(a.r, b.r) * std::min(a.r, b.r);
else if (dsq >= (a.r + b.r) * (a.r + b.r))
out = 0;
else {
cos_al = (b.r * b.r - a.r * a.r + dsq) / (b.r * 2 * d);
al = acosl(cos_al);
out = (b.r * b.r) * (al - cosl(al) * sinl(al));
cos_be = (a.r * a.r - b.r * b.r + dsq) / (a.r * 2 * d);
be = acosl(cos_be);
out += (a.r * a.r) * (be - cosl(be) * sinl(be));
}
std::cout << std::setprecision(15) << out;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, l, r, num_0, num_1, num_2;
long long dp[200005][3], mod[3];
void calc(int i, int md) {
if (md == 2) {
dp[i][2] += ((dp[i - 1][0]) * mod[2]) % 1000000007;
dp[i][2] %= 1000000007;
dp[i][2] += ((dp[i - 1][2]) * mod[0]) % 1000000007;
dp[i][2] %= 1000000007;
dp[i][2] += ((dp[i - 1][1]) * mod[1]) % 1000000007;
dp[i][2] %= 1000000007;
}
if (md == 1) {
dp[i][1] += ((dp[i - 1][0]) * mod[1]) % 1000000007;
dp[i][1] %= 1000000007;
dp[i][1] += ((dp[i - 1][1]) * mod[0]) % 1000000007;
dp[i][1] %= 1000000007;
dp[i][1] += ((dp[i - 1][2]) * mod[2]) % 1000000007;
dp[i][1] %= 1000000007;
}
if (md == 0) {
dp[i][0] += ((dp[i - 1][1]) * mod[2]) % 1000000007;
dp[i][0] %= 1000000007;
dp[i][0] += ((dp[i - 1][2]) * mod[1]) % 1000000007;
dp[i][0] %= 1000000007;
dp[i][0] += ((dp[i - 1][0]) * mod[0]) % 1000000007;
dp[i][0] %= 1000000007;
}
}
int main() {
cin >> n >> l >> r;
mod[0] = (r / 3) - (l / 3) + (l % 3 == 0);
mod[1] = ((r - 1) / 3) - ((l - 1) / 3) + ((l - 1) % 3 == 0);
mod[2] = (r - l) + 1 - mod[1] - mod[0];
dp[1][0] = mod[0];
dp[1][1] = mod[1];
dp[1][2] = mod[2];
for (int i = 2; i <= n; ++i) {
calc(i, 0);
calc(i, 1);
calc(i, 2);
}
cout << dp[n][0];
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n;cin>>n;
string s;cin>>s;ll r=0,b=0,g=0;
for(int i=0;i<s.size();i++){
if(s[i]=='R')r++;
else if(s[i]=='G')b++;
else if(s[i]=='B')g++;
}ll sum=r*g*b;
for(int i=1;i<=(n-1)/2;i++)
for(int k=0;k<n-2*i;k++)
{
if(s[k]!=s[k+i]&&s[k+i]!=s[k+i+i]&&s[k]!=s[k+i+i])
sum-- ;
}
cout<<sum<<endl;
} | 0 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<bitset>
#include<map>
#include<vector>
using namespace std;
const pair<int,int> no=make_pair(-1,2333333);
#define N 50050
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int n,m,T,x[N<<1],y[N<<1],col[N<<1];
void Output(){
for(int i=1;i<=m;++i){
putchar(col[i]?'^':'v');
}
putchar('\n');
}
namespace Task_1{
bitset<N> to[N];
int ok[N];
void Find(int k){
ok[x[k]]=ok[y[k]]=1;
for(int i=k-1;i>=1;--i){
if(!ok[x[i]]&&!ok[y[i]])continue;
if(ok[x[i]])col[i]=1;
ok[x[i]]=ok[y[i]]=1;
}
}
void Solve(){
for(int i=1;i<=n;++i){
to[i][i]=1;
}
for(int i=1;i<=m;++i){
to[x[i]]=to[y[i]]=to[x[i]]|to[y[i]];
if((int)to[x[i]].count()==n){
Find(i);
Output();
return;
}
}
printf("-1\n");
}
}
namespace Task_2{
vector<pair<int,int> > vec[N];
void Solve(){
if(n==2){
puts("-1");return;
}
for(int i=m;i>=1;--i){
vec[x[i]].emplace_back(y[i],i);
vec[y[i]].emplace_back(x[i],i);
}
int A=x[1],B=y[1]+1;
if(B>n)A=x[1]-1,B=y[1];
if(A<1)A=x[1]+1,B=y[1];
for(int i=1;i<=m;++i){
while(!vec[A].empty()&&vec[A].back().second<=i)vec[A].pop_back();
while(!vec[B].empty()&&vec[B].back().second<=i)vec[B].pop_back();
auto tA=vec[A].empty()?no:vec[A].back();
auto tB=vec[B].empty()?no:vec[B].back();
bool rev=(tA.second<tB.second&&tA.first==B)||(tA.second>=tB.second&&tB.first==A);
if(x[i]==A||y[i]==A){
col[i]=rev^(x[i]==A);
if(rev)A=(x[i]==A)?y[i]:x[i];
}
else if(x[i]==B||y[i]==B){
col[i]=rev^(x[i]==B);
if(rev)B=(x[i]==B)?y[i]:x[i];
}
}
Output();
}
}
int main(){
n=read(),m=read(),T=read();
for(int i=1;i<=m;++i){
x[i]=read(),y[i]=read();
}
if(T==1){
Task_1::Solve();
}
else{
Task_2::Solve();
}
return 0;
}
| 0 |
// 2014/08/30 Tazoe
#include <iostream>
using namespace std;
int main()
{
int N;
cin >> N;
for(int i=0; i<N; i++){
int x, y, b, p;
cin >> x >> y >> b >> p;
int f1 = x*b+y*p; // 割引なし
if(b<5){
b = 5;
}
if(p<2){
p = 2;
}
int f2 = (x*b+y*p)*4/5; // 割引あり
if(f1<f2){
cout << f1 << endl;
}
else{
cout << f2 << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using str = string;
using srt = short;
const int INF = (int)1e9 + 4;
const int MOD = (int)1e9 + 7;
const int N = 1005;
const ll inf = (ll)4e18;
const ll mod = 998244353;
bool us[N][N];
set<pair<int, int>> ans;
vector<pair<int, int>> arr(3);
vector<pair<int, int>> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int dist(pair<int, int> a, pair<int, int> b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
void vToV(int st, int en) {
int x1 = arr[st].first, y1 = arr[st].second, x2 = arr[en].first,
y2 = arr[en].second;
ans.insert({x1, y1});
while (x1 != x2 || y1 != y2) {
us[x1][y1] = 1;
if (x1 < x2 && us[x1 + 1][y1]) {
ans.insert({++x1, y1});
} else if (y1 < y2 && us[x1][y1 + 1]) {
ans.insert({x1, ++y1});
} else if (y1 > y2 && us[x1][y1 - 1]) {
ans.insert({x1, --y1});
} else {
int dst = INF;
pair<int, int> dir;
for (auto it : dirs) {
int now = dist({x1 + it.first, y1 + it.second}, {x2, y2});
if (now < dst) {
dir = it;
dst = now;
}
}
x1 += dir.first;
y1 += dir.second;
ans.insert({x1, y1});
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
for (auto &it : arr) {
cin >> it.first >> it.second;
ans.insert(it);
us[it.first][it.second] = 1;
}
sort(begin(arr), end(arr));
arr.emplace_back(arr.back());
vToV(0, 1);
vToV(1, 2);
cout << ans.size() << endl;
for (auto &it : ans) cout << it.first << ' ' << it.second << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, j;
cin >> n;
vector<int> v(n), used(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = 0; i < n - 1; i++) {
j = i + 1;
while (j < n && (v[j] == v[i] || used[j] == 1)) j++;
if (j < n) {
v[i] = 0;
used[j] = 1;
}
}
for (int i = 0; i < n; i++)
if (v[i] > 0) ans++;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, n, k, a[4000] = {};
void solve() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> a[i];
k = min(k, m - 1);
int ans = 0, temp;
for (int i = 0; i <= k; i++) {
temp = 1e9;
for (int j = 0; j <= m - k - 1; j++) {
temp = min(temp, max(a[i + j], a[n - m + i + j]));
}
ans = max(ans, temp);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;
while (tt--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string word;
cin >> word;
for (int i = 0; i < 26; i++) {
char c = i + 'a';
for (int j = 0; j <= word.size(); j++) {
string copy = word;
copy.insert(copy.begin() + j, c);
string revCopy = copy;
reverse(revCopy.begin(), revCopy.end());
if (revCopy == copy) {
cout << copy;
return 0;
}
}
}
cout << "NA";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
vector<long long> zeus(long long n) {
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
return a;
}
void Shazam() {
string s;
cin >> s;
vector<pair<char, bool>> v;
for (long long i = 0; i < s.size(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
if (s[i - 1] == '/')
v.push_back(make_pair(s[i], 0));
else
v.push_back(make_pair(s[i], 1));
}
}
long long sp = 0;
for (long long i = 0; i < v.size(); i++) {
if (v[i].second == 1) {
for (long long j = 0; j < sp; j++) cout << " ";
cout << "<" << v[i].first << ">"
<< "\n";
sp += 2;
} else {
sp -= 2;
for (long long j = 0; j < sp; j++) cout << " ";
cout << "</" << v[i].first << ">"
<< "\n";
}
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
Shazam();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main(void) {
int n, p, s;
char* c;
scanf("%d", &n);
n--;
for (p = 0; (int)5.0 * pow(2.0, (double)p) <= n; p++) {
n -= (int)5.0 * pow(2.0, (double)p);
}
s = (int)((double)n / pow(2.0, (double)p));
switch (s) {
case 0:
c = "Sheldon";
break;
case 1:
c = "Leonard";
break;
case 2:
c = "Penny";
break;
case 3:
c = "Rajesh";
break;
case 4:
c = "Howard";
break;
default:
break;
}
printf("%s\n", c);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[110], b[110], c[100];
int f1 = 0, se = 0, f2 = 0;
gets(a);
int l1 = strlen(a);
for (int i = 0; i < l1; i++) {
if (a[i] == 'a' || a[i] == 'e' || a[i] == 'i' || a[i] == 'o' || a[i] == 'u')
f1++;
}
gets(b);
int l2 = strlen(b);
for (int i = 0; i < l2; i++) {
if (b[i] == 'a' || b[i] == 'e' || b[i] == 'i' || b[i] == 'o' || b[i] == 'u')
se++;
}
gets(c);
int l3 = strlen(c);
for (int i = 0; i < l3; i++) {
if (c[i] == 'a' || c[i] == 'e' || c[i] == 'i' || c[i] == 'o' || c[i] == 'u')
f2++;
}
if (f1 == 5 && se == 7 && f2 == 5)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
long long n;
int main(void){
cin>>n;
n++;
int ans=0;
while(n/10>=1){
n/=10;
ans++;
}
cout<<n+9*ans-1<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = (int)s.size();
vector<int> vl(n + 1, n);
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
vl[i] = vl[i + 1];
for (int k = 1; i + 2 * k < vl[i]; k++) {
if (s[i] == s[i + k] && s[i + k] == s[i + 2 * k]) {
vl[i] = i + 2 * k;
break;
}
}
ans += n - vl[i];
}
cout << ans << endl;
}
| 2 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=17, M=70000;
int a[N][N], n, F[M];
void precomp(int x)
{
for(int i = 0; i < n; i++)
{
if((x & (1<<i)) == 0LL) continue;
for(int j = 0; j < n; j++)
{
if(x & (1<<j))
{
F[x]+=a[i][j];
}
}
}
F[x]/=2;
}
signed main()
{
cin >> n;
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
cin >> a[i][j];
}
}
for(int i = 0; i < (1<<n); i++)
{
precomp(i);
for(int j = i; j > 0; j = (j-1)&i)
{
F[i]=max(F[i], F[j] + F[i^j]);
}
}
cout << F[(1<<n)-1];
} | 0 |
#include <bits/stdc++.h>
int main() {
int n, i, count = 0;
scanf("%d", &n);
int a[n], c[105] = {0};
for (i = 0; i < n; i++) {
int b = 0;
scanf("%d%d", &a[i], &b);
c[b]++;
}
for (i = 0; i < n; i++) count = count + c[a[i]];
printf("%d", count);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
set<pair<long long, int> > pos[200309];
vector<int> g[200309];
int s[200309];
long long S, w[200309], off[200309];
int n, L;
void merge(int u, int v) {
if (pos[v].size() > pos[u].size()) {
swap(pos[u], pos[v]);
swap(off[u], off[v]);
}
for (auto pp : pos[v]) {
long long curw = pp.first + off[v] - off[u];
pos[u].insert({curw, pp.second});
}
pos[v].clear();
}
void dfs(int u, int h) {
s[u] = 0;
off[u] = 0;
for (int v : g[u]) {
dfs(v, h + 1);
s[u] += s[v];
off[v] += w[u];
merge(u, v);
}
while (!pos[u].empty()) {
auto cur = *pos[u].rbegin();
if (cur.first + off[u] > S)
pos[u].erase(cur);
else
break;
}
while (!pos[u].empty()) {
auto cur = *pos[u].rbegin();
if (cur.second - h > L - 1)
pos[u].erase(cur);
else
break;
}
if (pos[u].empty()) {
s[u]++;
pos[u].insert({w[u], h});
off[u] = 0;
}
}
int main() {
scanf("%d %d %lld", &n, &L, &S);
bool ok = true;
for (int u = 1; (u) <= int(n); (u)++) {
scanf("%lld", &w[u]);
if (w[u] > S) ok = false;
}
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
dfs(1, 0);
printf("%d\n", ok ? s[1] : -1);
return 0;
}
| 5 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
//struct PMA {
// PMA *next[128]; // next[0] is for fail
// vector<int> accept;
// PMA() { fill(next, next + 128, (PMA*)NULL); }
//};
//
//PMA *buildPMA(string p[1000], int size) {
// PMA *root = new PMA;
// for (int i = 0; i < size; i++) { // make trie
// PMA *t = root;
// for (int j = 0; p[i][j]; j++) {
// int c = p[i][j];
// if (t->next[c] == NULL) {
// t->next[c] = new PMA;
// }
// t = t->next[c];
// }
// t->accept.push_back(i);
// }
// queue<PMA*> que; // make failure link using bfs
// for (int c = 1; c < 128; c++) {
// if (root->next[c]) {
// root->next[c]->next[0] = root;
// que.push(root->next[c]);
// }
// else {
// root->next[c] = root;
// }
// }
// while (!que.empty()) {
// PMA *t = que.front();
// que.pop();
// for (int c = 1; c < 128; c++) {
// if (t->next[c] != NULL) {
// que.push(t->next[c]);
// PMA *r = t->next[0];
// while (!r->next[c]) {
// r = r->next[0];
// }
// t->next[c]->next[0] = r->next[c];
// for (vector<int>::iterator it = r->next[c]->accept.begin(); it != r->next[c]->accept.end(); it++) {
// t->next[c]->accept.push_back(*it);
// }
// }
// }
// }
// return root;
//}
//
//void deletePMA(PMA *root) {
// set<PMA*> visit;
// queue<PMA*> que;
// que.push(root);
// visit.insert(root);
// while (!que.empty()) {
// PMA *t = que.front();
// que.pop();
// for (int c = 1; c < 128; c++) {
// if (t->next[c] == NULL) { continue; }
// if (visit.count(t->next[c])) { continue; }
// visit.insert(t->next[c]);
// que.push(t->next[c]);
// }
// }
// for (set<PMA*>::iterator it = visit.begin(); it != visit.end(); it++) {
// delete *it;
// }
//}
//
//// n = strlen(t)
//// m[i] = strlen(p[i])
//vector<int> match(const char *t, int n, const PMA *v, int m[], int size) {
// vector<int> ret(size, -1);
// //int n = strlen(t);
// for (int i = 0; i < n; i++) {
// int c = t[i];
// while (!v->next[c]) {
// v = v->next[0];
// }
// v = v->next[c];
// for (vector<int>::const_iterator it = v->accept.begin(); it != v->accept.end(); it++) {
// if (ret[*it] != -1) { continue; }
// ret[*it] = i - m[*it] + 1;
// }
// }
// return ret;
//}
//int main() {
// while (1) {
// int N, M, K; cin >> N >> M >> K;
// vector<string>names;
// char oks[1000][1000];
// memset(oks, 0, sizeof(oks));
// for (size_t i = 0; i < N; i++)
// {
//
// string from, to; cin >> from >> to;
// auto ft = find(names.begin(), names.end(), from);
// if (ft == names.end()) {
// names.push_back(from);
// }
// auto tt = find(names.begin(), names.end(), to);
// if (tt == names.end()) {
// names.push_back(to);
// }
// ft = find(names.begin(), names.end(), from);
// tt = find(names.begin(), names.end(), to);
// oks[ft - names.begin()][tt - names.begin()] = true;
// }
// string seasons[1000];
// int aa[3];
// for (size_t i = 0; i < K; i++)
// {
// string st; cin >> st;
// seasons[i] = st;
// aa[i] = st.size();
//
// }
// auto it = buildPMA(seasons, K);
// char* c = "sakuraha";
// vector<int>m(match(c, 9, it, aa, 3));
// int a=0;
// a++;
// }
// return 0;
//}
#define REP(i,n) for(int i=0;i<n;++i)
struct SuffixArray {
struct SAComp {
const int h; const vector<int> &g;
SAComp(const int h_, const vector<int>&g_) : h(h_), g(g_) { ; }
bool operator() (int a, int b) {
return a == b ? false : g[a] != g[b] ? g[a] < g[b] : g[a + h] < g[b + h];
}
};
static const int SIZE = 100000;
int n;
string str;
vector<int> sa;
vector<int> lcp;
SuffixArray() { ; }
SuffixArray(const string t):str(t) {
Init();
}
void Init() {
n = str.size();
buildSA();
buildLCP();
}
// O(mlogn)
////?????°????????????
//int find(const string p) {
// int m = p.size();
// int left = 0;
// int right = n-m;
// while (left < right) {
// int mid = (left + right) / 2;
// if (str.substr(sa[mid],m)<p.substr(0,m)) { left = mid + 1; }
// else { right = mid; }
// }
// return str.substr(sa[left], m)== p.substr(0, m)? sa[left] : -1;
//}
private:
//O(nlog^2n)
void buildSA() {
sa = vector<int>(n + 1);
vector<int>g(n + 1);
vector<int>b(n + 1);
REP(i, n + 1) { sa[i] = i; g[i] = str[i]; }
b[0] = 0;
b[n] = 0;
SAComp f(0, g);
sort(sa.begin(), sa.end(),SAComp(0,g));
for (int h = 1; b[n] != n; h *= 2) {
SAComp comp(h, g);
sort(sa.begin(), sa.end(), comp);
REP(i, n) b[i + 1] = b[i] + comp(sa[i], sa[i + 1]);
REP(i, n + 1) g[sa[i]] = b[i];
}
}
void buildLCP() {
lcp = vector<int>(n + 1);
int h = 0;
vector<int>b(n + 1);
REP(i, n + 1) { b[sa[i]] = i; }
REP(i, n + 1) {
if (b[i]) {
for (int j = sa[b[i] - 1]; j + h < n && i + h < n && str[j + h] == str[i + h]; h++) { ; }
lcp[b[i]] = h;
}
else {
lcp[b[i]] = -1;
}
if (h > 0) { h--; }
}
}
};
#define Seg_Max_N (1<<19)
using Value = pair<int, int>;
Value dat[2 * Seg_Max_N];
struct segtree {
int N;
const Value ini=(make_pair(-1, 100000000));
segtree() {}
segtree(int n) {
N = 1;
while (N < n) N *= 2;
for (int i = 0; i < 2 * N - 1; i++) {
dat[i] = ini;
}
}
// update k th element
void update(int k, Value a) {
k += N - 1; // leaf
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
const Value al(dat[k * 2 + 1]);
const Value ar(dat[k * 2 + 2]);
dat[k] = make_pair(max(al.first,ar.first),min(al.second,ar.second));
}
}
// min [a, b)
Value query(int a, int b) { return query(a, b, 0, 0, N); }
Value query(int a, int b, int k, int l, int r) {
if (r <= a or b <= l) return ini;
if (a <= l and r <= b) return dat[k];
const int m = (l + r) / 2;
const Value al(query(a, b, k * 2 + 1, l, m));
const Value ar(query(a, b, k * 2 + 2, m, r));
return make_pair(max(al.first, ar.first), min(al.second, ar.second));
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string st; cin >> st;
SuffixArray sf(st.c_str());
segtree seg(st.size() + 1);
for (int i = 0; i < sf.n + 1; ++i) {
seg.update(i, make_pair(sf.sa[i], sf.sa[i]));
}
int M; cin >> M;
for (int i = 0; i < M; ++i) {
{
int f, t;
string from; cin >> from;
{
int left, right;
{
int amin = -1;
int amax = sf.n+1;
int a = 31;
while (a--) {
int amid = (amin + amax) / 2;
string ast = sf.str.substr(sf.sa[amid], from.size());
if (ast < from)amin = amid;
else amax = amid;
}
left = amin;
}
{
int amin = -1;
int amax = sf.n + 1;
int a = 31;
while (a--) {
int amid = (amin + amax) / 2;
string ast = sf.str.substr(sf.sa[amid], from.size());
if (ast <= from)amin = amid;
else amax = amid;
}
right = amin;
}
f = seg.query(left+1 , right+1 ).second;
}
int ans = 0;
string to; cin >> to;
{
ans += to.size();
int left, right;
{
int amin = -1;
int amax = sf.n + 1;
int a = 31;
while (a--) {
int amid = (amin + amax) / 2;
string ast = sf.str.substr(sf.sa[amid], to.size());
if (ast < to)amin = amid;
else amax = amid;
}
left = amin;
}
{
int amin = -1;
int amax = sf.n + 1;
int a = 31;
while (a--) {
int amid = (amin + amax) / 2;
string ast = sf.str.substr(sf.sa[amid], to.size());
if (ast <= to)amin = amid;
else amax = amid;
}
right = amin;
}
t = seg.query(left+1, right+1).first;
}
ans+= t - f;
if (ans < 0)ans = -1;
if (ans < to.size())ans = -1;
if (ans < from.size())ans = -1;
if (t == -1 || f > 1000000)ans = -1;
if (ans == -1)ans = 0;
printf("%d\n", ans);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int limit = 1e6;
int tree[4 * limit], lazy[4 * limit];
void do_lazy(int i, int val, int l, int r) {
if (l != r)
lazy[i] += val;
else
tree[i] += val;
}
void check_lazy(int i, int l, int r) {
if (l != r) {
lazy[i * 2 + 1] += lazy[i];
lazy[i * 2 + 2] += lazy[i];
}
tree[i] += lazy[i];
lazy[i] = 0;
}
void update(int l, int r, int val, int i, int p, int q) {
if (l > r || p > q || l > q || r < p) return;
if (p >= l && q <= r)
do_lazy(i, val, p, q);
else {
int mid = (p + q) / 2;
update(l, r, val, i * 2 + 1, p, mid);
update(l, r, val, i * 2 + 2, mid + 1, q);
int left = tree[i * 2 + 1] + lazy[i * 2 + 1];
int right = tree[i * 2 + 2] + lazy[i * 2 + 2];
tree[i] = max(left, right);
}
}
int query(int l, int r, int i, int p, int q) {
if (l > r || p > q || l > q || r < p) return -2e9;
check_lazy(i, p, q);
if (p >= l && q <= r) return tree[i];
int mid = (p + q) / 2;
int left = query(l, r, i, p, mid);
int right = query(l, r, i, mid + 1, q);
return max(left, right);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, pp;
cin >> n >> m >> pp;
pair<int, int> a[n];
for (int i = 0; i < n; ++i) cin >> a[i].first >> a[i].second;
sort(a, a + n);
pair<int, int> b[m];
vector<int> bb(m);
for (int i = 0; i < m; ++i) cin >> b[i].first >> b[i].second;
sort(b, b + m);
for (int i = 0; i < m; ++i) bb[i] = b[i].first;
for (int i = 0; i < m; ++i) update(i, i, -b[i].second, 0, 0, m - 1);
pair<int, pair<int, int>> arr[pp + 1];
for (int i = 0; i < pp; ++i)
cin >> arr[i].first >> arr[i].second.first >> arr[i].second.second;
sort(arr, arr + pp);
int ans = -2e9, last = 0;
for (int i = 0; i < n; ++i) {
while (last < pp && arr[last].first < a[i].first) {
int j = upper_bound(bb.begin(), bb.end(), arr[last].second.first) -
bb.begin();
update(j, m - 1, arr[last].second.second, 0, 0, m - 1);
++last;
}
ans = max(ans, query(0, m - 1, 0, 0, m - 1) - a[i].second);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main()
{
int n,i,a,b,c,d,e;
int sum;
int max,min;
while(1){
cin >>n;
if(n==0) break;
sum=0;
max=0;
min=999;
for(i=0;i<n;++i){
cin >>a>>b>>c>>d>>e;
sum=a+b+c+e+d;
if(sum>max) max=sum;
if(sum<min) min=sum;
}
cout << max <<" " <<min <<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 51 + 51, MOD = 1e9 + 7, mod = 998244353, INF = 2e18;
mt19937 Flash_new_51(51515);
using vi = vector<long long>;
using vp = vector<pair<long long, long long>>;
struct Node {
long long k, pos, ind;
Node() { k = pos = ind = 0; }
Node(long long k1, long long pos1, long long ind1) {
k = k1, pos = pos1, ind = ind1;
}
};
vector<Node> kek;
bool cmp(Node A, Node B) {
if (A.k == B.k) {
return A.pos < B.pos;
}
return A.k < B.k;
}
long long t[N], n, ans[N], b[N];
pair<long long, long long> a[N];
bool used[N];
void inc(long long i, long long delta) {
used[i] = 1;
for (; i < n; i |= (i + 1)) {
t[i] += delta;
}
}
long long sum(long long i) {
long long summ = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) summ += t[i];
return summ;
}
long long zap(long long pos) {
long long l = 0, r = n;
while (r - l > 1) {
long long m = (r + l) >> 1;
long long k = sum(m);
if (k == pos) {
if (used[m])
return b[m];
else
r = m;
} else {
if (k < pos)
l = m;
else
r = m;
}
}
return b[l];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = -i;
b[i] = a[i].first;
}
sort(a, a + n);
reverse(a, a + n);
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
long long k, pos;
cin >> k >> pos;
kek.push_back({k, pos, i});
}
sort(kek.begin(), kek.end(), cmp);
long long tek = 0;
for (auto to : kek) {
for (long long i = tek; i < to.k; i++) {
inc(abs(a[i].second), 1);
}
tek = to.k;
ans[to.ind] = zap(to.pos);
}
for (long long i = 0; i < q; i++) cout << ans[i] << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100009];
set<int> col[100009];
int c[100009];
int main() {
int n, m, a, b, min = INT_MAX;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c[i];
if (c[i] < min) min = c[i];
}
while (m--) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < adj[i].size(); j++) {
if (c[i] != c[adj[i][j]]) col[c[i]].insert(c[adj[i][j]]);
}
}
int ans = INT_MIN, anscol;
for (int i = 1; i <= 100000; i++) {
int l = col[i].size();
if (l > ans) {
ans = l;
anscol = i;
}
}
if (ans == 0) anscol = min;
cout << anscol << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, head[300010], o = 0, root[300010], id = 0, lc[6000010], rc[6000010],
st[6000010], up = 0, dep[300010], siz[6000010];
long long tree[6000010], add[6000010];
struct point {
int fa, w;
};
int new_node() {
int tmp = up ? st[up--] : ++id;
tree[tmp] = add[tmp] = 1e17;
return tmp;
}
void delte(int u) {
tree[u] = 1e17, lc[u] = rc[u] = add[u] = siz[u] = 0;
st[++up] = u;
}
vector<point> pos[300010];
struct edge {
int to, link;
} e[600010];
void add_edge(int u, int v) {
e[++o].to = v, e[o].link = head[u], head[u] = o;
e[++o].to = u, e[o].link = head[v], head[v] = o;
}
void pushdown(int t) {
if (lc[t]) {
tree[lc[t]] += add[t];
add[lc[t]] += add[t];
}
if (rc[t]) {
tree[rc[t]] += add[t];
add[rc[t]] += add[t];
}
add[t] = 0;
}
void add_tree(int &t, int a, int l, int r, long long c) {
if (!t) t = new_node(), siz[t] = 1;
tree[t] = min(tree[t], c);
if (l == r) return;
pushdown(t);
int mid = (l + r) >> 1;
if (mid >= a)
add_tree(lc[t], a, l, mid, c);
else
add_tree(rc[t], a, mid + 1, r, c);
siz[t] = siz[lc[t]] + siz[rc[t]];
}
long long query(int &t, int ll, int rr, int l, int r) {
if (!t) return 1e17;
if (ll <= l && r <= rr) return tree[t];
pushdown(t);
int mid = (l + r) >> 1;
if (mid < ll) return query(rc[t], ll, rr, mid + 1, r);
if (rr <= mid) return query(lc[t], ll, rr, l, mid);
return min(query(lc[t], ll, rr, l, mid), query(rc[t], ll, rr, mid + 1, r));
}
void merge(int &t, int &t2, int l, int r) {
if (!t2) return;
if (!t) t = new_node(), siz[t] = 1;
if (siz[t] < siz[t2]) swap(t, t2);
tree[t] = min(tree[t], tree[t2]);
if (l == r) return delte(t2), void();
int mid = (l + r) >> 1;
pushdown(t);
pushdown(t2);
merge(lc[t], lc[t2], l, mid);
merge(rc[t], rc[t2], mid + 1, r);
delte(t2);
siz[t] = siz[lc[t]] + siz[rc[t]];
}
void dfs(int u, int pre) {
dep[u] = dep[pre] + 1;
add_tree(root[u], dep[u], 1, n, 0);
for (int i = head[u]; i; i = e[i].link) {
if (e[i].to == pre) continue;
dfs(e[i].to, u);
long long tmp1 = query(root[u], 1, dep[u], 1, n),
tmp2 = query(root[e[i].to], 1, dep[u], 1, n);
if (root[u]) tree[root[u]] += tmp2, add[root[u]] += tmp2;
if (root[e[i].to]) tree[root[e[i].to]] += tmp1, add[root[e[i].to]] += tmp1;
merge(root[u], root[e[i].to], 1, n);
}
for (int i = 0; i < (signed)pos[u].size(); i++) {
long long tmp = query(root[u], 1, dep[u], 1, n);
add_tree(root[u], dep[pos[u][i].fa], 1, n, tmp + pos[u][i].w);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1, u, v; i < n; i++) scanf("%d %d", &u, &v), add_edge(u, v);
for (int i = 1, s, t, z; i <= m; i++)
scanf("%d %d %d", &s, &t, &z), pos[s].push_back((point){t, z});
dfs(1, 0);
long long tmp = query(root[1], 1, 1, 1, n);
printf("%lld\n", tmp >= 1e16 || tmp < 0 ? -1 : tmp);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a;
cin >> b;
long long ci = stoi(a) + stoi(b);
string c = to_string(ci);
string a1 = "", b1 = "", c1 = "";
for (int i = 0; i < a.length(); i++) {
if (a[i] != '0') {
a1 += a[i];
}
}
for (int i = 0; i < b.length(); i++) {
if (b[i] != '0') {
b1 += b[i];
}
}
for (int i = 0; i < c.length(); i++) {
if (c[i] != '0') {
c1 += c[i];
}
}
int c1i = stoi(a1) + stoi(b1);
if (c1i == stoi(c1))
cout << "YES\n";
else
cout << "NO\n";
}
| 1 |
#include<iostream>
#include<vector>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
#define INF (1e10)
int n,m,p,a,b;
int tic[8];
int di[30][30];
int main(){
double dp[1<<8][30];
while(cin>>n>>m>>p>>a>>b,n|m|p|a|b){
a--;b--;
for(int i=0;i<n;i++)cin>>tic[i];
memset(di,-1,sizeof(di));
for(int i=0;i<p;i++){
int x,y,z;
cin>>x>>y>>z;
x--;y--;
if(di[x][y]==-1 || z<di[x][y])
di[x][y]=di[y][x]=z;
}
double ans=INF;
for(int i=0;i<(1<<n);i++)
for(int j=0;j<m;j++)dp[i][j]=INF;
dp[(1<<n)-1][a]=0.0;
for(int i=(1<<n)-1;i>=0;i--){
for(int j=0;j<n;j++){
if((i&1<<j)==0)continue;
for(int k=0;k<m;k++){
for(int l=0;l<m;l++){
if(di[k][l]==-1)continue;
dp[i&~(1<<j)][l] = min(dp[i&~(1<<j)][l],dp[i][k]+(double)di[k][l]/tic[j]);
if(l==b)ans = min(ans, dp[i&~(1<<j)][l]);
}
}
}
}
if(ans==INF)puts("Impossible");
else printf("%.3f\n",ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
int n, m, len;
vector<int> L[1000010];
vector<int> vec[1000010];
vector<int> p[1000010];
int x[1000010], ans[1000010], c[1000010];
int Lowbit(int x) { return x & (-x); }
void Update(int pos, int val) {
while (pos <= 1000000) {
c[pos] += val;
pos += Lowbit(pos);
}
}
int Query(int pos) {
int ret = 0;
while (pos > 0) {
ret += c[pos];
pos -= Lowbit(pos);
}
return ret;
}
void Divide(int len, int idx) {
for (int i = 1; i < len; i++) {
if (x[i] + 1 >= x[i + 1]) continue;
vec[x[i + 1] - 1].push_back(x[i] + 1);
p[x[i + 1] - 1].push_back(idx);
}
}
int main() {
scanf("%d%d", &n, &m);
int a, b;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a, &b);
L[b].push_back(a);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b);
len = 0, x[++len] = 0;
for (int j = 1; j <= b; j++) {
scanf("%d", &a);
x[++len] = a;
}
x[++len] = 1000001;
Divide(len, i);
}
for (int i = 1; i <= m; i++) ans[i] = n;
int sum = 0;
for (int i = 1; i <= 1000000; i++) {
for (int j = 0; j < (int)L[i].size(); j++) {
Update(L[i][j], 1);
sum++;
}
int l, idx;
for (int j = 0; j < (int)vec[i].size(); j++) {
l = vec[i][j], idx = p[i][j];
ans[idx] -= sum - Query(l - 1);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
bitset<41> Adj[41];
int dp[(1 << 21)];
int main() {
int n, k;
int answer1 = 0;
cin >> n >> k;
if (n == 1) {
cout << "0"
<< "\n";
return 0;
}
for (int i = (int)(0); i <= (int)(n - 1); i++) {
for (int j = (int)(0); j <= (int)(n - 1); j++) {
int temp;
cin >> temp;
if (temp) {
Adj[i].set(j);
}
}
Adj[i].set(i);
}
int half = (n / 2);
for (int i = (int)(0); i <= (int)((1 << half) - 1); i++) {
bitset<41> ans;
ans.set();
for (int j = (int)(0); j <= (int)(half - 1); j++) {
if (i & (1 << j)) {
ans = ans & Adj[j];
dp[i] = max(dp[i], dp[i ^ (1 << j)]);
}
}
bool isComplete = true;
for (int j = (int)(0); j <= (int)(half - 1); j++) {
if (i & (1 << j)) {
if (!ans[j]) {
isComplete = false;
break;
}
}
}
if (isComplete) {
dp[i] = __builtin_popcount(i);
}
}
int remain = n - half;
int base1 = half;
for (int i = (int)(0); i <= (int)((1 << remain) - 1); i++) {
bitset<41> ans;
ans.set();
for (int j = (int)(0); j <= (int)(remain - 1); j++) {
if (i & (1 << j)) {
ans = ans & Adj[j + base1];
}
}
bool isComplete = true;
for (int j = (int)(0); j <= (int)(remain); j++) {
if (i & (1 << j)) {
if (!ans[j + base1]) {
isComplete = false;
break;
}
}
}
if (isComplete) {
int mask1 = 0;
for (int j = (int)(0); j <= (int)(half - 1); j++) {
if (ans[j]) {
mask1 += (1 << j);
}
}
answer1 = max(answer1, dp[mask1] + __builtin_popcount(i));
}
}
double maxSize = answer1;
double fac = 1.0 * k / (maxSize);
maxSize = fac * fac * maxSize * (maxSize - 1) / 2.0;
cout << fixed << setprecision(10) << maxSize << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
bool a[N][N];
vector<array<pair<int, int>, 3> > ans;
void apply(int x, int y, int op) {
a[x][y] ^= 1;
switch (op) {
case 1:
a[x - 1][y] ^= 1;
a[x][y - 1] ^= 1;
ans.push_back({pair<int, int>{x, y}, pair<int, int>{x - 1, y},
pair<int, int>{x, y - 1}});
break;
case 2:
a[x - 1][y] ^= 1;
a[x][y + 1] ^= 1;
ans.push_back({pair<int, int>{x, y}, pair<int, int>{x - 1, y},
pair<int, int>{x, y + 1}});
break;
case 3:
a[x + 1][y] ^= 1;
a[x][y + 1] ^= 1;
ans.push_back({pair<int, int>{x, y}, pair<int, int>{x + 1, y},
pair<int, int>{x, y + 1}});
break;
case 4:
a[x + 1][y] ^= 1;
a[x][y - 1] ^= 1;
ans.push_back({pair<int, int>{x, y}, pair<int, int>{x + 1, y},
pair<int, int>{x, y - 1}});
break;
}
}
void show(int n, int m) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) printf("%d%c", a[i][j], " \n"[j == m]);
}
void check(int n, int m) {
bool ok = true;
for (int i = 1; i <= n && ok; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j]) {
ok = false;
break;
}
if (!ok) {
show(n, m);
puts("INVALID");
}
if ((int)ans.size() > n * m) {
puts("OUT OF TIMES");
}
}
void solve_rows(int n, int m) {
for (int i = 1; i <= n - 2; ++i) {
for (int j = 1; j <= m; ++j) {
if (!a[i][j]) continue;
if (j == 1) {
apply(i + 1, j, 2);
continue;
}
if (j == m) {
apply(i + 1, j, 1);
continue;
}
if (a[i + 1][j - 1])
apply(i + 1, j, 1);
else
apply(i + 1, j, 2);
}
if (0) {
printf("solved row %d:\n", i);
show(n, m);
};
}
}
void solve_last_two_rows(int n, int m) {
for (int j = 1; j <= m - 2; ++j) {
switch (a[n - 1][j] * 2 + a[n][j]) {
case 0:
break;
case 1:
apply(n, j + 1, 1);
break;
case 2:
apply(n - 1, j + 1, 4);
break;
case 3:
if (a[n - 1][j + 1])
apply(n - 1, j, 3);
else
apply(n, j, 2);
break;
}
}
}
void solve_square(int x, int y) {
bool &A = a[x][y], &B = a[x][y + 1], &C = a[x + 1][y + 1], &D = a[x + 1][y];
while (true) {
int cnt = A + B + C + D;
switch (cnt) {
case 0:
return;
case 1:
if (A == 1)
apply(x, y, 3);
else if (B == 1)
apply(x, y + 1, 4);
else if (C == 1)
apply(x + 1, y + 1, 1);
else if (D == 1)
apply(x + 1, y, 2);
break;
case 2:
if (A == 1)
apply(x + 1, y + 1, 1);
else if (B == 1)
apply(x + 1, y, 2);
else if (C == 1)
apply(x, y, 3);
else if (D == 1)
apply(x, y + 1, 4);
break;
case 3:
if (A == 0)
apply(x + 1, y + 1, 1);
else if (B == 0)
apply(x + 1, y, 2);
else if (C == 0)
apply(x, y, 3);
else if (D == 0)
apply(x, y + 1, 4);
break;
case 4:
apply(x, y, 3);
break;
}
}
}
int main() {
int T, n, m;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
char ch = getchar();
for (; ch != '0' && ch != '1'; ch = getchar())
;
a[i][j] = ch == '1';
}
ans.clear();
solve_rows(n, m);
solve_last_two_rows(n, m);
solve_square(n - 1, m - 1);
check(n, m);
printf("%zu\n", ans.size());
for (auto x : ans) {
for (int i = 0; i < 3; ++i)
printf("%d %d%c", x[i].first, x[i].second, " \n"[i == 2]);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline int read() {
register int x = 0;
register int y = 1;
register char c = std::getchar();
while (c < '0' || c > '9') {
if (c == '-') y = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + (c ^ 48);
c = getchar();
}
return y ? x : -x;
}
int n, m;
char a[5006], b[5006];
int f[5006][5006];
int main() {
n = read();
m = read();
scanf("%s%s", a + 1, b + 1);
int ans = 0;
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= m; j++) {
if (a[i] == b[j])
f[i][j] = f[i - 1][j - 1] + 2;
else
f[i][j] = std::max(0, std::max(f[i - 1][j], f[i][j - 1]) - 1);
ans = std::max(ans, f[i][j]);
}
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void PLAY() {
cout << fixed << setprecision(10);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int MOD = 1e9 + 7;
long long poww(long long b, long long p) {
if (p == 0) return 1;
long long sq = poww(b, p / 2);
sq = (sq * sq) % MOD;
if (p % 2 == 1) {
sq = (sq * b) % MOD;
}
return sq;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b, c;
cin >> a >> b >> c;
long long ra = a / 3;
long long rb = b / 2;
long long rc = c / 2;
long long mini = min(ra, min(rb, rc));
long long ans = 0;
a -= (mini * 3);
b -= (mini * 2);
c -= (mini * 2);
ans += (mini * 7);
if (a == 1 && c == 1) {
ans += (1 + min(b, 1 * 1ll) + 1);
} else if (a == 0) {
ans += (min(b, 1 * 1ll) + min(c, 1 * 1ll));
} else if (b == 0) {
ans += max(2 * 1ll, (min(a, 1 * 1ll) + min(c, 2 * 1ll)));
} else if (c == 0) {
if (a >= 2)
ans += (min(a, 2 * 1ll) + min(b, 2 * 1ll));
else
ans += (min(a, 2 * 1ll) + min(b, 1 * 1ll));
} else {
ans += (min(a, 3 * 1ll) + min(b, 2 * 1ll) + min(c, 2 * 1ll));
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> f;
int main() {
long long n;
scanf("%lld", &n);
while (n--) {
long long x, v;
scanf("%lld", &x);
scanf("%lld", &v);
f[x] = max(f[x], v);
}
long long m;
scanf("%lld", &m);
while (m--) {
long long x, v;
scanf("%lld", &x);
scanf("%lld", &v);
f[x] = max(f[x], v);
}
long long ans = 0;
for (map<long long, long long>::iterator it = f.begin(); it != f.end();
it++) {
ans += (*it).second;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long base = 10000007;
long long large = 1000000000000000000LL;
class AC {
public:
int sz;
vector<int> val, f, last;
vector<vector<int> > ch;
int sigma_size;
int rb;
AC(int maxnode, int _sigma_size) {
sz = 1;
rb = 0;
ch.assign(maxnode, vector<int>(_sigma_size, -1));
val.assign(maxnode, 0);
f.assign(maxnode, 0);
last.assign(maxnode, 0);
sigma_size = _sigma_size;
}
int idx(char c) { return c - 'a'; }
void insert(string s, int v) {
int u = 0, n = (int)s.length();
for (int i = 0; i < n; i++) {
int c = idx(s[i]);
if (ch[u][c] == -1) {
val[sz] = 0;
ch[u][c] = sz++;
}
u = ch[u][c];
}
val[u] = v;
}
bool search(string s, int v) {
int u = 0, n = (int)s.length();
for (int i = 0; i < n; i++) {
int c = idx(s[i]);
if (ch[u][c] == -1) {
return false;
}
u = ch[u][c];
}
if (val[u] != v) return false;
return true;
}
void getFail() {
queue<int> q;
f[0] = 0;
for (int c = 0; c < sigma_size; c++) {
int u = ch[0][c];
if (u != -1) {
f[u] = 0;
q.push(u);
last[u] = 0;
}
}
while (!q.empty()) {
int r = q.front();
q.pop();
for (int c = 0; c < sigma_size; c++) {
int u = ch[r][c];
if (u == -1) continue;
q.push(u);
int v = f[r];
while (v && ch[v][c] == -1) v = f[v];
f[u] = ch[v][c];
if (f[u] == -1) f[u] = 0;
last[u] = val[f[u]] ? f[u] : last[f[u]];
}
}
}
void find(string t) {
int n = (int)t.length();
int j = 0;
for (int i = 0; i < n; i++) {
int c = idx(t[i]);
while (j && ch[j][c] == -1) j = f[j];
j = ch[j][c];
if (j == -1) j = 0;
if (val[j]) {
print(i, j);
} else {
if (last[j]) {
print(i, last[j]);
}
}
}
}
void print(int i, int j) {
if (j) {
printf("%d: %d\n", i, val[j]);
print(i, last[j]);
}
}
void clear() {
sz = 1;
ch.clear();
val.clear();
f.clear();
last.clear();
}
void assign(int x, int y) {
sz = 1;
ch.assign(x + 10, vector<int>(y + 10, -1));
val.assign(x + 10, 0);
f.assign(x + 10, 0);
last.assign(x + 10, 0);
}
void dfs(int u) {
val[u] = rb++;
for (int j = 0; j < 26; j++) {
if (ch[u][j] != -1) {
dfs(ch[u][j]);
}
}
}
void search(string &s, vector<int> &p) {
int u = 0, n = (int)s.length();
for (int i = 0; i < n; i++) {
int c = idx(s[i]);
if (ch[u][c] == -1) {
return;
}
u = ch[u][c];
p.push_back(val[u]);
}
}
};
vector<vector<int> > adj;
vector<vector<int> > dp;
vector<bool> vis;
void f(int u, int pa) {
vis[u] = true;
dp[u][0] = 0;
dp[u][1] = 1;
for (int j = 0; j < (int)adj[u].size(); j++) {
int v = adj[u][j];
if (v != pa) {
f(v, u);
dp[u][0] += max(dp[v][0], dp[v][1]);
dp[u][1] += dp[v][0];
}
}
return;
}
int main() {
int totalcase;
cin >> totalcase;
while (totalcase--) {
int n;
cin >> n;
int acc = 0;
vector<string> w;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
w.push_back(t);
acc += (int)t.size();
}
AC ac(acc + 10, 26);
for (int i = 0; i < n; i++) {
ac.insert(w[i], 1);
}
ac.dfs(0);
adj.assign(ac.rb - 1, vector<int>(0, 0));
for (int i = 0; i < n; i++) {
vector<int> p1, p2;
ac.search(w[i], p1);
string s = w[i].substr(1, w[i].length());
ac.search(s, p2);
for (int i = 0; i < (int)p2.size(); i++) {
int v1 = p1[i + 1];
int v2 = p2[i];
v1--;
v2--;
adj[v1].push_back(v2);
adj[v2].push_back(v1);
}
}
for (int i = 0; i < ac.rb - 1; i++) {
sort(adj[i].begin(), adj[i].end());
adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());
}
vis.assign(ac.rb - 1, false);
dp.assign(ac.rb - 1, vector<int>(2, 0));
int ans = 0;
for (int i = 0; i < ac.rb - 1; i++) {
if (!vis[i]) {
f(i, -1);
ans += max(dp[i][0], dp[i][1]);
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;cin>>n;
cout<<"Christmas";
for (int i=0;i<25-n;i++)cout<<" Eve";
} | 0 |
#include <bits/stdc++.h>
const long double pi = 3.141592654;
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, -1, 1};
bool vis[1000000];
vector<int> vec;
const long long N = 1e5 + 5, inf = 2e9, mod = 1e10 + 7;
long long fact[1000006], inv[1000006];
vector<vector<int>> graph;
bool valid(int r, int c) { return (r >= 0 && c >= 0 && r < 8 && c < 8); }
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
void move1step(long long& a, long long& b, long long q) {
long long c = a - b * q;
a = b;
b = c;
}
long long egcd(long long r0, long long r1, long long& x0, long long& y0) {
x0 = 1;
y0 = 0;
long long x1 = 0, y1 = 1;
while (r1) {
long long q = r0 / r1;
move1step(r0, r1, q);
move1step(x0, x1, q);
move1step(y0, y1, q);
}
return r0;
}
bool solve(long long a, long long b, long long c, long long& x, long long& y) {
long long g = egcd(a, b, x, y);
long long m = c / g;
y *= m;
x *= m;
return (c % g == 0);
}
long long fp(unsigned long long base, unsigned long long exp) {
if (exp == 0) return 1;
unsigned long long ans = fp(base, exp / 2);
ans = (ans * ans) % mod;
if (exp % 2 != 0) ans = (ans * (base % mod)) % mod;
return ans;
}
void calcFacAndInv(long long n) {
fact[0] = inv[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = (i * fact[i - 1]) % mod;
inv[i] = fp(fact[i], mod - 2);
}
}
long long ncr(long long n, long long r) {
return ((fact[n] * inv[r]) % mod * inv[n - r]) % mod;
}
long long npr(long long n, long long r) { return (fact[n] * inv[n - r]) % mod; }
vector<pair<long long, long long>> primeF(long long n) {
vector<pair<long long, long long>> v;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
v.push_back({i, 0});
while (n % i == 0) {
v.back().second++;
n /= i;
}
}
}
if (n > 1) {
v.push_back({n, 1});
}
return v;
}
set<long long> st1, st2;
vector<pair<long long, long long>> v1, v2;
void getDivisors1(int ind = 0, long long res = 1) {
if (ind == (int)v1.size()) {
st1.insert(res);
return;
}
for (long long i = 0; i <= v1[ind].second; i++) {
getDivisors1(ind + 1, res);
res = ((res % mod) * (v1[ind].first % mod)) % mod;
}
}
void getDivisors2(int ind = 0, long long res = 1) {
if (ind == (int)v2.size()) {
st2.insert(res);
return;
}
for (long long i = 0; i <= v2[ind].second; i++) {
getDivisors2(ind + 1, res);
res = ((res % mod) * (v2[ind].first % mod)) % mod;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
v1 = primeF(a);
v2 = primeF(b);
sort(v1.rbegin(), v1.rend());
sort(v2.rbegin(), v2.rend());
getDivisors1();
getDivisors2();
int n;
cin >> n;
long long l, h, max;
set<long long, long long>::reverse_iterator it;
set<long long, long long>::reverse_iterator it1;
vector<long long> v;
for (it = st1.rbegin(); it != st1.rend(); it++) {
for (it1 = st2.rbegin(); it1 != st2.rend(); it1++) {
if (*it == *it1) {
v.push_back(*it);
}
}
}
sort(v.rbegin(), v.rend());
while (n--) {
cin >> l >> h;
max = -1;
for (auto it : v) {
if (it <= h && it >= l) {
max = it;
break;
}
}
if (max != -1)
cout << max << "\n";
else
cout << -1 << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 12;
int g[N][N];
int dis[N][N];
void floyd(int n) {
memcpy(dis, g, sizeof g);
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> g[i][j];
}
}
floyd(n);
int ret = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ret = max(ret, dis[i][j]);
}
}
cout << ret << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
long long kek;
bool acum;
time_t bg, nd;
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
bg = clock();
realMain();
}
const long long N = (long long)4e5 + 7;
const long long INF = (long long)1e18;
long long n, c, s[N], pre[N], sol[N], p = 0, best = -INF;
deque<long long> dq;
long long eval(long long j) { return sol[j - 1] - pre[2 * j - 2]; }
signed realMain() {
cin >> n >> c;
for (long long i = 1; i <= 2 * n - 1; i++) {
cin >> s[i];
pre[i] = pre[i - 1] + s[i];
}
for (long long i = 1; i <= n; i++) {
while (p + 1 <= i && pre[2 * i - 1] - pre[2 * (p + 1) - 2] >= c) {
p++;
best = max(best, sol[p - 1]);
}
while (!dq.empty() && dq.front() <= p) {
dq.pop_front();
}
while (!dq.empty() && eval(i) > eval(dq.back())) {
dq.pop_back();
}
dq.push_back(i);
long long kek = -INF, val = 0;
val = max(val, best + c - sol[i - 1]);
kek = -INF;
if (p + 1 <= i) {
kek = eval(dq.front());
}
val = max(val, kek + pre[2 * i - 1] - sol[i - 1]);
sol[i] = sol[i - 1] + val;
}
cout << sol[n] << "\n";
return 0;
}
| 6 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
int a1=0,a2=0;
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++){
int a,b;
scanf("%d%d",&a,&b);
if(a>a1)
a1=a,a2=b;
}
printf("%d",a1+a2);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
cout << 1440 - ((a * 60) + b) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a = 1, b = 1;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
a *= 2;
a %= 1000000009;
}
a = (a + 1000000009 - 1) % 1000000009;
for (int i = 0; i < n; i++) {
b *= (a - i);
b %= 1000000009;
if (b == 0) break;
}
cout << b << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 50;
const int INF = 1 << 30;
struct item {
int a, b;
int cnt;
};
bool cmp(const item& a1, const item& a2) { return a1.cnt < a2.cnt; }
item itm[200050];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &itm[i].a);
for (int i = 0; i < n; i++) {
scanf("%d", &itm[i].b);
itm[i].cnt = itm[i].a - itm[i].b;
}
sort(itm, itm + n, cmp);
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i >= k && itm[i].cnt > 0) {
ans += itm[i].b;
} else {
ans += itm[i].a;
}
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int &i : a) cin >> i;
map<int, int> last;
vector<int> prev(n);
vector<int> w(n);
for (int i = 0; i < n; i++) {
auto it = last.find(a[i] - 1);
if (it != last.end()) {
prev[i] = it->second;
w[i] = w[it->second] + 1;
} else {
prev[i] = -1;
w[i] = 1;
}
last[a[i]] = i;
}
int it = max_element(w.begin(), w.end()) - w.begin();
vector<int> ans;
while (it >= 0) {
ans.push_back(it);
it = prev[it];
}
reverse(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int i : ans) cout << i + 1 << " ";
cout << '\n';
exit(0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long b;
vector<int> a;
for (int j = 0; j < 4; j++) {
cin >> b;
a.push_back(b);
}
sort(a.begin(), a.end());
if ((a[0] + a[3]) == (a[2] + a[1])) {
cout << "YES";
} else if (a[3] == a[0] + a[1] + a[2]) {
cout << "YES";
} else {
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, n = 0, p;
cin >> t;
while (t--) {
cin >> a;
while (a) {
if (a & 1) {
n++;
a /= 2;
} else
a /= 2;
}
p = pow(2.0, n);
cout << p << endl;
n = 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 3.3e7;
int prm[M], tot;
void init(int n) {
for (int i = 2; i <= n; i++) {
if (!prm[i]) prm[++tot] = i;
for (int j = 1; j <= tot && i * prm[j] <= n; ++j) {
prm[i * prm[j]] = true;
if (i % prm[j] == 0) break;
}
}
}
struct Query {
long long n, k;
int id;
bool operator<(const Query& A) const { return k < A.k; }
} Q[N];
bool ans[N];
int m;
long long fac[N];
void exgcd(long long a, long long b, long long& x, long long& y) {
if (!b)
assert(a == 1), x = 1, y = 0;
else {
exgcd(b, a % b, y, x);
y -= a / b * x;
}
}
void work(long long a, long long b, int l, int r) {
long long x, y;
exgcd(a, b, x, y);
y = (y % a + a) % a;
for (int i = l; i <= r; i++) {
long long val = (y * (Q[i].n % a)) % a * b;
ans[Q[i].id] = val <= Q[i].n;
}
}
bool vis[N];
long long dis[N];
struct Node {
int o;
long long d;
bool operator<(const Node& B) const { return d > B.d; }
};
void Dijkstra() {
int n = fac[1];
for (int i = 0; i <= n; i++) dis[i] = 1ll << 60, vis[i] = 0;
dis[0] = 0;
priority_queue<Node> q;
q.push((Node){0, 0});
while (!q.empty()) {
int o = q.top().o;
q.pop();
if (vis[o]) continue;
vis[o] = true;
for (int i = 2; i <= m; i++) {
long long d = dis[o] + (o + fac[i]) / n;
int u = (o + fac[i]) % n;
if (dis[u] > d) dis[u] = d, q.push((Node){u, d});
}
}
}
int main() {
init(M - 5);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++)
scanf("%I64d%I64d", &Q[i].n, &Q[i].k), Q[i].id = i;
sort(Q + 1, Q + q + 1);
for (int i = 1; i <= q; i++) {
long long x = Q[i].k;
int r = i;
while (r < q && Q[r + 1].k == x) ++r;
m = 0;
for (int j = 1; j <= tot; j++)
if (x % prm[j] == 0) {
fac[++m] = prm[j];
while (x % prm[j] == 0) x /= prm[j];
}
if (x > 1) fac[++m] = x;
if (m == 0)
for (int j = i; j <= r; j++) ans[Q[j].id] = false;
else if (m == 1)
for (int j = i; j <= r; j++) ans[Q[j].id] = Q[j].n % fac[1] == 0;
else if (m == 2)
work(fac[1], fac[2], i, r);
else {
Dijkstra();
for (int j = i; j <= r; j++)
ans[Q[j].id] = dis[Q[j].n % fac[1]] <= Q[j].n / fac[1];
}
i = r;
}
for (int i = 1; i <= q; i++) puts(ans[i] ? "YES" : "NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300111;
int x[MAXN], y[MAXN];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
}
int k = -1;
int sum = 0;
for (int i = 0; i < n; i++) {
sum += x[i];
if (k < 0 || y[i] > y[k]) k = i;
}
for (int i = 0; i < n; i++) {
int X = sum - x[i];
int Y = y[k];
if (i == k) {
int k2 = -1;
for (int j = 0; j < n; j++)
if (j != i && (k2 < 0 || y[j] > y[k2])) k2 = j;
Y = y[k2];
}
if (i > 0) printf(" ");
printf("%d", X * Y);
}
printf("\n");
return 0;
}
| 2 |
#include<cstdio>
#include<cstring>
static const int MAX_T = 100000;
int N, T;
int t[MAX_T + 1];
int main(){
memset(t, 0, sizeof(t));
int l, r;
scanf("%d %d", &N, &T);
for(int i = 1; i <= N; i++){
scanf("%d %d", &l, &r);
t[l]++; t[r]--;
}
int num = 0, max_num = 0;
for(int i = 0; i < T; i++){
num += t[i];
if(num > max_num) max_num = num;
}
printf("%d\n", max_num);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
template <class T>
bool INRANGE(T x, T a, T b) {
return a <= x && x <= b;
}
template <class T>
void amin(T &a, T v) {
if (a > v) a = v;
}
template <class T>
void amax(T &a, T v) {
if (a < v) a = v;
}
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
int main() {
int n, k;
scanf("%d %d ", &n, &k);
vector<int> s(n);
for (int i = 0; i < n; ++i) {
scanf("%d ", &s[i]);
}
long long lo = 0;
long long hi = 1e10;
{
while (lo < hi) {
long long mid = lo + (hi - lo) / 2LL;
vector<int> pack0(k);
vector<int> pack1(k, (-1));
int id0 = 0;
int id1 = k - 1;
bool ok = true;
if (s[n - 1] > mid) {
ok = false;
} else {
for (int i = n - 1; i >= 0; --i) {
if (id0 < k && s[i] <= mid) {
pack0[id0] = s[i];
id0++;
} else {
bool ireta = false;
while (id1 >= 0) {
if (pack1[id1] == (-1) && pack0[id1] != (-1) &&
pack0[id1] + s[i] <= mid) {
pack1[id1] = s[i];
ireta = true;
break;
}
id1--;
}
if (!ireta) {
ok = false;
break;
}
}
}
}
if (ok) {
hi = mid;
} else {
lo = mid + 1;
}
}
}
cout << lo << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int v1, v2;
int x, y;
} s[3 * 1005];
int father[3000];
int n, m;
int vist[1005], flg1, flg2, ans, xx, yy;
int cmp(const node a, const node b) {
if (a.y > b.y)
return 1;
else
return 0;
}
int find(int x) {
int root, i = x;
while (x != father[x]) x = father[x];
root = x;
x = i;
while (x != father[x]) {
i = father[x];
father[x] = root;
x = i;
}
return root;
}
int main() {
while (scanf("%d%d", &n, &m) > 0) {
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &s[i].v1, &s[i].v2, &s[i].x, &s[i].y);
}
sort(s, s + m, cmp);
ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= n; j++) father[j] = j;
for (int j = 0; j < m; j++) {
if (s[i].x > s[j].y) continue;
if (s[i].y < s[j].x) continue;
if (s[j].x > s[i].x) continue;
int s1 = find(s[j].v1);
int s2 = find(s[j].v2);
if (s1 != s2) {
father[s1] = s2;
}
if (find(1) == find(n)) {
if (ans < s[j].y - s[i].x + 1) ans = s[j].y - s[i].x + 1;
break;
}
}
}
if (ans == 0)
printf("Nice work, Dima!\n");
else
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lol = long long int;
const lol N = 1e6 + 5;
const lol modcon = 1e9 + 7, mod = 998244353;
const double eps = 1e-7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, w;
cin >> h >> w;
vector<int> r(h);
vector<int> c(w);
vector<vector<bool> > gr(h, vector<bool>(w, 0));
for (int i = 0; i < h; i++) {
cin >> r[i];
for (int j = 0; j < r[i]; j++) {
gr[i][j] = 1;
}
}
for (int i = 0; i < w; i++) {
cin >> c[i];
for (int j = 0; j < c[i]; j++) {
gr[j][i] = 1;
}
}
for (int i = 0; i < h; i++) {
int cnt = 0;
for (int j = 0; j < w; j++) {
if (gr[i][j] == 0) {
break;
}
cnt++;
}
if (cnt != r[i]) {
cout << "0";
return 0;
}
}
for (int i = 0; i < w; i++) {
int cnt = 0;
for (int j = 0; j < h; j++) {
if (gr[j][i] == 0) {
break;
}
cnt++;
}
if (cnt != c[i]) {
cout << "0";
return 0;
}
}
lol ans = 1;
for (int i = 1; i < h; i++) {
for (int j = r[i] + 1; j < w; j++) {
if (gr[i][j] == 0) {
if (i >= c[j] + 1) {
ans = (2 * ans) % modcon;
}
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int M = 1 << 13;
struct FLIP {
int x, y, z;
FLIP(int _x = 0, int _y = 0, int _z = 0) {
x = _x;
y = _y;
z = _z;
}
};
int a[N], n, p[M];
FLIP op[M];
vector<FLIP> flp;
void flip(int x, int y, int z) {
a[x] ^= 1;
a[y] ^= 1;
a[z] ^= 1;
flp.push_back(FLIP(x, y, z));
}
void go(int x) {
if (x == 7)
flip(n - 2, n - 1, n);
else if (x == 5)
flip(n - 4, n - 2, n);
else if (x == 6)
flip(n - 3, n - 2, n - 1);
else if (x == 1)
flip(n - 6, n - 3, n);
else if (x == 2)
flip(n - 5, n - 3, n - 1);
else if (x == 4)
flip(n - 4, n - 3, n - 2);
}
void work(int x) {
if (x == 7)
flip(n - 5, n - 3, n - 1), flip(n - 8, n - 4, n);
else if (x == 6)
flip(n - 9, n - 5, n - 1), flip(n - 8, n - 4, n);
else if (x == 5)
flip(n - 9, n - 5, n - 1), flip(n - 6, n - 3, n);
else if (x == 3)
flip(n - 4, n - 3, n - 2), flip(n - 2, n - 1, n);
else if (x == 1)
flip(n - 5, n - 3, n - 1), flip(n - 10, n - 5, n);
else if (x == 2)
flip(n - 6, n - 4, n - 2), flip(n - 2, n - 1, n);
else if (x == 4)
flip(n - 8, n - 5, n - 2), flip(n - 2, n - 1, n);
else
flip(n - 10, n - 6, n - 2), flip(n - 2, n - 1, n);
}
bool bfs(int s) {
memset(p, -1, sizeof(p));
p[s] = 0;
queue<int> Q;
Q.push(s);
int x, y;
while (!Q.empty()) {
x = Q.front();
Q.pop();
if (x == 0) break;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int k = j + 1; k < n; ++k) {
if (k - j != j - i) continue;
y = x ^ (1 << i) ^ (1 << j) ^ (1 << k);
if (~p[y]) continue;
p[y] = x;
Q.push(y);
op[y] = FLIP(n - k, n - j, n - i);
}
}
}
}
if (p[0] == -1) return false;
while (x != s) {
flp.push_back(op[x]);
x = p[x];
}
return true;
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
while (n >= 14) {
x = 0;
for (int i = 0; i < 3; ++i) x ^= a[n - i] << i;
if (x == 3) {
y = 0;
for (int i = 0; i < 3; ++i) y ^= a[n - 3 - i] << i;
work(y);
n -= 3;
} else
go(x);
n -= 3;
}
x = 0;
for (int i = 0; i < n; ++i) x ^= a[n - i] << i;
if (bfs(x)) {
printf("YES\n");
printf("%d\n", (int)flp.size());
for (auto p : flp) printf("%d %d %d\n", p.x, p.y, p.z);
} else
printf("NO\n");
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
int n, l[30], m[30], w[30];
int tw[30], P1, P2;
map<pair<long long, long long>, pair<long long, long long> > mp;
long long best = -(1ll << 58), msk1, msk2;
void rec(int p, int msk, long long L, long long M, long long W) {
if (p == P1) {
pair<long long, long long> tmp = make_pair(L - M, L - W);
if (mp.find(tmp) == mp.end())
mp[tmp] = make_pair(L, msk);
else if (mp[tmp].first < L) {
mp[tmp] = make_pair(L, msk);
}
return;
}
rec(p + 1, msk * 3, L, M + m[p], W + w[p]);
rec(p + 1, msk * 3 + 1, L + l[p], M, W + w[p]);
rec(p + 1, msk * 3 + 2, L + l[p], M + m[p], W);
}
void rec2(int p, int msk, long long L, long long M, long long W) {
if (p == n) {
pair<long long, long long> tmp = make_pair(-(L - M), -(L - W));
if (mp.find(tmp) == mp.end()) return;
pair<long long, long long> tmp2 = mp[tmp];
long long sum = L + tmp2.first;
if (sum < best) return;
best = sum;
msk1 = tmp2.second;
msk2 = msk;
return;
}
rec2(p + 1, msk * 3, L, M + m[p], W + w[p]);
rec2(p + 1, msk * 3 + 1, L + l[p], M, W + w[p]);
rec2(p + 1, msk * 3 + 2, L + l[p], M + m[p], W);
}
void print(int x, int msk) {
if (x == 0) return;
print(x - 1, msk / 3);
if (msk % 3 == 0)
printf("MW\n");
else if (msk % 3 == 1)
printf("LW\n");
else
printf("LM\n");
}
int main() {
for (int i = 0; i < 30; i++) tw[i] = 1 << i;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &l[i], &m[i], &w[i]);
}
P1 = n / 2, P2 = n - P1;
rec(0, 0, 0, 0, 0);
rec2(P1, 0, 0, 0, 0);
if (best == -(1ll << 58))
printf("Impossible\n");
else {
print(P1, msk1);
print(P2, msk2);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& o, pair<A, B> a) {
return o << a.first << ' ' << a.second;
}
template <typename A, typename B>
istream& operator>>(istream& o, pair<A, B>& a) {
return o >> a.first >> a.second;
}
const int mod = 998244353, abc = 864197532, N = 200005, K = 111;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
string s;
cin >> n >> k >> s;
vector<int> v[26];
for (int i = 0; i < n; ++i) v[s[i] - 'a'].push_back(i);
for (int i = 0; i < 26; ++i) {
reverse(v[i].begin(), v[i].end());
while (k && !v[i].empty()) {
v[i].pop_back();
k--;
}
}
vector<pair<int, char>> ans;
for (int i = 0; i < 26; ++i) {
while (!v[i].empty()) ans.emplace_back(v[i].back(), i), v[i].pop_back();
}
sort(ans.begin(), ans.end());
for (auto a : ans) cout << char(a.second + 'a');
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
long long int a, b, c;
while (q--) {
cin >> a >> b >> c;
cout << (a + b + c) / 2 << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a,b,c;
cin >> a >> b >> c ;
if ((c-a-b)*(c-a-b)>4*a*b && c-a-b>0) {cout << "Yes" << endl;}
else {cout <<"No" << endl;}
} | 0 |
#include <bits/stdc++.h>
int n, s[200010], p;
long long k, w[200010], g[200010], a[200010], b[200010], c[200010], d[200010];
long long inf = 0x3f3f3f3f3f3f3f3fll;
struct node {
long long x, lz, d;
} tr[800010];
int ans[200010];
void build(int x = 1, int l = 1, int r = n) {
tr[x].x = -inf;
if (l == r) return;
build(x << 1, l, (l + r) >> 1);
build(x << 1 | 1, ((l + r) >> 1) + 1, r);
}
void pushup(int x, int ls, int rs) {
tr[x].x = std::max(tr[ls].x, tr[rs].x);
tr[x].d = std::max(tr[ls].d, tr[rs].d);
}
void addtag(int x, long long lz) {
tr[x].lz += lz;
tr[x].x += lz;
}
void pushdown(int x, int ls, int rs) {
if (tr[x].lz) addtag(ls, tr[x].lz), addtag(rs, tr[x].lz), tr[x].lz = 0;
}
void setx(int p, long long k, int x = 1, int l = 1, int r = n) {
if (l == r) return tr[x].x = tr[x].d = k, void();
int mid = (l + r) >> 1, ls = x << 1, rs = x << 1 | 1;
pushdown(x, ls, rs);
if (p <= mid)
setx(p, k, ls, l, mid);
else
setx(p, k, rs, mid + 1, r);
pushup(x, ls, rs);
}
void add(int pl, int pr, long long k, int x = 1, int l = 1, int r = n) {
if (l == pl && r == pr) return addtag(x, k);
int mid = (l + r) >> 1, ls = x << 1, rs = x << 1 | 1;
pushdown(x, ls, rs);
if (pr <= mid)
add(pl, pr, k, ls, l, mid);
else if (pl > mid)
add(pl, pr, k, rs, mid + 1, r);
else
add(pl, mid, k, ls, l, mid), add(mid + 1, pr, k, rs, mid + 1, r);
pushup(x, ls, rs);
}
int ask(int pl, int pr, long long p, int x = 1, int l = 1, int r = n) {
if (l == r) return l;
int mid = (l + r) >> 1, ls = x << 1, rs = x << 1 | 1;
pushdown(x, ls, rs);
if (mid < pl) return ask(pl, pr, p, rs, mid + 1, r);
if (pr <= mid) return ask(pl, pr, p, ls, l, mid);
if (tr[rs].d + k >= std::max(p, tr[ls].x))
return ask(pl, pr, std::max(p, tr[ls].x), rs, mid + 1, r);
return ask(pl, pr, p, ls, l, mid);
}
void dfs(int x = 1, int l = 1, int r = n) {
printf("%lld %lld %lld %d~%d\n", tr[x].x, tr[x].lz, tr[x].d, l, r);
if (l == r) return;
int mid = (l + r) >> 1, ls = x << 1, rs = x << 1 | 1;
dfs(ls, l, mid), dfs(rs, mid + 1, r);
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i < n; i++) scanf("%lld", w + i);
for (int i = 1; i <= n; i++) scanf("%lld", g + i);
for (int i = 1; i < n; i++) a[i] = a[i - 1] + w[i];
for (int i = 1; i <= n; i++) b[i] = b[i - 1] + g[i];
for (int i = 1; i <= n; i++) c[i] = a[i - 1] - b[i - 1];
for (int i = 1; i <= n; i++) d[i] = b[i] - a[i - 1];
build();
for (int i = n; i; i--) {
while (p && c[i] >= c[s[p]]) {
if (p > 1) add(s[p - 1] - 1, n, c[s[p]] - c[s[p - 1]]);
--p;
}
s[++p] = i, setx(i, d[i]);
if (p > 1) add(s[p - 1] - 1, n, c[s[p - 1]] - c[i]);
int l = 1, r = p;
while (l < r) {
int mid = (l + r) >> 1;
if (c[s[mid]] - c[i] <= k)
r = mid;
else
l = mid + 1;
}
r = r == 1 ? n : s[r - 1] - 1;
ans[i] = ask(i, r, -inf);
}
int res = 0;
for (int i = 1; i <= n; i++) res = std::max(res, ans[i] - i + 1);
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int vis[50][50], n;
vector<pair<int, int>> pieces;
string grid[50], ans[100];
bool check(int dx, int dy) {
for (int i = 0; i < pieces.size(); i++) {
if (pieces[i].first + dy >= n || pieces[i].first + dy < 0 ||
pieces[i].second + dx >= n || pieces[i].second + dx < 0)
continue;
if (grid[pieces[i].first + dy][pieces[i].second + dx] == '.') {
return false;
}
}
for (int i = 0; i < pieces.size(); i++) {
if (pieces[i].first + dy >= n || pieces[i].first + dy < 0 ||
pieces[i].second + dx >= n || pieces[i].second + dx < 0)
continue;
if (grid[pieces[i].first + dy][pieces[i].second + dx] == 'x') {
vis[pieces[i].first + dy][pieces[i].second + dx] = 1;
}
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> grid[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 'o') {
pieces.push_back({i, j});
}
}
}
for (int i = 0; i < (2 * n - 1); i++) {
for (int j = 0; j < (2 * n - 1); j++) {
ans[i] += '.';
}
}
int centerx = n - 1, centery = n - 1;
ans[centery][centerx] = 'o';
for (int i = (-n + 1); i < n; i++) {
for (int j = (-n + 1); j < n; j++) {
if (check(i, j)) {
ans[centery + j][centerx + i] = 'x';
}
}
}
ans[centery][centerx] = 'o';
bool res = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 'x' && !vis[i][j]) {
res = 0;
}
}
}
if (res) {
cout << "YES\n";
for (int i = 0; i < (2 * n - 1); i++) {
cout << ans[i] << endl;
}
} else {
cout << "NO\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> a;
int getEdge(int u, int v) {
return (a[u].first ^ a[v].first) | (a[u].second ^ a[v].second);
}
int isLess(int x, int y, int z, int xx, int yy, int zz) {
if (x < xx) return 1;
if (x > xx) return 0;
if (y < yy) return 1;
if (y > yy) return 0;
return z < zz;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back({x / 2 % 2, y / 2 % 2});
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int cnt[2][2][2] = {0};
for (int j = 0; j < n; j++)
if (i != j) cnt[a[j].first][a[j].second][getEdge(i, j)]++;
int done[2][2][2] = {0};
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++)
for (int z = 0; z < 2; z++)
for (int xx = 0; xx < 2; xx++)
for (int yy = 0; yy < 2; yy++)
for (int zz = 0; zz < 2; zz++) {
int sum = ((x ^ xx) | (y ^ yy)) + z + zz;
if (sum % 2) continue;
if (x == xx && y == yy && z == zz) {
if (done[x][y][z]) continue;
done[x][y][z] = 1;
ans += (cnt[x][y][z] - 1LL) * cnt[x][y][z] / 2;
} else if (isLess(x, y, z, xx, yy, zz)) {
ans += 1LL * cnt[x][y][z] * cnt[xx][yy][zz];
}
}
}
cout << ans / 3 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005, mod = 1e9 + 7;
const long double pie = 3.14159265358979323846264338327950288419716939937510;
long long n, a[55][55];
bool v = 1;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
cin >> a[i][j];
}
}
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
if (a[i][j] > 1) {
bool v1 = 0;
for (long long k = 1; k <= n; ++k) {
for (long long m = 1; m <= n; ++m) {
if (k != i && m != j) {
if (a[i][m] + a[k][j] == a[i][j]) {
v1 = 1;
}
}
}
}
if (v1 == 0) v = 0;
}
}
}
if (v)
cout << "Yes";
else
cout << "No";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 2e5 + 5;
int pos[MAX], w[MAX], wa_bit[MAX];
long long w_bit[MAX];
int n, q;
inline int add(int a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
return a;
}
inline int sub(int a, int b) {
a -= b;
if (0 > a) {
a += MOD;
}
return a;
}
inline int mult(int a, int b) { return (1LL * a * b) % MOD; }
void update(int idx, int val, int bit[]) {
while (idx < MAX) {
bit[idx] = add(bit[idx], val);
idx += idx & -idx;
}
}
int query(int idx, int bit[]) {
int total = 0;
while (idx) {
total = add(total, bit[idx]);
idx -= idx & -idx;
}
return total;
}
int query(int left, int right, int bit[]) {
if (left > right) {
return 0;
}
return sub(query(right, bit), query(left - 1, bit));
}
void ll_update(int idx, long long val, long long bit[]) {
while (idx < MAX) {
bit[idx] += val;
idx += idx & -idx;
}
}
long long ll_query(int idx, long long bit[]) {
long long total = 0;
while (idx) {
total += bit[idx];
idx -= idx & -idx;
}
return total;
}
long long ll_query(int left, int right, long long bit[]) {
if (left > right) {
return 0;
}
return ll_query(right, bit) - ll_query(left - 1, bit);
}
int main() {
scanf("%d %d", &n, &q);
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", pos + i);
pos[i] -= i;
}
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", w + i);
ll_update(i, w[i], w_bit);
update(i, mult(w[i], pos[i]), wa_bit);
}
for (int t = int(0); t < int(q); t++) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
int id = -x;
int nw = y;
ll_update(id, -w[id], w_bit);
update(id, (-mult(w[id], pos[id])) + MOD, wa_bit);
w[id] = nw;
ll_update(id, w[id], w_bit);
update(id, mult(w[id], pos[id]), wa_bit);
} else {
int l = x;
int r = y;
int left = l, right = r;
int k = -1;
long long total_sum = ll_query(l, r, w_bit);
while (left <= right) {
int mid = (left + right) / 2;
long long cur_sum = ll_query(l, mid, w_bit);
if (2 * cur_sum >= total_sum) {
k = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
int ans = mult(ll_query(l, k - 1, w_bit) % MOD, pos[k]);
ans = sub(ans, query(l, k - 1, wa_bit));
ans = add(ans, query(k + 1, r, wa_bit));
ans = sub(ans, mult(ll_query(k + 1, r, w_bit) % MOD, pos[k]));
printf("%d\n", ans);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
int k;
cin >> n;
int maxi = 0;
vector<string> v(20);
for (int i = 0; i < n.length(); i++) {
maxi = max(maxi, (int)n[i] - '0');
}
cout << maxi << endl;
for (int i = 0; i < n.length(); i++) {
for (int j = 0; j < ((int)n[i] - '0'); j++) {
v[j].push_back('1');
}
for (int j = ((int)n[i] - '0'); j < maxi; j++) {
v[j].push_back('0');
}
}
for (int i = 0; i < maxi; i++) {
cout << atoi(v[i].c_str()) << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
double a[200003];
double b[200003];
void mergesort(double *a, double *b, int n) {
int i, i0, i1, iRight, iEnd, width, j;
for (width = 1; width < n; width *= 2)
for (i = 0; i + width < n; i += width * 2) {
i0 = i;
i1 = iRight = i + width;
iEnd = min(i + width * 2, n);
for (j = i; i0 < iRight; j++)
if (i1 == iEnd || a[i0] < a[i1])
b[j] = a[i0++];
else
b[j] = a[i1++];
for (j = i; j < i1; j++) a[j] = b[j];
}
}
double pos1, pos2, pos3;
int main() {
scanf("%d", &n);
int i;
double ep = 0.00000001;
for (i = 0; i < n; i++) {
scanf("%lf", &a[i]);
a[i] += ep;
}
mergesort(a, b, n);
double l, r, re;
l = 0.0000000;
r = 2000000000.0000;
int it = 50;
while (it > 0) {
it--;
re = (l + r) / 2.0;
int pos = 0;
double p1 = -1.00;
double p2 = -1.00;
double p3 = -1.00;
for (i = 1; i < n; i++) {
if (((double)a[i] - (double)a[pos]) / 2.0 + ep > re) {
if (p1 < -ep)
p1 = (a[i - 1] + a[pos]) / 2.00;
else if (p2 < -ep)
p2 = (a[i - 1] + a[pos]) / 2.00;
else
break;
pos = i;
}
}
p3 = ((double)a[n - 1] + (double)a[pos]) / 2.00;
if (i == n) {
pos1 = p1;
pos2 = p2;
pos3 = p3;
if (pos1 < -ep) pos1 = ep;
if (pos2 < -ep) pos2 = ep;
if (pos3 < -ep) pos3 = ep;
r = re;
} else
l = re;
}
printf("%.20f\n", r);
printf("%.20f %.20f %.20f\n", pos1, pos2, pos3);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long ex(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 998244353;
a = (a * a) % 998244353, b /= 2;
}
return ans;
}
inline long long add(long long a, long long b) {
a = a % 998244353 + b % 998244353;
if (a > 998244353) a %= 998244353;
return a;
}
inline long long sub(long long a, long long b) {
a = a % 998244353 - b % 998244353;
if (a < 0) a += 998244353;
return a;
}
inline long long mul(long long a, long long b) {
a %= 998244353, b %= 998244353;
return (a * b) % 998244353;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, q;
cin >> n >> q;
long long a[n + 2], b[n + 2], c[n + 2];
for (long long i = 1; i < n + 1; ++i)
cin >> a[i], a[i] = mul(100, ex(a[i], 998244353 - 2));
b[0] = 0, c[n + 1] = 1;
for (long long i = n; i >= 1; --i) c[i] = mul(c[i + 1], a[i]);
for (long long i = 1; i < n + 1; ++i) b[i] = add(b[i - 1], c[i]);
auto get = [&](long long l, long long r) {
long long x = sub(b[r], b[l - 1]);
x = mul(x, ex(c[r + 1], 998244353 - 2));
return x;
};
long long ans = get(1, n), x;
set<long long> s;
s.insert(1);
for (long long i = 0; i < q; ++i) {
long long u;
cin >> u;
if (s.count(u)) {
auto it = s.find(u);
auto it1 = s.upper_bound(u);
if (it1 == s.end())
x = n;
else
x = *it1 - 1;
auto it2 = s.lower_bound(u);
it2--;
ans = add(ans, get(*it2, x));
ans = sub(ans, add(get(*it2, *it - 1), get(*it, x)));
s.erase(u);
} else {
s.insert(u);
auto it = s.find(u);
auto it1 = s.upper_bound(u);
if (it1 == s.end())
x = n;
else
x = *it1 - 1;
auto it2 = s.find(u);
it2--;
ans = sub(ans, get(*it2, x));
ans = add(ans, add(get(*it2, *it - 1), get(*it, x)));
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, p, A=0, W=0;
string S;
cin >> N >> M;
vector<int> cA(N);
vector<int> cW(N);
for(int i=0; i<M; i++){
cin >> p >> S;
if(S=="AC" && cA.at(p-1)==0){
A++;
W += cW.at(p-1);
cA.at(p-1) = 1;
}else if(cA.at(p-1)==0)
cW.at(p-1)++;
}
cout << A << " " << W << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define endl '\n';
typedef long long ll;
ll nmax = 1000000000;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
ll t;
cin >> t;
while(t--){
ll n;
cin >> n;
string a;
cin >> a;
string s = "trygub";
ll count = 0;
string ans = "";
for(ll j=0; j<n; j++){
if(a[j] == 'b'){
count++;
}
}
while(count--){
ans+="b";
}for(ll i=0; i<n; i++){
if(a[i] != 'b'){
ans+=a[i];
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const double sn = 1e-6;
int n;
int arr[35];
int res;
bool visited[310][310];
bool notAgain[310][310][35][8];
pair<int, int> dirs[8] = {{0, 1}, {1, 1}, {1, 0}, {1, -1},
{0, -1}, {-1, -1}, {-1, 0}, {-1, 1}};
void dfs(int dir, int sx, int sy, int sc) {
if (notAgain[sx][sy][sc][dir]) return;
notAgain[sx][sy][sc][dir] = true;
for (int i = 0; i < arr[sc]; i++) {
sx += dirs[dir].first;
sy += dirs[dir].second;
if (!visited[sx][sy]) {
visited[sx][sy] = true;
res++;
}
}
if (sc < n - 1) {
dfs(dir != 7 ? dir + 1 : 0, sx, sy, sc + 1);
dfs(dir != 0 ? dir - 1 : 7, sx, sy, sc + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
dfs(0, 155, 155, 0);
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n, m, arr[105];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> arr[i];
sort(arr, arr + n);
int ans = 0, i = n - 1, sum = 0;
while (sum < m) {
sum += arr[i--];
ans++;
if (sum >= m) break;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct timer {
time_t start;
timer() { start = clock(); }
~timer() {
cerr << 1. * (clock() - start) / CLOCKS_PER_SEC << " secs" << endl;
}
};
int n, a[100010];
double dp[100010][101];
double nCr[501000][6];
int b[100010];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
for (int i = 0; i < (501000); i++) {
nCr[i][0] = 1;
for (int j = 1; j < (6); j++) {
nCr[i][j] = nCr[i][j - 1] * (i + 1 - j) / j;
}
}
cin >> n;
double ans = 0;
for (int i = 0; i < (n); i++) {
cin >> a[i];
if (a[i] == 0) ans++;
b[i] = a[i];
dp[i][a[i]] = 1;
}
int q, u, v, K;
cin >> q;
double dp2[101];
for (int ii = 0; ii < (q); ii++) {
cin >> u >> v >> K;
u--;
v--;
memset(dp2, 0, sizeof(dp2));
for (int i = 0; i < (a[u] + 1); i++)
if (dp[u][i]) {
for (int j = 0; j < (min(i, K) + 1); j++) {
dp2[i - j] +=
dp[u][i] * nCr[i][j] * nCr[b[u] - i][K - j] / nCr[b[u]][K];
}
}
ans += dp2[0] - dp[u][0];
cout << setprecision(12) << ans << endl;
for (int i = 0; i < (a[u] + 1); i++) dp[u][i] = dp2[i];
b[u] -= K;
b[v] += K;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const vector<int> mods = {998244353, 1000000007, 1000000009};
const long long inf = 3e18;
const double pi = acos(-1.0);
const double eps = 0.0000001;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class... K>
using umap = unordered_map<K...>;
template <class... K>
using uset = unordered_set<K...>;
const int N = 100;
long long n, a[N], idx[N];
bool rev;
vector<vector<long long> > res;
void hp(int i, int j, int d = 0) {
if (i > j) return;
if (!d) res.back().push_back(j - i + 1);
while (i < j) {
swap(idx[a[i]], idx[a[j]]);
swap(a[i], a[j]);
i++;
j--;
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.precision(13);
cin >> n;
for (long long i = (0); i < (n); ++i) {
cin >> a[i];
a[i]--;
idx[a[i]] = i;
}
for (long long i = (0); i < (n - 1); ++i) {
res.push_back({});
if (idx[i] == i) {
for (long long j = (0); j < (n); ++j) hp(j, j);
continue;
}
if (i) {
long long pr = idx[i - 1];
long long cur = idx[i];
for (long long k = (0); k < (pr + 1); ++k) {
hp(k, k);
}
hp(pr + 1, cur);
hp(cur + 1, n - 1);
}
if (!i) {
long long cur = idx[i];
if (cur == n - 1) {
rev = 1;
hp(0, n - 1, 1);
} else {
hp(0, cur);
hp(cur + 1, n - 1);
}
}
}
if (((int)(res).size()) % 2 == 1) {
res.push_back({});
for (long long i = (0); i < (n); ++i) hp(i, i);
}
cout << ((int)(res).size()) - rev << "\n";
for (long long i = (0); i < (((int)(res).size())); ++i) {
if (!((int)(res[i]).size())) continue;
cout << ((int)(res[i]).size()) << " ";
for (long long j = (0); j < (((int)(res[i]).size())); ++j)
cout << res[i][i % 2 == 1 ? ((int)(res[i]).size()) - 1 - j : j] << " ";
cout << "\n";
}
return 0;
}
| 4 |
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main(){
int n;
double x1,y1,x2,y2,x3,y3;
cin>>n;
for(int i=0;cin>>x1>>y1>>x2>>y2>>x3>>y3||i<n;i++){
double X,Y,L;
X= ((y2-y1)*(x1*x1-x3*x3+y1*y1-y3*y3)-(y3-y1)*(x1*x1-x2*x2+y1*y1-y2*y2))/
(2*(x2-x1)*(y3-y1)-2*(y2-y1)*(x3-x1));
Y= ((x3-x1)*(x1*x1-x2*x2+y1*y1-y2*y2)-(x2-x1)*(x1*x1-x3*x3+y1*y1-y3*y3))/
(2*(x2-x1)*(y3-y1)-2*(y2-y1)*(x3-x1));
L= sqrt((X-x1)*(X-x1)+(Y-y1)*(Y-y1));
cout<<fixed<<setprecision(3)<<X<<" "<<Y<<" "<<L<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
for (long long wer = 0; wer < t; wer++) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
string t = "";
for (long long i = 0; i < (n / 2 - k + 1); i++) {
t += '(';
}
for (long long i = 0; i < (n / 2 - k + 1); i++) {
t += ")";
}
for (long long i = 0; i < (k - 1); i++) {
t += "()";
}
vector<char> st;
for (long long i = 0; i < n; i++) {
st.push_back(s[i]);
}
vector<pair<long long, long long>> ans;
for (long long i = 0; i < n; i++) {
if (st[i] != t[i]) {
long long r = 0;
for (long long j = i + 1; j < n; j++) {
if (st[j] == t[i]) {
r = j;
}
}
vector<char> st1(n);
for (long long qr = 0; qr < n; qr++) {
st1[qr] = st[qr];
}
for (long long j = i; j <= r; j++) {
st1[j] = st[r + i - j];
}
st = st1;
ans.push_back({i + 1, r + 1});
}
}
cout << ans.size() << "\n";
for (long long i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
}
return 0;
}
| 1 |
#include<iostream>
#include<vector>
using namespace std;
int main(){
int K,N;cin>>K>>N;
vector<int> A(N);
for(int i=0;i<N;i++){
cin>>A[i];
}
int m=0;
for(int i=0;i<N-1;i++){
m=max(m,A[i+1]-A[i]);
}
m=max(m,K-A[N-1]+A[0]);
cout<<K-m<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e12;
const long long MOD = 1e9 + 7;
long long sq(long long num) { return num * num; }
long long mod_pow(long long x, long long n) {
if (n == 0) return 1;
if (n == 1) return x % MOD;
long long res = sq(mod_pow(x, n / 2));
res %= MOD;
if (n % 2 == 1) {
res *= x;
res %= MOD;
}
return res;
}
long long mod_add(long long a, long long b) { return (a + b) % MOD; }
long long mod_sub(long long a, long long b) { return (a - b + MOD) % MOD; }
long long mod_mul(long long a, long long b) { return a * b % MOD; }
long long n;
vector<long long> num;
vector<vector<long long>> ans;
map<long long, long long> endid;
int main() {
cin >> n;
long long now = 0;
vector<long long> vl;
num.resize(n);
for (int i = 0; i < (n); i++) {
cin >> num[i];
}
for (int i = 0; i < (n); i++) {
if (endid.empty()) {
endid[num[i]] = 1;
vl.push_back(num[i]);
ans.push_back(vl);
vl.clear();
} else {
auto it = endid.lower_bound(num[i]);
if (it == endid.begin()) {
long long s = endid.size();
endid[num[i]] = s + 1;
vl.push_back(num[i]);
ans.push_back(vl);
vl.clear();
} else {
it--;
endid[num[i]] = it->second;
endid.erase(it);
ans[it->second - 1].push_back(num[i]);
}
}
}
for (int i = 0; i < (ans.size()); i++) {
for (int j = 0; j < (ans[i].size()); j++) {
if (j != 0) cout << " ";
cout << ans[i][j];
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const char T[25] = "BERLAND";
bool g[10][10];
struct team {
char name[25];
int point;
int diff;
int score;
int miss;
} a[10];
int tot;
int cmp(struct team x, struct team y) {
if (x.point == y.point) {
if (x.diff == y.diff) {
if (x.score == y.score) return strcmp(x.name, y.name) < 0;
return x.score > y.score;
}
return x.diff > y.diff;
}
return x.point > y.point;
}
int search_team(char *str) {
for (int i = 0; i < tot; i++)
if (!strcmp(str, a[i].name)) return i;
strcpy(a[tot].name, str);
return tot++;
}
void fun(int pa, int pb) {
if (pa <= 1) {
printf("1:0\n");
return;
}
if (a[1].point - a[pa].point > 3) {
printf("IMPOSSIBLE\n");
return;
}
if (a[1].point - a[pa].point < 3) {
printf("1:0\n");
return;
}
int D = a[1].diff - a[pa].diff;
if (D <= 0) {
printf("1:0\n");
return;
}
int k, d, p, q;
struct team b[10];
for (d = (D + 1) / 2;; d++)
for (p = d;; p++) {
q = p - d;
for (k = 0; k < 4; k++) b[k] = a[k];
b[pa].diff += d;
b[pa].score += p;
b[pa].miss += q;
b[pa].point += 3;
b[pb].diff -= d;
b[pb].score += q;
b[pb].miss += p;
sort(b, b + 4, cmp);
for (k = 0; k < 4; k++)
if (!strcmp(b[k].name, T)) break;
if (k <= 1) {
printf("%d:%d\n", p, q);
return;
}
if (b[k].diff < b[1].diff) break;
}
}
void solve() {
int x, y;
char temp[25], teama[25], teamb[25];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
if (i != j && !g[i][j]) {
x = i;
y = j;
break;
}
strcpy(teama, a[x].name);
strcpy(teamb, a[y].name);
if (!strcmp(teamb, T)) {
strcpy(temp, teama);
strcpy(teama, teamb);
strcpy(teamb, temp);
}
sort(a, a + 4, cmp);
int pa = search_team(teama);
int pb = search_team(teamb);
fun(pa, pb);
}
int main() {
tot = 0;
memset(a, 0, sizeof(a));
memset(g, false, sizeof(g));
for (int i = 1; i <= 5; i++) {
char s1[25], s2[25];
int p, q;
scanf("%s%s%d:%d", s1, s2, &p, &q);
int x = search_team(s1);
a[x].score += p;
a[x].miss += q;
a[x].diff = a[x].score - a[x].miss;
int y = search_team(s2);
a[y].score += q;
a[y].miss += p;
a[y].diff = a[y].score - a[y].miss;
if (p > q)
a[x].point += 3;
else if (p == q) {
a[x].point += 1;
a[y].point += 1;
} else
a[y].point += 3;
g[x][y] = g[y][x] = true;
}
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int H[500001];
multiset<int> S;
vector<int> G[500001];
int D[500001];
int vis[500001];
int segtree[4000001];
int lazy[4000001];
const int MAX_VAL = 1000000000;
int MAX_ID;
map<int, int> compres;
int timer = 0;
void propagate(int L, int R, int i) {
if (lazy[i] == 0) return;
segtree[i] += lazy[i];
if (L != R) {
lazy[2 * i + 1] += lazy[i];
lazy[2 * i + 2] += lazy[i];
}
lazy[i] = 0;
}
int query(int L, int R, int i, int qL, int qR) {
propagate(L, R, i);
if (L > qR || R < qL) return INT_MAX / 2;
if (qL <= L && R <= qR) return segtree[i];
int mid = (L + R) / 2;
return min(query(L, mid, 2 * i + 1, qL, qR),
query(mid + 1, R, 2 * i + 2, qL, qR));
}
void update(int L, int R, int i, int qL, int qR, int v) {
propagate(L, R, i);
if (L > qR || R < qL) return;
if (qL <= L && R <= qR) {
lazy[i] += v;
propagate(L, R, i);
return;
}
int mid = (L + R) / 2;
update(L, mid, 2 * i + 1, qL, qR, v);
update(mid + 1, R, 2 * i + 2, qL, qR, v);
segtree[i] = min(segtree[2 * i + 1], segtree[2 * i + 2]);
}
void dfs(int i, int p, int d) {
d = min(d, H[i]);
D[i] = d;
for (int u : G[i]) {
if (u == p) continue;
G[u].erase(find(G[u].begin(), G[u].end(), i));
dfs(u, i, d);
}
}
void dfs2(int i, int d) {
int x = compres[D[i]], y = compres[d];
if (x < y)
update(1, MAX_ID, 0, x + 1, y, +1);
else if (x > y)
update(1, MAX_ID, 0, y + 1, x, -1);
for (int u : G[i]) {
dfs2(u, min(d, H[u]));
}
}
void dfs2_erase(int i, int d) {
int x = compres[D[i]], y = compres[d];
if (x < y)
update(1, MAX_ID, 0, x + 1, y, -1);
else if (x > y)
update(1, MAX_ID, 0, y + 1, x, +1);
for (int u : G[i]) {
dfs2_erase(u, min(d, H[u]));
}
}
int main() {
int N;
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &H[i]);
for (int i = 0; i < N - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
int K;
scanf("%d", &K);
for (int i = 1; i <= K; i++) {
int x;
scanf("%d", &x);
S.insert(x);
}
for (int i = 0; i <= N; i++) {
D[i] = INT_MAX / 2;
}
dfs(1, 0, INT_MAX / 2);
set<pair<int, int> > Q;
Q.insert({D[1], 1});
while (!S.empty() && !Q.empty()) {
int M = *S.rbegin();
auto it = Q.lower_bound({M, 0});
if (it == Q.end()) break;
S.erase(S.find(M));
int u = it->second;
Q.erase(it);
vis[u] = true;
for (int v : G[u]) {
Q.insert({D[v], v});
}
}
if (S.empty())
printf("0\n");
else {
int ans = INT_MAX / 2;
for (int x : S) compres[x];
for (int i = 1; i <= N; i++)
if (!vis[i]) compres[D[i]];
for (int i = 1; i <= N; i++)
if (!vis[i]) compres[H[i]];
compres[MAX_VAL];
for (auto it : compres) compres[it.first] = ++timer;
MAX_ID = compres[MAX_VAL];
assert(MAX_ID <= 1000005);
for (int x : S) {
update(1, MAX_ID, 0, 1, compres[x], -1);
}
for (int i = 1; i <= N; i++) {
if (!vis[i]) update(1, MAX_ID, 0, 1, compres[D[i]], 1);
}
for (auto it : Q) {
int u = it.second;
dfs2(u, *S.rbegin());
if (query(1, MAX_ID, 0, 1, MAX_ID) >= 0) {
ans = min(ans, *S.rbegin() - H[u]);
}
dfs2_erase(u, *S.rbegin());
}
if (ans == INT_MAX / 2)
printf("-1\n");
else
printf("%d\n", ans);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, w = 0;
char ch = getchar();
while (!isdigit(ch)) w |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return w ? -x : x;
}
int n, a[2555][2555], vis[2555], dis[2555], fa[2555], dep[2555];
int main() {
int n = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = read();
for (int i = 1; i <= n; i++)
if (a[i][i] != 0) {
puts("NOT MAGIC\n");
return 0;
}
for (int i = 1; i <= n; ++i)
for (int j = 1 + i; j <= n; ++j)
if (a[i][j] != a[j][i]) {
puts("NOT MAGIC\n");
return 0;
}
for (int i = 0; i <= n; ++i) fa[i] = i, dis[i] = 1e9 + 1e8;
dis[1] = 0;
for (int i = 1; i <= n; ++i) {
int pos = 0;
for (int j = 1; j <= n; ++j)
if (!vis[j] && dis[pos] > dis[j]) pos = j;
vis[pos] = 1;
for (int j = 1; j <= n; ++j)
if (!vis[j] && a[pos][j] < dis[j])
dis[j] = a[pos][j], fa[j] = pos, dep[j] = dep[pos] + 1;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
int x = i, y = j;
if (dep[x] > dep[y]) swap(x, y);
if (a[x][fa[x]] < a[x][y] && a[y][fa[x]] < a[x][y])
return printf("NOT MAGIC\n"), 0;
if (a[x][fa[y]] < a[x][y] && a[y][fa[y]] < a[x][y])
return printf("NOT MAGIC\n"), 0;
}
puts("MAGIC\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
int n, m, a[100005], b[100005], c[100005], d[100005], A[100005], e[100005];
bool cmp(int x, int y) { return x > y; }
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d %d %d", &a[i], &b[i], &c[i], &d[i]);
if (a[i] + b[i] < c[i] + d[i]) {
if (a[i] <= d[i] && b[i] <= c[i]) continue;
if (a[i] > d[i]) {
ans += 2 * (a[i] - d[i]);
A[++m] = 0;
} else {
ans += 2 * (c[i] - b[i]);
A[++m] = 0;
}
continue;
}
A[++m] = a[i] + b[i], ans += a[i] - b[i];
A[++m] = c[i] + d[i], ans += c[i] - d[i];
}
sort(A + 1, A + m + 1, cmp);
for (i = 1; i <= m; i++)
if (i & 1)
ans += A[i];
else
ans -= A[i];
cout << ans / 2;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N,M;
cin >> N >> M;
if (N >= 2 && M >= 2){
cout << (N-2)*(M-2) << endl;
}
else if (N == 1 && M == 1){
cout << 1 << endl;
}
else {
cout << N*M-2 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, mod = 1e9 + 7;
int n, a[N], id[N], inv[N], ans = 0;
int p[N], mu[N], phi[N], lp;
bool pri[N];
vector<int> e[N], E[N];
int fa[N], sz[N], son[N], dep[N], top[N], dfn[N], idx = 0;
int s[N], f[N], g[N], ss[N];
int pp[N], len, sta[N], Top = 0;
bool flag[N];
inline int add(const int &x, const int &y) {
return x + y < mod ? x + y : x + y - mod;
}
inline int sub(const int &x, const int &y) {
return x - y < 0 ? x - y + mod : x - y;
}
inline int mul(const int &x, const int &y) {
return (int)((long long)x * y % mod);
}
inline bool cmp(const int &x, const int &y) { return dfn[x] < dfn[y]; }
void Sieve() {
inv[0] = inv[1] = 1, phi[1] = mu[1] = 1;
for (int i = 2; i <= n; i++) inv[i] = mul(mod - mod / i, inv[mod % i]);
for (int i = 2; i <= n; i++) {
if (!pri[i]) p[++lp] = i, mu[i] = mod - 1, phi[i] = i - 1;
for (int j = 1; p[j] * i <= n; j++) {
pri[p[j] * i] = 1;
if (i % p[j] == 0) {
phi[p[j] * i] = phi[i] * p[j];
break;
}
mu[p[j] * i] = sub(0, mu[i]);
phi[p[j] * i] = phi[i] * (p[j] - 1);
}
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
s[j] = add(s[j], mul(mul(i, mu[j / i]), inv[phi[i]]));
}
void dfs1(int u, int ff) {
fa[u] = ff, dep[u] = dep[ff] + 1, sz[u] = 1;
for (auto v : e[u])
if (v ^ ff) {
dfs1(v, u), sz[u] += sz[v];
if (sz[son[u]] < sz[v]) son[u] = v;
}
}
void dfs2(int u, int tp) {
top[u] = tp, dfn[u] = ++idx;
if (son[u]) dfs2(son[u], tp);
for (auto v : e[u])
if (!top[v]) dfs2(v, v);
}
int LCA(int x, int y) {
for (; top[x] != top[y]; x = fa[top[x]])
if (dep[top[x]] < dep[top[y]]) swap(x, y);
return dep[x] < dep[y] ? x : y;
}
void insert(int x) {
int lca = LCA(x, sta[Top]);
if (Top == 1 || lca == sta[Top]) {
sta[++Top] = x;
return;
}
for (; Top > 1 && dfn[sta[Top - 1]] >= dfn[lca]; --Top)
E[sta[Top - 1]].push_back(sta[Top]);
if (lca != sta[Top]) E[lca].push_back(sta[Top]), sta[Top] = lca;
sta[++Top] = x;
}
void dp(int u) {
ss[u] = flag[u] * phi[a[u]], f[u] = g[u] = 0;
for (auto v : E[u]) {
dp(v);
int w = dep[v] - dep[u];
g[u] = add(g[v], add(add(g[u], mul(ss[v], add(mul(w, ss[u]), f[u]))),
mul(ss[u], f[v])));
ss[u] = add(ss[u], ss[v]), f[u] = add(f[u], add(f[v], mul(ss[v], w)));
}
E[u].clear(), flag[u] = 0;
}
int calc(int x) {
len = 0;
for (int i = x; i <= n; i += x) pp[++len] = id[i];
sort(pp + 1, pp + len + 1, cmp), sta[Top = 1] = 1;
for (int i = 1; i <= len; i++) {
flag[pp[i]] = 1;
if (pp[i] != 1) insert(pp[i]);
}
for (; Top > 1; --Top) E[sta[Top - 1]].push_back(sta[Top]);
dp(1);
return g[1];
}
int main() {
scanf("%d", &n), Sieve();
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), id[a[i]] = i;
for (int i = 1, x, y; i < n; i++)
scanf("%d%d", &x, &y), e[x].push_back(y), e[y].push_back(x);
dfs1(1, 0), dfs2(1, 1);
for (int i = 1; i <= n; i++) ans = add(ans, mul(calc(i), s[i]));
printf("%d\n", mul(add(ans, ans), mul(inv[n], inv[n - 1])));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int n, k;
int a[10000];
int b[10000];
cin >> t;
while (t--) {
int sum = 0, s = 0;
cin >> n >> k;
for (int j = 0; j < n; j++) {
cin >> a[j];
}
for (int j = 0; j < n; j++) {
cin >> b[j];
}
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; i++) {
if (s == k) break;
if (a[i] < b[n - i - 1]) {
a[i] = b[n - i - 1];
s++;
}
}
for (int i = 0; i < n; i++) {
sum += a[i];
}
cout << sum << endl;
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.