solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct val {
int x1, y1, x2, y2;
};
val d[150000];
multiset<int> minX, minY, maxX, maxY;
void hapus(val inp) {
multiset<int>::iterator it = minX.find(inp.x1);
minX.erase(it);
it = minY.find(inp.y1);
minY.erase(it);
it = maxX.find(inp.x2);
maxX.erase(it);
it = maxY.find(inp.y2);
maxY.erase(it);
}
void masuk(val inp) {
minX.insert(inp.x1);
minY.insert(inp.y1);
maxX.insert(inp.x2);
maxY.insert(inp.y2);
}
val getsq() {
val ret;
multiset<int>::iterator it = maxX.begin();
multiset<int>::reverse_iterator rit = minX.rbegin();
ret.x1 = *rit;
ret.x2 = *it;
it = maxY.begin();
rit = minY.rbegin();
ret.y1 = *rit;
ret.y2 = *it;
return ret;
}
int main() {
int n;
scanf("%d", &n);
for (int a = 0; a < n; a++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
d[a].x1 = x1;
d[a].y1 = y1;
d[a].x2 = x2;
d[a].y2 = y2;
minX.insert(x1);
minY.insert(y1);
maxX.insert(x2);
maxY.insert(y2);
}
for (int a = 0; a < n; a++) {
hapus(d[a]);
val now = getsq();
if (now.x1 <= now.x2 && now.y1 <= now.y2) {
printf("%d %d\n", now.x1, now.y1);
break;
}
masuk(d[a]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double l, p, q;
while (~scanf("%lf %lf %lf", &l, &p, &q)) {
l = l * p / (p + q);
printf("%lf\n", l);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long v;
cin >> v;
if (v == 1) {
cout << 1 << " " << 1 << endl;
cout << 1;
} else {
long ans = (v - 1) * 2;
cout << ans << " " << 2 << endl;
cout << 1 << " " << 2;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x[101][101];
int markc[101];
int mark[101];
int mark2[101];
int ans[101];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> x[i][j];
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= k; i++) mark2[i] = 0;
for (int i = 1; i <= n; i++)
if (markc[i] == 0) mark2[x[i][j]]++;
for (int i = 1; i <= k; i++)
if (mark2[i] > 1) mark[i] = 1;
for (int i = 1; i <= n; i++)
if (markc[i] == 0) {
if (mark[x[i][j]] == 1) {
markc[i] = 1;
ans[i] = j;
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n = 6;
long long a[n];
long long i = 0;
while (n--) {
cin >> a[i];
i++;
}
sort(a, a + 6);
vector<long long> v;
for (long long i = 0; i < 6; i++) {
long long cnt = 1;
for (long long j = i + 1; j < 6; j++) {
if (a[i] == a[j]) {
cnt++;
i = j;
} else {
break;
}
}
v.push_back(cnt);
}
sort(v.rbegin(), v.rend());
if (v[0] == 4 && v[1] == 1 && v[2] == 1 || v[0] == 5) {
cout << "Bear" << endl;
} else if (v[0] == 4 && v[1] == 2 || v[0] == 6) {
cout << "Elephant" << endl;
} else {
cout << "Alien" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int a[1010];
int main() {
int n;
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (sum % n != 0)
printf("Unrecoverable configuration.\n");
else {
int k = sum / n, p, q, x, y;
p = q = 0;
for (int i = 1; i <= n; i++)
if (a[i] < k) {
p++;
x = i;
} else if (a[i] > k) {
q++;
y = i;
}
if (p == 0 && q == 0)
printf("Exemplary pages.\n");
else if (p == 1 && q == 1)
printf("%d ml. from cup #%d to cup #%d.\n", k - a[x], x, y);
else
printf("Unrecoverable configuration.\n");
}
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000 + 7;
const double esp = 1e-13;
const double pi = 3.141592653589;
int n, m, x, y, f[4000 + 10][4000 + 10], ans, u, v, d;
vector<int> a[4000 + 10];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
f[x][y]++;
f[y][x]++;
a[x].push_back(y);
a[y].push_back(x);
}
ans = INF;
for (int i = 1; i <= n; i++)
if (a[i].size() >= 2) {
for (int j = 0; j < a[i].size(); j++)
for (int k = j + 1; k < a[i].size(); k++) {
u = a[i][j];
v = a[i][k];
d = a[i].size() + a[u].size() + a[v].size() - 6;
if (f[u][v]) ans = min(ans, d);
}
}
if (ans == INF)
cout << -1;
else
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> id;
for (int i = 0; i < n && id.size() < k / 2; ++i) {
if (s[i] == '(') {
id.emplace_back(i);
}
}
for (int i = n - 1; i >= 0 && id.size() < k; --i) {
if (s[i] == ')') {
id.emplace_back(i);
}
}
sort((id).begin(), (id).end());
for (auto i : id) {
cout << s[i];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int arr[2 * n];
for (int i = 0; i < 2 * n; i++) cin >> arr[i];
sort(arr, arr + (2 * n));
long long int sum1 = 0;
long long int sum2 = 0;
for (int i = 0; i < n; i++) sum1 += arr[i];
for (int i = n; i < 2 * n; i++) sum2 += arr[i];
if (sum1 == sum2)
cout << -1 << endl;
else {
for (int i = 0; i < 2 * n; i++) cout << arr[i] << " ";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double dp[7][2][3];
int vis[7][2][3], v;
int st[9], en[9];
double dp_func(int pos, int boro, int eq) {
if (pos == 0) {
if (eq && boro == 1) return v;
if (eq >= 2) return v;
return 0;
}
double l, k, r, d, ret = 0;
if (vis[pos][boro][eq] != 0) return dp[pos][boro][eq];
if (st[pos] < v) {
l = st[pos];
k = min(v - 1, en[pos]);
r = k - l + 1;
d = en[pos] - st[pos] + 1;
ret = ret + (dp_func(pos - 1, boro, eq) * r);
}
if (st[pos] <= v && en[pos] >= v) {
d = en[pos] - st[pos] + 1;
ret = ret + dp_func(pos - 1, boro, min(2, eq + 1));
}
if (boro == 0 && en[pos] > v) {
d = en[pos] - st[pos] + 1;
k = en[pos];
l = max(st[pos], v + 1);
r = k - l + 1;
ret = ret + (dp_func(pos - 1, 1, eq) * r);
}
d = en[pos] - st[pos] + 1;
ret = ret / d;
vis[pos][boro][eq] = 1;
return dp[pos][boro][eq] = ret;
}
int main() {
int i, j, k, l, m, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &st[i], &en[i]);
}
double sum = 0;
for (int i = 1; i <= 10000; i++) {
memset(vis, 0, sizeof vis);
v = i;
sum += dp_func(n, 0, 0);
}
printf("%.15f\n", sum);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> matching(100001, -1), buyer(100001, -1);
vector<vector<int> > graph(100000);
struct shoeShelf {
int shoeCost;
int shoeSize;
int index;
};
bool compare(const shoeShelf &firstShoeShelf,
const shoeShelf &secondShoeShelf) {
return firstShoeShelf.shoeSize < secondShoeShelf.shoeSize;
}
bool compare1(const shoeShelf &firstShoeShelf,
const shoeShelf &secondShoeShelf) {
return firstShoeShelf.shoeCost > secondShoeShelf.shoeCost;
}
bool kuhn(int i) {
for (vector<int>::iterator it = graph[i].begin(); it != graph[i].end();
it++) {
if (matching[*it] == i) continue;
if (matching[*it] == -1 || kuhn(matching[*it])) {
matching[*it] = i;
buyer[i] = *it;
return 1;
}
}
return 0;
}
int main() {
int n, m;
cin >> n;
vector<shoeShelf> allShoes(n);
for (int i = 0; i < n; i++) {
cin >> allShoes[i].shoeCost >> allShoes[i].shoeSize;
allShoes[i].index = i;
}
sort(allShoes.begin(), allShoes.end(), compare);
cin >> m;
for (int i = 0; i < m; i++) {
shoeShelf currentBuyer;
cin >> currentBuyer.shoeCost >> currentBuyer.shoeSize;
vector<shoeShelf>::iterator it;
it = lower_bound(allShoes.begin(), allShoes.end(), currentBuyer, compare);
if (it->shoeSize == currentBuyer.shoeSize &&
it->shoeCost <= currentBuyer.shoeCost)
graph[it->index].push_back(i);
currentBuyer.shoeSize++;
it = lower_bound(allShoes.begin(), allShoes.end(), currentBuyer, compare);
if (it->shoeSize == currentBuyer.shoeSize &&
it->shoeCost <= currentBuyer.shoeCost)
graph[it->index].push_back(i);
}
sort(allShoes.begin(), allShoes.end(), compare1);
int totalBuyers = 0;
long long totalSum = 0;
for (int i = 0; i < n; i++)
if (kuhn(allShoes[i].index)) {
totalSum += allShoes[i].shoeCost;
totalBuyers++;
}
cout << totalSum << "\n" << totalBuyers << "\n";
for (int i = 0; i < n; i++)
if (buyer[i] != -1) cout << buyer[i] + 1 << " " << i + 1 << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
typedef std::priority_queue<int, vector<int>, greater<int>> small_pq;
typedef std::priority_queue<int, vector<int>, less<int>> big_pq;
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &v) {
os << '{';
string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() {}
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << " " << H;
if (sizeof...(T) > 0) cerr << " ,";
dbg_out(T...);
}
void dbg_name(const string &s) {
string ss = s;
replace(ss.begin(), ss.end(), ',', ' ');
cerr << " ( " << ss << " ) ";
}
template <typename T>
inline void setmin(T &a, const T &b) {
if (b < a) a = b;
}
template <typename T>
inline void setmax(T &a, const T &b) {
if (b > a) a = b;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
unordered_map<long long, int, custom_hash> safe_map;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rnd64(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 998244353;
int mul(int x, int y) { return 1ll * x * y % MOD; }
int add(int x, int y) { return ((x + y) % MOD + MOD) % MOD; }
int sub(int x, int y) { return ((x - y) % MOD + MOD) % MOD; }
int qpow(int a, int b) {
long long ans = 1;
while (b) {
if (b & 1) ans = mul(ans, a);
a = mul(a, a);
b /= 2;
}
return ans;
}
const int N = 1e4 + 5;
namespace Suffix {
int sa[N], rk[N * 2], oldrk[N * 2], cnt[N * 2], id[N], px[N * 2];
int ht[N];
bool cmp(int x, int y, int w) {
return oldrk[x] == oldrk[y] && oldrk[x + w] == oldrk[y + w];
}
void suffix_array(char *s) {
memset(cnt, 0, sizeof(cnt));
memset(rk, 0, sizeof(rk));
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) rk[i] = s[i];
int m = 300;
for (int i = 1; i <= n; i++) cnt[rk[i]]++;
for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (int i = n; i >= 1; i--) sa[cnt[rk[i]]--] = i;
for (int w = 1; w < n; w <<= 1) {
int p = 0;
for (int i = n; i > n - w; i--) id[++p] = i;
for (int i = 1; i <= n; i++)
if (sa[i] > w) id[++p] = sa[i] - w;
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++) cnt[px[i] = rk[id[i]]]++;
for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (int i = n; i >= 1; i--) sa[cnt[px[i]]--] = id[i];
memcpy(oldrk, rk, sizeof(rk));
p = 0;
for (int i = 1; i <= n; i++) rk[sa[i]] = cmp(sa[i], sa[i - 1], w) ? p : ++p;
m = p;
}
for (int i = 1, k = 0; i <= n; i++) {
if (k) k--;
while ((i + k <= n) && s[i + k] == s[sa[rk[i] - 1] + k]) k++;
ht[rk[i]] = k;
}
}
} // namespace Suffix
const int M = 14;
char s[N];
int dp[N];
int f[N][M];
int calc(int i, int j) {
int s = log2(j - i + 1);
return min(f[i][s], f[j - (1 << s) + 1][s]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
using namespace Suffix;
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d %s", &n, s + 1);
Suffix::suffix_array(s);
for (int(i) = int(1); int(i) <= int(n); i++) {
f[i][0] = Suffix::ht[i];
}
for (int(i) = int(1); int(i) <= int(M - 1); i++) {
for (int(j) = int(1); int(j) <= int(n); j++) {
f[j][i] = min(f[j][i - 1], f[j + (1 << (i - 1))][i - 1]);
}
}
int ans = 0;
for (int(i) = int(1); int(i) <= int(n); i++) {
dp[i] = n - i + 1;
for (int(j) = int(1); int(j) <= int(i - 1); j++) {
if (Suffix::rk[i] > Suffix::rk[j])
dp[i] = max(dp[i], dp[j] + (n - i + 1) - calc(rk[j] + 1, rk[i]));
}
ans = max(ans, dp[i]);
}
cout << ans << endl;
fill(dp + 1, dp + 1 + n, 0);
for (int(i) = int(0); int(i) <= int(M - 1); i++)
for (int(j) = int(1); int(j) <= int(n); j++) f[j][i] = 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<long long, long long> P;
map<long long, long long> N;
long long n, r = 0;
cin >> n;
long long s = 0;
N[0] = 1;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
s = s ^ a;
if (i % 2 == 0) {
r = r + P[s];
P[s]++;
} else {
r = r + N[s];
N[s]++;
}
}
cout << r;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z, l, w, h;
cin >> x >> y >> z;
long long Min = min(x, min(y, z)), Max = max(x, max(y, z)),
mid = (x + y + z) - (Max + Min);
l = sqrt((Max * mid) / Min);
h = mid / l;
w = Min / h;
cout << (l + h + w) * 4 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string fu;
int fuu;
int num;
char an;
int lp = -2000000000;
int rp = 2000000000;
int main() {
int n;
cin >> n;
while (n--) {
cin >> fu >> num >> an;
if (fu == ">=") fuu = 1;
if (fu == ">") fuu = 2;
if (fu == "<=") fuu = 3;
if (fu == "<") fuu = 4;
if (an == 'N') {
if (fuu == 1)
fuu = 4;
else if (fuu == 2)
fuu = 3;
else if (fuu == 3)
fuu = 2;
else if (fuu == 4)
fuu = 1;
}
switch (fuu) {
case 1:
if (num >= lp) lp = num;
break;
case 2:
if (num + 1 >= lp) lp = num + 1;
break;
case 3:
if (num <= rp) rp = num;
break;
case 4:
if (num - 1 <= rp) rp = num - 1;
break;
}
}
if (lp <= rp)
cout << lp << endl;
else
cout << "Impossible" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void shikhar7s(long long int cas) {
long long int n, i, j;
cin >> n;
long long int a[n][n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> a[i][j];
}
}
long long int x[n];
for (i = 0; i < n; i++) {
cin >> x[i];
x[i]--;
}
long long int k, s = 0;
vector<long long int> ans, m(n, 0);
for (i = n - 1; i >= 0; i--) {
s = 0;
m[x[i]] = 1;
for (j = 0; j < n; j++) {
for (k = 0; k < n; k++) {
a[j][k] = min(a[j][k], a[j][x[i]] + a[x[i]][k]);
if (m[j] && m[k]) s += a[j][k];
}
}
ans.push_back(s);
}
for (i = (long long int)ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
}
signed main() {
std::ios_base::sync_with_stdio(false);
long long int t = 1;
long long int cas = 1;
while (cas <= t) {
shikhar7s(cas);
cas++;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
int mod_add(int a, int b, int m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
int mod_mul(int a, int b, int m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
int mod_sub(int a, int b, int m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
const long long mxm = 2 * 1e5;
long long M = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
long long expo(long long a, long long b, long long m) {
if (b == 0) {
return 1;
}
if (b % 2 == 0) {
long long temp = expo(a, b / 2, m);
return (temp % m * temp % m) % m;
} else {
long long temp = expo(a, b / 2, m);
return (a % m * temp % m * temp % m) % m;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n % 2 == 0) {
cout << n / 2 << ' ' << n / 2 - 1 << ' ' << 1 << "\n";
} else {
long long a = (n + 1) / 2;
long long b = n / 2;
if (b % 2 == 0) {
cout << (n + 1) / 2 << ' ' << (n / 2) - 1 << ' ' << 1 << ' ' << "\n";
} else {
cout << (n + 1) / 2 + 1 << ' ' << (n / 2) - 2 << ' ' << 1 << "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void Yes() { printf("Yes\n"); }
void No() { printf("No\n"); }
const long long mod = 1e9 + 7;
template <typename T>
T gcf(T a, T b) {
return (b == 0) ? a : gcf(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return (a * b) / gcf(a, b);
}
template <typename T>
T sumTo(T x) {
return x * (x + 1) / 2;
}
template <typename T>
T sumSquaresTo(T x) {
return x * (x + 1) * (2 * x + 1) / 6;
}
template <typename T>
T ceilDiv(T n, T d) {
return (n + d - 1) / d;
}
void solve() {
int n;
scanf("%d", &n);
string s, t;
cin >> s >> t;
int idx1 = -1, idx2 = -1;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
if (idx2 >= 0) {
No();
return;
} else if (idx1 >= 0) {
idx2 = i;
} else {
idx1 = i;
}
}
}
if ((idx1 == -1) != (idx2 == -1)) {
No();
return;
}
if (idx1 == idx2) {
bool reached[26];
for (int i = 0; i < 26; i++) reached[i] = 0;
for (char c : s) {
int ci = (int)c - (int)'a';
if (reached[ci]) {
Yes();
return;
}
reached[ci] = 1;
}
No();
return;
}
if (s[idx1] == s[idx2] && t[idx2] == t[idx1]) {
Yes();
} else {
No();
}
}
int main() {
int t = 1;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int a[110], b[110], c[110], use[110], n;
int cal(int x, int y) {
int ans = 0, i;
int now = y;
use[y] = 1;
do {
for (i = 1; i < n; i++)
if (a[i] == now && !use[b[i]]) break;
if (i != n)
now = b[i];
else {
int j;
for (j = 1; j < n; j++)
if (b[j] == now && !use[a[j]]) break;
if (j != n) {
now = a[j];
ans += c[j];
} else
break;
}
use[now] = 1;
} while (now != x);
return ans;
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
memset(use, 0, sizeof(use));
int ans1 = cal(a[0], b[0]);
memset(use, 0, sizeof(use));
int ans2 = cal(b[0], a[0]) + c[0];
printf("%d\n", ans1 < ans2 ? ans1 : ans2);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const long double EPS = 1e-9;
const long double PI = fabsl(atan2l(0.0, -1.0));
int n, m;
long long h[111111];
long long p[111111];
void load() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lld", &h[i]);
}
for (int i = 0; i < m; i++) {
scanf("%lld", &p[i]);
}
}
inline bool can(long long x1, long long x2, long long x, long long t) {
if (x <= x1) {
return x2 - x <= t;
}
if (x >= x2) {
return x - x1 <= t;
}
long long a = x - x1 + x2 - x1;
long long b = x2 - x + x2 - x1;
return min(a, b) <= t;
}
bool check(long long t) {
int from = 0;
for (int i = 0; i < n; i++) {
if (from == m) {
break;
}
int left = from;
int right = m;
while (right - left > 1) {
int md = (left + right) / 2;
if (can(p[from], p[md], h[i], t)) {
left = md;
} else {
right = md;
}
}
from = can(p[from], p[left], h[i], t) ? left + 1 : left;
}
return from == m;
}
void solve() {
long long left = -1;
long long right = 1LL << 60;
while (right - left > 1) {
long long md = (left + right) / 2;
if (check(md)) {
right = md;
} else {
left = md;
}
}
cout << right << "\n";
}
int main() {
clock_t start = clock();
load();
solve();
;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 179;
int dist[maxn][maxn];
vector<vector<int>> lr;
vector<vector<int>> rl;
vector<int> p;
bool used[1179];
bool dfs(int v) {
used[v] = true;
for (int u : lr[v]) {
if (p[u] == -1 || (!used[p[u]] && dfs(p[u]))) {
p[u] = v;
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
dist[i][j] = numeric_limits<int>::max() / 2;
for (int i = 0; i < (int)(n); i++) dist[i][i] = 0;
for (int i = 0; i < (int)(m); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
if (u == v) continue;
dist[u][v] = dist[v][u] = 1;
}
for (int k = 0; k < (int)(n); k++) {
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(n); j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
int s, b;
long long k, h;
cin >> s >> b >> k >> h;
lr.resize(s);
rl.resize(b);
vector<int> xs(s), a(s), f(s);
for (int i = 0; i < (int)(s); i++) {
cin >> xs[i] >> a[i] >> f[i];
xs[i]--;
}
vector<int> xb(b), d(b);
for (int i = 0; i < (int)(b); i++) {
cin >> xb[i] >> d[i];
xb[i]--;
}
for (int i = 0; i < (int)(s); i++) {
for (int j = 0; j < (int)(b); j++) {
if (dist[xs[i]][xb[j]] <= f[i] && a[i] >= d[j]) {
lr[i].push_back(j);
rl[j].push_back(i);
}
}
}
p.resize(b, -1);
int msz = 0;
for (int i = 0; i < (int)(s); i++) {
memset(used, 0, sizeof(used));
if (dfs(i)) {
msz++;
}
}
long long mincost = min(msz * k, h * s);
cout << mincost << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int t[n];
for (int i = 0; i < n; i++) {
cin >> t[i];
}
sort(t, t + n);
int s = n, h = 1;
int ref = 0;
for (int i = 1; i < n; i++) {
int count = 0;
while (t[i] == t[ref]) {
count++;
i++;
}
ref = i;
s -= count;
h = max(h, count + 1);
}
cout << h << " " << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[26];
int main() {
int n;
scanf("%d", &n);
string s;
cin >> s;
if (n > 26) {
printf("-1");
return 0;
}
for (int i = 0; i < n; i++) {
arr[s[i] - 'a']++;
}
int ans = 0;
for (int i = 0; i < 26; i++) {
if (arr[i] > 1) {
ans += arr[i] - 1;
}
}
printf("%d", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char f(char c) {
if (c == 's')
return 'p';
else if (c == 'p')
return 'r';
else
return 's';
}
int main() {
int w = 0, ans = 4;
string txt[3];
cin >> txt[0] >> txt[1] >> txt[2];
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (f(txt[i][0]) == txt[j][0]) {
w++, ans = i;
break;
}
}
}
if (w > 1 || ans == 4) return cout << '?' << endl, 0;
if (ans == 0)
cout << 'F' << endl;
else if (ans == 1)
cout << 'M' << endl;
else
cout << 'S' << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30 + 5, M = 1e9 + 7, oo = -1e9;
int b, g, n;
long long dp[N][N];
long long chose(long long n, long long k) {
if (k == 0 || k == n) return 1;
long long& re = dp[n][k];
if (re != -1) return re;
re = chose(n - 1, k - 1) + chose(n - 1, k);
return re;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
memset(dp, -1, sizeof dp);
cin >> b >> g >> n;
long long ans = 0;
for (int i = 4; i <= b; ++i) {
if (n - i <= g && n - i >= 1) {
ans += chose(b, i) * chose(g, n - i);
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, init[100100], goal[100100];
vector<int> a[100100], ans;
void dfs(int x, int par, int depth, int oddXor, int evenXor) {
if (depth)
init[x] ^= oddXor;
else
init[x] ^= evenXor;
int res = init[x] ^ goal[x];
if (depth)
oddXor ^= res;
else
evenXor ^= res;
if (res) ans.push_back(x);
for (int i = 0; i < int(a[x].size()); i++) {
int y = a[x][i];
if (y != par) dfs(y, x, depth ^ 1, oddXor, evenXor);
}
}
int main() {
ios::sync_with_stdio(0);
int x, y;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (int i = 1; i <= n; i++) cin >> init[i];
for (int i = 1; i <= n; i++) cin >> goal[i];
dfs(1, 0, 0, 0, 0);
cout << ans.size() << endl;
for (int i = 0; i < int(ans.size()); i++) cout << ans[i] << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int debts[100][100];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y, sum;
cin >> x >> y >> sum;
debts[x - 1][y - 1] = sum;
}
int res = 0;
for (int i = 0; i < n; ++i) {
int tmp = 0;
for (int j = 0; j < n; ++j) {
tmp += debts[i][j];
tmp -= debts[j][i];
}
res += max(0, tmp);
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, long long> m;
unordered_map<long long, long long>::iterator itm;
vector<long long> v;
vector<long long>::iterator it;
int main() {
long long n, j, t, b[100005], i, mx = 0, a[100005], pos = -1, sumx = 0,
sumy = 0, c[100005], flag = 0, tempx, tempy,
res;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
sumx += a[i];
sumy += b[i];
c[i] = a[i] - b[i];
}
res = abs(sumx - sumy);
for (i = 0; i < n; i++) {
tempx = sumx - a[i] + b[i];
tempy = sumy - b[i] + a[i];
if (res < abs(tempx - tempy)) {
pos = i;
res = abs(tempx - tempy);
}
}
cout << pos + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q = 0;
string s, t;
for (int i = 1; i <= 3; i++) {
cin >> s >> t;
if (q == 1)
cout << s << "\n" << t << "\n";
else {
if (s[3] == '.') {
s[3] = 'P';
q = 1;
} else if (s[4] == '.') {
s[4] = 'P';
q = 1;
} else if (t[3] == '.') {
t[3] = 'P';
q = 1;
} else if (t[4] == '.') {
t[4] = 'P';
q = 1;
} else if (s[1] == '.') {
s[1] = 'P';
q = 1;
} else if (s[0] == '.') {
s[0] = 'P';
q = 1;
} else if (s[6] == '.') {
s[6] = 'P';
q = 1;
} else if (s[7] == '.') {
s[7] = 'P';
q = 1;
} else if (t[0] == '.') {
t[0] = 'P';
q = 1;
} else if (t[1] == '.') {
t[1] = 'P';
q = 1;
} else if (t[6] == '.') {
t[6] = 'P';
q = 1;
} else if (t[7] == '.') {
t[7] = 'P';
q = 1;
}
cout << s << "\n" << t << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, i, a[101], b[101], c[101], d = 1000000001, e, j;
int main() {
cin >> n >> m >> k;
for (i = 1; i <= m; i++) cin >> a[i];
for (i = 1; i <= k; i++) cin >> b[i];
for (i = 1; i <= m; i++) {
for (j = 1; j <= k; j++) {
if (b[j] % a[i] == 0) c[i]++;
}
if (c[i] < d) d = c[i];
}
for (i = 1; i <= m; i++)
if (c[i] == d) e++;
cout << e << endl;
for (i = 1; i <= m; i++)
if (c[i] == d) cout << i << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long double PI = 3.14159265358979323846;
long long modo = 1e9 + 7;
const long long inf = 1e12;
const long long ms = (1e5 * 2) + 5;
long long dp[ms][2] = {0};
long long ar[ms];
long long br[ms];
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
int n;
cin >> n;
long long c;
cin >> c;
dp[1][1] = c;
int i;
for (i = 2; i <= n; i++) {
cin >> ar[i];
}
for (i = 2; i <= n; i++) {
cin >> br[i];
}
for (i = 2; i <= n; i++) {
dp[i][0] = min(ar[i] + dp[i - 1][0], ar[i] + dp[i - 1][1]);
dp[i][1] = min(br[i] + dp[i - 1][0] + c, br[i] + dp[i - 1][1]);
}
for (i = 1; i <= n; i++) {
cout << min(dp[i][0], dp[i][1]) << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using ii = pair<int, int>;
using ll = pair<lint, lint>;
using ti = tuple<int, int, int>;
using il = pair<int, lint>;
namespace T {
const int MAX = 1e5 + 5;
const int INF = 1e9 + 7;
const int N = 1e6 + 5;
int max_t[4 * MAX];
int min_t[4 * MAX];
void init() {
for (int i = 0; i < 4 * MAX; i++) {
max_t[i] = min_t[i] = 0;
}
}
void max_up(int n, int s, int e, int p, int v) {
if (p < s || p > e) return;
if (s == e)
max_t[n] = v;
else {
max_up(2 * n, s, (s + e) / 2, p, v);
max_up(2 * n + 1, (s + e) / 2 + 1, e, p, v);
max_t[n] = max(max_t[2 * n], max_t[2 * n + 1]);
}
}
void min_up(int n, int s, int e, int p, int v) {
if (p < s || p > e) return;
if (s == e)
min_t[n] = v;
else {
min_up(2 * n, s, (s + e) / 2, p, v);
min_up(2 * n + 1, (s + e) / 2 + 1, e, p, v);
min_t[n] = min(min_t[2 * n], min_t[2 * n + 1]);
}
}
int max_v(int n, int s, int e, int l, int r) {
if (r < s || l > e) return 0;
if (l <= s && e <= r) return max_t[n];
int m = (s + e) / 2;
return max(max_v(2 * n, s, m, l, r), max_v(2 * n + 1, m + 1, e, l, r));
}
int min_v(int n, int s, int e, int l, int r) {
if (r < s || l > e) return INF;
if (l <= s && e <= r) return min_t[n];
int m = (s + e) / 2;
return min(min_v(2 * n, s, m, l, r), min_v(2 * n + 1, m + 1, e, l, r));
}
class fenwick {
public:
lint tree[N] = {
0,
};
void update(int p, lint v) {
while (p < N) {
tree[p] += v;
p += p & -p;
}
}
lint sum(int p) {
if (p == 0) {
return 0LL;
}
lint ret = 0;
while (p) {
ret += tree[p];
p -= p & -p;
}
return ret;
}
lint sum(int x, int y) { return sum(y) - sum(x - 1); }
};
} // namespace T
namespace P {
const int N = 2 * 1e6 + 5;
using lint = long long;
bool v[N];
void make() {
fill(v, v + N, true);
for (int i = 2; i < N; i++) {
if (v[i]) {
for (lint j = (lint)i * i; j < N; j += i) {
v[j] = false;
}
}
}
}
} // namespace P
namespace U {
int min3(int a, int b, int c) { return min(min(a, b), c); }
int min4(int a, int b, int c, int d) { return min(min(a, b), min(c, d)); }
int max3(int a, int b, int c) { return max(max(a, b), c); }
int max4(int a, int b, int c, int d) { return max(max(a, b), max(c, d)); }
bool get(char c) {
return (c == 'a') || (c == 'e') || (c == 'i') || (c == 'o') || (c == 'u');
}
int gcd(int a, int b) {
if (a < b) {
swap(a, b);
}
if (b == 0)
return a;
else
return gcd(b, a % b);
}
} // namespace U
namespace C {
int get(const vector<int>& v, int key) {
int l = 0;
int r = (int)(v.size()) - 1;
while (l <= r) {
int m = (l + r) / 2;
if (v[m] == key) {
return m;
} else if (v[m] < key) {
l = m + 1;
} else {
r = m - 1;
}
}
}
vector<int> compress(const vector<int>& v) {
vector<int> val = v;
sort(val.begin(), val.end());
val.erase(unique(val.begin(), val.end()), val.end());
vector<int> re = v;
for (int& x : re) {
x = get(val, x) + 1;
}
return re;
}
} // namespace C
lint x, y, z;
void input() {}
int n;
const int N = 1e5 + 5;
char s[N];
int l;
string get(int x) {
vector<char> v1;
vector<char> v2;
vector<char> v3;
for (int i = 0; i < x; i++) {
v1.push_back(s[i]);
}
for (int i = x; i < l; i++) {
v2.push_back(s[i]);
}
reverse(v1.begin(), v1.end());
reverse(v2.begin(), v2.end());
v3.push_back('0');
for (int i = 0; i < max(v1.size(), v2.size()); i++) {
int x = 0;
int y = 0;
if (i < v1.size()) {
x = v1[i] - '0';
}
if (i < v2.size()) {
y = v2[i] - '0';
}
int z = v3[i] - '0';
int w = x + y + z;
v3[i] = w % 10 + '0';
v3.push_back(w / 10 + '0');
}
while (v3.back() == '0') {
v3.pop_back();
}
string re;
reverse(v3.begin(), v3.end());
for (char c : v3) {
re.push_back(c);
}
return re;
}
void go() {
scanf("%d", &l);
scanf("%s", s);
l = strlen(s);
int st = l / 2;
string s1, s2;
for (int i = 0; i < 1e6; i++) {
s1.push_back('9');
s2.push_back('9');
}
for (int i = st; i > 0; i--) {
if (s[i] != '0') {
s1 = get(i);
break;
}
}
for (int i = st + 1; i < l; i++) {
if (s[i] != '0') {
s2 = get(i);
break;
}
}
if (s1.length() > s2.length()) {
cout << s2;
} else if (s1.length() < s2.length()) {
cout << s1;
} else {
if (s1 > s2) {
cout << s2;
} else {
cout << s1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
go();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<long long> a(n - 1);
for (long long i = 0; i < (long long)n - 1; i++) cin >> a[i];
long long p = n;
vector<long long> c = {n};
while (p > 1) {
p = a[p - 2];
c.push_back(p);
}
for (long long i = 0; i < (long long)c.size(); i++)
cout << c[c.size() - i - 1] << ' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int grp0 = 0;
bool it = true;
int cnt0 = 0, cnt1 = 0;
for (char c : s) {
if (c == '0') {
cnt0++;
if (it) grp0++;
it = false;
} else {
cnt1++;
it = true;
}
}
if (cnt1 == 0)
cout << 1 << endl;
else if (cnt0 == 0)
cout << 0 << endl;
else if (grp0 >= 2)
cout << 2 << endl;
else
cout << grp0 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
char ch[1009];
int arr[1009];
int solve(int i, int j) {
int flag = 1;
int temp = arr[i] + j;
if (i - 1 >= 0 && arr[i - 1] == temp) flag = 0;
if (i - 2 >= 0 && arr[i - 2] == temp) flag = 0;
return flag;
}
void solve2(int i, int j) {
for (int k = i + 1; k < n; k++) {
for (int j = 1; j <= p; j++) {
int flag = 1;
if (k - 1 >= 0 && arr[k - 1] == j) flag = 0;
if (k - 2 >= 0 && arr[k - 2] == j) flag = 0;
if (flag) {
arr[k] = j;
break;
}
}
}
}
int main() {
cin >> n >> p;
cin >> ch;
for (int i = 0; i < n; i++) {
arr[i] = ch[i] - 'a' + 1;
}
if (p == 2 && n > 2) {
cout << "NO" << endl;
return 0;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j <= p; j++) {
if (arr[i] + j > p)
break;
else {
if (solve(i, j)) {
arr[i] += j;
solve2(i, j);
for (int i = 0; i < n; i++) ch[i] = arr[i] - 1 + 'a';
cout << ch << endl;
return 0;
}
}
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxnv = 1e6;
int nv, n, m;
vector<int> g[maxnv];
void Init(int n) {
nv = n * 2;
for (int i = 0; i < nv; ++i) {
g[i].clear();
}
}
int dfn[maxnv], clk;
int stk[maxnv], top;
int sccid[maxnv], nscc;
int Tarjan(int u) {
int low = dfn[u] = clk++;
stk[top++] = u;
for (int v : g[u]) {
if (dfn[v] == -1) {
low = min(low, Tarjan(v));
} else if (sccid[v] == -1) {
low = min(low, dfn[v]);
}
}
if (low == dfn[u]) {
int v;
do {
v = stk[--top];
sccid[v] = nscc;
} while (v != u);
++nscc;
}
return low;
}
void FindScc(void) {
memset((dfn), (-1), sizeof((dfn)[0]) * (nv));
memset((sccid), (-1), sizeof((sccid)[0]) * (nv));
clk = top = nscc = 0;
for (int i = 0; i < nv; ++i) {
if (dfn[i] == -1) {
Tarjan(i);
}
}
}
void AddEdge(int u, int v) {
g[u].push_back(v);
g[v ^ 1].push_back(u ^ 1);
}
void DelEdge(int u, int v) {
g[v ^ 1].pop_back();
g[u].pop_back();
}
bool Solve(void) {
FindScc();
for (int i = 0; i < nv; i += 2) {
if (sccid[i] == sccid[i + 1]) {
return false;
}
}
return true;
}
const int maxn = 5e4, maxm = 5e4;
struct Edge {
int u, v, c, t;
void Read(void) {
scanf("%d%d%d%d", &u, &v, &c, &t);
--u;
--v;
}
} edge[maxm];
vector<int> adj[maxn];
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
edge[i].Read();
edge[m + i] = edge[i];
adj[edge[i].u].push_back(i);
adj[edge[i].v].push_back(m + i);
}
m *= 2;
for (int i = 0; i < n; ++i) {
sort(adj[i].begin(), adj[i].end(),
[](int a, int b) { return edge[a].c < edge[b].c; });
}
Init(3 * m);
int ori = 0, con1 = m, con2 = 2 * m;
for (int u = 0; u < n; ++u) {
int s = adj[u].size();
vector<int> &a = adj[u];
for (int i = 0; i < s; ++i) {
AddEdge((ori + a[i]) << 1 | 1, (con1 + a[i]) << 1 | 1);
if (i + 1 < s) {
AddEdge((con1 + a[i]) << 1 | 1, (con1 + a[i + 1]) << 1 | 1);
AddEdge((con1 + a[i]) << 1 | 1, (ori + a[i + 1]) << 1 | 0);
}
}
for (int i = 0; i < s; ++i) {
AddEdge((ori + a[i]) << 1 | 0, (con2 + a[i]) << 1 | 1);
if (i + 1 < s && edge[a[i]].c == edge[a[i + 1]].c) {
AddEdge((con2 + a[i]) << 1 | 1, (con2 + a[i + 1]) << 1 | 1);
AddEdge((con2 + a[i]) << 1 | 1, (ori + a[i + 1]) << 1 | 1);
}
}
}
for (int i = 0; i < m / 2; ++i) {
AddEdge((ori + i) << 1 | 1, (ori + i + m / 2) << 1 | 1);
AddEdge((ori + i) << 1 | 0, (ori + i + m / 2) << 1 | 0);
}
if (!Solve()) {
puts("No");
return 0;
}
int low = 0, high = 1e9 + 10;
while (high - low > 1) {
int mid = low + high >> 1;
int lim = mid - 1;
for (int i = 0; i < m; ++i) {
if (edge[i].t > lim) {
AddEdge((ori + i) << 1 | 1, (ori + i) << 1 | 0);
}
}
if (Solve()) {
high = mid;
} else {
low = mid;
}
for (int i = 0; i < m; ++i) {
if (edge[i].t > lim) {
DelEdge((ori + i) << 1 | 1, (ori + i) << 1 | 0);
}
}
}
puts("Yes");
int lim = low;
for (int i = 0; i < m; ++i) {
if (edge[i].t > lim) {
AddEdge((ori + i) << 1 | 1, (ori + i) << 1 | 0);
}
}
Solve();
vector<int> ans;
for (int i = 0; i < m / 2; ++i) {
if (sccid[(ori + i) << 1 | 0] > sccid[(ori + i) << 1 | 1]) {
ans.push_back(i);
}
}
printf("%d %d\n", low, (int)ans.size());
for (int i = 0; i < ans.size(); ++i) {
printf("%d%c", ans[i] + 1, " \n"[i + 1 == ans.size()]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct node {
long double l, r;
long long r1;
bool operator<(node x) const {
if (l == x.l) return r1 > x.r1;
return l < x.l;
}
} a[N];
long long bit[N];
long long n;
void add(long long x, long long pos) {
while (pos <= n) {
bit[pos] += x;
pos += (pos & -pos);
}
}
long long query(long long pos) {
long long ans = 0;
while (pos > 0) {
ans += bit[pos];
pos -= (pos & -pos);
}
return ans;
}
bool cmp(node x, node y) { return x.r < y.r; }
int main() {
std::ios::sync_with_stdio(0);
long long i, j, k, t6, t7;
long double t1, t2, t3, t4, t5, w;
cin >> n >> w;
t6 = t7 = 0;
for (i = 0; i < n; i++) {
cin >> t1 >> t2;
t5 = t1;
t3 = t1 / (t2 - w);
t4 = t1 / (t2 + w);
a[i].l = t3;
a[i].r = t4;
}
sort(a, a + n, cmp);
long long t = 0;
for (i = 0; i < n; i++) {
if (i == 0 || a[i].r != a[i - 1].r)
a[i].r1 = (++t);
else
a[i].r1 = t;
}
memset(bit, 0, sizeof(bit));
sort(a, a + n);
long long ans = 0;
for (i = 0; i < n; i++) {
ans += query(n) - query(a[i].r1 - 1);
add(1, a[i].r1);
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct query {
long double alpha;
int id;
bool operator<(const query& other) const { return alpha < other.alpha; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
long double v;
cin >> q >> v;
vector<query> vct(q);
for (int i = 0; i < q; ++i) {
long double alpha;
cin >> alpha;
vct[i] = {alpha, i};
}
sort((vct).begin(), (vct).end());
vector<long double> ansx(q, -1);
vector<long double> ansy(q, -1);
int n;
cin >> n;
vector<pair<long double, long double> > a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
sort((a).begin(), (a).end());
int ptr = 0;
long double g = 9.8;
for (int i = 0; i < n; ++i) {
long double x = a[i].first;
while (ptr < q) {
long double len = v * v / g * sin(vct[ptr].alpha * 2);
if (len < x) {
ansx[vct[ptr].id] = len;
ansy[vct[ptr].id] = 0;
++ptr;
continue;
}
long double alpha = vct[ptr].alpha;
long double must =
x * tan(alpha) - g / 2 * x * x / v / v / cos(alpha) / cos(alpha);
if (must <= a[i].second) {
ansx[vct[ptr].id] = x;
ansy[vct[ptr].id] = must;
++ptr;
continue;
}
break;
}
}
cout << fixed;
cout.precision(20);
for (int i = 0; i < q; ++i) {
long double len = v * v / g * sin(vct[i].alpha * 2);
if (ansx[vct[i].id] < 0) {
ansx[vct[i].id] = len;
ansy[vct[i].id] = 0;
}
}
for (int i = 0; i < q; ++i) {
cout << ansx[i] << " " << ansy[i] << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> t[1000100];
vector<int> edge[1040];
bool visited[1040];
int ile_skladowych = 0;
multiset<pair<long long, long long>> s[10000];
void dfs(int x) {
s[ile_skladowych].insert(pair<long long, long long>(t[x].first, t[x].second));
visited[x] = true;
for (int i : edge[x]) {
if (!visited[i]) {
dfs(i);
}
}
}
long long dp[2010][2010];
int main() {
ios::sync_with_stdio(false);
int n, m, w, x, y;
cin >> n >> m >> w;
for (int i = 1; i <= n; i++) {
cin >> t[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> t[i].second;
}
for (int i = 1; i <= m; i++) {
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
ile_skladowych++;
}
}
for (int i = 0; i < ile_skladowych; i++) {
long long waga = 0;
long long wartosc = 0;
for (auto p : s[i]) {
waga = waga + p.first;
wartosc = wartosc + p.second;
}
s[i].insert(pair<long long, long long>(waga, wartosc));
}
for (int j = 0; j < ile_skladowych; j++) {
if (j != 0) {
for (int i = 0; i <= w; i++) {
dp[i][j] = dp[i][j - 1];
}
}
for (int k = w; k >= 1; k--) {
for (auto p : s[j]) {
if (k >= p.first) {
dp[k][j] = max(dp[k][j], dp[k - p.first][j] + p.second);
}
}
}
}
long long q = 0;
for (int i = 0; i < ile_skladowych; i++) {
q = max(q, dp[w][i]);
}
cout << q << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mx = 212345;
struct Node {
int a, b, e;
bool f;
Node(int a = -1, int b = -1, int e = -1, bool f = 0)
: a(a), b(b), e(e), f(f){};
};
class lca_t {
public:
int n;
int max_log, t;
vector<int> h, in, rin, out;
vector<vector<int>> adj, up;
lca_t(int _n) : n(_n) {
max_log = 0;
while ((1 << max_log) <= n) max_log++;
h.resize(n);
in.resize(n);
rin.resize(n);
out.resize(n);
adj.resize(n);
up.resize(n, vector<int>(max_log));
t = 0;
}
int walk(int first, int k) {
for (int i = max_log - 1; i >= 0; i--) {
if (k & (1 << i)) first = up[first][i];
}
return first;
}
bool anc(int first, int second) {
return in[first] <= in[second] && out[first] >= out[second];
}
int lca(int first, int second) {
if (anc(first, second)) return first;
if (anc(second, first)) return second;
for (int i = max_log - 1; i >= 0; i--)
if (!anc(up[first][i], second)) first = up[first][i];
return up[first][0];
}
void add(int first, int second) {
adj[first].push_back(second);
adj[second].push_back(first);
}
void dfs(int v, int p) {
in[v] = t++;
rin[in[v]] = v;
up[v][0] = p;
for (int i = 1; i < max_log; i++) up[v][i] = up[up[v][i - 1]][i - 1];
for (int i = 0; i < (int)adj[v].size(); i++) {
int u = adj[v][i];
if (u == p) continue;
h[u] = h[v] + 1;
dfs(u, v);
}
out[v] = t;
};
void set_root(int first) {
h[first] = 0;
dfs(first, first);
}
};
lca_t *t = NULL;
Node merge(Node first, Node second) {
if (!first.f || !second.f) return Node();
int a = first.a, b = first.b, e = first.e;
int c = second.a, d = second.b, f = second.e;
Node res = Node();
if (a != e && c != f) {
if (e == f) {
int first = t->lca(a, c);
int second = t->lca(b, d);
if ((first == a || first == c) && (second == b || second == d)) {
if (t->in[a] < t->in[c]) swap(a, c);
if (t->in[b] < t->in[d]) swap(b, d);
res = {a, b, e, 1};
}
}
} else if (a == e && c == f) {
int first = t->lca(a, c);
int second = t->lca(b, d);
if (first == second) {
if (t->in[b] > t->in[d]) swap(b, d);
res = {b, d, first, 1};
}
if ((first == a || first == c) && (second == b || second == d)) {
int x0 = max(pair<int, int>{t->in[a], a},
max(pair<int, int>{t->in[b], b},
max(pair<int, int>{t->in[c], c},
pair<int, int>{t->in[d], d})))
.second;
int y0 = min(pair<int, int>{t->in[a], a},
min(pair<int, int>{t->in[b], b},
min(pair<int, int>{t->in[c], c},
pair<int, int>{t->in[d], d})))
.second;
res = {y0, x0, y0, 1};
}
} else {
if (a == e) swap(a, c), swap(b, d), swap(e, f);
if (t->in[c] < t->out[e] && t->in[c] >= t->in[e]) {
int first = t->lca(a, d);
int second = t->lca(b, d);
if (first == a || first == d) {
res = {max(pair<int, int>{t->in[a], a}, pair<int, int>{t->in[d], d})
.second,
b, e, 1};
}
if (second == b || second == d) {
res = {a,
max(pair<int, int>{t->in[b], b}, pair<int, int>{t->in[d], d})
.second,
e, 1};
}
}
}
return res;
}
Node tree[4 * mx];
void upd(Node first, int pos, int l, int r, int on = 1) {
if (l + 1 == r) {
tree[on] = first;
return;
}
int m = l + r >> 1;
if (pos < m)
upd(first, pos, l, m, 2 * on);
else
upd(first, pos, m, r, 2 * on + 1);
tree[on] = merge(tree[2 * on], tree[2 * on + 1]);
}
int query(Node first, int l, int r, int on = 1) {
if (merge(tree[on], first).f == 1) return r - l;
if (l + 1 == r) return first.f ? merge(first, tree[on]).f : tree[on].f;
int m = l + r >> 1;
if ((first.f ? merge(first, tree[2 * on]) : tree[2 * on]).f == 1)
return m - l +
query(first.f ? merge(first, tree[2 * on]) : tree[2 * on], m, r,
2 * on + 1);
else
return query(first, l, m, 2 * on);
}
int p[mx];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
t = new lca_t(n + 1);
for (int i = 2; i <= n; i++) {
int first;
scanf("%d", &first);
t->add(first, i);
}
t->set_root(1);
for (int i = 1; i <= n; i++) {
upd(Node(i, i, i, 1), p[i], 0, n);
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 2) {
printf("%d\n", query(Node(), 0, n));
} else {
int a, b;
scanf("%d%d", &a, &b);
swap(p[a], p[b]);
upd(Node(a, a, a, 1), p[a], 0, n);
upd(Node(b, b, b, 1), p[b], 0, n);
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 0, d = 0, i = 0;
string s;
cin >> n;
cin >> s;
for (i = 0; s[i] != '\0'; i++) {
if (s[i] == 'A')
a++;
else
d++;
}
if (a > d)
cout << "Anton";
else if (d > a)
cout << "Danik";
else
cout << "Friendship";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using pa = pair<long long, long long>;
const long long maxm = 500010;
void fastscan(long long& ret) {
char r;
bool start = false, neg = false;
ret = 0;
while (true) {
r = getchar();
if ((r - '0' < 0 || r - '0' > 9) && r != '-' && !start) {
continue;
}
if ((r - '0' < 0 || r - '0' > 9) && r != '-' && start) {
break;
}
if (start) ret *= 10;
start = true;
if (r == '-')
neg = true;
else
ret += r - '0';
}
if (neg) ret = -ret;
}
long long t, n, m, c[maxm], ans;
pa edges[maxm];
vector<vector<long long>> negSet;
map<vector<long long>, long long> sum;
long long gcd(long long a, long long b) {
return a % b == 0 ? b : gcd(b, a % b);
}
signed main() {
ios_base::sync_with_stdio(0);
fastscan(t);
while (t--) {
fastscan(n);
fastscan(m);
negSet.resize(n + 1);
for (long long i = 1; i <= n; ++i) fastscan(c[i]);
for (long long i = 0; i < m; ++i) {
fastscan(edges[i].first);
fastscan(edges[i].second);
}
sort(edges, edges + m);
for (long long i = 0; i < m; ++i) {
negSet[edges[i].second].push_back(edges[i].first);
}
for (long long i = 1; i <= n; ++i) {
if (negSet[i].size() != 0) {
sum[negSet[i]] += c[i];
}
}
for (const auto& p : sum) ans = gcd(ans, p.second);
cout << ans << endl;
ans = 0;
sum.clear();
negSet.clear();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> num[1000010];
int main() {
int n, k, l = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
num[i].push_back(l + 1);
num[i].push_back(l + 2);
num[i].push_back(l + 3);
num[i].push_back(l + 5);
l += 6;
}
l -= 1;
printf("%d\n", l * k);
for (int i = 0; i < n; i++) {
printf("%d %d %d %d\n", num[i][0] * k, num[i][1] * k, num[i][2] * k,
num[i][3] * k);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define repa(i, s, e) for (int i = s; i <= e; i++);
#define repb(i, s, e) for (int i = e; i >= s; i--);
#define PI 3.1415926535897932384626433832795
using namespace std;
typedef long int li;
typedef long long int lli;
typedef pair<li, li> pii;
typedef vector<li> vi;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<pii> vii;
typedef vector<vi> vvi;
typedef map<li, li> mpii;
typedef set<li> seti;
const int MAX_N = 1e6 + 1;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const lli LINF = 1e18;
const lli N = 100001;
void snake_bite()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
}
void read(vi a, li n)
{
for (int i = 0; i < n; i++)
cin >> a[i];
}
void display(vi a, li n)
{
for (int i = 0; i < n; i++)
cout << a[i] << " ";
}
void solve()
{
// sort(a.begin(), a.end(), greater<int>()) -- for reverse sort
//
int n, m;
cin >> n >> m;
vi a(n);
vi b(m);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++)
cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int i = 0, j = 0;
int count = 0;
while (i < n && j < m)
{
if (a[i] == b[j]) count++, i++, j++;
else if (a[i] > b[j]) j++;
else i++;
}
cout << count;
}
int main()
{
snake_bite();
//InverseofNumber(MOD);
//InverseofFactorial(MOD);
//factorial(MOD);
// vector <li> primes;
// SieveOfEratosthenes(primes);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
li t;
cin >> t;
//t = 1;
while (t--)
{
solve();
cout << endl;
}
//std::cout << "Goodbye World!\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int search(string nam[], int i) {
int j = 0;
for (; j < i; j++) {
if (nam[j] == nam[i]) return 1;
}
return 0;
}
int main() {
int n, num = 0, cnt = 0, found = 0;
cin >> n;
string *names = new string[n];
for (int i = 0; i < n; i++) {
cin >> names[i];
found = search(names, i);
if (found)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
const long long mod = 1e9 + 7;
long long dp[N][N * 2][4];
int a[N], cnt, tot, vis[N];
vector<int> son[N];
void dfs(int x) {
vis[x] = 1;
cnt++;
for (int i : son[x]) {
if (vis[i]) continue;
dfs(i);
}
}
int main() {
int n, N, x, y;
scanf("%d%d", &n, &N);
for (int i = 1; i <= N; i++)
scanf("%d%d", &x, &y), son[x].push_back(y), son[y].push_back(x);
vis[1] = 1;
for (int i = 2; i <= n; i++) {
if (!vis[i]) {
cnt = 0;
dfs(i);
a[++tot] = cnt + 1;
}
}
dp[0][N][0] = 1;
dp[0][N][2] = 1;
int mx = 0;
for (int i = 1; i <= tot; i++) {
for (int j = -mx; j <= mx; j++) {
dp[i][j + a[i] + N][0] =
(dp[i][j + a[i] + N][0] + dp[i - 1][j + N][0]) % mod;
dp[i][j - a[i] + N][0] =
(dp[i][j - a[i] + N][0] + dp[i - 1][j + N][0]) % mod;
dp[i][j + N][0] = (dp[i][j + N][0] + dp[i - 1][j + N][0]) % mod;
dp[i][j + a[i] + N][1] =
(dp[i][j + a[i] + N][1] + dp[i - 1][j + N][1]) % mod;
dp[i][j - a[i] + N][1] =
(dp[i][j - a[i] + N][1] + dp[i - 1][j + N][1]) % mod;
dp[i][j + N][1] = (dp[i][j + N][1] + dp[i - 1][j + N][1]) % mod;
for (int k = 1; k < a[i]; k++)
dp[i][j + k - (a[i] - k) + N][1] =
(dp[i][j + k - (a[i] - k) + N][1] + 2 * dp[i - 1][j + N][0]) % mod;
for (int k = 1; k < a[i] - 1; k++)
dp[i][j + k - (a[i] - 1 - k) + N][1] =
(dp[i][j + k - (a[i] - 1 - k) + N][1] + 2 * dp[i - 1][j + N][0]) %
mod;
dp[i][j + a[i] + N][2] =
(dp[i][j + a[i] + N][2] + dp[i - 1][j + N][2]) % mod;
dp[i][j - a[i] + N][2] =
(dp[i][j - a[i] + N][2] + dp[i - 1][j + N][2]) % mod;
dp[i][j + a[i] + N][3] =
(dp[i][j + a[i] + N][3] + dp[i - 1][j + N][3]) % mod;
dp[i][j - a[i] + N][3] =
(dp[i][j - a[i] + N][3] + dp[i - 1][j + N][3]) % mod;
dp[i][j + a[i] - 1 + N][3] =
(dp[i][j + a[i] - 1 + N][3] + 2 * dp[i - 1][j + N][2]) % mod;
dp[i][j - a[i] + 1 + N][3] =
(dp[i][j - a[i] + 1 + N][3] + 2 * dp[i - 1][j + N][2]) % mod;
}
mx += a[i];
}
printf("%lld\n", (dp[tot][N][1] + dp[tot][N][2] + dp[tot][N][3]) % mod);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
void solve() {
int n, k, a;
cin >> n;
vector<int> adj[n + 1];
for (int i = 0; i < n; i++) {
cin >> k;
while (k--) {
cin >> a;
adj[i].push_back(a - 1);
}
}
vector<int> done(n, 0);
map<int, int> mpp;
for (int i = 0; i < n; i++) {
for (auto child : adj[i]) {
if (mpp[child] == 0) {
mpp[child]++;
done[i]++;
break;
}
}
}
for (int i = 0; i < n; i++) {
if (done[i] == 0) {
for (int k = 0; k < n; k++) {
if (mpp[k] == 0 &&
find(adj[i].begin(), adj[i].end(), k) == adj[i].end()) {
cout << "IMPROVE"
<< "\n";
cout << i + 1 << " " << k + 1 << "\n";
return;
}
}
}
}
cout << "OPTIMAL"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s1, s2;
cin >> s1 >> s2;
int l1 = s1.length(), l2 = s2.length();
sort(s1.begin(), s1.end());
reverse(s1.begin(), s1.end());
if (l2 > l1) {
cout << s1 << endl;
return 0;
}
bool rollback = false;
int iChar = -1;
while (++iChar < l1) {
if (s1[iChar] < s2[iChar]) break;
if (s1[iChar] == s2[iChar] && (!rollback)) continue;
int iBest = -1, vBest = -1;
for (int iRepl = iChar + 1; iRepl < l1; ++iRepl) {
if (s1[iRepl] > s2[iChar]) continue;
if (rollback && s1[iRepl] == s2[iChar]) continue;
if (s1[iRepl] - '0' >= vBest) {
iBest = iRepl;
vBest = s1[iRepl] - '0';
}
}
if (iBest == -1) {
rollback = true;
iChar -= 2;
continue;
}
swap(s1[iChar], s1[iBest]);
sort(s1.begin() + iChar + 1, s1.end());
reverse(s1.begin() + iChar + 1, s1.end());
if (s1[iChar] < s2[iChar]) break;
}
cout << s1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int a[6][3] = {{0, 1, 2}, {1, 0, 2}, {1, 2, 0},
{2, 1, 0}, {2, 0, 1}, {0, 2, 1}};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> x;
n = n % 6;
cout << a[n][x] << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int h[100010];
int ceng[100010];
int main() {
while (~scanf("%d", &n)) {
memset(ceng, -1, sizeof(ceng));
for (int i = 1; i <= n; i++) {
scanf("%d", &h[i]);
ceng[i] = min(h[i] - 1, ceng[i - 1] + 1);
}
int da = 0;
for (int i = n; i >= 1; i--) {
ceng[i] = min(ceng[i], ceng[i + 1] + 1);
if (ceng[i] > da) da = ceng[i];
}
printf("%d\n", da + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool com(pair<long long int, long long int> x,
pair<long long int, long long int> y) {
return x.first < y.first;
}
int N = 1e5 + 9;
void solve() {
long long int n, x, ans = 1, r = 0;
int m;
cin >> n >> x >> m;
long long int k, y, l = n;
for (int i = 0; i < m; i++) {
cin >> k >> y;
if ((x >= k && x <= y) || (k >= l && k <= r) || (y >= l && y <= r)) {
l = min(l, k);
r = max(r, y);
}
}
if (r - l + 1 < 0)
cout << 1 << "\n";
else
cout << r - l + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 100000000000000000;
struct pt {
long long x, y;
};
bool fun(pt a, pt b) { return a.x < b.x; }
long long f(long long maxx, long long minx, long long maxy, long long miny) {
long long v1 = 0, modx, mody;
modx = max(abs(maxx), abs(minx));
if (miny != inf) {
v1 = maxy - miny;
v1 *= v1;
mody = max(abs(maxy), abs(miny));
v1 = max(v1, mody * mody + modx * modx);
return v1 - ((maxx - minx) * (maxx - minx));
} else {
return -1 * (maxx - minx) * (maxx - minx);
}
}
long long g(long long maxx, long long minx, long long maxy, long long miny) {
long long v1 = 0, modx, mody;
modx = max(abs(maxx), abs(minx));
if (miny != inf) {
v1 = maxy - miny;
v1 *= v1;
mody = max(abs(maxy), abs(miny));
v1 = max(v1, mody * mody + modx * modx);
return max(v1, (maxx - minx) * (maxx - minx));
} else {
return (maxx - minx) * (maxx - minx);
}
}
int main() {
int n;
cin >> n;
vector<pt> A(n);
for (int i = 0; i < n; i++) cin >> A[i].x >> A[i].y;
sort(A.begin(), A.end(), fun);
long long fin = inf;
for (int jy = 0; jy < 2; jy++) {
vector<long long> pminy(n + 1, inf), sminy(n + 1, inf), pmaxy(n + 1, -inf),
smaxy(n + 1, -inf);
for (int i = 1; i <= n; i++) {
pminy[i] = min(A[i - 1].y, pminy[i - 1]);
pmaxy[i] = max(A[i - 1].y, pmaxy[i - 1]);
}
for (int i = n - 1; i >= 0; i--) {
sminy[i] = min(sminy[i + 1], A[i].y);
smaxy[i] = max(smaxy[i + 1], A[i].y);
}
long long ans = min(A[n - 1].x - A[0].x, pmaxy[n] - pminy[n]), val;
ans *= ans;
for (int i = n - 1; i >= 0; i--) {
if (A[i].x < 0) break;
val = inf;
int lp = 0, rp = i, pos, mid;
if (A[lp].x >= -A[i].x)
pos = lp;
else {
while (rp != lp + 1) {
mid = (lp + rp) / 2;
if (A[mid].x >= -A[i].x)
rp = mid;
else {
lp = mid;
}
}
pos = rp;
}
int lo = pos, hi = i;
if (f(A[i].x, A[lo].x, max(pmaxy[lo], smaxy[i + 1]),
min(pminy[lo], sminy[i + 1])) >= 0) {
ans = min(ans, g(A[i].x, A[lo].x, max(pmaxy[lo], smaxy[i + 1]),
min(pminy[lo], sminy[i + 1])));
} else {
if (f(A[i].x, A[hi].x, max(pmaxy[hi], smaxy[i + 1]),
min(pminy[hi], sminy[i + 1])) <= 0) {
ans = min(ans, g(A[i].x, A[hi].x, max(pmaxy[hi], smaxy[i + 1]),
min(pminy[hi], sminy[i + 1])));
} else {
while (hi != lo + 1) {
mid = (hi + lo) / 2;
if (f(A[i].x, A[mid].x, max(pmaxy[mid], smaxy[i + 1]),
min(pminy[mid], sminy[i + 1])) >= 0) {
hi = mid;
} else {
lo = mid;
}
}
ans = min(ans, g(A[i].x, A[hi].x, max(pmaxy[hi], smaxy[i + 1]),
min(pminy[hi], sminy[i + 1])));
ans = min(ans, g(A[i].x, A[lo].x, max(pmaxy[lo], smaxy[i + 1]),
min(pminy[lo], sminy[i + 1])));
}
}
}
fin = min(ans, fin);
vector<pt> tmp;
for (int i = n - 1; i >= 0; i--) {
A[i].x *= -1;
tmp.push_back(A[i]);
}
A = tmp;
}
cout << fin << endl;
return 0;
}
| 10 |
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
int t;
cin >> t;
for (int i = 0; i < t; i++)
{
int n, q;
cin >> n >> q;
string inp;
cin >> inp;
vector<int>x = { 0 };
for (int j = 0; j < n; j++)
{
if (inp[j] == '+')x.push_back(x.back() + 1);
else x.push_back(x.back() - 1);
}
vector<pair<int, int>> minimum, maximum;
minimum.resize(n + 1);
maximum.resize(n + 1);
minimum[0].first = 0;
minimum.back().second = x.back();
maximum[0].first = 0;
maximum.back().second = x.back();
for (int j = 0; j < n; j++)
{
minimum[j + 1].first = min(minimum[j].first, x[j + 1]);
minimum[n - j - 1].second = min(minimum[n - j].second, x[n - j - 1]);
maximum[j + 1].first = max(maximum[j].first, x[j + 1]);
maximum[n - j - 1].second = max(maximum[n - j].second, x[n - j - 1]);
}
for (int j = 0; j < q; j++)
{
int fst, lst;
int out;
cin >> fst >> lst;
if (lst == n) out = maximum[fst - 1].first - minimum[fst - 1].first + 1;
else out = max(maximum[fst - 1].first, maximum[lst + 1].second - (x[lst] - x[fst - 1])) - min(minimum[fst - 1].first, minimum[lst + 1].second - (x[lst] - x[fst - 1])) + 1;
cout << out << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
const long long MOD = 1e9 + 7;
long long fact[N + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fact[0] = fact[1] = 1;
for (long long i = 2; i <= N; i++) fact[i] = (fact[i - 1] * i) % MOD;
int n, m;
cin >> n >> m;
vector<vector<int> > x(m);
for (int i = 0; i < n; i++) {
int s;
cin >> s;
for (int j = 0; j < s; j++) {
int t;
cin >> t;
x[t - 1].push_back(i);
}
}
for (int i = 0; i < m; i++) sort(x[i].begin(), x[i].end());
sort(x.begin(), x.end());
long long ans = 1;
long long sm = 1;
for (int i = 1; i < m; i++) {
if (x[i] == x[i - 1])
sm++;
else
ans = (ans * fact[sm]) % MOD, sm = 1;
}
ans = (ans * fact[sm]) % MOD;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, d, c, N;
int main() {
scanf("%d %d", &n, &m);
int left = (20 - n) * 60 - m;
scanf("%d%d%d%d", &h, &d, &c, &N);
double ans = ceil(double(h) / N) * c;
double ans2 = ceil(double(h + left * d) / N) * 0.8 * c;
if (left >= 0)
printf("%.4f\n", min(ans, ans2));
else
printf("%.4f\n", ceil(double(h) / N) * 0.8 * c);
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(u,n,x) for (int i = u; i < n; i += x)
using ll = long long;
using ld = long double;
using namespace std;
void solve()
{
int n;
cin >> n;
vector<int> a(n),b(n),t(n);
rep(0,n,1) cin >> a[i] >> b[i];
rep(0,n,1) cin >> t[i];
int time = 0;
rep(0,n,1)
{
int travel_time = i == 0 ? a[0]+t[0] : a[i]-b[i-1]+t[i];
if (i == n-1)
{
time += travel_time;
break;
}
int departure = time+travel_time+ceil(((double)b[i]-(double)a[i])/2.00);
time = max(b[i],departure);
}
cout << time << "\n";
}
int main()
{
cout.tie(0);
cin.tie(0);
cout<<setprecision(10);
int t;
cin >> t;
while (t--)
{
solve();
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
string s;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long j = 0; j < n; j++) cin >> b[j];
for (long long i = 0; i < n; i++) {
a[i] *= i + 1;
a[i] *= n - i;
}
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
reverse((b).begin(), (b).end());
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans = (ans + (a[i] % 998244353 * b[i]) % 998244353) % 998244353;
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, oo = 10000000;
int dq, n, q, i, a[N], b[N], c[N];
long long ans;
struct data {
int mmin, pos, sum;
} tree[4 * N];
inline data p(data a, data b) {
data zs;
if (b.mmin < a.mmin) {
zs.mmin = b.mmin;
zs.pos = b.pos;
} else {
zs.mmin = a.mmin;
zs.pos = a.pos;
}
zs.sum = a.sum + b.sum;
return zs;
}
inline data chu(int po) {
data zs;
zs.mmin = a[po];
zs.pos = po;
zs.sum = c[po];
return zs;
}
inline data ask(int l, int r, int i, int j, int nod) {
if (i > j) return (data){oo, 1, 0};
int mid = (l + r) >> 1;
if (l == i && j == r) return tree[nod];
if (j <= mid)
return ask(l, mid, i, j, nod << 1);
else if (i > mid)
return ask(mid + 1, r, i, j, (nod << 1) + 1);
data left = ask(l, mid, i, mid, nod << 1);
data right = ask(mid + 1, r, mid + 1, j, (nod << 1) + 1);
return p(left, right);
}
inline void insert(int l, int r, int i, int nod) {
int mid = (l + r) >> 1;
if (l == r) {
tree[nod] = chu(l);
return;
}
if (i <= mid)
insert(l, mid, i, nod << 1);
else
insert(mid + 1, r, i, (nod << 1) + 1);
tree[nod] = p(tree[nod << 1], tree[(nod << 1) + 1]);
}
inline void build(int l, int r, int nod) {
int mid = (l + r) >> 1;
if (l == r) {
tree[nod] = chu(l);
return;
}
build(l, mid, nod << 1);
build(mid + 1, r, (nod << 1) + 1);
tree[nod] = p(tree[nod << 1], tree[(nod << 1) + 1]);
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = b[i] = read();
c[i] = 1;
}
sort(&b[1], &b[n + 1]);
build(1, n, 1);
for (int i = 1; i <= n; i++) {
int z = b[i];
data zs = ask(1, n, dq + 1, n, 1);
if (zs.mmin == z) {
ans += ask(1, n, dq + 1, zs.pos, 1).sum;
a[zs.pos] = oo;
c[zs.pos] = 0;
insert(1, n, zs.pos, 1);
} else {
ans += zs.sum;
zs = ask(1, n, 1, dq - 1, 1);
ans += ask(1, n, 1, zs.pos, 1).sum;
a[zs.pos] = oo;
c[zs.pos] = 0;
insert(1, n, zs.pos, 1);
}
dq = zs.pos;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
double p[N], f[N], len;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf", &p[i]);
for (int i = 1; i <= n; i++) {
f[i] = (f[i - 1] + 2.0 * len + 1.0) * p[i] + f[i - 1] * (1.0 - p[i]);
len = (len + 1.0) * p[i];
}
printf("%.9lf", f[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct node {
int l, r, id;
bool operator<(const node &a) const {
if (l != a.l) return l < a.l;
if (r != a.r) return r < a.r;
return id < a.id;
}
} p[N][4];
set<node> S[4];
int n, a, b, c, d;
void solve(set<node> *S) {
int n = S[0].size();
if (S[0].size() == 1) return;
set<node> T[4];
set<node>::iterator it[4];
int mx[4];
for (int i = 0; i <= 3; i++) it[i] = S[i].begin(), mx[i] = -(1 << 30);
for (int i = 1; i < n; i++) {
for (int j = 0; j <= 3; j++) mx[j] = max(mx[j], (it[j]++)->r);
for (int j = 0; j <= 3; j++)
if (mx[j] <= it[j]->l) {
set<node>::iterator it = S[j].begin();
for (int k = 1; k <= i; k++) {
int id = (it++)->id;
for (int l = 0; l <= 3; l++) {
T[l].insert(p[id][l]);
S[l].erase(p[id][l]);
}
}
solve(S);
solve(T);
return;
}
}
puts("NO");
exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
S[0].insert(p[i][0] = (node){a, c, i});
S[1].insert(p[i][1] = (node){b, d, i});
S[2].insert(p[i][2] = (node){-c, -a, i});
S[3].insert(p[i][3] = (node){-d, -b, i});
}
solve(S);
puts("YES");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int maxn = 2000 + 11;
int N, a[maxn], b[maxn];
bool used[maxn][10][10][10][10][10];
queue<tuple<int, int, char, char, char, char, char> > Q;
void resort(char &f1, char &f2, char &f3, char &f4) {
if (f1 > f2) swap(f1, f2);
if (f2 > f3) swap(f2, f3);
if (f3 > f4) swap(f3, f4);
if (f1 > f2) swap(f1, f2);
if (f2 > f3) swap(f2, f3);
if (f1 > f2) swap(f1, f2);
}
void push_in(int n, int t, char floor, char f1, char f2, char f3, char f4) {
if (used[n][floor][f1][f2][f3][f4]) return;
used[n][floor][f1][f2][f3][f4] = 1;
if (n == N && !f1 && !f2 && !f3 && !f4) throw t;
Q.push(make_tuple(n, t, floor, f1, f2, f3, f4));
}
void bfs() {
tuple<int, int, char, char, char, char, char> s =
make_tuple(0, 0, 1, 0, 0, 0, 0);
Q.push(s);
int n, t;
char floor, f1, f2, f3, f4;
while (1) {
tuple<int, int, char, char, char, char, char> cur = Q.front();
Q.pop();
tie(n, t, floor, f1, f2, f3, f4) = cur;
resort(f1, f2, f3, f4);
if (floor < 9) push_in(n, t + 1, floor + 1, f1, f2, f3, f4);
if (floor > 0) push_in(n, t + 1, floor - 1, f1, f2, f3, f4);
if (f1 == floor) push_in(n, t + 1, floor, 0, f2, f3, f4);
if (f2 == floor) push_in(n, t + 1, floor, f1, 0, f3, f4);
if (f3 == floor) push_in(n, t + 1, floor, f1, f2, 0, f4);
if (f4 == floor) push_in(n, t + 1, floor, f1, f2, f3, 0);
if (f1 == 0 && n < N && a[n + 1] == floor)
push_in(n + 1, t + 1, floor, b[n + 1], f2, f3, f4);
}
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) scanf("%d%d", &a[i], &b[i]);
try {
bfs();
} catch (int &x) {
cout << x << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[200010], b[200010];
vector<int> na, nb;
int main() {
ios_base::sync_with_stdio(false);
int n, f = 0, len = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0)
f = 1;
else {
na.push_back(a[i]);
len++;
}
}
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i]) nb.push_back(b[i]);
}
if (!f && na[0] != nb[0]) {
cout << "NO\n";
return 0;
}
for (int i = 0; i < len; i++) {
if (nb[i] == na[0]) {
for (int j = 1; j < len; j++)
if (na[j] != nb[(i + j) % len]) {
cout << "NO\n";
return 0;
}
break;
}
}
cout << "YES\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const double EPS = 1e-6;
const int MAX_N = 4e5 + 5;
int a[MAX_N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int tt = 0; tt < t; ++tt) {
int n;
cin >> n;
int cur = 0;
vector<pair<int, int> > v;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
a[i] = x;
if (i > 0 && a[i] < a[i - 1]) {
v.push_back(make_pair(a[i - 1], cur));
cur = 0;
}
++cur;
}
v.push_back(make_pair(a[n - 1], cur));
vector<pair<int, int> > use;
int idx = 0;
long long sum = 0;
while (idx < int(v.size()) && sum + v[idx].second <= n / 2) {
sum += v[idx].second;
use.push_back(v[idx]);
++idx;
}
if (idx < 3) {
cout << "0 0 0\n";
continue;
}
long long pre[MAX_N]{};
pre[0] = use[1].second;
for (int i = 1; i < int(use.size()) - 1; ++i) {
pre[i] = pre[i - 1] + use[i + 1].second;
}
bool works = false;
long long ag = use[0].second, as = 0, ab = 0;
for (int i = 0; i < int(use.size()); ++i) {
if (ag < pre[i] && ag < sum - ag - pre[i]) {
as = pre[i];
ab = sum - ag - pre[i];
works = true;
break;
}
}
if (works) {
cout << ag << ' ' << as << ' ' << ab << '\n';
} else {
cout << "0 0 0\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, d, h;
cin >> n >> d >> h;
int n1 = n;
if (n == 2) {
cout << 1 << " " << 2 << endl;
} else {
int val = ceil((float)d / (float)2);
int d1 = d, n1 = n;
if (h < val)
cout << -1 << "\n";
else {
int st = 1;
vector<pair<int, int>> v;
for (int i = 1; i <= h; i++) {
v.push_back({st, st + 1});
st++;
}
st += 1;
int rem = d - h;
if (rem > 0) {
v.push_back({1, st});
rem--;
for (int i = 1; i <= rem; i++) {
v.push_back({st, st + 1});
st++;
}
st += 1;
}
n -= (st - 1);
if (n < 0)
cout << -1 << endl;
else {
int with = (d == h ? 2 : 1);
for (int i = 1; i <= n; i++) {
v.push_back({with, st});
st++;
}
if (n1 >= 3 && (d <= 1))
cout << -1 << "\n";
else
for (pair<int, int> p : v) cout << p.first << " " << p.second << "\n";
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int flag[3005];
int main() {
int n, k;
cin >> n;
memset(flag, 0, sizeof(flag));
for (int i = 1; i <= n; i++) {
cin >> k;
flag[k] = 1;
}
for (int i = 1;; i++) {
if (!flag[i]) {
printf("%d\n", i);
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct A {
int id, key;
} node[600000];
int n, m, p, k, minn, sum;
int flow[600000];
bool mark[600000], book[600000], inque[600000];
vector<int> way[600000], id[600000], ans;
queue<int> que;
bool cmp(A x, A y) { return x.key < y.key; }
int main() {
int a, b;
cin >> n >> m >> p;
for (int i = 1; i <= m; i++) {
cin >> a;
way[0].push_back(a);
}
for (int i = 1; i < n; i++) {
cin >> a >> b;
way[a].push_back(b);
id[a].push_back(i);
way[b].push_back(a);
id[b].push_back(i);
}
que.push(0);
book[0] = true;
flow[0] = p + 1;
while (!que.empty()) {
k = que.front();
que.pop();
for (int i = 0; i < way[k].size(); i++) {
if (!book[way[k][i]]) {
flow[way[k][i]] = flow[k] - 1;
book[way[k][i]] = true;
que.push(way[k][i]);
}
}
}
minn = p + 1;
for (int i = 1; i <= n; i++) {
node[i].id = i;
node[i].key = flow[i];
}
sort(1 + node, 1 + n + node, cmp);
for (int i = 1; i <= n; i++) que.push(node[i].id);
while (!que.empty()) {
k = que.front();
que.pop();
mark[k] = true;
sum = 0;
for (int i = 0; i < way[k].size(); i++) {
if (!mark[way[k][i]]) {
if (flow[way[k][i]] == flow[k]) {
ans.push_back(id[k][i]);
} else if (flow[way[k][i]] == flow[k] + 1) {
sum++;
}
}
}
for (int i = 0; i < way[k].size(); i++) {
if (flow[way[k][i]] == flow[k] + 1 && sum != 1) {
sum--;
ans.push_back(id[k][i]);
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> newvec;
int n;
int x;
int ans;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
newvec.push_back(x);
}
sort(newvec.begin(), newvec.end());
if (newvec.size() % 2 == 1) {
ans = newvec[newvec.size() / 2];
} else {
ans = newvec[newvec.size() / 2 - 1];
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
vector<pair<long long, int> > graph[MAXN];
long long minDistance[MAXN];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int in, out;
long long weight;
scanf("%d%d%lld", &in, &out, &weight);
graph[out].push_back({weight * 2, in});
graph[in].push_back({weight * 2, out});
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &minDistance[i]);
pq.push({minDistance[i], i});
}
while (!pq.empty()) {
int u = pq.top().second;
long long price = pq.top().first;
pq.pop();
if (minDistance[u] != price) {
continue;
}
for (auto e : graph[u]) {
int v = e.second;
if (minDistance[v] > e.first + minDistance[u]) {
minDistance[v] = e.first + minDistance[u];
pq.push({minDistance[v], v});
}
}
}
for (int i = 1; i <= n; i++) {
printf("%lld ", minDistance[i]);
}
puts("");
cin.get();
cin.get();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
int n, k, a[1000010];
int gra(int n) {
if (k & 1) {
if (n < 4) return n & 1;
if (n == 4) return 2;
if (n == 5) return 0;
if (n & 1) return 0;
int d = gra(n / 2);
if (d == 1)
return 2;
else
return 1;
} else {
if (n == 0 || n == 3) return 0;
if (n == 1) return 1;
if (n == 2) return 2;
return (n + 1) & 1;
}
}
int main() {
gn(n, k);
for (int i = 0; i < n; i++) gn(a[i]);
int ans = 0;
for (int i = 0; i < n; i++) ans ^= gra(a[i]);
if (ans != 0)
puts("Kevin");
else
puts("Nicky");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[10010010];
long long t;
long long n, a, b;
int ne[1001000];
int check(int x) {
for (int i = 1; i <= x; ++i) {
int sum = ne[i] + ne[n] - ne[n - (x - i)];
int sum1 = min(2 * (i - 1) + x - i, 2 * (x - i) + i - 1) * a;
if (sum + sum1 <= t) return 1;
}
return 0;
}
int main() {
scanf("%d%d%d%lld", &n, &a, &b, &t);
scanf("%s", s + 1);
ne[0] = 0;
for (int i = 1; i <= n; ++i) {
ne[i] = ne[i - 1] + 1 + (s[i] == 'w' ? b : 0);
}
int l = 0;
int r = n;
int ans = 0;
int mid;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next, v;
} e[100005 * 2];
int fl[100005], head[100005], vis[100005], dp[100005][2][2];
int n, tot = 1, m, u, v, del, pdu, pdv, an0, an1, cnt;
void add(int x, int y, int v) {
e[++tot] = (edge){y, head[x], v};
head[x] = tot;
}
void add(int x, int y, int v1, int v2) {
x = abs(x);
y = abs(y);
add(x, y, v1);
add(y, x, v2);
}
void dfs(int x, int pre) {
cnt -= 2;
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
cnt++;
if (e[i].to == x) cnt++;
if (!vis[e[i].to])
dfs(e[i].to, i);
else if (i != (pre ^ 1)) {
u = x;
v = e[i].to;
del = i;
}
}
}
int check(int k1, int k2, int k3) {
if ((k3 & 2) == 0) k1 ^= 1;
if ((k3 & 1) == 0) k2 ^= 1;
return k1 | k2;
}
void treedp(int x, int fa) {
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa && (i ^ del) && (i ^ del ^ 1)) treedp(e[i].to, x);
memset(dp[x], 0, sizeof(dp[x]));
for (int w = 0; w < 2; w++) {
if (x == u && w != pdu) continue;
if (x == v && w != pdv) continue;
int ans0 = 1, ans1 = 0;
for (int i = head[x]; i; i = e[i].next) {
int to = e[i].to;
if (to == fa || !(i ^ del) || !(i ^ del ^ 1)) continue;
int an0 = ans0, an1 = ans1;
ans0 = 0;
ans1 = 0;
for (int w1 = 0; w1 < 2; w1++) {
int A = dp[to][w1][0], B = dp[to][w1][1];
if (check(w, w1, e[i].v)) swap(A, B);
ans0 = (ans0 + 1ll * A * an0 + 1ll * B * an1) % 1000000007;
ans1 = (ans1 + 1ll * A * an1 + 1ll * B * an0) % 1000000007;
}
}
if (fl[x] & (1 << w)) swap(ans0, ans1);
dp[x][w][0] = (dp[x][w][0] + ans0) % 1000000007;
dp[x][w][1] = (dp[x][w][1] + ans1) % 1000000007;
}
}
void solve(int x) {
cnt = 0;
del = -100;
dfs(x, -1);
int ans0 = 0, ans1 = 0;
if (del == -100) {
v = 0;
u = x;
pdu = 0;
pdv = 1;
treedp(x, 0);
ans0 = (ans0 + 1ll * dp[x][0][0] + dp[x][1][0]) % 1000000007;
ans1 = (ans1 + 1ll * dp[x][0][1] + dp[x][1][1]) % 1000000007;
pdu = 1;
treedp(x, 0);
ans0 = (ans0 + 1ll * dp[x][0][0] + dp[x][1][0]) % 1000000007;
ans1 = (ans1 + 1ll * dp[x][0][1] + dp[x][1][1]) % 1000000007;
} else {
for (pdu = 0; pdu < 2; pdu++)
for (pdv = 0; pdv < 2; pdv++) {
treedp(u, 0);
if (check(pdu, pdv, e[del].v))
swap(dp[u][0][0], dp[u][0][1]), swap(dp[u][1][0], dp[u][1][1]);
ans0 = (ans0 + 1ll * dp[u][0][0] + dp[u][1][0]) % 1000000007;
ans1 = (ans1 + 1ll * dp[u][0][1] + dp[u][1][1]) % 1000000007;
}
}
int k0 = an0, k1 = an1;
an0 = (1ll * k0 * ans0 + 1ll * k1 * ans1) % 1000000007;
an1 = (1ll * k0 * ans1 + 1ll * k1 * ans0) % 1000000007;
}
int main() {
scanf("%d%d", &m, &n);
for (; m; m--) {
int x, y;
scanf("%d", &x);
if (x == 1) {
scanf("%d", &y);
if (y > 0)
fl[y] |= 2;
else
fl[-y] |= 1;
} else {
scanf("%d%d", &x, &y);
if (x < 0 && y < 0) add(x, y, 0, 0);
if (x < 0 && y > 0) add(x, y, 1, 2);
if (x > 0 && y < 0) add(x, y, 2, 1);
if (x > 0 && y > 0) add(x, y, 3, 3);
}
}
an0 = 1;
an1 = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) solve(i);
printf("%d", an1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long int power(long long int a, long long int b, long long int mod) {
long long int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
signed main() {
long long int n;
scanf("%lld", &n);
if (n == 1) {
puts("YES");
printf("1");
return 0;
}
if (n == 4) {
puts("YES");
printf("1\n3\n2\n4");
return 0;
}
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return puts("NO"), 0;
}
puts("YES");
printf("1\n");
for (long long int i = 2; i <= n; i++) {
long long int val = (i * power(i - 1, n - 2, n)) % n;
if (val == 0) val += n;
printf("%lld\n", val);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mod(string num, long long a) {
int res = 0;
for (long long i = 0; i < num.length(); i++)
res = (res * 10 + num[i] - '0') % a;
return res;
}
void solve() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long ans = abs(a - b);
if (ans % 10)
cout << ans / 10 + 1 << endl;
else
cout << ans / 10 << endl;
}
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int _ML = 228;
const char _inpf[] = "";
const char _outf[] = "";
#pragma GCC optimize("O3,no-stack-protector")
using namespace std;
const double PI = 3.14159265358979323846;
mt19937 rd(228);
template <class T, class U>
inline ostream &operator<<(ostream &, const pair<T, U> &);
template <class T, class U>
inline istream &operator>>(istream &, pair<T, U> &);
template <class T>
inline ostream &operator<<(ostream &, const vector<T> &);
template <class T>
inline istream &operator>>(istream &, vector<T> &);
template <class T>
inline ostream &operator<<(ostream &, const set<T> &);
template <class T>
inline ostream &operator<<(ostream &, const multiset<T> &);
template <class T>
inline ostream &operator<<(ostream &, const unordered_set<T> &);
template <class T>
inline ostream &operator<<(ostream &, const unordered_multiset<T> &);
template <class T, class U>
inline ostream &operator<<(ostream &, const map<T, U> &);
template <class T, class U>
inline ostream &operator<<(ostream &, const unordered_map<T, U> &);
const int N = 52;
const int M = 1000 * 1000 * 1000 + 7;
int dp[2][N][N][N][N];
int a[N];
int pww[N];
inline int pw2(int first) {
if (first == -1) {
return 1;
}
return pww[first];
}
inline int mul(int a, int b) { return (int)((long long)a * b % M); }
inline void addeq(int &a, int b) { a = (a + b) % M; }
inline void _main_function() {
pww[0] = 1;
for (int i = 1; i < N; ++i) {
pww[i] = mul(pww[i - 1], 2);
}
int n, p;
cin >> n >> p;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
dp[1][0][0][0][0] = 1;
for (int i = 0; i < n; ++i) {
int cur = (i & 1);
int lst = (~i & 1);
memset(dp[cur], 0, sizeof dp[cur]);
for (int be = 0; be <= i; ++be) {
for (int bo = 0; bo <= i; ++bo) {
for (int we = 0; we <= i; ++we) {
for (int wo = 0; wo <= i; ++wo) {
if (dp[lst][be][bo][we][wo] == 0) {
continue;
}
if (a[i] != 1) {
int value = mul(pw2(be + bo + we), pw2(wo - 1));
addeq(dp[cur][be][bo + 1][we][wo],
mul(dp[lst][be][bo][we][wo], value));
if (wo != 0) {
addeq(dp[cur][be + 1][bo][we][wo],
mul(dp[lst][be][bo][we][wo], value));
}
}
if (a[i] != 0) {
int value = mul(pw2(we + wo + be), pw2(bo - 1));
if (bo != 0) {
addeq(dp[cur][be][bo][we + 1][wo],
mul(dp[lst][be][bo][we][wo], value));
}
addeq(dp[cur][be][bo][we][wo + 1],
mul(dp[lst][be][bo][we][wo], value));
}
}
}
}
}
}
int cur = ((n - 1) & 1);
int ans = 0;
for (int be = 0; be <= n; ++be) {
for (int bo = 0; bo <= n; ++bo) {
for (int we = 0; we <= n; ++we) {
for (int wo = 0; wo <= n; ++wo) {
if (((bo + wo) & 1) == p) {
addeq(ans, dp[cur][be][bo][we][wo]);
}
}
}
}
}
cout << ans << '\n';
}
int main() {
if (_inpf[0] != '\0') assert(freopen(_inpf, "r", stdin) != nullptr);
if (_outf[0] != '\0') assert(freopen(_outf, "w", stdout) != nullptr);
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << setprecision(20);
_main_function();
}
template <class T, class U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << ' ' << _p.second;
return _out;
}
template <class T, class U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <class T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) {
return _out;
}
_out << *_v.begin();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <class T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
template <class T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <class T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <class T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <class T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <class T, class U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
template <class T, class U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, ans[300005], update[300005], sum;
vector<int> v[300005];
vector<pair<int, int> > query[300005];
void DFS(int nod, int last, int level) {
int x = 0;
for (int i = 0; i < query[nod].size(); i++) {
int dist, add;
dist = level + query[nod][i].first + 1;
add = query[nod][i].second;
update[level] += add;
if (dist <= n) update[dist] -= add;
}
sum += update[level];
ans[nod] = sum;
for (int i = 0; i < v[nod].size(); i++) {
int child = v[nod][i];
if (child != last) DFS(child, nod, level + 1);
}
sum -= update[level];
for (int i = 0; i < query[nod].size(); i++) {
int dist, add;
dist = level + query[nod][i].first + 1;
add = query[nod][i].second;
update[level] -= add;
if (dist <= n) update[dist] += add;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
cin >> m;
for (int i = 1; i <= m; i++) {
int v, d, x;
cin >> v >> d >> x;
query[v].push_back(make_pair(d, x));
}
DFS(1, 0, 1);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const int MAX = 3030;
const long long int mod = 1e9 + 7;
int go[MAX * MAX][2], rt = 2;
long long int dp[MAX];
string vv = "";
void solve(int tc) {
memset(go, -1, sizeof(go));
int n;
scanf("%d", &n);
long long int ans = 0;
for (int e = 0; e < n; e++) {
string k;
cin >> k;
vv += k;
reverse(vv.begin(), vv.end());
int now = 1, wh = -1;
for (int p = 0; p < (int)vv.size(); p++) {
if (go[now][vv[p] - '0'] == -1) {
wh = p;
break;
} else {
now = go[now][vv[p] - '0'];
}
}
if (wh == -1) {
printf("%lld\n", ans);
continue;
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int p = 1; p < (int)vv.size(); p++) {
for (int q = 1; q <= 3; q++) {
if (p - q >= 0) dp[p] = (dp[p] + dp[p - q]) % mod;
}
if (p >= 3) {
string kk = vv.substr(p - 3, 4);
if (kk != "1100" && kk != "1010" && kk != "0111" && kk != "1111") {
if (p == 3)
dp[p] = (dp[p] + 1) % mod;
else
dp[p] = (dp[p] + dp[p - 4]) % mod;
}
} else {
dp[p] = (dp[p] + 1) % mod;
}
}
for (int p = wh; p < (int)vv.size(); p++) ans = (ans + dp[p]) % mod;
printf("%lld\n", ans);
now = 1;
for (int p = 0; p < (int)vv.size(); p++) {
if (go[now][vv[p] - '0'] == -1) go[now][vv[p] - '0'] = rt++;
now = go[now][vv[p] - '0'];
}
reverse(vv.begin(), vv.end());
}
}
int main(void) {
int tc = 1;
for (int test_number = 1; test_number <= tc; test_number++) {
solve(test_number);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (n % 2 == 0) {
cout << "No";
return 0;
}
if (a[0] % 2 == 0 || a[n - 1] % 2 == 0) {
cout << "No";
return 0;
}
cout << "Yes";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int a, b, c, mx = 0;
scanf("%d%d", &a, &b);
if (a > mx) mx = a;
if (b > mx) mx = b;
a = gcd(6, 6 - mx + 1);
if (mx == 0)
printf("0/1\n");
else if (mx == 6)
printf("1/6\n");
else
printf("%d/%d\n", (6 - mx + 1) / a, 6 / a);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> st;
int main() {
int n, x;
cin >> n >> x;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
st.insert(t);
}
int oper = 0;
for (int i = 0; i < x; i++) {
if (st.find(i) == st.end()) {
st.insert(i);
oper++;
}
}
if (st.find(x) != st.end()) oper++;
cout << oper;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 2e5 + 10;
const int MOD = 1e9 + 7;
const long double eps = 1e-12;
int n, m, p, a[N], b[N], f[N];
map<int, int> mp;
vector<int> vec, ans;
void solve(int base) {
int l = vec.size();
if (l < m) return;
int cnt = mp.size();
for (int i = 0; i < l + m; i++) {
if (i >= m && mp.find(vec[i - m]) != mp.end()) {
int second = mp[vec[i - m]];
if (second == 0) cnt++;
mp[vec[i - m]]++;
second++;
if (second == 0) cnt--;
}
if (i >= vec.size()) continue;
int v = vec[i];
if (mp.find(v) == mp.end()) continue;
int second = mp[v];
if (second == 0) cnt++;
mp[v]--;
second--;
if (second == 0) cnt--;
if (cnt == 0) {
ans.push_back((i - m + 1) * p + base + 1);
}
}
}
int main() {
n = in();
m = in();
p = in();
for (int i = 0; i < n; i++) a[i] = in();
for (int i = 0; i < m; i++) b[i] = in();
for (int i = 0; i < m; i++) mp[b[i]]++;
for (int i = 0; i < p; i++) {
for (int j = i; j < n; j += p) vec.push_back(a[j]);
solve(i);
vec.clear();
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
int a[500105];
const int N = 1000005;
set<int> ava;
struct fw {
int b[N + N + 5];
void init() { memset(b, 0, sizeof b); }
void update(int x) {
for (int i = x; i <= N + N + 4; i += i & -i) {
b[i]++;
}
}
int query(int x) {
int ret = 0;
for (; x > 0; ret += b[x], x -= x & -x)
;
return ret;
}
} f[2];
void add(int x) {
auto it = ava.upper_bound(x);
it--;
int y = *it;
ava.erase(it);
f[0].update(y + N);
f[1].update(x + N);
}
int gid() {
int l = 1, r = N;
while (l + 1 < r) {
int mid = (l + r) / 2;
int back = N - mid;
int us = f[1].query(mid - 1);
int cur = f[1].query(mid) - us;
if (us > back)
r = mid - 1;
else if (us + cur < back)
l = mid + 1;
else
return mid;
}
int us = f[1].query(r - 1);
int cur = f[1].query(r) - us;
assert(us + cur >= N - r);
if (us > N - r) return l;
return r;
}
void fmain(int tid) {
scanf("%d", &n);
for (int i = -N; i <= N; i++) {
ava.insert(i);
}
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int(i) = 0; (i) < (int)(2); (i)++) f[i].init();
for (int(i) = 1; (i) <= (int)(n); (i)++) {
add(a[i]);
int tar = gid();
int ss = f[0].query(N + N + 4) - f[0].query(tar);
tar += ss;
printf("%d\n", tar - N);
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long a, b;
cin >> a >> b;
long long sum = 0;
long long notes = 0;
while (sum + notes + 1 <= a + b) {
++notes;
sum += notes;
}
set<int> possible;
for (int i = 1; i <= notes; ++i) possible.insert(i);
vector<int> read_a;
while (a && possible.size()) {
if (*possible.rbegin() < a) {
int take = *possible.rbegin();
a -= take;
possible.erase(take);
read_a.push_back(take);
} else {
possible.erase(a);
read_a.push_back(a);
a = 0;
}
}
cout << read_a.size() << "\n";
for (int x : read_a) cout << x << " ";
cout << "\n";
cout << possible.size() << "\n";
for (int x : possible) cout << x << " ";
cout << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Min(long long a, long long b) { return a > b ? b : a; }
long long x, k;
vector<long long> arr;
vector<long long> answer;
map<long long, vector<long long> > d;
void GetDiv(long long x) {
int p = pow(x, 0.5) + 0.1;
for (int i = 1; i <= p; i++) {
long long div1 = i;
if (!(x % div1)) {
arr.push_back(div1);
long long div2 = x / div1;
if (div2 != div1) arr.push_back(div2);
}
}
sort(arr.begin(), arr.end());
for (int i = 0; i < ((int)arr.size()); i++) {
vector<long long> cur;
for (int j = 0; j <= i; j++) {
if (!(arr[i] % arr[j])) cur.push_back(arr[j]);
}
d[arr[i]] = cur;
}
}
bool IsPrime(vector<long long> &arr) {
return ((int)arr.size()) > 2 ? false : true;
}
long long maxx = ((int)1e+5) + 5;
inline void rec(long long value, long long curK, long long &pos) {
if (pos >= maxx || curK > k) return;
map<long long, vector<long long> >::iterator it = d.find(value);
bool prime = IsPrime((*it).second);
if (prime) {
if (value == 1) {
answer.push_back(value);
pos++;
return;
}
long long step = k - curK;
step = Min(step, (maxx - pos));
for (int i = 0; i < step; i++) {
answer.push_back(1);
pos++;
}
answer.push_back(value);
pos++;
return;
}
for (int i = 0; i < ((int)(*it).second.size()); i++) {
rec((*it).second[i], curK + 1, pos);
if (curK == k - 1) {
map<long long, vector<long long> >::iterator it1 =
d.find((*it).second[i]);
prime = IsPrime((*it1).second);
if (!prime) {
answer.push_back((*it).second[i]);
pos++;
}
}
}
}
int main() {
cin >> x >> k;
GetDiv(x);
long long pos = 0;
rec(x, 0, pos);
if (k == 0) {
cout << x;
return 0;
}
int to = Min(((int)answer.size()), (int)1e+5);
for (int i = 0; i < to; i++) printf("%I64d ", answer[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t1, t2, s1;
int i, j, pro, pro_pos, ru_pos, n;
cin >> s;
for (i = 0; i < s.length(); i++) {
if (s.substr(i, 4) == "http") {
pro = 1;
pro_pos = i;
break;
}
if (s.substr(i, 3) == "ftp") {
pro = 2;
pro_pos = i;
break;
}
}
for (i = 0; i < s.length(); i++) {
if (s.substr(i, 2) == "ru") {
ru_pos = i;
}
}
n = s.length();
i = 0;
while (i < n) {
if (i == pro_pos) {
if (pro == 1)
i += 4;
else
i += 3;
} else if (i == ru_pos) {
i += 2;
} else {
s1 = "";
for (j = i; j < n; j++, i++) {
if (j == pro_pos || j == ru_pos)
break;
else {
s1 += s[j];
}
}
if (t1.length() == 0)
t1 = s1;
else
t2 = s1;
}
}
if (pro == 1)
cout << "http://";
else
cout << "ftp://";
cout << t1 << "."
<< "ru";
if (t2.length() >= 1) cout << "/" << t2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime[110];
int prime[110];
int Get_prime(int x) {
int k = 0;
memset(is_prime, 0, sizeof(is_prime));
memset(prime, 0, sizeof(prime));
for (int i = 2; i < x; i++) {
if (!is_prime[i]) prime[k++] = i;
for (int j = 0; j < k && prime[j] * i < x; j++) {
is_prime[prime[j] * i] = 1;
if (!i % prime[j]) break;
}
}
return k;
}
int main() {
int num = Get_prime(50), cnt = 0;
prime[num++] = 4;
prime[num++] = 9;
prime[num++] = 25;
prime[num++] = 49;
char s[10];
for (int i = 0; i < num; i++) {
printf("%d\n", prime[i]);
fflush(stdout);
scanf("%s", s);
if (s[0] == 'y') cnt++;
if (cnt == 2) {
printf("composite\n");
return 0;
}
}
printf("prime\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
double x, y;
pt operator-(pt r) { return {x - r.x, y - r.y}; }
pt operator+(pt r) { return {x + r.x, y + r.y}; }
pt operator*(double a) { return {x * a, y * a}; }
bool operator<(const pt& r) const {
return (x + 1e-8 > r.x && x - 1e-8 < r.x) ? y < r.y : x < r.x;
}
bool operator==(const pt& r) const {
return (x + 1e-8 > r.x && x - 1e-8 < r.x) &&
(y + 1e-8 > r.y && y - 1e-8 < r.y);
};
double dst(pt r = {0, 0}) {
return sqrt((x - r.x) * (x - r.x) + (y - r.y) * (y - r.y));
}
double XP(pt b) { return x * b.y - y * b.x; }
double DT(pt& b) { return x * b.x + y * b.y; }
bool gt() { return ~scanf("%lf%lf", &x, &y); }
};
double xp, yp, vp, x, y, v, r, rp;
pt rot(pt p, double rad) {
return {p.x * cos(rad) - p.y * sin(rad), p.x * sin(rad) + p.y * cos(rad)};
}
double dist(pt p1, pt p2) { return hypot(p1.x - p2.x, p1.y - p2.y); }
pt her, me;
double XX(pt& a, pt& b, pt& c) {
return (a.x - c.x) * (b.y - c.y) - (b.x - c.x) * (a.y - c.y);
}
bool cp(pt a, pt b) {
return (a.y + 1e-8 > b.y && a.y - 1e-8 < b.y) ? a.x < b.x : a.y < b.y;
}
bool cli(pt o, pt b, double r) {
pt d = b - o;
double D = d.x * d.x + d.y * d.y, X = o.XP(b), O = r * r * D - X * X;
if (O < 1e-8) return 0;
pt a = {(X * d.y + ((d.y < 0) ? -1 : 1) * d.x * sqrt(O)) / D,
(-X * d.x + abs(d.y) * sqrt(O)) / D},
A = {(X * d.y - ((d.y < 0) ? -1 : 1) * d.x * sqrt(O)) / D,
(-X * d.x - abs(d.y) * sqrt(O)) / D};
int I = 2;
if (a.x < min(o.x, b.x) - 1e-8 || a.x > max(o.x, b.x) + 1e-8 ||
a.y < min(o.y, b.y) - 1e-8 || a.y > max(o.y, b.y) + 1e-8)
--I, a = A;
if (A.x < min(o.x, b.x) - 1e-8 || A.x > max(o.x, b.x) + 1e-8 ||
A.y < min(o.y, b.y) - 1e-8 || A.y > max(o.y, b.y) + 1e-8)
--I, A = a;
return I;
}
bool ok(double t) {
double fspin = (2 * 3.14159265358979323846264338327950288419716939 * rp) / vp;
double ang = 2 * 3.14159265358979323846264338327950288419716939 *
((t / fspin) - floor(t / fspin));
pt herr = rot(her, ang);
if (!cli(me, herr, r)) return dist(me, herr) < t * v;
double dme = dist({0, 0}, me), dher = dist({0, 0}, herr);
double tme = sqrt(dme * dme - r * r), ther = sqrt(dher * dher - r * r);
double ttl = tme + ther;
double ame = atan2(me.y, me.x), aher = atan2(herr.y, herr.x);
if (ame < 1e-8) ame += 2 * 3.14159265358979323846264338327950288419716939;
if (aher < 1e-8) aher += 2 * 3.14159265358979323846264338327950288419716939;
double ftheta =
min(fabs(ame - aher), 2 * 3.14159265358979323846264338327950288419716939 -
fabs(ame - aher));
double theta = ftheta - acos(r / dme) - acos(r / dher);
ttl += theta * r;
return ttl < t * v;
}
double bs(double lo, double hi) {
double mid = (hi + lo) / 2;
if (fabs(lo - hi) < 1e-8) return mid;
if (ok(mid)) return bs(lo, mid);
return bs(mid, hi);
}
int main() {
cin >> xp >> yp >> vp >> x >> y >> v >> r;
her = {xp, yp};
me = {x, y};
rp = dist({0, 0}, her);
cout << setprecision(10) << fixed << bs(0, 1e9) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[110][110];
int s[110];
vector<int> f;
int main() {
int n, m = 0, sum = 0;
scanf("%d", &n);
f.clear();
for (int i = 0; i < n; i++) {
scanf("%d", &s[i]);
for (int j = 0; j < s[i]; j++) scanf("%d", &a[i][j]), sum += a[i][j];
if (s[i] & 1) f.push_back(a[i][s[i] / 2]);
}
int ans = 0;
sort(f.begin(), f.end());
for (int i = f.size() - 1, j = 1; i >= 0; i--, j ^= 1)
if (j) ans += f[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < s[i] / 2; j++) ans += a[i][j];
printf("%d %d\n", ans, sum - ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k = 0, k1 = 0, c = 0, i, j, f = 0, l;
cin >> n >> m;
if (n == 1 || m == 1) {
if (n == 1)
l = m;
else
l = n;
int x[l + 10], y[l + 10];
for (i = 0; i < l; i++) cin >> x[i];
for (i = 0; i < l; i++) cin >> y[i];
for (i = 0; i < l - 1; i++) {
if (x[i + 1] <= x[i]) {
if (y[i + 1] > x[i]) {
int t = x[i + 1];
x[i + 1] = y[i + 1];
y[i + 1] = t;
} else
c++;
}
}
if (c > 0)
cout << "Impossible" << endl;
else {
for (i = 0; i < l - 1; i++) {
if (y[i + 1] <= y[i]) {
if (x[i + 1] > y[i] && y[i + 1] > x[i]) {
int t = x[i + 1];
x[i + 1] = y[i + 1];
y[i + 1] = t;
} else
c++;
}
}
if (c > 0) cout << "Impossible" << endl;
}
if (c == 0) cout << "Possible" << endl;
} else {
int a[n][m], b[n][m];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) cin >> a[i][j];
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) cin >> b[i][j];
}
if (a[0][0] >= a[1][0] && a[0][0] >= a[0][1]) {
if (b[0][0] < a[1][0] && a[0][0] < a[0][1]) {
int t = a[0][0];
a[0][0] = b[0][0];
b[0][0] = t;
f = 1;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (j != m - 1) {
if (a[i][j + 1] <= a[i][j]) {
if (b[i][j + 1] > a[i][j]) {
int t = a[i][j + 1];
a[i][j + 1] = b[i][j + 1];
b[i][j + 1] = t;
} else
k++;
}
}
if (i != n - 1) {
if (a[i + 1][j] <= a[i][j]) {
if (b[i + 1][j] > a[i][j]) {
int t = a[i + 1][j];
a[i + 1][j] = b[i + 1][j];
b[i + 1][j] = t;
} else
k++;
}
}
}
}
if (k > 0)
cout << "Impossible" << endl;
else {
if (b[0][0] >= b[1][0] && b[0][0] >= b[0][1]) {
if (a[0][0] < b[1][0] && a[0][0] < b[0][1] && b[0][0] < a[1][0] &&
b[0][0] < a[0][1]) {
int t = b[0][0];
b[0][0] = a[0][0];
a[0][0] = t;
} else
k1++;
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (j != m - 1) {
if (b[i][j + 1] <= b[i][j]) {
if (a[i][j + 1] > b[i][j]) {
if (b[i][j + 1] > a[i][j]) {
int t = a[i][j + 1];
a[i][j + 1] = b[i][j + 1];
b[i][j + 1] = t;
} else
k1++;
} else
k1++;
}
}
if (i != n - 1) {
if (b[i + 1][j] <= b[i][j]) {
if (a[i + 1][j] > b[i][j]) {
if (b[i + 1][j] > a[i][j]) {
int t = a[i + 1][j];
a[i + 1][j] = b[i + 1][j];
b[i + 1][j] = t;
} else
k1++;
} else
k1++;
}
}
}
}
if (k1 > 0) cout << "Impossible" << endl;
}
if (k == 0 && k1 == 0) cout << "Possible" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool is_Smaller_str(string str1, string str2) {
long long n1 = str1.length(), n2 = str2.length();
if (n1 < n2) return true;
if (n2 < n1) return false;
for (int i = 0; i < n1; i++)
if (str1[i] < str2[i])
return true;
else if (str1[i] > str2[i])
return false;
return false;
}
long long mod(long long a, long long b) {
long long ans = a / b;
ans *= b;
ans = a - ans;
return ans;
}
string find_Diff_str(string str1, string str2) {
if (is_Smaller_str(str1, str2)) swap(str1, str2);
string str = "";
long long n1 = str1.length(), n2 = str2.length();
reverse(str1.begin(), str1.end());
reverse(str2.begin(), str2.end());
long long carry = 0;
for (long long i = 0; i < n2; i++) {
long long sub = ((str1[i] - '0') - (str2[i] - '0') - carry);
if (sub < 0) {
sub = sub + 10;
carry = 1;
} else
carry = 0;
str.push_back(sub + '0');
}
for (long long i = n2; i < n1; i++) {
long long sub = ((str1[i] - '0') - carry);
if (sub < 0) {
sub = sub + 10;
carry = 1;
} else
carry = 0;
str.push_back(sub + '0');
}
reverse(str.begin(), str.end());
return str;
}
string find_sum_str(string str1, string str2) {
if (str1.length() > str2.length()) swap(str1, str2);
string str = "";
int n1 = str1.length(), n2 = str2.length();
reverse(str1.begin(), str1.end());
reverse(str2.begin(), str2.end());
int carry = 0;
for (int i = 0; i < n1; i++) {
int sum = ((str1[i] - '0') + (str2[i] - '0') + carry);
str.push_back(sum % 10 + '0');
carry = sum / 10;
}
for (int i = n1; i < n2; i++) {
int sum = ((str2[i] - '0') + carry);
str.push_back(sum % 10 + '0');
carry = sum / 10;
}
if (carry) str.push_back(carry + '0');
reverse(str.begin(), str.end());
return str;
}
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long Rselect(vector<long long> v, long long i, long long l, long long r);
long long partition(vector<long long> v, long long l, long long r);
void scanc(vector<char>& v, long long n) {
for (long long i = 0; i < n; i++) {
char num;
cin >> num;
v.push_back(num);
}
}
void scanP(vector<pair<long long, long long> >& v, long long n) {
for (long long i = 0; i < n; i++) {
long long num1, num2;
cin >> num1 >> num2;
pair<long long, long long> p = {num1, num2};
v.push_back(p);
}
}
template <typename T>
ostream& operator<<(ostream& stream, const vector<T>& vec) {
for (auto& i : vec) {
stream << i << ' ';
}
stream << '\n';
return stream;
}
template <class T>
istream& operator>>(istream& stream, vector<T>& vec) {
for (auto& i : vec) {
stream >> i;
}
return stream;
}
void solve();
void scanN(vector<long long>& v, long long n) {
for (long long i = 0; i < n; i++) {
long long num;
cin >> num;
v.push_back(num);
}
}
void scans(vector<string>& v, long long n) {
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
}
long long modfactorial(long long n, long long p) {
if (n >= p) return 0;
long long result = 1;
for (long long i = 1; i < n + 1; i++) {
result = result * i;
result = result % p;
}
return result;
}
long long MI(long long a, long long b, long long s0 = 1, long long s1 = 0) {
long long k = b;
if (b == 0)
return s0;
else {
return MI(b, a % b, s1, s0 - s1 * (a / b));
}
}
long long choose(long long a, long long b, long long c = (long long)1e9 + 7) {
if (a < b) return 0;
long long x = modfactorial(a, c);
long long y = modfactorial(b, c);
long long z = modfactorial(a - b, c);
long long y_ = MI(y, c, 1, 0);
if (y_ < 0) y_ = y_ + c;
long long z_ = MI(z, c, 1, 0);
if (z_ < 0) z_ = z_ + c;
long long mul = (x * y_) % c;
mul = (mul * z_) % c;
return mul;
}
void SOLT() {
int test;
cin >> test;
while (test--) {
solve();
}
}
long long modpow(long long n, long long p, long long k) {
n = n % k;
long long res = 1;
while (p > 0) {
if (p % 2 == 1) res = res * n % k;
n = n * n % k;
p = p / 2;
}
return res;
}
long long __pow(long long n, long long p) {
long long res = 1;
while (p > 0) {
if (p % 2 == 1) res = res * n;
n = n * n;
p = p / 2;
}
return res;
}
long long str_mod_num(string b, long long c) {
long long k = b.size();
vector<long long> mod(k + 1);
mod[0] = 1;
for (long long i = 1; i < k + 1; i++) {
mod[i] = 10 * mod[i - 1];
mod[i] %= c;
}
long long rem = 0;
for (long long i = k - 1; i > -1; i--) {
long long num = b[i] - '0';
num *= mod[k - 1 - i];
num %= c;
rem += num;
rem %= c;
}
return rem;
}
long long str_pow_str_mod_num(string b, string n, long long c) {
long long tr = n.size();
long long rem = str_mod_num(b, c);
long long time_pass = n[0] - '0';
long long ans = modpow(rem, time_pass, c);
for (long long i = 1; i < tr; i++) {
time_pass = n[i] - '0';
ans = modpow(ans, 10, c);
ans *= modpow(rem, time_pass, c);
ans %= c;
}
return ans;
}
bool isPrime(long long a) {
for (long long i = 2; i * i <= a; ++i)
if (a % i == 0) return false;
return true;
}
bool useflushdivisible(long long a) {
cout << a << endl;
fflush(stdout);
char sl[10];
scanf("%s", sl);
return sl[0] == 'y' || sl[0] == 'Y';
}
long long phi(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n = n / i;
result = result - result / i;
}
}
if (n > 1) result = result - result / n;
return result;
}
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
return x.first < y.first;
}
vector<long long> getfactors(long long n) {
vector<long long> factors;
for (long long i = 1; i < sqrt(n) + 1; i++) {
if (n % i == 0) {
factors.push_back(i);
if (i != (n / i)) factors.push_back(n / i);
}
}
return factors;
}
long long Binary_Search(vector<long long>& a, long long low, long long high,
long long key) {
if (high < low) return a[low - 1];
int mid = (high + low) / 2;
if (key == a[mid])
return a[mid];
else if (key < a[mid])
return Binary_Search(a, low, mid - 1, key);
return Binary_Search(a, mid + 1, high, key);
}
double area(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3) {
return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
}
bool isInside(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3, int x, int y) {
double A = area(x1, y1, x2, y2, x3, y3);
double A1 = area(x, y, x2, y2, x3, y3);
double A2 = area(x1, y1, x, y, x3, y3);
double A3 = area(x1, y1, x2, y2, x, y);
return (A == A1 + A2 + A3);
}
long long log3(long long n) {
long long j = 0;
while (n > 0) {
n /= 3;
j++;
}
return j - 1;
}
bool isleap(long long n) {
if (n % 4)
return 0;
else if (n % 100)
return 1;
else if (n % 400)
return 0;
else
return 1;
}
int main() {
FAST();
srand(time(0));
int test = 1;
for (int tt = 1; tt <= test; tt++) {
solve();
}
return 0;
}
void solve() {
long long n, k;
cin >> n >> k;
long long ans = modpow(n - k, n - k, (long long)1e9 + 7);
ans *= modpow(k, k - 1, (long long)1e9 + 7);
ans %= (long long)1e9 + 7;
cout << ans << endl;
}
long long Rselect(vector<long long> v, long long i, long long l, long long r) {
if (l == r) return v[l];
long long pivot = partition(v, l, r);
if (pivot == i)
return v[pivot - 1];
else if (pivot < i) {
return Rselect(v, i, pivot, r);
} else {
return Rselect(v, i, l, pivot - 2);
}
}
long long partition(vector<long long> v, long long l, long long r) {
long long pivot_index = rand() % (r - l + 1) + l;
swap(v[pivot_index], v[l]);
long long i = l + 1, j = l + 1;
while (j <= r) {
if (v[j] < v[l]) {
swap(v[j], v[i]);
i++;
}
j++;
}
swap(v[l], v[i - 1]);
return i;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[20], b[20], ans = 1e9;
char c[10], d[210];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
cin >> c >> d;
for (int i = 0; i < strlen(c); i++) a[c[i] - '0']++;
a[6] += a[9];
a[9] = a[6];
a[2] += a[5];
a[5] = a[2];
for (int i = 0; i < strlen(d); i++) {
if (d[i] == '9' || d[i] == '6') {
b[6]++;
b[9]++;
} else if (d[i] == '2' || d[i] == '5') {
b[2]++;
b[5]++;
} else
b[d[i] - '0']++;
}
for (int i = 0; i < 10; i++)
if (a[i]) ans = min(ans, b[i] / a[i]);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool Less(const pair<pair<int, int>, pair<int, int>>& s1,
const pair<pair<int, int>, pair<int, int>>& s2) {
if (s1.first.first == s2.first.first)
return s1.first.second > s2.first.second;
return s1.first.first < s2.first.first;
}
vector<string> da(2100);
vector<int> st(2100);
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> da[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (da[i][j] == '1') st[j]++;
}
for (int i = 0; i < n; i++) {
auto tmp = st;
for (int j = 0; j < m; j++)
if (da[i][j] == '1') tmp[j] -= 1;
int f = 0;
for (int j = 0; j < m; j++)
if (tmp[j] == 0) f = 1;
if (f == 0) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%I64d", &n);
long long ans;
if (n % 2 == 0)
ans = n / 2;
else
ans = n / 2 - n;
printf("%I64d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long md = 1e9 + 7;
const int Inf = 1e9;
const long long Inf64 = 1e18;
const long long MaxN = 1e6 + 100;
const long double eps = 1e-15;
using namespace std;
long long Cnt[(int)1e6 + 10];
struct el {
el() {}
el(long long A, long long B, long long C) {
l = A;
r = B;
ps = C;
}
long long l, r;
long long ps;
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long N;
cin >> N;
long long lst = 0;
long long Ans = 0;
for (int i = 0; i < N; i++) {
long long a;
cin >> a;
long long k = min(a / 2, lst);
a -= k * 2;
lst -= k;
Ans += k;
Ans += a / 3;
a %= 3;
lst += a;
}
cout << Ans;
cerr << '\n'
<< "Time execute: " << clock() / (double)CLOCKS_PER_SEC << " sec"
<< '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 * 1000 + 321;
int a[maxN];
int mark[maxN];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int f = 0; f < k + 1000; f++) {
memset(mark, 0, sizeof mark);
int t = 1;
for (int i = 0; i < n; i++)
if (a[i] != k) t = 0;
if (t) {
cout << f << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (!mark[a[i]] && a[i] != k) {
mark[a[i]] = 1;
a[i]++;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, seed, vmax;
const int mod = 1e9 + 7;
int rnd() {
int rlt = seed;
seed = (1ll * seed * 7 + 13) % mod;
return rlt;
}
int expmod(int a, int b, int P) {
int rlt = 1;
while (b) {
if (b & 1) rlt = 1ll * a * rlt % P;
a = 1ll * a * a % P;
b >>= 1;
}
return rlt;
}
long long a[101010], b[101010];
int op, le, ri, x, y;
void get_query() {
op = (rnd() % 4) + 1;
le = (rnd() % n) + 1;
ri = (rnd() % n) + 1;
if (le > ri) swap(le, ri);
if (op == 3)
x = (rnd() % (ri - le + 1)) + 1;
else
x = (rnd() % vmax) + 1;
if (op == 4) y = (rnd() % vmax) + 1;
}
void put_query() {
printf("%d %d %d %d", op, le, ri, x);
if (op == 4)
printf(" %d\n", y);
else
puts("");
}
long long add[101010 << 2], to[101010 << 2];
void refresh(int id) {
if (add[id] && to[id] != -1) to[id] += add[id], add[id] = 0;
}
void push_down(int id) {
refresh(id);
if (to[id] != -1) {
to[id << 1] = to[id];
add[id << 1] = 0;
to[(id << 1) ^ 1] = to[id];
add[(id << 1) ^ 1] = 0;
} else {
add[id << 1] += add[id];
add[(id << 1) ^ 1] += add[id];
add[id] = 0;
}
}
void build(int L, int R, int id) {
if (L == R) {
to[id] = a[L];
return;
}
int mid = (L + R) >> 1;
build(L, mid, id << 1);
build(mid + 1, R, (id << 1) ^ 1);
}
void update(int le, int ri, int d, int L, int R, int id) {
if (le > R || L > ri) return;
if (le <= L && R <= ri) {
refresh(id);
if (to[id] != -1) {
to[id] += d;
return;
}
add[id] += d;
return;
}
int mid = (L + R) >> 1;
push_down(id);
to[id] = -1;
update(le, ri, d, L, mid, id << 1);
update(le, ri, d, mid + 1, R, (id << 1) ^ 1);
}
void change(int le, int ri, int d, int L, int R, int id) {
if (le > R || L > ri) return;
if (le <= L && R <= ri) {
refresh(id);
add[id] = 0;
to[id] = d;
return;
}
int mid = (L + R) >> 1;
push_down(id);
to[id] = -1;
change(le, ri, d, L, mid, id << 1);
change(le, ri, d, mid + 1, R, (id << 1) ^ 1);
}
int query(int le, int ri, int x, int y, int L, int R, int id) {
if (le > R || L > ri) return 0;
if (to[id] != -1) {
refresh(id);
int len = min(R, ri) - max(L, le) + 1;
return (int)((1ll * expmod(to[id] % y, x, y) * len) % y);
}
int mid = (L + R) >> 1;
push_down(id);
to[id] = -1;
int ans1 = query(le, ri, x, y, L, mid, id << 1);
int ans2 = query(le, ri, x, y, mid + 1, R, (id << 1) ^ 1);
return (ans1 + ans2) % y;
}
priority_queue<pair<long long, int> > pq;
void calc(int le, int ri, int L, int R, int id) {
if (le > R || L > ri) return;
if (to[id] != -1) {
refresh(id);
int len = min(R, ri) - max(L, le) + 1;
pq.push(make_pair(to[id], len));
return;
}
int mid = (L + R) >> 1;
push_down(id);
to[id] = -1;
calc(le, ri, L, mid, id << 1);
calc(le, ri, mid + 1, R, (id << 1) ^ 1);
}
int main() {
scanf("%d %d %d %d", &n, &m, &seed, &vmax);
for (int i = 1; i <= n; i++) a[i] = (rnd() % vmax) + 1;
memset(to, -1, sizeof to);
build(1, n, 1);
while (m--) {
get_query();
if (op == 1) {
update(le, ri, x, 1, n, 1);
} else if (op == 2) {
change(le, ri, x, 1, n, 1);
} else if (op == 3) {
while (!pq.empty()) pq.pop();
calc(le, ri, 1, n, 1);
int tot = 0;
x = ri - le + 1 - x;
pair<long long, int> tmp;
while (1) {
tmp = pq.top();
x -= tmp.second;
if (x < 0) {
printf("%I64d\n", tmp.first);
break;
}
pq.pop();
}
} else {
int ans = 0;
ans = query(le, ri, x, y, 1, n, 1);
printf("%d\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans;
scanf("%d", &n);
if (n <= 9) {
printf("%d\n", n);
} else if (n > 9 && n <= 189) {
n = n - 9;
if (n % 2 == 1) {
n = n / 2;
n++;
ans = (n + 9) / 10;
printf("%d\n", ans);
} else if (n % 2 == 0) {
n = n / 2;
ans = (n + 9) % 10;
printf("%d\n", ans);
}
} else if (n > 189 && n <= 2700) {
n = n - 189;
if (n % 3 == 1) {
n = n / 3;
n++;
ans = (n + 99) / 100;
} else if (n % 3 == 2) {
n = n / 3;
n++;
ans = (n + 99) / 10;
ans = ans % 10;
} else if (n % 3 == 0) {
n = n / 3;
ans = (n + 99) % 10;
}
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[15];
int b[15];
int c[15];
int d[15];
int n, m, c0, d0;
int dp[1009][12];
int solve(int x, int f) {
if (x < 0) return -(1 << 25);
if (f == m) {
int temp = x;
int sum = 0;
while (temp >= c0) {
sum += d0;
temp -= c0;
}
return sum;
}
if (dp[x][f] != -1) return dp[x][f];
int maxi = 0;
for (int i = 0; i * c[f] <= x && i * b[f] <= a[f]; i++)
maxi = max(maxi, solve(x - c[f] * i, f + 1) + i * d[f]);
return dp[x][f] = maxi;
}
int main() {
while (cin >> n >> m >> c0 >> d0) {
memset(dp, -1, sizeof(dp));
for (int i = (0); i < (m); i++) cin >> a[i] >> b[i] >> c[i] >> d[i];
int res = solve(n, 0);
cout << res << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, summa, cnt = 0;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
vector<int> v(n + 1);
summa = 0;
cnt = 0;
for (int j = 1; j <= n; j++) {
cin >> v[j];
summa += v[j];
if (v[j] % j != 0 && j != 1) cnt++;
}
if (summa % n != 0) {
cout << -1 << endl;
continue;
}
cout << 2 * (n - 1) + cnt << endl;
summa /= n;
for (int j = 2; j <= n; j++) {
if (v[j] % j != 0) {
cout << 1 << " " << j << " " << j - v[j] % j << endl;
v[1] -= (j - v[j] % j);
v[j] += (j - v[j] % j);
}
cout << j << " 1 " << v[j] / j << endl;
v[1] += v[j];
v[j] = 0;
}
for (int j = 2; j <= n; j++) {
cout << 1 << " " << j << " " << summa << endl;
v[j] += summa;
v[1] -= summa;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> div;
for (int i = 1; i <= n; i++) {
if (n % i == 0) div.push_back(i);
}
for (int i = div.size() - 1; i >= 0; i--) {
int p = div[i];
int cnt = 0;
while (p % 2 == 0) {
p /= 2;
cnt++;
}
int u = 0;
while (p % 2 == 1) {
p /= 2;
u++;
}
if (p == 0 && cnt - u == -1) {
cout << div[i] << "\n";
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
constexpr int N = 5e6 + 5;
struct SegTree {
vector<int> t;
int s;
int comb(int l, int r) { return t[l] + t[r]; }
void build(int i, int l, int r) {
if (l + 1 == r) {
t[i] = 1;
return;
}
int mid = (l + r) >> 1;
build((i << 1) + 1, l, mid);
build((i << 1) + 2, mid, r);
t[i] = comb((i << 1) + 1, (i << 1) + 2);
}
SegTree(int sz) {
s = sz;
t.resize(sz << 2);
build(0, 0, sz);
}
void upd(int pos, int i, int l, int r) {
if (l + 1 == r) {
t[i] = 0;
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
upd(pos, (i << 1) + 1, l, mid);
else
upd(pos, (i << 1) + 2, mid, r);
t[i] = comb((i << 1) + 1, (i << 1) + 2);
}
int get(int val, int i, int l, int r) {
if (l + 1 == r) {
return l;
}
int mid = (l + r) >> 1;
if (t[(i << 1) + 1] >= val)
return get(val, (i << 1) + 1, l, mid);
else
return get(val - t[(i << 1) + 1], (i << 1) + 2, mid, r);
}
void del(int pos) { upd(pos, 0, 0, s); }
int find(int pos) { return get(pos, 0, 0, s); }
};
set<int> pos['z' - '0' + 1];
vector<pii> ans;
int n, m, l, r;
char c;
string s;
void del(int i, int l, int r, SegTree& t) {
auto it = pos[i].lower_bound(l);
while (it != pos[i].end() && *it <= r) {
t.del(*it);
it = pos[i].erase(it);
}
}
void Solve() {
cin >> n >> m >> s;
SegTree tr(n);
for (int i = 0; i < s.size(); i++) {
pos[s[i] - '0'].insert(i);
}
while (m--) {
cin >> l >> r >> c;
l = tr.find(l);
r = tr.find(r);
del(c - '0', l, r, tr);
}
for (int i = 0; i < 'z' - '0' + 1; i++) {
for (int v : pos[i]) ans.emplace_back(v, i);
}
sort(ans.begin(), ans.end());
for (auto [a, b] : ans) {
cout << static_cast<char>(b + '0');
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
Solve();
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.