solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
// ※※※ 解答不能 ※※※
// 以下のソースを勉強する.
// yutaka1999氏.
// https://atcoder.jp/contests/jsc2019-qual/submissions/7112552
#include <bits/stdc++.h>
using namespace std;
#define SIZE 200005
using LL = long long;
typedef pair<int, int> P;
typedef pair<int, P> PP;
struct UF{
int par[SIZE], rank[SIZE], sz[SIZE];
void init(int n){
for(int i = 0; i < n; i++){
par[i] = i;
rank[i] = 1;
sz[i] = -1;
}
}
int find(int x){
if(x == par[x]) return x;
return par[x] = find(par[x]);
}
int get(int v){
return sz[find(v)];
}
void unite(int x,int y){
x = find(x);
y = find(y);
if(x == y){
sz[x]++;
return;
}
if(rank[x] < rank[y]){
par[x] = y;
sz[y] += sz[x];
sz[y]++;
}else{
par[y] = x;
sz[x] += sz[y];
sz[x]++;
if(rank[x] == rank[y]) rank[x]++;
}
}
bool same(int x,int y){
return find(x) == find(y);
}
}uf;
vector<PP> edge;
bool use[SIZE];
int main(){
int n, h, w;
scanf("%d %d %d",&n, &h, &w);
for(int i = 0; i < n; i++){
int r, c, a;
scanf("%d %d %d",&r, &c, &a);
r--, c--;
edge.push_back(PP(a, P(r, c + h)));
}
sort(edge.begin(),edge.end(),greater<PP>());
uf.init(h + w + 2);
LL ret = 0;
for(int i = 0; i < edge.size(); i++){
P p = edge[i].second;
int a = uf.get(p.first);
int b = uf.get(p.second);
if(a + b + 1 <= 0){
uf.unite(p.first, p.second);
ret += edge[i].first;
use[i] = true;
// printf("* %d %d : %d\n",p.first,p.second,edge[i].first);
}
}
printf("%lld\n", ret);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, b[2222], e[2222];
char s[2222];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) {
for (int j = 0; i - j >= 0 && i + j < n; j++) {
if (s[i - j] != s[i + j]) break;
b[i - j]++;
e[i + j]++;
}
for (int j = 0; i - j >= 0 && i + j + 1 < n; j++) {
if (s[i - j] != s[i + j + 1]) break;
b[i - j]++;
e[i + j + 1]++;
}
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) ans += e[i] * b[j];
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, m;
int gi() {
char a = getchar();
int b = 0;
while (a < '0' || a > '9') a = getchar();
while (a >= '0' && a <= '9') b = b * 10 + a - '0', a = getchar();
return b;
}
int cal(int x, int y, int z, int a, int b, int c) {
return abs(x - a) + abs(y - b) + abs(z - c);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
int a, b, c;
int ans = 1000000007, ans1 = 0, ans2 = 0, ans3 = 0;
cin >> a >> b >> c;
for (int i = 1; i <= 2 * c; i++) {
for (int j = i; j <= 2 * c; j += i) {
for (int k = j; k <= 2 * c; k += j) {
if (cal(i, j, k, a, b, c) < ans) {
ans = cal(i, j, k, a, b, c);
ans1 = i;
ans2 = j;
ans3 = k;
}
}
}
}
cout << ans << endl;
cout << ans1 << " " << ans2 << " " << ans3 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
inline bool Solve(const long long d1, const long long d2) {
long long p = k + 2 * d1 + d2;
if (p % 3) return 0;
long long x1 = p / 3;
if (x1 < 0 || x1 > n / 3) return 0;
long long x2 = x1 - d1;
if (x2 < 0 || x2 > n / 3) return 0;
long long x3 = x2 - d2;
if (x3 < 0 || x3 > n / 3) return 0;
return 1;
}
int main() {
int t;
cin.sync_with_stdio(false);
cin >> t;
long long d1, d2;
while (t--) {
cin >> n >> k >> d1 >> d2;
if (n % 3) {
cout << "no\n";
continue;
}
bool ok = 0;
ok |= Solve(d1, d2);
ok |= Solve(-d1, d2);
ok |= Solve(-d1, -d2);
ok |= Solve(d1, -d2);
if (ok)
cout << "yes\n";
else
cout << "no\n";
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define X first
#define Y second
#define pb emplace_back
#define FOR(i,a,b) for(int (i)=(a);i<(b);++(i))
#define EFOR(i,a,b) for(int (i)=(a);i<=(b);++(i))
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define reps(X,S,Y) for (int (X) = S;(X) < (Y);++(X))
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define rreps(X,S,Y) for (int (X) = (Y)-1;(X) >= (S);--(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef ll LL;
typedef pii PII;
typedef pll PLL;
template<class T> using vv=vector<vector<T>>;
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
const ll MOD=998244353;
int N;
int M;
map<pii, int> contra;
bool fail;
LL ans = 1;
LL dp[114514][2];
LL mypow(LL base, LL exp) {
if (exp == 0) return 1;
LL res = mypow(base*base%MOD, exp/2);
if (exp%2) res = res*base % MOD;
return res;
}
int main() {
scanf("%d%d", &N, &M);
LL num_free = (LL(N-2)*(N-3)/2);
rep(i, M) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
--x;
--y;
contra[pii(x, y)] = c;
if (abs(x-y) <= 2) {
//
} else {
if (contra.count(pii(y, x))) {
if (contra[pii(y, x)] != c) fail = true;
} else num_free--;
}
}
assert(num_free >= 0);
LL ans = mypow(2, num_free);
//printf("num_free: %lld, ans: %lld\n", num_free, ans);
reps(x, 1, N-1) {
pii l(x+1, x-1);
pii r(x-1, x+1);
pii c(x, x);
int g = contra.count(l) + contra.count(r);
if (g == 2) {
int d = (contra[l] + contra[r])%2;
if (contra.count(c) && contra[c] != d) fail = true;
contra[c] = d;
} else if (g == 0) {
ans = ans*2 % MOD;
}
}
if (fail) {
puts("0");
return 0;
}
rep(c, 2) {
if (contra.count(pii(0, 0)) && contra[pii(0, 0)] != c) {
//
} else dp[0][c] = 1;
}
reps(x, 1, N) {
pii cns[3] = {pii(x, x-1), pii(x, x), pii(x-1, x)};
rep(k, 2) {
rep(st, 8) {
bool invalid = false;
int num = k;
rep(i, 3) {
int c = st >> i & 1;
auto &p = cns[i];
if (contra.count(p) && contra[p] != c) invalid = true;
num += c;
}
if (invalid) continue;
if (num%2) continue;
int nk = st >> 1 & 1;
(dp[x][nk] += dp[x-1][k]) %= MOD;
}
}
}
LL s = (dp[N-1][0] + dp[N-1][1]) % MOD;
printf("%lld\n", (ans*s)%MOD);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans[100010], tot = 1;
set<int> E[100010];
map<set<int>, vector<int> > M;
inline int read() {
register int w = 0, X = 0;
register char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) {
X = (X << 1) + (X << 3) + (ch ^ 48);
ch = getchar();
}
return w ? -X : X;
}
int main() {
n = read(), m = read();
for (register int i = 1; i <= m; i++) {
register int x = read(), y = read();
E[x].insert(y), E[y].insert(x);
}
for (register int i = 1; i <= n; i++) M[E[i]].push_back(i);
if (M.size() != 3) {
puts("-1");
return 0;
}
for (auto it = M.begin(); it != M.end(); it++, tot++) {
if ((it->first).size() == 0) {
puts("-1");
return 0;
}
for (auto x : it->second) ans[x] = tot;
}
for (register int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100] = {4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274,
319, 346, 355, 378, 382, 391, 438, 454, 483, 517, 526,
535, 562, 576, 588, 627, 634, 636, 645, 648, 654, 663,
666, 690, 706, 728, 729, 762, 778, 825, 852, 861, 895,
913, 915, 922, 958, 985, 1086, 1111, 1165};
int main() {
int n;
scanf("%d", &n);
printf("%d\n", a[n - 1]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
void eras(map<int, int> &m, int x) {
m[x]--;
if (!m[x]) m.erase(x);
}
const int N = (int)3e5 + 100;
const int M = (int)2e6 + 100;
const int inf = (int)1e9 + 100;
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, i;
cin >> n;
map<int, int> m;
for ((i) = 0; (i) < (n); (i)++) {
int a;
cin >> a;
m[a]++;
}
if (m[1]) {
cout << -1;
} else {
cout << 1;
}
}
| 1 |
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
int main(void) {
int n;
ll a, b;
cin >> n >> a >> b;
ll l, r;
cin >> l;
ll ans = 0;
for (int i = 1; i < n; i++) {
cin >> r;
ans += min((r - l) * a, b);
l = r;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
deque<string> strings;
bool logger = false;
void print() {
if (!logger) return;
cout << "logger:\n";
for (string s : strings) cout << s << ' ';
cout << '\n';
}
bool myStrComp(string s1, string s2) {
if (s1[0] == s2[0])
return s1.length() < s2.length();
else
return s1[0] < s2[0];
}
bool nicePair(string &s1, string &s2) {
int steps = min(s1.length(), s2.length());
for (int i = 0; i < steps; i++)
if (s1[i] != s2[i]) return false;
return true;
}
bool repeatableLetters(string s) {
if (s.size() > 26) return true;
vector<bool> present(26);
for (char c : s)
if (present[c - 'a'])
return true;
else
present[c - 'a'] = true;
return false;
}
bool joinable(string &str, string &join) {
for (int i = 0; i < str.size(); i++) {
if (str[i] == join[0]) {
for (int j = i + 1; j < str.size() && j - i < join.size(); j++) {
if (str[j] != join[j - i]) return false;
}
return true;
}
}
return false;
}
void join(string &str, string &join) {
for (int i = 0; i < str.size(); i++) {
if (str[i] == join[0]) {
for (int j = i + 1; j - i < join.size(); j++) {
if (j >= str.size()) str.push_back(join[j - i]);
}
return;
}
}
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
strings.resize(n);
for (int i = 0; i < n; i++) cin >> strings[i];
stable_sort(strings.begin(), strings.end(), myStrComp);
print();
for (int i = 0; i < strings.size() - 1;) {
if (strings[i][0] == strings[i + 1][0]) {
if (nicePair(strings[i], strings[i + 1])) {
if (strings[i].length() > strings[i + 1].length()) {
strings.erase(strings.begin() + i + 1);
} else {
strings.erase(strings.begin() + i);
}
} else {
cout << "NO";
return 0;
}
} else {
i++;
}
}
print();
bool joined = true;
while (joined) {
joined = false;
for (int i = 0; i < strings.size() && !joined; i++) {
for (int j = i + 1; j < strings.size() && !joined; j++) {
if (joinable(strings[i], strings[j])) {
join(strings[i], strings[j]);
joined = true;
strings.erase(strings.begin() + j);
print();
} else if (joinable(strings[j], strings[i])) {
join(strings[j], strings[i]);
joined = true;
strings.erase(strings.begin() + i);
print();
}
}
}
}
print();
string result = "";
for (int i = 0; i < strings.size(); i++) {
result.append(strings[i]);
}
if (repeatableLetters(result)) {
cout << "NO";
} else {
cout << result;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:536870912")
#pragma warning(disable : 4996)
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 2e5 + 100;
int a[N], p[N];
int main() {
int n, d, b;
scanf("%d%d%d", &n, &d, &b);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
p[i + 1] = p[i] + a[i];
}
int m = n / 2;
if (n % 2 == 0) m--;
int z = 0, x = 0, y = 0, t = d;
for (int i = 0; i <= m; i++, t = min(t + d, n - 1 - i)) {
if (a[i] + z < b) {
if (p[t + i + 1] - p[i] + z < b)
z += a[i], x++;
else {
z -= b - a[i];
}
} else {
z += a[i] - b;
}
}
z = 0;
t = d;
for (int i = n - 1; i > m; i--, t = min(t + d, i)) {
if (a[i] + z < b) {
if (p[i + 1] - p[i - t] + z < b)
z += a[i], y++;
else {
z -= b - a[i];
}
} else {
z += a[i] - b;
}
}
printf("%d", max(x, y));
return 0;
}
| 4 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string data;
int n;
cin>>data>>n;
while (n--){
string order,p; int a,b;
cin>>order>>a>>b;
if (order=="replace"){
cin>>p;
data.replace(a,b-a+1,p);
}
else if(order=="reverse") reverse(begin(data)+a,begin(data)+b+1);
else if (order=="print") cout<<data.substr(a,b-a+1)<<endl;
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n,r;
while(cin>>n>>r && n>0 && r>0){
vector<int> v;
for(int i=n;i>0;i--)v.push_back(i);
while(r--){
int p,c;
cin>>p>>c;
vector<int>::iterator it = v.begin();
rotate(it,it+p-1,it+p+c-1);
}
cout<<v[0]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int base = 1e9;
const int maxn = 1e3;
const int logn = 20;
const int inf = 2e9;
const int alpha = 26;
const int my_hash = 29;
const long long l_inf = 4e18;
const long long mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
int n;
long long x, sum = 0;
vector<long long> a, b;
long long binpow(long long a, long long b) {
if (!b) return 1;
if (b % 2) return (binpow(a, b - 1) * a) % mod;
long long k = binpow(a, b / 2);
return (k * k) % mod;
}
int main() {
ios_base::sync_with_stdio();
cin >> n >> x;
a = vector<long long>(n);
for (int i = int(0); i < int(n); i++) {
cin >> a[i];
sum += a[i];
}
for (int i = int(0); i < int(n); i++) b.push_back(sum - a[i]);
sort(b.rbegin(), b.rend());
while (true) {
long long cnt = 0, v = b.back();
while (!b.empty() && b.back() == v) {
cnt++;
b.pop_back();
}
if (cnt % x) {
cout << binpow(x, min(v, sum));
exit(0);
} else {
cnt /= x;
for (int i = int(0); i < int(cnt); i++) b.push_back(v + 1);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
string a, b;
cin >> a;
cin >> b;
long long n1 = b.length();
n = a.length();
vector<long long> v(n);
long long tp;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &tp);
v[tp - 1] = i;
}
long long l = 1, r = n;
long long ans = 0;
while (l <= r) {
long long m = (l + r) / 2;
long long j = 0;
for (long long i = 0; i < n; i++) {
if (a[i] == b[j] && v[i] >= m) j++;
if (j == n1) break;
}
if (j == n1) {
if (ans < m) ans = m - 1;
l = m + 1;
} else
r = m - 1;
}
printf("%lld\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
if (islower(s[0])) {
for (int i = 1; i < s.size(); i++) {
if (islower(s[i])) {
cout << s;
return 0;
}
}
s[0] = toupper(s[0]);
cout << s[0];
for (int i = 1; i < s.size(); i++) {
if (isupper(s[i])) s[i] = tolower(s[i]);
cout << s[i];
}
return 0;
}
if (isupper(s[0])) {
for (int i = 0; i < s.size(); i++) {
if (islower(s[i])) {
cout << s;
return 0;
}
}
s[0] = tolower(s[0]);
cout << s[0];
for (int i = 1; i < s.size(); i++) {
if (isupper(s[i])) s[i] = tolower(s[i]);
cout << s[i];
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<int> num;
map<int, int> lfc, rtc;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &m);
if (i == 1)
num.insert(m);
else {
set<int>::iterator itr = num.lower_bound(m);
if (itr == num.end())
rtc[*(--itr)] = m;
else if (lfc.count(*itr) == 0)
lfc[*itr] = m;
else
rtc[*(--itr)] = m;
printf("%d", *itr);
if (i != n) printf(" ");
num.insert(m);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
string a, b;
int main() {
cin >> t;
while (t--) {
cin >> n >> a >> b;
vector<int> ans = vector<int>();
vector<int> pos = vector<int>();
for (int i = 0; i < (n + 1) / 2; i++) {
pos.push_back(i);
pos.push_back(n - i - 1);
if (pos[pos.size() - 2] == pos[pos.size() - 1]) pos.pop_back();
}
for (int i = n - 1; i >= 0; i--) {
char a0 = char((int)'0' +
((((int)a[pos[n - i - 1]] - (int)'0') + n - i - 1) % 2));
if (b[i] == a0) {
ans.push_back(1);
}
ans.push_back(i + 1);
}
cout << ans.size() << ' ';
for (auto f : ans) {
cout << f << ' ';
}
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int i, q, x;
string s, op, t;
map<string, int> M;
int get(string s) {
int gmb = 0, fnc = 0, i = 0, j = s.size() - 1;
string t;
while (i < s.size() && s[i] == '&') ++i, ++gmb;
while (j >= 0 && s[j] == '*') --j, ++fnc;
t = s.substr(i, j - i + 1);
if (!M.count(t) || M[t] == -1 || M[t] + fnc - gmb < 0) return -1;
return M[t] + fnc - gmb;
}
int main() {
ios_base::sync_with_stdio(0);
M["void"] = 0;
for (cin >> q; q; --q) {
cin >> op;
if (op == "typedef")
cin >> s >> t, M[t] = get(s);
else {
cin >> s;
x = get(s);
if (x == -1)
cout << "errtype\n";
else {
cout << "void";
while (x--) cout << "*";
cout << '\n';
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char x[] = {'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p',
'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/'};
char y;
int z;
cin >> y;
if (y == 'L')
z = 1;
else
z = -1;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < 30; j++)
if (s[i] == x[j]) {
cout << x[j + z];
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int n, len;
int b[MAXN], v[MAXN][MAXN], t[MAXN][MAXN];
int ans = 0;
void work(int p, int q) {
int s1 = 0, s2 = 0;
int x1 = 1, x2 = 1, r1 = t[p][1], r2 = t[q][1];
while (s1 < len && s2 < len) {
bool f = (s1 < s2);
int r = min(r1, r2);
s1 += v[p][x1] * r, s2 += v[q][x2] * r;
r1 -= r, r2 -= r;
if (r1 == 0) x1++, r1 = t[p][x1];
if (r2 == 0) x2++, r2 = t[q][x2];
if (f && (s1 > s2 ||
s1 == s2 && x1 <= b[p] && x2 <= b[q] && v[p][x1] > v[q][x2]))
ans++;
}
}
int main() {
scanf("%d%d", &n, &len);
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
for (int j = 1; j <= b[i]; j++) scanf("%d%d", &v[i][j], &t[i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) work(i, j);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int c[N], stat[N];
vector<pair<int, int>> ds[10];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
int n, m, k;
n = read();
m = read();
k = read();
for (int i = 1; i <= n; i++) c[i] = read();
for (int i = 0; i < 2; i++) {
int sz = read();
while (sz--) {
int x;
scanf("%d", &x);
stat[x] |= (1 << i);
}
}
set<pair<int, int>> ss, Tp;
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (stat[i] == 0 || stat[i] == 3) {
Tp.insert({c[i], i});
sum += c[i];
}
ds[stat[i]].push_back({c[i], i});
}
for (int i = 1; i <= 3; i++)
if (!ds[i].empty()) sort(ds[i].begin(), ds[i].end());
long long ans = -1;
long long vis[10];
vis[1] = vis[2] = vis[3] = 0;
for (int i = 1; i <= 2; i++)
for (auto &p : ds[i]) vis[i] += p.first;
for (int i = 0; i <= ds[3].size(); i++) {
if (i > 0) {
int id = ds[3][i - 1].second;
auto it = Tp.find({c[id], id});
if (it != Tp.end()) {
Tp.erase(it);
sum -= c[id];
} else
ss.erase({c[id], id});
vis[3] += c[id];
}
if ((k - i) * 2 + i <= m && min(ds[1].size(), ds[2].size()) >= k - i) {
for (int j = 1; j <= 2; j++)
while (ds[j].size() > k - i) {
int id = ds[j].back().second;
if (!Tp.empty() && c[id] < (--Tp.end())->first) {
Tp.insert({c[id], id});
sum += c[id];
} else
ss.insert({c[id], id});
vis[j] -= c[id];
ds[j].pop_back();
}
int tmp = m - (k - i) * 2 - i;
while (Tp.size() < tmp) {
int id = ss.begin()->second;
Tp.insert({c[id], id});
sum += c[id];
ss.erase(ss.begin());
}
while (Tp.size() > tmp) {
int id = (--Tp.end())->second;
Tp.erase({c[id], id});
sum -= c[id];
ss.insert({c[id], id});
}
if (Tp.size() == tmp) {
long long res = vis[1] + vis[2] + vis[3] + sum;
if (ans < 0 || ans > res) ans = res;
}
}
}
printf("%lld", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n <= 2)
printf("-1\n");
else {
n -= 2;
printf("2 3");
while (n--) {
printf(" 1");
}
printf("\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
long long f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x *= f, void();
}
const long long N = 2e5 + 5;
long long n, a[N], b[N], p[N], tot, indu[N], ans;
vector<long long> g[N];
queue<long long> q;
signed main() {
read(n);
for (long long i = 1; i <= n; i++) read(a[i]);
for (long long i = 1; i <= n; i++) read(b[i]), ++indu[b[i]];
for (long long i = 1; i <= n; i++)
if (!indu[i]) q.push(i);
while (!q.empty()) {
long long u = q.front();
q.pop();
ans += a[u];
if (b[u] == -1) continue;
if (a[u] > 0) {
g[u].push_back(b[u]);
a[b[u]] += a[u];
} else {
g[b[u]].push_back(u);
}
if (--indu[b[u]] == 0) q.push(b[u]);
}
printf("%lld\n", ans);
for (long long i = 1; i <= n; i++)
for (long long v : g[i]) ++indu[v];
for (long long i = 1; i <= n; i++)
if (!indu[i]) q.push(i);
while (!q.empty()) {
long long u = q.front();
q.pop();
printf("%lld ", u);
for (long long v : g[u])
if (--indu[v] == 0) q.push(v);
}
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-7;
int h, n;
int p[maxn];
void solve() {
h = read(), n = read();
for (int i = 1; i <= n; ++i) p[i] = read();
int ans = 0;
for (int i = 2; i <= n; ++i) {
int cur = 1;
while (i + 1 <= n && p[i] == p[i + 1] + 1) cur++, i++;
if (cur & 1) ans++;
if (i == n && p[n] == 1 && (cur & 1)) ans--;
}
printf("%d\n", ans);
}
int main() {
int q = read();
while (q--) solve();
}
| 3 |
/*
{
######################
# Author #
# Gary #
# 2021 #
######################
*/
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
//inline int read(){
// int x=0;
// char ch=getchar();
// while(ch<'0'||ch>'9'){
// ch=getchar();
// }
// while(ch>='0'&&ch<='9'){
// x=(x<<1)+(x<<3)+(ch^48);
// ch=getchar();
// }
// return x;
//}
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
/*}
*/
struct Myhash{
size_t operator ()(const vector<int> & v) const{
unsigned int val=0;
for(auto it:v){
val^=it;
val^=val<<13;
val^=val>>7;
val^=val<<17;
}
return val;
}
};
int n,m;
unordered_map<vector<int>,int,Myhash> M;
vector<vector<int> > tot;
vector<int> Now;
const int MAXN=6;
int a[MAXN],b[MAXN],c[MAXN][MAXN];
void dfs(){
if(Now.size()==m){
M[Now]=tot.size();
tot.PB(Now);
return ;
}
int j=Now.size();
rb(i,0,b[j]){
Now.PB(i);
dfs();
Now.POB();
}
}
int dp[MAXN+1][4][15625];
int main(){
scanf("%d%d",&n,&m);
rep(i,n) scanf("%d",&a[i]);
rep(i,m) scanf("%d",&b[i]);
rep(i,n) rep(j,m) scanf("%d",&c[i][j]);
dfs();
memset(dp,0x3f,sizeof(dp));
dp[0][0][0]=0;
// cout<<tot.size()<<endl;
rep(i,n){
rep(j,a[i]){
rep(k,tot.size()){
if(dp[i][j][k]!=INF){
vector<int> is=tot[k];
rep(l,m){
rb(pt,1,min(a[i]-j,b[l]-is[l])){
vector<int> Tmp=is;
Tmp[l]+=pt;
if(j+pt==a[i]){
check_min(dp[i+1][0][M[Tmp]],dp[i][j][k]+c[i][l]);
}
else{
check_min(dp[i][j+pt][M[Tmp]],dp[i][j][k]+c[i][l]);
}
}
}
}
}
}
}
int rest=INF;
rep(i,tot.size()) check_min(rest,dp[n][0][i]);
if(rest==INF) rest=-1;
printf("%d\n",rest);
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int f[110][60][2], n, g[110][60][2];
char s[110];
int main() {
memset(f, 0x80, sizeof f);
memset(g, 0x3f, sizeof g);
scanf("%s%d", s + 1, &n);
f[0][0][0] = 0;
for (int i = 1; s[i]; i++)
for (int j = 0; j <= n; j++)
if (s[i] == 'T') {
for (int k = j; k >= 0; k--)
if (k & 1)
f[i][j][0] = max(f[i][j][0], f[i - 1][j - k][0] + 1);
else
f[i][j][0] = max(f[i][j][0], f[i - 1][j - k][1]);
for (int k = j; k >= 0; k--)
if (k & 1)
f[i][j][1] = max(f[i][j][1], f[i - 1][j - k][1] - 1);
else
f[i][j][1] = max(f[i][j][1], f[i - 1][j - k][0]);
} else {
for (int k = j; k >= 0; k--)
if (k & 1)
f[i][j][0] = max(f[i][j][0], f[i - 1][j - k][1]);
else
f[i][j][0] = max(f[i][j][0], f[i - 1][j - k][0] + 1);
for (int k = j; k >= 0; k--)
if (k & 1)
f[i][j][1] = max(f[i][j][1], f[i - 1][j - k][0]);
else
f[i][j][1] = max(f[i][j][1], f[i - 1][j - k][1] - 1);
}
g[0][0][0] = 0;
for (int i = 1; s[i]; i++)
for (int j = 0; j <= n; j++)
if (s[i] == 'T') {
for (int k = j; k >= 0; k--)
if (k & 1)
g[i][j][0] = min(g[i][j][0], g[i - 1][j - k][0] + 1);
else
g[i][j][0] = min(g[i][j][0], g[i - 1][j - k][1]);
for (int k = j; k >= 0; k--)
if (k & 1)
g[i][j][1] = min(g[i][j][1], g[i - 1][j - k][1] - 1);
else
g[i][j][1] = min(g[i][j][1], g[i - 1][j - k][0]);
} else {
for (int k = j; k >= 0; k--)
if (k & 1)
g[i][j][0] = min(g[i][j][0], g[i - 1][j - k][1]);
else
g[i][j][0] = min(g[i][j][0], g[i - 1][j - k][0] + 1);
for (int k = j; k >= 0; k--)
if (k & 1)
g[i][j][1] = min(g[i][j][1], g[i - 1][j - k][0]);
else
g[i][j][1] = min(g[i][j][1], g[i - 1][j - k][1] - 1);
}
int len = strlen(s + 1);
cout << max(-min(g[len][n][0], g[len][n][1]), max(f[len][n][0], f[len][n][1]))
<< endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto& x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
vector<string> a;
int n, m;
int r, c, x, y;
bitset<4000000> get(bool bc) {
vector<vector<pair<int, int>>> d(
n, vector<pair<int, int>>(m, pair<int, int>(inf, inf)));
priority_queue<pair<pair<int, int>, pair<int, int>>,
vector<pair<pair<int, int>, pair<int, int>>>,
greater<pair<pair<int, int>, pair<int, int>>>>
q;
q.emplace(pair<int, int>(0, 0), pair<int, int>(r, c));
d[r][c] = pair<int, int>(0, 0);
while (!q.empty()) {
auto it = q.top();
q.pop();
int x, y;
tie(x, y) = it.second;
if (it.first != d[x][y]) continue;
for (auto dx = (-1); dx <= (1); ++dx) {
for (auto dy = (-1); dy <= (1); ++dy) {
if (abs(dx) + abs(dy) == 1) {
if (x + dx >= 0 and x + dx <= n - 1 and y + dy >= 0 and
y + dy <= m - 1 and a[x + dx][y + dy] == '.') {
pair<int, int> nd = it.first;
if (dy == -1) (bc ? nd.first : nd.second)++;
if (dy == 1) (bc ? nd.second : nd.first)++;
if (nd < d[x + dx][y + dy]) {
d[x + dx][y + dy] = nd;
q.emplace(nd, pair<int, int>(x + dx, y + dy));
}
}
}
}
}
}
bitset<4000000> bt;
pair<int, int> mc(x, y);
if (!bc) swap(mc.first, mc.second);
for (auto i = (0); i <= (n - 1); ++i)
for (auto j = (0); j <= (m - 1); ++j) {
if (d[i][j].first <= mc.first and d[i][j].second <= mc.second) {
bt.set(i * m + j);
}
}
return bt;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
cin >> r >> c;
cin >> x >> y;
--r, --c;
a.resize(n);
for (auto i = (0); i <= (n - 1); ++i) cin >> a[i];
cout << (get(0) | get(1)).count() << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int no = 3e6 + 5, modulo = 1e9 + 7, inf = 1e18, N = 3e3 + 1;
long long int ar[no], br[no], cr[no];
void solve() {
long long int n = 0, m = 0, a = 0, b = 0, c = 0, d = 0, x = 0, y = 0, z = 0,
w = 0, k = 0;
cin >> n;
long long int q;
cin >> q;
while (q--) {
cin >> x;
if (x % 2) {
cout << (x + 1) / 2 << "\n";
} else {
y = (x - 1) / 2;
y += (n - x);
y++;
while (y % 2 == 0) {
x += y;
y /= 2;
}
x += y;
cout << (x + 1) / 2 << "\n";
}
}
}
inline void runn() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 1; i < t + 1; i++) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool fun(const pair<int, int> &p1, const pair<int, int> &p2) {
return (p1.second < p2.second);
}
int main() {
int n, i, j, ans;
cin >> n;
pair<int, int> p[n + 1];
for (i = 1; i <= n; ++i) {
cin >> p[i].first;
p[i].second = i;
}
sort(p + 1, p + n + 1, greater<pair<int, int>>());
ans = 0;
for (i = 1; i <= n; ++i) {
ans = ans + 1 + p[i].first * (i - 1);
}
cout << ans << "\n";
for (i = 1; i <= n; ++i) cout << p[i].second << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
vector<int> nums(n, 0);
for (int i = 0; i < n; i++) cin >> nums[i];
vector<int> ans(n, -1);
vector<int> prime = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
int curr_color = 1;
for (auto p : prime) {
bool flag = false;
for (int i = 0; i < n; i++) {
if (ans[i] != -1) continue;
if (nums[i] % p) continue;
flag = true;
ans[i] = curr_color;
}
if (flag) curr_color++;
}
cout << curr_color - 1 << endl;
for (auto x : ans) cout << x << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int64_t mod = 1e9 + 7, inf = 4e18;
map<vector<int64_t>, long double> seen;
long double rec(vector<int64_t> &people, int64_t n, int64_t len) {
if (len < 0) return -1;
if (n == 0) return 0;
if (seen[people]) return seen[people];
long double ans = 0;
for (int64_t i = 0; i < people.size(); i++) {
if (people[i] == 0) continue;
people[i] -= 1;
ans += (1 + rec(people, n - 1, len - i)) * (people[i] + 1) / n;
people[i] += 1;
}
seen[people] = ans;
return ans;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
cout << fixed << setprecision(5);
int64_t n, p;
cin >> n;
vector<int64_t> hist(51, 0);
int64_t tmp;
for (int64_t i = 0; i < int64_t(n); ++i) cin >> tmp, hist[tmp]++;
cin >> p;
cout << rec(hist, n, p);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int INF = 4127;
const int mod = 475;
int a[1005], b[1005];
set<int> rofl;
int main() {
int n, m, ans = 0, sum = 0;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
}
for (int i = 1; i <= 2000; i++) {
int x = i;
bool ok = 1;
for (int j = 1; j <= m; j++) {
if ((a[j] + x - 1) / x != b[j]) {
ok = 0;
break;
}
}
if (ok) {
rofl.insert((n + x - 1) / x);
}
}
if (rofl.size() != 1) {
cout << -1;
return 0;
}
cout << *rofl.begin();
}
| 2 |
#include <bits/stdc++.h>
int main() {
int cus, abs, wdw;
scanf("%d%d", &abs, &wdw);
for (cus = 0; cus < wdw; cus++) {
if (abs % 10 == 0) {
abs /= 10;
} else {
abs -= 1;
}
}
printf("%d\n", abs);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, q;
char s[N];
struct str {
void bld() {
for (char c = 'a'; c <= 'z'; c++) segtree[c - 'a'].bld(c);
}
void setRange(char ch, int u, int v, int l, int r) {
if (r < l) return;
segtree[ch - 'a'].setRange(0, l, r);
if (v >= u) segtree[ch - 'a'].setRange(1, u, v);
}
vector<int> composition(int l, int r) {
vector<int> ret;
for (char c = 'a'; c <= 'z'; c++) {
ret.emplace_back(segtree[c - 'a'].query(l, r));
}
return ret;
}
struct segment_tree {
struct node {
int sum = 0, tp;
bool pu = 0;
} tree[N << 2];
void merge(node &nn, node &l, node &r) { nn.sum = l.sum + r.sum; }
void push(int &x, int &lx, int &rx) {
node &nn = tree[x];
if (lx == rx) {
if (nn.pu) {
nn.sum = nn.tp;
nn.pu = 0;
}
return;
}
if (nn.pu) {
node &lc = tree[x + x];
node &rc = tree[x + 1 + x];
lc.pu = rc.pu = 1;
lc.tp = rc.tp = nn.tp;
nn.sum = (rx - lx + 1) * nn.tp;
nn.pu = 0;
}
}
void bld(char c, int x = 1, int lx = 1, int rx = n) {
tree[x].pu = 0;
if (lx == rx) {
tree[x].sum = (s[lx] == c ? 1 : 0);
return;
}
int mid = lx + rx >> 1;
bld(c, x + x, lx, mid);
bld(c, x + 1 + x, mid + 1, rx);
merge(tree[x], tree[x + x], tree[x + 1 + x]);
}
int val, u, v;
void upd(int x = 1, int lx = 1, int rx = n) {
push(x, lx, rx);
if (v < lx or u > rx) return;
if (u <= lx and rx <= v) {
tree[x].pu = 1;
tree[x].tp = val;
push(x, lx, rx);
return;
}
int mid = lx + rx >> 1;
upd(x + x, lx, mid);
upd(x + 1 + x, mid + 1, rx);
merge(tree[x], tree[x + x], tree[x + 1 + x]);
}
void setRange(int value, int l, int r) {
val = value;
u = l;
v = r;
upd();
}
int qry(int x = 1, int lx = 1, int rx = n) {
push(x, lx, rx);
if (v < lx or u > rx) return 0;
if (u <= lx and rx <= v) return tree[x].sum;
int mid = lx + rx >> 1;
return qry(x + x, lx, mid) + qry(x + 1 + x, mid + 1, rx);
}
int query(int l, int r) {
u = l;
v = r;
return qry();
}
} segtree[26];
} T;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
cin >> 1 + s;
T.bld();
int l, r, ty;
while (q--) {
cin >> l >> r >> ty;
auto v = T.composition(l, r);
if (ty == 1) {
int packed = 0;
for (char c = 'a'; c <= 'z'; c++) {
int len = v[c - 'a'];
T.setRange(c, l + packed, l + packed + len - 1, l, r);
packed += len;
}
} else {
int packed = 0;
for (char c = 'z'; c >= 'a'; c--) {
int len = v[c - 'a'];
T.setRange(c, l + packed, l + packed + len - 1, l, r);
packed += len;
}
}
}
for (int i = 1; i <= n; i++) {
auto v = T.composition(i, i);
char c = 'a' + (int)(max_element(v.begin(), v.end()) - v.begin());
cout << c;
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 100;
double alpha[maxn], beta[maxn];
double a[maxn], b[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf", &beta[i]);
for (int i = 0; i < n; i++) scanf("%lf", &alpha[i]);
double Sa = 0, Sb = 0;
for (int i = 0; i < n; i++) {
double c = alpha[i] + beta[i];
double A = 1, B = -(c + (Sb - Sa)), C = beta[i] - c * Sa;
double x1 = (-B + sqrt(max(0., B * B - 4. * A * C))) / 2.;
double y1 = c - x1;
a[i] = x1;
b[i] = y1;
Sa += a[i];
Sb += b[i];
}
cout.precision(15);
for (int i = 0; i < n; i++) printf("%.9lf ", a[i]);
printf("\n");
for (int i = 0; i < n; i++) printf("%.9lf ", b[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926536;
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void TXT() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
FAST();
string s;
cin >> s;
int n;
cin >> n;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] += 32;
if (s[i] - n < 'a') {
if (s[i] >= 'a' && s[i] <= 'z') s[i] -= 32;
}
}
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9, inff = 1e18;
struct edge {
int to, nxxt;
long long len;
} e[501200 << 1];
queue<int> q;
int head[501200], cnt = 2, n, S, T, dep[501200], cur[501200];
inline void ins(int u, int v, long long w) {
e[cnt] = (edge){v, head[u], w};
head[u] = cnt++;
}
inline bool bfs() {
for (int i = 1; i <= T; i++) cur[i] = head[i], dep[i] = -1;
dep[S] = 0;
q.push(S);
while (!q.empty()) {
int a1 = q.front();
q.pop();
for (int i = head[a1]; i; i = e[i].nxxt) {
int t1 = e[i].to;
if (e[i].len && dep[t1] == -1) {
dep[t1] = dep[a1] + 1;
q.push(t1);
}
}
}
return dep[T] != -1;
}
long long dfs(int te, long long fl) {
if (te == T) return fl;
long long ret = 0;
for (int i = head[te]; i; i = e[i].nxxt) {
int j = e[i].to;
if (dep[j] == dep[te] + 1 && e[i].len) {
long long r = dfs(j, min(fl, e[i].len));
if (r) {
ret += r;
fl -= r;
e[i].len -= r;
e[i ^ 1].len += r;
if (!fl) break;
}
}
}
return ret;
}
int main() {
scanf("%d", &n);
S = 2 * n + 1, T = S + 1;
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int x;
scanf("%d", &x);
ins(i, x + n, inff);
ins(x + n, i, 0);
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
ans += inf - x;
ins(S, i, inf - x);
ins(i, S, 0);
}
for (int i = 1; i <= n; i++) ins(i + n, T, inf), ins(T, i + n, 0);
while (bfs()) {
ans -= dfs(S, inff);
}
printf("%lld\n", -ans);
}
| 5 |
#include <bits/stdc++.h>
const long long mod9 = 1e9 + 7;
const long long maxsize = 2e9 + 1;
const long long mod2 = 1073741824;
const long long INF = 1e18L + 5;
using namespace std;
void solve() {
long long a, b;
cin >> a >> b;
if (!a or !b) {
cout << 0 << "\n";
return;
}
long long minc = min(a, b);
cout << min(minc, (a + b) / 3) << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct Data {
ll one, size, ans;
};
struct st {
ll one, size, ans;
bool b;
st *L, *R;
void change() {
ans = one*(size-one)-ans;
one = size-one;
b ^= 1;
}
void pull() {
one = L->one+R->one;
ans = L->ans+R->ans+(R->size-R->one)*L->one;
b = 0;
}
void push() {
if (b) {
L->change();
R->change();
}
}
};
st *build(int L, int R)
{
st *c = new st;
if (L == R) {
scanf("%lld", &c->one);
c->size = 1;
c->ans = 0;
return c;
}
int m = (L+R)/2;
c->L = build(L, m);
c->R = build(m+1, R);
c->pull();
c->size = R-L+1;
return c;
}
void modify(st *c, int L, int R, int x, int y)
{
if (y < L || R < x) return;
if (x <= L && R <= y) {
c->change();
return;
}
c->push();
int m = (L+R)/2;
modify(c->L, L, m, x, y);
modify(c->R, m+1, R, x, y);
c->pull();
}
Data query(st *c, int L, int R, int x, int y)
{
if (y < L || R < x) return Data{0, 0, 0};
if (x <= L && R <= y) return Data{c->one, c->size, c->ans};
c->push();
int m = (L+R)/2;
Data l = query(c->L, L, m, x, y), r = query(c->R, m+1, R, x, y);
c->pull();
return Data{l.one+r.one, l.size+r.size, l.ans+r.ans+(r.size-r.one)*l.one};
}
int main()
{
int n, q, t, l, r;
scanf("%d%d", &n, &q);
st *c = build(1, n);
while (q--) {
scanf("%d%d%d", &t, &l, &r);
if (t == 1) {
modify(c, 1, n, l, r);
}
else {
printf("%lld\n", query(c, 1, n, l, r).ans);
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0;
scanf("%I64d", &n);
cout << (n / 2) + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const double eps = (1e-6);
vector<int> adj[3];
int visit[3];
bool cycle(int cur) {
visit[cur] = 1;
for (auto to : adj[cur]) {
if (visit[to] == 1) return 1;
if (cycle(to)) return 1;
}
visit[cur] = 2;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int i = 0; i < 3; ++i) {
char x, sign, y;
cin >> x >> sign >> y;
if (sign == '>')
adj[x - 'A'].push_back(y - 'A');
else
adj[y - 'A'].push_back(x - 'A');
}
for (int i = 0; i < 3; ++i) {
memset(visit, 0, sizeof(visit));
if (cycle(i)) {
cout << "Impossible" << endl;
return 0;
} else if (visit[0] == 2 && visit[1] == 2 && visit[2] == 2) {
string ans;
ans += char(i + 'A');
if ((int)(adj[adj[i][0]]).size()) {
ans += char(adj[i][0] + 'A');
ans += char(adj[adj[i][0]][0] + 'A');
} else {
ans += char(adj[i][1] + 'A');
ans += char(adj[adj[i][1]][0] + 'A');
}
reverse(ans.begin(), ans.end());
cout << ans << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char inp[5010][5010];
int to[5010][5010];
priority_queue<int> Q;
int main() {
int n, m, i, j, c, res = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", inp[i]);
to[i][m] = m;
for (j = m - 1; j >= 0; j--) {
to[i][j] = (inp[i][j] == '1') ? to[i][j + 1] : j;
}
}
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
Q.push(to[j][i]);
}
c = 0;
while (!Q.empty()) {
c++;
res = max(res, (Q.top() - i) * c);
Q.pop();
}
}
printf("%d", res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int p[2];
int cnt;
node() {
cnt = 0;
p[0] = -1;
p[1] = -1;
}
};
vector<node> v;
string tobin(int n) {
string ans = "";
while (n != 0) {
if (n % 2 == 0)
ans += '0';
else
ans += '1';
n /= 2;
}
for (int i = ans.size(); i < 31; i++) ans += '0';
reverse(ans.begin(), ans.end());
return ans;
}
void insert(string n, int ad) {
int cur = 0;
for (int i = 0; i < 31; ++i) {
int b = n[i] - '0';
if (v[cur].p[b] == -1) {
v[cur].p[b] = v.size();
v.push_back(node());
}
cur = v[cur].p[b];
v[cur].cnt += ad;
}
}
string ans(string n) {
int cur = 0;
string ans = tobin(0);
for (int i = 0; i < 31; ++i) {
ans[i] = '1';
int b = n[i] - '0';
int nod = v[cur].p[!b];
if (v[cur].p[!b] != -1 && v[nod].cnt) {
cur = nod;
} else {
ans[i] = '0';
cur = v[cur].p[b];
}
}
return ans;
}
int frombin(string n) {
int k = 0;
for (int i = 0; i < 31; i++) {
k += pow(2.0, 30 - i) * (n[i] - '0');
}
return k;
}
int main() {
int q;
cin >> q;
char c;
int x;
v.push_back(node());
v[0].cnt = 0;
string n = tobin(0);
insert(n, 1);
for (int i = 0; i < q; i++) {
cin >> c >> x;
string v = tobin(x);
if (c == '+') {
insert(v, 1);
} else if (c == '-') {
insert(v, -1);
} else {
string u = ans(v);
int ans = frombin(u);
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
long long a,b,c[200005],n,d,ans,x[200005],y[200005],l,k;
struct node
{
long long x,y;
} w[200005];
inline bool cmp(node x,node y)
{
return x.x<y.x;
}
int main()
{
scanf("%lld%lld%lld",&n,&d,&a);
d*=2;
for(int i=1; i<=n; ++i)
{
scanf("%lld%lld",&w[i].x,&w[i].y);
w[i].y=(w[i].y+a-1)/a;
}
sort(w+1,w+n+1,cmp);
l=1;
for(int i=1; i<=n; ++i)
{
while(l<i&&w[i].x-w[l].x>d)
k-=c[l++];
c[i]=w[i].y-k;
if(c[i]<0)
c[i]=0;
ans+=c[i];
k+=c[i];
}
printf("%lld",ans);
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
long long A[5001], B[5001], dp[5001];
int n, m;
long long iabs(long long a) {
if (a < 0) return (-a);
return a;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
B[i] = A[i];
}
sort(B, B + n);
m = 0;
for (int i = 0; i < n; i++) {
while (i + 1 < n && B[i] == B[i + 1]) i++;
B[m++] = B[i];
}
dp[0] = iabs(A[0] - B[0]);
for (int j = 1; j < m; j++) dp[j] = min(dp[j - 1], abs(A[0] - B[j]));
for (int i = 1; i < n; i++) {
dp[0] += abs(A[i] - B[0]);
for (int j = 1; j < m; j++)
dp[j] = min(dp[j - 1], dp[j] + abs(A[i] - B[j]));
}
cout << dp[m - 1] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int64_t mx = 1e9 + 9;
int64_t po(int64_t a, int64_t b) {
int64_t ans = 1;
while (b) {
if (b & 1) {
ans = (ans * (a % mx)) % mx;
}
a = a * a % mx;
b = b >> 1;
}
return ans;
}
int main() {
int64_t n, a, b, k, curr = 0;
cin >> n >> a >> b >> k;
string s;
cin >> s;
for (int64_t i = 0; i < k; i++) {
if (s[i] == '+') {
curr = (curr + (po(a, n - i) * (po(b, i) % mx)) % mx) % mx;
} else {
curr = (curr - (po(a, n - i) * po(b, i) % mx) + mx) % mx;
}
}
int64_t qq = po(a, k);
int64_t t = (po(qq, (mx - 2) % (mx)) % mx) * po(b, k) % mx;
if (t == 1)
curr = curr * ((n + 1) / k) % mx;
else
curr = (curr * po(t - 1, (mx - 2) % (mx)) % (mx)) *
(po(t, (n + 1) / k) - 1) % mx;
cout << curr << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int c = 300500;
struct rec {
int i, a, b;
};
bool operator<(const rec &a, const rec &b) {
if (a.b != b.b) return a.b < b.b;
if (a.a % a.b != b.a % b.b) return a.a % a.b < b.a % b.b;
return a.a > b.a;
}
int n, p;
int a[c];
rec m[c];
long long ans[c];
int main() {
scanf("%d", &n);
int i, j;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
scanf("%d", &p);
for (i = 1; i <= p; ++i) {
m[i].i = i;
scanf("%d%d", &m[i].a, &m[i].b);
}
m[0].b = 0;
sort(m + 1, m + p + 1);
bool q;
for (i = 1; i <= p; ++i) {
if (m[i].b == m[i - 1].b && m[i].a % m[i].b == m[i - 1].a % m[i - 1].b)
q = 1;
else
q = 0;
ans[m[i].i] = 0;
j = m[i].a;
while (j <= n && !(q && j == m[i - 1].a)) {
ans[m[i].i] += a[j];
j += m[i].b;
}
if (q) ans[m[i].i] += ans[m[i - 1].i];
}
for (i = 1; i <= p; ++i) cout << ans[i] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, a[5002], in[5002][2] = {0}, r, f, s, j, sum = 0, ans = 0,
dp[5002] = {0}, l;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<pair<long long, long long> > g;
map<pair<long long, long long>, long long> v;
set<long long> st;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
for (i = 1; i <= n; ++i) {
if (in[a[i]][0] == 0) in[a[i]][0] = i;
in[a[i]][1] = i;
}
for (i = 1; i <= n; ++i) {
r = in[a[i]][1];
f = 1;
s = 0;
st.clear();
for (j = i; j <= r; ++j) {
if (in[a[j]][0] < i) {
f = 0;
break;
}
if (in[a[j]][1] > r) r = in[a[j]][1];
if (st.find(a[j]) == st.end()) {
s = (s ^ a[j]);
st.insert(a[j]);
}
}
if (f) {
g.push_back({i, r});
v[{i, r}] = s;
}
}
sort(g.begin(), g.end(), cmp);
pair<long long, long long> p;
for (i = n; i > 0; --i) {
p = {i, 1e9};
l = upper_bound(g.begin(), g.end(), p) - g.begin();
if (g[l - 1].first != i)
dp[i] = dp[i + 1];
else
dp[i] = max(dp[i + 1], v[g[l - 1]] + dp[g[l - 1].second + 1]);
}
cout << dp[1];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
const int mod = 1e9 + 7;
const int MAXN = 1 << 20;
string s, t;
int n, gap;
int sa[MAXN], pos[MAXN], tmp[MAXN], lcp[MAXN];
int cnt[MAXN];
int L[MAXN], R[MAXN];
int st[MAXN];
int sz;
bool sufCmp(int i, int j) {
if (pos[i] != pos[j]) return pos[i] < pos[j];
i += gap;
j += gap;
return (i < n && j < n) ? pos[i] < pos[j] : i > j;
}
void buildSA() {
n = s.length();
for (int i = 0; i < n; ++i) sa[i] = i, pos[i] = s[i];
for (gap = 1;; gap *= 2) {
sort(sa, sa + n, sufCmp);
for (int i = 0; i + 1 < n; ++i)
tmp[i + 1] = tmp[i] + sufCmp(sa[i], sa[i + 1]);
for (int i = 0; i < n; ++i) pos[sa[i]] = tmp[i];
if (tmp[n - 1] == n - 1) break;
}
}
void buildLCP() {
for (int i = 0, k = 0; i < n; ++i)
if (pos[i] != n - 1) {
for (int j = sa[pos[i] + 1]; s[i + k] == s[j + k];) ++k;
lcp[pos[i]] = k;
if (k) --k;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin >> s >> t;
reverse(t.begin(), t.end());
buildSA();
buildLCP();
for (int i = 0; i < n; ++i) {
cnt[i] = t[sa[i]] - '0';
cnt[i] = 1 - cnt[i];
if (i) cnt[i] += cnt[i - 1];
}
int sz = 0;
for (int i = 0; i < n; ++i) {
int len = n - sa[i];
while (sz > 0 && lcp[st[sz]] >= len) --sz;
if (sz == 0)
L[i] = -1;
else
L[i] = st[sz];
st[++sz] = i;
}
sz = 0;
for (int i = n - 1; i >= 0; --i) {
int len = n - sa[i];
if (lcp[i] < len) {
R[i] = i;
st[++sz] = i;
continue;
}
while (sz > 0 && lcp[st[sz]] >= len) --sz;
if (sz > 0)
R[i] = st[sz];
else
R[i] = n - 1;
st[++sz] = i;
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
int x = n - sa[i];
int all = cnt[R[i]];
if (L[i] >= 0) all -= cnt[L[i]];
ans = max(ans, all * 1ll * x);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000200;
const long long MOD = 1e9 + 7;
long long mult(long long a, long long b) { return (a * b) % MOD; }
long long factor[MAXN];
int n, m;
int it;
int num[MAXN];
set<int> sets[MAXN];
int a[MAXN];
int cnt[MAXN];
vector<int> v[MAXN];
int main() {
factor[0] = 1;
for (int i = 1; i < MAXN; ++i) factor[i] = mult(factor[i - 1], i);
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) sets[0].insert(i + 1);
it = 1;
for (int i = 0; i < n; ++i) {
int k;
scanf("%d", &k);
for (int i = 0; i < k; ++i) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 0; i < k; ++i) v[cnt[a[i]]].push_back(a[i]);
for (int i = 0; i < k; ++i) {
if (v[cnt[a[i]]].empty()) continue;
map<int, set<int>> inter;
for (int j : v[cnt[a[i]]]) {
int x = num[j];
{
inter[x].insert(j);
sets[x].erase(j);
}
}
for (auto x : inter) {
for (auto j : x.second) num[j] = it;
sets[it++] = x.second;
}
v[cnt[a[i]]].clear();
}
for (int i = 0; i < k; ++i) cnt[a[i]] = 0;
}
long long ans = 1;
for (int i = 0; i < it; ++i) ans = mult(ans, factor[sets[i].size()]);
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005, mod1 = 1e9 + 9, base1 = 31, mod2 = 1e9 + 7, base2 = 59;
bool pre[N][N];
int hash1[N][N], hash2[N][N];
void buildPreHash(const string &x) {
int n = ((int)((x).size()));
for (int i = 0; i < n; i++) {
long long h1 = 1, h2 = 1;
for (int j = i; j < n; j++) {
h1 = (h1 * base1 + x[j] - 'a') % mod1;
hash1[i][j] = h1;
h2 = (h2 * base2 + x[j] - 'a') % mod2;
hash2[i][j] = h2;
}
}
for (auto i = 0; i < (long long)(n); i++) {
unordered_set<int> h1, h2;
for (int j = 0; i + j < n; j++) {
if (j - (i + 1) >= 0) {
h1.insert(hash1[j - (i + 1)][j - 1]);
h2.insert(hash2[j - (i + 1)][j - 1]);
}
if (h1.find(hash1[j][j + i]) != h1.end() &&
h2.find(hash2[j][i + j]) != h2.end())
pre[j][i + j] = 1;
}
}
}
string x;
int n, a, b;
int memo[N];
int solve(int idx) {
if (idx == n) return 0;
int &ret = memo[idx];
if (~ret) return ret;
ret = a + solve(idx + 1);
for (int j = idx; j < n; j++) {
if (pre[idx][j]) ret = min(ret, b + solve(j + 1));
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
cin >> x;
buildPreHash(x);
memset(memo, -1, sizeof memo);
cout << solve(0) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long n, k, b, ans = 0;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
if (a[i] < k) {
b = k - a[i];
ans = ans + b / a[0];
}
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#define FOR(i, a, n) for(ll i = (ll)a; i < (ll)n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
constexpr ll mod = 1e9 + 7;
template <class T> inline bool chmax(T &a, const T b) {
if(a >= b) return false;
a = b;
return true;
}
template <class T> inline bool chmin(T &a, const T b) {
if(a <= b) return false;
a = b;
return true;
}
/*-------------------------------------------*/
int n, q, par[100000][17], dep[100009];
int LCA(int u, int v) {
if(dep[u] > dep[v]) swap(u, v);
rep(i, 17) if((dep[v] - dep[u] >> i) & 1) v = par[v][i];
if(u == v) return u;
for(int i = 16; i >= 0; i--)
if(par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return par[u][0];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cin >> n;
par[0][0] = -1;
rep(i, n) {
int k;
cin >> k;
rep(j, k) {
int a;
cin >> a;
par[a][0] = i;
dep[a] = dep[i] + 1;
}
}
FOR(i, 1, 17) {
rep(j, n) {
if(par[j][i - 1] == -1)
par[j][i] = -1;
else
par[j][i] = par[par[j][i - 1]][i - 1];
}
}
cin >> q;
while(q--) {
int u, v;
cin >> u >> v;
cout << LCA(u, v) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 999999;
int n, m;
int ss[maxN], ff[maxN], dd[maxN], x[maxN], last[maxN], pred[maxN], good[maxN],
deg[maxN], used[maxN];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &ss[i], &ff[i], &dd[i]);
ss[i + m] = ff[i];
ff[i + m] = ss[i];
dd[i + m] = dd[i];
}
for (int i = 1; i <= n; i++) {
last[i] = 0;
}
for (int i = 1; i <= m + m; i++) {
good[i] = 0;
pred[i] = last[ss[i]];
last[ss[i]] = i;
}
for (int i = 1; i <= n; i++) {
deg[i] = 0;
}
for (int i = 1; i <= m + m; i++) {
deg[ss[i]] += dd[i];
}
for (int i = 1; i <= n; i++) {
deg[i] /= 2;
}
for (int i = 1; i <= n; i++) {
used[i] = 0;
}
deg[1] = deg[n] = 0;
int l = 1;
int e = 1;
x[1] = 1;
while (l <= e) {
int j = last[x[l]];
while (j > 0) {
if (ff[j] == n) {
good[j] = 1;
}
if (used[ff[j]] < deg[ff[j]]) {
good[j] = 1;
used[ff[j]] += dd[j];
if (used[ff[j]] == deg[ff[j]]) {
e++;
x[e] = ff[j];
}
}
j = pred[j];
}
l++;
}
for (int i = 1; i <= m; i++) {
printf("%d\n", 1 - good[i]);
}
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main()
{
int h, w;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
cin >> s[i];
}
int a[26] = {};
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
a[s[i][j] - 'a']++;
}
}
int sum4 = 0, sum2 = 0;
for (int i = 0; i < 26; i++) {
int tmp = a[i] / 4;
a[i] -= tmp * 4;
sum4 += tmp;
sum2 += a[i] / 2;
}
if ((h / 2) * (w / 2) <= sum4) {
sum4 -= (h / 2) * (w / 2);
int t = 0;
if (h % 2 == 1) {
t += w / 2;
}
if (w % 2 == 1) {
t += h / 2;
}
if (t <= sum2 + sum4 * 2) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
cout << "No" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,s,t) for(int i=s;i<t;i++)
int num[2][200][200][200];
char mat[200][200];
int main()
{
int n,m;scanf("%d%d",&n,&m);
rep(i,1,n+1)scanf("%s",mat[i]+1);
for(int i=m;i;i--)
rep(j,1,n+1)
{
int flag=1,bef=mat[j][i];
for(int k=j;k;k--)
{
flag&=(bef==mat[k][i]);
if(flag)num[0][i][j][k]=mat[k][i]==mat[k][i+1]?(i!=m?num[0][i+1][j][k]:m):i;
else num[0][i][j][k]=i-1;
bef=mat[k][i];
}
}
int type=1,r=0;
while(1)
{
if(num[!type][1][n][1]==m)break;
r++;
rep(i,1,m+1)rep(j,1,n+1)rep(k,1,j+1)
num[type][i][j][k]=num[!type][i][j][k]==m?m:num[!type][num[!type][i][j][k]+1][j][k];
rep(i,1,m+1)rep(j,1,n+1)
{
int pos=j;
for(int k=j;k;k--)
{
while(pos>k+1&&min(num[!type][i][j][pos],num[!type][i][pos-1][k])<=
min(num[!type][i][j][pos-1],num[!type][i][pos-2][k]))
pos--;
if(pos!=k)
num[type][i][j][k]=max(num[type][i][j][k],min(num[!type][i][j][pos],num[!type][i][pos-1][k]));
}
}
type=!type;
}
printf("%d\n",r);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T Abs(const T& value) {
return value < 0 ? -value : value;
}
template <typename T>
inline T Sqr(const T& value) {
return value * value;
}
int main() {
int n;
cin >> n;
vector<long long> ans(n, 0);
vector<int> a(n);
vector<long long> sum(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a.rbegin(), a.rend());
for (int i = 0; i < n; ++i) {
sum[i] = a[i];
if (i > 0) sum[i] += sum[i - 1];
}
for (int i = 1; i <= n - 1; ++i) {
long long cur = 1;
long long sz = i;
long long ml = 1;
while (cur < n) {
ans[i] += (sum[min<long long>(cur + sz - 1, n - 1)] - sum[cur - 1]) * ml;
cur += sz;
sz = sz * i;
++ml;
}
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int qq;
scanf("%d", &qq);
if (qq >= n - 1) qq = n - 1;
cout << ans[qq] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using namespace std;
ifstream fin("AAtest.in.txt");
int n, a, b, c, vas;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> a >> b >> c;
int aa = 0, vas = 0;
while (aa <= n) {
int bb = 0;
while (bb <= n - aa) {
int cc = n - aa - bb;
if (!(cc % c)) vas = max(vas, aa / a + bb / b + cc / c);
bb += b;
}
aa += a;
}
cout << vas;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string x;
cin >> n >> x;
int c1 = 0, c2 = 0;
for (int i = n - 1; i >= 0; i--) {
int z = x[i] - '0';
if (z == 7 || z == 4) {
if (i >= n / 2)
c1 += z;
else
c2 += z;
} else {
cout << "NO" << endl;
return 0;
}
}
if (c1 == c2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > g[1001];
long long int n, m, k;
char a[1001][11][11];
long long int d[1001];
long long int vis[1001];
vector<pair<long long int, long long int> > op;
long long int xxx() {
long long int i, u, v, dist, e, par, ans = 0;
for (i = 0; i <= k; i++) {
d[i] = (long long)1000000000000000000;
vis[i] = 0;
}
priority_queue<
pair<long long int, pair<long long int, long long int> >,
vector<pair<long long int, pair<long long int, long long int> > >,
greater<pair<long long int, pair<long long int, long long int> > > >
pq;
pq.push(pair<long long int, pair<long long int, long long int> >(
0, pair<long long int, long long int>(0, 0)));
d[0] = 0;
while (!pq.empty()) {
u = (pq.top()).second.first;
dist = (pq.top()).first;
par = (pq.top()).second.second;
pq.pop();
if (vis[u] == 1) continue;
ans = ans + d[u];
op.push_back(pair<long long int, long long int>(u, par));
for (i = 0; i < g[u].size(); i++) {
v = g[u][i].first;
e = g[u][i].second;
if (vis[v] == 0 && d[v] > e) {
d[v] = e;
pq.push(pair<long long int, pair<long long int, long long int> >(
e, pair<long long int, long long int>(v, u)));
}
}
vis[u] = 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, cost, u, v, w, it;
cin >> n >> m >> k >> w;
for (i = 1; i <= k; i++)
for (j = 1; j <= n; j++)
for (it = 1; it <= m; it++) cin >> a[i][j][it];
for (u = 1; u <= k; u++) {
g[0].push_back(pair<long long int, long long int>(u, n * m));
g[u].push_back(pair<long long int, long long int>(0, n * m));
for (v = 1; v <= k; v++) {
cost = 0;
if (v == u) continue;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[u][i][j] != a[v][i][j]) cost++;
}
}
g[u].push_back(pair<long long int, long long int>(v, cost * w));
}
}
cout << xxx() << "\n";
for (i = 1; i <= k; i++) cout << op[i].first << " " << op[i].second << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, m;
std::cin >> n >> m;
int* r = new int[n];
int* c = new int[m];
int xor_row = 0, xor_col = 0;
for (int i = 0; i != n; ++i) {
std::cin >> r[i];
xor_row ^= r[i];
}
for (int j = 0; j != m; ++j) {
std::cin >> c[j];
xor_col ^= c[j];
}
if (xor_row != xor_col) {
std::cout << "NO" << std::endl;
return 0;
}
std::cout << "YES" << std::endl;
for (int i = 0; i != n - 1; ++i) {
for (int j = 0; j != m - 1; ++j) {
std::cout << 0 << " ";
}
std::cout << r[i] << std::endl;
}
for (int j = 0; j != m - 1; ++j) {
std::cout << c[j] << " ";
}
std::cout << (r[n - 1] ^ c[m - 1] ^ xor_row) << std::endl;
delete[] r;
delete[] c;
}
| 4 |
#include<iostream>
using namespace std;
#include<vector>
int main(){
int n,m,c;
cin>>n>>m>>c;
vector<int> b(m);
for(int i=0;i<m;i++) cin>>b[i];
int cnt=0;
for(int i=0;i<n;i++){
int res=c;
for(int j=0;j<m;j++){
int a;
cin>>a;
res+=a*b[j];
}
if(res>0) cnt++;
}
cout<<cnt<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
cout << (m * (m - 1)) / 2 << '\n';
for (int i = 1; i < m; ++i) {
for (int j = i + 1; j <= m; ++j) {
if (k)
cout << j << ' ' << i;
else
cout << i << ' ' << j;
cout << '\n';
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int A[11];
int a[51],b[51],c[51],d[51];
int n,m,q,cnt=0,maxc=0;
void dfs(int t,int k)
{
// cout<<t<<" "<<k<<endl;
if(t==1)
{
for(int i=k;i>=1;i--)
{
cnt=0;
A[1]=i;
for(int j=0;j<q;j++)
{
if(A[b[j]]-A[a[j]]==c[j])
cnt+=d[j];
}
maxc=max(maxc,cnt);
}
return;
}
else
{
for(int i=k;i>=1;i--)
{
A[t]=i;
dfs(t-1,i);
}
}
}
int main()
{
cin>>n>>m>>q;
for(int i=0;i<q;i++)
{
cin>>a[i]>>b[i]>>c[i]>>d[i];
}
dfs(n,m);
cout<<maxc;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int razm = 1001;
int n, d, z = 0, tek = 0;
string a[razm][3];
int b[razm];
bool v[razm];
int main() {
cin >> n >> d;
for (int i = 1; i <= n; i++) cin >> a[i][1] >> a[i][2] >> b[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][1] == a[j][2] & a[i][2] == a[j][1] & b[j] - b[i] <= d &
b[j] > b[i] & (!v[i])) {
bool f = true;
for (int h = 1; h <= n; h++)
if (v[h] & ((a[h][1] == a[i][2] & a[h][2] == a[i][1]) ||
(a[h][1] == a[i][1] & a[h][2] == a[i][2]))) {
f = false;
break;
}
if (f) {
z += 1;
v[i] = true;
}
}
cout << z << endl;
for (int i = 1; i <= n; i++)
if (v[i]) cout << a[i][1] << ' ' << a[i][2] << endl;
cin >> n;
}
| 1 |
#include <bits/stdc++.h>
bool chk[1001];
int main() {
int n, m, a, b;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
chk[a] = true;
chk[b] = true;
}
int index = 1;
printf("%d\n", n - 1);
for (int i = 1; i <= n; i++) {
if (chk[i] == false) {
index = i;
break;
}
}
for (int i = 1; i <= n; i++) {
if (i != index) {
printf("%d %d\n", index, i);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int S = 100003;
const int MOD = 1e9 + 7;
const double pi = 2 * acos(0.0);
int _In() {
int x;
scanf("%d", &x);
return x;
}
long long _LLI() {
long long x;
scanf("%lld", &x);
return x;
}
int dirX[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dirY[] = {0, 1, 0, -1, 1, -1, -1, 1};
int rX[] = {1, 1, 2, 2, -1, -1, -2, -2};
int rY[] = {2, -2, 1, -1, 2, -2, 1, -1};
template <class T>
T Distance(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
};
int sset(int N, int pos) { return N = N | (1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
struct data {
long long p, q;
bool operator<(const data &R) const {
if (p == R.p) return q < R.q;
return p < R.p;
}
} ob, ob1;
long long ar[S][4];
map<data, int> M;
int main() {
int n = _In();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) ar[i][j] = _LLI();
}
for (int i = 0; i < n; i++) sort(ar[i], ar[i] + 3);
double rad, ans = 0;
int ind, num = 1;
for (int i = 0; i < n; i++) {
rad = ar[i][0] / 2.0;
if (rad > ans) {
ind = i + 1;
ans = rad;
}
}
int ind1, ind2;
for (int i = 0; i < n; i++) {
ob.p = ar[i][0];
ob.q = ar[i][1];
ob1.p = ar[i][0];
ob1.q = ar[i][1];
if (M[ob1]) {
if (ar[i][0] == ar[M[ob1] - 1][0] && ar[i][1] == ar[M[ob1] - 1][1] &&
ar[i][2] == ar[M[ob1] - 1][2]) {
long long x = ar[i][0] + ar[M[ob1] - 1][0];
long long y = ar[i][1];
long long z = ar[i][2];
if (x < y) {
rad = x / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
} else {
rad = y / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
}
} else {
if (ar[M[ob1] - 1][0] == ar[i][0] && ar[M[ob1] - 1][1] == ar[i][1]) {
rad = ar[i][0] / 2.0;
if (rad > ans) {
ind2 = i + 1;
ind1 = M[ob1];
ans = rad;
num = 2;
}
} else if (ar[M[ob1] - 1][1] == ar[i][0] &&
ar[M[ob1] - 1][2] == ar[i][1]) {
rad = ar[i][0] / 2.0;
if (rad > ans) {
ind2 = i + 1;
ind1 = M[ob1];
ans = rad;
num = 2;
}
} else if (ar[M[ob1] - 1][0] == ar[i][0] &&
ar[M[ob1] - 1][2] == ar[i][1]) {
rad = ar[i][0] / 2.0;
if (rad > ans) {
ind2 = i + 1;
ind1 = M[ob1];
ans = rad;
num = 2;
}
}
}
}
ob1.p = ar[i][0];
ob1.q = ar[i][2];
if (M[ob1]) {
if (ar[M[ob1] - 1][0] == ar[i][0] && ar[M[ob1] - 1][1] == ar[i][2]) {
rad = ar[i][0] / 2.0;
if (rad > ans) {
ind2 = i + 1;
ind1 = M[ob1];
ans = rad;
num = 2;
}
} else if (ar[M[ob1] - 1][1] == ar[i][0] &&
ar[M[ob1] - 1][2] == ar[i][2]) {
long long y = ar[i][1] + ar[M[ob1] - 1][0];
long long x = ar[i][0];
long long z = ar[i][2];
if (x < y) {
rad = x / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
} else {
rad = y / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
}
} else if (ar[M[ob1] - 1][0] == ar[i][0] &&
ar[M[ob1] - 1][2] == ar[i][2]) {
rad = ar[i][0] / 2.0;
if (rad > ans) {
ind2 = i + 1;
ind1 = M[ob1];
ans = rad;
num = 2;
}
}
}
ob1.p = ar[i][1];
ob1.q = ar[i][2];
if (M[ob1]) {
if (ar[M[ob1] - 1][0] == ar[i][1] && ar[M[ob1] - 1][1] == ar[i][2]) {
long long x = ar[i][0] + ar[M[ob1] - 1][2];
long long y = ar[i][1];
long long z = ar[i][2];
if (x < y) {
rad = x / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
} else {
rad = y / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
}
} else if (ar[M[ob1] - 1][1] == ar[i][1] &&
ar[M[ob1] - 1][2] == ar[i][2]) {
long long x = ar[i][0] + ar[M[ob1] - 1][0];
long long y = ar[i][1];
long long z = ar[i][2];
if (x < y) {
rad = x / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
} else {
rad = y / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
}
} else if (ar[M[ob1] - 1][0] == ar[i][1] &&
ar[M[ob1] - 1][2] == ar[i][2]) {
long long x = ar[i][0] + ar[M[ob1] - 1][1];
long long y = ar[i][1];
long long z = ar[i][2];
if (x < y) {
rad = x / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
} else {
rad = y / 2.0;
if (rad > ans) {
ind1 = M[ob1];
ind2 = i + 1;
ans = rad;
num = 2;
}
}
}
}
if (!M[ob])
M[ob] = i + 1;
else {
if (ar[M[ob] - 1][0] < ar[i][0]) M[ob] = i + 1;
}
ob.p = ar[i][1];
ob.q = ar[i][2];
if (!M[ob])
M[ob] = i + 1;
else {
if (ar[M[ob] - 1][0] < ar[i][0]) M[ob] = i + 1;
}
ob.p = ar[i][0];
ob.q = ar[i][2];
if (!M[ob])
M[ob] = i + 1;
else {
if (ar[M[ob] - 1][0] < ar[i][0]) M[ob] = i + 1;
}
}
cout << num << endl;
if (num == 2)
cout << ind1 << " " << ind2 << endl;
else
cout << ind << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 31;
const long long int MOD = 998244353;
long long int mod(long long int n) { return (n % MOD + MOD) % MOD; }
void solve() {
long long int x;
cin >> x;
if (x % 4 == 0)
cout << x / 4 << endl;
else if (x % 4 == 1)
(x - 9) / 4 < 0 ? cout << -1 << endl : cout << 1 + (x - 9) / 4 << endl;
else if (x % 4 == 2)
(x - 6) / 4 < 0 ? cout << -1 << endl : cout << 1 + (x - 6) / 4 << endl;
else if (x % 4 == 3)
(x - 15) / 4 < 0 ? cout << -1 << endl : cout << 2 + (x - 15) / 4 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
cin >> T;
for (long long int i = 0; i < T; i++) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int n;
cin >> n;
for (int i = 1; i <= 9; ++i) {
if (n % i == 0 && n / i <= 9) {
cout << "Yes";
return 0;
}
}
cout << "No";
}
| 0 |
/*
Author: Nguyen Tan Bao
Status:
Idea:
*/
#include <bits/stdc++.h>
#define FI first
#define SE second
#define ALL(a) a.begin(), a.end()
#define SZ(a) int((a).size())
#define MS(s, n) memset(s, n, sizeof(s))
#define FOR(i,a,b) for (int i = (a); i <= (b); i++)
#define FORE(i,a,b) for (int i = (a); i >= (b); i--)
#define FORALL(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define TRAV(x, a) for (auto &x : a)
using namespace std;
using ll = long long; using ld = double;
using pi = pair<int, int>; using pl = pair<ll, ll>; using pd = pair<ld, ld>;
using cd = complex<ld>; using vcd = vector<cd>;
using vi = vector<int>; using vl = vector<ll>;
using vd = vector<ld>; using vs = vector<string>;
using vpi = vector<pi>; using vpl = vector<pl>; using vpd = vector<pd>; // vector<pair>
template<class T> using min_pq = priority_queue<T, vector<T>, greater<T> >;
template<class T> inline int ckmin(T& a, const T& val) { return val < a ? a = val, 1 : 0; }
template<class T> inline int ckmax(T& a, const T& val) { return a < val ? a = val, 1 : 0; }
template<class T> void remDup(vector<T>& v) { sort(ALL(v)); v.erase(unique(ALL(v)), end(v)); }
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x))
constexpr int p2(int x) { return 1<<x; }
constexpr int msk2(int x) { return p2(x)-1; }
ll ceilDiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); } // divide a by b rounded up
ll floorDiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); } // divide a by b rounded down
void setPrec(int x) { cout << fixed << setprecision(x); }
// TO_STRING
#define ts to_string
string ts(char c) { return string(1, c); }
string ts(const char* s) { return (string) s; }
string ts(string s) { return s; }
string ts(bool b) { return ts((int)b); }
template<class T> string ts(complex<T> c) { stringstream ss; ss << c; return ss.str(); }
template<class T> using V = vector<T>;
string ts(V<bool> v) {string res = "{"; FOR(i,0,SZ(v)-1) res += char('0'+v[i]); res += "}"; return res; }
template<size_t sz> string ts(bitset<sz> b) { string res = ""; FOR(i,0,SZ(b)-1) res += char('0'+b[i]); return res; }
template<class T, class U> string ts(pair<T,U> p);
template<class T> string ts(T v) { // containers with begin(), end()
bool fst = 1; string res = "";
for (const auto& x: v) { if (!fst) res += " "; fst = 0; res += ts(x); }
return res;
}
template<class T, class U> string ts(pair<T,U> p) { return "("+ts(p.FI)+", "+ts(p.SE)+")"; }
// OUTPUT
template<class T> void pr(T x) { cout << ts(x); }
template<class T, class ...U> void pr(const T& t, const U&... u) { pr(t); pr(u...); }
void ps() { pr("\n"); } // print w/ spaces
template<class T, class ...U> void ps(const T& t, const U&... u) { pr(t); if (sizeof...(u)) pr(" "); ps(u...); }
// DEBUG
void DBG() { cerr << "]" << endl; }
template<class T, class ...U> void DBG(const T& t, const U&... u) { cerr << ts(t); if (sizeof...(u)) cerr << ", "; DBG(u...); }
#define dbg(...) cerr << "Line(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#define chk(...) if (!(__VA_ARGS__)) cerr << "Line(" << __LINE__ << ") -> function(" \
<< __FUNCTION__ << ") -> CHK FAILED: (" << #__VA_ARGS__ << ")" << "\n", exit(0);
const ld PI = acos(-1.0);
const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1};
const ld EPS = 1e-9;
const ll MODBASE = 1000000007LL;
const int INF = 0x3f3f3f3f;
const int MAXN = 200010;
const int MAXM = 1000;
const int MAXK = 16;
const int MAXQ = 200010;
int n;
ll c, a[MAXN], b[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int te;
cin >> te;
while (te--) {
cin >> n >> c;
FOR(i,1,n) cin >> a[i];
FOR(i,1,n-1) cin >> b[i];
ll money = 0;
ll days = 0;
ll res = 1e18;
FOR(i,1,n) {
// stay forever
ll resStay = days;
if (money < c) {
resStay += (c - money) / a[i] + ((c - money) % a[i] > 0);
}
// dbg(i, resStay);
res = min(res, resStay);
// find way to move forward
if (i < n) {
ll resMove = days;
if (money < b[i]) {
ll incr = (b[i] - money) / a[i] + ((b[i] - money) % a[i] > 0);
money += incr * a[i];
resMove += incr;
}
money -= b[i];
days = resMove + 1;
// dbg(i, days, money);
}
}
cout << res << "\n";
}
return 0;
}
| 6 |
#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
int a;
double h, l;
int cnt = 0;
while(~scanf("%d,%lf,%lf", &a, &h, &l)){
if(h >= 25 * l * l){
printf("%d\n", a);
cnt++;
}
}
if(cnt == 0){
puts("該当なし");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
struct Point {
int x, y;
} pos[1000][2];
char map[31][31];
bool used[100][100], found[100][100];
int count, n, m, k, square[31][31], c[1000], saved[31][31], t;
Point find(Point p) {
int i, j;
for (i = -1; i <= 1; i++)
for (j = -1; j <= 1; j++)
if (i != j && map[p.x + i][p.y + j] == map[p.x][p.y]) {
p.x += i;
p.y += j;
return p;
}
}
void pre() {
int i, j;
Point p, p2;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (!square[i][j] && map[i][j] != '.')
square[i][j] = square[i][j + 1] = square[i + 1][j] =
square[i + 1][j + 1] = ++k;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (!found[i][j] && map[i][j] != '.') {
found[i][j] = true;
p.x = i;
p.y = j;
p2 = find(p);
found[p2.x][p2.y] = true;
pos[++t][0] = p;
pos[t][1] = p2;
}
memset(c, -1, sizeof(c));
}
void dfs(int kk, int num) {
if (kk == k + 1) {
memset(used, false, sizeof(used));
for (int i = 1; i <= t; i++) {
int s1 = square[pos[i][0].x][pos[i][0].y];
int s2 = square[pos[i][1].x][pos[i][1].y];
if (used[c[s1]][c[s2]]) return;
used[c[s1]][c[s2]] = true;
used[c[s2]][c[s1]] = true;
}
if (count == 0)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
saved[i][j] = map[i][j] == '.' ? -1 : c[square[i][j]];
count++;
return;
}
if (c[kk] > -1) {
dfs(kk + 1, num);
return;
}
c[kk] = num;
for (int i = kk + 1; i <= k; i++)
if (c[i] == -1) {
c[i] = num;
dfs(kk + 1, num + 1);
c[i] = -1;
}
c[kk] = -1;
}
int main() {
scanf("%d%d", &n, &m);
int i, j;
for (i = 1; i <= n; i++) {
getchar();
for (j = 1; j <= m; j++) scanf("%c", &map[i][j]);
}
pre();
dfs(1, 0);
printf("%d\n", count * 5040);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
printf("%c", map[i][j] == '.' ? '.' : ('0' + saved[i][j]));
printf("\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
long long l;
long long ex(long long a, long long b, long long c) {
long long res = 0;
long long Max = a + b + c + l;
for (long long i = a; i <= a + l; i++) {
if (b + c > i)
continue;
else {
long long x = min(Max - i, i) - b - c;
res += (x + 2) * (x + 1) / 2;
}
}
return res;
}
int main() {
long long a, b, c, ans;
ifstream fin("t.txt");
while (cin >> a >> b >> c >> l) {
ans = (l + 3) * (l + 2) * (l + 1) / 6;
ans -= ex(a, b, c);
ans -= ex(b, a, c);
ans -= ex(c, b, a);
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vp;
int dp[305][100000];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int fun(int i, int x, int n) {
if (x == 1) return 0;
if (i == n && x != 1) return 100000000;
if (x < 100000 && dp[i][x] > 0)
return dp[i][x];
else {
if (x == 0) {
dp[i][x] =
min(fun(i + 1, x, n), vp[i].second + fun(i + 1, vp[i].first, n));
return dp[i][x];
}
int a = gcd(x, vp[i].first);
if (a == x) {
if (x < 100000)
dp[i][x] = fun(i + 1, x, n);
else
return fun(i + 1, x, n);
return dp[i][x];
}
if (a < x) {
if (x < 100000)
dp[i][x] = min(fun(i + 1, x, n), vp[i].second + fun(i + 1, a, n));
else
return min(fun(i + 1, x, n), vp[i].second + fun(i + 1, a, n));
return dp[i][x];
}
}
}
int main() {
int n, i;
scanf("%d", &n);
vp.resize(n);
for (i = 0; i < n; i++) scanf("%d", &vp[i].first);
for (i = 0; i < n; i++) scanf("%d", &vp[i].second);
sort(vp.begin(), vp.end());
i = fun(0, 0, n);
if (i >= 100000000) i = -1;
cout << i << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], q[100010];
vector<int> v;
int main() {
int n;
scanf("%d", &n);
int i, j, t;
memset(q, 0, sizeof(q));
v.clear();
for (i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
q[0] = 1;
t = 1;
int s = 0;
for (i = 0; i < n - 1; i++) {
if (a[i] == a[n - 1]) s++;
}
for (i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
q[i] = 1;
t++;
}
}
if (t == n - s) {
printf("%d\n", t);
for (i = t - 1; i >= 0; i--) {
if (i != t - 1) printf(" ");
printf("%d", a[i]);
}
printf("\n");
} else {
for (i = 0; i < n; i++) {
if (q[i]) {
v.push_back(i);
}
}
int tt = a[n - 1];
for (i = n - 1; i >= 0; i--) {
if (q[i]) continue;
if (a[i] != tt) {
tt = a[i];
v.push_back(i);
}
}
printf("%d\n", v.size());
for (i = 0; i < v.size(); i++) {
if (i != 0) printf(" ");
printf("%d", a[v[i]]);
}
printf("\n");
}
return 0;
}
| 2 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int const lim=100000000;
typedef long long ll;
ll s;
int a[601][601],i,j,k,n,m,x,y;
int main(){
scanf("%d%d%d%d",&n,&m,&x,&y);
if (x==1&&y==1){
puts("No");return 0;
}
for (i=1,s=0;i<=n;i++)
for (j=1;j<=m;j++){
if (i%x==0&&j%y==0) a[i][j]=-lim;else{
a[i][j]=(lim-1)/(x*y-1);
if (i%x==1&&j%y==1) a[i][j]+=(lim-1)%(x*y-1);
}
s+=a[i][j];
}
if (s>0){
puts("Yes");
for (i=1;i<=n;i++)
for (j=1;j<=m;j++) printf("%d%c",a[i][j],(j==m)?'\n':' ');
}else puts("No");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int N = 201;
double dp[205][205][405];
int n, l, k;
int pro[205];
int bag[205];
int main() {
scanf("%d%d%d", &n, &l, &k);
for (int i = 1; i <= n; i++) scanf("%d", &pro[i]);
for (int i = 1; i <= n; i++) scanf("%d", &bag[i]);
double ans = 0;
memset(dp, 0, sizeof(dp));
dp[0][0][k + N] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
for (int f = 0; f <= 2 * N; f++) {
if (bag[i] == -1) {
if (f > 0) dp[i][j + 1][f - 1] += dp[i - 1][j][f] * 0.01 * pro[i];
} else {
if (f + bag[i] > 2 * N)
dp[i][j + 1][2 * N] += dp[i - 1][j][f] * 0.01 * pro[i];
else
dp[i][j + 1][f + bag[i]] += dp[i - 1][j][f] * 0.01 * pro[i];
}
dp[i][j][f] += dp[i - 1][j][f] * (1 - 0.01 * pro[i]);
}
}
}
for (int i = l; i <= n; i++) {
for (int j = N; j <= 2 * N; j++) ans += dp[n][i][j];
}
printf("%.10f", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1e8 + 7;
struct edge {
int u, v, ind;
long long w;
friend bool operator<(edge e1, edge e2) {
pair<long long, int> t1 = {e1.w, e1.ind};
pair<long long, int> t2 = {e2.w, e2.ind};
return t1 < t2;
}
};
int n, m, k;
vector<edge> vec;
vector<int> ans;
int par[N];
int get(int v) {
if (par[v] == v) {
return v;
}
return get(par[v]);
}
int mst(int k) {
ans.clear();
for (int i = 0; i < n; i++) {
par[i] = i;
}
for (int i = 0; i < m; i++) {
if (!vec[i].u || !vec[i].v) {
vec[i].w += k;
}
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < m; i++) {
if (get(vec[i].u) == get(vec[i].v)) {
continue;
}
par[get(vec[i].u)] = get(vec[i].v);
ans.push_back(vec[i].ind);
if (!vec[i].u || !vec[i].v) {
cnt++;
}
}
for (int i = 0; i < m; i++) {
if (!vec[i].u || !vec[i].v) {
vec[i].w -= k;
}
}
return cnt;
}
void bsearch() {
int r = inf;
int l = -inf;
while (r - l > 1) {
int mid = (l + r) / 2;
int tmp = mst(mid);
if (tmp > k) {
l = mid;
}
if (tmp < k) {
r = mid;
}
if (tmp == k) {
cout << n - 1 << endl;
for (int i = 0; i < n - 1; i++) {
cout << ans[i] << " ";
}
exit(0);
}
}
cout << -1;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
edge tmp;
cin >> tmp.u >> tmp.v >> tmp.w;
tmp.u--;
tmp.v--;
tmp.w *= 2;
tmp.ind = i + 1;
vec.push_back(tmp);
}
bsearch();
}
| 5 |
#include <bits/stdc++.h>
const long long mod = 1000000007;
using namespace std;
int n, m;
vector<vector<int> > graf;
vector<int> dp;
int main() {
long long n;
cin >> n;
long long ans = 0;
while (n) {
ans += (long long)pow(2, n);
n--;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 21;
int n, s, l;
long long a[MAXN], dp[MAXN];
set<pair<long long, int> > st;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> s >> l;
for (int i = 0; i < n; i++) cin >> a[i];
int start = 0;
for (int i = 0; i < n; i++) {
st.insert({a[i], i});
while (st.rbegin()->first - st.begin()->first > s)
st.erase({a[start], start++});
int best = -1;
for (int j = start; i - j + 1 >= l; j++)
if ((!j || dp[j - 1]) && (best < 0 || dp[j] < best)) {
if (j)
best = dp[j - 1];
else
best = 0;
break;
}
dp[i] = best + 1;
}
if (dp[n - 1])
cout << dp[n - 1] << '\n';
else
cout << -1 << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100100];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int s = 0;
for (int i = 1; i <= n - 1; i++) s += a[i];
int t = a[n] - s + 1;
cout << t;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 5e5 + 10;
long long indx[N], num[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == '?')
indx[i] = 1;
else
num[i] = stoi(s);
}
for (int i = 0; i < k; i++) {
long long pre = -2e9;
long long cnt = 0;
int last = i;
for (int j = i; j < n; j += k) {
if (indx[j])
cnt++;
else {
if (num[j] <= pre + cnt) {
puts("Incorrect sequence");
return 0;
}
long long st = max(pre + 1, min(-cnt / 2, num[j] - cnt));
for (int l = cnt; l > 0; l--) num[j - l * k] = st++;
cnt = 0;
pre = num[j];
}
last = j;
}
if (cnt) {
long long st = max(pre + 1, -cnt / 2);
while (last - k >= 0 && indx[last - k] == 1) {
last -= k;
}
for (int j = last; j < n; j += k) num[j] = st++;
}
}
for (int i = 0; i < n; i++) cout << num[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
int ddx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int ddy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
using namespace std;
using namespace std;
string s, v;
pair<int, int> p[200100];
pair<char, char> t[200100];
vector<int> g[200100];
vector<int> gr[200100];
int ord[200100];
int cnt, n, m;
bool used[200100];
int color[200100];
void dfs(int v) {
used[v] = 1;
for (int _n((g[v].size()) - 1), i(0); i <= _n; ++i)
if (!used[g[v][i]]) dfs(g[v][i]);
ord[cnt++] = v;
}
void cmp(int v, int id) {
color[v] = id;
for (int _n((gr[v].size()) - 1), i(0); i <= _n; ++i)
if (color[gr[v][i]] == -1) cmp(gr[v][i], id);
}
bool SAT(string t) {
for (int _n((n)-1), i(0); i <= _n; ++i)
if (t[i] != '#') {
if (v[t[i] - 'a'] == 'C')
g[i].push_back(i + n), gr[i + n].push_back(i);
else
g[i + n].push_back(i), gr[i].push_back(i + n);
}
cnt = 0;
for (int _n((n << 1) - 1), i(0); i <= _n; ++i) used[i] = 0, color[i] = -1;
for (int _n((n << 1) - 1), i(0); i <= _n; ++i)
if (!used[i]) dfs(i);
reverse(ord, ord + cnt);
int id = 0;
for (int _n((n << 1) - 1), i(0); i <= _n; ++i)
if (color[ord[i]] == -1) cmp(ord[i], ++id);
for (int _n((n)-1), i(0); i <= _n; ++i)
if (t[i] != '#') {
if (v[t[i] - 'a'] == 'C')
g[i].pop_back(), gr[i + n].pop_back();
else
g[i + n].pop_back(), gr[i].pop_back();
}
for (int _n((n)-1), i(0); i <= _n; ++i)
if (color[i] == color[i + n]) return 0;
return 1;
}
int main() {
int C, V;
C = V = 0;
cin >> v;
for (int _n((v.size()) - 1), i(0); i <= _n; ++i) (v[i] == 'V' ? V : C)++;
cin >> n >> m;
for (int _n((m)-1), i(0); i <= _n; ++i) {
cin >> p[i].first >> t[i].first;
cin >> p[i].second >> t[i].second;
p[i].first--, p[i].second--;
if (t[i].first == 'C') p[i].first += n;
if (t[i].second == 'C') p[i].second += n;
g[p[i].first].push_back(p[i].second);
gr[p[i].second].push_back(p[i].first);
if (p[i].first < n)
p[i].first += n;
else
p[i].first -= n;
if (p[i].second < n)
p[i].second += n;
else
p[i].second -= n;
g[p[i].second].push_back(p[i].first);
gr[p[i].first].push_back(p[i].second);
}
cin >> s;
if (SAT(s)) {
cout << s << endl;
return 0;
} else if (!C || !V) {
cout << -1 << endl;
return 0;
}
for (int i = (n - 1), _b = (0); i >= _b; --i) {
pair<int, int> f = {0, 0};
for (int _n(v.size() - 1), j(s[i] + 1 - 'a'); j <= _n; ++j) {
if (v[j] == 'C') {
if (f.first) continue;
f.first++;
} else {
if (f.second) continue;
f.second++;
}
string solve = s;
solve[i] = 'a' + j;
for (int _n(n - 1), k(i + 1); k <= _n; ++k) solve[k] = '#';
if (SAT(solve)) {
for (int _n(n - 1), k(i + 1); k <= _n; ++k) {
pair<int, int> g = {0, 0};
for (int _n((v.size()) - 1), l(0); l <= _n; ++l) {
if (v[l] == 'C') {
if (g.first) continue;
g.first++;
} else {
if (g.second) continue;
g.second++;
}
solve[k] = 'a' + l;
if (SAT(solve)) break;
}
}
cout << solve << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
}
| 3 |
#include <iostream>
#include <string>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <stack>
#include <iomanip>
using namespace std;
#define REP(i, n) for(ll i = 0;i < n;i++)
#define REPR(i, n) for(ll i = n;i >= 0;i--)
#define FOR(i, m, n) for(ll i = m;i < n;i++)
#define FORR(i, m, n) for(ll i = m;i >= n;i--)
#define REPO(i, n) for(ll i = 1;i <= n;i++)
#define ll long long
#define INF (ll)1 << 60
#define MINF (-1 * INF)
#define ALL(n) n.begin(),n.end()
#define MOD 1000000007
#define P pair<ll, ll>
int main() {
ll n, m, a = 0, b = 0;
cin >> n >> m;
REP(i, n) {
ll aa;
cin >> aa;
a += aa;
}
REP(i, m) {
ll aa;
cin >> aa;
b += aa;
}
cout << a * b << endl;
}
| 0 |
#include <cstdio>
#include <algorithm>
using namespace std;
int n, m;
char cv[256], ch, ch2;
int main(){
while(scanf("%d\n", &n), n != 0) {
fill(cv, cv + 256, 0);
for (int i = 0; i < n; i++) {
scanf("%c %c\n", &ch, &ch2);
cv[ch] = ch2;
}
scanf("%d\n", &m);
for (int i = 0; i < m; i++) {
scanf("%c\n", &ch);
printf("%c", cv[ch] == 0 ? ch : cv[ch]);
}
printf("\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e5;
long long n, arr[N + 2], sum;
long long bigmod(long long b, long long p, long long mod) {
long long ret = 1LL;
while (p) {
if (p & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
p /= 2;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
long long up = 2, dw = 1;
int f = 0;
for (int i = 1; i <= n; i++) {
if (arr[i] % 2 == 0) f = 1;
up = bigmod(up, arr[i], mod) % mod;
}
up = (up * bigmod(2, mod - 2, mod)) % mod;
dw = up;
if (f)
up = (up + 1) % mod;
else
up = (up - 1 + mod) % mod;
up = (up * bigmod(3, mod - 2, mod)) % mod;
cout << up << "/" << dw << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long L, R, K;
void solve() {
int f, i, j, k, l, x, y;
cin >> L >> R >> K;
if (K == 1) return (void)printf("%lld\n1\n%lld\n", L, L);
if (R - L == 1) {
if ((L ^ R) < L)
return (void)printf("%lld\n2\n%lld %lld\n", L ^ R, L, L + 1);
return (void)printf("%lld\n1\n%lld\n", L, L);
}
if (R - L <= 10) {
int mask;
for (mask = 0; mask < 1 << (R - L + 1); mask++)
if (mask) {
signed long long tot = 0;
for (i = 0; i < R - L + 1; i++)
if (mask & (1 << i)) tot ^= L + i;
if (tot == 0 && __builtin_popcount(mask) <= K) {
(void)printf("0\n%d\n", __builtin_popcount(mask));
for (i = 0; i < R - L + 1; i++)
if (mask & (1 << i)) (void)printf("%lld ", L + i);
return;
}
}
}
if (K >= 3) {
int lb = 0;
while (1LL << (lb + 1) <= L) lb++;
signed long long aa = (1LL << (1 + lb)) + (L - (1LL << lb));
signed long long bb = (1LL << (1 + lb)) + (1LL << lb);
if (bb <= R)
return (void)printf("%lld\n3\n%lld %lld %lld\n", 0LL, L, aa, bb);
}
L = (L + 1) / 2 * 2;
if (L + 3 < R && K >= 4)
return (void)printf("0\n4\n%lld %lld %lld %lld\n", L, L + 1, L + 2, L + 3);
(void)printf("1\n2\n%lld %lld\n", L, L + 1);
}
int main(int argc, char** argv) {
string s;
if (argc == 1) ios::sync_with_stdio(false);
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a1[100005] = {0};
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a1[a] += c;
a1[b] -= c;
}
int sum = 0;
for (int i = 0; i < 100005; i++) {
if (a1[i] > 0) sum += a1[i];
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long double dis(double x, double y, double x1, double y1) {
return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
}
double PI = 3.14159265359;
double e = 2.718281828;
void EnGz() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
long long GCD_(long long a, long long b) { return b ? GCD_(b, a % b) : a; }
long long LCM_(long long a, long long b) { return (a * b) / GCD_(a, b); }
int done[1005][1005];
int win[1005];
int main() {
EnGz();
int n, k;
scanf("%d%d", &n, &k);
int c = 0;
for (int i = 1; i <= n - 1; i++)
for (int j = i + 1; j <= n; j++) {
if (done[i][j] || done[j][i]) continue;
if (win[i] == k && win[j] < k) {
win[j]++;
done[i][j] = -1;
done[j][i] = 1;
c++;
} else if (win[i] < k) {
done[i][j] = 1;
done[j][i] = -1;
win[i]++;
c++;
}
}
for (int i = 1; i <= n; i++)
if (win[i] != k) return !printf("-1\n");
printf("%d\n", c);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (done[i][j] == 1) {
printf("%d %d\n", i, j);
done[i][j] = -1;
} else if (done[j][i] == 1) {
printf("%d %d\n", j, i);
done[j][i] = -1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace FGF {
int n, m;
const int N = 2e5 + 5;
vector<int> g[N];
queue<int> q;
int a[N], cnt[N];
bool vis[N];
void work() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
int ans = 0;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v), g[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (g[i].size() == 1) q.push(i);
while (q.size()) {
int u = q.front();
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int sz = g[u].size(), i = 0; i < sz; i++) {
int v = g[u][i];
if (vis[v]) continue;
cnt[v]++;
if (cnt[v] + 1 == g[v].size() && cnt[v] % m == 0) q.push(v);
}
}
for (int i = 1; i <= n; i++) ans += cnt[i] / m;
for (int i = 1; i <= n; i++) g[i].clear(), cnt[i] = 0, vis[i] = 0;
printf("%d\n", min(n - 1, ans));
}
}
} // namespace FGF
int main() {
FGF::work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using llint = long long;
const int N = 510, B = 1e9 + 7;
int n, m, q;
int e[N][2 * N];
int x[N];
int ps[N];
char s[N][N];
char bs[N];
int inv[] = {0, 1, 3, 2, 4};
int pw[N] = {1};
int rk;
llint mypw(int a, int b, int m) {
llint ret = 1;
while (b) {
if (b & 1) ret = ret * a % m;
a = a * a % m;
b >>= 1;
}
return ret;
}
int solve(int n, int m, int ms) {
int r = 0;
for (int c = 0, i, j, k; c < m && r < n; ++c) {
for (i = k = r; i < n; ++i) {
if (e[i][c] > e[k][c]) k = i;
if (k != r)
for (j = c; j < ms; ++j) swap(e[k][j], e[r][j]);
if (e[r][c] == 0) continue;
for (i = r + 1; i < n; ++i) {
int t = (50 - e[i][c] * inv[e[r][c]] % 5) % 5;
for (int j = c; j < ms; ++j) e[i][j] = (e[i][j] + t * e[r][j] % 5) % 5;
}
++r;
}
}
return r;
}
bool check(int x) {
for (int j = rk; j < m; ++j) {
if (e[j][x + n] != 0) return 0;
}
return 1;
}
void init() {
for (int i = 1; i < N; ++i) pw[i] = pw[i - 1] * 5ll % B;
}
int main() {
init();
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
e[j][i] = s[i][j] - 'a';
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%s", bs);
for (int j = 0; j < m; ++j) {
e[j][i + n] = bs[j] - 'a';
}
}
rk = solve(m, n, n + q);
for (int i = 0; i < q; ++i) {
if (check(i)) {
printf("%d\n", pw[n - rk]);
} else {
puts("0");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> h[100002], r[100002];
int c, nr;
int check(long long int l) {
int i;
long long int lx = INT_MAX, rx = INT_MIN, ly = INT_MAX, ry = INT_MIN;
for (i = 0; i < c; i++) {
lx = min(lx, h[i].first + l);
rx = max(rx, h[i].first - l);
ly = min(ly, h[i].second + l);
ry = max(ry, h[i].second - l);
}
for (i = 0; i < nr; i++) {
if (r[i].first <= lx && r[i].first >= rx && r[i].second <= ly &&
r[i].second >= ry)
return i + 1;
}
return 0;
}
int main() {
int n, m, i, j;
scanf("%d%d", &n, &m);
;
scanf("%d", &c);
;
for (i = 0; i < c; i++) {
int x, y;
scanf("%d%d", &x, &y);
;
h[i].first = x + y;
h[i].second = x - y;
}
scanf("%d", &nr);
;
for (i = 0; i < nr; i++) {
int x, y;
scanf("%d%d", &x, &y);
;
r[i].first = x + y;
r[i].second = x - y;
}
long long int low = 0, high = 2e9, ans = -1;
while (low <= high) {
long long int mid = (low + high) / 2;
ans = check(mid);
if (ans > 0)
high = mid - 1;
else
low = mid + 1;
}
cout << high + 1 << endl << check(high + 1) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200001;
const int maxk = 51;
double DP[maxn][maxk];
double val[maxn], B[maxn], sum[maxn], recip[maxn];
int N, K;
double costo(int i, int j) {
return B[j] - B[i - 1] - sum[i - 1] * (recip[j] - recip[i - 1]);
}
void doDP(int ini, int fin, int iniq, int finq, int k) {
if (ini > fin) return;
int M = (ini + fin) / 2;
int q, qt;
q = max(iniq, k);
DP[M][k] = DP[q - 1][k - 1] + costo(q, M);
qt = q;
for (q = max(iniq, k) + 1; q <= min(finq, M); q++) {
if (DP[M][k] > DP[q - 1][k - 1] + costo(q, M)) {
DP[M][k] = DP[q - 1][k - 1] + costo(q, M);
qt = q;
}
}
doDP(ini, M - 1, iniq, qt, k);
doDP(M + 1, fin, qt, finq, k);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> K;
int i, j, k;
for (i = 1; i <= N; i++) cin >> val[i];
for (i = 1; i <= N; i++) {
sum[i] = sum[i - 1] + val[i];
B[i] = sum[i] / ((double)val[i]);
B[i] += B[i - 1];
recip[i] = recip[i - 1] + 1.0 / ((double)val[i]);
}
for (i = 1; i <= N; i++) DP[i][1] = costo(1, i);
for (j = 2; j <= K; j++) doDP(1, N, 1, N, j);
cout << fixed << setprecision(6) << DP[N][K];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, r;
vector<int> G[500000];
int rest_stop[500000], cor[500000];
int dist[500000], pai[500000], sz[500000];
int anc[500000][25], MAX_LOG, nivel[500000];
void dfs(int v, int p, int d) {
nivel[v] = d;
anc[v][0] = p;
if (d) MAX_LOG = max(MAX_LOG, (int)log2((double)d) + 1);
for (int &u : G[v])
if (u != p) dfs(u, v, d + 1);
}
void build() {
for (int j = 0; j < 23; j++)
for (int i = 0; i < 2 * n; i++) anc[i][j] = -1;
dfs(0, -1, 0);
for (int j = 1; j <= MAX_LOG; j++)
for (int i = 0; i < 2 * n; i++)
if (anc[i][j - 1] != -1) anc[i][j] = anc[anc[i][j - 1]][j - 1];
}
int walk(int v, int x) {
while (x) {
assert(v >= 0);
v = anc[v][(int)log2(x & -x)], x -= x & -x;
}
return v;
}
int lca(int u, int v) {
if (nivel[u] > nivel[v]) u = walk(u, nivel[u] - nivel[v]);
if (nivel[u] < nivel[v]) v = walk(v, nivel[v] - nivel[u]);
if (u == v) return u;
for (int i = MAX_LOG; i >= 0; i--)
if (anc[u][i] != anc[v][i]) {
u = anc[u][i];
v = anc[v][i];
}
return anc[u][0];
}
int dist_in_tree(int u, int v) {
return nivel[u] + nivel[v] - 2 * nivel[lca(u, v)];
}
int find(int x) {
if (pai[x] == x) return x;
return pai[x] = find(pai[x]);
}
void join(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
pai[x] = y;
sz[y] += sz[x];
}
void bfs() {
queue<int> q;
for (int i = 0; i < 2 * n; i++) {
dist[i] = -1;
pai[i] = i;
sz[i] = 1;
if (rest_stop[i]) {
q.push(i);
dist[i] = 0;
cor[i] = i + 1;
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
if (dist[u] >= k) continue;
for (int &w : G[u]) {
if (dist[w] == -1) {
dist[w] = dist[u] + 1;
cor[w] = cor[u];
q.push(w);
} else
join(cor[w], cor[u]);
}
}
}
int walk_to(int u, int v, int x) {
int l = lca(u, v);
if (x <= nivel[u] - nivel[l]) return walk(u, x);
int d = x - (nivel[u] - nivel[l]);
return walk(v, nivel[v] - nivel[l] - d);
}
int32_t main() {
scanf(" %d %d %d", &n, &k, &r);
for (int i = 1; i < n; i++) {
int u, v;
scanf(" %d %d", &u, &v);
u--;
v--;
G[u].push_back(n + i - 1);
G[n + i - 1].push_back(v);
G[v].push_back(n + i - 1);
G[n + i - 1].push_back(u);
}
for (int i = 0; i < r; i++) {
int x;
scanf(" %d", &x);
rest_stop[x - 1] = 1;
}
build();
bfs();
int q;
cin >> q;
while (q--) {
int u, v;
scanf(" %d %d", &u, &v);
u--;
v--;
bool fl = false;
if (dist_in_tree(u, v) <= 2 * k)
fl = true;
else {
int c1 = cor[walk_to(u, v, k)];
int c2 = cor[walk_to(v, u, k)];
if (c1 and c2 and find(c1) == find(c2)) fl = true;
}
puts(fl ? "YES" : "NO");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int cnt[100100], tcnt[100100];
int u[100100], v[100100];
int* g[100100];
int a[100100];
int niz[100100];
int rez[100100];
int q[1000100];
int main() {
int i, j, x, y, n, m;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d %d", u + i, v + i);
cnt[u[i]]++;
cnt[v[i]]++;
}
for (i = 1; i <= n; i++)
g[i] = (int*)malloc(sizeof(int) * (cnt[i] + 1)), tcnt[i] = cnt[i];
for (i = 1; i <= m; i++) {
x = u[i];
y = v[i];
g[x][tcnt[x]--] = y;
g[y][tcnt[y]--] = x;
}
int p = 1, k = 1;
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
if (!a[i]) q[k++] = i;
}
int sol = 0;
while (p != k) {
x = q[p];
if (a[x] != niz[x]) {
p++;
continue;
}
rez[++sol] = x;
niz[x]++;
for (i = 1; i <= cnt[x]; i++) {
j = g[x][i];
niz[j]++;
if (niz[j] == a[j]) q[k++] = j;
}
p++;
}
printf("%d\n", sol);
if (sol) {
for (i = 1; i < sol; i++) printf("%d ", rez[i]);
printf("%d\n", rez[sol]);
}
for (i = 1; i <= n; i++) free(g[i]);
return 0;
}
| 4 |
#include <iostream>
#include <tuple>
#include <vector>
#include <queue>
using namespace std;
typedef long long ll;
typedef tuple<ll, ll> ii;
typedef vector<bool> vb;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
typedef priority_queue<ii, vii, greater<ii>> pq;
ll n, m, s, t, u, v, a, b;
void bfs(vvii &g, vi& c, int s) {
vb v(n);
pq q;
q.push(make_tuple(0, s));
while (!q.empty()) {
ll k, i;
tie(k, i) = q.top();
q.pop();
if (v[i]) continue;
v[i] = true;
c[i] = k;
for (auto &z:g[i]) {
ll k2, i2;
tie(k2, i2) = z;
if (v[i2]) continue;
q.push(make_tuple(k + k2, i2));
}
}
}
int main() {
cin >> n >> m >> s >> t;
s--; t--;
vvii ga(n), gb(n);
for (int i = 0; i < m; i++) {
cin >> u >> v >> a >> b;
u--; v--;
ga[u].push_back(make_tuple(a, v));
ga[v].push_back(make_tuple(a, u));
gb[u].push_back(make_tuple(b, v));
gb[v].push_back(make_tuple(b, u));
}
vi ca(n), cb(n), c(n);
bfs(ga, ca, s);
bfs(gb, cb, t);
c[n - 1] = ca[n - 1] + cb[n - 1];
for (int i = n - 2; i >= 0; i--) c[i] = min(c[i + 1], ca[i] + cb[i]);
for (int i = 0; i < n; i++) cout << 1000000000000000LL - c[i] << endl;
}
| 0 |
#include <iostream>
#include <vector>
using namespace std;
int dp[1001];
int main() {
int D, G;
cin>>D>>G;
vector<int> p(D),c(D);
int p_sum=0;
for (int i=0;i<D;++i) {
cin>>p[i]>>c[i];
p_sum += p[i];
}
for (int i=1;i<=D;++i) {
for (int j=p_sum;j>=0;--j) {
for (int k=0;k<=p[i-1]&&k<=j;++k) {
int pts = (k==p[i-1])?(100*i*k+c[i-1]):100*i*k;
dp[j] = max(dp[j], dp[j-k]+pts);
}
}
}
int ans=0;
while(dp[ans]<G)ans++;
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_A = 1e7 + 5;
const int MAX_N = 1e6 + 5;
long long gcd(long long p, long long q) {
if (q == 0) return p;
return gcd(q, p % q);
}
long long sq(long long x) { return x * x; }
bool is_perfect(long long x) {
long long sqx = sqrt(x);
if (sqx * sqx == x) return true;
if ((sqx - 1) * (sqx - 1) == x) return true;
if ((sqx + 1) * (sqx + 1) == x) return true;
return false;
}
int arr[MAX_N];
int pos[MAX_A];
int root[MAX_N];
int height[MAX_N];
int find(int u) {
if (root[u] != u) {
root[u] = find(root[u]);
}
return root[u];
}
void merge(int u, int v) {
u = find(u);
v = find(v);
if (u != v) {
if (height[u] < height[v]) {
swap(u, v);
}
root[v] = u;
if (height[u] == height[v]) {
height[u]++;
}
}
}
int main() {
for (int i = 1; i < MAX_N; i++) {
root[i] = i;
}
ios::sync_with_stdio(false);
int length;
cin >> length;
for (int i = 1; i <= length; i++) {
cin >> arr[i];
pos[arr[i]] = i;
}
for (int m = 2; m * m < 3 * MAX_A; m++) {
for (int n = 1; n < m; n++) {
if (m % 2 == 0 || n % 2 == 0) {
if (gcd(m, n) == 1) {
int a = sq(m) - sq(n);
int b = 2 * m * n;
int c = sq(m) + sq(n);
if (a < MAX_A && b < MAX_A) {
if (pos[a] && pos[b]) {
merge(pos[a], pos[b]);
}
}
if (a < MAX_A && c < MAX_A) {
if (pos[a] && pos[c]) {
merge(pos[a], pos[c]);
}
}
if (b < MAX_A && c < MAX_A) {
if (pos[b] && pos[c]) {
merge(pos[b], pos[c]);
}
}
}
}
}
}
int ans = 0;
for (int i = 1; i <= length; i++) {
if (find(i) == i) {
ans++;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace star {
const int maxn = 1e6 + 10, mod = 998244353;
char s[maxn];
int n, l[maxn], r[maxn], w[maxn], inv[maxn], mul[maxn];
inline int fpow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
inline int C(int n, int m) {
return n < 0 or m < 0 or n < m
? 0
: 1ll * mul[n] * inv[m] % mod * inv[n - m] % mod;
}
inline void work() {
scanf("%s", s + 1), n = strlen(s + 1);
for (int i = 1; i <= n; i++)
l[i] = l[i - 1] + (s[i] == '('), w[i] = w[i - 1] + (s[i] == '?');
for (int i = n; i; i--) r[i] = r[i + 1] + (s[i] == ')');
mul[0] = inv[0] = 1;
for (int i = 1; i <= n; i++) mul[i] = 1ll * mul[i - 1] * i % mod;
inv[n] = fpow(mul[n], mod - 2);
for (int i = n - 1; i; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
int ans = 0;
for (int i = 1; i < n; i++) {
int s1 = l[i], s2 = w[i], s3 = r[i + 1], s4 = w[n] - w[i];
ans = (ans + 1ll * s1 * C(s2 + s4, s3 + s4 - s1) +
1ll * s2 * C(s2 + s4 - 1, s3 + s4 - s1 - 1)) %
mod;
}
printf("%d\n", ans);
}
} // namespace star
signed main() {
star::work();
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.