solution
stringlengths 53
181k
| difficulty
int64 0
13
|
---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
char ch[N];
int s[N], r[N];
int n, m, sa[N], rk[N], h[N], he[N], t[N * 2], c[N];
void radix(int val[], int src[], int dest[]) {
for (int i = 0; i <= m; ++i) c[i] = 0;
for (int i = 1; i <= n; ++i) ++c[val[i] + 1];
for (int i = 1; i <= m; ++i) c[i] += c[i - 1];
for (int i = 1; i <= n; ++i) dest[++c[val[src[i]]]] = src[i];
}
int _lcp(int x, int y) {
int p = 0;
for (; ch[x + p] && ch[x + p] == ch[y + p]; ++p)
;
return p;
}
void run() {
int pos;
m = (n == 255 ? 256 : 255);
for (int i = 1; i <= n; ++i) rk[i] = ch[i], t[i + n] = 0, t[i] = i;
radix(rk, t, sa);
for (int d = 1; m != n; d <<= 1) {
pos = 0;
for (int i = n - d + 1; i <= n; ++i) t[++pos] = i;
for (int i = 1; i <= n; ++i)
if (sa[i] > d) t[++pos] = sa[i] - d;
radix(rk, t, sa);
for (int i = 1; i <= n; ++i) t[i] = rk[i];
rk[sa[1]] = m = 1;
for (int i = 2; i <= n; ++i)
rk[sa[i]] =
(m += (t[sa[i]] != t[sa[i - 1]] || t[sa[i] + d] != t[sa[i - 1] + d]));
}
for (int i = 1; i <= n; ++i)
if (rk[i] != 1) {
pos = max(h[i - 1] - 1, 0);
h[i] = pos + _lcp(i + pos, sa[rk[i] - 1] + pos);
} else
h[i] = 0;
for (int i = 1; i <= n; ++i) he[i] = h[sa[i]];
}
vector<int> pd[N * 2], *p = pd + N;
int get(int key, int l, int r) {
if (l > r || p[key].empty()) return 0;
return upper_bound(p[key].begin(), p[key].end(), r) -
lower_bound(p[key].begin(), p[key].end(), l);
}
int main() {
scanf("%d%s", &n, ch + 1);
for (int i = n; i; --i)
if (ch[i] == ')')
s[i] = s[i + 1] + 1;
else
s[i] = s[i + 1] - 1;
for (int i = 1; i <= n + 1; ++i) p[s[i]].push_back(i);
for (int i = n + 1; i; --i) {
int &p = r[i];
for (p = i + 1; p <= n + 1 && s[p] >= s[i]; p = r[p])
;
}
run();
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += get(s[sa[i]], sa[i] + he[i] + 1, r[sa[i]] - 1);
}
printf("%I64d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30);
const long long inf = (1LL << 60LL);
const int maxn = 1e5 + 5;
int n, k;
long long arr[55];
long long dp[55][55];
long long curr;
long long rek(int at, int kLeft) {
if (at == n && kLeft == 0) {
return 1;
}
if (at == n) {
return 0;
}
if (dp[at][kLeft] != -1) {
return dp[at][kLeft];
}
long long sum = 0;
long long ret = 0;
for (int i = at; i < n; i++) {
sum += arr[i];
if ((sum & curr) == curr) {
if (kLeft - 1 >= 0) ret = max(ret, rek(i + 1, kLeft - 1));
}
}
return dp[at][kLeft] = ret;
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
long long ret = 0;
for (long long i = 60LL; i >= 0LL; i--) {
ret += (1LL << i);
curr = ret;
memset(dp, -1, sizeof dp);
if (!rek(0, k)) {
ret -= (1LL << i);
}
}
cout << ret << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long p, long long e, long long M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return ret;
}
long long extended(long long a, long long b, long long &x, long long &y) {
a = abs(a);
b = abs(b);
long long g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
long long modinverse(long long a, long long M) { return bigmod(a, M - 2, M); }
long long bpow(long long p, long long e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
string convertInt(long long number) {
if (number == 0) return "0";
string temp = "";
string returnvalue = "";
while (number > 0) {
temp += number % 10 + 48;
number /= 10;
}
for (int i = 0; i < temp.length(); i++)
returnvalue += temp[temp.length() - i - 1];
return returnvalue;
}
long long ncr[1001][1001];
void NCR() {
for (int i = 1; i <= 1000; i++) {
ncr[i][i] = 1;
ncr[i][0] = 1;
for (int r = 1; r < i; r++) {
ncr[i][r] = (ncr[i - 1][r] + ncr[i - 1][r - 1]) % 1000000007;
}
}
}
vector<int> vec[4002];
int ar[4001][4001];
pair<int, int> p[4002];
int main() {
int n, m;
cin >> n >> m;
int x1, x2;
for (int i = 0; i < m; i++) {
cin >> x1 >> x2;
p[i].first = x1;
p[i].second = x2;
ar[x1][x2] = 1;
ar[x2][x1] = 1;
vec[x1].push_back(x2);
vec[x2].push_back(x1);
}
int mini = 100000000, ans;
int flag = 0;
for (int i = 0; i < m; i++) {
int fs, sn, td;
fs = p[i].first;
sn = p[i].second;
for (int j = 0; j < m; j++) {
if (p[j].first == sn) {
td = p[j].second;
if (ar[td][fs] == 1) {
flag = 1;
ans = vec[fs].size();
ans += vec[sn].size();
ans += vec[td].size();
ans = ans - 6;
mini = min(ans, mini);
}
}
}
}
if (flag == 0) {
cout << -1 << endl;
return 0;
}
cout << mini << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 1e-9;
int tm1[1010], tm2[1010], tm3[1010];
inline pair<int, int> get(int *a, int n) {
int pos = min_element(a, a + n) - a;
return make_pair(a[pos], pos);
}
int main() {
int k;
cin >> k;
int n1, n2, n3;
cin >> n1 >> n2 >> n3;
int t1, t2, t3;
cin >> t1 >> t2 >> t3;
for (int i = 0; i < k; ++i) {
pair<int, int> c1 = get(tm1, n1), c2 = get(tm2, n2), c3 = get(tm3, n3);
int can = max(c1.first, max(c2.first - t1, c3.first - t1 - t2));
tm1[c1.second] = can + t1;
tm2[c2.second] = can + t1 + t2;
tm3[c3.second] = can + t1 + t2 + t3;
}
int ans = 0;
for (int i = 0; i < n3; ++i) {
ans = max(ans, tm3[i]);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7, M = 1e6 + 3;
string s[N];
long long solve(string ss) {
vector<bool> pos(2);
for (int i = 0; i < ss.size(); i++) {
if (ss[i] == '.') continue;
pos[(ss[i] == 'L') ^ (i % 2)] = 1;
}
if (pos[0] && pos[1]) return 0;
if (pos[0] || pos[1]) return 1;
return 2;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
long long ans = 1;
for (int i = 0; i < n; i++) {
string ss;
for (int j = 0; j < m; j++) {
if (s[i][j] == '.')
ss += '.';
else if (s[i][j] == '1' || s[i][j] == '2')
ss += 'L';
else
ss += 'R';
}
ans = (ans * solve(ss)) % M;
}
for (int j = 0; j < m; j++) {
string ss;
for (int i = 0; i < n; i++) {
if (s[i][j] == '.')
ss += '.';
else if (s[i][j] == '1' || s[i][j] == '4')
ss += 'L';
else
ss += 'R';
}
ans = (ans * solve(ss)) % M;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long rw, rh, bw, bh, s;
cin >> rw >> rh >> bw >> bh;
s = (rw + 2) * (rh + 1) - rw * rh + 2 + (rw - bw) + 2 * bh + bw;
printf("%d\n", s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5;
int n, m, mx, c, kam;
vector<vector<char> > a, tmp;
vector<vector<int> > up, down, l, r, tmpu, tmpd, tmpl, tmpr;
void cpy() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
tmp[i][j] = a[i][j];
tmpu[i][j] = up[i][j];
tmpd[i][j] = down[i][j];
tmpl[i][j] = l[i][j];
tmpr[i][j] = r[i][j];
}
}
}
bool valid(int x) { return x != n + m; }
void solve(int i, int j) {
int c = 0;
while (i != n + m && j != n + m) {
c++;
if (valid(tmpu[i][j])) tmpd[tmpu[i][j]][j] = tmpd[i][j];
if (valid(tmpd[i][j])) tmpu[tmpd[i][j]][j] = tmpu[i][j];
if (valid(tmpl[i][j])) tmpr[i][tmpl[i][j]] = tmpr[i][j];
if (valid(tmpr[i][j])) tmpl[i][tmpr[i][j]] = tmpl[i][j];
if (tmp[i][j] == 'U') {
i = tmpu[i][j];
} else if (tmp[i][j] == 'D') {
i = tmpd[i][j];
} else if (tmp[i][j] == 'L') {
j = tmpl[i][j];
} else {
j = tmpr[i][j];
}
}
if (c == mx)
kam++;
else if (c > mx) {
mx = c;
kam = 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
up = down = r = l = tmpl = tmpr = tmpu = tmpd =
vector<vector<int> >(n + 5, vector<int>(m + 5));
a = tmp = vector<vector<char> >(n + 5, vector<char>(m + 5));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
up[i][j] = down[i][j] = l[i][j] = r[i][j] = n + m;
if (a[i][j] != '.') {
int x = i - 1;
while (x >= 0 && a[x][j] == '.') x--;
if (x >= 0) up[i][j] = x;
x = i + 1;
while (x < n && a[x][j] == '.') x++;
if (x < n) down[i][j] = x;
x = j - 1;
while (x >= 0 && a[i][x] == '.') x--;
if (x >= 0) l[i][j] = x;
x = j + 1;
while (x < m && a[i][x] == '.') x++;
if (x < m) r[i][j] = x;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '.') continue;
cpy();
solve(i, j);
}
}
cout << mx << ' ' << kam << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ctr = 0;
vector<int> v;
cin >> n;
int c = 0;
for (int i = 0; i < n; i++) {
int j;
cin >> j;
if (j == 1) {
ctr++;
if (i) v.push_back(c);
}
if (i == n - 1) v.push_back(j);
c = j;
}
cout << ctr << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << ' ';
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int L = 1 << 20;
bitset<L> ans;
int dat[N], nxt[N][25], last[25];
int n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> dat[i];
for (int i = 0; i < 25; i++) last[i] = n;
for (int i = n - 1; i >= 0; i--) {
for (int bit = 0; bit <= 20; bit++) {
if ((dat[i] & (1LL << bit))) last[bit] = i;
nxt[i][bit] = last[bit];
}
}
for (int i = 0; i < n; i++) {
int j = i, curr = 0;
while (j < n) {
curr |= dat[j];
ans[curr] = 1;
int nxtj = n;
for (int bit = 0; bit <= 20; bit++)
if ((curr & (1LL << bit)) == 0) nxtj = min(nxtj, nxt[j][bit]);
j = nxtj;
}
}
cout << ans.count() << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
long long INF = 1e18;
long long inf = 1e9 + 7;
long long MOD = 1e9 + 7;
long double eps = 1e-5;
const long long MAXN = 1e7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long n, m, k;
cin >> n >> m >> k;
vector<long long> v(m);
for (long long i = 0; i < m; i++) {
cin >> v[i];
}
long long ans = 0;
long long cnt = 0;
long long id = 0;
while (id != m) {
cnt = (cnt - 1) % k + 1;
long long fl = 0;
long long idwas = id;
for (; id < m; id++) {
long long add = v[id];
if (id != 0) add -= v[id - 1];
if (((cnt + add) > k && fl)) {
ans++;
cnt -= (id - idwas);
break;
}
if (id + 1 == m) {
ans++;
id++;
break;
}
fl = 1;
cnt += add;
cnt = (cnt - 1) % k + 1;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str, str1;
int num;
int counter1 = 0, counter2 = 0;
while (cin >> num >> str) {
for (int i = 0; i < num; i += 2) {
str1.push_back('1');
str1.push_back('0');
}
for (int i = 0; i < num; ++i) {
if (str[i] != str1[i]) {
counter1++;
}
if (str[i] == str1[i]) {
counter2++;
}
}
cout << min(counter1, counter2) << endl;
counter1 = counter2 = 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long MOD = 1e9 + 7;
char s[N], w[N];
long long ret1, ret2, ret, ans;
int main() {
int n;
scanf("%d %s %s", &n, s + 1, w + 1);
ans = ret1 = ret2 = ret = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '?') ans = ans * 10 % MOD;
if (w[i] == '?') ans = ans * 10 % MOD;
}
for (int i = 1; i <= n; i++) {
if (s[i] == '?' && w[i] == '?') {
ret1 = ret1 * 55 % MOD;
ret2 = ret2 * 55 % MOD;
ret = ret * 10 % MOD;
} else if (s[i] == '?') {
ret1 = ret1 * ('9' - w[i] + 1) % MOD;
ret2 = ret2 * (w[i] - '0' + 1) % MOD;
} else if (w[i] == '?') {
ret1 = ret1 * (s[i] - '0' + 1) % MOD;
ret2 = ret2 * ('9' - s[i] + 1) % MOD;
} else {
if (s[i] < w[i]) ret1 = ret = 0;
if (s[i] > w[i]) ret2 = ret = 0;
}
}
ans = ((ans - ret1 - ret2 + ret) % MOD + MOD) % MOD;
printf("%I64d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
const int maxn = 1e5 + 100;
int k;
vector<pair<int, int> > adjList[maxn];
int dp[maxn][2];
void dfs(int u, int p) {
vector<pair<int, int> > temp;
for (auto v : adjList[u]) {
if (v.first == p) continue;
dfs(v.first, u);
temp.emplace_back(
pair<int, int>(v.second + dp[v.first][0], v.second + dp[v.first][1]));
}
sort(temp.begin(), temp.end(), greater<pair<int, int> >());
for (int i = 0; i < min((int)temp.size(), k - 1); ++i)
dp[u][0] += temp[i].first;
for (int i = 0; i < temp.size(); ++i) {
int lol = dp[u][0];
lol += temp[i].second;
if (i < k - 1) {
lol -= temp[i].first;
if (temp.size() >= k) lol += temp[k - 1].first;
}
dp[u][1] = max(lol, dp[u][1]);
};
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n >> k;
for (int i = 0; i < n - 1; ++i) {
int u, v, c;
cin >> u >> v >> c;
adjList[u].emplace_back(pair<int, int>(v, c));
adjList[v].emplace_back(pair<int, int>(u, c));
}
dfs(0, -1);
cout << dp[0][1] << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, p;
cin >> n >> p;
long long som = 0;
vector<pair<long long, long long>> v;
for (int i = 0; i < (int)(n); i++) {
long long a, b;
cin >> a >> b;
som += a;
v.push_back(make_pair(a, b));
}
if (p >= som) {
cout << "-1"
<< "\n";
return 0;
}
long double res = -1;
long double l = 0, r = (1e18);
for (int q = 0; q < (int)(750) and l <= r; q++) {
long double mid = (l + r) / 2.0;
long double charge = p * mid;
vector<long double> qt;
for (int i = 0; i < (int)(n); i++) {
qt.push_back((long double)v[i].second - mid * v[i].first);
}
for (int i = 0; i < (int)(n); i++) {
if (qt[i] < 0) charge += qt[i];
}
if (charge >= (1e-6)) {
res = mid;
l = mid;
} else {
r = mid;
}
}
cout << fixed << setprecision(7) << res << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str[100005];
int n;
int i, j;
cin >> n;
int cnto[500005] = {0}, cntc[500005] = {0};
int cnt = 0;
for (i = 0; i < n; i++) {
cin >> str[i];
int l = str[i].size();
int ob = 0;
int cb = 0;
for (j = 0; j < l; j++) {
if (str[i][j] == '(') {
ob++;
} else if (ob > 0) {
ob--;
} else {
cb++;
}
}
if (ob == 0 && cb == 0) {
cnt++;
} else {
if (ob == 0) cntc[cb]++;
if (cb == 0) cnto[ob]++;
}
}
int ans = cnt / 2;
for (int i = 1; i < 500005; ++i) {
ans += min(cnto[i], cntc[i]);
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1e9 + 7;
long long mem[4][1000001];
long long solve(int n, int cnt) {
assert(cnt <= 3);
if (mem[cnt][n] != -1) return mem[cnt][n];
if (n == 0) {
if (cnt == 3 || cnt == 0) return 1;
return 0;
}
if (cnt == 3) {
return mem[cnt][n] = (solve(n - 1, cnt) + solve(n - 1, 0)) % MOD;
}
if (cnt == 0) {
return mem[cnt][n] = (solve(n - 1, 1) + solve(n - 1, 0)) % MOD;
}
return mem[cnt][n] = solve(n - 1, cnt + 1) % MOD;
}
int main() {
long long p, k;
cin >> p >> k;
int pos = 1;
int cur = p % k;
vector<int> sol;
int carry = 0;
while (p || carry != 0) {
cur = p % k + carry;
if (pos) {
if (cur == k) {
carry = 1;
sol.push_back(0);
} else {
carry = 0;
sol.push_back(cur);
}
} else {
if (cur == 0) {
sol.push_back(0);
carry = 0;
} else {
sol.push_back(k - cur);
carry = 1;
}
}
pos ^= 1;
p /= k;
}
cout << sol.size() << endl;
for (auto el : sol) cout << el << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gi() {
T f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
const int INF = 0x3f3f3f3f, N = 100003, M = N << 1;
int n, k, mod;
pair<int, int> p[2];
long long inv[N], sum[N];
inline long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod, b >>= 1;
}
return res;
}
inline void pre() {
for (int i = 1; i <= max(n, 4); i += 1)
inv[i] = qpow(i, mod - 2), sum[i] = (sum[i - 1] + inv[i]) % mod;
return;
}
inline long long solve(long long len1, long long len2) {
long long res = 0;
for (int i = 1; i <= len1; i += 1)
res = ((res + len2 * inv[2] % mod - (sum[i + len2] - sum[i]) % mod) % mod +
mod) %
mod;
return res;
}
int main() {
n = gi<int>(), k = gi<int>(), mod = gi<int>();
--k;
if (k > 20) k = 20;
int u = min(n, 1 << k);
int a = n / u, b = a + 1, cnta = b * u - n, cntb = u - cnta;
p[0] = {a, cnta}, p[1] = {b, cntb};
pre();
long long ans = 0;
for (int i = 0; i <= 1; i += 1) {
int len = p[i].first, cnt = p[i].second;
ans = (ans + 1ll * cnt * len % mod * (len - 1) % mod * inv[4] % mod) % mod;
}
for (int i = 0; i <= 1; i += 1)
for (int j = 0; j <= 1; j += 1) {
if (i == j) {
long long len = p[i].first,
cnt = 1ll * p[i].second * (p[i].second - 1) / 2 % mod;
ans = (ans + 1ll * cnt * solve(len, len) % mod) % mod;
} else if (p[i].first < p[j].first) {
long long len1 = p[i].first, len2 = p[j].first,
cnt = 1ll * p[i].second * p[j].second % mod;
ans = (ans + 1ll * cnt * solve(len1, len2) % mod) % mod;
}
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e4 + 9;
long long n, m, k, A, B;
long long a[N], b[N];
template <typename T>
inline void read(T &x) {
x = 0;
T w = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') w = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x *= w;
}
long long qmul(long long a, long long b, long long p) {
long long c = a * b - (long long)((long double)a / p * b + 0.5) * p;
return c < 0 ? c + p : c;
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long d = exgcd(b, a % b, x, y);
long long t = x;
x = y;
y = t - a / b * y;
return d;
}
void excrt() {
A = a[1], B = b[1];
for (long long i = 2; i <= k; ++i) {
long long c = ((b[i] - B) % a[i] + a[i]) % a[i], Y, y,
d = exgcd(A, a[i], Y, y);
if (c % d) {
printf("NO");
exit(0);
}
Y = qmul(Y, c / d, a[i] / d);
B += A * Y;
A = A / d * a[i];
B = (B % A + A) % A;
}
if (!B) B = A;
}
int main() {
read(n);
read(m);
read(k);
for (long long i = 1; i <= k; ++i)
read(a[i]), b[i] = ((1 - i) % a[i] + a[i]) % a[i];
if (m < k) {
printf("NO");
return 0;
}
excrt();
if (A > n || B + k - 1 > m) {
printf("NO");
return 0;
}
for (long long i = 1; i <= k; ++i)
if (gcd(A, B + i - 1) != a[i]) {
printf("NO");
return 0;
}
printf("YES");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200200;
const long long int INF = 1e16;
struct node {
long long int mn, mx, res;
node(long long int mn_ = -INF, long long int mx_ = -INF,
long long int res_ = -INF) {
mn = mn_, mx = mx_, res = res_;
}
friend node operator+(const node &a, const node &b) {
node ret;
ret.mn = max(a.mn, b.mn);
ret.mx = max(a.mx, b.mx);
ret.res = max(a.mn + b.mx, max(a.res, b.res));
return ret;
}
} seg[MAXN * 4];
int N, M;
int d[MAXN];
int h[MAXN];
long long int dn[MAXN];
inline node eval(int k, int b, int e) {
if (b == e)
return seg[k] = node(2LL * h[b] - dn[b], 2LL * h[b] + dn[b], -INF);
return seg[k] =
eval(k * 2, b, (b + e) / 2) + eval(k * 2 + 1, (b + e) / 2 + 1, e);
}
inline node query(int k, int b, int e, int a1, int a2) {
if (b > a2 || e < a1) return node(-INF, -INF, -INF);
if (b >= a1 && e <= a2) return seg[k];
return query(k * 2, b, (b + e) / 2, a1, a2) +
query(k * 2 + 1, (b + e) / 2 + 1, e, a1, a2);
}
int main() {
scanf(" %d %d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf(" %d", d + i);
d[i + N] = d[i];
}
for (int i = 1; i <= N; i++) {
scanf(" %d", h + i);
h[i + N] = h[i];
}
N *= 2;
for (int i = 2; i <= N; i++)
dn[i] = (long long int)dn[i - 1] + (long long int)d[i - 1];
eval(1, 1, N);
for (int a, b, i = 0; i < M; i++) {
scanf(" %d %d", &a, &b);
if (a <= b)
printf("%I64d\n", query(1, 1, N, b + 1, a + N / 2 - 1).res);
else
printf("%I64d\n", query(1, 1, N, b + 1, a - 1).res);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long int power(long long int x, long long int y,
long long int m = 1000000007) {
long long int ans = 1;
x %= m;
while (y) {
if (y & 1) ans = (x * ans) % m;
x = (x * x) % m;
y >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<long long int> a(3), m(3), c(3);
long long int mn = 1e18;
for (int i = 0; i < 3; i++) cin >> a[i];
for (int i = 0; i < 3; i++) cin >> m[i];
for (int i = 0; i < 3; i++) cin >> c[i];
long long int ipay = max((long long int)0, (m[2] + 1 - a[1]) * c[1]);
for (int i = max((long long int)1, a[1] - m[2]), l = 0;; i++, l++) {
for (int j = max((long long int)0, m[1] - a[2]), pt = 0; j >= 0;
j--, pt++) {
long long int minh = ((m[0] + i - 1) / i) * j + 1;
mn = min(mn, max((minh - a[0]), (long long int)0) * c[0] + c[1] * (l) +
c[2] * (pt));
}
if (i >= 100) break;
}
cout << mn + ipay;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18;
const long long mod = 1e9 + 7;
const double Pi = acos(-1);
int n, m;
set<int> v[100009];
int dfs(int node) {
vector<int> out;
while (v[node].size()) {
int u = *v[node].begin();
v[node].erase(u);
v[u].erase(node);
int ret = dfs(u);
if (ret != -1) {
cout << node + 1 << " " << u + 1 << " " << ret + 1 << endl;
} else {
out.push_back(u);
}
}
for (int i = (out.size()) % 2; i < out.size(); i += 2) {
cout << out[i] + 1 << " " << node + 1 << " " << out[i + 1] + 1 << endl;
}
return (out.size() % 2 ? out[0] : -1);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
v[a].insert(b);
v[b].insert(a);
}
if (m % 2) {
cout << "No solution" << endl;
return 0;
}
dfs(0);
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
void read(int &x) {
x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
void prt(int x) {
if (x > 9) prt(x / 10);
putchar(x % 10 ^ 48);
}
const int N = 200000;
int n, m;
vector<int> nei[N + 1];
int cnt[N + 1];
bool dp0[N + 1];
int dp[N + 1];
void dfs(int x = 1, int fa = 0) {
cnt[x] = 0;
dp0[x] = true;
dp[x] = 0;
for (int i = 0; i < nei[x].size(); i++) {
int y = nei[x][i];
if (y == fa) continue;
dfs(y, x);
cnt[x] += dp0[y];
dp0[x] &= dp0[y];
dp[x] += dp[y];
}
dp[x] += cnt[x] / m;
dp0[x] &= cnt[x] % m == 0;
}
int ans;
void dfs0(int x = 1, int fa = 0) {
ans = max(ans, dp[x]);
for (int i = 0; i < nei[x].size(); i++) {
int y = nei[x][i];
if (y == fa) continue;
int cnt_x = cnt[x], dp0_x = dp0[x], dp_x = dp[x], cnt_y = cnt[y],
dp0_y = dp0[y], dp_y = dp[y];
cnt[x] -= dp0[y];
dp0[x] = cnt[x] == nei[x].size() - 1 && cnt[x] % m == 0;
dp[x] = dp[x] - dp[y] - (cnt[x] + dp0[y]) / m + cnt[x] / m;
cnt[y] += dp0[x];
dp0[y] = cnt[y] == nei[y].size() && cnt[y] % m == 0;
dp[y] = dp[y] + dp[x] - (cnt[y] - dp0[x]) / m + cnt[y] / m;
dfs0(y, x);
cnt[x] = cnt_x;
dp0[x] = dp0_x;
dp[x] = dp_x;
cnt[y] = cnt_y;
dp0[y] = dp0_y;
dp[y] = dp_y;
}
}
void mian() {
read(n);
read(m);
for (int i = 1; i <= n; i++) nei[i].clear();
for (int i = 1; i < n; i++) {
int x, y;
read(x);
read(y);
nei[x].push_back(y);
nei[y].push_back(x);
}
dfs();
ans = 0;
dfs0();
prt(ans);
putchar('\n');
}
int main() {
int testnum;
cin >> testnum;
while (testnum--) mian();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
long long dp[2];
int main() {
int n;
while (cin >> n) {
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i]--;
}
a[0] = a[1];
a[n + 1] = a[n];
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
int f = i & 1;
int mn1 = min(a[i], a[i - 1]);
int mn2 = min(a[i], a[i + 1]);
ans = (ans + mn1 * 1LL * dp[1 - f] % 1000000007) % 1000000007;
ans = (ans + a[i] * 1LL) % 1000000007;
dp[f] = min(mn1, mn2) * 1LL * dp[1 - f] % 1000000007;
dp[f] = (dp[f] + mn2 * 1LL) % 1000000007;
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, k, a[MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
long long sum = 0;
for (int i = 0; i < k; ++i) sum += a[i];
double ans = double(sum) / (n - k + 1);
for (int i = 0; i + k < n; ++i) {
sum -= a[i], sum += a[i + k];
ans += double(sum) / (n - k + 1);
}
printf("%.10lf\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, arr[105];
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
int ans = arr[0];
for (int i = 1; i < n; i++) {
ans = gcd(ans, arr[i]);
}
cout << ans * n << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
char pp[55][55];
int nxt[4][2] = {{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = (0); i < (n); ++i) cin >> pp[i];
int cnt = 0;
int mxx = -1, mxy = -1, mnx = 55, mny = 55;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (n); ++j) {
if (pp[i][j] == '4') {
mxx = max(mxx, i);
mxy = max(mxy, j);
mnx = min(mnx, i);
mny = min(mny, j);
cnt++;
}
}
}
if (mxx == -1 || cnt != (mxx - mnx + 1) * (mxy - mny + 1)) {
cout << "No" << endl;
return 0;
}
for (int i = mnx - 1; i <= mxx + 1; i++) {
for (int j = mny - 1; j <= mxy + 1; j++) {
if (i < 0 || i >= n || j < 0 || j >= n || pp[i][j] == '4') continue;
int cc = 0;
for (int k = (0); k < (4); ++k) {
int x = i + nxt[k][0];
int y = j + nxt[k][1];
if (mnx - 1 <= x && x <= mxx + 1 && mny - 1 <= y && y <= mxy + 1) cc++;
}
if (pp[i][j] - '0' != cc) {
cout << "No" << endl;
return 0;
}
}
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) {
if (mnx - 1 <= i && i <= mxx + 1 && mny - 1 <= j && j <= mxy + 1)
continue;
if (pp[i][j] != '0') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[5];
int b[5];
int main() {
int n;
cin >> n;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
a[x - 1]++;
}
for (int i = 0; i < n; i++) {
cin >> x;
b[x - 1]++;
}
int ans = 0;
for (int i = 0; i < 5; i++) {
if ((a[i] + b[i]) % 2 == 1) {
cout << -1 << endl;
return 0;
}
int xx = (a[i] + b[i]) / 2;
ans += (abs(a[i] - xx));
}
cout << ans / 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
int n;
long long a[500009], b[500009];
set<long long> sa, ans;
int main() {
while (scanf("%d", &n) == 1) {
sa.clear();
for (int(i) = (0); (i) < (n); ++(i)) {
scanf("%lld", &a[i]);
sa.insert(a[i]);
}
ans.clear();
priority_queue<long long> heap;
for (int(i) = (0); (i) < (n); ++(i)) heap.push(a[i]);
while (!heap.empty()) {
long long v = heap.top();
heap.pop();
sa.erase(v);
long long x = (v >> 1);
while (x > 0 && sa.count(x)) x >>= 1;
if (x == 0) {
sa.insert(v);
ans.insert(v);
} else {
sa.insert(x);
heap.push(x);
}
}
bool fp = 1;
for (__typeof((ans).begin()) it = (ans).begin(); it != (ans).end(); ++it) {
if (fp)
fp = 0;
else
printf(" ");
printf("%lld", *it);
}
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1005, MN = 1000005, inf = 1000000005, mod = 1000000007, L = 1000;
const long long INF = 1000000000000000005LL;
vector<int> kub[MX];
pair<int, int> pkt[MN];
bool comp(int a, int b) { return pkt[a] < pkt[b]; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
pkt[i] = {b, a};
kub[a / L].push_back(i);
}
for (int i = 0; i < MX; ++i) {
sort((kub[i]).begin(), (kub[i]).end(), comp);
if (i & 1) reverse((kub[i]).begin(), (kub[i]).end());
for (auto x : kub[i]) printf("%d ", x);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double n, i, j, r, x1, x2, y1, y2, R, fx1, fx2, fy1, fy2, m, c, p, q, A,
B, C, dist1, dist2, ansx, ansy;
cin >> R >> x1 >> y1 >> x2 >> y2;
long double precomp =
(long double)((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1));
if (precomp >= (R * R)) {
cout << x1 << " " << y1 << " " << R;
exit(0);
}
if (x2 != x1) {
m = (long double)(y2 - y1) / (x2 - x1);
c = (long double)(y1 - (m * x1));
p = x1;
q = y1;
B = (long double)2 * ((m * c) - (m * q) - p);
A = (long double)((m * m) + 1);
C = (long double)((q * q) - (R * R) + (p * p) - (2 * c * q) + (c * c));
fx1 = (long double)(-B + ((long double)sqrt((B * B) - (4 * A * C)))) /
(2 * A);
fx2 = (long double)(-B - ((long double)sqrt((B * B) - (4 * A * C)))) /
(2 * A);
fy1 = (long double)((m * fx1) + c);
fy2 = (long double)((m * fx2) + c);
dist1 = (long double)((long double)sqrt(((fx1 - x2) * (fx1 - x2)) +
((fy1 - y2) * (fy1 - y2))));
dist2 = (long double)((long double)sqrt(((fx2 - x2) * (fx2 - x2)) +
((fy2 - y2) * (fy2 - y2))));
ansx, ansy;
if (dist1 > dist2) {
ansx = (long double)(fx1 + x2) / 2;
ansy = (long double)(fy1 + y2) / 2;
r = (long double)(dist1 / 2);
} else {
ansx = (long double)(fx2 + x2) / 2;
ansy = (long double)(fy2 + y2) / 2;
r = (long double)(dist2 / 2);
}
} else {
fx1 = x1;
fy1 = (R + y1);
fx2 = x2;
fy2 = (y1 - R);
dist1 = (long double)((long double)sqrt(((fx1 - x2) * (fx1 - x2)) +
((fy1 - y2) * (fy1 - y2))));
dist2 = (long double)((long double)sqrt(((fx2 - x2) * (fx2 - x2)) +
((fy2 - y2) * (fy2 - y2))));
ansx, ansy;
if (dist1 > dist2) {
ansx = (long double)(fx1 + x2) / 2;
ansy = (long double)(fy1 + y2) / 2;
r = (long double)(dist1 / 2);
} else {
ansx = (long double)(fx2 + x2) / 2;
ansy = (long double)(fy2 + y2) / 2;
r = (long double)(dist2 / 2);
}
}
cout << setprecision(30) << ansx << " " << ansy << " " << r;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int a, n;
std::cin >> a >> n;
std::vector<int> months(a + n + 1);
std::vector<int> mindivisor(a + n + 1);
mindivisor[1] = 1;
for (int i = 2; i < a + n; ++i) {
if (mindivisor[i] == 0) {
mindivisor[i] = 1;
for (int j = i + i; j < a + n; j += i) {
if (mindivisor[j] == 0) mindivisor[j] = i;
}
}
}
long long ans = 0;
for (int i = 1; i < a + n; ++i) {
int d = mindivisor[i];
if (d == 1) {
months[i] = i;
} else {
int p = months[i / d];
months[i] = (p % d == 0 ? p / d : p * d);
}
if (i >= a) {
ans += months[i];
}
}
std::cout << ans << std::endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline void checkmin(T& x, U y) {
x = min(x, (T)y);
};
template <class T, class U>
inline void checkmax(T& x, U y) {
x = max(x, (T)y);
};
int Cnt[5050], tCnt;
void process(string& doc) {
int n = ((int)(doc.size()));
tCnt = 0;
memset(Cnt, 0, sizeof Cnt);
vector<int> res;
for (int i = 0; i < n;) {
if (i + 7 <= n and doc.substr(i, 7) == "<table>") {
Cnt[tCnt++] = 0;
i += 7;
} else if (i + 8 <= n and doc.substr(i, 8) == "</table>") {
res.push_back(Cnt[--tCnt]);
i += 8;
} else if (i + 4 <= n and doc.substr(i, 4) == "<td>") {
for (int j = (tCnt - 1); j < (tCnt); ++j) Cnt[j]++;
i += 4;
} else if (i + 5 <= n and doc.substr(i, 5) == "</td>") {
i += 5;
} else
i++;
}
sort((res).begin(), (res).end());
for (int i = (0); i < (((int)(res.size()))); ++i) cout << res[i] << endl;
return;
}
int main() {
string doc = "";
for (string line; cin >> line; doc += line)
;
process(doc);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[1001001][2];
vector<int> G[1001001];
int ans[1001001] = {};
int ma[1001001] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (2); ++j) dp[i][j] = 0;
for (int i = (n)-1; i >= 0; --i) {
if (i == n - 1) {
if (s[i] == '0') {
dp[i][0] = 1;
} else if (s[i] == '1') {
dp[i][1] = 1;
} else {
dp[i][0] = 1;
dp[i][1] = 1;
}
} else {
if (s[i] == '0') {
dp[i][0] = dp[i + 1][0] + 1;
} else if (s[i] == '1') {
dp[i][1] = dp[i + 1][1] + 1;
} else {
dp[i][0] = dp[i + 1][0] + 1;
dp[i][1] = dp[i + 1][1] + 1;
}
}
ma[i] = max(dp[i][0], dp[i][1]);
if (i > 0) {
if (s[i - 1] == '0' && s[i] != '0') {
for (int j = 0; j < (dp[i][1]); ++j) {
G[j + 1].push_back(i);
}
}
if (s[i - 1] == '1' && s[i] != '1') {
for (int j = 0; j < (dp[i][0]); ++j) {
G[j + 1].push_back(i);
}
}
}
}
set<int> se;
for (int i = 0; i < (n + 1); ++i) {
sort(G[i].begin(), G[i].end());
}
for (int i = (n + 1) - 1; i >= 0; --i) {
if (i == 0) break;
int now = 0;
int ite = 0;
int m = G[i].size();
while (now < n) {
if (ma[now] >= i) {
ans[i]++;
now += i;
} else {
while (ite < m) {
if (G[i][ite] >= now) {
break;
}
ite++;
}
if (ite == m) break;
ans[i]++;
now = G[i][ite] + i;
}
}
}
for (int i = 1; i < n + 1; ++i) printf("%d ", ans[i]);
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
short m, l, r;
cin >> m;
while (m--) {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
l = n;
r = l;
while (l > 0) {
for (int j = 1; j <= i; ++j) {
if (l <= 0) break;
cout << "(";
l--;
}
cout << ")";
r--;
}
for (int z = 0; z < r; ++z) cout << ")";
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long fun(long long l, long long r, long long n) {
if (l > r) swap(l, r);
if (l % n) l += n - (l % n + n) % n;
if (r % n) r -= (r % n + n) % n;
return (r - l) / n + 1;
}
int main() {
long long a, b, xa, ya, xb, yb;
scanf("%lld %lld %lld %lld %lld %lld", &a, &b, &xa, &ya, &xb, &yb);
printf("%lld\n",
max(fun(xa + ya, xb + yb, 2 * a), fun(xa - ya, xb - yb, 2 * b)));
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define eb emplace_back
#define mp make_pair
typedef pair<int,int> pii;
#define f first
#define s second
#ifdef local
#define debug(x,label) cerr<<"DEBUG "<<label<<" "<<x<<'\n';
#else
#define debug(x,label);
#endif
#define min(a,b) ((a<b)?a:b)
#define max(a,b) ((a>b)?a:b)
//const int mod=1000000007;
int edgs[505][505],edgf[505][505],kekw[505][505][11];
int xx[4]={-1,-1,1,1};
int yy[4]={-1,1,-1,1};
int32_t main(){
ios_base::sync_with_stdio(false);cin.tie(0);
int n,m,k,ans;
cin>>n>>m>>k;
if((k%2)==1){
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cout<<"-1";
if(j+1<m)cout<<' ';
else cout<<'\n';
}
}
return 0;
}
k/=2;
for(int i=0;i<n;i++){
for(int j=0;j<m-1;j++){
cin>>edgs[i][j];
}
}
for(int i=0;i<n-1;i++){
for(int j=0;j<m;j++){
cin>>edgf[i][j];
}
}
for(int kk=1;kk<=k;kk++){
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
kekw[i][j][kk]=1e9;
if(i+1<n)kekw[i][j][kk]=min(edgf[i][j]+kekw[i+1][j][kk-1],kekw[i][j][kk]);
if(j+1<m)kekw[i][j][kk]=min(edgs[i][j]+kekw[i][j+1][kk-1],kekw[i][j][kk]);
if(i>0)kekw[i][j][kk]=min(edgf[i-1][j]+kekw[i-1][j][kk-1],kekw[i][j][kk]);
if(j>0)kekw[i][j][kk]=min(edgs[i][j-1]+kekw[i][j-1][kk-1],kekw[i][j][kk]);
}
}
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cout<<2*kekw[i][j][k];
if(j+1<m)cout<<' ';
}
cout<<'\n';
}
return 0;
}
/*
*/
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
ll t, n, g, b;
int main() {
cin >> t;
while (t--) {
cin >> n >> g >> b;
if (g >= b) {
cout << n << endl;
} else {
ll v = (n + 1) / 2;
ll res = (v / g) * (b + g);
if (v % g == 0) {
res -= b;
}
v %= g;
res += v;
cout << max(res, n) << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
const long double pi = acosl(-1.);
const long double eps = 1e-17;
int r, h;
long double getAngle(long double x, long double y, long double z) {
long double H = h - z;
if (H < eps) return 0;
long double R = r * H / h;
long double X = 0;
long double Y = R;
long double d = sqrtl((x - X) * (x - X) + (y - Y) * (y - Y));
long double a = asinl(d / 2 / R) * 2;
long double l = a * R / sqrtl(R * R + H * H);
if (x > 0) l = -l;
return l;
}
long double conDist(long double z, long double Z, long double a) {
long double r1 = sqrtl(h * h + r * r + 0.) / h * (h - z);
long double r2 = sqrtl(h * h + r * r + 0.) / h * (h - Z);
long double x = r1;
long double y = 0;
long double X = cosl(a) * r2;
long double Y = sinl(a) * r2;
return sqrtl((x - X) * (x - X) + (y - Y) * (y - Y));
}
long double getOnConus(long double x, long double y, long double z,
long double X, long double Y, long double Z) {
long double a1 = getAngle(x, y, z);
long double a2 = getAngle(X, Y, Z);
long double a = fabsl(a2 - a1);
long double A = r / sqrtl(h * h + r * r + 0.) * 2 * pi;
return min(conDist(z, Z, a), conDist(z, Z, A - a));
}
long double getOnConus(long double x, long double y, long double z,
long double X, long double Y) {
if (z > eps) return getOnConus(x, y, z, X, Y, 0);
return sqrtl((x - X) * (x - X) + (y - Y) * (y - Y));
}
long double getD(long double x, long double y, long double z, long double X,
long double Y, long double Z, long double XX, long double YY,
long double XXX, long double YYY) {
long double res = sqrtl((XX - XXX) * (XX - XXX) + (YY - YYY) * (YY - YYY));
res += getOnConus(x, y, z, XX, YY);
res += getOnConus(X, Y, Z, XXX, YYY);
return res;
}
long double getD(long double x, long double y, long double z, long double X,
long double Y, long double Z, long double XX, long double YY) {
long double res = 1e100;
for (int i(0); i < (6); i++) {
long double a = 2 * pi / 3 * i;
long double b = a + pi;
for (int j(0); j < (50); j++) {
long double s1 = (a * 2 + b) / 3;
long double s2 = (a + 2 * b) / 3;
long double d1 =
getD(x, y, z, X, Y, Z, XX, YY, cosl(s1) * r, sinl(s1) * r);
long double d2 =
getD(x, y, z, X, Y, Z, XX, YY, cosl(s2) * r, sinl(s2) * r);
res = min(res, min(d1, d2));
if (d1 < d2)
b = s2;
else
a = s1;
}
}
return res;
}
long double go(long double x, long double y, long double z, long double X,
long double Y, long double Z) {
long double res = getOnConus(x, y, z, X, Y, Z);
if (z < eps || Z < eps) res = 1e100;
for (int i(0); i < (6); i++) {
long double a = 2 * pi / 3 * i;
long double b = a + pi;
for (int j(0); j < (50); j++) {
long double s1 = (a * 2 + b) / 3;
long double s2 = (a + 2 * b) / 3;
long double d1 = getD(x, y, z, X, Y, Z, cosl(s1) * r, sinl(s1) * r);
long double d2 = getD(x, y, z, X, Y, Z, cosl(s2) * r, sinl(s2) * r);
res = min(res, min(d1, d2));
if (d1 < d2)
b = s2;
else
a = s1;
}
}
return res;
}
int main() {
cin >> r >> h;
long double x, y, z, X, Y, Z;
cin >> x >> y >> z >> X >> Y >> Z;
if (z < eps && Z < eps)
printf("%.10lf\n", (double)sqrt((x - X) * (x - X) + (y - Y) * (y - Y)));
else
printf("%.10lf\n", (double)go(x, y, z, X, Y, Z));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void enumerateSubmasks(long long m) {
for (long long s = m;; s = (s - 1) & m) {
if (s == 0) {
break;
}
}
}
long long mpow(long long a, long long b, long long m) {
if (b == 0) return 1;
long long x = mpow(a, b / 2, m);
x = (x * x) % m;
if (b % 2) {
x = (x * a) % m;
}
return x;
}
void update(long long s, long long e, long long qs, long long qe,
vector<long long> &seg, vector<long long> &lazy, long long index,
long long value) {
if (lazy[index] != -1) {
seg[index] = max(seg[index], lazy[index]);
if (s != e) {
if (lazy[2 * index] == -1)
lazy[2 * index] = lazy[index];
else
lazy[2 * index] = max(lazy[2 * index], lazy[index]);
if (lazy[2 * index + 1] == -1)
lazy[2 * index + 1] = lazy[index];
else
lazy[2 * index + 1] = max(lazy[2 * index + 1], lazy[index]);
}
lazy[index] = -1;
}
if (qs > e || qe < s) return;
if (s >= qs && e <= qe) {
seg[index] = max(seg[index], value);
if (s != e) {
if (lazy[2 * index] == -1)
lazy[2 * index] = value;
else
lazy[2 * index] = max(lazy[2 * index], value);
if (lazy[2 * index + 1] == -1)
lazy[2 * index + 1] = value;
else
lazy[2 * index + 1] = max(lazy[2 * index + 1], value);
}
return;
}
long long mid = (s + e) / 2;
update(s, mid, qs, qe, seg, lazy, 2 * index, value);
update(mid + 1, e, qs, qe, seg, lazy, 2 * index + 1, value);
}
long long query(long long s, long long e, long long qs, long long qe,
vector<long long> &seg, vector<long long> &lazy,
long long index) {
if (lazy[index] != -1) {
seg[index] = max(seg[index], lazy[index]);
if (s != e) {
if (lazy[2 * index] == -1)
lazy[2 * index] = lazy[index];
else
lazy[2 * index] = max(lazy[2 * index], lazy[index]);
if (lazy[2 * index + 1] == -1)
lazy[2 * index + 1] = lazy[index];
else
lazy[2 * index + 1] = max(lazy[2 * index + 1], lazy[index]);
}
lazy[index] = -1;
}
if (qs > e || qe < s) return LLONG_MIN;
if (s >= qs && e <= qe) {
return seg[index];
}
long long mid = (s + e) / 2;
long long a = query(s, mid, qs, qe, seg, lazy, 2 * index);
long long b = query(mid + 1, e, qs, qe, seg, lazy, 2 * index + 1);
return max(a, b);
}
void printBinaryString(long long n) {
vector<long long> temp;
while (n) {
if (n & 1)
temp.push_back(1);
else
temp.push_back(0);
n = n >> 1;
}
reverse(temp.begin(), temp.end());
for (auto node : temp) cout << node << " ";
cout << endl;
}
void readVector(vector<long long> &a) {
long long n = a.size();
for (long long i = 0; i < n; ++i) cin >> a[i];
}
long long findGrid(long long i, long long j, long long n,
vector<vector<long long>> &dp) {
if (i >= n || i < 0 || j >= n || j < 0) return 0;
return dp[i][j];
}
long long dx[2] = {0, -1};
long long dy[2] = {-1, 0};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
vector<vector<char>> grid(n, vector<char>(n, 0));
for (long long i = 0; i < n; ++i) {
string s;
cin >> s;
for (long long j = 0; j < n; ++j) grid[i][j] = s[j];
}
vector<vector<long long>> dp1(n, vector<long long>(n, 0));
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < n; ++j) {
dp1[i][j] = 0;
for (long long x = 0; x < 2; ++x) {
dp1[i][j] = max(dp1[i][j], findGrid(i + dx[x], j + dy[x], n, dp1));
}
if (grid[i][j] == 'a') dp1[i][j] += 1;
}
}
long long maxA = 0;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < n; ++j) {
if ((dp1[i][j] + k) >= (i + j + 1)) maxA = max(maxA, i + j + 1);
}
}
vector<pair<long long, long long>> startPoints;
if (maxA == 0) startPoints.push_back({0, 0});
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < n; ++j) {
if ((dp1[i][j] + k) >= (i + j + 1) && (i + j + 1) == maxA)
startPoints.push_back({i, j});
}
}
string answer = "";
vector<pair<long long, long long>> temp;
while (1) {
map<pair<long long, long long>, bool> visited;
char minChar = '{';
for (auto node : startPoints) {
long long x = node.first;
long long y = node.second;
if (x != n - 1) minChar = min(minChar, grid[x + 1][y]);
if (y != n - 1) minChar = min(minChar, grid[x][y + 1]);
}
if (minChar == '{') break;
answer += minChar;
for (auto node : startPoints) {
long long x = node.first;
long long y = node.second;
if (x != n - 1) {
if (grid[x + 1][y] == minChar && visited[{x + 1, y}] == false) {
visited[{x + 1, y}] = true;
temp.push_back({x + 1, y});
}
}
if (y != n - 1) {
if (grid[x][y + 1] == minChar && visited[{x, y + 1}] == false) {
visited[{x, y + 1}] = true;
temp.push_back({x, y + 1});
}
}
}
startPoints = temp;
temp.clear();
}
if (!maxA) answer = grid[0][0] + answer;
for (long long i = 0; i < maxA; ++i) answer = 'a' + answer;
cout << answer;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int v[100010];
int mn, mx;
pair<int, int> T[100010 * 4];
int dp[100010 * 4];
int n, s, len;
void build(int l, int r, int node) {
if (l == r) {
T[node] = {v[l], v[l]};
return;
}
build(l, (l + r) / 2, node * 2);
build((l + r) / 2 + 1, r, node * 2 + 1);
T[node].first = min(T[node * 2].first, T[node * 2 + 1].first);
T[node].second = max(T[node * 2].second, T[node * 2 + 1].second);
}
void upd(int pos, int x, int l, int r, int node) {
if (l == r) {
dp[node] = x;
return;
}
if (pos <= (l + r) / 2)
upd(pos, x, l, (l + r) / 2, node * 2);
else
upd(pos, x, (l + r) / 2 + 1, r, node * 2 + 1);
dp[node] = min(dp[node * 2], dp[node * 2 + 1]);
}
void tap(int a, int b, int l, int r, int node) {
if (a > r || b < l) return;
if (l >= a && r <= b) {
mn = min(mn, T[node].first);
mx = max(mx, T[node].second);
return;
}
tap(a, b, l, (l + r) / 2, node * 2);
tap(a, b, (l + r) / 2 + 1, r, node * 2 + 1);
}
int tap2(int a, int b, int l, int r, int node) {
if (a > r || b < l) return 1e9;
if (l >= a && r <= b) return dp[node];
return min(tap2(a, b, l, (l + r) / 2, node * 2),
tap2(a, b, (l + r) / 2 + 1, r, node * 2 + 1));
}
int main() {
cin >> n >> s >> len;
for (int i = 1; i <= n; i++) cin >> v[i];
build(1, n, 1);
for (int i = 1; i <= n; i++) {
int l = 1, m, r = i - len + 1, ans = 1e9;
while (l <= r) {
m = (l + r) / 2;
mn = 1e9, mx = -1e9;
tap(m, i, 1, n, 1);
if (mx - mn <= s)
r = m - 1, ans = min(ans, m);
else
l = m + 1;
}
if (ans == 1e9) {
upd(i, 1e9, 0, n, 1);
continue;
}
int a = tap2(ans - 1, i - len, 0, n, 1);
upd(i, a + 1, 0, n, 1);
}
int ans = tap2(n, n, 0, n, 1);
if (ans > n) ans = -1;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
const long long MOD = 1e9 + 7;
void solve() {
long long x, y, sum;
long long a[3][3];
for (long long i = 0; i < 3; i++) {
long long temp = 0;
for (long long j = 0; j < 3; j++) {
cin >> a[i][j];
temp += a[i][j];
}
if (i == 0) x = temp;
if (i == 2)
y = temp;
else
sum = temp;
}
for (long long i = 1; i <= 1e5; i++) {
long long check = sum + i;
long long temp1 = check - x;
long long temp2 = check - y;
if (temp1 > 0 && temp2 > 0 && (temp1 + temp2 + i == check)) {
a[1][1] = i;
a[0][0] = temp1;
a[2][2] = temp2;
break;
}
}
for (long long i = 0; i < 3; i++) {
for (long long j = 0; j < 3; j++) {
cout << a[i][j] << " ";
}
cout << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[11];
long long n;
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
vector<long long> v(n + 1);
for (long long i = 1; i <= n; i++) {
cin >> v[i];
}
long long ans = 1;
for (long long i = 1; i <= n; i++) {
cnt[v[i]]++;
map<long long, long long> mp;
for (long long i = 1; i <= 10; i++) {
if (cnt[i]) mp[cnt[i]]++;
}
if (mp.size() == 2) {
auto ite = mp.begin();
auto ite2 = mp.begin();
ite2++;
if ((ite2->first - ite->first == 1 && ite2->second == 1) ||
(ite->first == 1 && ite->second == 1)) {
ans = i;
}
} else if (mp.size() == 1) {
auto ite = mp.begin();
if ((ite->first == 1)) {
ans = i;
} else if (ite->second == 1) {
ans = i;
}
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int mod = 1e9 + 9;
int n, k, m, a, b, c, d;
struct Data {
int x, y;
Data() {}
Data(int x, int y) : x(x), y(y) {}
} da[N];
bool operator<(const Data &A, const Data &B) { return A.x < B.x; }
struct Seg {
int l, r, mid;
int ch[2];
pair<int, int> val;
} tree[N];
int tot;
pair<int, int> update(pair<int, int> a, pair<int, int> b) {
return make_pair(max(a.first + b.second, a.second + b.first) + 1,
a.first + b.first);
}
int BTree(int l, int r) {
if (l > r) return 0;
int loc = l;
for (int i = l + 1; i <= r; i++)
if (da[loc].y < da[i].y) loc = i;
tree[loc].l = l;
tree[loc].r = r;
tree[loc].mid = loc;
tree[loc].ch[0] = BTree(l, tree[loc].mid - 1);
tree[loc].ch[1] = BTree(tree[loc].mid + 1, r);
tree[loc].val = update(tree[tree[loc].ch[0]].val, tree[tree[loc].ch[1]].val);
return loc;
}
pair<int, int> Query(int l, int r, int idx) {
if (r < l || idx == 0) return make_pair(0, -1);
if (tree[idx].l == l && tree[idx].r == r) return tree[idx].val;
if (r < tree[idx].mid) return Query(l, r, tree[idx].ch[0]);
if (l > tree[idx].mid) return Query(l, r, tree[idx].ch[1]);
return update(Query(l, tree[idx].mid - 1, tree[idx].ch[0]),
Query(tree[idx].mid + 1, r, tree[idx].ch[1]));
}
int x[N];
int main() {
tree[0].val = make_pair(0, -1);
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d", &da[i].x, &da[i].y);
}
scanf("%d%d%d%d", &a, &b, &c, &d);
for (int i = k + 1; i <= n; i++) {
da[i].x = (1ll * da[i - 1].x * a + b) % mod;
da[i].y = (1ll * da[i - 1].y * c + d) % mod;
}
sort(da + 1, da + n + 1);
for (int i = 1; i <= n; i++) x[i] = da[i].x;
tot = 0;
int root = BTree(1, n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
l = lower_bound(x + 1, x + n + 1, l) - x;
r = upper_bound(x + 1, x + n + 1, r) - x - 1;
printf("%d\n", Query(l, r, root).first);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int l_beg = -1;
int r_beg = -1;
string pattern = "[:";
int j = 0;
for (int i = 0; i < n; i++) {
if (s[i] == pattern[j]) {
j++;
if (j == 2) {
l_beg = i;
break;
}
}
}
pattern = "]:";
for (int i = n - 1, j = 0; i >= 0; i--) {
if (s[i] == pattern[j]) {
j++;
if (j == 2) {
r_beg = i;
break;
}
}
}
if (r_beg == -1 || l_beg == -1 || l_beg >= r_beg) {
cout << -1 << endl;
} else {
int ans = 0;
for (int i = l_beg + 1; i < r_beg; i++)
if (s[i] == '|') ans += 1;
cout << ans + 4 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
vector<long long int> graph[200010], backIn[200010], backOut[200010],
tree[200010];
long long int dep[200010], par[200010];
void dfs(long long int i, long long int p) {
par[i] = p;
dep[i] = dep[p] + 1;
for (long long int j : graph[i])
if (j - p) {
if (!dep[j]) {
tree[i].push_back(j);
dfs(j, i);
} else if (dep[j] < dep[i]) {
backIn[j].push_back(i);
backOut[i].push_back(j);
}
}
}
vector<tuple<long long int, long long int, long long int>> triples;
long long int root;
bool fillTriples(long long int i) {
vector<long long int> edges = backOut[i];
for (long long int j : tree[i])
if (!fillTriples(j)) edges.push_back(j);
for (long long int k = 0; k + 1 < edges.size(); k += 2)
triples.push_back({edges[k], i, edges[k + 1]});
if ((edges.size() & 1) && i != root)
triples.push_back({edges.back(), i, par[i]});
return edges.size() & 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n;
cin >> n;
long long int m;
cin >> m;
while (m--) {
long long int u;
cin >> u;
long long int v;
cin >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (long long int i = 1; i < (n + 1); ++i)
if (!dep[i]) {
dfs(i, i);
root = i;
fillTriples(i);
}
cout << triples.size() << '\n';
for (auto a : triples)
cout << get<0>(a) << ' ' << get<1>(a) << ' ' << get<2>(a) << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > v(n, vector<int>(m));
for (int i = 0; i < m; ++i) {
for (int j = n - 1; j > -1; --j) {
cin >> v[j][i];
}
}
int mn = 100, sum = 0;
for (int i = 0; i < m; ++i) sum += v[0][i];
vector<int> ans(m);
for (int i = 0; i < m; ++i) ans[i] = i;
for (int i = 1; i < n; ++i) {
int k = 0, sumi = 0, summ = sum;
vector<pair<int, int> > a(m);
vector<int> el;
for (int j = 0; j < m; ++j)
a[j].first = v[0][j] - v[i][j], a[j].second = j, sumi += v[i][j];
if (sumi >= sum) {
mn = 0, ans.clear();
break;
}
sort(a.rbegin(), a.rend());
for (int j = 0; j < m; ++j) {
el.push_back(a[j].second);
sumi -= v[i][a[j].second], summ -= v[0][a[j].second];
if (sumi >= summ) break;
}
if (el.size() < mn) mn = el.size(), ans = el;
}
cout << mn << '\n';
for (auto i : ans) cout << i + 1 << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 0x3f3f3f3f;
vector<pair<pair<int, int>, int> > tubes;
int vis[303];
vector<int> g[303];
int v;
int a[303], b[303];
long long A, B;
int n, e;
void dfs(int now) {
vis[now] = 1;
A += a[now];
B += b[now];
for (auto it : g[now]) {
if (!vis[it]) dfs(it);
}
}
int fa[303];
vector<int> order;
vector<int> tree_edges[303];
void build(int now, int pre = 0) {
fa[now] = pre;
vis[now] = 2;
order.push_back(now);
for (auto it : g[now]) {
if (vis[it] != 2) {
tree_edges[now].push_back(it);
tree_edges[it].push_back(now);
build(it, now);
}
}
}
bool updated[303];
void pull_up(int index) {
for (auto it : tree_edges[index]) {
if (it != fa[index]) {
int can = min(v - a[index], a[it]);
if (updated[it]) can = min(can, a[it] - b[it]);
if (can) tubes.push_back(make_pair(make_pair(it, index), can));
a[it] -= can;
a[index] += can;
pull_up(it);
}
}
}
void work(int root) {
order.clear();
build(root);
for (auto it : order) {
int to = fa[it];
int from = it;
while (to) {
int can = v - a[to];
if (min(a[from], can)) {
tubes.push_back(make_pair(make_pair(from, to), min(a[from], can)));
a[to] += min(a[from], can);
a[from] -= min(a[from], can);
}
from = to;
to = fa[to];
}
}
for (auto it : order) assert(a[it] <= v);
reverse(order.begin(), order.end());
for (int i = 1; i <= n; ++i) {
bool ok = 0;
for (auto it : order) {
if (updated[it]) continue;
if (a[it] >= b[it])
;
else {
ok = 1;
int needs = b[it] - a[it];
vector<int> way;
int to = fa[it];
while (to) {
way.push_back(to);
if (a[to] >= needs) {
break;
}
to = fa[to];
}
reverse(way.begin(), way.end());
way.push_back(it);
for (int i = 0; i < way.size() - 1; ++i) {
int move = min(a[way[i]], v - a[way[i + 1]]);
move = min(move, needs);
a[way[i]] -= move;
a[way[i + 1]] += move;
tubes.push_back(make_pair(make_pair(way[i], way[i + 1]), move));
}
updated[it] = 1;
pull_up(root);
break;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> v >> e;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> b[i];
for (int i = 1; i <= e; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
A = B = 0;
dfs(i);
if (A != B) {
cout << "NO\n";
return 0;
}
work(i);
}
}
cout << tubes.size() << endl;
for (auto it : tubes) {
cout << it.first.first << ' ' << it.first.second << ' ' << it.second
<< endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
namespace LCP {
namespace SA {
int sa[1000000 + 5];
int rk[1000000 + 5], ht[1000000 + 5];
template <typename T>
void init(T s[], int n, int m) {
static int t1[1000000 + 5], t2[1000000 + 5], c[1000000 + 5];
int *x = t1, *y = t2;
for (int i = 0; i < m; ++i) c[i] = 0;
for (int i = 0; i < n; ++i) c[x[i] = s[i]]++;
for (int i = 1; i < m; ++i) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--c[x[i]]] = i;
for (int j = 1; j <= n; j <<= 1) {
int p = 0;
for (int i = n - j; i < n; ++i) y[p++] = i;
for (int i = 0; i < n; ++i) {
if (sa[i] >= j) y[p++] = sa[i] - j;
}
for (int i = 0; i < m; ++i) c[i] = 0;
for (int i = 0; i < n; ++i) c[x[y[i]]]++;
for (int i = 1; i < m; ++i) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--c[x[y[i]]]] = y[i];
std::swap(x, y);
p = 1;
x[sa[0]] = 0;
for (int i = 1; i < n; ++i)
x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + j] == y[sa[i] + j])
? p - 1
: p++;
if (p >= n) break;
m = p;
}
}
template <typename T>
void get_height(T s[], int n) {
int k = 0;
for (int i = 0; i < n; i++) rk[sa[i]] = i;
for (int i = 0; i < n; i++) {
if (k) --k;
if (rk[i] == 0)
ht[rk[i]] = 0;
else {
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) ++k;
ht[rk[i]] = k;
}
}
}
} // namespace SA
template <typename T, typename Comparer, size_t MaxN>
class st_table {
T dp[MaxN][32];
Comparer comp;
int n;
public:
st_table(Comparer _comp = Comparer()) : comp(_comp) {}
void init(const T* array, int n) {
this->n = n;
for (int i = 0; i < n; ++i) dp[i][0] = array[i];
for (int j = 1; (1 << j) <= n; ++j) {
for (int i = 0; i + (1 << j) - 1 < n; ++i)
dp[i][j] = min(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1], comp);
}
}
T query(int left, int right) const {
int k = 8 * sizeof(int) - __builtin_clz(right - left + 1) - 1;
return min(dp[left][k], dp[right - (1 << k) + 1][k], comp);
}
};
template <typename T, size_t MaxN>
using st_table_min = st_table<T, std::less<int>, MaxN>;
st_table_min<int, 1000005> rmq;
void init(const char* s, int len) {
SA::init(s, len + 1, 256);
SA::get_height(s, len + 1);
rmq.init(SA::ht, len + 1);
}
int query(int suf1, int suf2) {
assert(suf1 != suf2);
if (SA::rk[suf1] > SA::rk[suf2]) std::swap(suf1, suf2);
return rmq.query(SA::rk[suf1] + 1, SA::rk[suf2]);
}
} // namespace LCP
class segment_tree {
int val[1000005 * 4];
bool lazy[1000005 * 4];
void lazy_pushdown(int segp) {
if (lazy[segp]) {
int lchild = ((segp) << 1);
int rchild = (((segp) << 1) | 1);
val[lchild] = std::max(val[lchild], val[segp]);
val[rchild] = std::max(val[rchild], val[segp]);
lazy[lchild] = lazy[rchild] = true;
lazy[segp] = false;
}
}
public:
void init(int segleft, int segright, int segp) {
val[segp] = -1;
lazy[segp] = false;
if (segleft != segright) {
int mid = (segleft + segright) / 2;
init(segleft, mid, ((segp) << 1));
init(mid + 1, segright, (((segp) << 1) | 1));
}
}
void update(int left, int right, int value, int segleft, int segright,
int segp) {
if (left == segleft && right == segright) {
val[segp] = std::max(val[segp], value);
lazy[segp] = true;
} else {
lazy_pushdown(segp);
int mid = (segleft + segright) / 2;
if (right <= mid)
update(left, right, value, segleft, mid, ((segp) << 1));
else if (left > mid)
update(left, right, value, mid + 1, segright, (((segp) << 1) | 1));
else {
update(left, mid, value, segleft, mid, ((segp) << 1));
update(mid + 1, right, value, mid + 1, segright, (((segp) << 1) | 1));
}
}
}
template <typename CallbackT>
void collect(int left, int right, CallbackT callback, int segleft,
int segright, int segp) {
if (segleft == segright)
callback(segleft, val[segp]);
else {
lazy_pushdown(segp);
int mid = (segleft + segright) / 2;
if (right <= mid)
collect(left, right, callback, segleft, mid, ((segp) << 1));
else if (left > mid)
collect(left, right, callback, mid + 1, segright, (((segp) << 1) | 1));
else {
collect(left, mid, callback, segleft, mid, ((segp) << 1));
collect(mid + 1, right, callback, mid + 1, segright,
(((segp) << 1) | 1));
}
}
}
};
char s[1000005];
int after[500005], before[500005];
segment_tree segtree;
int n;
int main(int argc, char* argv[]) {
scanf("%d", &n);
scanf("%s", s);
int half = (n - 1) / 2;
LCP::init(s, n);
for (int i = 0; i <= half; ++i) {
int mir = n - i - 1;
if (i == mir) continue;
after[i] = LCP::query(i, mir);
}
std::reverse(s, s + n);
LCP::init(s, n);
for (int i = 0; i <= half; ++i) {
int mir = n - i - 1;
if (i == mir) continue;
before[i] = LCP::query(i, mir);
}
segtree.init(1, n, 1);
for (int i = 0; i <= half; ++i) {
int r = std::min(before[i], after[i]);
if (r == 0) continue;
assert(i - r + 1 >= 0);
segtree.update(i - r + 1 + 1, i + 1, i + 1, 1, n, 1);
}
segtree.collect(
1, half + 1,
[](int pos, int value) {
int len = -1;
if (value != -1) {
assert(value >= pos);
len = (value - pos + 1) * 2 - 1;
}
printf("%d ", len);
},
1, n, 1);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> b(6);
for (int i = 0; i < 6; i++) cin >> b[i];
bool check = false;
for (int i = 0; i < 6; i++)
for (int j = 3; j < 5; j++)
if (b[i][j] == '.') {
b[i][j] = 'P';
check = true;
for (int i = 0; i < 6; i++) cout << b[i] << endl;
return 0;
}
if (!check)
for (int i = 0; i < 6; i++)
for (int j = 0; j < 8; j++)
if (b[i][j] == '.') {
b[i][j] = 'P';
check = true;
for (int i = 0; i < 6; i++) cout << b[i] << endl;
return 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1909;
const double eps = 1e-6;
long long n;
long long get(long long n) {
long long l = 0, r = 1e9, mid;
while (l < r) {
mid = (l + r) >> 1;
if (mid * (mid + 1) * 3 >= n)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
cin >> n;
if (n == 0) {
cout << "0 0" << endl;
return 0;
}
long long a = get(n);
long long c = n - 3 * a * (a - 1);
long long x, y;
if (c <= a) {
x = a * 2 - c;
y = c * 2;
} else if (c <= 2 * a) {
c -= a;
x = a - c * 2;
y = a * 2;
} else if (c <= a * 3) {
c -= a * 2;
x = -a - c;
y = a * 2 - c * 2;
} else if (c <= a * 4) {
c -= a * 3;
x = -a * 2 + c;
y = -c * 2;
} else if (c <= a * 5) {
c -= a * 4;
x = -a + c * 2;
y = -a * 2;
} else {
c -= a * 5;
x = a + c;
y = -a * 2 + c * 2;
}
cout << x << " " << y;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T = 1;
while (T--) {
int n;
std::cin >> n;
std::vector<int> a(n);
for (size_t iai = 0; iai < a.size(); iai++) {
std::cin >> a[iai];
};
int ans = 0;
int temp = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == 1) {
temp++;
} else {
ans = max(ans, temp);
temp = 0;
}
}
if (temp != 0 && temp != n) {
int q = 0;
while (a[q] == 1) {
temp++;
q++;
}
}
ans = max(ans, temp);
std::cout << ans << std::endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[101];
cin >> str;
int flag = -1;
for (int i = 0; i < 101; i++) {
if (str[i] == '1' && flag == -1)
flag = 0;
else if (str[i] == '0' && flag > -1)
flag++;
}
if (flag >= 6)
cout << "yes";
else
cout << "no";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> graph;
vector<vector<int>> cycles;
vector<bool> visited;
vector<int> parent;
vector<int> endpoints;
vector<int> weights;
void dfs(int u, int p) {
visited[u] = 1;
parent[u] = p;
for (auto [v, w] : graph[u]) {
if (v == parent[u] || v == p) continue;
weights[v] = w;
if (visited[v]) {
endpoints.push_back(u);
parent[v] = u;
continue;
}
dfs(v, u);
}
}
int MOD = 1000000007;
int modpow(int b, int e) {
int a = 1;
while (e) {
if (e & 1) a = 1LL * a * b % MOD;
b = 1LL * b * b % MOD;
e /= 2;
}
return a;
}
struct poly {
int arr[1 << 17];
poly() {
for (int i = 0; i != 1 << 17; ++i) arr[i] = 0;
}
int degree() { return (1 << 17); }
int& operator[](int i) { return arr[i]; }
};
poly FWHT(poly P, bool inverse) {
for (int len = 1; 2 * len <= P.degree(); len <<= 1) {
for (int i = 0; i < P.degree(); i += 2 * len) {
for (int j = 0; j < len; j++) {
int u = P[i + j];
int v = P[i + len + j];
P[i + j] = ((u + v) % MOD + MOD) % MOD;
P[i + len + j] = ((u - v) % MOD + MOD) % MOD;
}
}
}
if (inverse) {
for (int i = 0; i < P.degree(); i++)
P[i] = 1LL * P[i] * modpow(P.degree(), MOD - 2) % MOD;
}
return P;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int total = 0;
graph.resize(n);
for (int i = 0; i != m; ++i) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
total ^= w;
}
visited.resize(n);
parent.resize(n, -1);
weights.resize(n);
dfs(0, -1);
for (int u : endpoints) {
cycles.push_back({weights[u]});
for (int v = parent[u]; v != u; v = parent[v])
cycles[cycles.size() - 1].push_back(weights[v]);
;
}
vector<poly> polys(cycles.size());
for (int i = 0; i != cycles.size(); ++i) {
for (int v : cycles[i]) polys[i][v]++;
polys[i] = FWHT(polys[i], 0);
}
poly Q = poly();
for (int i = 0; i != 1 << 17; ++i) Q[i] = 1;
for (poly& a : polys)
for (int i = 0; i != 1 << 17; ++i) Q[i] = 1LL * Q[i] * a[i] % MOD;
Q = FWHT(Q, 1);
MOD = 998244353;
polys = vector<poly>(cycles.size());
for (int i = 0; i != cycles.size(); ++i) {
for (int v : cycles[i]) polys[i][v]++;
polys[i] = FWHT(polys[i], 0);
}
poly QQ = poly();
for (int i = 0; i != 1 << 17; ++i) QQ[i] = 1;
for (poly& a : polys)
for (int i = 0; i != 1 << 17; ++i) QQ[i] = 1LL * QQ[i] * a[i] % MOD;
QQ = FWHT(QQ, 1);
for (int i = 0; i != 1 << 17; ++i) {
if (Q[i ^ total] || QQ[i ^ total]) {
cout << i << ' ' << Q[i ^ total] << '\n';
break;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > coprime(100001);
void prime_factorization() {
for (long long i = 2; i <= 100001; i += 2) {
coprime[i].push_back(2);
}
for (long long i = 3; i <= 100001; i += 3) {
coprime[i].push_back(3);
}
for (long long i = 5; i <= 50000; i += 6) {
if (coprime[i].size() == 0) {
for (long long j = i; j <= 100000; j += i) {
coprime[j].push_back(i);
}
}
if (coprime[i + 2].size() == 0) {
for (long long j = i + 2; j <= 100000; j += i + 2) {
coprime[j].push_back(i + 2);
}
}
}
}
bool isprime(long long n) {
if (n < 2) return false;
if (n == 2 || n == 3) return true;
if (n % 2 == 0) return false;
if (n % 3 == 0) return false;
for (long long i = 5; i <= sqrt(n); i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
void swap(long long &a, long long &b) {
long long temp = a;
a = b;
b = temp;
}
long long bin_power(long long a, long long n) {
if (a == 0) return 0;
long long res = 1;
while (n) {
if (n % 2) {
res = (res * a) % 1000000007;
n--;
} else {
a = (a * a) % 1000000007;
n /= 2;
}
}
return res;
}
void p_factors(long long &n, map<long long, long long> &m) {
if (n % 2 == 0) {
long long c = 0;
while (n % 2 == 0) {
n /= 2;
c++;
}
m[2] = c;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
long long c = 0;
while (n % i == 0) {
n /= i;
c++;
}
m[i] = c;
}
}
if (n != 1) m[n] = 1;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long extended_gcd(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
long long x1, y1;
long long g = extended_gcd(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return g;
}
void simple_sieve(long long n, vector<long long> &primes) {
if (n < 2) return;
if (n < 3) {
primes.push_back(2);
return;
}
vector<bool> mark(n + 1, true);
mark[2] = true;
mark[3] = true;
primes.push_back(2);
primes.push_back(3);
for (long long i = 5; i * i < n; i += 6) {
if (mark[i]) {
for (long long j = i * i; j < n; j += i) mark[j] = false;
}
if (mark[i + 2] && (i + 2) < sqrt(n)) {
for (long long j = (i + 2) * (i + 2); j < n; j += (i + 2))
mark[j] = false;
}
}
for (long long i = 5; i < n; i += 6) {
if (mark[i]) primes.push_back(i);
if (mark[i + 2] && (i + 2) < n) primes.push_back(i + 2);
}
}
long long linear_sieve(long long n, vector<long long> &primes) {
if (n < 2) return 0;
if (n < 3) {
primes.push_back(2);
return 1;
}
vector<long long> mark(n + 1);
for (long long i = 2; i <= n; i++) {
if (mark[i] == 0) {
primes.push_back(i);
mark[i] = i;
}
for (long long j = 0;
j < primes.size() && primes[j] <= mark[i] && i * primes[j] <= n; j++)
mark[i * primes[j]] = primes[j];
}
return primes.size();
}
void segmented_sieve(long long n, vector<long long> &primes) {
if (n < 2) return;
long long limit = sqrt(n) + 1;
simple_sieve(limit, primes);
long long low = limit;
long long high = 2 * limit;
while (low < n) {
if (high >= n) high = n + 1;
vector<bool> mark(high - low + 2, true);
for (long long i = 0; i < primes.size(); i++) {
long long lolim = (low / primes[i]) * primes[i];
if (lolim < low) lolim += primes[i];
for (long long j = lolim; j < high; j += primes[i]) mark[j - low] = false;
}
for (long long j = low; j < high; j++) {
if (mark[j - low]) primes.push_back(j);
}
low += limit;
high += limit;
}
}
void ranged_primes(long long low, long long high, vector<long long> &primes) {
if (low < 2) low = 2;
if (high < 2) return;
long long lim = sqrt(high);
vector<long long> pr;
linear_sieve(lim, pr);
if (pr.size() == 0) {
if (high == 2) {
primes.push_back(2);
return;
}
if (high == 3) {
if (low <= 2) {
primes.push_back(2);
primes.push_back(3);
return;
}
primes.push_back(3);
return;
}
}
vector<bool> mark(high - low + 1, true);
for (auto &i : pr) {
long long j = i * i;
if (j < low) {
j = (low / i) * i;
if (j < low) j += i;
}
while (j <= high) {
mark[j - low] = false;
j += i;
}
}
for (long long i = low; i <= high; i++) {
if (mark[i - low]) primes.push_back(i);
}
}
long long totient(long long n) {
long long res = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
res -= res / i;
}
}
if (n > 1) res -= res / n;
return res;
}
void phi_1_to_n(long long n, vector<long long> &phi) {
for (long long i = 0; i <= n; i++) {
phi[i] = i;
}
for (long long i = 2; i <= n; i++) {
if (phi[i] == i) {
for (long long j = i; j <= n; j += i) {
phi[j] -= phi[j] / i;
}
}
}
}
long long factorial(long long n) {
long long res = 1;
for (long long i = 2; i <= n; i++) {
res = (res * i) % 1000000007;
}
return res % 1000000007;
}
long long sumofint(long long n) {
string s = to_string(n);
long long sum = 0;
for (long long i = 0; i < s.size(); i++) {
int j = s[i];
j -= 48;
sum += j;
}
return sum;
}
long long modinverse(long long n) { return bin_power(n, 1000000007 - 2); }
long long ncr(long long n, long long r) {
if (n < 0 || r > n || r < 0) return 0;
if (n - r < r) r = n - r;
vector<long long> c(n + 1);
c[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, r); j > 0; j--) {
c[j] = (c[j] + c[j - 1]) % 1000000007;
}
}
return c[r] % 1000000007;
}
void dfsinto(long long v, vector<vector<long long> > &adj,
vector<long long> &mark, stack<long long> &s) {
mark[v] = 1;
s.push(v);
for (long long x : adj[v]) {
if (!mark[x]) {
dfsinto(x, adj, mark, s);
}
}
}
void dfs(vector<vector<long long> > &v, stack<long long> &s,
vector<long long> &mark) {
for (long long i = 0; i < 26; i++) {
if (mark[i] || !v[i].size()) continue;
dfsinto(i, v, mark, s);
}
}
bool iscyclic(vector<vector<long long> > &g) {
queue<long long> q;
vector<long long> mark(26), p(26);
for (long long i = 0; i < 26; i++) {
if (mark[i] || !g[i].size()) continue;
mark[i] = 1;
q.push(i);
p[i] = -1;
while (!q.empty()) {
long long f = q.front();
q.pop();
for (long long x : g[f]) {
if (mark[x]) {
if (x != p[f]) return true;
} else {
mark[x] = 1;
q.push(x);
p[x] = f;
}
}
}
}
return false;
}
long long lcs(string &a, string &b, long long m, long long n, long long &l1,
long long &l2) {
vector<vector<long long> > L(n, vector<long long>(m));
long long i, j, flag = 0;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (a[i - 1] == b[j - 1]) {
L[i][j] = L[i - 1][j - 1] + 1;
} else
L[i][j] = max(L[i - 1][j], L[i][j - 1]);
}
}
return L[m][n];
}
bool issorted(vector<long long> &v, long long n) {
for (long long i = 1; i < n; i++) {
if (v[i] < v[i - 1]) return false;
}
return true;
}
string lexogy(string &a, string &b) {
long long n = a.size(), m = b.size();
if (n < m) swap(n, m);
for (long long i = 0; i < m; i++) {
if (a[i] == b[i])
continue;
else if (a[i] < b[i])
return a;
else
return b;
}
if (a.size() > b.size())
return a;
else if (b.size() > a.size())
return b;
else
return "EQUAL";
}
string bin_string(long long n, long long l) {
string s;
for (long long i = l - 1; i >= 0; i--) {
if (n % 2)
s.push_back('1');
else
s.push_back('0');
n /= 2;
}
reverse(s.begin(), s.end());
return s;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long tc = 1;
cin >> tc;
while (tc--) {
long long n, ans = 0;
cin >> n;
string s[n];
map<string, long long> m;
vector<long long> v(10);
for (long long i = 0; i < n; i++) {
cin >> s[i];
++m[s[i]];
++v[s[i][3] - '0'];
}
auto it = m.begin();
while (it != m.end()) {
ans += it->second - 1;
it++;
}
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (s[j] == s[i]) {
for (long long k = 0; k < 10; k++) {
if (v[k]) continue;
s[j][3] = '0' + k;
v[k] = 1;
break;
}
}
}
}
cout << ans << endl;
for (long long i = 0; i < n; i++) cout << s[i] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ara[n];
for (int i = 0; i < n; i++) cin >> ara[i];
sort(ara, ara + n);
int cur = 1;
for (int i = 0; i < n; i++) {
if (ara[i] >= cur) cur++;
}
cout << cur << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100003;
vector<int> vec;
int main() {
vec.push_back(0);
vec.push_back(1);
int a = 0, b = 1, c;
for (int i = 0;; ++i) {
c = a + b;
if (c >= 1000000000) break;
vec.push_back(c);
b = c;
a = b;
}
int n;
while (cin >> n) {
printf("0 0 %d", n);
}
}
| 0 |
#include <bits/stdc++.h>
const int MAX = (int)(5e5) + 7;
const int MOD = (int)(1e9) + 7;
const int INF_I = (int)(1e9) + 7;
const long long INF_LL = (long long)(1e18) + 7;
using namespace std;
string s;
string t;
int z[MAX];
template <typename T>
void info(T& a) {
for (auto& el : a) cout << el << ' ';
cout << '\n';
}
inline int input_I() {
int a;
cin >> a;
return a;
}
inline long long input_LL() {
long long a;
cin >> a;
return a;
}
void boot() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void z_func(string& s) {
int n = (int)((s).size());
int l = 0, r = 0;
for (int i = 1; i < n; ++i) {
if (i <= l) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
}
pair<int, int> get_symb(string& s) {
int zers = 0, ones = 0;
for (auto& i : s) {
if (i == '0')
++zers;
else
++ones;
}
return {zers, ones};
}
void solve() {
string ans;
auto [s_0, s_1] = get_symb(s);
auto [t_0, t_1] = get_symb(t);
if (s_0 >= t_0 && s_1 >= t_1) {
cout << t;
s_0 -= t_0;
s_1 -= t_1;
int st = -1;
int sz_t = (int)((t).size());
int l = 0, r = 0;
for (int i = 1; i < sz_t; ++i) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < sz_t && t[z[i]] == t[i + z[i]]) ++z[i];
if (z[i] == sz_t - i) {
st = i;
break;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
if (st != -1) {
string suff = "";
for (int i = sz_t - st; i < sz_t; ++i) {
suff += t[i];
}
auto [suff_0, suff_1] = get_symb(suff);
while (s_0 >= suff_0 && s_1 >= suff_1) {
cout << suff;
s_0 -= suff_0;
s_1 -= suff_1;
}
}
while (s_0 >= t_0 && s_1 >= t_1) {
cout << t;
s_0 -= t_0;
s_1 -= t_1;
}
for (int i = 0; i < s_0; ++i) cout << '0';
for (int i = 0; i < s_1; ++i) cout << '1';
} else {
cout << s;
}
}
signed main() {
boot();
while (cin >> s >> t) solve();
}
| 4 |
#include <bits/stdc++.h>
long long i, j, k, m, n;
int main() {
scanf("%I64d%I64d", &n, &m);
m = (m + 1) / 2;
for (i = 1; i <= m; i++) {
for (j = 2, k = n; j * j <= k; j++)
if (!(k % j)) {
n = n / j * (j - 1);
while (!(k % j)) k = k / j;
}
if (k > 1) n = n / k * (k - 1);
if (n == 1) break;
}
printf("%I64d", n % 1000000007);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
int n, m, i, x = 0, y, z;
cin >> n;
string s[n + 1];
for (int i = 0; i < n; i++) cin >> s[i];
vector<pair<int, int>> v;
if (s[0][1] == s[1][0]) {
if (s[n - 1][n - 2] == s[0][1]) {
v.push_back({n, n - 1});
}
if (s[n - 2][n - 1] == s[0][1]) {
v.push_back({n - 1, n});
}
} else if (s[n - 1][n - 2] == s[n - 2][n - 1]) {
if (s[n - 1][n - 2] == s[0][1]) {
v.push_back({1, 2});
}
if (s[n - 2][n - 1] == s[1][0]) {
v.push_back({2, 1});
}
} else {
if (s[0][1] != '0') {
v.push_back({1, 2});
}
if (s[1][0] != '0') {
v.push_back({2, 1});
}
if (s[n - 2][n - 1] != '1') {
v.push_back({n - 1, n});
}
if (s[n - 1][n - 2] != '1') {
v.push_back({n, n - 1});
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> M;
int countbits(int n) {
int ret = 0;
while (n) {
if (n % 2) ret++;
n /= 2;
}
return ret;
}
int check(char c, int n) {
n /= pow(2, M[c]);
return n % 2;
}
void setmap() {
M['1'] = 0;
M['2'] = 1;
M['3'] = 2;
M['4'] = 3;
M['5'] = 4;
M['R'] = 5;
M['G'] = 6;
M['B'] = 7;
M['Y'] = 8;
M['W'] = 9;
}
int main() {
int n, i, ans, flag, j, k;
cin >> n;
string s[n];
for (i = 0; i < n; i++) {
cin >> s[i];
}
setmap();
ans = 2000000000;
for (i = 0; i < 1024; i++) {
flag = 0;
for (j = 0; j < n; j++) {
for (k = j + 1; k < n; k++) {
if (s[j] == s[k]) {
continue;
} else if (s[j][0] == s[k][0]) {
if (!check(s[j][1], i) && !check(s[k][1], i)) {
flag = 1;
break;
}
} else if (s[j][1] == s[k][1]) {
if (!check(s[j][0], i) && !check(s[k][0], i)) {
flag = 1;
break;
}
} else {
if (!check(s[j][1], i) && !check(s[k][1], i) && !check(s[j][0], i) &&
!check(s[k][0], i)) {
flag = 1;
break;
}
}
}
if (flag) break;
}
if (!flag) {
ans = min(ans, countbits(i));
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int M, mn = INT_MAX;
scanf("%d", &M);
for (int i = 0; i < M; i++) {
int x;
scanf("%d", &x);
mn = min(mn, x);
}
int N;
scanf("%d", &N);
int a[N + 2];
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
sort(a, a + N, greater<int>());
int sum = 0, cnt = 0;
for (int i = 0; i < N; i++) {
cnt++;
if (cnt <= mn) sum += a[i];
if (cnt == mn + 2) cnt = 0;
}
printf("%d", sum);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a1, a2, b1, b2, c1, c2;
cin >> a1 >> a2 >> b1 >> b2 >> c1 >> c2;
if (b1 < a1 and b2 < a2 and c1 < a1 and c2 < a2) {
cout << "YES";
return;
} else if (b1 > a1 and b2 < a2 and c1 > a1 and c2 < a2) {
cout << "YES";
return;
} else if (b1 > a1 and b2 > a2 and c1 > a1 and c2 > a2) {
cout << "YES";
return;
} else if (b1 < a1 and b2 > a2 and c1 < a1 and c2 > a2) {
cout << "YES";
return;
}
cout << "NO";
return;
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
struct Point {
long long x, y;
Point() {}
Point(long long _x, long long _y) : x(_x), y(_y) {}
Point operator-(const Point &t) const { return Point(x - t.x, y - t.y); }
long long operator*(const Point &t) const { return x * t.y - y * t.x; }
} p[MAXN];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long pointOnLine(Point p, Point q) {
long long tx = abs(p.x - q.x), ty = abs(p.y - q.y);
if (tx == 0) return ty;
if (ty == 0) return tx;
return gcd(tx, ty);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d%I64d", &p[i].x, &p[i].y);
long long tmp = 0;
for (int i = 0; i < n; i++) {
tmp += p[i] * p[(i + 1) % n];
tmp -= pointOnLine(p[i], p[(i + 1) % n]);
}
tmp = (tmp + 2) / 2;
double res = 0, cut = pow(2.0, -n), buf = 1 - (1LL * n * n + n + 2) / 2 * cut;
for (int i = 0; i < n; i++) {
long long cnt = 0;
double q = 0.5;
for (int j = (i + 1) % n, k = 2; k <= min(n - 1, 40);
j = (j + 1) % n, k++) {
res += cnt * ((q *= 0.5) - cut) / buf;
long long now = (p[j] - p[i]) * (p[(j + 1) % n] - p[i]);
now -= pointOnLine(p[i], p[j]);
now -= pointOnLine(p[j], p[(j + 1) % n]);
now -= pointOnLine(p[(j + 1) % n], p[i]);
cnt += (now + 2) / 2;
cnt += pointOnLine(p[i], p[(j + 1) % n]) - 1;
}
}
res = tmp - res;
printf("%.10f", res);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int check_for(int k) {
if (k == 0) return 0;
if (k == 1 || k == 2 || k == 3 || k == 4 || k == 5 || k == 6 || k == 7 ||
k == 8 || k == 8 || k == 9 || k == 11)
return 4;
if (k == 10)
return 15;
else
return 0;
}
int main() {
int n;
cin >> n;
int k = n - 10;
cout << check_for(k);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ok, sx, sy, vis[1005][1005], a[1005][1005], in[1005][1005], row[1005][1005],
col[1005][1005], n, m, val;
int w[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
void solve(int cur) {
queue<pair<int, int> > q;
memset(vis, 0, sizeof(vis));
memset(in, 0, sizeof(in));
q.push({sx, sy});
while (!q.empty()) {
pair<int, int> now = q.front();
q.pop();
if (vis[now.first][now.second]) continue;
vis[now.first][now.second] = 1;
for (int j = 0; j < 4; j++) {
bool flag = 1;
for (int i = 1; i <= cur; i++) {
if (!a[now.first + i * w[j][0]][now.second + i * w[j][1]]) {
flag = 0;
break;
}
}
if (flag) {
for (int i = 1; i < cur; i++) {
vis[now.first + i * w[j][0]][now.second + i * w[j][1]] = 1;
}
in[now.first + cur * w[j][0]][now.second + cur * w[j][1]]++;
q.push({now.first + cur * w[j][0], now.second + cur * w[j][1]});
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!vis[i][j] && a[i][j]) return;
}
}
int tot = 0;
for (int i = sx - (sx - 1) / cur * cur; i <= n; i += cur) {
for (int j = sy; j <= m; j += cur) {
if (in[i][j] & 1) tot++;
}
}
if (tot <= 2) {
ok = 1;
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
row[i][j] = (row[i][j - 1] + 1) * a[i][j];
col[i][j] = (col[i - 1][j] + 1) * a[i][j];
val = max(val, max(row[i][j], col[i][j]));
}
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
if (a[i][j]) {
sx = i, sy = j;
break;
}
}
if (sx) break;
}
for (int i = val - 1; i >= 2; i--) {
if ((val - 1) % i == 0) {
solve(i);
if (ok) {
for (int j = 2; j <= i; j++) {
if (i % j == 0) printf("%d ", j);
}
return 0;
}
}
}
printf("-1");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int INF = 0x3f3f3f3f;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int ans = INF;
for (int i = 0; i < n / 2; i++) ans = min(ans, a[i + n / 2] - a[i]);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int npr;
int a[100000], f[100000], ff[100000 + 1];
int ind;
int cur;
int ans;
inline void check(int p) {
if (ff[p] < ind) ++ans;
ff[p] = cur;
}
inline void factor(int n) {
for (int i = 1; i * i <= n; ++i)
if (n % i == 0) {
check(i);
if (i * i != n) check(n / i);
}
}
int n;
int main() {
for (int i = 0; i <= 100000; ++i) ff[i] = -1;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
cur = i;
ans = 0;
ind = i - y;
factor(x);
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int pct(int x) { return __builtin_popcount(x); }
int bit(int x) { return 31 - __builtin_clz(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
const int maxn = 1e5 * 3 + 20;
int n, _, q, k;
int a[maxn];
int b[maxn];
void solve() {
cin >> n;
set<int> seen;
for (signed i = 1; i <= n; i++) cin >> a[i], seen.insert(a[i]);
set<int> has;
set<int> spe;
seen.insert(0);
for (signed i = 0; i <= a[n]; i++) {
if (i != a[n]) {
has.insert(i);
}
if (!seen.count(i)) {
spe.insert(i);
}
}
int cnt = 1e5 + 2;
while ((signed)has.size() < n) {
has.insert(cnt);
spe.insert(cnt);
cnt++;
}
bool valid = true;
for (signed i = 1; i <= n; i++) {
if (a[i] == a[i - 1]) {
int large = *(spe.begin());
b[i] = large;
has.erase(large);
spe.erase(large);
} else {
b[i] = a[i - 1];
if (!has.count(a[i - 1])) {
valid = false;
break;
}
has.erase(a[i - 1]);
}
}
if (!valid) {
cout << -1 << endl;
exit(0);
}
for (signed i = 1; i <= n; i++) {
cout << b[i] << " ";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const bool online_judge = true;
const long long inf = 1LL << 60;
long long toInt(string s) {
long long res;
stringstream ss;
ss << s;
ss >> res;
return res;
}
string toString(long long n) {
stringstream ss;
ss << n;
return ss.str();
}
void run() {
long long n;
vector<long long> v;
cin >> n;
long long sum = 0;
for (long long _ = 0; _ < n; _++) {
long long tmp;
cin >> tmp;
v.push_back(tmp);
sum += tmp;
}
vector<long long> ans;
for (long long i = 0; i < n; i++) {
if ((sum - v[i]) % (n - 1) == 0 && (sum - v[i]) / (n - 1) == v[i])
ans.push_back(i + 1);
}
cout << ans.size() << endl;
for (long long i = 0; i < ((long long)((ans).size())); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
int main(int argc, char *argv[]) {
run();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100008;
int n, a[N];
vector<pair<int, int> > ans;
int main(void) {
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", a + i);
for (i = 1; i + 2 <= n; i++)
if (a[i]) {
for (k = 1, j = 2; i + j + j <= n; j++)
if (a[i + j]) {
k = j;
break;
}
a[i] ^= 1;
a[i + k] ^= 1;
a[i + k + k] ^= 1;
ans.push_back(make_pair(i, k));
}
if (a[n - 1] == 1 && a[n] == 0) {
if (n >= 8) {
ans.push_back(make_pair(n - 7, 1));
ans.push_back(make_pair(n - 7, 3));
ans.push_back(make_pair(n - 6, 1));
} else {
puts("NO");
return 0;
}
} else if (a[n - 1] == 0 && a[n] == 1) {
if (n >= 7) {
ans.push_back(make_pair(n - 6, 1));
ans.push_back(make_pair(n - 6, 3));
ans.push_back(make_pair(n - 5, 1));
} else {
puts("NO");
return 0;
}
} else if (a[n - 1] == 1 && a[n] == 1) {
if (n >= 8) {
ans.push_back(make_pair(n - 7, 1));
ans.push_back(make_pair(n - 7, 3));
ans.push_back(make_pair(n - 6, 1));
ans.push_back(make_pair(n - 6, 1));
ans.push_back(make_pair(n - 6, 3));
ans.push_back(make_pair(n - 5, 1));
} else {
puts("NO");
return 0;
}
}
printf("YES\n%d\n", (int)ans.size());
for (auto p : ans)
printf("%d %d %d\n", p.first, p.first + p.second,
p.first + p.second + p.second);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int f = 0;
vector<int> a(t, 0);
vector<int> b(t, 0);
for (int i = 0; i < t; i++) {
cin >> a[i];
}
for (int i = 0; i < t; i++) {
cin >> b[i];
}
int c = 0;
int c1 = 0;
unordered_map<int, int> d;
for (int i = 0; i < t - 1; i++) {
d[b[i]]++;
if (a[i - c] != b[i]) {
if (d[a[i - c]] != 0) {
c--;
i--;
} else {
c++;
c1++;
}
}
}
cout << c1 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
using namespace std;
template <typename T>
void uin(T &a, T b) {
if (b < a) {
a = b;
}
}
template <typename T>
void uax(T &a, T b) {
if (b > a) {
a = b;
}
}
const int N = 100 * 1000 + 228;
const double eps = 1e-7;
struct edge {
int a, b, c;
edge() {}
edge(int _a, int _b, int _c) {
a = _a;
b = _b;
c = _c;
}
};
vector<edge> edges;
bool eq(double first, double second) { return abs(first - second) <= eps; }
vector<pair<int, int> > g[N];
pair<double, double> f[N];
bool used[N];
double VALUE[N];
void GO(int V) {
queue<int> q;
q.push(V);
f[V] = {1, 0};
used[1] = 1;
vector<int> uv;
uv.emplace_back(V);
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto go : g[v]) {
int to = go.first;
int type = go.second;
if (to == v && f[v].first != 0) {
double X = ((double)type / 2.0 - f[v].second) / (double)f[v].first;
for (auto ve : uv) {
double a = f[ve].first, b = f[ve].second;
f[ve].first = 0;
f[ve].second = a * X + b;
}
continue;
}
if (!used[to]) {
used[to] = 1;
f[to].first = -f[v].first;
f[to].second = type - f[v].second;
uv.emplace_back(to);
q.push(to);
} else {
int A = -f[v].first;
int B = type - f[v].second;
if (A && eq(f[to].first, A) && !eq(f[to].second, B)) {
cout << "NO\n";
exit(0);
}
if (!eq(f[to].first, A)) {
double X = (f[to].second - B) / (A - f[to].first);
for (auto ve : uv) {
double a = f[ve].first, b = f[ve].second;
f[ve].first = 0;
f[ve].second = a * X + b;
}
}
}
}
}
if (eq(f[uv[0]].first, 0)) {
for (int first : uv) {
VALUE[first] = f[first].second;
}
} else {
vector<double> t;
for (int first : uv) {
if (f[first].first == 1) {
t.emplace_back(-f[first].second);
} else {
t.emplace_back(f[first].second);
}
}
sort(t.begin(), t.end());
double X = t[(int)t.size() / 2];
for (int first : uv) {
VALUE[first] = f[first].first * X + f[first].second;
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v, col;
cin >> u >> v >> col;
edges.emplace_back(u, v, col);
g[u].emplace_back(v, col);
g[v].emplace_back(u, col);
}
for (int v = 1; v <= n; ++v) {
if (!used[v]) {
GO(v);
}
}
for (auto e : edges) {
int a = e.a, b = e.b, c = e.c;
if (!eq(VALUE[a] + VALUE[b], c)) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
cout.precision(20);
for (int i = 1; i <= n; ++i) {
cout << VALUE[i] << ' ';
}
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ed[100010], cost[100010];
long long ans;
long long sz[100010], m;
long long tp[100011];
bool done[100010];
map<long long, long long> downf, upf, downfl[100010], upfl[100010];
void dfs(long long n, long long p) {
sz[n] = 1;
for (long long i = 0; i < ed[n].size(); i++) {
long long v = ed[n][i];
if (v != p && done[v] == false) {
dfs(v, n);
sz[n] += sz[v];
}
}
}
long long s2, s1, t2, t1;
long long egcd(long long a, long long b) {
long long temp;
if (a % b == 0) {
return s1;
}
temp = s2 - (a / b) * s1;
s2 = s1;
s1 = temp;
temp = t2 - (a / b) * t1;
t2 = t1;
t1 = temp;
return egcd(b, a % b);
}
void ndfs(long long n, long long p, long long loc, long long down,
long long h) {
long long x = (-down) % m;
if (x < 0) x += m;
long long y = tp[h];
s2 = t1 = 1;
s1 = t2 = 0;
y = (egcd(y, m) % m + m) % m;
x = (x * y) % m;
ans += upf[x] - upfl[loc][x];
for (long long i = 0; i < ed[n].size(); i++) {
long long v = ed[n][i];
if (v != p && done[v] == false) {
ndfs(v, n, loc, ((down * 10) % m + cost[n][i]) % m, h + 1);
}
}
}
void adfs(long long n, long long p, long long loc, long long down, long long up,
long long h) {
downf[down]++;
upf[up]++;
downfl[loc][down]++;
upfl[loc][up]++;
if (!(up % m)) ans++;
for (long long i = 0; i < ed[n].size(); i++) {
long long v = ed[n][i];
if (v != p && done[v] == false) {
adfs(v, n, loc, ((down * 10) % m + cost[n][i]) % m,
(up + ((tp[h] * cost[n][i]) % m)) % m, h + 1);
}
}
}
long long decompose(long long cen) {
dfs(cen, -1);
long long target = sz[cen] / 2, p = -1;
bool ok = false;
while (!ok) {
ok = true;
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
if (p != v && done[v] == false && sz[v] > target) {
ok = false;
p = cen;
cen = v;
}
}
}
done[cen] = true;
downf.clear();
upf.clear();
upf[0]++;
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
upfl[v].clear();
downfl[v].clear();
if (!done[v]) {
adfs(v, cen, v, cost[cen][i] % m, cost[cen][i] % m, 1);
}
}
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
if (!done[v]) {
ndfs(v, cen, v, cost[cen][i] % m, 1);
}
}
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
if (!done[v]) {
decompose(v);
}
}
return cen;
}
int main() {
long long cs, ts, i, j, k, x, y, z, q, n;
tp[0] = 1;
scanf("%lld", &n);
scanf("%lld", &m);
for (long long i = 1; i <= n; i++) tp[i] = (10 * tp[i - 1]) % m;
for (i = 1; i < n; i++) {
scanf("%lld", &x);
scanf("%lld", &y);
scanf("%lld", &z);
x++;
y++;
ed[x].push_back(y);
ed[y].push_back(x);
cost[x].push_back(z);
cost[y].push_back(z);
}
ans = 0;
decompose(1);
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> e[N];
int n, x, y, tot, ans, cnt;
map<vector<int>, int> mmp;
map<int, int> f[N];
int deg[N], can[N * 5];
int dfs(int k, int fa) {
if (f[k][fa]) return f[k][fa];
vector<int> vac;
for (int v : e[k])
if (v != fa) vac.push_back(dfs(v, k));
sort(vac.begin(), vac.end());
if (!mmp[vac]) mmp[vac] = ++cnt;
return f[k][fa] = mmp[vac];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
deg[x]++;
deg[y]++;
}
for (int i = 1; i <= n; i++)
if (deg[i] < 4) can[dfs(i, 0)] = 1;
for (int i = 1; i <= cnt; i++)
if (can[i]) ans++;
printf("%d", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int size = 105;
int x[size] = {0}, y[size] = {0};
int main() {
int n;
cin >> n;
int cnt1 = 0, cnt2 = 0;
char ch;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> ch;
if (ch == '.') {
if (!x[i]) x[i] = j, cnt1++;
if (!y[j]) y[j] = i, cnt2++;
}
}
}
if (cnt1 == n)
for (int i = 1; i <= n; i++) cout << i << " " << x[i] << "\n";
else if (cnt2 == n)
for (int i = 1; i <= n; i++) cout << y[i] << " " << i << "\n";
else
cout << "-1\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 2139063143;
const int N = 1010000;
const int P = 1000000007;
const double eps = 1e-7;
template <typename T>
inline void sc(T &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void pr(T x) {
print(x), putchar('\n');
}
template <typename T1, typename T2>
void chkmax(T1 &A, T2 B) {
A = A >= B ? A : B;
}
template <typename T1, typename T2>
void chkmin(T1 &A, T2 B) {
A = A <= B ? A : B;
}
struct TREE {
int mi, w, d;
long long ans, num;
} t[N << 2];
void pushd(int p, int d) { t[p].mi += d, t[p].d += d; }
void pushnum(int p, long long num) {
t[p].ans += num * t[p].w, t[p].num += num;
}
void push(int p) {
int ls = p << 1, rs = ls | 1;
if (t[p].d != 0) pushd(ls, t[p].d), pushd(rs, t[p].d), t[p].d = 0;
if (t[p].num) {
if (t[p].mi == t[ls].mi) pushnum(ls, t[p].num);
if (t[p].mi == t[rs].mi) pushnum(rs, t[p].num);
t[p].num = 0;
}
}
void update(int p) {
int ls = p << 1, rs = ls | 1;
t[p].mi = min(t[ls].mi, t[rs].mi);
t[p].w = 0;
if (t[p].mi == t[ls].mi) t[p].w = t[ls].w;
if (t[p].mi == t[rs].mi) t[p].w += t[rs].w;
t[p].ans = t[ls].ans + t[rs].ans;
}
void build(int p, int l, int r) {
if (l == r) return t[p].mi = l, t[p].w = 1, void();
int mid = (l + r) >> 1, ls = p << 1, rs = ls | 1;
build(ls, l, mid), build(rs, mid + 1, r);
update(p);
}
void change(int p, int l, int r, int L, int R, int d) {
if (L <= l && r <= R) return pushd(p, d), void();
int mid = (l + r) >> 1, ls = p << 1, rs = ls | 1;
push(p);
if (L <= mid) change(ls, l, mid, L, R, d);
if (R > mid) change(rs, mid + 1, r, L, R, d);
update(p);
}
long long query(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return t[p].ans;
int mid = (l + r) >> 1, ls = p << 1, rs = ls | 1;
long long ans = 0;
push(p);
if (L <= mid) ans = query(ls, l, mid, L, R);
if (R > mid) ans += query(rs, mid + 1, r, L, R);
return ans;
}
int s1[N], z1 = 0, s2[N], z2 = 0;
int a[N];
struct LY {
int l, id;
};
vector<LY> v[N];
long long ans[N];
int main() {
int n;
sc(n);
for (int i = 1; i <= n; i++) sc(a[i]);
int m;
sc(m);
for (int i = 1; i <= m; i++) {
int l, r;
sc(l), sc(r);
v[r].push_back((LY){l, i});
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
pushd(1, -1);
while (z1 && a[s1[z1]] < a[i])
change(1, 1, n, s1[z1 - 1] + 1, s1[z1], a[i] - a[s1[z1]]), --z1;
s1[++z1] = i;
while (z2 && a[s2[z2]] > a[i])
change(1, 1, n, s2[z2 - 1] + 1, s2[z2], a[s2[z2]] - a[i]), --z2;
s2[++z2] = i;
pushnum(1, 1);
for (LY x : v[i]) ans[x.id] = query(1, 1, n, x.l, i);
}
for (int i = 1; i <= m; i++) pr(ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int freq[n][n + 1];
for (int i = 0; i < n; i++)
for (int j = 0; j <= n; j++) freq[i][j] = 0;
bool ans[n + 1];
memset(ans, false, sizeof(ans));
int arr[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
freq[i][arr[i][j]]++;
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= n; j++)
if (freq[i][j] + j == n && !ans[j]) {
ans[j] = true;
cout << j << " ";
break;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct query {
int l, r, ID;
} Q[100000];
int n, q, idx, SQRT, cur_ans;
int a[100000];
int cnt[100001];
int answer[100000];
bool mo_cmp(const query &a, const query &b) {
int x = a.l / SQRT;
int y = b.l / SQRT;
if (x == y) return a.r < b.r;
return x < y;
}
inline void add(int idx) {
if (a[idx] > 100000) return;
if (cnt[a[idx]] == a[idx]) cur_ans--;
cnt[a[idx]]++;
if (cnt[a[idx]] == a[idx]) cur_ans++;
}
inline void remove(int idx) {
if (a[idx] > 100000) return;
if (cnt[a[idx]] == a[idx]) cur_ans--;
cnt[a[idx]]--;
if (cnt[a[idx]] == a[idx]) cur_ans++;
}
int main() {
if (0) {
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
} else {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", a + i);
}
for (int i = 0; i < q; i++) {
if (0)
cin >> Q[i].l >> Q[i].r;
else
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].l--;
Q[i].r--;
Q[i].ID = i;
}
SQRT = (int)(sqrt(n + 1.0));
sort(Q, Q + q, mo_cmp);
memset(cnt, 0, sizeof cnt);
int mo_left = 0;
int mo_right = -1;
for (int i = 0; i < q; i++) {
int L = Q[i].l;
int R = Q[i].r;
while (mo_right < R) {
mo_right++;
add(mo_right);
}
while (R < mo_right) {
remove(mo_right);
mo_right--;
}
while (mo_left < L) {
remove(mo_left);
mo_left++;
}
while (L < mo_left) {
mo_left--;
add(mo_left);
}
answer[Q[i].ID] = cur_ans;
}
if (0)
for (int i = 0; i < q; i++) cout << answer[i] << '\n';
else
for (int i = 0; i < q; i++) printf("%d\n", answer[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, x1, x2;
cin >> n >> x1 >> x2;
vector<pair<int, int>> a(n);
for (auto &i : a) cin >> i.first, i.second = &i - &a[0] + 1;
sort(a.begin(), a.end());
for (int flag = 0; flag < 2; ++flag) {
for (int i = n - 2; i >= 0; --i) {
int k1 = (x1 + a[i].first - 1) / a[i].first;
if (i + k1 < n) {
int k2 = (x2 + a[i + k1].first - 1) / a[i + k1].first;
if (i + k1 + k2 <= n) {
vector<int> _a, b;
for (int j = k1; j--; ++i) _a.push_back(a[i].second);
for (int j = k2; j--; ++i) b.push_back(a[i].second);
if (flag) swap(k1, k2), swap(_a, b);
cout << "Yes\n";
cout << k1 << " " << k2 << "\n";
for (auto i : _a) cout << i << " \n"[i == _a.back()];
for (auto i : b) cout << i << " \n"[i == b.back()];
return 0;
}
}
}
swap(x1, x2);
}
cout << "No\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long longinf = 1LL << 60;
const long long mod = 1e9 + 7;
template <typename T = unsigned int, int B = 32>
struct BinaryTrie {
private:
struct Node {
int cnt;
T lazy;
Node* ch[2] = {};
Node() : cnt(0), lazy(0) {}
};
Node* root;
int size(Node* t) { return t ? t->cnt : 0; }
void eval(Node* t, int bit_index) {
if (!t->lazy) return;
if (t->lazy >> bit_index) swap(t->ch[0], t->ch[1]);
if (t->ch[0]) t->ch[0]->lazy ^= t->lazy;
if (t->ch[1]) t->ch[1]->lazy ^= t->lazy;
t->lazy = 0;
}
Node* insert(Node* t, T n, int bit_index) {
if (!t) t = new Node;
t->cnt += 1;
if (bit_index == -1) return t;
eval(t, bit_index);
bool c = (n >> bit_index) & 1;
t->ch[c] = insert(t->ch[c], n, bit_index - 1);
return t;
}
Node* erase(Node* t, T n, int bit_index) {
t->cnt -= 1;
if (!t->cnt) return nullptr;
if (bit_index == -1) return t;
eval(t, bit_index);
bool c = (n >> bit_index) & 1;
t->ch[c] = erase(t->ch[c], n, bit_index - 1);
return t;
}
T get_min(Node* t, T n, int bit_index) {
if (bit_index < 0) return 0;
eval(t, bit_index);
bool c = (n >> bit_index) & 1;
T ret = 0;
if (!t->ch[c]) c ^= 1;
return get_min(t->ch[c], n, bit_index - 1) | ((T)c << bit_index);
}
T get(Node* t, T n, int k, int bit_index) {
if (bit_index < 0) return 0;
eval(t, bit_index);
bool c = (n >> bit_index) & 1;
if (size(t->ch[c]) < k) k -= size(t->ch[c]), c ^= 1;
return get(t->ch[c], n, k, bit_index - 1) | ((T)c << bit_index);
}
int count_lower(Node* t, T n, T val, int bit_index) {
if (!t || bit_index < 0) return 0;
eval(t, bit_index);
bool c = (n >> bit_index) & 1;
int ret = 0;
if ((val >> bit_index) & 1) ret += size(t->ch[c]), c ^= 1;
return ret + count_lower(t->ch[c], n, val, bit_index - 1);
}
public:
BinaryTrie() : root(nullptr) {}
int size() { return size(root); }
bool empty() { return !root; }
void insert(T n) { root = insert(root, n, B - 1); }
void erase(T n) { root = erase(root, n, B - 1); }
void xor_all(T n) {
if (root) root->lazy ^= n;
}
T max_element(T bias = 0) { return get_min(root, ~bias, B - 1); }
T min_element(T bias = 0) { return get_min(root, bias, B - 1); }
int lower_bound(T x, T bias = 0) { return count_lower(root, bias, x, B - 1); }
int upper_bound(T x, T bias = 0) {
return count_lower(root, bias, x + 1, B - 1);
}
int count(T x) { return upper_bound(x) - lower_bound(x); }
T get(int k, T bias = 0) { return get(root, bias, k + 1, B - 1); }
T operator[](int k) { return get(k); }
};
int main() {
int n, k;
cin >> n >> k;
BinaryTrie<> bt;
bt.insert(0);
long long ans = 0;
int sum = 0;
for (int i = (int)0; i < (int)n; ++i) {
int a;
cin >> a;
sum ^= a;
ans += (i + 1) - bt.lower_bound(k, sum);
bt.insert(sum);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void __read(T &a) {
cin >> a;
}
template <typename T, typename... Args>
void __read(T &a, Args &...args) {
cin >> a;
__read(args...);
}
constexpr long long M7 = 1000000007ll;
constexpr long long M9 = 1000000009ll;
constexpr long long MFFT = 998244353ll;
template <class T>
void outv(T &a) {
for (auto &x : a) cout << x << ' ';
}
static mt19937 rnd(static_cast<unsigned>(
chrono::steady_clock::now().time_since_epoch().count()));
auto __fast_io__ = (ios_base::sync_with_stdio(false), cin.tie(nullptr));
int32_t main() {
long long n;
__read(n);
long long k = -1, mx = -1;
for (long long i = 2; i <= n; ++i) {
long long val = n - (n + i - 1) / i - i + 1;
if (val > mx) {
mx = val;
k = i;
}
}
vector<long long> was(n);
while (true) {
vector<long long> a;
for (long long j = 0; j < n; ++j) {
if (j % k != 0 && !was[j]) {
a.push_back(j);
}
}
if (a.size() < k) {
cout << 0 << endl;
break;
}
cout << k;
shuffle((a).begin(), (a).end(), rnd);
for (long long i = 0; i < k; ++i) {
cout << ' ' << a[i] + 1;
was[a[i]] = 1;
}
cout << endl;
long long x;
__read(x);
assert(x != -1);
x--;
for (long long i = 0; i < k; ++i) {
was[(x + i) % n] = 0;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
int cnt[1000] = {0};
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
vector<int> odd;
int lit = -1;
int ans[1000] = {0};
for (int i = 1; i <= n; i++) {
if (cnt[a[i]] == 1) {
odd.push_back(a[i]);
}
if (cnt[a[i]] > 2) lit = i;
}
if (odd.size() % 2 != 0 and lit == -1) {
cout << "NO\n";
return 0;
} else {
string res = "";
if (odd.size() % 2 == 0) {
bool aa = false, bb = false;
for (auto i : odd) {
if (!aa) {
ans[i] = 1;
aa = true;
} else {
aa = false;
}
}
for (int i = 1; i <= n; i++) {
if (ans[a[i]] == 1)
res += 'A';
else
res += 'B';
}
} else {
bool aa = false, bb = false;
for (auto i : odd) {
if (!aa) {
ans[i] = 1;
aa = true;
} else {
aa = false;
}
}
bool li = false;
for (int i = 1; i <= n; i++) {
if (ans[a[i]] == 1 or a[i] == a[lit])
res += 'A';
else {
res += 'B';
}
}
res[lit - 1] = 'B';
}
cout << "YES\n";
cout << res << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000LL;
const double EPS = 1e-9;
const long long mod = 1000000007ll;
const int maxn = 500500;
int longestP[1000500];
char pat[1000500];
void KMP() {
for (int i = 1, k = 0; pat[i]; i++) {
while (k > 0 && pat[i] != pat[k]) k = longestP[k - 1];
if (pat[i] == pat[k])
longestP[i] = ++k;
else
longestP[i] = k;
}
}
int main() {
scanf("%s", pat);
int n = strlen(pat);
KMP();
if (longestP[n - 1] == 0) {
puts("Just a legend");
return 0;
}
for (int i = 0; i + 1 < n; i++)
if (longestP[n - 1] == longestP[i]) {
for (int j = 0; j < longestP[i]; j++) putchar(pat[j]);
return 0;
}
if (longestP[longestP[n - 1] - 1] == 0) {
puts("Just a legend");
return 0;
}
for (int j = 0; j < longestP[longestP[n - 1] - 1]; j++) putchar(pat[j]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i = 0;
cin >> n;
int a[n];
while (n--) {
cin >> a[i];
i++;
}
sort(a, a + i);
cout << a[i / 2];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300010];
int odd[300010], even[300010], ans[300010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), ans[1] = max(ans[1], a[i]);
for (int i = 1; i < n; i++) {
int len = min(i, n - i);
even[len] = max(even[len], max(a[i], a[i + 1]));
}
for (int i = 2; i < n; i++) {
int len = min(i - 1, n - i);
odd[len] = max(odd[len], min(a[i], max(a[i - 1], a[i + 1])));
}
for (int i = n / 2; i; i--) ans[i << 1] = max(ans[(i + 1) << 1], even[i]);
for (int i = n / 2; i; i--)
ans[i << 1 | 1] = max(ans[(i + 1) << 1 | 1], odd[i]);
for (int i = n; i; i--) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, n, temp, temp1, count = 0, i;
cin >> a >> b >> c >> n;
for (i = 1; i < n + 1; i++) {
long long int temp;
cin >> temp;
if (temp > b && temp < c) count++;
}
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int E = N << 1;
int fa[N], last[N], bcnt[N], bsum[N], eid[N], fa_[N], depth[N];
int tov[E], nxt[E];
long long bsum2[N];
int n, q, tot;
long long ans;
int getfather(int son) {
return fa_[son] == son ? son : fa_[son] = getfather(fa_[son]);
}
inline void insert(int x, int y) {
tov[++tot] = y, nxt[tot] = last[x], last[x] = tot;
}
inline long long sqr(int x) { return 1ll * x * x; }
void dfs(int x) {
bsum[x] = bcnt[x] = 1, fa_[x] = x;
for (int i = last[x], y; i; i = nxt[i])
if ((y = tov[i]) != fa[x]) {
depth[y] = depth[fa[y] = x] + 1, dfs(y);
bsum[x] += bsum[y], bsum2[x] += sqr(bsum[y]);
}
bsum2[x] += sqr(n - bsum[x]);
ans += (1ll * (bcnt[x] - 1) * (bcnt[x] - 2) +
2ll * (bcnt[x] - 1) * (n - bcnt[x]) + (sqr(n - bcnt[x]) - bsum2[x])) *
bcnt[x];
}
int main() {
scanf("%d", &n);
for (int i = 1, x, y; i < n; ++i)
scanf("%d%d", &x, &y), insert(x, y), insert(y, x);
depth[1] = 1, dfs(1), printf("%lld\n", ans), scanf("%d", &q);
for (int i = 1, x, y, x_, y_; i <= q; ++i) {
scanf("%d%d", &x, &y), x_ = x = getfather(x), y_ = y = getfather(y);
for (; x != y; x = getfather(fa[x])) {
if (depth[x] < depth[y]) swap(x, y);
ans -= (1ll * (bcnt[x] - 1) * (bcnt[x] - 2) +
2ll * (bcnt[x] - 1) * (n - bcnt[x]) +
(sqr(n - bcnt[x]) - bsum2[x])) *
bcnt[x];
}
ans -=
(1ll * (bcnt[x] - 1) * (bcnt[x] - 2) +
2ll * (bcnt[x] - 1) * (n - bcnt[x]) + (sqr(n - bcnt[x]) - bsum2[x])) *
bcnt[x];
x = x_, y = y_;
for (int z; x != y; x = z) {
if (depth[x] < depth[y]) swap(x, y);
fa_[x] = z = getfather(fa[x]);
bcnt[z] += bcnt[x];
bsum2[z] -= sqr(bsum[x]) - bsum2[x] + sqr(n - bsum[x]);
}
ans +=
(1ll * (bcnt[x] - 1) * (bcnt[x] - 2) +
2ll * (bcnt[x] - 1) * (n - bcnt[x]) + (sqr(n - bcnt[x]) - bsum2[x])) *
bcnt[x];
printf("%lld\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, z = 0, o = 0;
cin >> n >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] - '0' == 0)
z++;
else
o++;
}
if (z != o || z > 0 && o == 0 || o > 0 && z == 0) {
cout << 1 << endl;
cout << s << endl;
} else {
cout << 2 << endl;
cout << s[0] << " ";
for (int i = 1; i < n; i++) cout << s[i];
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 9 + 7;
int n, m;
bool A[N], B[N];
int main() {
scanf("%d%d", &n, &m);
int minA = 10;
for (int i = (0); i <= (n - 1); ++i) {
int _tmp;
scanf("%d", &_tmp);
minA = min(minA, _tmp);
A[_tmp] = true;
}
int minB = 10;
for (int i = (0); i <= (m - 1); ++i) {
int _tmp;
scanf("%d", &_tmp);
minB = min(minB, _tmp);
B[_tmp] = true;
}
for (int i = (1); i <= (9); ++i) {
if (A[i] && B[i]) {
printf("%d\n", i);
return 0;
}
}
if (minA > minB) {
int _tmp = minA;
minA = minB;
minB = _tmp;
}
printf("%d%d\n", minA, minB);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int B = 1000000007;
const int N = 1000000;
int d[N + 1], c[N + 1];
int pop(int i) {
int a = 0;
for (; i > 0; i -= i & (-i)) a = (a + d[i]) % B;
return a;
}
int push(int i, int a) {
a = (a + ((B - c[i]) % B)) % B;
c[i] = (c[i] + a) % B;
for (; i <= N; i += i & (-i)) d[i] = (d[i] + a) % B;
return 0;
}
int n, a, r;
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
int r = int64_t(a) * (pop(a) + 1LL) % B;
push(a, r);
}
printf("%d", pop(N));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long sum = 0;
if (n % 2 == 0) {
sum = n / 2;
} else {
sum = ((n + 1) / 2) * (-1);
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, cnt = 0;
signed main() {
cin >> n;
if (n == 0) {
cout << 0;
exit(0);
}
n++;
if (n % 2 == 0)
cout << n / 2;
else
cout << n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505000;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
if (f) x = -x;
}
vector<int> v[N];
int a[N], h[N], to[N], ne[N];
int dfn[N], Top[N], f[N], s[N];
int son[N], siz[N], dep[N];
int n, top, num, tot;
inline void add(int x, int y) { ne[++tot] = h[x], to[tot] = y, h[x] = tot; }
void dfs1(int x, int fa) {
siz[x] = 1, f[x] = fa, dep[x] = dep[fa] + 1;
for (int i = h[x]; i; i = ne[i]) {
int y = to[i];
if (y == fa) continue;
dfs1(y, x), siz[x] += siz[y];
if (siz[y] > siz[son[x]]) son[x] = y;
}
}
void dfs2(int x, int topf) {
Top[x] = topf, dfn[x] = ++num;
if (!son[x]) return;
dfs2(son[x], topf);
for (int i = h[x]; i; i = ne[i])
if (!dfn[to[i]]) dfs2(to[i], to[i]);
}
int Lca(int x, int y) {
while (Top[x] != Top[y]) {
if (dep[Top[x]] < dep[Top[y]]) swap(x, y);
x = f[Top[x]];
}
return dep[x] < dep[y] ? x : y;
}
inline void add_e(int x, int y) { v[x].push_back(y); }
int inp[N];
void ins(int x) {
if (top == 1) return s[++top] = x, void();
int lca = Lca(x, s[top]);
if (lca == s[top]) return s[++top] = x, void();
while (top > 1 && dfn[s[top - 1]] >= dfn[lca])
add_e(s[top - 1], s[top]), top--;
if (lca != s[top]) add_e(lca, s[top]), s[top] = lca;
s[++top] = x;
}
int ans;
void dp(int x) {
if (!v[x].size()) return;
int cnt = 0;
for (int i = 0; i < v[x].size(); i++) {
dp(v[x][i]), cnt += inp[v[x][i]];
inp[v[x][i]] = 0;
}
v[x].clear();
if (inp[x])
ans += cnt;
else if (cnt >= 2)
ans++;
else if (cnt)
inp[x] = 1;
}
bool cmp(int a, int b) { return dfn[a] < dfn[b]; }
int main() {
read(n);
for (int i = 1; i < n; i++) {
int x, y;
read(x), read(y);
add(x, y), add(y, x);
}
dfs1(1, 0), dfs2(1, 1);
int m;
read(m);
while (m--) {
int k;
read(k);
for (int i = 1; i <= k; i++) read(a[i]), inp[a[i]] = 1;
int flag = 0;
for (int i = 1; i <= k; i++)
if (inp[f[a[i]]]) {
flag = 1;
break;
}
if (flag)
for (int i = 1; i <= k; i++) inp[a[i]] = 0;
if (flag) {
printf("-1\n");
continue;
}
sort(a + 1, a + k + 1, cmp);
s[top = 1] = 1;
for (int i = 1; i <= k; i++)
if (a[i] != 1) ins(a[i]);
while (top > 0) add_e(s[top - 1], s[top]), top--;
ans = 0, dp(1), inp[1] = 0;
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
inline int fpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % p;
x = 1ll * x * x % p;
y >>= 1;
}
return ans;
}
vector<int> v1[100086], v2[100086];
int fa[100086], dep[100086];
int col[100086], cnt;
void dfs1(int i) {
for (int j = 0; j < v1[i].size(); j++) {
int to = v1[i][j];
if (to == fa[i]) continue;
if (!dep[to]) {
dep[to] = dep[i] + 1, fa[to] = i;
dfs1(to);
} else {
if (dep[i] > dep[to]) {
col[i] = ++cnt;
for (int j = i; j != to; j = fa[j]) col[fa[j]] = col[i];
}
}
}
if (!col[i]) col[i] = ++cnt;
}
int siz[100086], sum[100086];
int f[100086][25], lg[100086];
void dfs2(int i) {
sum[i] = (siz[i] > 1) + sum[f[i][0]];
for (int j = 1; j <= lg[dep[i]]; j++) f[i][j] = f[f[i][j - 1]][j - 1];
for (int j = 0; j < v2[i].size(); j++) {
int to = v2[i][j];
if (!dep[to]) {
f[to][0] = i;
dep[to] = dep[i] + 1;
dfs2(to);
}
}
}
inline int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] > dep[y]) x = f[x][lg[dep[x] - dep[y]]];
if (x == y) return x;
for (int i = lg[dep[x]]; i >= 0; i--) {
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
}
return f[x][0];
}
int n, m, k, x, y, z;
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++) lg[i] = lg[i - 1] + (1 << (lg[i - 1] + 1) == i);
while (m--) {
scanf("%d%d", &x, &y);
v1[x].push_back(y), v1[y].push_back(x);
}
dep[1] = 1, dfs1(1);
for (int i = 1; i <= n; i++) {
siz[col[i]]++;
for (int j = 0; j < v1[i].size(); j++) {
if (col[i] ^ col[v1[i][j]]) v2[col[i]].push_back(col[v1[i][j]]);
}
}
memset(dep, 0, sizeof(dep));
dep[1] = 1, dfs2(1);
scanf("%d", &k);
while (k--) {
scanf("%d%d", &x, &y);
x = col[x], y = col[y];
z = lca(x, y);
printf("%d\n", fpow(2, sum[x] + sum[y] - sum[z] - sum[f[z][0]]));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 1100;
long long comb[MAXN][MAXN];
int main() {
comb[0][0] = 1;
for (int i = 1; i < MAXN; i++) {
comb[i][0] = 1;
for (int j = 1; j < MAXN; j++)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % MOD;
}
long long c, k, dp;
cin >> k;
dp = 1;
long long sum = 0;
for (int i = 0; i < k; i++) {
cin >> c;
if (i > 0) dp = (dp * comb[sum + c - 1][c - 1]) % MOD;
sum += c;
}
cout << dp << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void _F(const char *name, T arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
const char *name = strchr(names, ',');
cerr.write(names, name - names) << " = " << arg1 << '\n';
_F(name + 2, args...);
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
in >> q.first >> q.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
out << q.first << " " << q.second;
return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first + p2.first, p1.second + p2.second};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first - p2.first, p1.second - p2.second};
}
void solve() {
std::vector<long long> v = {1, 6, 8, 9};
string s, ans;
cin >> s;
long long one = 0, six = 0;
long long eight = 0, nine = 0;
for (auto u : s) {
if (u == '1' && !one) {
one = 1;
continue;
}
if (u == '6' && !six) {
six = 1;
continue;
}
if (u == '8' && !eight) {
eight = 1;
continue;
}
if (u == '9' && !nine) {
nine = 1;
continue;
}
ans.push_back(u);
}
sort((ans).rbegin(), (ans).rend());
long long r[7];
do {
long long x = 0;
for (auto u : v) {
x *= 10, x += u;
}
r[x % 7] = x;
} while (next_permutation((v).begin(), (v).end()));
if (!(long long)((ans).size()) || ans[0] == '0') {
cout << r[0] << ans << '\n';
} else {
cout << ans;
long long rr = 0;
for (auto u : ans) {
rr = (rr * 10 + (u - '0')) % 7;
}
long long cnt = 4;
while (cnt) rr = (rr * 10) % 7, cnt--;
cout << r[(7 - rr) % 7];
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
start = clock();
cout << fixed << setprecision(12);
for (long long i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, k, p1, p2;
cin >> n >> k;
long long int t = (sqrt(1 + 8 * k) - 1) / 2;
if (k == ((t * (t + 1)) / 2)) {
p1 = t + 1;
p2 = t;
} else {
p1 = t + 2;
p2 = k - (t * (t + 1)) / 2;
}
p1 = n - p1;
p2 = n - p2;
for (int i = 0; i < n; i++) {
if (i == p1 || i == p2)
cout << "b";
else
cout << "a";
}
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n << " ";
for (int i = 2; i <= n; ++i) {
while (n % i == 0) {
n /= i;
cout << n << " ";
}
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 200007;
int n;
vector<int> ret, los;
struct tr {
vector<int> e[_];
void adde(int a, int b) { e[a].emplace_back(b); }
void addde(int a, int b) { adde(a, b), adde(b, a); }
int fa[_], dep[_], sz[_], mxch[_];
void dfs(int x, int ff) {
fa[x] = ff, dep[x] = dep[ff] + 1, sz[x] = 1;
for (auto b : e[x]) {
if (b == ff) continue;
dfs(b, x), sz[x] += sz[b];
if (sz[mxch[x]] < sz[b]) mxch[x] = b;
}
}
int dfn[_], top[_], dcnt;
void dfs2(int x, int tp) {
dfn[x] = ++dcnt, top[x] = tp;
if (mxch[x]) dfs2(mxch[x], tp);
for (auto b : e[x])
if (b != fa[x] && b != mxch[x]) dfs2(b, b);
}
struct sgt {
static const int _t = _ << 2;
vector<int> t[_t];
int loss[_];
void plant(int x, int l, int r) {
t[x].clear();
if (l == r) {
loss[l] = 0;
return;
}
plant((x << 1), l, ((l + r) >> 1)),
plant((x << 1 | 1), ((l + r) >> 1) + 1, r);
}
void change(int x, int l, int r, int tl, int tr, int d) {
if (tl <= l && r <= tr) {
t[x].emplace_back(d);
return;
}
if (tl <= ((l + r) >> 1)) change((x << 1), l, ((l + r) >> 1), tl, tr, d);
if (tr > ((l + r) >> 1))
change((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr, d);
}
void dels(int x, int l, int r, int tar) {
for (auto i : t[x])
if (!loss[i]) loss[i] = 1, ret.emplace_back(i);
t[x].clear();
if (l == r) return;
if (tar <= ((l + r) >> 1))
dels((x << 1), l, ((l + r) >> 1), tar);
else
dels((x << 1 | 1), ((l + r) >> 1) + 1, r, tar);
}
} t;
void make() {
for (int i = 2, a; i <= n; i++) a = ty(), addde(i, a);
dfs(1, 0), dfs2(1, 1), t.plant(1, 1, n);
}
void push(int a, int b, int d) {
while (top[a] != top[b]) {
if (dep[top[a]] < dep[top[b]]) swap(a, b);
t.change(1, 1, n, dfn[top[a]], dfn[a], d), a = fa[top[a]];
}
if (dep[a] > dep[b]) swap(a, b);
if (a != b) t.change(1, 1, n, dfn[a] + 1, dfn[b], d);
}
void pop(int x) { t.dels(1, 1, n, dfn[x]); }
tr() {
memset(fa, 0, sizeof(fa));
memset(dep, 0, sizeof(dep));
memset(sz, 0, sizeof(sz));
memset(mxch, 0, sizeof(mxch));
memset(dfn, 0, sizeof(dfn));
memset(top, 0, sizeof(top));
dcnt = 0;
}
} t[2];
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), t[0].make(), t[1].make();
for (int i = 2; i <= n; i++)
t[0].push(t[1].fa[i], i, i), t[1].push(t[0].fa[i], i, i);
los.emplace_back(ty() + 1), t[1].t.loss[los.back()] = 1;
for (int now = 0;; now ^= 1) {
cout << (now ? "Red" : "Blue") << lf, sort(los.begin(), los.end());
for (auto i : los) cout << i - 1 << ' ';
cout << lf;
ret.clear();
for (auto i : los) t[now].pop(i);
if (ret.empty()) break;
ret.swap(los);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, s;
cin >> n >> s;
long long a[21] = {0};
long long p = 20;
while (n > 0) {
a[p--] = n % 10;
n /= 10;
}
long long sum = 0;
for (long long i = 0; i <= 20; i++) sum += a[i];
if (sum <= s)
cout << 0 << endl;
else {
long long val = 0;
long long carry = 0;
long long hold = 1;
for (int i = 20; i >= 1; i--) {
sum -= (a[i]);
val += (10 - a[i]) * hold;
a[i] = 0;
carry = 1;
hold *= 10;
for (int j = i - 1; j >= 0; j--) {
long long v = a[j];
a[j] = (a[j] + carry) % 10;
carry = (v + carry) / 10;
}
long long chk = 0;
for (int j = 0; j <= 20; j++) chk += a[j];
if (chk <= s) {
cout << val << endl;
break;
}
}
}
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.