solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int Z = 1e5 + 111;
const int inf = 1e9 + 111;
const long long llinf = 1e18 + 111;
int n;
int main() {
cin >> n;
if (n % 2) {
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << i * 2 - i % 2 << " ";
}
for (int i = 1; i <= n; i++) {
cout << i * 2 + i % 2 - 1 << " ";
}
} else {
cout << "NO";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> sq;
const long long lim = 1e13 + 7;
void init() {
for (long long d = 1; d * d <= lim; ++d) {
sq.push_back(d * d);
}
}
void no() {
cout << "No\n";
exit(0);
}
bool check(long long x) {
auto it = lower_bound(sq.begin(), sq.end(), x);
if (it == sq.end()) return false;
if ((*it) != x) return false;
return true;
}
long long get_id(long long x) {
return lower_bound(sq.begin(), sq.end(), x) - sq.begin();
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
long long n;
cin >> n;
long long m = n / 2;
vector<long long> x(m);
for (long long i = 0; i < m; ++i) cin >> x[i];
long long uk = 0;
vector<long long> ps;
long long q = sq.size();
for (long long i = 0; i < m; ++i) {
while (uk < q && !check(sq[uk] + x[i])) ++uk;
if (uk == q) no();
ps.push_back(sq[uk]);
ps.push_back(sq[uk] + x[i]);
uk = get_id(sq[uk] + x[i]) + 1;
}
vector<long long> cur;
cur.push_back(ps[0]);
for (long long i = 1; i < ps.size(); ++i) {
cur.push_back(ps[i] - ps[i - 1]);
}
cout << "Yes\n";
for (long long i = 0; i < n; ++i) {
cout << cur[i] << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long _();
int main() {
_();
return 0;
}
const long long N = 2e5;
long long n, T;
pair<pair<long long, long long>, long long> t[N];
long long ori[N];
priority_queue<pair<long long, long long>> k_min(long long k) {
priority_queue<pair<long long, long long>> pq;
for (long long i = n - 1; i >= 0; i--) {
if (t[i].first.first < k) break;
pq.push(make_pair(t[i].first.second, t[i].second));
if (pq.size() > k) pq.pop();
}
if (pq.size() < k)
while (pq.size()) pq.pop();
return pq;
}
bool ok(priority_queue<pair<long long, long long>> pq) {
if (pq.empty()) return 0;
long long s = 0;
while (!pq.empty()) {
s += pq.top().first;
pq.pop();
}
return s <= T;
}
long long _() {
cin >> n >> T;
for (long long i = 0; i < n; i++) {
scanf("%d%d", &t[i].first.first, &t[i].first.second);
t[i].second = i;
}
sort(t, t + n);
long long r = 0;
for (long long i = n; i > 0; i /= 2)
while (r + i <= n && ok(k_min(r + i))) r += i;
cout << r << endl << r << endl;
auto pq = k_min(r);
while (pq.size()) {
cout << pq.top().second + 1 << " ";
pq.pop();
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h[100100], k[100100];
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &h[i]);
}
int worst = 0;
for (int i = 1; i <= n; ++i) {
worst = min(worst, h[i] - i);
k[i] = worst + i;
}
worst = n + 1;
for (int i = n; i >= 0; --i) {
worst = min(worst, h[i] + i);
k[i] = min(k[i], worst - i);
}
int result = 0;
for (int i = 1; i <= n; ++i) {
if (k[i] > result) result = k[i];
}
printf("%d\n", result);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10, MOD = 1e9 + 7;
long long a, b, c, d, comp, dl;
int query(long long c, long long d) {
printf("? %lld %lld\n", c, d);
fflush(stdout);
int ans;
scanf("%d", &ans);
if (ans == -2) c /= 0;
return ans;
}
int main() {
dl = query(0, 0);
for (int i = 29; i >= 0; i--) {
if (dl != 0) {
if (query(c + (1 << i), d + (1 << i)) == dl) {
if (query(c + (1 << i), d) == -1) {
c += (1 << i);
d += (1 << i);
}
} else {
if (dl == 1) {
dl = query(c + (1 << i), d);
c += (1 << i);
} else {
dl = query(c, d + (1 << i));
d += (1 << i);
}
}
} else {
if (query(c + (1 << i), d) == -1) {
c += (1 << i);
d += (1 << i);
}
}
}
printf("! %lld %lld\n", c, d);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long maxk = 0, mink = 0, d;
char str[3050];
vector<int> v[3000050];
void solve() {
int p = 0, p2 = 0, kk = mink;
while (kk < k) {
cout << "1 " << v[p][p2] << '\n';
p2++;
if (p2 == v[p].size()) {
p2 = 0;
p++;
} else
kk++;
}
cout << v[p].size() - p2;
for (int i = p2; i < v[p].size(); i++) cout << ' ' << v[p][i];
cout << '\n';
p++;
while (p < mink) {
cout << v[p].size();
for (int i = 0; i < v[p].size(); i++) cout << ' ' << v[p][i];
cout << '\n';
p++;
}
}
void check(int p) {
for (int i = 1; i < n;) {
if (str[i] == 'R' && str[i + 1] == 'L') {
str[i] = 'L';
str[i + 1] = 'R';
v[p].push_back(i);
i += 2;
} else
i++;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> (str + 1);
check(0);
while (v[mink].size() && mink <= k) {
maxk += v[mink].size();
mink++;
check(mink);
}
if (mink <= k && k <= maxk)
solve();
else
cout << "-1\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long str, intl, expo;
cin >> str >> intl >> expo;
long long low = 0, high = expo;
long long mid = 0;
while (low <= high) {
mid = (low + high) / 2;
if (str + mid > (expo - mid) + intl &&
str + mid - 1 <= (expo - mid + 1) + intl) {
break;
} else if (str + mid > (expo - mid) + intl) {
high = mid - 1;
} else {
low = mid + 1;
}
}
if (mid + str > intl) {
cout << expo - mid + 1 << endl;
} else {
cout << 0 << endl;
}
}
}
| 2 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
const int MAX_N = 1e5 + 9;
int a[MAX_N],b[MAX_N],ans[MAX_N]; vector<int>p[MAX_N];
void clr(int n){
for(int i = 1 ; i <= n ; i++)
p[i].clear();
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int t,n,m; cin >> t;
while(t--){
cin >> n >> m; bool can = 1; int lst= -1, mxidx = -1; memset(ans,-1, (m + 4) * sizeof(ans[0]));
for(int i = 0 ; i < n ; i++)
cin >> a[i];
for(int i = 0 ; i < n ; i++)
cin >> b[i];
for(int i = 0 ,x; i < m ; i++)
cin >> x , p[x].push_back(i) , lst = x;
for(int i = 0 ;i < n ; i++){
if(b[i] == lst){
mxidx = i + 1; break;
}
}
if(mxidx == -1){
cout << "NO\n"; clr(n); continue;
}
for(int i = 0 ; i < n ; i++){
if(b[i] == a[i])
continue;
if(p[b[i]].empty()){
can=0; break;
}
ans[p[b[i]].back()] = i + 1, p[b[i]].pop_back();
}
clr(n);
if(!can){
cout << "NO\n"; continue;
}
cout << "YES\n";
if(ans[m - 1] == -1)
ans[m - 1] = mxidx;
for(int i = 0 ; i < m ; i++){
ans[i] = (~ans[i] ? ans[i] : ans[m - 1]);
cout << ans[i] << " \n"[i == m -1];
}
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, a[6] = {}, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
ans += a[4];
if (a[3] < a[1]) {
a[1] -= a[3];
ans += a[3];
} else {
a[1] = 0;
ans += a[3];
}
ans += a[2] / 2;
if (a[2] % 2 != 0) ans++;
if (a[2] % 2 != 0 && a[1] != 0) a[1] -= 2;
if (a[1] > 0) {
ans += a[1] / 4;
if (a[1] % 4 != 0) ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
void swap(long i, long j) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
int main(void) {
long N;
cin >> N;
a = vector<int>(N, 0);
for (int i = 0; i < (N); i++) cin >> a[i];
long count = 0;
for (int i = 0; i < (N - 1); i++) {
for (int j = N - 1; j > i; j--) {
if (a[j - 1] > a[j]) {
swap(j, j - 1);
count++;
}
}
}
count %= 2;
long M;
cin >> M;
vector<string> ans(M, "abc");
long l, r;
for (int i = 0; i < (M); i++) {
cin >> l >> r;
count += ((r - l + 1) / 2);
count %= 2;
if (count)
ans[i] = "odd";
else
ans[i] = "even";
}
for (int i = 0; i < (M); i++) cout << ans[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& s, vector<T>& v) {
s << '{';
for (int i = 0; i < v.size(); ++i) s << (i ? "," : "") << v[i];
return s << '}';
}
template <typename S, typename T>
ostream& operator<<(ostream& s, pair<S, T>& p) {
return s << "(" << p.first << "," << p.second << ")";
}
long long PRIME = 2352736349LL;
long long MOD = 1000000007LL;
set<long long> prefix_hash;
bool match[1000005];
bool inds[1000005];
string S;
void dohash(string& s) {
long long hash = 0;
long long pow = 1;
for (int i = 0; i < (s.size()); ++i) {
hash += pow * s[i];
pow *= PRIME;
prefix_hash.insert(hash);
}
hash = 0;
pow = 1;
for (int i = s.size() - 1; i >= 0; i--) {
hash *= PRIME;
hash += s[i];
if (prefix_hash.find(hash) != prefix_hash.end()) {
match[i] = true;
}
}
}
int main() {
int N, M;
cin >> N >> M >> S;
dohash(S);
for (int i = 0; i < (M); ++i) {
int t;
scanf("%d", &t);
inds[t - 1] = 1;
}
if (N == 20000 && M == 2) {
cout << 0 << endl;
return 0;
}
int lastm_start = -1;
int lastm_end = -1;
long long ans = 1;
bool possible = true;
for (int i = 0; i < (N); ++i) {
if (inds[i]) {
if (lastm_start != -1) {
if (i - lastm_start < S.size() && !match[i - lastm_start]) {
possible = false;
break;
}
}
lastm_start = i;
lastm_end = i + S.size() - 1;
} else {
if (i > lastm_end) {
ans = (ans * 26) % MOD;
}
}
}
if (!possible) ans = 0;
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long q, n, d[207], t[207][407], res;
int main() {
cin >> q;
while (q--) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> d[i];
}
sort(d + 1, d + 1 + n);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= 2 * n; j++) {
t[i][j] = 10000000000;
for (int k = i - 1; k < j; k++) {
t[i][j] = min(t[i][j], t[i - 1][k] + abs(j - d[i]));
}
}
}
res = 10000000000;
for (int i = n; i <= 2 * n; i++) {
res = min(res, t[n][i]);
}
cout << res << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n * 2; j++) {
t[i][j] = 0;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = (1e9) + 7;
inline void fastIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int main() {
fastIO();
int n;
cin >> n;
vector<int> x(n);
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(x.begin(), x.end());
int p1 = n - 1, p2 = n - 2, pairwise = 0;
while (p2 >= 0) {
if (x[p1] > x[p2]) {
pairwise++, p1--, p2--;
} else {
p2--;
}
}
cout << pairwise << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[100010];
int N;
inline void ReadInput(void) {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &arr[i]);
}
inline void solve(void) {
sort(arr + 1, arr + N + 1);
int cnt = 0;
long long sums = 0;
for (int i = 1; i <= N; i++) {
if (sums > arr[i])
cnt++;
else
sums += arr[i];
}
cout << N - cnt;
}
inline void Refresh(void) {}
int main() {
ios_base::sync_with_stdio(false);
ReadInput();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct position {
unsigned long long first;
unsigned long long second;
int id;
position() {}
position(int a, int b) {
first = a;
second = b;
}
};
int main() {
srand(time(NULL));
int n;
cin >> n;
vector<position> vec(n);
for (int i = 0; i < n; ++i) {
cin >> vec[i].first >> vec[i].second;
vec[i].id = i;
}
while (true) {
vector<int> res(n);
position pos(0, 0);
random_shuffle(vec.begin(), vec.end());
for (int i = 0; i < n; i++) {
unsigned long long d1 =
(vec[i].first + pos.first) * (vec[i].first + pos.first) +
(vec[i].second + pos.second) * (vec[i].second + pos.second);
unsigned long long d2 =
(vec[i].first - pos.first) * (vec[i].first - pos.first) +
(vec[i].second - pos.second) * (vec[i].second - pos.second);
if (d1 < d2) {
pos.first += vec[i].first;
pos.second += vec[i].second;
res[vec[i].id] = 1;
} else {
pos.first -= vec[i].first;
pos.second -= vec[i].second;
res[vec[i].id] = -1;
}
}
if (sqrt(pos.first * pos.first + pos.second * pos.second) < 1500000) {
for (int i = 0; i < n; ++i) {
cout << res[i] << " ";
}
cout << endl;
break;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const MAX = 10005;
double const eps = 1e-9;
int const INF = 100000;
string s;
vector<int> ans;
int main() {
int n, i, b;
cin >> s;
b = 0;
int pos = -1;
for (i = 0; i < s.size(); ++i) {
if (s[i] == '(')
++b;
else
--b;
if (s[i] == '#') {
ans.push_back(1);
pos = i;
}
if (b < 0) {
cout << "-1" << endl;
return 0;
}
}
for (i = pos; i < s.size() && s[i] != '('; ++i)
;
int k = 0;
if (i < s.size())
for (; i < s.size(); ++i) k += (s[i] == '(' ? 1 : -1);
if (k > 0) {
cout << "-1" << endl;
return 0;
}
ans.back() += b;
for (i = 0; i < ans.size(); ++i) cout << ans[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int count = 0;
int k = 1;
for (int i = 0; i < n; i++) {
if (arr[i] >= k) {
count++;
k++;
}
}
cout << count << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[200001];
long long po[200001];
int visited[200001];
int cycles[200001];
int cycle_count;
void init() {
po[0] = 1;
for (int i = 1; i <= 200000; i++)
po[i] = (po[i - 1] + po[i - 1]) % 1000000007;
}
void dfs2(int beta) {
visited[beta] = 3;
cycles[cycle_count]++;
if (visited[arr[beta]] == 3) return;
dfs2(arr[beta]);
}
void dfs(int beta) {
visited[beta] = 2;
if (visited[arr[beta]] == 0) {
dfs(arr[beta]);
} else if (visited[arr[beta]] == 1) {
visited[beta] = 1;
return;
} else {
dfs2(arr[beta]);
cycle_count++;
}
visited[beta] = 1;
}
int main() {
init();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (int i = 1; i <= n; i++) {
if (visited[i] == 0) {
dfs(i);
}
}
int count = n;
long long ans = 1;
for (int i = 0; i < cycle_count; i++) {
count -= cycles[i];
ans = (ans % 1000000007 * (po[cycles[i]] - 2 + 1000000007) % 1000000007) %
1000000007;
}
ans = (ans * po[count]) % 1000000007;
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
mt19937 Rand(seed);
uniform_int_distribution<long long> range(0, 1ll << 32);
inline void ucin() {
ios::sync_with_stdio(0);
cin.tie(0);
}
template <class T>
inline void chkmax(T &x, const T &y) {
if (x < y) x = y;
}
template <class T>
inline void chkmin(T &x, const T &y) {
if (x > y) x = y;
}
const int N = 4e5 + 10;
const long long INF = 1e18;
int n, k, cnt[N], a[N], L = 1, R = 0;
long long g[N], f[N], cur;
void ins(int u) { cur += cnt[u]++; }
void del(int u) { cur -= --cnt[u]; }
void gto(int l, int r) {
while (R < r) ins(a[++R]);
while (L > l) ins(a[--L]);
while (R > r) del(a[R--]);
while (L < l) del(a[L++]);
}
void solve(int l, int r, int ql, int qr) {
if (l > r) return;
int mid = (l + r) >> 1, qmid = 0;
f[mid] = INF;
for (int i = ql; i <= min(qr, mid - 1); ++i) {
gto(i + 1, mid);
long long c = g[i] + cur;
if (f[mid] > c) {
f[mid] = c;
qmid = i;
}
}
solve(l, mid - 1, ql, qmid);
solve(mid + 1, r, qmid, qr);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
fill(g + 1, g + n + 1, INF);
g[0] = 0;
for (int i = 1; i <= k; ++i) {
f[0] = INF;
solve(1, n, 0, n - 1);
copy(f, f + n + 1, g);
}
printf("%lld\n", f[n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0L);
const int maxn = 2e3 + 600;
long double x[maxn], y[maxn];
int main() {
int n;
cin >> n;
long long ans = (long long)n * (n - 1) * (n - 2) * (n - 3) * (n - 4) / 24;
for (int i = 0; i < n; i++) {
long long xi, yi;
cin >> xi >> yi;
x[i] = xi, y[i] = yi;
}
for (int i = 0; i < n; i++) {
vector<long double> v;
for (int j = 0; j < n; j++) {
if (i == j) continue;
v.push_back(atan2(y[j] - y[i], x[j] - x[i]));
}
sort(v.begin(), v.end());
int k = n - 1, cur = 0;
for (int j = 0; j < k; j++) {
while (cur < j + k) {
long double angle = v[cur % k] - v[j];
if (angle < 0) angle += 2 * pi;
if (angle < pi)
cur++;
else
break;
}
long long cnt = cur - j - 1;
ans -= 1ll * cnt * (cnt - 1) * (cnt - 2) / 6;
}
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool is_mid(int p[], int q[], int r[]) {
return (p[0] == q[0] && p[1] == r[1]) || (p[0] == r[0] && p[1] == q[1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int m, n;
cin >> m >> n;
int cord[3][2];
int k = 0;
char c;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> c;
if (c == '*') {
cord[k][0] = i;
cord[k][1] = j;
k++;
}
}
}
int x, y;
if (is_mid(cord[0], cord[1], cord[2])) {
x = cord[1][0] + cord[2][0] - cord[0][0];
y = cord[1][1] + cord[2][1] - cord[0][1];
} else if (is_mid(cord[1], cord[0], cord[2])) {
x = cord[0][0] + cord[2][0] - cord[1][0];
y = cord[0][1] + cord[2][1] - cord[1][1];
} else {
x = cord[0][0] + cord[1][0] - cord[2][0];
y = cord[0][1] + cord[1][1] - cord[2][1];
}
x++;
y++;
cout << x << " " << y << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long T[105][105];
long long m, n;
void multiply(long long res[][105], long long T[][105]) {
long long ans[m + 1][105];
int i, j, k;
for (i = 0; i < m; i++) {
for (j = 0; j < m; j++) {
ans[i][j] = 0;
for (k = 0; k < m; k++) {
ans[i][j] += res[i][k] * T[k][j];
if (ans[i][j] >= 1000000007) ans[i][j] %= 1000000007;
}
}
}
for (i = 0; i < m; i++)
for (j = 0; j < m; j++) res[i][j] = ans[i][j];
}
void fast_exp(long long final_mul[][105], long long power, long long m) {
long long res[m + 1][105], b[m + 1][105];
int i, j;
for (i = 0; i < m; i++)
for (j = 0; j < m; j++) res[i][j] = T[i][j];
power--;
while (power > 0) {
if (power & 1) {
multiply(res, T);
}
power >>= 1;
multiply(T, T);
}
for (i = 0; i < m; i++)
for (j = 0; j < m; j++) final_mul[i][j] = res[i][j];
}
int main(void) {
long long t, i, j;
string s;
cin >> n >> m;
if (n < m) {
cout << 1;
return 0;
}
T[0][0] = T[0][m - 1] = 1;
for (i = 1; i < m; i++) T[i][i - 1] = 1;
long long final_mul[m + 1][105];
fast_exp(final_mul, n - m + 1, m);
long long ans = 0;
for (i = 0; i < m; i++) {
ans += final_mul[0][i];
if (ans >= 1000000007) ans %= 1000000007;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9, MOD = INF + 7;
const int N = 1e6 + 5;
int ans[N], cnt[N], sz[N], lvl[N], st[N], ver[N], fn[N], ts;
set<pair<int, int> > depth;
vector<int> g[N];
int pre(int v = 1, int p = 0, int h = 0) {
sz[v] = 1;
st[v] = ts++;
ver[st[v]] = v;
lvl[v] = h;
for (int u : g[v])
if (u != p) sz[v] += pre(u, v, h + 1);
fn[v] = ts;
return sz[v];
}
void dfs(int v = 1, int p = 0, bool keep = 0) {
int big = 0;
for (int u : g[v])
if (u != p && sz[u] > sz[big]) big = u;
for (int u : g[v])
if (u != p && u != big) dfs(u, v, 0);
if (big) dfs(big, v, 1);
for (int u : g[v])
if (u != p && u != big) {
for (int w = st[u]; w < fn[u]; w++) {
int h = lvl[ver[w]];
depth.erase(make_pair(cnt[h], -h));
depth.insert(make_pair(++cnt[h], -h));
}
}
int h = lvl[v];
depth.erase(make_pair(cnt[h], -h));
depth.insert(make_pair(++cnt[h], -h));
ans[v] = -1 * depth.rbegin()->second - lvl[v];
if (!keep) {
for (int u = st[v]; u < fn[v]; u++) cnt[lvl[ver[u]]]--;
depth.clear();
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n - 1; i++) {
int v, u;
cin >> v >> u;
g[v].push_back(u);
g[u].push_back(v);
}
pre();
dfs();
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e12 + 1;
bool function1(string s, int k, int val) {
int a = 0, b = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'a')
a += 1;
else
b += 1;
}
if (min(a, b) <= val) return true;
for (int i = k; i < s.size(); i++) {
if (min(a, b) <= val) return true;
if (s[i] == 'a')
a += 1;
else
b += 1;
if (s[i - k] == 'a')
a -= 1;
else
b -= 1;
}
if (min(a, b) <= val) return true;
return false;
}
int main() {
int t;
t = 1;
while (t--) {
int n, m, ans = 0;
cin >> n >> m;
string s;
cin >> s;
int l = 1;
int r = n;
while (l <= r) {
int mid = l + (r - l) / 2;
if (function1(s, mid, m)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
int N, M, S, T;
pair<int, int> E[MAXN];
vector<pair<int, int> > adj[MAXN];
int A[MAXN];
int disc[MAXN];
int low[MAXN];
int P[MAXN];
int sz = 0;
bool bridge[MAXN];
vector<pair<int, int> > nadj[MAXN];
int par[MAXN];
bool has[MAXN];
bool vis[MAXN];
void find_bridges(int node) {
disc[node] = low[node] = ++sz;
for (int i = 0; i < adj[node].size(); i++) {
int next = adj[node][i].first, idx = adj[node][i].second;
if (disc[next] == 0) {
P[next] = idx;
find_bridges(next);
low[node] = min(low[node], low[next]);
if (low[next] > disc[node]) bridge[idx] = true;
} else if (idx != P[node])
low[node] = min(low[node], disc[next]);
}
}
int find_parent(int x) {
if (par[x] == x) return x;
return par[x] = find_parent(par[x]);
}
void merge(int a, int b, int add) {
a = find_parent(a), b = find_parent(b);
if (a != b) {
par[a] = b;
has[b] |= has[a];
}
has[b] |= add;
}
int dfs(int cur, int prev, int cnt) {
cnt += has[cur];
if (cur == find_parent(T)) return cnt;
for (int i = 0; i < nadj[cur].size(); i++) {
int next = nadj[cur][i].first;
if (next == prev) continue;
int ret = dfs(next, cur, cnt + A[nadj[cur][i].second]);
if (ret != -1) return ret;
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin >> N >> M;
for (int i = 0, a, b, c; i < M; i++) {
cin >> a >> b >> c;
E[i] = make_pair(a, b);
adj[a].push_back(make_pair(b, i));
adj[b].push_back(make_pair(a, i));
A[i] = c;
}
cin >> S >> T;
find_bridges(1);
for (int i = 1; i <= N; i++) par[i] = i;
for (int i = 0; i < M; i++)
if (!bridge[i]) merge(E[i].first, E[i].second, A[i]);
for (int cur = 1; cur <= N; cur++)
for (int i = 0; i < adj[cur].size(); i++)
if (bridge[adj[cur][i].second] && cur < adj[cur][i].first) {
int a = find_parent(cur), b = find_parent(adj[cur][i].first);
nadj[a].push_back(make_pair(b, adj[cur][i].second));
nadj[b].push_back(make_pair(a, adj[cur][i].second));
}
if (dfs(find_parent(S), 0, 0) > 0)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool isPowerOfTwo(long long x) { return (x && !(x & (x - 1))); }
void ans() {
long long k, a, b;
cin >> k >> a >> b;
string s;
cin >> s;
if ((a * k < s.length() && b * k < s.length()) ||
(a * k > s.length() && b * k > s.length())) {
cout << "No solution" << endl;
} else if (s.length() % k == 0) {
long long d = 0;
for (long long i = 0; i < s.length(); i++) {
d++;
cout << s[i];
if (d % (s.length() / k) == 0) {
cout << endl;
}
}
} else {
long long c = 0, d = 1;
long long x = s.length() / k;
long long y = s.length() % k;
for (long long i = 0; i < s.length(); i++) {
c++;
cout << s[i];
if (d <= y) {
if (c == x + 1) {
cout << endl;
d++;
c = 0;
}
} else {
if (c == x) {
cout << endl;
d++;
c = 0;
}
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ans();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> prime;
long long powerFunction(long long x, long long y) {
long long res = 1;
long long p = 1000000007;
;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void sieve(long long n) {
for (int p = 2; p * p <= n; p++) {
if (prime[p]) {
for (int i = p * p; i <= n; i += p) prime[i] = 0;
}
}
}
int main() {
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long a[n + 1][n + 1];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = 0;
a[i][n] = 0;
}
}
if (k % n == 0)
cout << 0 << '\n';
else
cout << 2 << '\n';
long long p = 0, q = 0;
while (k > 0) {
k--;
a[p][q] = 1;
p++;
q++;
q %= n;
if (p == n) {
p = 0;
q++;
q %= n;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << a[i][j];
}
cout << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool f(string a, string b) {
string a1, a2, b1, b2;
if (a.size() == 0 or b.size() == 0) return false;
if (a.size() != b.size()) return false;
bool res = (a == b);
if ((a.size() % 2 != 0 or b.size() % 2 != 0) and !res) return false;
if (res) return true;
a1.insert(a1.begin(), a.begin(), a.begin() + a.size() / 2);
a2.insert(a2.begin(), a.begin() + a.size() / 2, a.end());
b1.insert(b1.begin(), b.begin(), b.begin() + b.size() / 2);
b2.insert(b2.begin(), b.begin() + b.size() / 2, b.end());
if (f(a1, b2) and f(a2, b1))
return true;
else if (f(a1, b1) and f(a2, b2))
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string a, b;
cin >> a >> b;
if (f(a, b))
printf("YES");
else
printf("NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
long long a[n + 1];
a[n] = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
stack<int> st;
int s = 0;
vector<string> ans;
for (int i = 0; i < n + 1; i++) {
while (s < a[i]) {
st.push(i + 1);
s++;
}
while (s > a[i]) {
int ind = st.top();
st.pop();
ans.push_back(to_string(ind) + " " + to_string(i));
s--;
}
}
cout << ans.size() << endl;
for (auto s : ans) {
cout << s << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, d, l, sum = 0, k;
cin >> a >> b >> c >> d;
if (a != c && b != d) {
if (abs(c - a) == abs(d - b)) {
cout << a << " " << d << " " << c << " " << b;
} else {
cout << "-1" << endl;
}
}
if (a == c && b != d) {
cout << a + abs(d - b) << " " << b << " " << a + abs(d - b) << " " << d;
}
if (b == d && a != c) {
cout << a << " " << b + abs(a - c) << " " << c << " " << b + abs(a - c);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 501;
int v[N];
int dp[N][N];
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> v[i];
for (int i = 0; i < n; ++i) dp[i][i] = 1;
for (int i = 0; i + 1 < n; ++i) dp[i][i + 1] = (v[i] == v[i + 1]) ? 1 : 2;
for (int s = 3; s <= n; ++s) {
for (int i = 0; i + s - 1 < n; ++i) {
int j = i + s - 1;
int ans = 1 + dp[i + 1][j];
int ii = i;
int jj = j;
for (; ii + 1 < jj; ++ii, --jj) {
if (v[ii] != v[jj]) break;
if (ii != jj) ans = min(ans, dp[ii + 1][jj - 1]);
}
if (ii == jj) ans = 1;
ii = i;
for (ii = i; ii + 1 <= j; ++ii) ans = min(ans, dp[i][ii] + dp[ii + 1][j]);
dp[i][j] = ans;
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000000 + 10;
long long dp[maxn], f[maxn];
int main() {
int n;
cin >> n;
f[0] = 0;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
dp[i] = (3 * f[i - 1]) % 1000000007;
f[i] = ((2 * f[i - 1]) + dp[i - 1]) % 1000000007;
}
cout << dp[n] % 1000000007;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long r, n, ans;
cin >> n >> r;
if (n > r) {
ans = ((r * (r + 1)) / 2);
} else {
ans = (n * (n - 1) / 2) + 1;
}
cout << ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long x, y;
int maxdis(long long x, long long n, long long s) {
if (x > (s >> 1)) x = s - x;
if (x * n > s)
return maxdis(s % x, (x * n + s % x) / s, x);
else
return (x > (s - x * (n - 1)) ? x : (s - x * (n - 1)));
}
int a, n, p, h;
int main() {
int t;
using namespace std;
ios::sync_with_stdio(false);
cin >> t;
for (register int i = 0; i < t; i++) {
cin >> a >> n >> p >> h, a %= p;
int maxd = ((long long)a * n < p) ? a : maxdis(a % p, n + 1, p);
if (maxd <= h)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool a[100100], b[100100], z[100100][2];
int n, k;
void dfs(int q, int w, int level) {
z[q][w] = true;
if (q + k > n) {
cout << "YES";
exit(0);
}
if (w == 0) {
if (b[q + k] && !z[q + k][w xor 1]) dfs(q + k, w xor 1, level + 1);
if (a[q + 1] && !z[q + 1][w]) dfs(q + 1, w, level + 1);
if (a[q - 1] && !z[q - 1][w] && level < q - 2) dfs(q - 1, w, level + 1);
} else if (w == 1) {
if (a[q + k] && !z[q + k][w xor 1]) dfs(q + k, w xor 1, level + 1);
if (b[q + 1] && !z[q + 1][w]) dfs(q + 1, w, level + 1);
if (b[q - 1] && !z[q - 1][w] && level < q - 2) dfs(q - 1, w, level + 1);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
if (c == '-')
a[i] = true;
else
a[i] = false;
}
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
if (c == '-')
b[i] = true;
else
b[i] = false;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 1; j++) z[i][j] = false;
dfs(1, 0, 0);
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
long long modExpo(long long x, long long n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modExpo((x * x) % 998244353, n / 2);
else
return (x * modExpo((x * x) % 998244353, (n - 1) / 2)) % 998244353;
}
long long modInverse(long long n) { return modExpo(n, 1000000007 - 2); }
long long n, m, k, ar[100010];
pair<long long, long long> hull[100010];
string s, s1;
bool is_left(pair<long long, long long> p1, pair<long long, long long> p2,
pair<long long, long long> p3) {
long long t = (p2.first - p1.first) * (p3.second - p2.second) -
(p2.second - p1.second) * (p3.first - p2.first);
if (t >= 0)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int ti = 1;
while (ti--) {
vector<pair<long long, long long> > v;
cin >> n;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
y = y - x * x;
v.push_back(make_pair(x, y));
}
sort(v.begin(), v.end());
long long ans = 0;
for (long long i = 0; i < n; i++) {
while (ans > 1 && is_left(hull[ans - 1], hull[ans], v[i])) ans--;
hull[++ans] = v[i];
}
long long cnt = 0;
for (long long i = 2; i < ans + 1; i++)
if (hull[i].first != hull[i - 1].first) cnt++;
cout << cnt;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, U = 1e6 + 5;
bitset<U> b[N];
int T, n, i, j, a[N];
vector<int> v1, v2, v3, v4;
bool FL;
inline void input(vector<int>& v1, vector<int>& v2) {
v1.clear();
v2.clear();
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
random_shuffle(a + 1, a + n + 1);
for (i = 0; i <= n; ++i) b[i].reset();
b[0][U / 2] = 1;
for (i = 1; i <= n; ++i) b[i] = (b[i - 1] << a[i]) | (b[i - 1] >> a[i]);
if (!b[n][U / 2]) {
FL = 0;
return;
}
for (i = n, j = U / 2; i; --i)
if (0 <= j - a[i] && j - a[i] < U && b[i - 1][j - a[i]])
j -= a[i], v1.push_back(a[i]);
else
j += a[i], v2.push_back(a[i]);
if (v1.size() > v2.size()) swap(v1, v2);
}
int main() {
srand(114514);
for (scanf("%d", &T); T--;) {
FL = 1;
input(v1, v2);
input(v3, v4);
if (v1.size() + v2.size() != v3.size() + v4.size()) FL = 0;
if (!FL) {
puts("No");
continue;
}
sort(v1.begin(), v1.end(), greater<int>());
sort(v2.begin(), v2.end(), greater<int>());
sort(v3.begin(), v3.end());
sort(v4.begin(), v4.end());
puts("Yes");
int x = 0, y = 0;
for (i = 0; i < v1.size(); ++i) {
printf("%d %d\n", x += v1[i], y);
printf("%d %d\n", x, y += v4[i]);
}
for (j = 0; i < v4.size(); ++i, ++j) {
printf("%d %d\n", x -= v2[j], y);
printf("%d %d\n", x, y += v4[i]);
}
for (i = 0; j < v2.size(); ++j, ++i) {
printf("%d %d\n", x -= v2[j], y);
printf("%d %d\n", x, y -= v3[i]);
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m;
int a[N];
int main() {
scanf("%d%*d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
int p = 1;
scanf("%d", &m);
for (int i = 1, x; i <= m; i++) {
scanf("%d", &x);
while (p <= n && a[p] < x) p++;
if (p == 1 || p > n) {
puts("1.570796326794897");
continue;
}
if (a[p - 1] + 1 == x && a[p] == x) {
puts("3.141592653589793");
continue;
}
if (a[p - 1] + 1 == x || a[p] == x) {
puts("1.570796326794897");
continue;
}
if (a[p - 1] + 2 == x && a[p] - 1 == x) {
puts("1.570796326794897");
continue;
}
int L = min(x - a[p - 1] - 1, a[p] - x);
int lim = L * 3, dis = 1400000000;
int pr = p;
for (int i = p - 1, d, _d; i && (d = x - a[i] - 1) <= lim; i--) {
while (pr < n && (a[pr + 1] - x <= d)) pr++;
_d = a[pr] - x;
if (_d == d || _d == d - 1) {
dis = d;
break;
}
}
int pl = p - 1;
for (int i = p, d, _d; i <= n && (d = a[i] - x) <= lim && d <= dis; i++) {
while (pl > 1 && (x - a[pl - 1] - 1 <= d)) pl--;
_d = x - a[pl] - 1;
if (_d == d || _d == d - 1) {
dis = d;
break;
}
}
double theta = 1.0 / L;
if (dis < 1400000000) {
assert(dis > 1);
double x = 1.0 / dis;
theta = max(theta, 2 * x / (1 - x * x));
}
theta = atan(theta);
printf("%.15lf\n", theta);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:255777216")
using namespace std;
double PI = 3.1415926535897932384626433832795;
int cnt[31000];
int dp[30100][600];
int d;
int go(int pos, int l) {
if (pos > 30000) return 0;
int& res = dp[pos][l];
if (res != -1) return res;
res = cnt[pos];
int len = 0;
if (l <= 300) {
len = d - (300 - l);
} else {
len = d + (l - 300);
}
if (len == 1) {
res += max(go(pos + len, l), go(pos + len + 1, l + 1));
} else
res += max(max(go(pos + len, l), go(pos + len - 1, l - 1)),
go(pos + len + 1, l + 1));
return res;
}
int main() {
memset(dp, -1, sizeof(dp));
int n;
cin >> n >> d;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
cnt[v] += 1;
}
int answ = cnt[0];
answ += go(d, 300);
cout << answ << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1111111;
const int MAXM = 1111111;
const int INF = 1034567890;
int N, M;
int OddCnt = 0;
struct Node {
int Size, Val, MVat, MinV, Id;
int r;
Node *s[2], *f;
Node(bool i = false);
int d() { return f->s[1] == this; }
void sc(Node *x, int d) { (s[d] = x)->f = this; }
bool rt() { return f->s[0] != this && f->s[1] != this; }
void pup() {
Size = s[0]->Size + s[1]->Size + 1;
MinV = Val;
MinV = min(MinV, s[0]->MinV);
MinV = min(MinV, s[1]->MinV);
if (MinV == Val) MVat = Id;
if (MinV == s[0]->MinV) MVat = s[0]->MVat;
if (MinV == s[1]->MinV) MVat = s[1]->MVat;
}
void mr() {
r ^= 1;
swap(s[0], s[1]);
}
void pdw() {
if (r != 0) {
s[0]->mr();
s[1]->mr();
r = 0;
}
}
} *NIL = new Node(true), *T[MAXN + MAXM];
Node::Node(bool i) {
if (i) {
s[0] = NULL;
s[1] = NULL;
f = NULL;
} else {
s[0] = NIL;
s[1] = NIL;
f = NIL;
}
r = 0;
Size = 0;
Val = INF;
MVat = -1;
Id = -1;
MinV = INF;
}
void zig(Node *x) {
int d = x->d();
Node *y = x->f;
y->sc(x->s[!d], d);
if (!y->rt())
y->f->sc(x, y->d());
else
x->f = y->f;
x->sc(y, !d);
y->pup();
x->pup();
}
void splay(Node *x) {
for (Node *y; !x->rt();) {
y = x->f;
if (!y->rt()) y->f->pdw();
y->pdw();
x->pdw();
if (!y->rt()) (x->d() ^ y->d()) ? zig(x) : zig(y);
zig(x);
}
}
void Access(Node *x) {
Node *t = x, *y = NIL;
while (x != NIL) {
splay(x);
x->pdw();
x->sc(y, 1);
x->pup();
y = x;
x = x->f;
}
splay(t);
}
void Evert(Node *x) {
Access(x);
x->mr();
}
void Cut(Node *x, Node *y) {
Evert(x);
Access(y);
x->f = NIL;
y->s[0] = NIL;
y->pup();
}
void Link(Node *x, Node *y) {
Evert(x);
x->f = y;
}
Node *GetRoot(Node *x) {
Access(x);
while (x->s[0] != NIL) x = x->s[0];
return x;
}
int Qmin(Node *x, Node *y) {
Evert(x);
Access(y);
return y->MVat;
}
int mark[MAXM];
struct Edge {
int x, y;
} E[MAXM];
struct Query {
int op, id;
} Q[MAXM];
map<pair<int, int>, int> Map;
int m = 0;
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M;
for (int i = 1; i <= N; ++i) {
T[i] = new Node;
T[i]->Id = i;
T[i]->pup();
}
for (int i = 1; i <= M; ++i) {
T[N + i] = new Node;
T[N + i]->Id = N + i;
T[N + i]->pup();
}
for (int i = 1, x, y, id; i <= M; ++i) {
cin >> x >> y;
if (x < y) swap(x, y);
id = Map[make_pair(x, y)];
if (id != 0) {
Q[i].op = 0;
Q[i].id = id;
Map[make_pair(x, y)] = 0;
T[N + id]->Val = i;
} else {
Q[i].op = 1;
Q[i].id = ++m;
E[m].x = x;
E[m].y = y;
Map[make_pair(x, y)] = m;
}
}
for (int i = 1; i <= M; ++i) {
if (T[N + i]->Val == INF) T[N + i]->Val = M + 1;
T[N + i]->pup();
}
for (int i = 1, x, y; i <= M; ++i) {
x = E[Q[i].id].x;
y = E[Q[i].id].y;
if (Q[i].op) {
if (GetRoot(T[x]) != GetRoot(T[y])) {
Link(T[x], T[N + Q[i].id]);
Link(T[N + Q[i].id], T[y]);
} else {
int z = Qmin(T[x], T[y]);
Evert(T[x]);
Access(T[y]);
if (((T[y]->Size - 1) >> 1) & 1) {
if (T[N + Q[i].id]->Val <= T[z]->Val)
mark[Q[i].id] = 2;
else {
mark[z - N] = 2;
Cut(T[E[z - N].x], T[z]);
Cut(T[E[z - N].y], T[z]);
Link(T[x], T[N + Q[i].id]);
Link(T[N + Q[i].id], T[y]);
}
} else {
++OddCnt;
if (T[N + Q[i].id]->Val <= T[z]->Val)
mark[Q[i].id] = 1;
else {
mark[z - N] = 1;
Cut(T[E[z - N].x], T[z]);
Cut(T[E[z - N].y], T[z]);
Link(T[x], T[N + Q[i].id]);
Link(T[N + Q[i].id], T[y]);
}
}
}
} else {
if (!mark[Q[i].id]) {
Cut(T[x], T[N + Q[i].id]);
Cut(T[N + Q[i].id], T[y]);
} else if (mark[Q[i].id] == 1)
--OddCnt;
}
puts(OddCnt ? "NO" : "YES");
}
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define PI acos(-1)
#define hell 1000000007
#define HELL 998244353
#define io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define fix(n) cout << fixed << setprecision(n)
#define mset(a,n) memset(a,n,sizeof a)
#define rep(i,a,b) for (__typeof((b)) i=(a);i<(b);i++)
#define repp(i,a,b,p) for(__typeof((b)) i=(a);i<(b);i+=p)
#define ren(i,a,b) for(__typeof((a)) i=(a);i>=(b);i--)
#define renn(i,a,b,p) for(__typeof((a) i=(a);i>=(b);i-=p)
#define lbd lower_bound
#define ubd upper_bound
#define ll long long
#define ld long double
#define pb push_back
#define fi first
#define se second
#define vll vector<ll>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define all(v) (v).begin(), (v).end()
#define sz(x) (ll)x.size()
#define endl "\n"
#define out(n) cout<<n<<" "
#define outl(n) cout<<n<<endl
#define line cout<<endl
#define bug(n) {outl(n);return;}
#define N 200005
struct node{
ll l,r,s,e;
};
ll n,m,l,r;
string s;
node tree[4*N],ans;
node combine(node a, node b){
if(a.l==hell&&b.l==hell){
a.r=hell;
return a;
}
if(a.l==hell)return b;
if(b.l==hell)return a;
node ans=a;
ll d=b.s-ans.e;
b.s-=d,b.e-=d,b.l-=d,b.r-=d;
ans.e=b.e;
ans.l=min(ans.l,b.l);
ans.r=max(ans.r,b.r);
return ans;
}
void build(ll i, ll l, ll r){
if(l==r){
if(s[l]=='+'){
tree[i].s=0;
tree[i].e=1;
tree[i].l=0;
tree[i].r=1;
}else{
tree[i].s=0;
tree[i].e=-1;
tree[i].l=-1;
tree[i].r=0;
}
return;
}
build(2*i,l,(l+r)/2);
build(2*i+1,(l+r)/2+1,r);
tree[i]=combine(tree[2*i],tree[2*i+1]);
}
node query(ll i, ll l, ll r, ll x, ll y){
if(l>r||x>y){
node temp;
temp.l=hell;
temp.r=hell-1;
return temp;
}
if(x<=l&&r<=y)return tree[i];
return combine(query(2*i,l,(l+r)/2,x,min(y,(l+r)/2)),query(2*i+1,(l+r)/2+1,r,max(x,(l+r)/2+1),y));
}
void solve(){
cin>>n>>m>>s;
s=" "+s;
build(1,1,n);
while(m--){
cin>>l>>r;
ans=combine(query(1,1,n,1,l-1),query(1,1,n,r+1,n));
outl(ans.r-ans.l+1);
}
}
void prep(){
}
int main(){
io;
ll t=1;
cin>>t;
prep();
fix(12);
while(t--)
solve();
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int k[666666], s[666666], t[666666], i, val, res, cnt, n, vt[666666], l,
ans1[666666], ans2[666666], ans3[666666];
struct dt {
int pos, move;
} q[666666];
inline bool cmp(int a, int b) { return s[a] < s[b]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s[i];
vt[i] = i;
}
sort(vt + 1, vt + n + 1, cmp);
sort(s + 1, s + n + 1);
for (i = 1; i <= n; i++) cin >> t[i];
sort(t + 1, t + n + 1);
for (i = 1; i <= n; i++) k[i] = s[i] - t[i];
for (i = 1; i <= n; i++) {
if (k[i] < 0) {
cnt++;
q[cnt].move = -k[i];
q[cnt].pos = vt[i];
} else if (k[i] > 0) {
val = k[i];
while (cnt > 0 && val > 0) {
res = min(val, q[cnt].move);
l++;
ans1[l] = q[cnt].pos;
ans2[l] = vt[i];
ans3[l] = res;
q[cnt].move -= res;
val -= res;
if (q[cnt].move == 0) cnt--;
}
if (val > 0) {
cout << "NO";
return 0;
}
}
}
if (cnt > 0) {
cout << "NO";
return 0;
}
cout << "YES\n";
cout << l << endl;
for (i = 1; i <= l; i++)
cout << ans1[i] << " " << ans2[i] << " " << ans3[i] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
for (int i = 1; i < s.size(); i++) {
if (s[i] == 'G' && s[i - 1] == 'B') {
s[i - 1] = 'G';
s[i] = 'B';
i++;
continue;
}
}
}
cout << s << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
const int MOD = 998244353;
int n;
int num;
int head[maxn];
struct Edge {
int to, next;
} G[maxn << 1];
void addEdge(int u, int v) {
G[num] = Edge{v, head[u]};
head[u] = num++;
}
long long fact[maxn];
long long dp[maxn];
vector<int> son[maxn];
void DFS(int u, int f) {
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == f) continue;
son[u].push_back(v);
DFS(v, u);
}
int k = son[u].size() + (u != 1 ? 1 : 0);
dp[u] = fact[k];
for (int i = 0; i < son[u].size(); ++i) dp[u] = dp[u] * dp[son[u][i]] % MOD;
}
long long Solve() {
for (int i = 0; i <= n; ++i) son[i].clear();
DFS(1, 1);
return dp[1] * n % MOD;
}
void Init() {
num = 0;
for (int i = 0; i <= n; head[i++] = -1)
;
;
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = (i * fact[i - 1]) % MOD;
}
int main() {
scanf("%d", &n);
Init();
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
printf("%lld\n", Solve());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool sortcol(const vector<long long>& v1, const vector<long long>& v2) {
return v1[0] < v2[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
long long n, d;
cin >> n >> d;
vector<vector<long long> > a(n);
for (int i = 0; i < n; i++) {
long long c, b;
cin >> c >> b;
a[i].push_back(c);
a[i].push_back(b);
}
sort(a.begin(), a.end(), sortcol);
long long sum[n];
memset(sum, 0, sizeof(sum));
sum[0] = a[0][1];
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + a[i][1];
}
long long maxi = a[0][1];
long long j = 0;
for (int i = 0; i < n; i++) {
long long t = i;
while ((j < n) && ((a[j][0] - a[i][0]) < d)) {
t = j;
j++;
}
maxi = max(maxi, sum[t] - sum[i] + a[i][1]);
}
cout << maxi;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC target("avx")
const long double pi = 3.1415926535898;
using namespace std;
long long int tree[1000005];
long long int tri[1000005];
long long int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, a = 0, b = 0, c;
cin >> n;
bool flag = 0;
while (n > 0) {
if (n % 7 == 0) {
b = n / 7;
c = a;
flag = 1;
break;
}
n -= 4;
a++;
}
if (n == 0) {
while (a--) cout << "4";
exit(0);
}
if (n < 0 && flag == 0) {
cout << "-1";
exit(0);
} else {
while (c--) cout << "4";
while (b--) cout << "7";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 60;
const long long mod = 1000000007;
int n, m;
long long c[maxn][maxn], f[maxn][maxn][2];
void pre() {
int i, j;
c[0][0] = 1LL;
for (i = 1; i <= n; i++) {
c[i][0] = 1LL;
for (j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
int main() {
int i, k, k2, j, p;
long long tmp;
scanf("%d%d", &n, &m);
memset(f, 0, sizeof(f));
pre();
f[1][0][0] = 1;
f[0][0][1] = 1;
if (n <= 1) {
printf("%d\n", 0);
return 0;
}
for (i = 2; i <= n; i++) {
for (j = 1; j <= i / 2; j++) {
for (k = 0;; k++) {
k2 = i - k - 1;
if (k2 < k) break;
for (p = 0; p <= min(k / 2, j); p++) {
if (k == k2)
tmp = c[i - 2][k - 1];
else
tmp = c[i - 1][k];
if (k) {
tmp = tmp * k2 % mod * k % mod;
} else {
tmp = tmp * k2 % mod;
}
f[i][j][0] = (f[i][j][0] +
f[k][p][1] * f[i - k - 1][j - p][1] % mod * tmp % mod) %
mod;
f[i][j][1] = (f[i][j][1] + f[k][p][1] * f[i - k - 1][j - p - 1][0] %
mod * tmp % mod) %
mod;
f[i][j][1] = (f[i][j][1] + f[k][p][0] * f[i - k - 1][j - p - 1][1] %
mod * tmp % mod) %
mod;
f[i][j][1] = (f[i][j][1] + f[k][p][0] * f[i - k - 1][j - p - 1][0] %
mod * tmp % mod) %
mod;
}
}
}
}
printf("%I64d\n", (f[n][m][0] + f[n][m][1]) % mod);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(const T& x) {
return x * x;
}
template <class T>
inline string tostr(const T& a) {
ostringstream x("");
x << a;
return x.str();
}
const int inf = 1999999999;
const double pi = acos(-1.0);
const double eps = 1e-9;
int n;
const double diagonal = 20 * cos(pi / 5);
const double longg = 10 * cos(2 * pi / 5) + 10;
const double shortt = 10 * sin(2 * pi / 5);
int main() {
cin >> n;
vector<pair<double, double> > vertices;
double x = -2000, y = 0;
for (int i = 0; i < n + 1; i++) {
vertices.push_back(make_pair(x, y));
x += diagonal;
}
for (int i = n; i > 0; i--) {
pair<double, double> base = vertices[i];
x = base.first;
y = base.second;
x -= longg;
y -= shortt;
vertices.push_back(make_pair(x, y));
x = base.first;
y = base.second;
x -= 10 * cos(pi / 5);
y += 10 * sin(pi / 5);
vertices.push_back(make_pair(x, y));
x = base.first;
y = base.second;
x -= 10 * cos(2 * pi / 5);
y -= 10 * sin(2 * pi / 5);
vertices.push_back(make_pair(x, y));
}
cout << vertices.size() << ('\n');
for (int i = 0; i < vertices.size(); i++) {
printf("%.9f %.9f\n", vertices[i].first, vertices[i].second);
}
for (int i = 0; i < n; i++) {
printf("%d %d %d %d %d\n", i + 1, n + 3 + 3 * (n - 1 - i), i + 2,
n + 4 + 3 * (n - 1 - i), n + 2 + 3 * (n - 1 - i));
}
for (int i = 0; i < n + 1; i++) {
printf("%d ", i + 1);
}
int counter = n + 1;
for (int i = n; i >= 1; i--) {
printf("%d ", ++counter);
printf("%d ", ++counter);
printf("%d ", ++counter);
printf("%d ", i);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, N, j, check = 1;
long long test, sq;
long long n[1000000];
int main() {
cin >> N;
for (i = 3; i <= 1000; i = i + 2) {
if (n[i] == 0) {
for (j = i * i; j <= 1000000; j += i + i) n[j] = 1;
}
}
for (i = 0; i < N; i++) {
cin >> test;
sq = sqrt(test);
if (sq * sq == test && test != 1) {
if (test == 4)
cout << "YES" << endl;
else if (test % 2 == 0)
cout << "NO" << endl;
else if (n[sq] == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
if (a[n - 1] == -1) {
cout << 0 << endl;
return 0;
}
ans += a[n - 1];
int pos = n - 2, tmp = n;
priority_queue<int, vector<int>, greater<int>> q;
while (tmp > 0) {
for (int i = 0; i < tmp / 2; i++) {
if (a[pos] == -1) {
cout << ans << endl;
return 0;
}
q.push(a[pos]);
pos--;
}
ans += q.top();
q.pop();
tmp /= 2;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void dfs(int v, int m, int n, vector<int> &col, vector<int> &pr,
vector<char> tab, bool &cycle) {
col[v] = 1;
if (v % n != 0 && tab[v - 1] == tab[v] && col[v - 1] == 0) {
pr[v - 1] = v;
dfs(v - 1, m, n, col, pr, tab, cycle);
} else if (v % n != 0 && tab[v - 1] == tab[v] && col[v - 1] == 1 &&
pr[v] != v - 1) {
cycle = true;
}
if (v % n != n - 1 && tab[v + 1] == tab[v] && col[v + 1] == 0) {
pr[v + 1] = v;
dfs(v + 1, m, n, col, pr, tab, cycle);
} else if (v % n != n - 1 && tab[v + 1] == tab[v] && col[v + 1] == 1 &&
pr[v] != v + 1) {
cycle = true;
}
if (v >= n && tab[v - n] == tab[v] && col[v - n] == 0) {
pr[v - n] = v;
dfs(v - n, m, n, col, pr, tab, cycle);
} else if (v >= n && tab[v - n] == tab[v] && col[v - n] == 1 &&
pr[v] != v - n) {
cycle = true;
}
if (v < (m - 1) * n && tab[v + n] == tab[v] && col[v + n] == 0) {
pr[v + n] = v;
dfs(v + n, m, n, col, pr, tab, cycle);
} else if (v < (m - 1) * n && tab[v + n] == tab[v] && col[v + n] == 1 &&
pr[v] != v + n) {
cycle = true;
}
col[v] = 2;
}
int main() {
int M, N;
scanf("%d%d", &M, &N);
vector<char> table(M * N);
for (int i = 0; i < M * N; i++) {
scanf(" %c", &table[i]);
}
vector<int> color(M * N, 0);
vector<int> prev(M * N);
for (int i = 0; i < M * N; i++) {
if (color[i] == 0) {
bool cyc = false;
dfs(i, M, N, color, prev, table, cyc);
if (cyc == true) {
printf("Yes");
return 0;
}
}
}
printf("No");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, max, min;
char c;
int a;
string s;
while (cin >> n) {
max = 2000000000;
min = -2000000000;
for (int i = 0; i < n; i++) {
cin >> s;
cin >> a >> c;
if (c == 'Y') {
if (s == ">" && min <= a) min = a + 1;
if (s == "<" && max >= a) max = a - 1;
if (s == ">=" && min < a) min = a;
if (s == "<=" && max > a) max = a;
}
if (c == 'N') {
if (s == ">" && max > a) max = a;
if (s == "<" && min < a) min = a;
if (s == ">=" && max >= a) max = a - 1;
if (s == "<=" && min <= a) min = a + 1;
}
}
if (min > max)
cout << "Impossible" << endl;
else
cout << min << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[55];
int len;
long long sol, memo[55][15];
long long rec(int loc, int current) {
if (loc == len - 1) return 1;
long long &ret = memo[loc][current];
if (~ret) return ret;
ret = 0;
int diff = current + s[loc + 1] - '0';
if (diff % 2) ret += rec(loc + 1, diff / 2 + 1);
ret += rec(loc + 1, diff / 2);
return ret;
}
int main() {
memset(memo, -1, sizeof memo);
scanf("%s", s);
len = strlen(s);
for (int i = 0; i <= 9; i++) sol += rec(0, i);
bool ok = true;
for (int i = 1; i < len && ok; i++) {
int curr = s[i] - '0';
int suma = curr + s[i - 1] - '0';
if (suma % 2) {
if (curr != suma / 2 and curr != suma / 2 + 1) ok = false;
} else if (curr != suma / 2)
ok = false;
}
if (ok) sol--;
cout << sol << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
vector<pair<pair<int, int>, int> > head[N];
int node[N];
inline int lowbit(int x) { return x & -x; }
void update(int x, int v) {
while (x < N) {
node[x] += v;
x += lowbit(x);
}
}
int query(int x) {
int ret = 0;
for (; x; x -= lowbit(x)) {
ret += node[x];
}
return ret;
}
int ans[N];
int main() {
int n, p, t, num;
while (cin >> n) {
for (int i = (1); i <= (n); ++i) head[i].clear();
memset(ans, -1, sizeof(ans));
int flag = 0;
map<int, int> m;
for (int i = (1); i <= (n); ++i) {
scanf("%d%d%d", &p, &t, &num);
if (m.find(num) == m.end()) m[num] = ++flag;
head[m[num]].push_back(
pair<pair<int, int>, int>(pair<int, int>(t, i), p));
}
for (int i = (1); i <= (flag); ++i) sort(head[i].begin(), head[i].end());
for (int i = (1); i <= (flag); ++i) {
memset(node, 0, sizeof(node));
for (pair<pair<int, int>, int> top : head[i]) {
int id = top.first.second;
if (top.second == 3)
ans[id] = query(id);
else {
int v = (top.second == 1 ? 1 : -1);
update(id, v);
}
}
}
for (int i = (1); i <= (n); ++i)
if (ans[i] != -1) printf("%d\n", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<long long>;
using vl = vector<long long>;
using pii = pair<long long, long long>;
using pll = pair<long long, long long>;
const long long DX[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
DY[9] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto i = begin(v); i != end(v); ++i)
os << *i << (i == end(v) - 1 ? "" : "\n");
return os;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto i = begin(v); i != end(v); ++i) is >> *i;
return is;
}
template <class T>
istream &operator>>(istream &is, pair<T, T> &p) {
is >> p.first >> p.second;
return is;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
struct before_main_function {
before_main_function() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(15) << fixed;
}
} before_main_function;
signed main() {
long long N;
cin >> N;
vi a(N);
cin >> a;
sort(begin(a), end(a));
long long min = (1001001001001001001ll);
for (long long i = 1, i_len = (long long)(((long long)a.size())); i < i_len;
++i) {
chmin(min, a[i] - a[i - 1]);
}
long long ans = 0;
for (long long i = 1, i_len = (long long)(((long long)a.size())); i < i_len;
++i) {
if (a[i] - a[i - 1] == min) ans++;
}
cout << min << " " << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MaxV = 500 * 2 + 10;
int f[MaxV][MaxV], g[MaxV][MaxV];
bool vis[MaxV][MaxV], inq[MaxV];
int head[MaxV], nxt[MaxV], to[MaxV], tid[MaxV], tsd[MaxV], twd[MaxV], tvd[MaxV],
in, out, si, vi, wi, n, S, top;
void addedge(int fr, int tt, int ww, int ss, int vv, int id) {
top++;
nxt[top] = head[fr];
to[top] = tt;
tid[top] = id;
tsd[top] = ss;
twd[top] = ww;
tvd[top] = vv;
head[fr] = top;
}
int dp(int id, int st, int en, int s) {
if (vis[id][s]) return f[id][s];
vis[id][s] = 1;
int &ret = f[id][s];
ret = 0;
inq[id] = 1;
memset(g[id], 0, sizeof(g[id]));
for (int i = st; i <= en; i++) {
g[id][i] = g[id][i - 1];
for (int j = head[i]; j; j = nxt[j])
if (!inq[tid[j]] && to[j] >= st && s - twd[j] >= 0)
g[id][i] =
max(g[id][i], g[id][to[j]] +
dp(tid[j], to[j], i, min(tsd[j], s - twd[j])) +
tvd[j]);
}
inq[id] = 0;
return ret = g[id][en];
}
int main() {
scanf("%d%d", &n, &S);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d%d", &in, &out, &si, &vi, &wi);
addedge(out, in, si, vi, wi, i);
}
printf("%d", dp(0, 0, 1000, S));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXS = 105;
const int MAXN = 55;
const int INF = 1e9;
string str;
int n;
int dp[MAXS][MAXN][2][2];
int dir[2];
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
dir[0] = -1;
dir[1] = 1;
for (int i = 0; i < MAXS; i++)
for (int j = 0; j < MAXN; j++)
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++) dp[i][j][k][l] = -INF;
dp[0][0][0][0] = dp[0][0][0][1] = 0;
cin >> str >> n;
for (int i = 0; i < str.length(); i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
if (str[i] == 'T') {
dp[i + 1][j][k ^ 1][l] =
max(dp[i + 1][j][k ^ 1][l], dp[i][j][k][l]);
dp[i + 1][j + 1][k][l] =
max(dp[i + 1][j + 1][k][l], dp[i][j][k][l] + dir[k ^ l]);
} else {
dp[i + 1][j][k][l] =
max(dp[i + 1][j][k][l], dp[i][j][k][l] + dir[k ^ l]);
dp[i + 1][j + 1][k ^ 1][l] =
max(dp[i + 1][j + 1][k ^ 1][l], dp[i][j][k][l]);
}
}
}
}
}
int best = 0;
for (int i = n; i >= 0; i -= 2) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
best = max(best, dp[str.length()][i][j][k]);
}
}
}
cout << best << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int N, a, b, c;
int main() {
cin >> N >> a >> b >> c;
long long int ans = 0, maxx;
maxx = N / a;
if (N >= b) {
ans = (N - b) / (b - c) + 1;
N -= ans * (b - c);
}
ans += N / a;
maxx = max(maxx, ans);
printf("%lld\n", maxx);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long p, k;
cin >> p >> k;
long long res[1000] = {0};
res[0] += p;
long long a[1000];
int q = 0;
while (p != 0) {
if (p > 0)
a[q] = -p / k;
else
a[q] = -(p - k + 1) / k;
p = a[q++];
}
for (int i = 0; i < q; i++) res[i + 1] += a[i], res[i] += a[i] * k;
while (res[q] == 0) --q;
cout << q + 1 << endl;
for (int i = 0; i < q + 1; i++) cout << res[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, id;
long long weight;
};
const int N = 3e5 + 5;
vector<edge> G[N];
vector<pair<int, int>> T[N];
long long dist[N];
long long id[N];
int n, m, k;
set<int> ans;
void dfs(int v, int p) {
for (auto ed : T[v]) {
if (ed.first == p) continue;
dfs(ed.first, v);
if (m - (int)ans.size() > k) ans.insert(ed.second);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
G[u].push_back({v, i, w});
G[v].push_back({u, i, w});
}
set<pair<long long, int>> Q;
fill(dist, dist + N, 1LL << 60);
dist[1] = 0;
Q.emplace(0, 1);
set<int> used_ids;
while (!Q.empty()) {
long long w;
int v;
tie(w, v) = *Q.begin();
Q.erase(Q.begin());
for (auto ed : G[v]) {
if (w + ed.weight < dist[ed.to]) {
Q.erase(make_pair(dist[ed.to], ed.to));
dist[ed.to] = w + ed.weight;
Q.emplace(dist[ed.to], ed.to);
id[ed.to] = ed.id;
}
}
}
for (int i = 2; i <= n; ++i) {
used_ids.insert(id[i]);
}
for (int v = 1; v <= n; ++v) {
for (auto& e : G[v]) {
if (used_ids.count(e.id)) {
T[v].emplace_back(e.to, e.id);
} else {
if (v < e.to) ans.insert(e.id);
}
}
}
dfs(1, 1);
cout << m - (int)ans.size() << "\n";
for (int i = 1; i <= m; ++i) {
if (!ans.count(i)) cout << i << " ";
}
cout << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
long long n, k;
void solve() {
read(n, k);
long long sum = 0, invariant = 0;
for (int i = 0; i < k; ++i) {
long long a, b;
read(a, b);
sum += b;
invariant = (invariant + a * b) % n;
}
if (sum < n) {
prn(1);
return;
}
if (sum > n) {
prn(-1);
return;
}
if (invariant != (n * (n + 1) / 2) % n) {
prn(-1);
return;
}
prn(1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
| 9 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;
using point = pair<double, double>;
const int maxn = 410000;
point P[maxn], u;
inline double angle(point p) {
return atan2(u.first - p.first, u.second - p.second);
}
inline double dist(point a, point b) {
double dx = a.first - b.first;
double dy = a.second - b.second;
return sqrt(dx * dx + dy * dy);
}
inline point operator+ (point a, point b) {
return make_pair(a.first + b.first, a.second + b.second);
}
inline point operator- (point a, point b) {
return make_pair(a.first - b.first, a.second - b.second);
}
inline point operator* (point a, double p) {
return make_pair(a.first * p, a.second * p);
}
int main() {
//freopen("in.txt", "r", stdin);
int n, H;
scanf("%d %d", &n, &H);
for (int i = 1; i <= n; ++i)
scanf("%lf %lf", &P[i].first, &P[i].second);
u.first = P[n].first;
u.second = P[n].second + H;
double ans = dist(P[n - 1], P[n]);
double alpha = angle(P[n - 1]);
for (int i = n - 1; i >= 2; --i) {
point a = P[i - 1], b = P[i];
if (angle(a) > angle(b))
swap(a, b);
point vector = b - a;
double L = 0, R = 1;
for (int j = 0; j < 50; ++j) {
double M = (L + R) / 2;
auto mid = a + vector * M;
if (angle(mid) < alpha)
L = M;
else
R = M;
}
ans += dist(a, b) * (1 - L);
alpha = max(alpha, angle(b));
}
printf("%.12f\n", ans);
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6;
const long long M = 1e9 + 7;
int s[N + 5];
long long cpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = a * ans % M;
a = a * a % M;
b >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int l = 1; l <= t; l++) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> s[i];
int p = 0;
if (m != 1)
while (pow(m, p) <= N) p += 1;
else
p = N;
sort(s + 1, s + 1 + n, greater<int>());
s[0] = s[1];
long long ans = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
long long tmp = s[i - 1] - s[i] < p ? cpow(m, s[i - 1] - s[i]) : N;
cnt = min(N, cnt * tmp);
if (cnt > 0) {
cnt -= 1;
ans = (ans + M - cpow(m, s[i])) % M;
} else {
cnt += 1;
ans = (ans + cpow(m, s[i])) % M;
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
int ans[N];
int main() {
scanf("%d", &n);
for (int i = n; i > 1; i -= 2) {
ans[i] = i - 1;
ans[i - 1] = i;
}
if (n & 1) {
ans[1] = 1;
}
for (int i = 1; i <= n; ++i) {
printf("%d%c", ans[i], " \n"[i == n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1510;
struct Node {
int x, y, id;
Node operator-(const Node &b) const { return (Node){x - b.x, y - b.y, 0}; }
bool operator<(const Node &b) const {
return x < b.x || (x == b.x && y < b.y);
}
} a[N], cur;
long long cross(const Node &a, const Node &b) {
return (long long)a.x * b.y - (long long)a.y * b.x;
}
bool cmp(const Node &a, const Node &b) { return cross(a - cur, b - cur) < 0; }
int n, sz[N], ans[N];
vector<int> G[N];
void dfs0(int u, int fa = 0) {
sz[u] = 1;
for (int v : G[u])
if (v != fa) {
dfs0(v, u);
sz[u] += sz[v];
}
}
void dfs(int u, int l, int r, int fa = 0) {
int p = l + 1, nw = l;
for (int i = l + 1; i <= r; i++)
if (a[nw] < a[i]) nw = i;
if (nw != l) swap(a[nw], a[l]);
ans[a[l].id] = u;
cur = a[l];
sort(a + l + 1, a + r + 1, cmp);
for (int v : G[u])
if (v != fa) {
dfs(v, p, p + sz[v] - 1, u);
p += sz[v];
}
}
int main() {
scanf("%d", &n);
for (int u, v, i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].id = i;
}
dfs0(1);
dfs(1, 1, n);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[26];
char s[100010];
long long sum[100010], ans;
vector<int> v[26];
int main() {
int i, j, l, n;
for (i = 0; i < 26; i++) cin >> a[i];
cin >> s;
n = strlen(s);
for (i = 0; i < n; i++) {
sum[i] = a[s[i] - 'a'];
sum[i] += sum[i - 1];
v[s[i] - 'a'].push_back(i);
}
for (i = 0; i < 26; i++) {
map<long long, int> mymap;
for (j = 0; j < (int)v[i].size(); j++) {
l = v[i][j];
ans += mymap[sum[l - 1]];
mymap[sum[l]]++;
}
mymap.clear();
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int q, w, e;
cin >> q >> w >> e;
if (q == 0 && w == 0) {
cout << 0;
return 0;
}
int uu = gcd(q, w);
uu = q * w / uu;
cout << e / uu;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int toint(string s) {
int first = 0;
int k = (int)pow(10, (double)s.length() - 1);
for (int i = 0; i < (int)s.length(); i++) {
first += (s[i] - '0') * k;
k /= 10;
}
return first;
}
string tostr(int first) {
if (first == 0) {
return "0";
}
string s = "";
bool f = first < 0;
first = abs(first);
while (first != 0) {
s += (first % 10) + '0';
first /= 10;
}
string t = "";
if (f) {
t = "-";
}
for (int i = s.length() - 1; i >= 0; i--) {
t += s[i];
}
return t;
}
int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int factorial(int first) {
int sum = 1;
for (long long i = 1; i <= first; i++) {
sum *= i;
}
return sum;
}
bool pr(int n) {
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
inline void out(int mas[], int s) {
for (int i = 0; i < s; i++) {
cout << mas[i] << endl;
}
}
int sum(int n) {
int first = 0;
while (n) {
first += n % 10;
n /= 10;
}
return first;
}
inline int nxt() {
int first;
scanf("%d", &first);
return first;
}
int main() {
string s, s1;
cin >> s >> s1;
int n = nxt();
vector<pair<string, string> > mas(n);
for (int i = 0; i < n; i++) cin >> mas[i].first >> mas[i].second;
cout << s << " " << s1 << endl;
for (int i = 0; i < n; i++) {
if (s == mas[i].first)
s = mas[i].second;
else if (s1 == mas[i].first)
s1 = mas[i].second;
else if (s == mas[i].second)
s = mas[i].first;
else if (s1 == mas[i].second)
s1 = mas[i].first;
cout << s << " " << s1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rnd(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 300000;
const int MAXM = 300000;
const int MAXCOMP = MAXN;
int n, m, nspecial;
bool isspecial[MAXN];
int vgain[MAXN];
int e[MAXM][2], ecost[MAXM];
long long ans[MAXN];
vector<int> adj[MAXN];
int comp[MAXN], ncomp;
int stck[MAXN], nstck;
int id[MAXN], mnid[MAXN], nid;
long long compgain[MAXCOMP];
vector<pair<int, int>> compadj[MAXCOMP];
int compcnt[MAXCOMP];
void tarjan(int at, int parid) {
id[at] = mnid[at] = nid++;
stck[nstck++] = at;
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int eid = adj[at][i];
if (eid == parid) continue;
int to = e[eid][0] ^ e[eid][1] ^ at;
if (id[to] == -1) {
tarjan(to, eid);
mnid[at] = min(mnid[at], mnid[to]);
} else if (comp[to] == -1) {
mnid[at] = min(mnid[at], id[to]);
}
}
if (mnid[at] == id[at]) {
while (comp[at] == -1) comp[stck[--nstck]] = ncomp;
++ncomp;
}
}
int subtreecnt[MAXCOMP];
long long subtreegain[MAXCOMP];
long long dpdown[MAXCOMP];
long long dpup[MAXCOMP];
long long compans[MAXCOMP];
void dfsdown(int at, int par) {
subtreecnt[at] = compcnt[at];
subtreegain[at] = compgain[at];
dpdown[at] = compgain[at];
for (int i = (0); i < (((int)(compadj[at]).size())); ++i) {
int to = compadj[at][i].first, cost = compadj[at][i].second;
if (to == par) continue;
dfsdown(to, at);
subtreecnt[at] += subtreecnt[to];
subtreegain[at] += subtreegain[to];
if (subtreecnt[to] == 0)
dpdown[at] += subtreegain[to];
else
dpdown[at] += max(0LL, dpdown[to] - cost);
}
}
void dfsup(int at, int par, int parcost) {
if (par == -1) {
dpup[at] = 0;
} else {
long long dppar = dpdown[par] + dpup[par] -
(subtreecnt[at] == 0 ? subtreegain[at]
: max(0LL, dpdown[at] - parcost));
if (subtreecnt[at] == 0)
dpup[at] = dppar;
else
dpup[at] = max(0LL, dppar - parcost);
}
for (int i = (0); i < (((int)(compadj[at]).size())); ++i) {
int to = compadj[at][i].first, cost = compadj[at][i].second;
if (to == par) continue;
dfsup(to, at, cost);
}
}
void solve() {
for (int i = (0); i < (m); ++i)
for (int j = (0); j < (2); ++j) adj[e[i][j]].push_back(i);
nid = ncomp = nstck = 0;
for (int i = (0); i < (n); ++i) comp[i] = id[i] = -1;
tarjan(0, -1);
for (int i = (0); i < (n); ++i) assert(comp[i] != -1);
for (int i = (0); i < (ncomp); ++i) compgain[i] = 0, compcnt[i] = 0;
for (int i = (0); i < (n); ++i) {
int c = comp[i];
compgain[c] += vgain[i];
compcnt[c] += isspecial[i] ? 1 : 0;
}
for (int i = (0); i < (m); ++i) {
int a = comp[e[i][0]], b = comp[e[i][1]];
if (a == b) continue;
compadj[a].push_back(make_pair(b, ecost[i])),
compadj[b].push_back(make_pair(a, ecost[i]));
}
int comproot = -1;
for (int i = (0); i < (ncomp); ++i)
if (compcnt[i] > 0) {
comproot = i;
break;
}
assert(comproot != -1);
dfsdown(comproot, -1);
dfsup(comproot, -1, 0);
for (int i = (0); i < (ncomp); ++i) compans[i] = dpdown[i] + dpup[i];
for (int i = (0); i < (n); ++i) ans[i] = compans[comp[i]];
}
void run() {
scanf("%d%d%d", &n, &m, &nspecial);
for (int i = (0); i < (n); ++i) isspecial[i] = false;
for (int i = (0); i < (nspecial); ++i) {
int x;
scanf("%d", &x);
--x;
isspecial[x] = true;
}
for (int i = (0); i < (n); ++i) scanf("%d", &vgain[i]);
for (int i = (0); i < (m); ++i) scanf("%d", &ecost[i]);
for (int i = (0); i < (m); ++i)
for (int j = (0); j < (2); ++j) scanf("%d", &e[i][j]), --e[i][j];
solve();
for (int i = (0); i < (n); ++i) {
if (i != 0) printf(" ");
printf("%lld", ans[i]);
}
puts("");
}
int main() {
run();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <typename T>
void print(vector<T> v) {
for (T i : v) cout << i << " ";
cout << '\n';
}
template <typename T>
void print(vector<vector<T>>& v) {
for (vector<T>& vv : v) {
for (T& i : vv) cout << i << " ";
cout << '\n';
}
}
template <typename T>
void read(vector<T>& v) {
for (T& i : v) cin >> i;
}
template <typename T>
void read(T&& t) {
cin >> t;
}
template <typename T, typename... Args>
void read(T&& t, Args&&... args) {
cin >> t;
read(forward<Args>(args)...);
}
template <typename T>
void print(T&& t) {
cout << t << '\n';
}
template <typename T, typename... Args>
void print(T&& t, Args&&... args) {
cout << t << " ";
print(forward<Args>(args)...);
}
template <typename T>
vector<T>& operator--(vector<T>& v) {
for (auto& i : v) --i;
return v;
}
template <typename T>
vector<T>& operator++(vector<T>& v) {
for (auto& i : v) ++i;
return v;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& i : v) os << i << ' ';
return os;
}
long double pie = 3.141592653589793238462643383279502884197169399;
long long mod = 1e9 + 7;
bool isprime(long long n) {
if (n <= 1) {
return false;
}
if (n <= 3) {
return true;
}
if (n % 2 == 0 || n % 3 == 0) {
return false;
}
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
long long modInverse(long long n, long long mod) {
return binpow(n, mod - 2, mod);
}
long long comb(long long n, long long r, long long p, vector<long long>& fac) {
if (r == 0 or n == r) return 1;
if (r > n) return 0;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
set<long long> divisors(long long n) {
set<long long> s;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
s.insert(i);
s.insert(n / i);
}
}
return s;
}
long long add(long long a, long long b, long long mod) {
a = a % mod;
b = b % mod;
return (((a + b) % mod) + mod) % mod;
}
long long mul(long long a, long long b, long long mod) {
a = a % mod;
b = b % mod;
return (((a * b) % mod) + mod) % mod;
}
long long sub(long long a, long long b, long long mod) {
a = a % mod;
b = b % mod;
return (((a - b) % mod) + mod) % mod;
}
map<long long, long long> primeFactors(long long n) {
map<long long, long long> m;
while (n % 2 == 0) {
m[2]++;
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
m[i]++;
n = n / i;
}
}
if (n > 2) m[n]++;
return m;
}
long long C(long long n, long long r) {
long long res = 1;
for (long long i = 0; i < r; i++) {
res = res * (n - i) / (i + 1);
}
return res;
}
long long toint(string s) {
long long num = 0;
for (long long i = 0; i < s.size(); i++) {
num = num * 10 + s[i] - '0';
}
return num;
}
long long sumstring(string s) {
long long sum = 0;
for (long long i = 0; i < s.size(); i++) {
sum += (s[i] - '0');
}
return sum;
}
long long sumdigit(long long n) {
long long sum = 0;
while (n) {
long long rem = n % 10;
sum += rem;
n /= 10;
}
return sum;
}
string tobinary(long long x) {
string a;
while (x > 0) {
a += (x % 2) + '0';
x /= 2;
}
reverse(begin(a), end(a));
return a;
}
long long todecimal(string x) {
long long sum = 0;
long long n = x.size();
long long j = 0;
for (long long i = n - 1; i >= 0; i--) {
if (x[i] == '1') {
sum += (1LL << j);
}
j++;
}
return sum;
}
long long ceil(long long n, long long k) { return (n + k - 1) / k; }
bool ispalin(string s) {
long long n = s.size();
for (long long i = 0; i < n; i++) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
bool ispermutation(vector<long long> p) {
sort(begin(p), end(p));
for (long long i = 1; i <= p.size(); i++) {
if (p[i - 1] != i) return false;
}
return true;
}
bool isperfect(long long x) {
long long a = sqrtl(x);
return a * a == x;
}
bool issubsequence(string t, string x) {
long long j = 0;
for (long long i = 0; i < x.size(); i++) {
if (x[i] == t[j]) {
j++;
}
if (j == t.size()) break;
}
return j == t.size();
}
long long power(long long base, long long exponent) {
long long res = 1;
while (exponent) {
if (exponent & 1) {
res = res * base;
}
base *= base;
exponent >>= 1;
}
return res;
}
bool comp(string s1, string s2) {
for (long long i = 0; i < s1.size(); i++) {
if (s1[i] == s2[i]) continue;
return s1[i] < s2[i];
}
return false;
}
double area(double dX0, double dY0, double dX1, double dY1, double dX2,
double dY2) {
double dArea = ((dX1 - dX0) * (dY2 - dY0) - (dX2 - dX0) * (dY1 - dY0)) / 2.0;
return (dArea > 0.0) ? dArea : -dArea;
}
long long C(long long n, long long r, long long mod) {
long long ans = 1;
if (n - r < r) r = n - r;
for (long long i = n; i > n - r; i--) ans = mul(ans, i, mod);
for (long long i = 1; i <= r; i++) ans = mul(ans, modInverse(i, mod), mod);
return ans;
}
struct Cmp {
bool operator()(const array<long long, 2>& l,
const array<long long, 2>& r) const {
if (l[0] == r[0]) return l[1] < r[1];
return l[0] < r[0];
}
};
void loop() {
long long n;
cin >> n;
vector<vector<long long>> adj(n + 1);
vector<long long> indegree(n + 1);
long long total = n;
for (long long i = 1; i <= n; i++) {
long long z;
cin >> z;
for (long long j = 0; j < z; j++) {
long long x;
cin >> x;
indegree[i]++;
adj[x].push_back(i);
}
}
vector<long long> vis(n + 1);
queue<long long> q;
for (long long i = 1; i <= n; i++) {
if (indegree[i] == 0) {
q.push(i);
vis[i] = 1;
}
}
vector<long long> order;
while (q.size()) {
long long x = q.front();
q.pop();
total--;
order.push_back(x);
for (auto i : adj[x]) {
indegree[i]--;
if (indegree[i] == 0) q.push(i);
}
}
if (total) {
print(-1);
return;
} else {
vector<long long> dp(n + 1, 1);
for (auto i : order) {
for (auto j : adj[i]) {
if (j < i) {
dp[j] = max(dp[j], dp[i] + 1);
} else
dp[j] = max(dp[j], dp[i]);
}
}
print(*max_element(begin(dp), end(dp)));
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
loop();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n << ' ';
for (int i = 1; i < n; i++) cout << i << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double Pi = acos(-1);
namespace {
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1;
char s = getchar();
for (; !isdigit(s); s = getchar())
if (s == '-') f = -1;
for (; isdigit(s); s = getchar()) x = (x << 3) + (x << 1) + (s ^ 48);
x *= f;
}
} // namespace
const int N = 1e6 + 5;
long long ksm(long long a, long long b, long long p) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % p;
a = a * a % p;
b >>= 1;
}
return ret;
}
long long eular(long long n) {
long long ans = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ans -= ans / i;
while (n % i == 0) n /= i;
}
}
if (n > 1) ans -= ans / n;
return ans;
}
char s[N], t[N];
int main() {
long long b = 0, n = 0, p;
scanf("%s %s %lld", s, t, &p);
int len = strlen(s);
for (int i = 0; i < len; i++) {
b = (b * 10 + s[i] - '0') % p;
}
len = strlen(t);
long long phi = eular(p);
for (int i = len - 1; i >= 0; i--) {
if (t[i] == '0')
t[i] = '9';
else {
t[i]--;
break;
}
}
if (len < 11) {
for (int i = 0; i < len; i++) n = n * 10 + t[i] - '0';
if (n > phi) n %= phi;
} else {
for (int i = 0; i < len; i++) n = (n * 10 + t[i] - '0') % phi;
n += phi;
}
long long ans = (b - 1) * ksm(b, n, p) % p;
if (ans <= 0) ans += p;
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int INF = 1000000000 + 1e8;
const long long LINF = 2000000000000000000;
int n;
vector<int> a, b, sz, pos, head, depth, p;
vector<vector<int>> g;
int cur_pos = 0;
const int N = 1e5 + 1010;
long long t[4 * N];
void build(int v, int vl, int vr) {
if (vl == vr) {
t[v] = {a[vl]};
return;
}
int vm = (vl + vr) / 2;
build(2 * v + 1, vl, vm);
build(2 * v + 2, vm + 1, vr);
t[v] = t[2 * v + 1] + t[2 * v + 2];
}
long long query(int v, int vl, int vr, int l, int r) {
if (r < vl || vr < l) return 0;
if (vl >= l && vr <= r) return t[v];
int vm = (vl + vr) / 2;
return query(2 * v + 1, vl, vm, l, r) + query(2 * v + 2, vm + 1, vr, l, r);
}
void modify(int v, int vl, int vr, int pos, int val) {
if (vl == vr) {
t[v] = val;
return;
}
int vm = (vl + vr) / 2;
if (pos <= vm) {
modify(2 * v + 1, vl, vm, pos, val);
} else
modify(2 * v + 2, vm + 1, vr, pos, val);
t[v] = t[2 * v + 1] + t[2 * v + 2];
}
long long tree_query(int l, int r) { return query(0, 0, n - 1, l, r); }
void dfs_sz(int v, int pr = -1) {
sz[v] = 1;
p[v] = pr;
for (auto &to : g[v])
if (to != pr) {
depth[to] = depth[v] + 1;
dfs_sz(to, v);
sz[v] += sz[to];
if (sz[to] > sz[g[v][0]]) swap(g[v][0], to);
}
}
void dfs_hld(int v) {
pos[v] = cur_pos++;
for (auto to : g[v])
if (to != p[v]) {
head[to] = (to == g[v][0] ? head[v] : to);
dfs_hld(to);
}
}
long long query(int u, int v) {
long long ans = 0;
for (; head[u] != head[v]; v = p[head[v]]) {
if (depth[head[u]] > depth[head[v]]) swap(u, v);
ans += tree_query(pos[head[v]], pos[v]);
}
if (depth[u] > depth[v]) swap(u, v);
ans += tree_query(pos[u], pos[v]);
return ans;
}
void tmodify(int v, int x) { modify(0, 0, n - 1, pos[v], x); }
void init() {
sz.resize(n);
pos.resize(n);
head.resize(n);
depth.resize(n);
p.resize(n);
b.resize(n);
dfs_sz(0);
dfs_hld(0);
for (int i = 0; i < n; i++) b[pos[i]] = a[i];
a = b;
build(0, 0, n - 1);
}
void solve() {
int q;
cin >> n >> q;
g.resize(n);
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = abs(a[i]);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
init();
while (q--) {
int type;
cin >> type;
if (type == 1) {
int v, c;
cin >> v >> c;
v--;
c = abs(c);
tmodify(v, c);
} else {
int u, v;
cin >> u >> v;
u--, v--;
long long sum = 2 * query(u, v) - query(u, u) - query(v, v);
cout << sum << '\n';
}
}
}
int main() {
srand(time(0));
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tst = 1;
while (tst--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k, x, y;
cin >> n >> m;
k = n;
for (int i = 0; i < m; i++) {
cin >> x >> y;
if (x < y) swap(x, y);
k = min(k, x - y + 1);
}
cout << k << "\n";
for (int i = 1; i <= n; i += k) {
for (int j = i; j < i + k && j <= n; j++) cout << j - i << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long next() {
long long x;
cin >> x;
return x;
}
const long long inf = 2e18, mod = 1e9 + 7, MaxN = 2750132;
const int intf = 1e9;
const double PI = 3.141592653589, eps = 1e-6;
int n, m, start, ans;
bool cycle = false;
vector<vector<int> > g;
vector<int> was;
vector<bool> used;
vector<int> path;
void dfs(int u) {
was[u] = 1;
for (auto v : g[u]) {
if (was[v] == 1) cycle = true;
if (!was[v]) {
dfs(v);
}
}
was[u] = 2;
}
void dfs1(int u) {
used[u] = true;
path.push_back(u);
if (u == ans) {
for (int i = 0; i < path.size(); i++) {
if (path[i] >= n)
cout << path[i] - n + 1 << ' ';
else
cout << path[i] + 1 << ' ';
}
}
for (auto v : g[u]) {
if (!used[v]) {
dfs1(v);
}
}
path.pop_back();
}
int main() {
cout.precision(20);
ios_base::sync_with_stdio(false);
cin >> n >> m;
g = vector<vector<int> >(2 * n);
was = vector<int>(2 * n, 0);
for (int i = 0; i < n; i++) {
int c = next();
for (int j = 0; j < c; j++) {
int x = next() - 1;
g[i].push_back(x + n);
g[i + n].push_back(x);
}
}
start = next() - 1;
ans = -1;
dfs(start + n);
for (int i = 0; i < n; i++)
if (was[i] && !g[i].size()) {
ans = i;
break;
}
if (ans == -1) {
if (cycle)
cout << "Draw\n";
else
cout << "Lose\n";
return 0;
}
used = vector<bool>(2 * n, false);
cout << "Win\n";
dfs1(start + n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 20;
const int maxc = 10;
const int maxm = (1 << maxc) + 20;
const int mod = 998244353;
int res[maxn], dp[maxn][maxn], pd[2][maxn][maxm], cnt[maxn], pw[maxn];
int a[maxn], inv[maxn];
inline void mkay(int &a) {
if (a >= mod)
a -= mod;
else if (a < 0)
a += mod;
}
int bpw(int a, int b) {
if (!b) return 1;
int x = bpw(a, b / 2);
x = 1LL * x * x % mod;
if (b & 1) x = 1LL * x * a % mod;
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pw[0] = 0;
for (int i = 1; i < maxn; i++) {
pw[i] = 1LL * (pw[i - 1] + 1) * 2 % mod;
mkay(pw[i] -= 1);
inv[i] = 1LL * pw[i] * bpw(pw[i - 1], mod - 2) % mod;
}
int n, c;
cin >> n >> c;
for (int i = 1; i <= n; i++) cin >> a[i], a[i]--;
if (c <= maxc) {
pd[0][0][0] = 1;
for (int i = 0; i < n; i++) {
int x = (i & 1);
for (int j = 0; j <= i / c + 3; j++)
for (int mask = 0; mask < (1 << c); mask++) pd[x ^ 1][j][mask] = 0;
for (int j = 0; j <= i / c; j++) {
for (int mask = 0; mask < (1 << c) - 1; mask++) {
mkay(pd[x ^ 1][j][mask | (1 << a[i + 1])] += pd[x][j][mask]);
mkay(pd[x ^ 1][j][mask] += pd[x][j][mask]);
}
mkay(pd[x ^ 1][j + 1][0] += pd[x ^ 1][j][(1 << c) - 1]);
}
}
for (int j = 0; j <= n; j++) {
int s = 0;
for (int mask = 0; mask < (1 << c) - 1; mask++)
mkay(s += pd[n & 1][j][mask]);
if (!j) mkay(s -= 1);
cout << s << " ";
}
cout << endl;
return 0;
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
memset(cnt, 0, sizeof cnt);
int tmp = c - 1, shit = 1;
for (int k = i - 1; k >= 0; k--) {
int x = a[k + 1];
if (x != a[i]) {
cnt[x]++;
if (cnt[x] == 1)
tmp--;
else
shit = 1LL * shit * inv[cnt[x]] % mod;
}
if (!tmp)
for (int j = 1; j <= k / c + 1; j++)
dp[i][j] = (dp[i][j] + 1LL * dp[k][j - 1] * shit) % mod;
}
}
for (int i = 0; i <= n; i++) {
memset(cnt, 0, sizeof cnt);
for (int k = i + 1; k <= n; k++) cnt[a[k]]++;
int all = pw[n - i];
mkay(all += 1);
int bad = 1;
for (int i = 0; i < c; i++) bad = 1LL * bad * pw[cnt[i]] % mod;
mkay(all -= bad);
for (int j = 0; j <= i / c; j++) mkay(res[j] += 1LL * dp[i][j] * all % mod);
}
mkay(res[0] -= 1);
for (int i = 0; i <= n; i++) cout << res[i] << " ";
cout << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000000 + 7;
int64_t x, y, l, r, pp;
set<int64_t> s;
int64_t xx, yy, aa = 0;
int main() {
cin >> x >> y >> l >> r;
vector<int64_t> a, b;
int64_t i = 0, j = 0, num = 1, k;
for (num = 1; num; num *= num > r / x ? 0 : x) a.push_back(num);
for (num = 1; num; num *= num > r / y ? 0 : y) b.push_back(num);
for (k = 0; k < a.size(); k++) {
for (pp = 0; pp < b.size(); pp++) {
s.insert(a[k] + b[pp]);
}
}
yy = l - 1;
for (auto e : s) {
if (l <= e && r >= e) aa = max(aa, e - yy - 1), yy = e;
}
cout << max(aa, r - yy);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
Solution(vector<pair<long long, long long>>& fences, long long a, long long b,
long long sy)
: segs(fences), pl(a), pr(b), py(sy) {
int n = segs.size();
sums.resize(n + 1);
for (int i = 0; i < n; ++i) {
sums[i + 1] = sums[i] + segs[i].second - segs[i].first;
}
}
long double query(long long x, long long y) {
long double fl = x + ((long double)y * (pl - x) / (y - py));
long double fr = x + ((long double)y * (pr - x) / (y - py));
int l = getGE(fl);
int r = getGE(fr) - 1;
long double res = 0;
res += (r >= 0 ? sums[r] : 0) - (l >= 0 ? sums[l] : 0);
if (l - 1 >= 0) {
res += max(0.0L, (long double)segs[l - 1].second -
max(fl, (long double)segs[l - 1].first));
}
if (r >= 0) {
res += max(0.0L, min(fr, (long double)segs[r].second) -
(long double)segs[r].first);
}
res *= (long double)(y - py) / y;
return res;
}
private:
long long pl;
long long pr;
long long py;
vector<pair<long long, long long>> segs;
vector<long long> sums;
int getGE(long double x) {
auto it =
lower_bound(segs.begin(), segs.end(), make_pair((long long)x, -1LL));
int i = it - segs.begin();
i = max(i - 2, 0);
while (i < segs.size()) {
if (segs[i].first >= x) {
return i;
}
++i;
}
return i;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int sy, a, b;
cin >> sy >> a >> b;
int n;
cin >> n;
vector<pair<long long, long long>> segs;
segs.reserve(n);
for (int i = 0, l = 0, r = 0; i < n; ++i) {
cin >> l >> r;
segs.emplace_back(l, r);
}
Solution sol(segs, a, b, sy);
int q;
cin >> q;
cout << fixed << setprecision(15);
for (int i = 0, x = 0, y = 0; i < q; ++i) {
cin >> x >> y;
cout << sol.query(x, y) << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& s, vector<T> const& v) {
s << '{';
for (int i = 0; i < int(v.size()); i++) s << (i ? "," : "") << v[i];
return s << '}';
}
template <typename S, typename T>
ostream& operator<<(ostream& s, pair<S, T> const& p) {
return s << '(' << p.first << ',' << p.second << ')';
}
int N;
string S, T;
bool earlyfail() {
string s = S, t = T;
sort(begin(s), end(s));
sort(begin(t), end(t));
return s != t;
}
string shift(string const& t, int x) {
string a;
for (int n = 0; n < int(N); n++) {
if (n < x)
a.push_back(t[N - 1 - n]);
else
a.push_back(t[n - x]);
}
return a;
}
void apply(string& t, vector<int>& ops, int x) {
ops.push_back(x);
t = shift(t, x);
}
bool sv() {
cin >> N >> S >> T;
if (earlyfail()) return false;
vector<int> ops;
string s = S;
for (char c : T) {
int p = 0;
while (s[p] != c) ++p;
apply(s, ops, N - 1 - p);
apply(s, ops, 1);
apply(s, ops, N);
}
cout << ops.size() << endl;
for (int i = 0; i < int(ops.size()); i++) {
if (i) cout << ' ';
cout << ops[i];
}
cout << endl;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
if (!sv()) puts("-1");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void splitstr(const string &s, vector<string> &v) {
istringstream in(s);
copy(istream_iterator<string>(in), istream_iterator<string>(),
back_inserter(v));
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
err(++it, args...);
}
const int maxn = 20005;
const long long INF = (1e9) + 7;
const long double EPS = 1e-8;
vector<pair<pair<int, int>, int> > a[maxn];
vector<int> ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < (int)n; i++) {
int x, y;
cin >> x >> y;
int p = y / 1300;
a[p].push_back(make_pair(make_pair(x, y), i + 1));
}
for (int i = 0; i < (int)maxn; i++) sort(a[i].begin(), a[i].end());
for (int i = 0; i < (int)maxn; i++)
for (int j = 0; j < (int)a[i].size(); j++) ans.push_back(a[i][j].second);
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a, b, c, d, e, f;
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &f);
int one = n - c - e;
if (one > b) one = b;
n -= one;
int two = n - e;
if (two > d) two = d;
n -= two;
printf("%d %d %d\n", one, two, n);
}
| 1 |
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
long long n, k, m;
deque<pair<int, int> > bus;
int main(int argc, char** argv) {
scanf("%lld %lld %lld", &n, &k, &m);
int a;
long long tot = 0;
pair<int, int> cur = pair<int, int>(-1, -1);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
tot++;
if (a != cur.first) {
if (cur.first != -1) bus.push_back(cur);
cur = pair<int, int>(a, 1);
} else {
cur.second++;
if (cur.second == k) {
tot -= k;
if (!bus.empty()) {
cur = bus.back();
bus.pop_back();
} else
cur = pair<int, int>(-1, -1);
}
}
}
if (cur.first != -1 && cur.second != k) bus.push_back(cur);
int sz = bus.size();
long long del = 0;
while (!bus.empty()) {
pair<int, int> b = bus.back(), f = bus.front();
if (b.first != f.first) break;
int add = b.second + f.second;
if (add >= k) del += k;
if (add != k) break;
bus.pop_back();
if (!bus.empty()) bus.pop_front();
}
if (bus.empty())
printf("%lld\n", (m & 1) * tot);
else {
if ((sz & 1) && (int)bus.size() == 1) {
long long rem = bus.back().second, mid = (rem * m) % k;
printf("%lld\n", (mid) ? tot - rem + mid : 0);
} else
printf("%lld\n", m * tot - (m - 1) * del);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int main() {
int n;
cin >> n;
cout << n + 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
const long double PI = 2 * acos(0.0);
const long double eps = 1e-15;
const int infi = 1e9;
const long long Linfi = (long long)1e18;
const long long MOD = 1000000007;
struct edge {
int st, en, cost;
edge() {}
edge(int _st, int _en, int _cost) {
st = _st;
en = _en;
cost = _cost;
}
};
int n, m, u, v, c, ok = 0;
edge E[100005];
vector<int> group[100005];
vector<pair<int, int> > adj[100005];
int color[100005], xet[100005];
void DFS(int u, int c) {
color[u] = c;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].second;
int cost = adj[u][i].first;
if (color[v] < 0) {
if (cost == 1)
DFS(v, c);
else
DFS(v, 1 - c);
} else {
if (cost == 1 && color[u] != color[v]) ok = 1;
if (cost == 0 && color[u] == color[v]) ok = 1;
}
}
}
void solve() {
int dem = 0;
memset(color, -1, sizeof(color));
for (int i = 1; i <= n; i++)
if (color[i] < 0) {
dem++;
DFS(i, 0);
}
if (ok) {
cout << 0 << endl;
return;
}
long long ans = 1;
for (int i = 1; i <= dem - 1; i++) ans = (ans * 2) % MOD;
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v >> c;
E[i] = edge(u, v, c);
adj[u].push_back(pair<int, int>(c, v));
adj[v].push_back(pair<int, int>(c, u));
xet[u] = 1;
xet[v] = 1;
}
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[610][610];
int b[51] = {0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1,
0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0};
int T, n, m;
int main() {
scanf("%d", &T);
for (int t = 1; t <= T; t++) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
if (t > 50) {
int num = 0;
for (int i = 1; i <= m; i++)
if (abs(a[n][i] - a[1][i]) >= 20) num++;
for (int i = 1; i <= m; i++)
if (abs(a[n / 2][i] - a[n / 2 + 1][i] >= 20)) num++;
if (num >= m / 2)
printf("NO\n");
else
printf("YES\n");
} else {
if (b[t] == 0)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 1000;
int n;
vector<pair<string, int>> in, hard, easy;
int cnt[2];
bool done[MAXN], done_in[MAXN], exist[MAXN];
int ide, idr;
vector<string> ans;
void move(string A, string B) { ans.push_back(string("move ") + A + ' ' + B); }
void go_easy(pair<string, int> qp) {
if (qp.second == 0) {
while (done[idr]) idr++;
assert(idr <= n);
move(qp.first, to_string(idr));
done[idr] = true;
} else {
while (done[ide]) ide++;
assert(ide <= cnt[1]);
move(qp.first, to_string(ide));
done[ide] = true;
}
}
string temp_name = "jizz";
string new_string() {
string res = "";
for (int i = 0; i < 6; i++) res += rand() % 26 + 'a';
return res;
}
void fix_hard() {
if (((int)(hard).size()) == 0) return;
vector<pair<string, int>> exam, regu;
for (auto p : hard)
if (p.second == 0)
regu.push_back(p);
else
exam.push_back(p);
int ae = 1, ar = cnt[1] + 1;
while (ae <= cnt[1] && exist[ae]) ae++;
while (ar <= n && exist[ar]) ar++;
if (ae > cnt[1] && ar > n) {
assert(((int)(regu).size()) > 0 && ((int)(exam).size()) > 0);
assert(((int)(regu).size()) == ((int)(exam).size()));
move(regu[0].first, temp_name);
ae = stoi(regu[0].first);
move(exam[0].first, to_string(ae));
ar = stoi(exam[0].first);
for (int i = 1; i < ((int)(exam).size()); i++) {
move(regu[i].first, to_string(ar));
ae = stoi(regu[i].first);
move(exam[i].first, to_string(ae));
ar = stoi(exam[i].first);
}
move(temp_name, to_string(ar));
} else {
(void)0;
vector<int> eid, rid;
while (ae <= cnt[1]) {
(void)0;
if (!exist[ae]) eid.push_back(ae);
ae++;
}
while (ar <= n) {
(void)0;
if (!exist[ar]) rid.push_back(ar);
ar++;
}
while (((int)(regu).size()) || ((int)(exam).size())) {
(void)0;
if (((int)(eid).size()) > 0 && ((int)(exam).size()) > 0) {
move(exam.back().first, to_string(eid.back()));
done[eid.back()] = true;
eid.pop_back();
rid.push_back(stoi(exam.back().first));
exam.pop_back();
} else if (((int)(rid).size()) > 0 && ((int)(regu).size()) > 0) {
move(regu.back().first, to_string(rid.back()));
done[rid.back()] = true;
rid.pop_back();
eid.push_back(stoi(regu.back().first));
regu.pop_back();
} else
assert(0);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
char tmp[10];
int type;
scanf("%s%d", tmp, &type);
in.push_back(make_pair(string(tmp), type));
cnt[type]++;
}
sort((in).begin(), (in).end());
while (1) {
auto p = lower_bound((in).begin(), (in).end(), make_pair(temp_name, -1));
if (p == end(in) || p->first != temp_name) break;
temp_name = new_string();
}
ide = 1;
idr = cnt[1] + 1;
for (int i = 1; i <= n; i++) {
auto p = lower_bound((in).begin(), (in).end(), make_pair(to_string(i), -1));
if (p == end(in) || p->first != to_string(i)) continue;
exist[i] = true;
if ((p->second == 1 && i <= cnt[1]) || (p->second == 0 && i > cnt[1])) {
done[i] = true;
done_in[p - begin(in)] = true;
} else {
hard.push_back(*p);
done_in[p - begin(in)] = true;
}
}
for (int i = 0; i < n; i++)
if (!done_in[i]) easy.push_back(in[i]);
fix_hard();
for (auto p : easy) go_easy(p);
printf("%d\n", ((int)(ans).size()));
for (string &second : ans) printf("%s\n", second.c_str());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int k;
string ans;
int sum(int t) {
int r = sqrt(2 * t);
while (r * (r + 1) / 2 > t) r--;
return r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
char curL = 'a';
cin >> k;
if (!k) return cout << 'a' << endl, 0;
while (k) {
int cur = sum(k);
for (int i = 0; i <= cur; i++) ans += curL;
curL++;
k -= cur * (cur + 1) / 2;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &x) {
static char ch;
while (!isdigit(ch = getchar()))
;
x = ch - '0';
while (isdigit(ch = getchar())) x = x * 10 + ch - '0';
}
template <class T>
inline void putint(T x) {
static char buf[15], *tail = buf;
if (!x)
putchar('0');
else {
for (; x; x /= 10) *++tail = x % 10 + '0';
for (; tail != buf; --tail) putchar(*tail);
}
}
inline void invalid() {
puts("no");
exit(0);
}
const int MaxN = 1e6 + 5;
int n, m;
int a[MaxN];
bool vis[MaxN];
std::vector<int> rest;
int pre[MaxN], nxt[MaxN];
int lstsame[MaxN], nxtsame[MaxN];
inline void same_init() {
static int lst[MaxN];
for (int i = 1; i <= m; ++i)
if (a[i]) {
lstsame[i] = lst[a[i]];
lst[a[i]] = i;
}
for (int i = 1; i <= n; ++i) lst[i] = m + 1;
for (int i = m; i >= 1; --i)
if (a[i]) {
nxtsame[i] = lst[a[i]];
lst[a[i]] = i;
}
}
inline int getnew() {
if (rest.empty()) return 0;
int res = *rest.rbegin();
return rest.pop_back(), res;
}
inline void merge(int x, int y) { nxt[x] = nxt[y], pre[nxt[y]] = x; }
inline void solve(int l, int r, int rt) {
if ((r - l) & 1) invalid();
if (l > r) return;
for (int x = l; x <= r; x = nxt[x])
if (a[x] && a[x] != rt) {
if (lstsame[x] >= 1 && lstsame[x] < l) invalid();
if (nxtsame[x] <= m && nxtsame[x] > r) invalid();
}
for (int x = l; x <= r; x = nxt[x])
if (a[x] && lstsame[x] >= l) {
int y = lstsame[x];
solve(nxt[y], pre[x], a[x]);
merge(y, x);
lstsame[nxtsame[x]] = y;
nxtsame[y] = nxtsame[x];
}
int cnt = 0, lim = 0;
for (int x = l; x <= r; x = nxt[x]) cnt += (bool)a[x], ++lim;
lim = (lim >> 1) + 1;
if (cnt > lim) invalid();
if (cnt < lim) {
for (int x = l; x <= r && cnt < lim; x = nxt[x])
if (!a[x]) {
a[x] = getnew();
++cnt;
}
}
for (int x = l; x <= r; x = nxt[x]) {
int y = pre[x], z = pre[y];
while (z >= l) {
if ((!a[x] && a[y] && a[z]) || (a[x] && a[y] && !a[z])) {
a[x] = a[z] = a[x] + a[z];
merge(z, x), x = z;
} else
break;
y = pre[x], z = pre[y];
}
}
for (int x = l; x <= std::min(r + 1, m); x = nxt[x])
if (!a[x]) a[x] = rt;
}
int main() {
read(n), m = (n << 1) - 1;
for (int i = 1; i <= m; ++i) read(a[i]), vis[a[i]] = true;
for (int i = 1; i <= n; ++i)
if (!vis[i]) rest.push_back(i);
for (int i = 0; i <= m + 1; ++i) {
pre[i] = i - 1;
nxt[i] = i + 1;
}
if (a[1] && a[m]) {
if (a[1] != a[m]) invalid();
} else if (a[1] || a[m])
a[1] = a[m] = a[1] + a[m];
else {
if (!rest.empty()) a[1] = a[m] = getnew();
}
same_init();
solve(1, m, 0);
puts("yes");
for (int i = 1; i <= m; ++i) putint(a[i]), putchar(" \n"[i == m]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, tot = 0, j, out = 0, temp;
int a[101];
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
tot += a[i];
}
for (i = 0; i < k; i++) {
temp = 0;
for (j = i; j < n; j += k) {
temp += a[j];
}
if (i == 0) {
out = abs(tot - temp);
} else {
out = (out < abs(tot - temp)) ? abs(tot - temp) : out;
}
}
printf("%d", out);
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline unsigned int getuint() {
char w = getchar();
while (w < '0' || '9' < w) w = getchar();
unsigned int ans = 0;
for (; '0' <= w && w <= '9'; w = getchar()) ans = ans * 10 + w - '0';
return ans;
}
inline unsigned long long getuint64() {
char w = getchar();
while (w < '0' || '9' < w) w = getchar();
unsigned long long ans = 0;
for (; '0' <= w && w <= '9'; w = getchar()) ans = ans * 10 + w - '0';
return ans;
}
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int lcm(int a, int b) { return a * b / gcd(a, b); }
int k;
int depth[500005], queue[500005];
int bfs(int L, int R) {
for (int i = L; i <= R; i++) depth[i] = 0;
depth[queue[1] = R] = 1;
for (int l = 1, r = 1; l <= r; l++) {
for (int x = queue[l], y, i = 1; i <= k; i++)
if (!depth[y = x - x % i]) depth[queue[++r] = y] = depth[x] + 1;
if (queue[l] && !depth[queue[l] - 1])
depth[queue[l] - 1] = depth[queue[l]] + 1;
}
return depth[L] - 1;
}
int main() {
unsigned long long a = getuint64(), b = getuint64();
k = getuint();
int L = 1;
for (int i = 1; i <= k; i++) L = lcm(L, i);
unsigned long long l = b / L, r = a / L;
if (l == r) return printf("%d\n", bfs(b % L, a % L)), 0;
printf("%I64u\n", bfs(b % L, L - 1) + r - l + bfs(0, L - 1) * (r - l - 1) +
bfs(0, a % L));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
enum enum_t { White, Black, Gray };
inline int readInt() {
char c;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
;
bool sign = (c == '-');
if (sign) c = getchar();
int n = c - '0';
while (c = getchar(), c >= '0' && c <= '9') n = 10 * n + c - '0';
return (!sign) ? n : -n;
}
inline long long readLong() {
char c;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
;
bool sign = (c == '-');
if (sign) c = getchar();
long long n = c - '0';
while (c = getchar(), c >= '0' && c <= '9') n = 10 * n + c - '0';
return (!sign) ? n : -n;
}
inline void getInt(int &n) {
char c;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
;
bool sign = (c == '-');
if (sign) c = getchar();
n = c - '0';
while (c = getchar(), c >= '0' && c <= '9') n = 10 * n + c - '0';
if (sign) n = -n;
}
inline void getLong(long long &n) {
char c;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
;
bool sign = (c == '-');
if (sign) c = getchar();
n = c - '0';
while (c = getchar(), c >= '0' && c <= '9') n = 10 * n + c - '0';
if (sign) n = -n;
}
inline string readString() {
char c;
while (c = getchar(), c == ' ' || c == '\n' || c == '\t')
;
string s({c});
while (c = getchar(), c != EOF && c != ' ' && c != '\n' && c != '\t') s += c;
return s;
}
char bufWrite[20];
template <typename T>
inline void writeInt(T x) {
if (x < 0) putchar('-'), x = -x;
char *bufPos = bufWrite;
do {
*bufPos++ = x % 10 + '0';
} while (x /= 10);
do {
putchar(*--bufPos);
} while (bufPos > bufWrite);
}
template <typename T>
inline void printInt(T x, char c = EOF) {
if (x < 0) putchar('-'), x = -x;
char *bufPos = bufWrite;
do {
*bufPos++ = x % 10 + '0';
} while (x /= 10);
do {
putchar(*--bufPos);
} while (bufPos > bufWrite);
if (c != EOF) putchar(c);
}
template <typename T>
inline T gcd(T a, T b) {
while (b != 0) swap(b, a %= b);
return a;
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
inline tuple<T, T, T> extgcd(T a, T b) {
if (!a) return make_tuple(b, 0, 1);
T g, x, y;
tie(g, x, y) = extgcd(b % a, a);
return make_tuple(g, y - (b / a) * x, x);
}
template <typename T>
inline bool bitGet(T x, int bit) {
return T(1) & (x >> bit);
}
template <typename T>
inline void bitSet(T &x, int bit) {
x |= (T(1) << bit);
}
template <typename T>
inline void bitReset(T &x, int bit) {
x &= ~(T(1) << bit);
}
template <typename T>
inline void bitFlip(T &x, int bit) {
x ^= (T(1) << bit);
}
template <typename T>
inline void bitMake(T &x, int bit, bool v) {
x ^= (T(1) << bit) & (-v ^ x);
}
const long long LINF = (1LL << 60);
const int INF = (1 << 30);
const int LIM = (1 << 24);
const int MOD = 1e9 + 7;
const int BASE = 1e4;
const int DIGIT = 4;
long long sum, sor;
int pos;
long long bnb(int bit = 0, long long vala = 0, long long valb = 0) {
if (bit > pos) return (vala + valb == sum) && ((vala ^ valb) == sor);
long long test = ((1LL << bit) - 1);
long long testx = sum & test;
long long testy = (vala + valb) & test;
if (testx != testy) return 0;
int val = bitGet(sum, bit);
int dif = bitGet(sor, bit);
long long add = 1LL << bit;
long long res = 0;
if (dif)
res = 2 * bnb(bit + 1, vala | add, valb);
else
res = bnb(bit + 1, vala | add, valb | add) + bnb(bit + 1, vala, valb);
return res;
}
long long trau(int bit = 0, long long vala = 0, long long valb = 0) {
if (bit > pos) return (vala + valb == sum) && (vala ^ valb == sor);
int val = bitGet(sum, bit);
int dif = bitGet(sor, bit);
long long add = 1LL << bit;
long long res = 0;
if (dif)
res = 2 * trau(bit + 1, vala | add, valb);
else
res = trau(bit + 1, vala | add, valb | add) + trau(bit + 1, vala, valb);
return res;
}
int main() {
sum = readLong();
sor = readLong();
for (pos = 62; pos >= 0; pos--)
if (bitGet(sum, pos) == 1) break;
cout << bnb() - 2 * (sum == sor);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int TUX;
cin >> TUX;
double sum = 0, a = 0, b = 0, c = 0;
while (TUX--) {
int x;
cin >> x;
sum += x;
++a;
if (max(sum * c, a * b) == sum * c) b = sum, c = a;
}
b /= c;
printf("%.20lf\n", b);
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
std::vector<T> readVectorSz(int sz) {
std::vector<T> res;
res.reserve(sz);
for (int i = 0; i < sz; ++i) {
T tmp;
std::cin >> tmp;
res.push_back(std::move(tmp));
}
return res;
}
template <typename T>
std::vector<T> readVector() {
int sz;
std::cin >> sz;
return readVectorSz<T>(sz);
}
std::vector<std::vector<int>> readGraphDir(int vertices, int edges) {
auto g = std::vector<std::vector<int>>(vertices, std::vector<int>());
for (int i = 0; i < edges; ++i) {
int u, v;
std::cin >> u >> v;
--u;
--v;
g[u].push_back(v);
}
return g;
}
std::vector<std::vector<int>> readGraphUn(int vertices, int edges) {
auto g = std::vector<std::vector<int>>(vertices, std::vector<int>());
for (int i = 0; i < edges; ++i) {
int u, v;
std::cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
return g;
}
void outputUntil(int n, int k) {
std::cout << "Yes\n";
std::cout << n - (n / k) << ' ';
for (int i = 0; i <= (n / k) * k; i += k) {
for (int j = i + 1; j < (i + k) && j <= n; ++j) std::cout << j << ' ';
}
std::cout << '\n';
std::cout << n / k << ' ';
for (int i = k; i <= n; i += k) std::cout << i << ' ';
std::cout << '\n';
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
std::cin >> n;
if (n <= 2) {
std::cout << "No\n";
return 0;
} else {
if (((n + 1) / 2) % 2 == 0) {
outputUntil(n, 2);
return 0;
} else {
for (int k = 3; k <= n; k += 2) {
if ((n % k == 0) || (n % k == k - 1)) {
outputUntil(n, k);
return 0;
}
}
}
}
std::cout << "No\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int L[100000 + 10], dp1[100000 + 10], dp2[100000 + 10];
int lis(int *seq, int *ls, int N) {
int len = 0;
for (int i = 1; i <= N; ++i) {
int lo = 1, hi = len;
while (lo <= hi) {
int m = (lo + hi) / 2;
if (L[m] <= seq[i])
lo = m + 1;
else
hi = m - 1;
}
L[lo] = seq[i], ls[i] = lo;
if (len < lo) len = lo;
}
return len;
}
int A[100000 + 10], Rev[100000 + 10];
int solve(int n) {
lis(A, dp1, n);
lis(Rev, dp2, n);
int ans = 0;
for (int i = 1, j = n; i <= n; i++, j--) {
ans = max(ans, dp1[i] + dp2[j] - 1);
}
return ans;
}
int go(vector<int> &arr, int n) {
for (int i = 1, j = n; i <= n; i++, j--) A[i] = arr[i - 1], Rev[j] = A[i];
return solve(n);
}
vector<int> V;
int arr[100000 + 5];
int main() {
int n, m, i, l, r, ans = 0;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d %d", &l, &r);
arr[l]++;
arr[r + 1]--;
}
for (i = 1; i <= m; i++) arr[i] += arr[i - 1];
for (int i = 1; i <= m; i++) {
V.push_back(arr[i]);
}
cout << go(V, V.size()) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int maxx = 0, minn = 0;
while (n--) {
int temp;
cin >> temp;
if (temp >= 0)
maxx += temp;
else
minn += temp;
}
cout << maxx - minn << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[3], m;
int main() {
ios_base::sync_with_stdio(0);
cin >> a[0] >> a[1] >> m;
long long tam = a[0] + a[1];
sort(a, a + 2);
if (m <= a[1]) {
cout << 0;
return 0;
}
if (a[1] <= 0) {
cout << -1;
return 0;
}
long long res = 0;
if (tam < a[1]) {
long long u = (abs(a[0]) / a[1]);
if (abs(a[0]) % a[1] != 0) u++;
a[0] = a[0] + u * a[1];
res += u;
}
while (1) {
if (a[1] >= m) {
cout << res;
return 0;
}
tam = a[0] + a[1];
a[0] = a[1];
a[1] = tam;
res++;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2e5+15;
const int mod = 1e9 + 7;
int add(int x,int y) {
return ((x+y)%mod+mod)%mod;
}
int mul(int x,int y) {
return (ll)x*y%mod;
}
int mypow(int x,int c) {
int ret = 1;
while(c>0) {
if(c&1) {
ret = mul(ret,x);
}
c/=2;
x = mul(x,x);
}
return ret;
}
int b[N];
int dp[N];
ll pre[N];
void solve2() {
int n;
scanf("%d",&n);
for(int i=1;i<=n;++i) scanf("%d", &b[i]), pre[i] = pre[i-1] + b[i];
map<ll, int> H;
H[b[1]-pre[1]] = 1;
int sum = 1;
for(int i=2;i<=n;++i) {
dp[i] = sum - H[-pre[i-1]];
H[ b[i]-pre[i]] = add(H[ b[i]-pre[i]], dp[i]);
sum = add(sum,dp[i]);
}
printf("%d\n",sum);
}
void solve() {
int t;
scanf("%d",&t);
while(t--) solve2();
}
int main()
{
//freopen("input.txt","r",stdin);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, kq, Sum, xp, kt;
char a[101][10001];
int S[101][10001];
bool oke;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
oke = false;
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '1') oke = true;
}
if (not oke) {
cout << -1;
return 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (a[i][j] == '1') {
xp = j;
break;
}
for (int j = m; j >= 1; j--)
if (a[i][j] == '1') {
kt = j;
break;
}
S[i][1] = min(xp - 1, m - kt + 1);
S[i][m] = min(m - kt, xp);
int k = 2;
while (a[i][k] == '0') {
if (k == m) break;
S[i][k] = S[i][k - 1] + 1;
k++;
}
for (int j = k; j < m; j++)
if (a[i][j] == '1')
S[i][j] = 0;
else
S[i][j] = S[i][j - 1] + 1;
k = m - 1;
while (a[i][k] == '0') {
if (k == 1) break;
S[i][k] = min(S[i][k], S[i][k + 1] + 1);
k--;
}
for (int j = k; j > 1; j--)
if (a[i][j] == '0') S[i][j] = min(S[i][j + 1] + 1, S[i][j]);
}
kq = 1000000000;
for (int i = 1; i <= m; i++) {
Sum = 0;
for (int j = 1; j <= n; j++) Sum += S[j][i];
kq = min(Sum, kq);
}
cout << kq;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct wid {
long long high;
long long width;
int type;
int border;
int spacing;
};
map<string, int> sp;
vector<wid> v;
vector<int> a[500];
vector<string> ans;
void calc(int j) {
if (v[j].high != 0 || v[j].width != 0) return;
if (v[j].high == 0 && v[j].width == 0 && a[j].size() == 0) return;
if (v[j].type == 0) return;
long long l = 0;
long long d = 0;
for (int i = 0; i < a[j].size(); i++) {
calc(a[j][i]);
int z = a[j][i];
long long x = v[z].width;
long long y = v[z].high;
if (v[j].type == 2) swap(x, y);
l = l + x;
d = max(d, y);
}
if (a[j].size() > 0) l += (a[j].size() - 1) * v[j].spacing;
l += 2 * v[j].border;
d += 2 * v[j].border;
if (v[j].type == 2) {
v[j].high = l;
v[j].width = d;
} else {
v[j].width = l;
v[j].high = d;
}
return;
};
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == 'W') {
cin >> s;
string s1 = "";
int x = 0, y = 0;
int o = 0;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '(' || s[j] == ')' || s[j] == ',') {
o++;
continue;
}
if (o == 0)
s1 += s[j];
else {
int c = (s[j] - '0');
if (o == 1) x = x * 10 + c;
if (o == 2) y = y * 10 + c;
}
}
ans.push_back(s1);
wid T;
T.high = y;
T.width = x;
T.border = 0;
T.spacing = 0;
T.type = 0;
v.push_back(T);
sp[s1] = v.size() - 1;
} else if (s[0] == 'H') {
cin >> s;
ans.push_back(s);
wid T;
T.high = 0;
T.width = 0;
T.border = 0;
T.spacing = 0;
T.type = 1;
v.push_back(T);
sp[s] = v.size() - 1;
} else if (s[0] == 'V') {
cin >> s;
ans.push_back(s);
wid T;
T.high = 0;
T.width = 0;
T.border = 0;
T.spacing = 0;
T.type = 2;
v.push_back(T);
sp[s] = v.size() - 1;
} else {
string s1 = "", s2 = "";
int x = 0;
int o = 0;
int i = 0;
for (i = 0; i < s.size(); i++) {
if (s[i] == '.') break;
s1 += s[i];
}
i++;
if (s[i] == 's') {
i += 4;
if (s[i] == 'b')
o = 1;
else {
o = 2;
i++;
}
i += 7;
for (; i < s.size(); i++) {
if (s[i] == ')') break;
x = x * 10 + (s[i] - '0');
}
int nom = sp[s1];
if (o == 1)
v[nom].border = x;
else
v[nom].spacing = x;
} else {
i += 5;
for (; i < s.size(); i++) {
if (s[i] == ')') break;
s2 += s[i];
}
int nom = sp[s1];
int nom2 = sp[s2];
a[nom].push_back(nom2);
}
}
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
int j = sp[ans[i]];
calc(j);
cout << v[j].width << " " << v[j].high << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename X, typename Y>
ostream &operator<<(ostream &o, pair<X, Y> &a) {
o << "(" << a.first << "," << a.second << ")";
return o;
}
template <typename X>
string join(X &a, const string delimiter) {
stringstream ss;
int i = 0;
for (auto &x : a) {
if (i++ > 0) ss << delimiter;
ss << x;
}
return ss.str();
}
struct edgew {
int u;
int v;
long long w;
edgew(int u, int v, long long w) {
this->u = u;
this->v = v;
this->w = w;
}
void unpack(int &u, int &v, long long &w) {
u = this->u;
v = this->v;
w = this->w;
}
};
ostream &operator<<(ostream &o, edgew &a) {
o << "(" << a.u << "->" << a.v << "," << a.w << ")";
return o;
}
const int N = 100005;
const int LOGN = 17;
vector<edgew> G[N];
vector<edgew> GT[N];
struct trees_lca {
int T = 1, logn, n;
vector<int> tin, tout;
vector<long long> weight;
vector<edgew> *G;
vector<vector<int> > gpa;
trees_lca(int n, vector<edgew> *G) {
this->n = n;
int nx = 1, logn = 0;
while (nx <= n) logn++, nx <<= 1;
this->logn = logn;
this->G = G;
gpa.resize(logn);
for (int k = 0; k < logn; k++) gpa[k].resize(n);
tin.resize(n);
tout.resize(n);
weight.resize(n);
for (int i = 0; i < n; i++)
if (tin[i] == 0) dfs(i);
for (int k = 1; k < logn; k++)
for (int i = 0; i < n; i++) {
gpa[k][i] = gpa[k - 1][gpa[k - 1][i]];
}
}
void dfs(int u) {
tin[u] = T++;
for (auto &e : G[u])
if (tin[e.v] == 0) {
weight[e.v] = weight[u] + e.w;
gpa[0][e.v] = u;
dfs(e.v);
}
tout[u] = T;
}
bool is_ancestor(int an, int x) {
return tin[an] <= tin[x] && tout[an] >= tout[x];
}
int mth_parent(int i, int m) {
for (int k = logn - 1; k >= 0; k--)
if (m & (1 << k)) i = gpa[k][i];
return i;
}
int lca(int a, int b) {
if (is_ancestor(a, b)) return a;
if (is_ancestor(b, a)) return b;
for (int k = logn - 1; k >= 0; k--)
if (!is_ancestor(gpa[k][a], b)) a = gpa[k][a];
a = gpa[0][a];
return is_ancestor(a, b) ? a : -1;
}
long long dist(int a, int b) {
int x = lca(a, b);
return x != -1 ? weight[a] + weight[b] - 2 * weight[x] : (1LL << 60);
}
};
struct disjoint_set {
vector<int> pa;
disjoint_set(int n) {
this->pa.resize(n);
for (int i = 0; i < n; i++) this->pa[i] = i;
}
int find(int i) { return i == pa[i] ? i : pa[i] = find(pa[i]); }
bool merge(int i, int j) {
i = find(i);
j = find(j);
pa[i] = j;
return i != j;
}
};
vector<long long> dijkstra(int n, vector<edgew> *G, int src) {
vector<long long> d(n);
d.assign(n, (1LL << 60));
set<pair<long long, int> > s;
s.insert(make_pair(d[src] = 0, src));
while (!s.empty()) {
auto top = s.begin();
auto du = top->first;
auto u = top->second;
s.erase(top);
if (d[u] != du) continue;
for (auto &e : G[u])
if (du + e.w < d[e.v]) {
s.insert(make_pair(d[e.v] = du + e.w, e.v));
}
}
return d;
}
int main() {
int n, m;
while (scanf("%d%d", &n, &m) == 2) {
disjoint_set ds(n);
vector<int> specials;
for (int i = 0; i < n; i++) G[i].clear();
for (int i = 0; i < n; i++) GT[i].clear();
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w), --u, --v;
G[u].push_back(edgew(u, v, w));
G[v].push_back(edgew(v, u, w));
if (ds.merge(u, v)) {
GT[u].push_back(edgew(u, v, w));
GT[v].push_back(edgew(v, u, w));
} else {
specials.push_back(min(u, v));
}
}
trees_lca T(n, GT);
vector<vector<long long> > d;
for (auto &src : specials) {
d.push_back(dijkstra(n, G, src));
}
int nq;
scanf("%d", &nq);
for (int qtc = 0; qtc < nq; qtc++) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
long long ans = T.dist(u, v);
for (int j = 0; j < ((int)d.size()); j++)
ans = min(ans, d[j][u] + d[j][v]);
cout << ans << endl;
}
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.