solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m, a, b;
cin >> n >> m;
vector<long long> vec;
long long sumb = 0, suma = 0;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
suma += a;
sumb += b;
vec.push_back(a - b);
}
if (sumb > m) {
cout << "-1" << '\n';
return;
}
sort(vec.begin(), vec.end());
long long ans = 0;
long long t = m - suma;
if (t >= 0) {
cout << "0" << '\n';
return;
}
t = abs(t);
for (int i = n - 1; i >= 0; i--) {
ans++;
if (t - vec[i] <= 0) {
break;
}
t -= vec[i];
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
long double a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
map<long double, int> c;
int maxx = 0, d = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
if (b[i] == 0) {
d++;
}
continue;
}
long double d = -b[i] / a[i];
c[d]++;
}
map<long double, int>::iterator k = c.begin();
for (; k != c.end(); k++) {
maxx = max(maxx, (*k).second);
}
cout << maxx + d;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, tot;
vector<pair<int, int> > e[100010];
vector<pair<int, int> > ps;
vector<pair<int, int> > es;
void dfs(int u, int p) {
int fa;
if (p == 0)
fa = 0;
else
fa = ps[p - 1].first;
int pre = 0;
for (int i = 0, len = e[u].size(); i < len; ++i) {
int v = e[u][i].first;
if (v == fa) continue;
e[u][i].second = ++tot;
ps.push_back(make_pair(u, v));
if (pre == 0) {
if (fa != 0) es.push_back(make_pair(p, tot));
} else
es.push_back(make_pair(pre, tot));
pre = tot;
dfs(v, tot);
}
}
int main() {
int x, y;
while (cin >> n) {
for (int i = 1; i < n; ++i) {
cin >> x >> y;
e[x].push_back(make_pair(y, 0));
e[y].push_back(make_pair(x, 0));
}
tot = 0;
dfs(1, 0);
cout << n - 1 << endl;
for (int i = 0; i < ps.size(); ++i)
cout << 2 << " " << ps[i].first << " " << ps[i].second << endl;
for (int i = 0; i < es.size(); ++i)
cout << es[i].first << " " << es[i].second << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2, s3, s4;
int dp[101][101][101], lmt, sdp[101][101];
map<string, int> m;
vector<string> sv;
int gen(string xz) {
for (int i = 0; i <= s3.size(); i++) sv.push_back(s3.substr(0, i));
for (auto ix : sv) {
string s = ix;
for (int k = 'A'; k <= 'Z'; k++) {
s.push_back(k);
for (int j = 0; j < s.size(); j++) {
int jj = 0, cnt = 0;
bool br = 0;
for (int i = 0; i + j < s.size() and jj < s3.size(); i++) {
if (s[i + j] == s3[jj])
jj++, cnt++;
else {
br = 1;
break;
}
}
if (!br)
sdp[s.size() - 1][(int)s.back()] =
max(cnt, sdp[s.size() - 1][(int)s.back()]);
}
if (sdp[s.size() - 1][(int)s.back()] == -1)
sdp[s.size() - 1][(int)s.back()] = 0;
s.pop_back();
}
}
return 1;
}
bool printed = 0;
int lcs(int i, int j, int mi) {
if (mi == s3.size()) return INT_MIN;
if (i == s1.size() || j == s2.size()) return 0;
if (dp[i][j][mi] != -1) return dp[i][j][mi];
int x, y, z;
x = y = z = INT_MIN;
if (s1[i] == s2[j]) x = 1 + lcs(i + 1, j + 1, sdp[mi][(int)s1[i]]);
y = lcs(i + 1, j, mi);
z = lcs(i, j + 1, mi);
return dp[i][j][mi] = max({x, y, z});
}
void print(int i, int j, int mi) {
if (i == s1.size() || j == s2.size()) {
return;
}
int re = lcs(i, j, mi);
if (s1[i] == s2[j] and re == 1 + lcs(i + 1, j + 1, sdp[mi][(int)s1[i]])) {
cout << s1[i];
print(i + 1, j + 1, sdp[mi][(int)s1[i]]);
return;
}
if (re == lcs(i + 1, j, mi)) {
print(i + 1, j, mi);
return;
} else
print(i, j + 1, mi);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
memset(dp, -1, sizeof dp);
memset(sdp, -1, sizeof sdp);
cin >> s1 >> s2 >> s3;
s4 = s3;
gen(s4);
int ans = lcs(0, 0, 0);
if (!ans) return cout << "0", 0;
print(0, 0, 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct data {
long long idx_start, idx_end;
long long prefix, length;
int value;
} d[100010];
int n;
long long index(long long mid, bool& again);
int main() {
int q;
long long len = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int v, ty;
long long c[2];
cin >> ty;
if (ty == 1) {
cin >> v;
d[i].value = v;
d[i].idx_start = d[i].idx_end = len++;
} else {
cin >> c[0] >> c[1];
d[i].value = -1;
d[i].idx_start = len;
d[i].prefix = c[0];
d[i].length = c[1];
len += c[0] * c[1];
d[i].idx_end = len - 1;
}
}
cin >> q;
long long idx;
for (int i = 0; i < q; i++) {
cin >> idx;
idx--;
bool b;
do {
idx = index(idx, b);
} while (b);
cout << d[idx].value;
if (i == q - 1)
cout << endl;
else
cout << ' ';
}
return 0;
}
long long index(long long idx, bool& again) {
int low, high;
low = 0, high = n - 1;
while (low <= high) {
int m = (low + high) >> 1;
if (d[m].idx_start <= idx && d[m].idx_end >= idx) {
if (d[m].idx_end == d[m].idx_start && d[m].value != -1) {
again = false;
return m;
} else {
again = true;
return (idx - d[m].idx_start) % d[m].prefix;
}
} else if (d[m].idx_start > idx) {
high = m - 1;
} else
low = m + 1;
}
again = true;
return -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const long long mod = 1e9 + 9;
inline long long qpow(long long s, long long y, long long ret = 1) {
for (; y; y >>= 1, s = 1ll * s * s % mod)
if (y & 1) ret = 1ll * ret * s % mod;
return ret;
}
map<pair<long long, long long>, long long> mp;
set<long long> s;
long long f[100003], x[100003], y[100003];
long long locked[100003];
long long recalc(long long i) {
f[i] = (mp[make_pair(x[i] - 1, y[i] - 1)] > 0) +
(mp[make_pair(x[i], y[i] - 1)] > 0) +
(mp[make_pair(x[i] + 1, y[i] - 1)] > 0);
if (f[i] == 1) {
if (mp[make_pair(x[i] - 1, y[i] - 1)]) {
long long X = mp[make_pair(x[i] - 1, y[i] - 1)];
locked[X]++;
if (s.find(X) != s.end()) s.erase(s.find(X));
}
if (mp[make_pair(x[i], y[i] - 1)]) {
long long X = mp[make_pair(x[i], y[i] - 1)];
locked[X]++;
if (s.find(X) != s.end()) s.erase(s.find(X));
}
if (mp[make_pair(x[i] + 1, y[i] - 1)]) {
long long X = mp[make_pair(x[i] + 1, y[i] - 1)];
locked[X]++;
if (s.find(X) != s.end()) s.erase(s.find(X));
}
}
}
signed main() {
long long n = read();
for (long long i = 1; i <= n; i++)
x[i] = read(), y[i] = read(), mp[make_pair(x[i], y[i])] = i;
for (long long i = 1; i <= n; i++)
if (y[i]) {
f[i] = (mp[make_pair(x[i] - 1, y[i] - 1)] > 0) +
(mp[make_pair(x[i], y[i] - 1)] > 0) +
(mp[make_pair(x[i] + 1, y[i] - 1)] > 0);
if (f[i] == 1) {
if (mp[make_pair(x[i] - 1, y[i] - 1)])
locked[mp[make_pair(x[i] - 1, y[i] - 1)]]++;
if (mp[make_pair(x[i], y[i] - 1)])
locked[mp[make_pair(x[i], y[i] - 1)]]++;
if (mp[make_pair(x[i] + 1, y[i] - 1)])
locked[mp[make_pair(x[i] + 1, y[i] - 1)]]++;
}
}
for (long long i = 1; i <= n; i++)
if (!locked[i]) s.insert(i);
long long ans = 0;
for (long long i = n - 1, ss = 1; i >= 0; i--, ss ^= 1) {
long long t;
if (ss)
t = *(s.rbegin()), s.erase(t);
else
t = *(s.begin()), s.erase(t);
(ans += (t - 1) * qpow(n, i) % mod) %= mod;
mp[make_pair(x[t], y[t])] = 0;
if (f[t] == 1) {
if (mp[make_pair(x[t] - 1, y[t] - 1)]) {
locked[mp[make_pair(x[t] - 1, y[t] - 1)]]--;
if (locked[mp[make_pair(x[t] - 1, y[t] - 1)]] == 0)
s.insert(mp[make_pair(x[t] - 1, y[t] - 1)]);
}
if (mp[make_pair(x[t], y[t] - 1)]) {
locked[mp[make_pair(x[t], y[t] - 1)]]--;
if (locked[mp[make_pair(x[t], y[t] - 1)]] == 0)
s.insert(mp[make_pair(x[t], y[t] - 1)]);
}
if (mp[make_pair(x[t] + 1, y[t] - 1)]) {
locked[mp[make_pair(x[t] + 1, y[t] - 1)]]--;
if (locked[mp[make_pair(x[t] + 1, y[t] - 1)]] == 0)
s.insert(mp[make_pair(x[t] + 1, y[t] - 1)]);
}
}
if (mp[make_pair(x[t] - 1, y[t] + 1)])
recalc(mp[make_pair(x[t] - 1, y[t] + 1)]);
if (mp[make_pair(x[t], y[t] + 1)]) recalc(mp[make_pair(x[t], y[t] + 1)]);
if (mp[make_pair(x[t] + 1, y[t] + 1)])
recalc(mp[make_pair(x[t] + 1, y[t] + 1)]);
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a[200005];
long long vis[200005];
long long sz[200005];
long long ans = 0;
void dfs(long long n) {
vis[n] = 1;
sz[n] = 1;
for (long long i = 0; i < a[n].size(); i++) {
if (vis[a[n][i]] == 0) {
dfs(a[n][i]);
sz[n] += sz[a[n][i]];
}
}
ans += sz[n];
}
long long n2;
void find(long long n, long long curans) {
ans = max(ans, curans);
vis[n] = 1;
for (long long i = 0; i < a[n].size(); i++) {
if (vis[a[n][i]] == 0) {
find(a[n][i], curans + n2 - 2 * sz[a[n][i]]);
}
}
}
int32_t main() {
long long n;
cin >> n;
n2 = n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
dfs(1);
for (long long i = 1; i <= n; i++) vis[i] = 0;
find(1, ans);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, tmm;
long long ara[110];
long long ff(long long motn, long long mottm) {
long long foo = 0;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= motn; j++) {
if (ara[i] + mottm <= tmm) {
mottm += ara[i];
foo++;
}
}
}
return foo;
}
int main() {
std::ios_base::sync_with_stdio(false);
;
cin >> n >> k >> tmm;
long long sum = 0;
for (int i = 1; i <= k; i++) {
cin >> ara[i];
sum += ara[i];
}
sort(ara + 1, ara + 1 + k);
long long ans = 0;
for (int i = 0; i <= n; i++) {
if ((sum * (long long)i) > tmm) {
break;
}
ans =
max(ans, ((long long)i * (k + 1LL)) + ff(n - i, (sum * (long long)i)));
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int n, k;
cin >> n >> k;
vector<int> x(n);
for (int j = 0; j < n; j++) {
int t;
cin >> t;
x[j] = t % 2;
}
vector<int> ans;
for (int j = 0; j < n; j++) {
if (x[j] % 2 != 0) {
ans.push_back(j + 1);
}
}
if (ans.size() < k || (ans.size() - k) % 2 != 0) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int j = 0; j < k - 1; j++) {
cout << ans[j] << ' ';
}
cout << n << '\n';
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long mod = 1000000007;
const int mxn = 10e6;
void solve() {
int n;
cin >> n;
int k = n;
string st = "abcdefghijklmnopqrstuvwxyz";
unordered_map<char, int> make_pair;
while (k--) {
string s;
cin >> s;
for (auto c : s) {
++make_pair[c];
}
}
for (auto c : st) {
if (make_pair[c] % n != 0) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[30005];
int lol = INT_MIN;
int dp[30005][1005];
int n;
int memo[30005][1005];
int compute(int i, int j) {
int ans;
if (i >= 30005) return 0;
if (memo[i][j] == 1) return dp[i][j];
memo[i][j] = 1;
if (j == 1) {
ans = arr[i] + max(compute(i + j, j), compute(i + j + 1, j + 1));
} else {
ans = arr[i] + max(max(compute(i + j - 1, j - 1), compute(i + j, j)),
compute(i + j + 1, j + 1));
}
dp[i][j] = ans;
return ans;
}
int main() {
int d;
scanf("%d %d", &n, &d);
for (int i = 1; i <= n; i++) {
int value;
scanf("%d", &value);
int lol = max(lol, value);
arr[value]++;
}
int sol = compute(d, d);
printf("%d", sol);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 7;
char str[2][maxN];
int n, len, top, cur, lab[2][2][maxN];
map<string, int> strh;
map<pair<int, int>, int> muti;
int main() {
scanf("%s%s", str[0], str[1]);
n = strlen(str[0]);
for (len = n; (len & 1) == 0; len >>= 1)
;
n /= len;
cur = top = 0;
for (int i = 0; i < 2; i++)
for (int p = 0; p < n; p++) {
string tmp;
tmp.assign(str[i] + p * len, len);
map<string, int>::iterator it = strh.find(tmp);
if (it == strh.end()) {
lab[cur][i][p] = top;
strh.insert(make_pair(tmp, top++));
} else {
lab[cur][i][p] = it->second;
}
}
for (; n > 1; n >>= 1) {
muti.clear(), top = 0;
for (int i = 0; i < 2; i++)
for (int p = 0; p < n; p += 2) {
pair<int, int> tmp;
if (lab[cur][i][p] <= lab[cur][i][p + 1])
tmp = make_pair(lab[cur][i][p], lab[cur][i][p + 1]);
else
tmp = make_pair(lab[cur][i][p + 1], lab[cur][i][p]);
map<pair<int, int>, int>::iterator it = muti.find(tmp);
if (it == muti.end()) {
lab[cur ^ 1][i][p >> 1] = top;
muti.insert(make_pair(tmp, top++));
} else {
lab[cur ^ 1][i][p >> 1] = it->second;
}
}
cur ^= 1;
}
if (lab[cur][0][0] == lab[cur][1][0])
printf("YES\n");
else
printf("NO\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct _ {
_() { ios_base::sync_with_stdio(0); }
} _;
template <class A, class B>
ostream &operator<<(ostream &o, pair<A, B> t) {
o << "(" << t.first << ", " << t.second << ")";
return o;
}
template <class T>
string tostring(T first, int len = 0, char c = '0') {
stringstream ss;
ss << first;
string r = ss.str();
if (r.length() < len) r = string(len - r.length(), c) + r;
return r;
}
template <class T>
void PV(T a, T b, int n = 0, int w = 0, string s = " ") {
int c = 0;
while (a != b) {
cout << tostring(*a++, w, ' ');
if (a != b && (n == 0 || ++c % n))
cout << s;
else
cout << "\n";
cout.flush();
}
}
template <class T>
inline bool chmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool chmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
const long long linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = int(1e9) + 7;
const int N = 1010;
int d[N][N];
int first[N];
int eq[N];
int big[N];
double dp[N][N];
const int NN = N + 10;
double C[NN][NN];
void binomialTable(int n) {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++) {
C[i][j] = j > 0 ? C[i - 1][j - 1] + C[i - 1][j] : 1;
}
}
int main() {
binomialTable(N);
int n, m;
cin >> n >> m;
vector<int> v;
for (int i = 0; i < m; i++) {
cin >> first[i];
for (int j = 0; j < first[i]; j++) {
cin >> d[i][j];
v.push_back(d[i][j]);
}
}
sort((v).begin(), (v).end());
int important = *(v.rbegin() + n - 1);
for (int i = 0; i < m; i++) {
for (int j = 0; j < first[i]; j++) {
if (d[i][j] == important) eq[i]++;
if (d[i][j] > important) big[i]++;
}
}
int e = n;
for (int i = 0; i < m; i++) e -= big[i];
int ne = 0;
for (int i = 0; i < m; i++) ne += eq[i];
dp[0][0] = 1;
for (int i = 1; i <= m; i++)
for (int j = 0; j <= e; j++) {
dp[i][j] = dp[i - 1][j] / C[first[i - 1]][big[i - 1]];
if (eq[i - 1] && j > 0)
dp[i][j] += dp[i - 1][j - 1] / C[first[i - 1]][big[i - 1] + 1];
}
double r1 = dp[m][e];
double r2 = C[ne][e];
double res = r1 / r2;
cout << fixed << setprecision(20) << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long unorder(int n) {
if (n == 0) return 1;
if (n == 1) return 0;
bool good;
long long ans = 0;
vector<int> V(n);
for (int i = 0; i < n; i++) V[i] = i;
do {
good = true;
for (int i = 0; i < n && good; i++) good = (V[i] != i);
if (good) ans++;
} while (next_permutation(V.begin(), V.end()));
return ans;
}
long long newton(int n, int k) {
if (k > n) return 0;
if (2 * k > n) k = n - k;
long long ans = 1;
for (int i = n - k + 1; i <= n; i++) ans *= i;
for (int i = 1; i <= k; i++) ans /= i;
return ans;
}
int main() {
int n, k;
long long ans = 0;
cin >> n >> k;
for (int i = 0; i <= k; i++) {
long long unorders = unorder(i), combinations = newton(n, n - i);
ans += combinations * unorders;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m;
long long int a[100001];
long long int max(long long int a, long long int b) { return a > b ? a : b; }
int main() {
int c;
cin >> c;
int res = 0;
long long int sum = 0;
for (int i = 0; i < c; ++i) {
cin >> a[i];
sum += a[i];
m[sum]++;
res = max(m[sum], res);
}
cout << c - res << endl;
}
| 6 |
#include <bits/stdc++.h>
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline void sub(long long &a, long long b) {
a -= b;
if (a < 0) a += 1000000007;
}
inline void add(long long &a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
template <typename T>
inline T const &MAX(T const &a, T const &b) {
return a > b ? a : b;
}
template <typename T>
inline T const &MIN(T const &a, T const &b) {
return a < b ? a : b;
}
inline long long qp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007, b >>= 1;
}
return ans;
}
inline long long qp(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c, b >>= 1;
}
return ans;
}
using namespace std;
const unsigned long long ba = 233;
const double eps = 1e-8;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 10000 + 10, maxn = 10000000 + 10, inf = 0x3f3f3f3f;
int main() {
int h1, h2, a, b;
scanf("%d%d%d%d", &h1, &h2, &a, &b);
if (h1 + 8 * a >= h2)
puts("0");
else {
if (a <= b)
puts("-1");
else {
h1 += 8 * a - 12 * b;
int ans = 1;
while (h1 + 12 * a < h2) h1 += 12 * (a - b), ans++;
printf("%d\n", ans);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 150002;
int n, m, P, i, op, l, r, x;
struct node {
int a[5], b[5], tag;
node operator+(node p) const {
for (register int i = 0; i <= P; i++)
if (b[i]) {
bool fl = 0;
for (int j = 0; j <= P && !fl; j++)
if (p.a[j] == a[i]) p.b[j] += b[i], fl = 1;
if (fl) continue;
int k = 0;
for (int j = 0; j <= P && !fl; j++)
if (!p.b[j])
p.a[j] = a[i], p.b[j] = b[i], fl = 1;
else if (p.b[j] < p.b[k])
k = j;
if (fl) continue;
if (p.b[k] >= b[i]) {
for (register int j = 0; j <= P; j++) p.b[j] -= b[i];
continue;
}
int mn = p.b[k];
for (register int j = 0; j <= P; j++) p.b[j] -= mn;
p.a[k] = a[i], p.b[k] = b[i] - mn;
}
p.tag = 0;
return p;
}
} s[N << 2], t;
void up(int t) { s[t] = s[t << 1] + s[t << 1 | 1]; }
void build(int t, int l, int r) {
if (l == r) {
scanf("%d", &x);
s[t].a[0] = x, s[t].b[0] = 1;
return;
}
build(t << 1, l, ((l + r) >> 1));
build(t << 1 | 1, ((l + r) >> 1) + 1, r);
up(t);
}
void doit(int t, int l, int r, int v) {
s[t].a[0] = v, s[t].b[0] = r - l + 1;
for (register int i = 1; i <= P; i++) s[t].b[i] = 0;
s[t].tag = v;
}
void down(int t, int l, int r) {
if (s[t].tag) {
doit(t << 1, l, ((l + r) >> 1), s[t].tag);
doit(t << 1 | 1, ((l + r) >> 1) + 1, r, s[t].tag);
s[t].tag = 0;
}
}
void update(int t, int l, int r, int x, int y, int v) {
if (x <= l && r <= y) {
doit(t, l, r, v);
return;
}
down(t, l, r);
if (x <= ((l + r) >> 1)) update(t << 1, l, ((l + r) >> 1), x, y, v);
if (((l + r) >> 1) < y) update(t << 1 | 1, ((l + r) >> 1) + 1, r, x, y, v);
up(t);
}
node query(int t, int l, int r, int x, int y) {
if (x <= l && r <= y) return s[t];
down(t, l, r);
node ans;
for (register int i = 0; i <= P; i++) ans.b[i] = 0;
if (x <= ((l + r) >> 1)) ans = query(t << 1, l, ((l + r) >> 1), x, y);
if (((l + r) >> 1) < y)
ans = ans + query(t << 1 | 1, ((l + r) >> 1) + 1, r, x, y);
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &P), P = 100 / P - 1;
build(1, 1, n);
for (; m--;) {
scanf("%d%d%d", &op, &l, &r);
if (op == 1)
scanf("%d", &x), update(1, 1, n, l, r, x);
else {
t = query(1, 1, n, l, r);
printf("%d ", P + 1);
for (register int i = 0; i <= P; i++) printf("%d ", t.a[i]);
puts("");
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int ara[1003][1003], row1[1003][1003], row2[1003][1003], col1[1003][1003],
col2[1003][1003], c[1003];
pair<int, int> b[1003];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &ara[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) b[j] = {ara[i][j], j};
sort(b, b + m);
int cnt = 0;
for (int j = 0; j < m; j++) {
int s = j;
cnt++;
while (j < m && b[j].first == b[s].first) c[b[j].second] = cnt, j++;
j--;
}
for (int j = 0; j < m; j++) row1[i][j] = c[j], row2[i][j] = cnt - c[j];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) b[j] = {ara[j][i], j};
sort(b, b + n);
int cnt = 0;
for (int j = 0; j < n; j++) {
int s = j;
cnt++;
while (j < n && b[j].first == b[s].first) c[b[j].second] = cnt, j++;
j--;
}
for (int j = 0; j < n; j++) col1[j][i] = c[j], col2[j][i] = cnt - c[j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
printf("%d ", max(row1[i][j], col1[i][j]) + max(row2[i][j], col2[i][j]));
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int size1 = 8e5;
const long long INF = 1e18;
const int INF1 = 1e9;
const double eps = 1e-5;
const long long mod = 1e9 + 7;
vector<vector<int> > graph(size1);
vector<vector<long long> > graph1(size1);
static int maxder[size1], minder[size1], d[size1], v[size1], u[size1], w[size1],
tin[size1], tout[size1];
static bool used[size1];
static long long ras[size1];
static long long tree[size1], tree1[size1], tree2[size1], tree3[size1],
w1[size1];
int num = 1;
int time1 = 0;
void dfs(int v) {
used[v] = true;
minder[v] = INF1;
for (int i = 0; i < graph[v].size(); i++) {
if (!used[graph[v][i]]) {
dfs(graph[v][i]);
minder[v] = min(minder[v], minder[graph[v][i]]);
}
}
maxder[v] = num;
num++;
minder[v] = min(minder[v], maxder[v]);
}
void dfs1(int v, long long ras1, int depth) {
time1++;
used[v] = true;
ras[maxder[v]] = ras1;
d[v] = depth;
tin[v] = time1;
for (int i = 0; i < graph[v].size(); i++) {
if (!used[graph[v][i]]) {
dfs1(graph[v][i], ras1 + graph1[v][i], depth + 1);
}
}
time1++;
tout[v] = time1;
}
void build_tree(int tl, int tr, int pos) {
if (tl == tr) {
tree[pos] = ras[tl];
} else {
int tm = (tl + tr) / 2;
build_tree(tl, tm, pos * 2);
build_tree(tm + 1, tr, pos * 2 + 1);
tree[pos] = tree[pos * 2] + tree[pos * 2 + 1];
}
}
void prib(int tl, int tr, int pos, int l, int r, long long x) {
if (l <= tl && tr <= r) {
tree1[pos] += x;
} else {
int tm = (tl + tr) / 2;
if (max(tl, l) <= min(tm, r)) {
prib(tl, tm, pos * 2, l, r, x);
}
if (max(tm + 1, l) <= min(tr, r)) {
prib(tm + 1, tr, pos * 2 + 1, l, r, x);
}
tree[pos] = tree[pos * 2] + tree[pos * 2 + 1] +
tree1[pos * 2] * (tm - tl + 1) + tree1[pos * 2 + 1] * (tr - tm);
}
}
long long zn(int tl, int tr, int pos, int pos1, long long add) {
if (tl == pos1 && tr == pos1) {
return add + tree[pos] + tree1[pos];
} else {
int tm = (tl + tr) / 2;
if (tl <= pos1 && pos1 <= tm) {
return zn(tl, tm, pos * 2, pos1, add + tree1[pos]);
} else {
return zn(tm + 1, tr, pos * 2 + 1, pos1, add + tree1[pos]);
}
}
}
void build_tree1(int tl, int tr, int pos) {
if (tl == tr) {
tree2[pos] = ras[tl] + w1[tl];
} else {
int tm = (tl + tr) / 2;
build_tree1(tl, tm, pos * 2);
build_tree1(tm + 1, tr, pos * 2 + 1);
tree2[pos] = min(tree2[pos * 2], tree2[pos * 2 + 1]);
}
}
void upd2(int tl, int tr, int pos, int l, int r, long long x) {
if (l <= tl && tr <= r) {
tree3[pos] += x;
} else {
int tm = (tl + tr) / 2;
if (max(tl, l) <= min(tm, r)) {
upd2(tl, tm, pos * 2, l, r, x);
}
if (max(tm + 1, l) <= min(tr, r)) {
upd2(tm + 1, tr, pos * 2 + 1, l, r, x);
}
tree2[pos] = min(tree2[pos * 2] + tree3[pos * 2],
tree2[pos * 2 + 1] + tree3[pos * 2 + 1]);
}
}
long long zn1(int tl, int tr, int pos, int l, int r, long long add) {
if (l <= tl && tr <= r) {
return add + tree3[pos] + tree2[pos];
} else {
int tm = (tl + tr) / 2;
long long ans = INF;
if (max(l, tl) <= min(r, tm)) {
ans = min(ans, zn1(tl, tm, pos * 2, l, r, add + tree3[pos]));
}
if (max(tm + 1, l) <= min(tr, r)) {
ans = min(ans, zn1(tm + 1, tr, pos * 2 + 1, l, r, add + tree3[pos]));
}
return ans;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q, i;
cin >> n >> q;
for (i = 1; i <= n - 1; i++) {
cin >> v[i] >> u[i] >> w[i];
graph[v[i]].push_back(u[i]);
graph[u[i]].push_back(v[i]);
graph1[v[i]].push_back(w[i]);
graph1[u[i]].push_back(w[i]);
}
dfs(1);
for (i = n; i <= 2 * n - 2; i++) {
cin >> v[i] >> u[i] >> w[i];
w1[maxder[v[i]]] = w[i];
}
memset(used, false, sizeof used);
dfs1(1, 0, 0);
build_tree(1, n, 1);
build_tree1(1, n, 1);
for (i = 1; i <= q; i++) {
int t, a, b;
cin >> t >> a >> b;
if (t == 1) {
if (a >= n) {
upd2(1, n, 1, maxder[v[a]], maxder[v[a]], b - w1[maxder[v[a]]]);
w1[maxder[v[a]]] = b;
} else {
int v1 = 0;
if (d[v[a]] > d[u[a]]) {
v1 = v[a];
} else {
v1 = u[a];
}
prib(1, n, 1, minder[v1], maxder[v1], b - w[a]);
upd2(1, n, 1, minder[v1], maxder[v1], b - w[a]);
w[a] = b;
}
} else {
long long res = INF;
if (max(tin[a], tin[b]) <= min(tout[a], tout[b]) && d[a] <= d[b]) {
res = min(res, zn(1, n, 1, maxder[b], 0) - zn(1, n, 1, maxder[a], 0));
}
res = min(res, zn1(1, n, 1, minder[a], maxder[a], 0) -
zn(1, n, 1, maxder[a], 0) + zn(1, n, 1, maxder[b], 0));
cout << res << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x, y;
};
Node d[1010];
int father[1010], rnk[1010];
int nn;
int Find(int r) {
return father[r] = (father[r] == r) ? father[r] : Find(father[r]);
}
void Merge(int x, int y) {
int fx = Find(x), fy = Find(y);
if (fx != fy) {
if (rnk[fx] >= rnk[fy]) {
father[fy] = fx;
if (rnk[fx] == rnk[fy]) rnk[fx] += rnk[fy];
} else {
father[fx] = fy;
}
}
}
int main() {
int i, j;
while (~scanf("%d", &nn)) {
for (i = 1; i <= nn; i++) {
father[i] = i;
rnk[i] = 1;
}
for (i = 1; i <= nn; i++) {
scanf("%d%d", &d[i].x, &d[i].y);
for (j = 1; j < i; j++) {
if (d[i].x == d[j].x || d[i].y == d[j].y) {
Merge(i, j);
}
}
}
int ans = 0;
for (i = 1; i <= nn; i++) {
int r = Find(i);
if (r == i) ans++;
}
printf("%d\n", ans - 1);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> rpt[2 * 20005];
int first[20005], second[20005], ans;
int n, m, p, ox, oy, dp[2][20005], ep[2][20005];
int val(int a, int b) {
int res = first[a] + second[b];
return res >= p ? res - p : res;
}
void go(int sx, int sy, int fx, int fy) {
int d = fx + fy - sx - sy;
int mid = d >> 1, up, dw;
int u = 0, v = 1;
dp[0][0] = 0;
for (int i = 1; i <= mid; i++) {
if (i == mid)
for (int j = 0; j <= i; j++) ep[v][j] = j;
up = min(i, m - sy - 1);
dw = max(0, sx + i - n + 1);
if (dw == 0) dw++, dp[v][0] = dp[u][0] + val(sx + i, sy);
if (up == i) up--, dp[v][i] = dp[u][i - 1] + val(sx, sy + i);
for (int j = dw; j <= up; j++)
dp[v][j] = max(dp[u][j], dp[u][j - 1]) + val(sx + i - j, sy + j);
swap(u, v);
}
for (int i = 0; i <= mid; i++) ep[u][i] = i;
for (int i = mid + 1; i <= d; i++) {
up = min(i, m - sy - 1);
dw = max(0, sx + i - n + 1);
if (dw == 0)
dw++, dp[v][0] = dp[u][0] + val(sx + i, sy), ep[v][0] = ep[u][0];
if (up == i)
up--, dp[v][i] = dp[u][i - 1] + val(sx, sy + i), ep[v][i] = ep[u][i - 1];
for (int j = dw; j <= up; j++) {
dp[v][j] = max(dp[u][j], dp[u][j - 1]) + val(sx + i - j, sy + j);
ep[v][j] = dp[u][j] > dp[u][j - 1] ? ep[u][j] : ep[u][j - 1];
}
swap(u, v);
}
int k = ep[u][fy - sy];
oy = sy + k;
ox = sx + sy + mid - oy;
if (!sx && !sy && fx == n - 1 && fy == m - 1) ans = dp[u][m - 1];
}
void func(int sx, int sy, int fx, int fy) {
int d = fx + fy - sx - sy;
if (d <= 1) return;
int mid = d >> 1;
go(sx, sy, fx, fy);
rpt[sx + sy + mid] = pair<int, int>(ox, oy);
func(sx, sy, ox, oy);
func(ox, oy, fx, fy);
return;
}
int main() {
scanf("%d %d %d", &n, &m, &p);
for (int i = 0; i < n; i++) scanf("%d", &first[i]), first[i] %= p;
for (int i = 0; i < m; i++) scanf("%d", &second[i]), second[i] %= p;
rpt[0] = pair<int, int>(0, 0);
rpt[m + n - 2] = pair<int, int>(n - 1, m - 1);
func(0, 0, n - 1, m - 1);
printf("%d\n", ans + val(0, 0));
for (int i = 1; i <= m + n - 2; i++) {
if (rpt[i].first == rpt[i - 1].first + 1)
putchar('C');
else
putchar('S');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int TM;
struct Data {
long long mx, lazy;
Data() { mx = lazy = 0LL; }
};
Data nod[4 * 200005];
int N = 200005 - 3;
void update_node(int cur, int L, int R, long long val) {
nod[cur].mx += val;
nod[cur].lazy += val;
}
void lazy_update(int cur, int L, int R) {
update_node((2 * cur), L, ((L + R) >> 1), nod[cur].lazy);
update_node((2 * cur + 1), ((L + R) >> 1) + 1, R, nod[cur].lazy);
nod[cur].lazy = 0;
}
void update(int st, int ed, long long val, int cur = 1, int L = 1, int R = N) {
if (st > R || ed < L) return;
if (st <= L && ed >= R) return update_node(cur, L, R, val);
if (nod[cur].lazy) lazy_update(cur, L, R);
update(st, ed, val, (2 * cur), L, ((L + R) >> 1));
update(st, ed, val, (2 * cur + 1), ((L + R) >> 1) + 1, R);
nod[cur].mx = max(nod[(2 * cur)].mx, nod[(2 * cur + 1)].mx);
}
int findPos(int cur = 1, int L = 1, int R = N) {
if (L == R) return nod[cur].mx == 0 ? L : -1;
if (nod[cur].lazy) lazy_update(cur, L, R);
if (nod[(2 * cur)].mx >= 0) {
int ans = findPos((2 * cur), L, ((L + R) >> 1));
if (ans != -1) return ans;
}
if (nod[(2 * cur + 1)].mx >= 0) {
int ans = findPos((2 * cur + 1), ((L + R) >> 1) + 1, R);
if (ans != -1) return ans;
}
return -1;
}
int main() {
int q, arr[200005], el;
scanf("%d", &N);
scanf("%d", &q);
long long tot = 0;
for (int i = 1; i <= N; i++) {
scanf("%d", &el);
update(i, i, (long long)el - tot);
tot += el;
arr[i] = el;
}
while (q--) {
int in;
long long val, cur, ext;
scanf("%d", &in);
scanf("%lld", &val);
cur = arr[in];
arr[in] = val;
ext = val - cur;
update(in, in, ext);
if (in < N) update(in + 1, N, -1 * ext);
printf("%d\n", findPos());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int* arr = new int[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
if (arr[i] % m == 0) {
arr[i] /= m;
} else {
arr[i] = arr[i] / m + 1;
}
}
int maxi = -1, maxv = INT_MIN;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] > maxv) {
maxv = arr[i];
maxi = i;
}
}
cout << maxi + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000008;
const long long M = 1000000000000ll;
vector<pair<long long, long long> > a[N], b[N];
priority_queue<pair<long long, pair<long long, long long> > > d;
pair<long long, pair<long long, long long> > dp;
long long n, m, w, ans, cl[N], cr[N], c[N];
long long maxx(long long x, long long y) {
if (x > y) y = x;
return y;
}
long long minx(long long x, long long y) {
if (x < y) y = x;
return y;
}
int main(void) {
std::ios::sync_with_stdio(false);
long long i, j, k, p1, p2, st, ed, now;
cin >> n >> m >> w;
for (i = 1; i <= m; i++) {
cin >> p1 >> j >> k >> p2;
if (j)
a[j].push_back(make_pair(p1, p2));
else
b[k].push_back(make_pair(p1, p2));
}
for (i = 1; i <= n; i++) {
if (a[i].empty() || b[i].empty()) {
cout << -1;
return 0;
}
sort(a[i].begin(), a[i].end());
sort(b[i].begin(), b[i].end());
}
st = a[1][0].first;
for (i = 2; i <= n; i++) st = maxx(st, a[i][0].first);
ed = b[1][b[1].size() - 1].first;
for (i = 2; i <= n; i++) ed = minx(ed, b[i][b[i].size() - 1].first);
while (!d.empty()) d.pop();
for (i = 1; i <= n; i++) c[i] = M;
now = n * M;
for (i = 1; i <= n; i++) {
for (j = 0; j < (int)a[i].size() && a[i][j].first <= st; j++)
if (a[i][j].second < c[i]) {
now -= c[i] - a[i][j].second;
c[i] = a[i][j].second;
}
if (j < (int)a[i].size())
d.push(make_pair(-a[i][j].first, make_pair(i, j)));
}
cl[st] = now;
for (i = st + 1; i <= ed; i++) {
while (!d.empty() && -d.top().first <= i) {
dp = d.top();
d.pop();
if (a[dp.second.first][dp.second.second].second < c[dp.second.first]) {
now -= c[dp.second.first] - a[dp.second.first][dp.second.second].second;
c[dp.second.first] = a[dp.second.first][dp.second.second].second;
}
if (dp.second.second + 1 < (int)a[dp.second.first].size())
d.push(make_pair(-a[dp.second.first][dp.second.second + 1].first,
make_pair(dp.second.first, dp.second.second + 1)));
}
cl[i] = now;
}
while (!d.empty()) d.pop();
for (i = 1; i <= n; i++) c[i] = M;
now = n * M;
for (i = 1; i <= n; i++) {
for (j = (int)b[i].size() - 1; j >= 0 && b[i][j].first >= ed; j--)
if (b[i][j].second < c[i]) {
now -= c[i] - b[i][j].second;
c[i] = b[i][j].second;
}
if (j >= 0) d.push(make_pair(b[i][j].first, make_pair(i, j)));
}
cr[ed] = now;
for (i = ed - 1; i >= st; i--) {
while (!d.empty() && d.top().first >= i) {
dp = d.top();
d.pop();
if (b[dp.second.first][dp.second.second].second < c[dp.second.first]) {
now -= c[dp.second.first] - b[dp.second.first][dp.second.second].second;
c[dp.second.first] = b[dp.second.first][dp.second.second].second;
}
if (dp.second.second - 1 >= 0)
d.push(make_pair(b[dp.second.first][dp.second.second - 1].first,
make_pair(dp.second.first, dp.second.second - 1)));
}
cr[i] = now;
}
k = M;
for (i = st; i + w + 1 <= ed; i++) k = minx(k, cl[i] + cr[i + w + 1]);
if (k < M)
cout << k;
else
cout << -1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
const int M = 1e9 + 7;
int n, a[N];
int q, w;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] == 2) {
q++;
} else {
w++;
}
}
if (w == 0) {
cout << 0 << "\n";
exit(0);
}
if (q == 0) {
cout << w / 3 << "\n";
exit(0);
}
int ans = min(w, q);
if (ans == w) {
cout << ans << "\n";
exit(0);
}
int z = w - q;
cout << z / 3 + q << "\n";
exit(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> solve(vector<int> arr, int n, vector<int> q, int m) {
vector<int> comparisons(n + 1);
int comp = 0;
for (int i = 0; i < n; i++) comparisons[arr[i]] = ++comp;
long long a, b;
a = b = 0;
for (int i = 0; i < m; i++) {
a += comparisons[q[i]];
b += n - comparisons[q[i]] + 1;
}
return make_pair(a, b);
}
int main() {
int n, m;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
cin >> m;
vector<int> q(m);
for (int i = 0; i < m; i++) cin >> q[i];
auto res = solve(arr, n, q, m);
cout << res.first << " " << res.second << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long int
#define vll vector<long long int>
using namespace std;
ll MOD = 1e9 + 7;
//for flushing use fflush(stdout) after printing any output or use endl
//for interactive remove buffered input/output logic
void solver()
{
ll a,b;
cin>>a>>b;
if(b==1){
cout<<"NO\n";
return ;
}
cout<<"YES\n";
cout<<a<<" "<<a*b<<" "<<a*(b+1)<<"\n";
}
int main()
{
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
ll t = 1;
cin>>t;
while (t--)
{
solver();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tests = 1;
cin >> tests;
while (tests--) {
int n;
cin >> n;
long long prod = n;
prod *= (n + 1);
long long sum = prod / 2;
long long temp = 1;
long long ev = 0;
while (temp <= n) {
ev += temp;
if (temp * 2 > n) break;
temp *= 2;
}
long long po = 2 * ev;
long long newsum = sum - po;
cout << newsum << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 9;
const long long mod = 1e9 + 7;
vector<int> g[maxn], comp[maxn];
int par[maxn], vis[maxn];
bool f;
int root(int v) { return ((par[v] + 1) ? par[v] = root(par[v]) : v); }
void merge(int v, int u) {
v = root(v);
u = root(u);
if (v == u) return;
par[v] = u;
}
void dfs(int v) {
vis[v] = 1;
for (auto u : g[v]) {
if (vis[u] == 1) f = true;
if (vis[u] == 0) dfs(u);
}
vis[v] = 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(par, -1, sizeof par);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
--v;
--u;
merge(v, u);
g[v].push_back(u);
}
for (int i = 0; i < n; i++) comp[root(i)].push_back(i);
int res = 0;
for (int i = 0; i < n; i++) {
if (comp[i].size() == 0) continue;
f = false;
for (auto u : comp[i])
if (!vis[u]) dfs(u);
res += comp[i].size() - ((f) ? 0 : 1);
}
cout << res << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, q, x, y, k;
int S[7][100005 * 4], lazy[7][100005 * 4], pre[7][100005];
int C[10][10];
char c;
int power(int x, int p, int bas, int son) {
return 1ll * x * (pre[p][son] - pre[p][bas - 1] + 1000000007) % 1000000007;
}
void push(int node, int bas, int son, int po) {
if (~lazy[po][node] && bas != son) {
lazy[po][node * 2] = lazy[po][node * 2 + 1] = lazy[po][node];
S[po][node * 2] = power(lazy[po][node], po, bas, ((bas + son) / 2));
S[po][node * 2 + 1] = power(lazy[po][node], po, ((bas + son) / 2) + 1, son);
}
lazy[po][node] = -1;
}
int get(int node, int bas, int son, int x, int y, int po) {
if (bas > y || son < x) return 0;
if (bas >= x && son <= y) return S[po][node];
push(node, bas, son, po);
return (get(node * 2, bas, ((bas + son) / 2), x, y, po) +
get(node * 2 + 1, ((bas + son) / 2) + 1, son, x, y, po)) %
1000000007;
}
void up(int node, int bas, int son, int x, int y, int val, int po) {
if (bas > y || son < x) return;
if (bas >= x && son <= y) {
S[po][node] = power(val, po, bas, son);
lazy[po][node] = val;
return;
}
push(node, bas, son, po);
up(node * 2, bas, ((bas + son) / 2), x, y, val, po);
up(node * 2 + 1, ((bas + son) / 2) + 1, son, x, y, val, po);
S[po][node] = (S[po][node * 2] + S[po][node * 2 + 1]) % 1000000007;
}
void solve(int x, int y, int k) {
int val = -x + 1;
int now = 1;
int res = 0;
for (int i = k; i >= 0; i--) {
res = (1ll * res +
1ll * get(1, 1, n, x, y, i) * now % 1000000007 * C[k][k - i] %
1000000007 +
3ll * 1000000007) %
1000000007;
now = 1ll * now * val % 1000000007;
}
printf("%d\n", res);
}
int main() {
for (int i = 0; i <= 5; i++) memset(lazy[i], -1, sizeof(lazy[i]));
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
for (int p = 0, now = 1; p <= 5; p++, now = 1ll * now * i % 1000000007) {
pre[p][i] = (pre[p][i - 1] + now) % 1000000007;
}
}
C[0][0] = 1;
for (int i = 1; i <= 6; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
for (int j = 0; j <= 5; j++) {
up(1, 1, n, i, i, x, j);
}
}
while (q--) {
scanf(" %c %d %d %d", &c, &x, &y, &k);
if (c == '?') {
solve(x, y, k);
} else {
for (int i = 0; i <= 5; i++) {
up(1, 1, n, x, y, k, i);
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int n, k;
pair<long long, int> X[300005];
long long x[300005];
long long sumL[300005], sumR[300005];
void solve() {
sort(X, X + n);
for (int i = 0; i < n; i++) {
x[i] = X[i].first;
}
sumR[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (i >= n - k) {
sumR[i] = sumR[i + 1] + (n - 1 - i) * (x[i + 1] - x[i]);
} else {
sumR[i] =
sumR[i + 1] - (x[i + k] - x[i + 1]) + (k - 1) * (x[i + 1] - x[i]);
}
}
sumL[0] = 0;
for (int i = 1; i < n; i++) {
if (i < k) {
sumL[i] = sumL[i - 1] + i * (x[i] - x[i - 1]);
} else {
sumL[i] =
sumL[i - 1] - (x[i - 1] - x[i - k]) + (k - 1) * (x[i] - x[i - 1]);
}
}
int id = 0;
long long ans = 0;
for (int i = 0; i < k; i++) {
ans += sumL[i];
}
long long curr = ans;
for (int i = k; i < n; i++) {
curr += sumL[i];
curr -= sumR[i - k];
if (curr < ans) {
id = i - k + 1;
ans = curr;
}
}
for (int i = id; i < id + k; i++) {
cout << X[i].second << ' ';
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> X[i].first;
X[i].second = i + 1;
}
cin >> k;
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string pat;
int n;
int bal;
int main() {
cin >> n;
cin >> pat;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == pat[0] && s[1] == pat[1] && s[2] == pat[2]) bal++;
if (s[5] == pat[0] && s[6] == pat[1] && s[7] == pat[2]) bal--;
}
if (bal)
cout << "contest\n";
else
cout << "home\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> basis, b;
int v[200005], used[2000005];
void add(int u) {
int x = u;
for (auto &v : basis) u = min(u, u ^ v);
if (u) {
basis.push_back(u);
b.push_back(x);
for (int i = basis.size() - 1; i > 0; i--)
if (basis[i] > basis[i - 1]) swap(basis[i], basis[i - 1]);
}
}
int size = 0;
vector<int> ans;
void dfs(int at) {
used[at] = 1;
ans.push_back(at);
if (ans.size() == (1 << size)) return;
for (auto &c : b) {
if (used[c ^ at] == 0) {
dfs(c ^ at);
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
for (int x = 20; x >= 0; x--) {
basis.clear();
b.clear();
for (int i = 0; i < n; i++) {
if (v[i] < (1 << x)) add(v[i]);
}
if (basis.size() < x) continue;
size = x;
printf("%d\n", x);
dfs(0);
for (auto &c : ans) {
printf("%d ", c);
}
puts("");
return 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sum;
long long val;
long long color;
};
node T[400040];
int n, m;
void built(int node, int l, int r) {
if (l == r) {
T[node].color = l;
T[node].sum = 0;
T[node].val = 0;
return;
}
int mid = (l + r) >> 1;
built(node << 1, l, mid);
built(node << 1 | 1, mid + 1, r);
}
void update(int node, int l, int r, int u, int v, int col) {
if ((r < u) || (l > v)) return;
if ((u <= l) && (r <= v) && (T[node].color)) {
T[node].sum += abs(col - T[node].color) * (r - l + 1);
T[node].val += abs(col - T[node].color);
T[node].color = col;
return;
}
int mid = (l + r) >> 1;
if (T[node].val > 0) {
T[node << 1].val += T[node].val;
T[node << 1].sum += T[node].val * (mid - l + 1);
T[node << 1 | 1].val += T[node].val;
T[node << 1 | 1].sum += T[node].val * (r - mid);
T[node].val = 0;
T[node << 1].color = T[node].color;
T[node << 1 | 1].color = T[node].color;
}
T[node].color = 0;
update(node << 1, l, mid, u, v, col);
update(node << 1 | 1, mid + 1, r, u, v, col);
T[node].sum = T[node << 1].sum + T[node << 1 | 1].sum;
if (T[node << 1].color == T[node << 1 | 1].color)
T[node].color = T[node << 1].color;
}
long long query(int node, int l, int r, int u, int v) {
long long res = 0;
if ((v < l) || (r < u)) return 0;
if ((u <= l) && (r <= v)) {
return T[node].sum;
}
int mid = (l + r) >> 1;
if (T[node].val > 0) {
T[node << 1].val += T[node].val;
T[node << 1].sum += T[node].val * (mid - l + 1);
T[node << 1 | 1].val += T[node].val;
T[node << 1 | 1].sum += T[node].val * (r - mid);
T[node].val = 0;
T[node << 1].color = T[node].color;
T[node << 1 | 1].color = T[node].color;
}
res += query(node << 1, l, mid, u, v);
res += query(node << 1 | 1, mid + 1, r, u, v);
T[node].sum = T[node << 1].sum + T[node << 1 | 1].sum;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
built(1, 1, n);
int u, v, col, x;
for (int i = 1; i <= m; i++) {
cin >> x;
if (x == 1) {
cin >> u >> v >> col;
update(1, 1, n, u, v, col);
} else if (x == 2) {
cin >> u >> v;
cout << query(1, 1, n, u, v) << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int l1, r1;
cin >> l1 >> r1;
long long int val1 = l1;
if ((r1 / 2) + 1 > l1) {
val1 = (r1 / 2) + 1;
}
cout << r1 % val1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long mod = 1e9 + 7;
long long dp[105][105][70];
long long m, n;
long long ddp[105];
using namespace std;
void nhan() {
for (long long i = 1; i <= 60; i++) {
for (long long j = 1; j <= m; j++) {
for (long long k = 1; k <= m; k++) {
for (long long l = 1; l <= m; l++) {
dp[j][k][i] += dp[j][l][i - 1] * dp[l][k][i - 1];
dp[j][k][i] %= mod;
}
}
}
}
}
void mul(long long bac) {
long long tdp[105];
memset(tdp, 0, sizeof(tdp));
for (long long i = 1; i <= m; i++) {
for (long long j = 1; j <= m; j++) {
tdp[i] += dp[j][i][bac] * ddp[j];
tdp[i] %= mod;
}
}
for (long long i = 1; i <= m; i++) {
ddp[i] = tdp[i];
}
}
signed main() {
memset(dp, 0, sizeof(dp));
cin >> n >> m;
if (n < m) {
cout << 1;
return 0;
}
n -= m;
for (long long i = 1; i < m; i++) {
dp[i + 1][i][0] = 1;
}
dp[m][m][0] = 1;
dp[1][m][0] = 1;
nhan();
for (long long i = 1; i <= m; i++) {
ddp[i] = 1;
}
ddp[m] = 2;
long long temp = 0;
for (long long i = 1; i <= n; i *= 2) {
long long check = n & i;
if (check) {
mul(temp);
}
temp++;
if (n / i < 2) {
break;
}
}
cout << ddp[m];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool exitInput = false;
int ntest = 1, itest = 1;
const char* directions[4] = {"NE", "SE", "SW", "NW"};
const long long Mod = 1000000000LL + 7;
const int maxn = 200000 + 5;
const int maxv = 500000 + 5;
const int maxe = 600000 + 5;
const int root = 1;
int n, a[maxn], LogN, rmq[maxn][18];
int ft[maxn];
void update(int x, int val) {
while (x > 0) {
ft[x] = max(ft[x], val);
x -= x & (-x);
}
}
int get(int x) {
int res = 0;
while (x < maxn) {
res = max(res, ft[x]);
x += x & -x;
}
return res;
}
void build_rmq() {
int i, j, k;
for (LogN = 1; (1 << LogN) <= n; ++LogN)
;
--LogN;
for (i = 1; i <= n; ++i) rmq[i][0] = a[i];
for (j = 1; j <= LogN; ++j) {
for (i = 1; i + (1 << j) - 1 <= n; ++i) {
k = i + (1 << (j - 1));
rmq[i][j] = min(rmq[i][j - 1], rmq[k][j - 1]);
}
}
}
int get_min(int i, int j) {
int len = j - i + 1;
int k;
for (k = 1; (1 << k) <= len; ++k)
;
--k;
return min(rmq[i][k], rmq[j - (1 << k) + 1][k]);
}
int get_left(int idx) {
int lo = 1, hi = idx, mid, res = idx;
int k;
while (lo <= hi) {
mid = (lo + hi) >> 1;
k = get_min(mid, idx);
if (k >= a[idx]) {
res = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
return res;
}
int get_right(int idx) {
int lo = idx, hi = n, mid, res = idx;
int k;
while (lo <= hi) {
mid = (lo + hi) >> 1;
k = get_min(idx, mid);
if (k >= a[idx]) {
res = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
return res;
}
int main() {
int i, j, k;
int x, res;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
build_rmq();
int L, R;
for (i = 1; i <= n; ++i) {
L = get_left(i);
R = get_right(i);
update(R - L + 1, a[i]);
}
for (i = 1; i <= n; ++i) {
k = get(i);
printf("%d ", k);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<string> s;
int main() {
int n, m;
cin >> n >> m;
string tmp;
for (int i = 0; i < n; i++) {
cin >> tmp;
s.insert(tmp);
}
int match = 0;
for (int j = 0; j < m; j++) {
cin >> tmp;
if (s.find(tmp) != s.end()) {
match++;
}
}
n -= (match) / 2;
m -= (match) / 2;
if (match % 2 == 1) {
n++;
}
if (n > m) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#pragma comment(linker, "/STACK:512000000")
using namespace std;
using li = long long;
using ld = long double;
void solve(bool);
void precalc();
clock_t start;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
precalc();
while (t--) {
solve(true);
}
cout.flush();
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template <typename T>
void relax_min(T& cur, T val) {
cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
cur = max(cur, val);
}
void precalc() {}
const int LBase = 4;
const int Base = 10000;
struct BigInt {
vector<int> a;
BigInt() {}
BigInt(string s) {
reverse(s.begin(), s.end());
for (int i = 0; i < s.length(); i += LBase) {
int en = min((int)s.length(), i + LBase);
int cur = 0;
for (int j = en - 1; j >= i; --j) {
cur = cur * 10 + s[j] - '0';
}
a.push_back(cur);
}
}
void norm() {
int carry = 0;
for (int i = 0; i < a.size() || carry > 0; ++i) {
if (i == a.size()) {
a.push_back(0);
}
a[i] += carry;
carry = a[i] / Base;
a[i] -= carry * Base;
}
while (a.size() > 0 && a.back() == 0) {
a.pop_back();
}
}
bool operator<(const BigInt& ot) const {
if (a.size() != ot.a.size()) {
return a.size() < ot.a.size();
}
for (int i = 0; i < a.size(); ++i) {
int q = a[a.size() - 1 - i], w = ot.a[a.size() - 1 - i];
if (q != w) {
return q < w;
}
}
return false;
}
BigInt operator*(int c) const {
BigInt res = *this;
for (int& x : res.a) {
x *= c;
}
res.norm();
return res;
}
};
const int L = 20;
const int N = 1 << L;
bool fft_initialized = false;
using base = complex<double>;
using Poly = vector<double>;
const double pi = acosl(-1);
base angles[N * 2];
int bitrev[N];
const double eps = 1e-7;
inline bool eq(double x, double y) { return abs(x - y) < eps; }
void fft_init() {
for (int n = 1; n <= N; n *= 2) {
auto w = angles + n / 2;
for (int i = 0; i < n / 2; ++i) {
w[i] = polar(1.0, 2 * pi * i / n);
}
}
}
template <bool inverse>
void fft(base* y, base* x, int n, int k = 1) {
if (n == 1) {
*y = *x;
} else {
n /= 2;
auto w = angles + n;
fft<inverse>(y, x, n, k * 2);
fft<inverse>(y + n, x + k, n, k * 2);
for (int i = 0; i < n; ++i) {
auto q = y[i + n] * (inverse ? conj(w[i]) : w[i]);
y[i + n] = y[i] - q;
y[i] = y[i] + q;
}
}
}
void fft(vector<base>& a, bool inverse = false) {
int n = (int)a.size();
static base b[1 << 21];
for (int i = 0; i < n; ++i) {
b[i] = a[i];
}
if (inverse) {
fft<true>(a.data(), b, n);
for (auto& x : a) {
x /= n;
}
} else {
fft<false>(a.data(), b, n);
}
}
Poly multiply(Poly a, Poly b) {
int n = 1;
while (n < (int)a.size() || n < (int)b.size()) {
n *= 2;
}
vector<base> ar(n + n), br(n + n);
for (int i = 0; i < (int)a.size(); ++i) {
ar[i] = a[i];
}
for (int i = 0; i < (int)b.size(); ++i) {
br[i] = b[i];
}
fft(ar);
fft(br);
for (int i = 0; i < n + n; ++i) {
ar[i] = ar[i] * br[i];
}
fft(ar, true);
while (!ar.empty() && eq(norm(ar.back()), 0)) {
ar.pop_back();
}
a.resize(ar.size());
for (int i = 0; i < (int)a.size(); ++i) {
a[i] = real(ar[i]);
}
return a;
}
BigInt multiply(const BigInt& a, const BigInt& b) {
vector<double> A(a.a.begin(), a.a.end()), B(b.a.begin(), b.a.end());
auto C = multiply(A, B);
BigInt res;
res.a.resize(C.size());
li carry = 0;
for (int i = 0; i < C.size() || carry; ++i) {
if (i < C.size()) {
carry += (li)round(C[i]);
}
if (i == res.a.size()) {
res.a.push_back(0);
}
res.a[i] = carry % Base;
carry /= Base;
}
res.norm();
return res;
}
BigInt get_power(BigInt cur, int what) {
if (what == 0) {
return BigInt("1");
}
cur = get_power(cur, what / 2);
cur = multiply(cur, cur);
if (what & 1) {
cur = cur * 3;
}
return cur;
}
void solve(bool read) {
string s;
if (read) {
cin >> s;
} else {
s = string(1500000, '9');
for (int i = 1; i < s.length(); ++i) {
s[i] = (char)('0' + rand() % 10);
}
}
if (s == "1") {
cout << 1 << "\n";
return;
}
BigInt num(s);
double log_appr = ((int)s.length() - 1);
log_appr = log_appr * log(10) / log(3);
int b = max((int)(log_appr - 5), 0);
if (b % 2 == 1) --b;
fft_init();
int need_b = b;
BigInt three;
three.a = vector<int>(1, 3);
BigInt res = get_power(three, b);
int ans = (int)1e9;
auto relax = [&](int mult, int a) {
auto cur_res = res * mult;
int cur_ans = 3 * b + a * 2;
while (cur_res < num) {
cur_res = cur_res * 3;
cur_ans += 3;
}
ans = min(ans, cur_ans);
};
relax(1, 0);
relax(2, 1);
relax(4, 2);
cout << ans << "\n";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 10010;
double a[maxN], b[maxN];
int N, L;
double f[maxN], jc[maxN];
bool check(double m) {
for (int i = 1; i <= N; i++) f[i] = 1e9, jc[i] = 0;
for (int i = 1; i <= N; i++) {
for (int x = 0; x <= i - 1; x++) {
double t = sqrt(fabs(a[i] - a[x] - L)) - m * b[i] + f[x];
if (t < f[i]) {
f[i] = t;
jc[i] = x;
}
}
}
return f[N] < 0;
}
int ans[maxN], cnt;
int main() {
scanf("%d%d", &N, &L);
for (int i = 1; i <= N; i++) scanf("%lf%lf", a + i, b + i);
double l = 0, r = 1e9;
while (abs(l - r) > 1e-9) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
int iter = N;
while (jc[iter]) {
ans[++cnt] = iter;
iter = jc[iter];
}
ans[++cnt] = iter;
for (int i = cnt; i >= 1; i--) cout << ans[i] << " ";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
int found;
string s = "+------------------------+";
string r1 = "|#.#.#.#.#.#.#.#.#.#.#.|D|)";
string r2 = "|#.#.#.#.#.#.#.#.#.#.#.|.|";
string r3 = "|#.......................|";
string r4 = "|#.#.#.#.#.#.#.#.#.#.#.|.|)";
for (int i = 1; i <= k; i++) {
found = 0;
for (int j = 1; j <= 21 && !found; j += 2) {
if (r1[j] == '#') {
r1[j] = 'O';
found = 1;
} else if (r2[j] == '#') {
r2[j] = 'O';
found = 1;
} else if (r3[j] == '#') {
r3[j] = 'O';
found = 1;
} else if (r4[j] == '#') {
r4[j] = 'O';
found = 1;
}
}
}
cout << s << endl
<< r1 << endl
<< r2 << endl
<< r3 << endl
<< r4 << endl
<< s << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
int n, m;
vector<int> g[N];
int p[N], nx[N];
bool read() {
if (!(cin >> n >> m)) return false;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].emplace_back((n + v - u) % n);
}
return true;
}
void solve() {
for (int i = 0; i < n; ++i) sort(g[i].begin(), g[i].end());
for (int x = 0; x < n; ++x) {
for (int i = 0; i < n; ++i) {
p[i] = g[i].size();
nx[i] = (i + 1) % n;
}
auto res = 0;
for (int pos = x, T = 0, c = m; c > 0;) {
if (p[pos] > 0) {
res = max(res, T + g[pos][--p[pos]]);
--c;
}
if (p[pos] == 0) {
for (int i = 0; i < n; ++i)
if (nx[(n + pos - i) % n] == pos)
nx[(n + pos - i) % n] = nx[pos];
else
break;
}
T += (n + nx[pos] - pos) % n;
pos = nx[pos];
}
cout << res << ' ';
}
cout << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read()) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int di[] = {0, -1, 0, 1, -1, -1, 1, 1};
const int dj[] = {1, 0, -1, 0, 1, -1, -1, 1};
int main() {
pair<int, int> vet[200];
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &vet[i].first);
vet[i].second = i + 1;
}
sort(vet, vet + n);
for (int i = 0; i < n / 2; i++) {
printf("%d %d\n", vet[i].second, vet[n - i - 1].second);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Solution {
int N, W;
vector<int> A, B;
int Find(const vector<int> s, const vector<int>& s1) {
if (s1.empty()) return s.size() + 1;
vector<int> next(s1.size() + 1);
next[0] = -1;
int k = -1;
for (int i = 0; i < s1.size(); ++i) {
while (k >= 0 && s1[k] != s1[i]) k = next[k];
next[i + 1] = ++k;
}
k = 0;
int answer = 0;
for (int i = 0; i < s.size(); ++i) {
while (k >= 0 && s1[k] != s[i]) k = next[k];
if (++k == s1.size()) {
++answer;
k = next[k];
}
}
return answer;
}
void Solve() {
scanf("%d%d", &N, &W);
A.resize(N);
for (int i = 0; i < N; ++i) scanf("%d", &A[i]);
B.resize(W);
for (int i = 0; i < W; ++i) scanf("%d", &B[i]);
for (int i = 0; i < N - 1; ++i) A[i] = A[i + 1] - A[i];
for (int i = 0; i < W - 1; ++i) B[i] = B[i + 1] - B[i];
A.pop_back();
B.pop_back();
printf("%d\n", Find(A, B));
}
};
int main() {
Solution().Solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100010], a[500010], pre[100010];
bool vis[100010];
int main() {
long long n, x, y;
cin >> n >> x >> y;
string s;
cin >> s;
long long c = 0;
for (long long i = s.length() - 1; i >= s.size() - y; i--) {
if (s[i] != '0') c++;
}
if (s[s.size() - y - 1] != '1') c++;
for (long long i = s.size() - 2 - y; i >= s.size() - x; i--) {
if (s[i] != '0') c++;
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010, M = 3010;
string a[M][2];
string s[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> a[i][0] >> a[i][1];
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m * 2; j++) {
int x = j / 2, y = j % 2;
if (a[x][y] == s[i]) {
if (a[x][y xor 1].size() < a[x][y].size())
s[i] = a[x][y xor 1];
else
break;
}
}
}
for (int i = 0; i < n; i++) cout << s[i] << (i == n - 1 ? "\n" : " ");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[105];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
if (a[1] == a[n / 2 + 1]) {
cout << "Bob" << endl;
} else
cout << "Alice" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
const int MAX = 5000 + 7;
string A[MAX];
int D[MAX][MAX];
int B[MAX];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = (0); i < (n); i++) cin >> A[i];
for (int i = (0); i < (n); i++) {
for (int j = (m)-1; j >= (0); j--) {
D[i][j] = D[i][j + 1];
if (A[i][j] == '1') D[i][j]++;
if (A[i][j] == '0') D[i][j] = 0;
}
}
int ans = 0;
for (int j = (0); j < (m); j++) {
for (int i = (0); i < (n); i++) {
B[i] = D[i][j];
}
sort(B, B + n);
reverse(B, B + n);
for (int i = (0); i < (n); i++) {
ans = max(ans, (i + 1) * B[i]);
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, m, k, a, i, j, o, t, an;
scanf("%d%d%d", &n, &m, &k);
o = 0;
t = 0;
an = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a);
if (a == 1)
o++;
else
t++;
}
if (o > m) {
an = o - m;
m = 0;
} else {
m = m - o;
}
if (t > (k + m)) an = an + (t - (k + m));
printf("%d", an);
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MN = 1e6 + 100;
const ll INF = 1e16;
int N, M, P;
int a[MN];
void out(vector<ll>& x) {
for (int i = 0; i < x.size(); i++)
printf("%lld%c", x[i], " \n"[i + 1 == x.size()]);
}
struct DAT {
public:
ll s;
vector<ll> f;
DAT() {
s = 0LL;
f.clear();
}
DAT(int v) {
s = static_cast<ll>(v);
f = {static_cast<ll>(P) - v};
}
DAT(const DAT& A, const DAT& B) {
s = A.s + B.s;
const vector<ll>&a = A.f, &b = B.f;
vector<ll> e(0);
for (int i = 0; i < a.size(); i++)
e.push_back(A.s + a[i] - static_cast<ll>(i + 1) * P);
int x = 0, y = 0;
ll da = -INF, db = -A.s;
for (int i = 0; i < a.size() + b.size(); i++)
if (y != b.size() &&
(x == a.size() || (a[x] + (da > e[x] ? da - e[x] : 0LL)) > b[y] + db))
f.push_back(b[y] + db), da = b[y++];
else
f.push_back(a[x] + (da > e[x] ? da - e[x] : 0LL)), db += P, x++;
}
ll operator()(const ll& x) const {
return x + s -
static_cast<ll>(P) *
(upper_bound(f.begin(), f.end(), x) - f.begin());
}
};
DAT v[MN * 4];
void build(int n, int l, int r) {
if (r - l > 1) {
int m = l + (r - l >> 1);
build(n << 1, l, m), build(n << 1 | 1, m, r);
v[n] = {v[n << 1], v[n << 1 | 1]};
} else
v[n] = {a[l]};
}
ll qry(int n, int l, int r, int ql, int qr, ll x) {
if (ql <= l && r <= qr) return v[n](x);
int m = l + (r - l >> 1);
if (ql < m) x = qry(n << 1, l, m, ql, qr, x);
if (m < qr) x = qry(n << 1 | 1, m, r, ql, qr, x);
return x;
}
int main(void) {
scanf("%d%d%d", &N, &M, &P);
for (int i = 0; i < N; i++) scanf("%d", a + i);
build(1, 0, N);
for (int i = 0, a, b; i < M; i++)
scanf("%d%d", &a, &b), printf("%lld\n", qry(1, 0, N, --a, b, 0LL));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const int N = 205, inf = 1e9 + 5;
long long add(long long x, long long y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
long long sub(long long x, long long y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
long long mult(long long x, long long y) { return (x * y) % MOD; }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int K, a, b;
cin >> K >> a >> b;
string s;
cin >> s;
bool dp[N][N];
int chars_in_kth_line[N][N];
for (int n = a; n <= b; ++n) {
dp[1][n] = true;
chars_in_kth_line[1][n] = n;
}
for (int k = 2; k <= K; ++k) {
for (int n = 1; n <= s.size(); ++n) {
for (int kth_chars = a; kth_chars <= n && kth_chars <= b; ++kth_chars) {
if (dp[k - 1][n - kth_chars] > dp[k][n]) {
dp[k][n] = dp[k - 1][n - kth_chars];
chars_in_kth_line[k][n] = kth_chars;
}
}
}
}
if (dp[K][s.size()]) {
int curr_n = s.size();
vector<string> ans;
for (int k = K; k >= 1; --k) {
ans.push_back(s.substr(curr_n - chars_in_kth_line[k][curr_n]));
s.erase(curr_n - chars_in_kth_line[k][curr_n]);
curr_n -= chars_in_kth_line[k][curr_n];
}
reverse(begin(ans), end(ans));
for (auto x : ans) cout << x << endl;
} else {
cout << "No solution" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 9;
const long long mod = 1e9 + 7;
const int inf = 1e9 + 10;
stack<pair<long long, int> > st;
long long x[maxn], d[maxn], lft[maxn], rgt[maxn], f1[maxn], f2[maxn];
long long seg1[maxn * 4], seg2[maxn * 4];
void build1(int l = 0, int r = maxn, int id = 1) {
if (r - l == 1) {
seg1[id] = rgt[l];
return;
}
int mid = (l + r) >> 1;
build1(l, mid, id * 2);
build1(mid, r, id * 2 + 1);
seg1[id] = max(seg1[id * 2], seg1[id * 2 + 1]);
}
void build2(int l = 0, int r = maxn, int id = 1) {
if (r - l == 1) {
seg2[id] = lft[l];
return;
}
int mid = (l + r) >> 1;
build2(l, mid, id * 2);
build2(mid, r, id * 2 + 1);
seg2[id] = min(seg2[id * 2], seg2[id * 2 + 1]);
}
int get1(int st, int en, long long val, int l = 0, int r = maxn, int id = 1) {
if (st >= r || en <= l || seg1[id] < val) return -1;
int mid = (l + r) >> 1;
if (st <= l && en >= r) {
if (r - l == 1) return l;
if (seg1[id * 2 + 1] >= val) return get1(st, en, val, mid, r, id * 2 + 1);
return get1(st, en, val, l, mid, id * 2);
} else
return max(get1(st, en, val, l, mid, id * 2),
get1(st, en, val, mid, r, id * 2 + 1));
}
int get2(int st, int en, long long val, int l = 0, int r = maxn, int id = 1) {
if (st >= r || en <= l || seg2[id] > val) return 1e9;
int mid = (l + r) >> 1;
if (st <= l && en >= r) {
if (r - l == 1) return l;
if (seg2[id * 2] <= val) return get2(st, en, val, l, mid, id * 2);
return get2(st, en, val, mid, r, id * 2 + 1);
} else
return min(get2(st, en, val, l, mid, id * 2),
get2(st, en, val, mid, r, id * 2 + 1));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i <= n + 1; i++) cin >> x[i];
for (int i = 1; i <= n; i++) cin >> d[i];
fill(lft, lft + maxn, inf);
fill(rgt, rgt + maxn, -1);
st.push(make_pair(-1, n + 1));
for (int i = n; i >= 1; i--) {
while (st.top().second != n + 1 && st.top().first > x[i]) st.pop();
long long cur = 2 * d[i] - (x[st.top().second] - x[i]);
if (cur <= 0)
lft[i] = inf;
else {
lft[i] = x[i] - cur;
f1[i] = cur;
st.push(make_pair(lft[i], i));
}
}
while (st.top().second != n + 1 && st.top().first > x[0]) st.pop();
if (st.size() > 1) return cout << 0 << "\n", 0;
while (st.size()) st.pop();
st.push(make_pair(-1, 0));
for (int i = 1; i <= n; i++) {
while (st.top().second != 0 && st.top().first < x[i]) st.pop();
long long cur = 2 * d[i] - (x[i] - x[st.top().second]);
if (cur <= 0)
rgt[i] = -1;
else {
rgt[i] = x[i] + cur;
f2[i] = cur;
st.push(make_pair(rgt[i], i));
}
}
rgt[0] = 1e9;
lft[n + 1] = -1e9;
build1();
build2();
double ans = (x[n + 1] - x[0]) / 2.0;
for (int i = 1; i <= n; i++) {
if (lft[i] == inf) continue;
int id = get1(0, i, lft[i]);
ans = min(ans, (x[i] - x[id]) / 2.0);
if (lft[i] + 1 && rgt[i] + 1) ans = min(ans, (f1[i] + f2[i]) / 2.0);
}
for (int i = 1; i <= n; i++) {
if (rgt[i] == -1) continue;
int id = get2(i + 1, n + 2, rgt[i]);
ans = min(ans, (x[id] - x[i]) / 2.0);
}
cout << fixed << setprecision(10) << ans << "\n";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
const long long maxn = 100005;
long long inf = 2000000009;
long long c[maxn], a[maxn], b[maxn];
long long f(long long x, long long y, long long z) {
return (x - y) * (x - y) + (x - z) * (x - z) + (y - z) * (y - z);
}
signed main() {
fast();
long long t, i, j, k, n, m, p;
cin >> t;
while (t--) {
cin >> n >> m >> p;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> b[i];
}
for (i = 0; i < p; i++) {
cin >> c[i];
}
sort(a, a + n);
sort(b, b + m);
sort(c, c + p);
a[n] = inf;
b[m] = inf;
c[p] = inf;
long long ans = 7000000000000000018;
long long x, y, z;
for (i = 0; i < n; i++) {
x = a[i];
y = upper_bound(b, b + m + 1, x) - b - 1;
z = lower_bound(c, c + p + 1, x) - c;
if (y >= 0 && z < p) {
y = b[y], z = c[z];
ans = min(ans, f(x, y, z));
}
y = lower_bound(b, b + m + 1, x) - b;
z = upper_bound(c, c + p + 1, x) - c - 1;
if (y < m && z >= 0) {
y = b[y], z = c[z];
ans = min(ans, f(x, y, z));
}
}
for (i = 0; i < m; i++) {
x = b[i];
y = upper_bound(a, a + n + 1, x) - a - 1;
z = lower_bound(c, c + p + 1, x) - c;
if (y >= 0 && z < p) {
y = a[y], z = c[z];
ans = min(ans, f(x, y, z));
}
y = lower_bound(a, a + n + 1, x) - a;
z = upper_bound(c, c + p + 1, x) - c - 1;
if (y < n && z >= 0) {
y = a[y], z = c[z];
ans = min(ans, f(x, y, z));
}
}
for (i = 0; i < p; i++) {
x = c[i];
y = upper_bound(b, b + m + 1, x) - b - 1;
z = lower_bound(a, a + n + 1, x) - a;
if (y >= 0 && z < n) {
y = b[y], z = a[z];
ans = min(ans, f(x, y, z));
}
y = lower_bound(b, b + m + 1, x) - b;
z = upper_bound(a, a + n + 1, x) - a - 1;
if (y < m && z >= 0) {
y = b[y], z = a[z];
ans = min(ans, f(x, y, z));
}
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
vector<vector<int> > v;
vector<int> mn;
int n, m;
scanf("%d %d ", &n, &m);
v.assign(n, vector<int>());
mn.assign(n, 1e9);
while (m--) {
int a, b;
scanf("%d %d ", &a, &b);
a--;
b--;
v[a].push_back(b);
mn[a] = min(mn[a], (((b - a) % n) + n) % n);
}
int mc = 0;
for (int i = 0; i < v.size(); i++) {
mc = max(mc, (int)v[i].size());
}
for (int i = 0; i < n; i++) {
int ex = 0;
for (int j = n - 1; j >= 0; j--) {
int id = (j + i) % n;
if (v[id].size() > 0) {
ex = max(ex, mn[id] + j + (int(v[id].size()) - 1) * n);
}
}
if (i > 0) {
printf(" ");
}
printf("%d", ex);
}
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int limit_f, limit_h;
long long int dp[101][101][11][11];
int getAns(int f, int h, int k1, int k2) {
if ((f + h) == 0) return 1;
if (dp[f][h][k1][k2] != -1) return dp[f][h][k1][k2];
int x = 0;
if (f > 0 && k1 > 0) x = getAns(f - 1, h, k1 - 1, limit_h);
int y = 0;
if (h > 0 && k2 > 0) y = getAns(f, h - 1, limit_f, k2 - 1);
return dp[f][h][k1][k2] = (x + y) % 100000000;
}
int main() {
int t, n1, n2;
t = 1;
while (t--) {
cin >> n1 >> n2 >> limit_f >> limit_h;
memset(dp, -1, sizeof(dp));
int ans = getAns(n1, n2, limit_f, limit_h);
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int r, c, x, y, way, g, h;
char a, arr[11][11];
x = 9, y = 0;
for (r = 1; r <= 8; r++) {
for (c = 1; c <= 8; c++) {
scanf(" %c", &arr[r][c]);
}
}
for (c = 1; c <= 8; c++) {
way = 0;
for (r = 1; r <= 8; r++) {
if (arr[r][c] == 'B') way++;
;
if (way == 0 && arr[r][c] == 'W') {
if (r < x) {
x = r;
break;
}
}
}
}
for (c = 1; c <= 8; c++) {
way = 0;
for (r = 8; r >= 1; r--) {
if (arr[r][c] == 'W') way++;
if (way == 0 && arr[r][c] == 'B') {
if (r > y) {
y = r;
break;
}
}
}
}
g = x - 1, h = 8 - y;
if (g <= h)
printf("A\n");
else
printf("B\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 69;
const int MAXP = 2e6 + 69;
int n, q;
int val[MAXN];
vector<int> a[MAXN];
int check[MAXP];
vector<int> p;
void build() {
for (long long i = 2; i < MAXP; i++) {
if (check[i] == 0) {
p.push_back(i);
check[i] = i;
for (long long j = i * i; j < MAXP; j += i) {
if (check[j] == 0) check[j] = i;
}
}
}
}
int ans[MAXN];
int h[MAXN];
vector<int> prim[MAXP];
void ptich(int i) {
int x = val[i];
while (check[x] != 0) {
int t = check[x];
if (!prim[t].empty()) {
int u = prim[t].back();
if (h[u] > h[ans[i]]) {
ans[i] = u;
}
}
prim[t].push_back(i);
while (x % t == 0) x /= t;
}
}
void xoa(int i) {
int x = val[i];
while (check[x] != 0) {
int t = check[x];
prim[t].pop_back();
while (x % t == 0) x /= t;
}
}
void dfs(int x, int p) {
h[x] = h[p] + 1;
ptich(x);
for (int u : a[x]) {
if (u == p) continue;
dfs(u, x);
}
xoa(x);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
build();
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
dfs(1, 1);
while (q--) {
int type;
cin >> type;
if (type == 2) {
for (int i = 1; i <= n; i++) ans[i] = 0, h[i] = 0;
for (int i = 1; i < MAXP; i++) prim[i].clear();
int x, y;
cin >> x >> y;
val[x] = y;
dfs(1, 1);
} else {
int x;
cin >> x;
if (ans[x] != 0)
cout << ans[x] << '\n';
else
cout << -1 << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int>* v;
vector<int>* vt;
int n, m;
int pri[100005];
int dfs1[100005];
int dfs2[100005];
stack<int> ord;
int brk = 1;
map<pair<int, int>, int> mp;
void dfsf(vector<int>** v, int* vis, int x, int m, int r) {
if (r == 2 && dfs1[x] != dfs1[m]) return;
vis[x] = m;
if (r == 2) vis[x] = brk;
for (int i = 0; i < ((*v)[x]).size(); i++) {
if (vis[(*v)[x][i]] == 0) dfsf(v, vis, (*v)[x][i], m, r);
}
if (r == 1) ord.push(x);
}
void tarjan() {
for (int i = 0; i < n; i++)
if (dfs1[i + 1] == 0) dfsf(&v, dfs1, i + 1, i + 1, 1);
for (int i = 0; i < n; i++) {
int o = ord.top();
if (dfs2[ord.top()] == 0) {
dfsf(&vt, dfs2, o, o, 2);
brk++;
}
ord.pop();
}
}
int main() {
v = new vector<int>[100005];
vt = new vector<int>[100005];
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &pri[i + 1]);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
vt[y].push_back(x);
}
tarjan();
int mod = (int)1e9 + 7;
long long nacin = 1;
long long price = 0;
int p[100005], b[n];
for (int i = 0; i <= n; i++) p[i] = 1 << 30, b[i] = 0;
for (int i = 1; i < n + 1; i++) {
if (p[dfs2[i]] == pri[i]) b[dfs2[i]]++;
if (p[dfs2[i]] > pri[i]) b[dfs2[i]] = 1, p[dfs2[i]] = pri[i];
}
for (int i = 1; i <= n; i++) {
if (p[i] != 1 << 30) {
nacin *= b[i];
nacin %= mod;
price += p[i];
}
}
cout << price << ' ' << nacin;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("input", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const int N = 400 + 7;
int q, mod, fact[N], no_pre[N], ways[N][N], ret[N];
int add(int a, int b) {
a += b;
if (a >= mod) return a - mod;
if (a < 0) return a + mod;
return a;
}
int mul(int a, int b) { return a * (long long)b % mod; }
signed realMain() {
cin >> q >> mod;
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = mul(fact[i - 1], i);
}
for (int i = 1; i < N; i++) {
no_pre[i] = fact[i];
for (int j = 1; j < i; j++) {
no_pre[i] = add(no_pre[i], -mul(fact[j], no_pre[i - j]));
}
}
ways[0][0] = 1;
for (int n = 1; n < N; n++) {
for (int k = 1; k < N; k++) {
for (int last = 1; last <= n; last++) {
ways[n][k] = add(ways[n][k], mul(fact[last], ways[n - last][k - 1]));
}
}
}
for (int i = 1; i < N; i++) {
ret[i] = fact[i];
for (int j = 1; j < i; j++) {
ret[i] = add(ret[i], -mul(2, mul(fact[j], no_pre[i - j])));
}
for (int k = 3; k < i; k++) {
ret[i] = add(ret[i], -mul(ways[i][k], ret[k]));
}
}
ret[2] = 2;
while (q--) {
int n;
cin >> n;
cout << ret[n] << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
const int N = 100000 + 10;
int n, s;
bool mark[N];
vector<pair<int, int> > adj[N];
int DFS(int u, int h) {
mark[u] = true;
int res = h;
for (int i = 0; i < adj[u].size(); i++)
if (!mark[adj[u][i].first])
res = max(res, DFS(adj[u][i].first, h + adj[u][i].second));
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
adj[x].push_back(make_pair(y, z));
adj[y].push_back(make_pair(x, z));
s += z;
}
cout << (unsigned long long)2 * s - (unsigned long long)DFS(1, 0) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace moonpie {
const int N = 2e5 + 5;
int n, a[N];
set<pair<int, int> > s;
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int cnt = 0;
for (int i = 1; i <= n; ++i) {
int x = log2(a[i]);
int sum = 0;
for (int j = i + 1; j < n; ++j) {
sum += a[j];
if (sum > (1 << (x + 1))) break;
if (sum == (a[i] ^ a[j + 1])) s.insert(pair<int, int>(i, j + 1));
}
}
for (int i = n; i >= 1; --i) {
int x = log2(a[i]);
int sum = 0;
for (int j = i - 1; j > 1; --j) {
sum += a[j];
if (sum > (1 << (x + 1))) break;
if (sum == (a[i] ^ a[j - 1])) s.insert(pair<int, int>(j - 1, i));
}
}
cout << s.size() << endl;
}
} // namespace moonpie
signed main() {
moonpie::solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const signed int MAX = 1e5 + 5;
signed int N;
signed int M;
signed int num[MAX];
signed int cost[MAX];
signed int last[MAX];
bool check(signed int idx) {
for (signed int i = (1); i <= (M); ++i) last[i] = 0;
for (signed int i = (1); i <= (idx); ++i) last[num[i]] = i;
signed long long free = 0;
signed long long c = 0;
signed int n = 0;
for (signed int i = (1); i <= (idx); ++i) {
if (num[i] == 0 || last[num[i]] > i)
free++;
else {
c += cost[num[i]];
if (c > free) return 0;
n++;
}
}
return n == M;
}
signed int main() {
scanf("%d %d", &N, &M);
for (signed int i = 0; i < (N); ++i) scanf("%d", num + i + 1);
for (signed int i = 0; i < (M); ++i) scanf("%d", cost + i + 1);
signed int low = 0, high = N + 1;
signed int mid;
while (low < high) {
mid = low + high >> 1;
if (check(mid))
high = mid;
else
low = mid + 1;
}
if (low == N + 1 || low == 0) low = -1;
printf("%d\n", low);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100009;
int n, m;
vector<pair<int, int> > E;
vector<vector<pair<int, int> > > g;
int idx[MAX], low[MAX], dfs = 1;
bool is[MAX] = {0};
int P[MAX];
int sz[MAX];
void DFS(int u, int p) {
low[u] = idx[u] = dfs++;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i].first;
int j = g[u][i].second;
if (idx[v] == 0) {
DFS(v, u);
low[u] = min(low[u], low[v]);
if (low[u] < idx[v]) {
is[j] = 1;
}
} else if (v != p) {
low[u] = min(low[u], idx[v]);
}
}
}
int find(int x) { return (x == P[x] ? x : P[x] = find(P[x])); }
int BFS(int src) {
bool ok = 0;
queue<int> Q;
idx[src] = 0;
Q.push(src);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i].first;
int c = g[u][i].second;
ok = ok || (is[c] == 0);
if (idx[v] == 0) {
idx[v] = 1;
Q.push(v);
}
}
}
return ok == false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
E.push_back(make_pair(u, v));
}
memset(idx, 0, sizeof idx);
for (int i = 0; i < n; i++)
if (idx[i] == 0) DFS(i, -1);
for (int i = 0; i < n; i++) {
P[i] = i;
sz[i] = 1;
}
for (int i = 0; i < m; i++) {
if (!is[i]) {
int a = find(E[i].first);
int b = find(E[i].second);
P[a] = b;
sz[a] += sz[b];
}
}
int ans = 0;
memset(idx, 0, sizeof idx);
for (int i = 0; i < n; i++) {
if (idx[i] == 0) ans += BFS(i);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, aux, i, j;
cin >> n;
k = n * n;
aux = n;
i = 1;
while (aux) {
j = i;
if (n % 2 == 0)
j += n / 2;
else
j = j + n / 2 + 1;
for (i; i < j; i++) cout << i << " " << k - i + 1 << " ";
cout << "\n";
aux--;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n;
scanf("%d", &n);
int ans = 1000000000;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
ans = min(ans, a / max(i, n - i - 1));
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, r, c, x;
long long max(long long a, long long b) { return a > b ? a : b; }
long long total(long long m) {
long long cnt = 0;
for (long long i = max(1, r - m); i <= min(n, r + m); i++) {
long long L, R;
L = c - m + abs(r - i);
R = c + m - abs(r - i);
cnt += max(0, 1 + min(n, R) - max(1, L));
}
return cnt;
}
long long fn() {
long long l = 0, h = 1e7, m;
for (long long i = 0; i < 200; i++) {
m = (l + h) / 2;
long long p = total(m);
if (h - l <= 1) break;
if (p >= x)
h = m;
else
l = m;
}
return total(l) >= x ? l : h;
}
int main() {
int t, tc = 0;
cin >> n >> r >> c >> x;
long long ans = fn();
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> col(n, 10000);
vector<pair<int, int>> col1, col2, col3;
for (int i = 0; i != m; i++) {
int a, b, c;
cin >> a >> b >> c;
b--;
c--;
if (a) {
col1.push_back({b, c});
} else {
col2.push_back({b, c});
}
}
sort(col2.begin(), col2.end());
sort(col1.begin(), col1.end());
for (int i = 1; i < col1.size(); i++) {
if (col1[i].first <= col1[i - 1].second) {
col1[i].first = min(col1[i].first, col1[i - 1].first);
col1[i].second = max(col1[i].second, col1[i - 1].second);
} else {
col3.push_back(col1[i - 1]);
}
}
if (col1.size() > 0) {
col3.push_back(col1[col1.size() - 1]);
}
for (int i = 0; i < col2.size(); i++) {
for (int j = 0; j < col3.size(); j++) {
if (col2[i].first >= col3[j].first && col2[i].second <= col3[j].second) {
cout << "NO";
return 0;
}
}
}
vector<int> ans;
if (col3.size() > 0) {
for (int j = 0; j < col3[0].first; j++) {
ans.push_back(j);
}
for (int i = 0; i < col3.size() - 1; i++) {
ans.push_back(col3[i].first);
for (int j = col3[i].second + 1; j < col3[i + 1].first; j++) {
ans.push_back(j);
}
}
ans.push_back(col3[col3.size() - 1].first);
for (int j = col3[col3.size() - 1].second + 1; j < n; j++) {
ans.push_back(j);
}
} else {
for (int i = 0; i != n; i++) {
ans.push_back(i);
}
}
int cur = 10000;
for (int i = 0; i != ans.size(); i++) {
cur--;
col[ans[i]] = cur;
}
cout << "YES\n";
for (int i = 0; i != n; i++) {
cout << col[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int min(int x, int y) {
if (x < y)
return x;
else
return y;
}
int max(int x, int y) {
if (x > y)
return x;
else
return y;
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1; j++) {
if (a[j] > min(a[i], a[i + 1]) && a[j] < max(a[i], a[i + 1]) &&
(a[j + 1] < min(a[i], a[i + 1]) ||
a[j + 1] > max(a[i], a[i + 1])) ||
(a[j + 1] > min(a[i], a[i + 1]) && a[j + 1] < max(a[i], a[i + 1]) &&
(a[j] < min(a[i], a[i + 1]) || a[j] > max(a[i], a[i + 1])))) {
cout << "yes";
return 0;
}
}
}
cout << "no";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
double f[N][N], p, q;
int x, k;
int main() {
scanf("%d%d%lf", &x, &k, &p);
p /= 100;
q = 1 - p;
for (int i = 0; i <= k; i++)
for (int j = x + i; j % 2 == 0; j /= 2) f[0][i]++;
for (int i = 0; i < k; i++)
for (int j = 0; j <= k; j++) {
if (j) f[i + 1][j - 1] += q * f[i][j];
if (j * 2 <= k) f[i + 1][j * 2] = p * (f[i][j] + 1);
}
printf("%.10lf", f[k][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using mat = vector<vector<ll>>;
mat mul(mat& a, mat& b, ll mod) {
mat ret;
ret.resize(a.size(), vector<ll>(b[0].size(), 0));
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < b[0].size(); j++) {
for (int k = 0; k < b.size(); k++) {
ret[i][j] = (ret[i][j] + a[i][k] * b[k][j]) % mod;
}
}
}
return ret;
}
void print(mat& m) {
for (int i = 0; i < m.size(); i++) {
for (int j = 0; j < m[i].size(); j++) {
cout << m[i][j] << " ";
}
cout << "\n";
}
}
mat fpow(mat base, ll e, ll mod) {
mat ret(base.size(), vector<ll>(base.size(), 0));
for (int i = 0; i < base.size(); i++) {
ret[i][i] = 1;
}
while (e) {
if (e & 1) {
ret = mul(ret, base, mod);
}
base = mul(base, base, mod);
e >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
ll n, sx, sy, dx, dy, t;
cin >> n >> sx >> sy >> dx >> dy >> t;
sx--, sy--;
mat A(6, vector<ll>(6, 0));
A[0][0] = A[1][1] = 2;
A[0][2] = A[0][3] = 1;
A[1][0] = A[0][1] = A[1][2] = A[1][3] = 1;
A[2][0] = A[2][2] = 1;
A[3][1] = A[3][3] = 1;
A[4][0] = A[4][1] = A[4][2] = A[4][3] = A[4][4] = 1;
A[5][0] = A[5][1] = A[5][2] = A[5][3] = 2;
A[5][4] = A[5][5] = 1;
mat at(1, vector<ll>(6, 0));
at[0][0] = sx;
at[0][1] = sy;
at[0][2] = dx;
at[0][3] = dy;
at[0][4] = 0;
at[0][5] = 1;
mat b = fpow(A, t, n);
b = mul(at, b, n);
while (b[0][0] < 0) b[0][0] += n;
while (b[0][1] < 0) b[0][1] += n;
cout << (b[0][0] + 1) << " " << (b[0][1] + 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, M = 2e5 + 10, K = 62, mod = 1e9 + 7;
namespace io {
long long read() {
long long x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
return x;
}
void write(long long x) {
if (x > 9) write(x / 10);
putchar(x % 10 ^ 48);
}
void writeln(long long x) {
write(x);
putchar(10);
}
} // namespace io
using namespace io;
namespace LB {
long long sz;
long long bas[K];
bool can[K];
void init() {
sz = 0;
for (long long i = 0; i < K; i++) bas[i] = 0, can[i] = 0;
}
void insert(long long x) {
for (long long i = 0; i < K; i++)
if (x >> i & 1ll) can[i] = 1;
for (long long i = 0; i < K; i++) {
if (bas[i] && x >> i & 1ll)
x ^= bas[i];
else if (x >> i & 1ll) {
bas[i] = x;
sz++;
break;
}
}
}
} // namespace LB
using LB::init;
using LB::insert;
namespace MS42 {
struct Tedge {
long long v;
long long w;
long long nxt;
} e[M * 2];
long long head[N], cnt = 1;
long long n, m, sz[N], g[N][K], f[N][K];
long long ans, dis[N];
bool vis[N];
void file() {}
void input() {
n = read(), m = read();
for (long long i = 1; i <= m; i++) {
long long u = read(), v = read(), w = read();
e[++cnt] = (Tedge){v, w, head[u]};
head[u] = cnt;
swap(u, v);
e[++cnt] = (Tedge){v, w, head[u]};
head[u] = cnt;
}
}
void dfs(long long x, long long y) {
vis[x] = 1;
sz[x] = 1;
for (long long i = 0; i < K; i++) {
f[x][i] = dis[x] >> i & 1ll;
g[x][i] = 1 - f[x][i];
}
for (long long i = head[x]; i; i = e[i].nxt)
if (i != y) {
if (vis[e[i].v]) {
insert(dis[x] ^ dis[e[i].v] ^ e[i].w);
continue;
}
dis[e[i].v] = dis[x] ^ e[i].w;
dfs(e[i].v, i ^ 1);
for (long long j = 0; j < K; j++) {
f[x][j] += f[e[i].v][j];
g[x][j] += g[e[i].v][j];
}
sz[x] += sz[e[i].v];
}
}
long long C(long long x) { return 1ll * x * (x - 1) / 2 % mod; }
void solve() {
for (long long i = 1; i <= n; i++)
if (!vis[i]) {
init();
dfs(i, 0);
for (long long j = 0; j < K; j++)
if (!LB::can[j])
ans = (ans + ((1ll << j) % mod) * ((1ll << LB::sz) % mod) % mod *
f[i][j] % mod * g[i][j] % mod) %
mod;
else
ans = (ans + ((1ll << j) % mod) * ((1ll << LB::sz - 1) % mod) % mod *
C(sz[i]) % mod) %
mod;
}
writeln(ans);
}
void solution() {
file();
input();
solve();
}
} // namespace MS42
signed main() {
MS42::solution();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
struct point_t {
int x, y, col, id;
point_t(int k1 = 0, int k2 = 0, int k3 = 0, int k4 = 0)
: x(k1), y(k2), col(k3), id(k4) {}
bool operator<(const point_t A) const {
if (x != A.x) return x < A.x;
return y < A.y;
}
};
point_t operator-(const point_t a, const point_t b) {
return point_t(a.x - b.x, a.y - b.y);
}
long long cross(point_t a, point_t b) {
return 1ll * a.x * b.y - 1ll * a.y * b.x;
}
vector<point_t> make_hull(vector<point_t> a) {
int n = (int)a.size();
sort(a.begin(), a.end());
vector<point_t> ans;
int top = -1;
for (int i = 0; i < n; i++) {
while (top >= 1 && cross(a[i] - ans[top], a[i] - ans[top - 1]) > 0)
ans.pop_back(), --top;
ans.push_back(a[i]);
++top;
}
int lim = top + 1;
for (int i = n - 2; i >= 0; i--) {
while (top >= lim && cross(a[i] - ans[top], a[i] - ans[top - 1]) > 0)
ans.pop_back(), --top;
ans.push_back(a[i]);
++top;
}
ans.pop_back();
return ans;
}
const double PI = acos(-1.0);
bool check(point_t a, point_t b, point_t c) {
double ang1 = atan2(a.y, a.x), ang2 = atan2(b.y, b.x), ang3 = atan2(c.y, c.x);
if (ang2 < ang1) ang2 += PI * 2;
if (ang3 < ang1) ang3 += PI * 2;
return ang3 <= ang2;
}
vector<pair<int, int> > ans;
void solve(vector<point_t> a, vector<point_t> b, int col) {
int id = -1;
for (int i = 0; i < (int)b.size(); i++) {
if (b[i].col == col) {
id = i;
break;
}
}
if (id == -1) {
for (int i = 0; i < (int)b.size(); i++) {
ans.push_back(make_pair(a[0].id, b[i].id));
}
return;
}
ans.push_back(make_pair(a[2].id, b[id].id));
vector<point_t> po[3];
for (int i = 0; i < (int)b.size(); i++) {
if (i == id) continue;
for (int j = 0; j < 3; j++) {
int go = (j + 1) % 3;
if (check(a[go] - b[id], a[j] - b[id], b[i] - b[id])) {
po[j].push_back(b[i]);
}
}
}
vector<point_t> tmp;
tmp.clear();
tmp.push_back(a[0]);
tmp.push_back(a[1]);
tmp.push_back(b[id]);
solve(tmp, po[0], col);
tmp.clear();
tmp.push_back(a[2]);
tmp.push_back(b[id]);
tmp.push_back(a[1]);
solve(tmp, po[1], col ^ 1);
tmp.clear();
tmp.push_back(b[id]);
tmp.push_back(a[2]);
tmp.push_back(a[0]);
solve(tmp, po[2], col ^ 1);
}
vector<point_t> a, b;
int vis[1005];
int n;
int main() {
read(n);
a.resize(n);
for (int i = 0; i < n; i++) {
read(a[i].x);
read(a[i].y);
read(a[i].col);
a[i].id = i;
}
int cando = 1;
for (int i = 1; i < n; i++) {
if (a[i].col != a[0].col) {
cando = 0;
break;
}
}
if (cando) {
printf("%d\n", n - 1);
for (int i = 1; i < n; i++) printf("%d %d\n", 0, i);
return 0;
}
b = make_hull(a);
int cnt = 0;
for (int l = 0, r; l < (int)b.size(); l = r + 1) {
r = l;
while (r + 1 < (int)b.size() && b[l].col == b[r + 1].col) ++r;
++cnt;
}
if (cnt > 3) {
printf("Impossible\n");
return 0;
}
for (int i = 0; i < (int)b.size(); i++) vis[b[i].id] = 1;
if (cnt == 1) {
int id = -1;
for (int i = 0; i < n; i++) {
if (a[i].col != b[0].col) {
id = i;
break;
}
}
for (int i = 1; i < (int)b.size(); i++)
ans.push_back(make_pair(b[i - 1].id, b[i].id));
vector<vector<point_t> > po(b.size());
for (int i = 0; i < n; i++) {
if (vis[i] || i == id) continue;
for (int j = 0; j < (int)b.size(); j++) {
int go = (j + 1) % b.size();
if (check(b[j] - a[id], b[go] - a[id], a[i] - a[id])) {
po[j].push_back(a[i]);
break;
}
}
}
for (int i = 0; i < (int)b.size(); i++) {
vector<point_t> tmp;
tmp.push_back(b[(i + 1) % b.size()]);
tmp.push_back(b[i]);
tmp.push_back(a[id]);
solve(tmp, po[i], a[id].col);
}
} else {
reverse(b.begin(), b.end());
int fir1 = -1;
for (int i = 0; i < (int)b.size(); i++) {
if (b[i].col != b[0].col) {
fir1 = i;
break;
}
}
assert(fir1 != -1);
int fir2 = fir1;
while (b[fir2].col == b[fir1].col) fir2 = (fir2 + 1) % b.size();
int now1 = fir1, now2 = fir2;
while ((now1 + 1) % (int)b.size() != fir2) {
vector<point_t> po;
int go = (now1 + 1) % b.size();
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
if (check(b[go] - b[fir2], b[now1] - b[fir2], a[i] - b[fir2]))
po.push_back(a[i]);
}
vector<point_t> tmp;
tmp.push_back(b[now1]);
tmp.push_back(b[go]);
tmp.push_back(b[fir2]);
ans.push_back(make_pair(b[now1].id, b[go].id));
solve(tmp, po, b[fir2].col);
now1 = go;
}
while ((now2 + 1) % (int)b.size() != fir1) {
vector<point_t> po;
int go = (now2 + 1) % b.size();
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
if (check(b[go] - b[fir1], b[now2] - b[fir1], a[i] - b[fir1]))
po.push_back(a[i]);
}
vector<point_t> tmp;
tmp.push_back(b[now2]);
tmp.push_back(b[go]);
tmp.push_back(b[fir1]);
ans.push_back(make_pair(b[now2].id, b[go].id));
solve(tmp, po, b[fir1].col);
now2 = go;
}
}
assert((int)ans.size() == n - 2);
printf("%d\n", n - 2);
for (int i = 0; i < n - 2; i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
const double Pi = 3.14159265;
const int N = 5e6 + 10;
const int M = 1e5 + 10;
const unsigned long long base = 163;
const int INF = 0x3f3f3f3f;
const int mod = 192600817;
const double eps = 1e-10;
const double pi = acos(-1);
using namespace std;
int n, m, d;
char s[M][52];
int ans[N];
vector<int> E[N];
int u[M], v[M];
void add(int u, int v) { E[u].push_back(v); }
int sta[N], stasize = 0;
int low[N], dfn[N];
int com[N], sz = 0;
int vis[N];
int step = 0;
pair<int, int> getp(int x) { return pair<int, int>{x / d + 1, x % d}; }
pair<int, int> p;
void dfs(int u) {
dfn[u] = low[u] = ++step;
vis[u] = 1;
sta[stasize++] = u;
for (auto v : E[u]) {
if (!vis[v])
dfs(v), low[u] = min(low[u], low[v]);
else if (vis[v] == 1)
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
int k;
sz++;
do {
k = sta[--stasize];
p = getp(k);
vis[k] = 2;
com[k] = sz;
} while (k != u);
}
}
void tarjan() { dfs(0); }
int getid(int x, int t) { return (x - 1) * d + t; }
void sma() {
for (int i = 0; i < n * d; i++) vector<int>().swap(E[i]);
int z, p;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j < d; ++j) {
z = getid(u[i], j), p = getid(v[i], (j + 1) % d);
if (com[z] == com[p] || !com[z] || !com[p]) continue;
add(com[z], com[p]);
}
}
set<int> ss;
for (int i = 1; i <= n; i++) {
ss.clear();
for (int j = 0; j < d; j++) {
if (s[i][j] != '1') continue;
int c = com[getid(i, j)];
if (!c) continue;
ss.insert(c);
}
for (auto x : ss) ans[x]++;
}
}
int DFS(int u) {
if (vis[u] != -1) return vis[u];
vis[u] = 0;
for (auto v : E[u]) {
vis[u] = max(vis[u], DFS(v));
}
vis[u] += ans[u];
return vis[u];
}
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u[i], &v[i]);
for (int j = 0; j < d; ++j) {
add(getid(u[i], j), getid(v[i], (j + 1) % d));
}
}
for (int i = 1; i <= n; ++i) scanf("%s", s[i]);
tarjan();
sma();
memset(vis, -1, sizeof(vis));
printf("%d\n", DFS(com[0]));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxd = 58;
long long f[maxd + 10][maxd * 2 + 10][2], two[maxd + 10];
int i, j, k, l, t, n, m, a, b;
long long x, y, now, s, ans;
void work(int a, int b, long long now, int cnt) {
int i, j, k, l, r, t, s, d, mx = max(a - 2, b - 1) + 2;
for (i = 0; i <= maxd + 2; i++)
for (j = 0; j <= cnt; j++) f[i][j][0] = f[i][j][1] = 0;
f[0][0][0] = 1;
for (i = 0; i <= mx - 1; i++) {
if ((now & two[i]))
d = 1;
else
d = 0;
for (j = 0; j <= cnt; j++)
for (t = 0; t <= 1; t++)
if (f[i][j][t]) {
for (l = 0; l <= 1; l++)
for (r = 0; r <= 1; r++) {
if (l && i > a - 2) continue;
if (r && i > b - 1) continue;
if (!r && i == b - 1) continue;
s = l + r + t;
k = s / 2;
s = s % 2;
if (s != d) continue;
f[i + 1][j + l + r][k] += f[i][j][t];
}
}
}
ans += f[mx][cnt][0];
}
int main() {
two[0] = 1;
for (i = 1; i <= maxd + 1; i++) two[i] = two[i - 1] * 2;
scanf("%I64d", &s);
for (a = 0; a <= maxd; a++)
for (b = 0; b <= maxd; b++) {
y = two[a + 1] + two[b + 1] - 3;
x = s / y;
while (x) {
now = s - x * y;
if (now > two[a] - a + two[b + 1] - b - 3) {
x = 0;
break;
}
if (now >= two[b] - 1 && now <= two[a] - a + two[b + 1] - b - 3) break;
x--;
}
if (!x) continue;
now = s - x * y;
for (i = 0; i <= maxd * 2; i++)
if ((now + i) % 2 == 0) work(a, b, (now + i) / 2, i);
}
printf("%I64d\n", ans);
}
| 12 |
#include <bits/stdc++.h>
std::vector<long long> ds;
long long d[100001];
int dd[100001];
int dn;
int pow_mod(int a, int b, int m) {
int ret = 1;
a %= m;
while (b) {
if (b & 1) {
ret = (long long)ret * a % m;
}
b >>= 1;
a = (long long)a * a % m;
}
return ret;
}
int aa[51][51];
int ans;
void go2(int n, long long *a, int *b, int d, long long cur) {
if (d == n) {
int p = 1;
for (int i = 0; i < n; i++) {
p = (long long)p * aa[i][b[i]] % 1000000007;
}
ans += ((long long)p * (cur % 1000000007)) % 1000000007;
if (ans >= 1000000007) ans -= 1000000007;
return;
}
int tmp = b[d];
int i, j, k;
long long cc = 1;
for (i = 0; i <= tmp; i++) {
b[d] = i;
go2(n, a, b, d + 1, cur * cc);
cc *= a[d];
}
b[d] = tmp;
}
int a[52][10001][52];
int main() {
long long n;
int m;
scanf("%I64d%d", &n, &m);
for (long long k = 2; k * k <= n; k++) {
if (n % k == 0) {
int t = 0;
while (n % k == 0) n /= k, t++;
d[dn] = k;
dd[dn++] = t;
}
}
if (n > 1) {
d[dn] = n;
dd[dn++] = 1;
}
int i, j, k;
for (k = 0; k < dn; k++) {
a[k][m][dd[k]] = 1;
for (j = m; j > 0; j--) {
for (i = dd[k]; i >= 0; i--) {
int rr = pow_mod(i + 1, 1000000005, 1000000007);
for (int x = 0; x <= i; x++) {
a[k][j - 1][x] += (long long)a[k][j][i] * rr % 1000000007;
if (a[k][j - 1][x] >= 1000000007) a[k][j - 1][x] -= 1000000007;
}
}
}
for (i = dd[k]; i >= 0; i--) {
aa[k][i] = a[k][0][i];
}
}
go2(dn, d, dd, 0, 1);
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
double z = ceil(n / 4.0);
for (int i = 1; i <= n - z; i++) {
cout << "9";
}
for (int i = 1; i <= z; i++) {
cout << "8";
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, ans = 1, res = 1, x, mn = 0, mx = 1E9;
set<int> S;
set<int>::iterator it;
char s[10];
int main() {
scanf("%d", &n);
S.insert(1E9);
S.insert(0);
for (int i = 1; i <= n; i++) {
scanf("%s%d", s, &x);
if (s[1] == 'D')
S.insert(x), res += (x >= mn && x <= mx) ? 1 : 0;
else {
if (x < mn || x > mx) ans = 0;
if (x != mn && x != mx) ans = 2 * ans % mod;
S.erase(x);
res = 1;
it = S.lower_bound(x);
mx = *it;
mn = *(--it);
}
}
printf("%d\n", 1ll * ans * res % mod);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.000001;
double sqr(double a) { return a * a; }
int GCD(int a, int b) {
int q;
while (b) {
q = a % b;
a = b;
b = q;
}
return a;
}
int main() {
string s, left, right;
int N, i;
cin >> s;
N = s.length();
for (left = "", i = 0; i < N && s[i] != '^'; ++i) left += s[i];
for (right = "", ++i; i < N; ++i) right += s[i];
long long s_left, s_right;
s_left = s_right = 0;
for (i = 0; i < left.length(); ++i) {
if (left[i] != '=') s_left += (left.length() - i) * (left[i] - 48);
}
for (i = 0; i < right.length(); ++i) {
if (right[i] != '=') s_right += (i + 1) * (right[i] - 48);
}
if (s_left == s_right)
cout << "balance";
else if (s_left > s_right)
cout << "left";
else
cout << "right";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int pow_mod(long long int a, long long int b) {
long long int res = 1;
while (b != 0) {
if (b & 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
void solve() {
long long int n, k;
cin >> n >> k;
long long int a[n];
long long int d[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 0; i < n; i++) cin >> d[i];
long long int suf[n];
long long int ka[n + 1];
ka[n] = 0;
for (long long int i = n - 1; i >= 0; i--) {
if (i == n - 1)
suf[i] = a[i];
else
suf[i] = suf[i + 1] + a[i];
ka[i] = max(ka[i + 1], suf[i] - d[i]);
}
long long int ans = 0;
if (k == 0) {
for (long long int i = 0; i < n; i++) ans = max(ans, -d[i] + suf[i]);
} else if (k >= 2) {
long long int sum = 0;
for (long long int i = 0; i < n; i++) sum += a[i];
for (long long int i = 0; i < n - 1; i++) ans = max(ans, sum - d[i]);
ans = max(ans, a[n - 1] - d[n - 1]);
} else {
long long int mxi[n];
long long int sum[n];
for (long long int i = 0; i < n; i++) {
if (i == 0)
mxi[i] = d[i];
else
mxi[i] = min(mxi[i - 1], d[i]);
if (i == 0)
sum[i] = a[i];
else
sum[i] = sum[i - 1] + a[i];
}
for (long long int i = 0; i < n - 1; i++) {
long long int res = suf[0] - suf[i + 1];
long long int lk = max(0LL, ka[i + 1]);
ans = max(ans, max(0LL, sum[i] - mxi[i]) + lk);
}
ans = max(ans, a[n - 1] - d[n - 1]);
ans = max(ans, a[0] - d[0] + suf[2]);
long long int mx = 0;
for (long long int i = 0; i < n - 2; i++) {
mx = max(mx, suf[i] - d[i]);
ans = max(ans, mx - a[i + 1]);
}
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
char _;
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
int n;
int a[2000006];
int b[2000006];
int seen[2000006];
vector<int> factors(int x) {
vector<int> ret;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
ret.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) ret.push_back(x);
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n + 1; ++i) cin >> a[i];
int cur = 1;
while (cur <= n) {
vector<int> f = factors(a[cur]);
bool ok = true;
for (int i = 0; i < int((f).size()); ++i) {
if (seen[f[i]]) {
ok = false;
break;
}
}
if (!ok) break;
b[cur] = a[cur];
cur++;
for (int i = 0; i < int((f).size()); ++i) seen[f[i]] = 1;
}
if (cur <= n) {
for (int i = a[cur] + 1;; i++) {
vector<int> f = factors(i);
bool ok = true;
for (int j = 0; j < int((f).size()); ++j) {
if (seen[f[j]]) {
ok = false;
break;
}
}
if (ok) {
b[cur] = i;
for (int j = 0; j < int((f).size()); ++j) {
seen[f[j]] = 1;
}
cur++;
break;
}
}
}
if (cur <= n) {
vector<int> v;
for (int i = 2;; i++) {
if (cur + int((v).size()) > 1e5 + 5) break;
if (seen[i]) continue;
vector<int> f = factors(i);
bool ok = true;
for (int j = 0; j < int((f).size()); ++j)
if (seen[f[j]]) {
ok = false;
break;
}
if (ok) {
v.push_back(i);
for (int j = 0; j < int((f).size()); ++j) seen[f[j]] = 1;
}
}
int i = 0;
while (cur <= n) {
b[cur++] = v[i++];
}
}
for (int i = 1; i < n + 1; ++i) cout << b[i] << ' ';
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long count = 0;
long long p = 0;
for (int i = 0; i < n; i++) {
int x = p;
p += a[i];
if (p <= k && x != 0) {
count++;
p = 0;
} else {
count += p / k;
p = p % k;
}
}
if (p > 0) {
count++;
}
cout << count;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20100;
struct Node {
int x, y;
bool id;
int bianhao;
};
Node node[maxn];
Node ji;
bool cmp1(Node& a, Node& b) {
if (a.y != b.y)
return a.y < b.y;
else
return a.x < b.x;
}
bool cmp2(Node& a, Node& b) {
return ((a.x - ji.x) * (b.y - ji.y) - (a.y - ji.y) * (b.x - ji.x)) < 0;
}
int n;
int ans[maxn];
void dfs(int l, int r) {
if (l > r) return;
int c = min_element(node + l, node + r + 1, cmp1) - node;
swap(node[l], node[c]);
ji = node[l];
sort(node + l + 1, node + r + 1, cmp2);
int cnt1 = 0, cnt2 = 0;
int k = r;
while (!(ji.id != node[k].id && cnt1 == cnt2)) {
if (node[k].id == ji.id)
cnt1++;
else
cnt2++;
k--;
}
if (ji.id)
ans[node[k].bianhao] = ji.bianhao;
else
ans[ji.bianhao] = node[k].bianhao;
dfs(l + 1, k - 1);
dfs(k + 1, r);
}
int main() {
scanf("%d", &n);
{
for (int i = 1; i <= n; i++) {
scanf("%d %d", &node[i].x, &node[i].y);
node[i].id = false;
node[i].bianhao = i;
}
for (int i = n + 1; i <= 2 * n; i++) {
scanf("%d %d", &node[i].x, &node[i].y);
node[i].id = true;
node[i].bianhao = i - n;
;
}
dfs(1, 2 * n);
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long c[200007], l[200007], z[200007];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, s, t, i, kol, L, M, R, time, ans = INT_MAX;
bool OK;
cin >> n >> k >> s >> t;
for (i = 1; i <= n; i++) cin >> c[i] >> l[i];
for (i = 1; i <= k; i++) cin >> z[i];
z[0] = 0;
z[k + 1] = s;
sort(z + 1, z + k + 1);
kol = t - s;
L = 0;
R = 2000000000;
while (R - L > 1) {
M = (R + L) / 2;
time = 0;
OK = true;
for (i = 1; i <= k + 1; i++)
if (z[i] - z[i - 1] > M) {
L = M;
OK = false;
break;
} else {
kol = M - (z[i] - z[i - 1]);
if (kol >= z[i] - z[i - 1])
time += z[i] - z[i - 1];
else
time += (kol + (z[i] - z[i - 1] - kol) * 2);
}
if (OK) {
if (time <= t)
R = M;
else
L = M;
}
}
for (i = 1; i <= n; i++)
if (l[i] >= R) ans = min(ans, c[i]);
if (ans != INT_MAX)
cout << ans;
else
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m;
const int SIZE = 5e5 + 10;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> m;
vector<pair<int, int>> a(n * m);
for (int i = 0; i < n * m; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
for (int i = 0; i < n * m; i++) {
a[i].second = -a[i].second;
}
int res = 0;
for (int i = 0; i < n; i++) {
sort(a.begin() + (m * i), a.begin() + (m * i + m));
for (int j = 0; j < m; j++) {
for (int k = 0; k < j; k++) {
if (a[i * m + k].second > a[i * m + j].second) res++;
}
}
}
cout << res << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct child {
int ctr, idx;
bool operator<(const child &o) const { return ctr < o.ctr; }
};
struct S {
int from, to, type;
};
child c[N];
set<int> a[N];
vector<S> ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int total = 0;
for (int i = 1; i <= n; ++i) {
cin >> c[i].ctr;
c[i].idx = i;
total += c[i].ctr;
for (int j = 0; j < c[i].ctr; ++j) {
int x;
cin >> x;
a[i].insert(x);
}
}
sort(c + 1, c + 1 + n);
int hi_ctr = total % n;
int i = 1, j = n;
while (i < j) {
int lo, hi;
if (i >= n - hi_ctr + 1) {
lo = total / n + 1;
} else {
lo = total / n;
}
if (j >= n - hi_ctr + 1) {
hi = total / n + 1;
} else {
hi = total / n;
}
int transfer = min(lo - c[i].ctr, c[j].ctr - hi);
int idx1 = c[i].idx, idx2 = c[j].idx;
vector<int> found;
auto it1 = a[idx1].begin(), it2 = a[idx2].begin();
while (transfer) {
if (it1 == a[idx1].end()) {
found.push_back(*it2);
++it2;
--transfer;
} else if (*it1 == *it2) {
++it1;
++it2;
} else if (*it1 < *it2) {
++it1;
} else {
found.push_back(*it2);
++it2;
--transfer;
}
}
for (auto &f : found) {
ans.push_back({idx2, idx1, f});
a[idx2].erase(f);
a[idx1].insert(f);
}
c[i].ctr += found.size();
c[j].ctr -= found.size();
if (c[i].ctr >= lo) {
++i;
}
if (c[j].ctr == hi) {
--j;
}
}
cout << ans.size() << '\n';
for (auto &f : ans) {
cout << f.from << ' ' << f.to << ' ' << f.type << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 410;
struct bign {
int len;
int s[MAXN];
bign() {
memset(s, 0, sizeof(s));
len = 1;
}
bign(const char *num) { *this = num; }
bign(int num) { *this = num; }
bign operator=(const int num) {
char s[MAXN];
sprintf(s, "%d", num);
*this = s;
return *this;
}
bign operator=(const char *num) {
for (int i = 0; num[i] == '0'; num++)
;
len = strlen(num);
for (int i = 0; i < len; i++) {
s[i] = num[len - i - 1] - '0';
}
return *this;
}
void clean() {
while (len > 1 && !s[len - 1]) len--;
}
string str() const {
string res = "";
for (int i = 0; i < len; i++) {
res = char(s[i] + '0') + res;
}
return res;
}
bool operator<(const bign &b) {
if (len != b.len) return len < b.len;
for (int i = len - 1; i >= 0; i--) {
if (s[i] != b.s[i]) return s[i] < b.s[i];
}
return false;
}
bign operator+(const bign &b) const {
bign c;
c.len = 0;
for (int i = 0, g = 0; g || i < max(len, b.len); i++) {
int x = g;
if (i < len) x += s[i];
if (i < b.len) x += b.s[i];
c.s[c.len++] = x % 10;
g = x / 10;
}
return c;
}
bign operator*(const bign &b) {
bign c;
c.len = len + b.len;
for (int i = 0; i < len; i++) {
for (int j = 0; j < b.len; j++) {
c.s[i + j] += s[i] * b.s[j];
}
}
for (int i = 0; i < c.len; i++) {
c.s[i + 1] += c.s[i] / 10;
c.s[i] %= 10;
}
c.clean();
return c;
}
bign operator-(const bign &b) {
bign c;
c.len = 0;
for (int i = 0, g = 0; i < len; i++) {
int x = s[i] - g;
if (i < b.len) x -= b.s[i];
if (x >= 0)
g = 0;
else {
g = 1;
x += 10;
}
c.s[c.len++] = x;
}
c.clean();
return c;
}
bign operator/(const bign &b) {
bign c, f = 0;
for (int i = len - 1; i >= 0; i--) {
f = f * 10;
f.s[0] = s[i];
while (!(f < b)) {
f = f - b;
c.s[i]++;
}
}
c.len = len;
c.clean();
return c;
}
bign operator%(const bign &b) {
bign r = *this / b;
r = *this - r * b;
return r;
}
};
istream &operator>>(istream &in, bign &x) {
string s;
in >> s;
x = s.c_str();
return in;
}
ostream &operator<<(ostream &out, const bign &x) {
out << x.str();
return out;
}
int main() {
bign d, k, a, b, t;
cin >> d >> k >> a >> b >> t;
bign rr = d / k;
bign yi(1);
bign result;
bign aaa = d * b;
bign bbb = ((rr) * (t) + rr * a * k + (d % k) * a);
bign ddd = ((rr - 1) * t + rr * a * k + (d % k) * b);
bign ccc = (b * (d - k) + a * k);
if (aaa < bbb)
result = aaa;
else
result = bbb;
if (ccc < result) result = ccc;
if (ddd < result) result = ddd;
cout << result << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long calc(long long n) {
long long m = n + 1;
if (n % 2 == 0)
n /= 2;
else
m /= 2;
long long res = n % MOD * (m % MOD) % MOD;
return res % MOD;
}
long long modmul(long long a) { return ((a % MOD) + MOD) % MOD; }
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long p = sqrt(n);
long long res = 0;
if (m > n) res = (m - n) % MOD * (n % MOD) % MOD;
for (int i = 1; i <= min(p, m); i++) {
res += n % i;
res %= MOD;
}
for (int a = 1; a <= min(p, m); a++) {
long long l = max(p + 1, n / (a + 1) + 1);
long long r = min(m, n / a);
if (l > r) continue;
res += n % MOD * ((r - l + 1) % MOD);
res %= MOD;
long long sum = calc(r) - calc(l - 1);
sum = modmul(sum);
sum = sum * (a % MOD);
sum %= MOD;
res -= sum;
res = modmul(res);
}
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef struct pp {
int pos;
int dif;
};
bool cmpp(int *a, int *b) {
int i = 0;
while (*(a + i) == *(b + i)) {
i++;
}
if (*(a + i) < *(b + i))
return true;
else
return false;
}
int cmp(const void *a, const void *b) {
if ((((struct pp *)a)->dif) != ((((struct pp *)b))->dif))
return (((struct pp *)a)->dif) - ((((struct pp *)b))->dif);
else
return (((struct pp *)a)->pos) - (((struct pp *)b)->pos);
}
int cmp2(const void *a, const void *b) {
if ((((struct pp *)a)->dif) != (((struct pp *)b)->dif))
return (((struct pp *)a)->dif) - (((struct pp *)b)->dif);
else
return -((((struct pp *)a)->pos) - (((struct pp *)b)->pos));
}
int main() {
int n, k;
char digit;
int num[10001];
struct pp dif1[10001], dif2[10001], adif[10001];
int ans[10], anss[10][10001];
cin >> n >> k;
for (int i = 0; i != n; i++) {
cin >> digit;
num[i] = digit - '0';
for (int m = 0; m != 10; m++) {
anss[m][i] = num[i];
}
}
for (int i = 0; i <= 9; i++) {
int t1 = 0, t2 = 0;
for (int m = 0; m != n; m++) {
if (i - num[m] >= 0) {
dif1[t1].dif = i - num[m];
dif1[t1++].pos = m;
} else {
dif2[t2].dif = num[m] - i;
dif2[t2++].pos = m;
}
adif[m].dif = abs(i - num[m]);
adif[m].pos = m;
}
qsort(adif, n, sizeof(struct pp), cmp);
qsort(dif1, t1, sizeof(struct pp), cmp2);
qsort(dif2, t2, sizeof(struct pp), cmp);
int sum = 0;
for (int m = 0; m != k; m++) {
sum = sum + adif[m].dif;
}
ans[i] = sum;
int maxx = adif[k - 1].dif - 1;
int dn = 0;
int w = 0;
while (dn < k && dif2[w].dif <= maxx && w < t2) {
anss[i][dif2[w].pos] -= dif2[w].dif;
w++;
dn++;
}
w = 0;
while (dn < k && dif1[w].dif <= maxx && w < t1) {
anss[i][dif1[w].pos] += dif1[w].dif;
dn++;
w++;
}
w = 0;
while (dn < k && dif2[w].dif <= maxx + 1 && w < t2) {
if (dif2[w].dif == maxx + 1) {
anss[i][dif2[w].pos] -= dif2[w].dif;
dn++;
}
w++;
}
w = 0;
while (dn < k) {
if (dif1[w].dif == maxx + 1) {
anss[i][dif1[w].pos] += dif1[w].dif;
dn++;
}
w++;
}
}
int rans = 100000, r;
for (int i = 0; i <= 9; i++) {
if (rans > ans[i]) {
r = i;
rans = ans[i];
} else if (rans == ans[i]) {
if (cmpp(anss[i], anss[r])) {
r = i;
}
}
}
cout << ans[r] << endl;
for (int i = 0; i != n; i++) {
cout << anss[r][i];
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void print(T& x) {
cout << x;
}
template <class T, class U>
void print(pair<T, U>& p) {
cout << "(";
print(p.first);
cout << ", ";
print(p.second);
cout << ")";
}
template <class T>
void print(vector<T>& v) {
cout << "{";
if (((int)(v).size())) print(v[0]);
for (int i = 1; i < ((int)(v).size()); i++) cout << ", ", print(v[i]);
cout << "}" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
int N, x, y;
cin >> T;
while (T--) {
cin >> N >> x >> y;
if (x > y || x > N) {
cout << "NO\n";
continue;
}
y -= x;
vector<vector<int>> M(N + 2);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
M[a].push_back(i);
}
int notOcc = -1;
vector<vector<int>> occ(N + 1);
for (int i = 1; i <= N + 1; i++) {
occ[((int)(M[i]).size())].push_back(i);
if (((int)(M[i]).size()) == 0) notOcc = i;
}
int used = 0;
vector<int> A(N, -1);
for (int cnt = N; cnt > 0; cnt--) {
while (x && ((int)(occ[cnt]).size())) {
int col = occ[cnt].back();
occ[cnt].pop_back();
A[M[col].back()] = col;
M[col].pop_back();
occ[cnt - 1].push_back(col);
used++;
x--;
}
}
bool pos = true;
for (int cnt = N; cnt > 0; cnt--) {
if (((int)(occ[cnt]).size()) > 0) {
if ((N - used - cnt) * 2 < y) {
pos = false;
}
break;
}
}
if (!pos) {
cout << "NO\n";
continue;
}
cout << "YES\n";
auto makeCyc = [&](vector<int>& c) {
for (int i = 0; i < ((int)(c).size()); i++) {
int c1 = c[i], c2 = c[(i + 1) % ((int)(c).size())];
A[M[c1].back()] = c2;
M[c1].pop_back();
}
y -= ((int)(c).size());
};
for (int cnt = N; cnt > 0; cnt--) {
if (y == 0) break;
if (((int)(occ[cnt]).size()) <= y) {
if (((int)(occ[cnt]).size()) == 1) {
int nxtI;
for (nxtI = cnt - 1; nxtI > 0; nxtI--)
if (((int)(occ[nxtI]).size())) break;
if (y == 1) {
A[M[occ[nxtI].back()].back()] = occ[cnt].back();
y--;
break;
} else {
vector<int> c;
c.push_back(occ[cnt][0]);
c.push_back(occ[nxtI].back());
makeCyc(c);
occ[nxtI - 1].push_back(occ[nxtI].back());
occ[nxtI].pop_back();
occ[cnt - 1].push_back(occ[cnt].back());
occ[cnt].pop_back();
}
} else {
makeCyc(occ[cnt]);
occ[cnt - 1].insert(occ[cnt - 1].end(), occ[cnt].begin(),
occ[cnt].end());
occ[cnt].clear();
}
} else {
if (y == 1) {
A[M[occ[cnt].back()].back()] = occ[cnt][0];
y--;
break;
} else {
vector<int> tmp;
for (int i = 0; i < y; i++) {
tmp.push_back(occ[cnt].back());
occ[cnt].pop_back();
}
makeCyc(tmp);
occ[cnt - 1].insert(occ[cnt - 1].end(), tmp.begin(), tmp.end());
}
}
}
for (int k : A) {
if (k == -1) k = notOcc;
cout << k << " ";
}
cout << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
int A[26];
long long sum = 0;
int max = -1;
for (int i = 0; i < 26; i++) {
cin >> A[i];
if (A[i] > max) max = A[i];
}
for (int i = 0; i < s.length(); i++) sum += (i + 1) * (A[s[i] - 'a']);
for (int i = s.length() + 1; i < s.length() + k + 1; i++) sum += (i * max);
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int mod = 1000000007;
struct P {
int x, y;
};
int dp[210][210];
int perm[210][210];
P p[210];
int n;
P operator-(const P &a, const P &b) { return (P){b.x - a.x, b.y - a.y}; }
int operator==(const P &a, const P &b) { return a.x == b.x && a.y == b.y; }
P middle(const P &a, const P &b) {
return (P){(a.x + b.x) / 2, (a.y + b.y) / 2};
}
long long det(const P &a, const P &b) {
return (long long)a.x * b.y - (long long)a.y * b.x;
}
template <class T>
inline T abs(T x) {
return x > 0 ? x : -x;
}
int sig(long long k) { return k ? k / abs(k) : 0; }
int online(P a, P b, P c) {
int f = abs(c.x - a.x) + abs(b.x - c.x) == abs(b.x - a.x);
f &= abs(c.y - a.y) + abs(b.y - c.y) == abs(b.y - a.y);
return f;
}
int iscrs(P a, P b, P c, P d) {
int abc = sig(det(b - a, c - a)), abd = sig(det(b - a, d - a));
if (abc * abd == 1) {
return 0;
}
if (abc == 0 && online(a, b, c) || abd == 0 && online(a, b, d)) {
return 1;
}
if (abc * abd == 0) {
return 0;
}
int cda = sig(det(d - c, a - c)), cdb = sig(det(d - c, b - c));
if (cda == 0 && online(c, d, a) || cdb == 0 && online(c, d, b)) {
return 1;
}
return cda * cdb == -1;
}
int inpoly(P a) {
int res = 0;
P tmp;
for (int i = 0; i < n; i++) {
P b = p[i] - a, c = p[i + 1] - a;
if (b.y > c.y) {
tmp = b;
b = c;
c = tmp;
}
if (b.y < 0 && c.y >= 0 && det(b, c) > 0) {
res ^= 1;
if (det(b, c) == 0) {
return 1;
}
}
}
return res;
}
int f(int i, int j) {
for (int k = 0; k < n; k++) {
if (p[i] == p[k] || p[j] == p[k]) {
continue;
}
if (det(p[k] - p[i], p[j] - p[i]) == 0 && online(p[i], p[j], p[k])) {
return 0;
}
if (p[i] == p[k + 1] || p[j] == p[k + 1]) {
continue;
}
if (iscrs(p[i], p[j], p[k], p[k + 1])) {
return 0;
}
}
return inpoly(middle(p[i], p[j]));
}
void add(int &t, int v) {
t += v;
if (t >= mod) t -= mod;
}
int count(int L, int R) {
if (R - L <= 1) {
return 1;
}
if (dp[L][R] != -1) {
return dp[L][R];
}
int &res = dp[L][R];
res = 0;
if (!perm[L][R]) {
return 0;
}
for (int i = L + 1; i < R; i++) {
if (perm[L][i] && perm[i][R]) {
int tmp = (long long)count(L, i) * count(i, R) % mod;
add(res, tmp);
}
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
p[i] = (P){x * 2, y * 2};
}
p[n] = p[0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (p[i] == p[j + 1] || p[i + 1] == p[j]) {
perm[i][j] = 1;
} else {
perm[i][j] = f(i, j);
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = -1;
}
}
printf("%d\n", count(0, n - 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int Abs(int a) { return a < 0 ? -a : a; }
struct point {
int a, b;
} p1, p2;
int main() {
int a, b;
while (cin >> a >> b) {
if (b >= 0) {
p1.a = 0;
p1.b = Abs(a) + b;
} else {
p1.a = 0;
p1.b = -(Abs(a) + Abs(b));
}
if (a >= 0) {
p2.a = a + Abs(b);
p2.b = 0;
} else {
p2.a = -(Abs(a) + Abs(b));
p2.b = 0;
}
if (p1.a < p2.a) {
cout << p1.a << " " << p1.b << " " << p2.a << " " << p2.b << endl;
} else
cout << p2.a << " " << p2.b << " " << p1.a << " " << p1.b << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 10000000;
int a[Maxn + 5], b[Maxn + 5];
int main() {
int n;
while (~scanf("%d", &n)) {
int flag = 0, i, j;
for (i = 1; i <= 2 * n; i++) scanf("%1d", &a[i]);
if (n > 1) {
sort(a + 1, a + 1 + n);
sort(a + n + 1, a + 1 + 2 * n);
for (i = 1, j = n + 1; i <= n; j++, i++) {
if (a[1] <= a[n + 1]) {
if (a[i] >= a[j]) {
flag = 1;
break;
}
} else if (a[1] > a[n + 1]) {
if (a[i] <= a[j]) {
flag = 1;
break;
}
}
}
}
if (n == 1)
if (a[1] == a[2]) flag = 1;
if (flag)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
const int MOD = 1000000007;
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int highestPowerof2(unsigned int n) {
if (n < 1) return 0;
int res = 1;
for (int i = 0; i < 8 * sizeof(unsigned int); i++) {
int curr = 1 << i;
if (curr > n) break;
res = curr;
}
return res;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int E[1000001], S[1000001], F[1000001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
string s;
cin >> s;
stack<int> stk;
for (int i = 0; i < 1000001; i++) F[i] = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '(')
stk.push(i);
else {
if (stk.empty())
S[i] = -1;
else {
int tp = stk.top();
stk.pop();
S[i] = tp;
E[i] = tp;
if (tp >= 1 && s[tp - 1] == ')' && S[tp - 1] != -1) {
E[i] = E[tp - 1];
}
F[i - E[i] + 1]++;
}
}
}
int mx = -1;
for (int i = 0; i < 1000001; i++) {
if (F[i] != 0) {
mx = max(mx, i);
}
}
if (mx == -1)
cout << "0 1\n";
else {
cout << mx << " " << F[mx] << "\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
long long int n, s;
cin >> n >> s;
long long int a[n], smax = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
smax += a[i];
}
for (int i = 0; i < n; i++) {
long long int xmin = s - (smax - a[i]);
long long int xmax = s - (n - 1);
long long int ans = 0;
if (xmax < a[i]) ans += (a[i] - xmax);
if (xmin > 1) ans += (xmin - 1);
cout << ans << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s, ans;
int main() {
while (~scanf("%d%d", &n, &m)) {
int k = 0;
cin >> s;
for (int i = 0; i < n - 1; i++) {
if (s.substr(0, i + 1) == s.substr(n - 1 - i)) k = i + 1;
}
cout << s;
for (int i = 1; i < m; i++) {
cout << s.substr(k);
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using llu = long long unsigned;
using ld = long double;
const int inf = 0x3c3c3c3c;
const ll infl = 0x3c3c3c3c3c3c3c3c;
int n, x, y;
string s;
int main() {
cin.tie(NULL);
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> n >> x >> y >> s;
int oc = 0, zc = 0;
if (s[0] == '0') zc++;
for (int i = 1; i < n; i++) {
if (s[i - 1] == '0' && s[i] == '1') oc++;
if (s[i - 1] == '1' && s[i] == '0') zc++;
}
ll ans = min(1LL * (oc - (s[n - 1] == '1')) * x + y, 1LL * zc * y);
ans = max(ans, 0LL);
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x[4], y[4], a[4], b[4];
int p[4][4][2];
vector<int> X, Y;
int dis(int x1, int y1, int x2, int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
int dot(int x1, int y1, int x2, int y2, int x3, int y3) {
return (x1 - x3) * (x2 - x3) + (y1 - y3) * (y2 - y3);
}
void solve() {
for (int i = 0; i < 4; i++) scanf("%d%d%d%d", &x[i], &y[i], &a[i], &b[i]);
for (int i = 0; i < 4; i++) {
p[i][0][0] = x[i];
p[i][0][1] = y[i];
for (int j = 1; j < 4; j++) {
int x = p[i][j - 1][0] - a[i];
int y = p[i][j - 1][1] - b[i];
p[i][j][0] = -y + a[i];
p[i][j][1] = x + b[i];
}
}
int Ans = 10000;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
for (int t = 0; t < 4; t++) {
X.clear(), Y.clear();
X.push_back(p[0][i][0]);
X.push_back(p[1][j][0]);
X.push_back(p[2][k][0]);
X.push_back(p[3][t][0]);
Y.push_back(p[0][i][1]);
Y.push_back(p[1][j][1]);
Y.push_back(p[2][k][1]);
Y.push_back(p[3][t][1]);
vector<int> tmp;
for (int ii = 0; ii < 4; ii++) tmp.push_back(ii);
int flag = 0;
do {
int dis1 = dis(X[tmp[0]], Y[tmp[0]], X[tmp[1]], Y[tmp[1]]);
int dis2 = dis(X[tmp[1]], Y[tmp[1]], X[tmp[2]], Y[tmp[2]]);
int dis3 = dis(X[tmp[2]], Y[tmp[2]], X[tmp[3]], Y[tmp[3]]);
int dis4 = dis(X[tmp[3]], Y[tmp[3]], X[tmp[0]], Y[tmp[0]]);
int dot1 = dot(X[tmp[0]], Y[tmp[0]], X[tmp[2]], Y[tmp[2]],
X[tmp[1]], Y[tmp[1]]);
int dot2 = dot(X[tmp[1]], Y[tmp[1]], X[tmp[3]], Y[tmp[3]],
X[tmp[2]], Y[tmp[2]]);
int dot3 = dot(X[tmp[2]], Y[tmp[2]], X[tmp[0]], Y[tmp[0]],
X[tmp[3]], Y[tmp[3]]);
int dot4 = dot(X[tmp[3]], Y[tmp[3]], X[tmp[1]], Y[tmp[1]],
X[tmp[0]], Y[tmp[0]]);
if (dis1 > 0 && dis1 == dis2 && dis2 == dis3 && dis3 == dis4 &&
dot1 == 0 && dot2 == 0 && dot3 == 0 && dot4 == 0)
flag = 1;
} while (next_permutation(tmp.begin(), tmp.end()));
if (flag) Ans = min(Ans, i + j + k + t);
}
}
}
}
if (Ans == 10000)
cout << "-1" << endl;
else
cout << Ans << endl;
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int n, v;
} e[1000100];
int n, k, esize;
int en[1010], in[1010], d[1010];
int s[6][1010], p[1010][6];
void addedge(int u, int v) {
e[esize].v = v;
e[esize].n = en[u];
en[u] = esize++;
}
queue<int> q;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < k; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &s[i][j]);
p[s[i][j]][i] = j;
}
memset(en, -1, sizeof(en));
memset(in, 0, sizeof(in));
esize = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
bool flag = true;
for (int l = 0; l < k; l++)
if (p[i][l] >= p[j][l]) {
flag = false;
break;
}
if (flag) {
addedge(i, j);
in[j]++;
}
}
memset(d, 0, sizeof(d));
int ans = 0;
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++)
if (!in[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
ans = max(d[u], ans);
for (int t = en[u]; t != -1; t = e[t].n) {
int v = e[t].v;
in[v]--;
d[v] = max(d[v], d[u] + 1);
if (!in[v]) q.push(v);
}
}
printf("%d\n", ans + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<string, pair<int, int> > Type;
char B[2000][2000];
pair<int, int> dice[300][300];
int main(int argc, char **argv) {
Type["........."] = make_pair(1, 1);
Type["....O...."] = make_pair(1, 1);
Type["O.......O"] = make_pair(1, 0);
Type["..O...O.."] = make_pair(0, 1);
Type["O...O...O"] = make_pair(1, 0);
Type["..O.O.O.."] = make_pair(0, 1);
Type["O.O...O.O"] = make_pair(1, 1);
Type["O.O.O.O.O"] = make_pair(1, 1);
Type["OOO...OOO"] = make_pair(1, 0);
Type["O.OO.OO.O"] = make_pair(0, 1);
int N, M;
cin >> N >> M;
for (int i = (0); i < (4 * N + 1); ++i) scanf("%s", B[i]);
for (int i = (0); i < (N); ++i)
for (int j = (0); j < (M); ++j) {
int cx = 4 * i + 1, cy = 4 * j + 1;
string s;
for (int p = (0); p < (3); ++p)
for (int q = (0); q < (3); ++q) s += B[cx + p][cy + q];
dice[i][j] = Type[s];
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
long long column[M], twocolumns[N][M];
memset(column, 0, sizeof(column));
memset(twocolumns, 0, sizeof(twocolumns));
for (int i = (0); i < (M); ++i) {
column[i] = !(N & 1);
for (int j = (0); j < (N / 2) && (column[i]); ++j)
column[i] = dice[2 * j][i].second & dice[2 * j + 1][i].second;
}
for (int i = (0); i < (N); ++i)
for (int j = (1); j < (M); ++j)
if (!i)
twocolumns[i][j] = dice[i][j].first & dice[i][j - 1].first;
else {
twocolumns[i][j] =
(twocolumns[i][j] +
dice[i][j].first * dice[i][j - 1].first * twocolumns[i - 1][j]) %
1000000007LL;
if (dice[i][j].second & dice[i - 1][j].second & dice[i][j - 1].second &
dice[i - 1][j - 1].second)
twocolumns[i][j] =
(twocolumns[i][j] + ((i == 1) ? 1 : twocolumns[i - 2][j])) %
1000000007LL;
}
for (int i = (1); i < (M); ++i)
if (column[i] && column[i - 1]) twocolumns[N - 1][i]--;
long long DP[M];
memset(DP, 0, sizeof(DP));
DP[0] = column[0];
DP[1] = twocolumns[N - 1][1];
for (int i = (1); i < (M); ++i) {
DP[i] = (DP[i] + column[i] * DP[i - 1]) % 1000000007LL;
if (i > 1)
DP[i] = (DP[i] + DP[i - 2] * twocolumns[N - 1][i]) % 1000000007LL;
}
cout << DP[M - 1] << endl;
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.