solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long int n;
vector<long long int> v;
map<long long int, long long int> mp, ck;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
ck[a]++;
ck[b]++;
ck[b + 1]++;
mp[a]++;
mp[b + 1]--;
if (ck[a] == 1) v.push_back(a);
if (ck[b] == 1) v.push_back(b);
if (ck[b + 1] == 1) v.push_back(b + 1);
}
sort(v.begin(), v.end());
long long int pre = 0;
bool ans = true;
for (int i = 0; i < v.size(); i++) {
mp[v[i]] += pre;
pre = mp[v[i]];
if (pre > 2) ans = false;
}
cout << (ans ? "YES" : "NO") << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
const int MAX = 10010;
using namespace std;
int k;
long long dp[6][MAX];
long long calc(int q, long long n) {
if (n > 10000) return calc(q, 10000);
if (dp[q][n] != -1) return dp[q][n];
long long x = n - 1;
for (long long i = 1; i <= n + 1; i++) {
if (x > 10004205361450474LL) break;
x = x + 1 + calc(q - 1, x + 1);
}
return dp[q][n] = x - n;
}
int read() {
int x;
scanf("%d", &x);
if (x == -1) exit(0);
return x;
}
void ask(vector<long long> &v) {
printf("%d ", (int)(v.size()) - 2);
for (int i = 1; i < (int)(v.size()) - 1; i++) printf("%lld ", v[i]);
printf("\n");
fflush(stdout);
}
vector<long long> v;
int main() {
for (int j = 1; j <= 5; j++)
for (int i = 1; i <= 10000; i++) dp[j][i] = -1;
long long l = 1, r = 10004205361450474LL;
int q = 5;
while (q--) {
v.clear();
v.push_back(l - 1);
long long p = min(10000LL, l);
for (long long i = 1; i <= p + 1 && v.back() <= r; i++) {
v.push_back(min(v.back() + 1 + calc(q, v.back() + 1), r + 1));
}
v.back() = r + 1;
ask(v);
k = read();
l = v[k] + 1;
r = v[k + 1] - 1;
}
}
| 22
|
#include <bits/stdc++.h>
char a[105];
int main() {
int n, k, sch = 0, ans = 0;
scanf("%d%d%s", &n, &k, a);
a[n] = 'E';
for (int i = 0; i <= n; i++) {
if (a[i] != a[i - 1]) {
if (sch > ans) ans = sch;
sch = 0;
}
if (a[i] == 'N') sch++;
}
if (ans > k) {
printf("NO");
return 0;
}
sch = 0;
for (int i = 0; i < n - k + 1; i++) {
for (int j = 0; j < k; j++)
if (a[i + j] == 'N' || a[i + j] == '?') sch++;
if (a[i - 1] != 'N' && a[i + k] != 'N' && sch == k) {
printf("YES");
return 0;
}
sch = 0;
}
printf("NO");
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 5;
void solve() {
long long int n, i;
cin >> n;
string s;
cin >> s;
vector<pair<char, long long int> > a(n);
for (i = 0; i < n; i++) {
a[i].first = s[i];
a[i].second = i;
}
sort(a.begin(), a.end());
long long int ans = 0, last;
vector<long long int> answer(n, 0), check(n, 0);
for (i = 0; i < n; i++) {
if (answer[i] == 0) {
ans++;
last = i;
answer[i] = ans;
for (long long int j = i + 1; j < n; j++) {
if (answer[j] == 0 && s[j] >= s[last]) {
answer[j] = ans;
last = j;
}
}
}
}
cout << ans << '\n';
for (auto x : answer) {
cout << x << " ";
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
long long modF(long long n) {
long long mod = 256;
return (n % mod + mod) % mod;
}
long long FUNCREV(long long n) {
vector<long long> dp(8, 0);
long long dpC = 0;
while (n > 1) {
dp[dpC++] = n % 2;
n = n / 2;
}
if (n != 0) dp[dpC++] = n;
long long ans = 0, mul = 1;
for (long long i = 7; i >= 0; i--) {
ans = ans + dp[i] * mul;
mul = mul << 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
getline(cin, s);
for (long long i = 0; i < s.length(); i++) {
long long number = s[i];
long long rev;
if (i == 0) {
rev = 0;
} else {
rev = FUNCREV(s[i - 1]);
}
number = FUNCREV(number);
number = (rev - number);
number = modF(number);
cout << number << endl;
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
const int N = 2e5 + 10;
const long long MOD = 1e9 + 7;
const int rx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int ry[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const long double eps = 1e-7;
const double pi = acos(-1.0);
const long long INF = 2e18;
bool comp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<pair<int, int> > > col(m, vector<pair<int, int> >(n)),
row(n, vector<pair<int, int> >(m));
int colmx[m], rowmx[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> row[i][j].first;
row[i][j].second = j;
col[j][i].first = row[i][j].first;
col[j][i].second = i;
}
}
for (int i = 0; i < n; i++) {
sort(row[i].begin(), row[i].end());
int z = row[i][0].first;
row[i][0].first = 1;
for (int j = 1; j < m; j++) {
if (row[i][j].first == z) {
z = row[i][j].first;
row[i][j].first = row[i][j - 1].first;
} else {
z = row[i][j].first;
row[i][j].first = row[i][j - 1].first + 1;
}
}
rowmx[i] = row[i][m - 1].first;
sort(row[i].begin(), row[i].end(), comp);
}
for (int i = 0; i < m; i++) {
sort(col[i].begin(), col[i].end());
int z = col[i][0].first;
col[i][0].first = 1;
for (int j = 1; j < n; j++) {
if (col[i][j].first == z) {
z = col[i][j].first;
col[i][j].first = col[i][j - 1].first;
} else {
z = col[i][j].first;
col[i][j].first = col[i][j - 1].first + 1;
}
}
colmx[i] = col[i][n - 1].first;
sort(col[i].begin(), col[i].end(), comp);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (row[i][j].first == col[j][i].first)
cout << max(rowmx[i], colmx[j]) << " ";
else if (row[i][j].first < col[j][i].first)
cout << max(colmx[j], rowmx[i] + col[j][i].first - row[i][j].first)
<< " ";
else
cout << max(rowmx[i], colmx[j] + row[i][j].first - col[j][i].first)
<< " ";
}
cout << endl;
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, sum = 0;
cin >> n;
int *d = new int[n - 1];
for (int i = 0; i < n - 1; i++) cin >> d[i];
cin >> a >> b;
for (int i = a; i < b; i++) sum += d[i - 1];
cout << sum;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int sum = 0;
sort(v.begin(), v.end());
for (int i = 0; i < n; i += 2) {
sum += abs(v[i] - v[i + 1]);
}
cout << sum;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int t;
long long n, d, x, s;
double y, z;
int main() {
cin >> t;
while (t--) {
cin >> n >> d;
if (n >= d)
cout << "YES" << endl;
else {
x = sqrt(d) - 1;
y = (1.0 * d) / (x + 1);
s = ceil(y);
if (s + x <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
int n, m, i, j, dis[21777], cnt, x, y, z, op, typ[5005], bel[5005], l[21777],
r[21777], s = 0, t = 21775;
vector<pair<pair<int, int>, int> > v;
struct ed {
int fr, y, c, re, id;
} e[380005];
vector<int> bi[21777];
void init() {
int i;
cnt = 0;
for (i = 1; i <= n; i++) bi[i].clear();
}
bool bfs(int st, int ed) {
int i;
queue<int> qx;
memset(dis, -1, sizeof(dis));
dis[st] = 0;
qx.push(st);
while (!qx.empty()) {
int x = qx.front();
qx.pop();
for (i = 0; i < bi[x].size(); i++) {
if (e[bi[x][i]].y != st && e[bi[x][i]].c > 0 &&
dis[e[bi[x][i]].y] == -1) {
dis[e[bi[x][i]].y] = dis[x] + 1;
qx.push(e[bi[x][i]].y);
}
}
}
if (dis[ed] == -1) return 0;
return 1;
}
int dfs(int x, int ed, int flw) {
if (x == ed) {
return flw;
}
int i, res = 0;
for (i = 0; i < bi[x].size(); i++) {
if (dis[x] + 1 == dis[e[bi[x][i]].y] && e[bi[x][i]].c > 0) {
int t = dfs(e[bi[x][i]].y, ed, min(e[bi[x][i]].c, flw));
e[bi[x][i]].c -= t;
e[e[bi[x][i]].re].c += t;
flw -= t;
res += t;
if (flw < 1) break;
}
}
if (res == 0) dis[x] = -123456;
return res;
}
int maxflow(int st, int ed) {
int ans = 0;
while (bfs(st, ed)) ans += dfs(st, ed, 0x22222222);
return ans;
}
void add(int x, int y, int sz, int id = 0) {
cnt += 2;
e[cnt - 1] = {x, y, sz, cnt, id};
e[cnt] = {y, x, 0, cnt - 1, id};
bi[x].push_back(cnt - 1);
bi[y].push_back(cnt);
}
void build(int x, int le, int ri) {
l[x] = le;
r[x] = ri;
if (le == ri) return;
add(x + n, x * 2 + n, 10000);
add(x + n, x * 2 + 1 + n, 10000);
build(x * 2, le, (le + ri) / 2);
build(x * 2 + 1, (le + ri) / 2 + 1, ri);
}
void upd(int fr, int x, int le, int ri) {
if (l[x] > ri || r[x] < le) return;
if (l[x] >= le && r[x] <= ri) {
add(fr, x + n, 1);
return;
}
upd(fr, x * 2, le, ri);
upd(fr, x * 2 + 1, le, ri);
}
bool cmp(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y) {
return make_pair(make_pair(x.first.second, x.first.first), x.second) <
make_pair(make_pair(y.first.second, y.first.first), y.second);
}
int main() {
ios_base::sync_with_stdio(false);
;
cin >> n >> m;
build(1, 1, 8192);
if ((1) <= ((n)))
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
cin >> op;
typ[i] = op;
if (op == 0) {
cin >> x;
while (x--) {
cin >> y;
add(i, 8191 + y + n, 1);
}
}
if (op == 1) {
cin >> x >> y;
upd(i, 1, x, y);
v.push_back(make_pair(make_pair(y, x), i));
}
if (op == 2) {
cin >> x >> y >> z;
add(i, 8191 + x + n, 1);
add(i, 8191 + y + n, 1);
add(i, 8191 + z + n, 1);
}
}
stable_sort((v).begin(), (v).end(), cmp);
for (i = 1; i <= n; i++) {
if (typ[i] == 2) add(s, i, 2);
}
for (i = 1; i <= n; i++) {
if (typ[i] != 2) add(s, i, 1);
}
for (i = 1; i <= m; i++) add(i + 8191 + n, t, 1);
cout << maxflow(s, t) << endl;
for (i = 1; i <= m; i++) {
for (__typeof((bi[i + n + 8191]).begin()) it = (bi[i + n + 8191]).begin();
it != (bi[i + n + 8191]).end(); it++) {
if (e[*it].y != t && e[*it].c > 0) {
bel[i] = e[*it].y;
}
}
}
set<pair<pair<int, int>, int> > s;
int pnt = 0;
for (i = 1; i <= m; i++) {
if (bel[i] > n || typ[bel[i]] == 1) {
while (pnt < v.size() && v[pnt].first.second <= i) s.insert(v[pnt++]);
while (!s.empty() && s.begin()->first.first < i) s.erase(s.begin());
bel[i] = 0;
if (!s.empty()) {
bel[i] = s.begin()->second;
s.erase(s.begin());
}
}
}
if ((1) <= ((m)))
for (((i)) = (1); ((i)) <= ((m)); ((i))++)
if (bel[i]) cout << bel[i] << ' ' << i << endl;
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int i, n, t, m, j;
cin >> t;
while (t--) {
cin >> n >> m;
long long int a[n + 2][m + 2];
long long int ans[n + 2][m + 2];
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
long long int temp[] = {a[i][j], a[n - i + 1][j], a[i][m - j + 1],
a[n - i + 1][m - j + 1]};
sort(temp, temp + 4);
long long int av = temp[1];
ans[i][j] = av;
}
}
long long int moves = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
moves += llabs(a[i][j] - ans[i][j]);
}
}
cout << moves << "\n";
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MOD = 1e9 + 7;
inline int msb(int n) {
int b = 1;
while (b < 32) {
n |= n >> b;
b <<= 1;
}
return (n + 1) >> 1;
}
int A[N];
int res[N];
vector<int> bas[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
vector<int> cur_bas;
int ans = 1;
for (int i = 1; i <= n; i++) {
cur_bas.push_back(A[i]);
int sz = cur_bas.size();
for (int i = 0; i < sz - 1; i++) {
int ms = msb(cur_bas[i]);
if (cur_bas.back() & ms) cur_bas.back() ^= cur_bas[i];
}
if (cur_bas.back() == 0) {
cur_bas.pop_back();
ans += ans;
if (ans >= MOD) ans -= MOD;
}
bas[i] = cur_bas;
res[i] = ans;
}
while (q--) {
int l, x;
cin >> l >> x;
cur_bas = bas[l];
cur_bas.push_back(x);
int sz = cur_bas.size();
for (int i = 0; i < sz - 1; i++) {
int ms = msb(cur_bas[i]);
if (cur_bas.back() & ms) cur_bas.back() ^= cur_bas[i];
}
if (cur_bas.back() == 0) {
cout << res[l] << "\n";
} else {
cout << 0 << "\n";
}
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, f, g, h, i, j, k;
long long F[305][305][305], C[305][305];
long long an[305][305] = {
{0, 0},
{0, 2, 1},
{0, 32, 30, 80, 109},
{0, 6824, 59808, 147224, 415870, 1757896, 1897056, 4898872, 7593125},
{0, 776830421, 290516100, 746623577, 293783147, 33900006, 735127505,
565460332, 428982705, 472062098, 161873957, 117354594, 515619293,
578944191, 312106242, 569389279, 391464593},
{0, 261086313, 584837659, 683961846, 468868529, 211593382,
736955478, 229471758, 157617135, 398169441, 360252438, 629394768,
264125799, 647490480, 342079395, 391579767, 225200475, 486011304,
513156108, 628771752, 132906648, 142138221, 20119449, 444199674,
195188679, 387329805, 44684703, 651912135, 737154512, 612549793,
519860281, 186175544, 212568440},
{0, 240805271, 239509872, 581127897, 6511239, 156126222,
509425833, 672407328, 366667722, 459185405, 509737025, 554790222,
165216555, 703150560, 74806569, 398730015, 383350905, 506108358,
51326142, 298053147, 104256117, 391428765, 374020479, 206607807,
87664059, 275899176, 56407680, 551553401, 448939463, 582889860,
129676638, 226078251, 135769095, 61292868, 578972226, 190181628,
390739055, 184587732, 446575689, 732674124, 232198470, 676760679,
352474101, 611444862, 575661807, 628905585, 320813094, 522840969,
469781928, 156006018, 554473341, 239654268, 643714911, 433540170,
199307003, 496385218, 291740751, 67309914, 370826673, 202356819,
279421821, 421203111, 63744786, 520987612, 550671827},
{0, 482164403, 768209115, 462063756, 154906374, 36099042,
341766705, 678182556, 621882744, 478771358, 231881111, 175889805,
243630450, 168908523, 671961765, 55761813, 652682670, 773939082,
517628076, 756201264, 124604900, 750976272, 498253248, 676047609,
137170026, 705610017, 495032139, 561797418, 703097347, 500815609,
95984586, 739707108, 265613565, 387099846, 777331779, 594676173,
591219559, 407997044, 208947235, 93337440, 478908360, 685013007,
487033953, 671903001, 39521181, 738490312, 33785059, 465470131,
310453920, 54648783, 346831137, 427694175, 474743430, 705296781,
435828036, 429824745, 663532359, 261388683, 244690731, 533997135,
596108961, 506813013, 371892402, 590145264, 104733162, 143420103,
654339672, 700348950, 685038942, 578826927, 286484229, 501639192,
434962491, 299270097, 27702486, 335375775, 111746817, 565603164,
294926121, 676063665, 735862995, 710035809, 437011960, 668528077,
138765186, 508213986, 615036450, 353784942, 624827616, 343900011,
241289776, 52410890, 72018835, 352406796, 415705878, 4802637,
376367145, 65589678, 333633477, 341834527, 303717460, 282387700,
42951006, 254706039, 423048528, 526429710, 68131467, 669954708,
12787348, 500636381, 317959019, 479433192, 657133515, 416259390,
610216692, 340129188, 44594256, 257373347, 138718678, 530767740,
292922628, 37220268, 605295159, 480722613, 458170419, 30540300,
487159055, 232966794, 149150650},
{0, 412133651, 386543325, 139952108, 289303402, 102404925,
317067177, 396414708, 80515854, 663739304, 317300809, 228877044,
493725043, 715317967, 490300965, 315527373, 743539734, 488329191,
553627998, 533025234, 242583957, 706116537, 614109258, 645447222,
523195911, 492109128, 722623041, 111085128, 766395126, 654378921,
691964847, 496688157, 399056049, 654363234, 102052314, 191720088,
473910948, 259736526, 332840025, 388047555, 665791056, 627111387,
139696515, 441456687, 443032569, 283264821, 771641703, 452641455,
511306362, 117572859, 127701891, 721298331, 176520078, 357242229,
611296308, 696994956, 405628839, 429224274, 465336054, 695091546,
689828796, 574648641, 351220905, 507964023, 675326610, 517248963,
453528621, 220301928, 494463186, 681789969, 339589656, 44524053,
417125457, 339589404, 747135963, 341780733, 734158215, 396817281,
21997836, 5728464, 147611205, 456248898, 714128667, 377654949,
3862068, 128418948, 589390074, 304947090, 11703825, 228266073,
127304142, 429215724, 361541124, 521572968, 468358191, 341231688,
65323503, 613778508, 15985323, 291661029, 410970006, 591638112,
349541550, 89967528, 224922159, 361094166, 584206074, 640051812,
324264456, 652625388, 693768537, 11740617, 309238398, 211085469,
194905872, 639416484, 110110707, 296645895, 748118511, 131177718,
511142751, 775975599, 421403409, 475528473, 434685258, 1768977,
80301375, 708023862, 569195676, 56238084, 632887668, 88089750,
631539342, 396695565, 38780154, 695798271, 469819224, 439587099,
69045921, 682966116, 112310856, 64943298, 534475872, 40215357,
389728458, 286368453, 736006257, 501181650, 54829908, 603489402,
338032656, 512182818, 627500097, 462674016, 3103092, 157324491,
43978329, 596818971, 259025598, 9088632, 91991781, 577291428,
211245489, 429471231, 142626330, 172560633, 510907446, 444609585,
758102058, 375112647, 744786693, 276174402, 19259856, 233672418,
745389414, 225772848, 23385663, 324290610, 519804558, 120337812,
402578568, 360676008, 450089262, 551043738, 337388940, 512108856,
28879011, 690040638, 106017282, 558262341, 99972432, 608226003,
612152037, 42414435, 776201013, 39580443, 518796945, 494437752,
583194366, 723936555, 415359657, 309569589, 751104774, 166684527,
249229170, 353120823, 130668327, 753823584, 580966092, 561963717,
543672234, 393846327, 586278000, 327398400, 278403867, 156455586,
363920382, 190245195, 290039148, 547014447, 466218648, 146037150,
585462906, 666008595, 691786683, 374707494, 622498779, 231158277,
685740951, 115612245, 681825249, 545555745, 551718468, 277206615,
640171035, 757727334, 195193908, 658656684, 457760646, 225925875,
505761984, 18685233, 506832921, 112511021, 396846646, 290147622,
113924623, 669986155, 336008070, 63611061, 238586775, 119956662,
616557739, 772784623, 334527774, 410403148, 51933421}};
void DP() {
C[0][0] = 1;
for (i = 1; i <= a; i++) {
C[i][0] = 1;
for (j = 1; j <= i; j++)
(C[i][j] = C[i - 1][j - 1] + C[i - 1][j]) %= 777777777;
}
for (i = 0; i <= a; i++) F[0][i][0] = 1;
for (i = 1; i <= a; i++)
for (j = 1; j <= a; j++)
for (k = 0; k <= i; k++) {
if (i >= j) (F[i][j][k] += F[i - j][j - 1][k] * C[i][j]) %= 777777777;
for (long long l = 0; l <= k; l++)
if (l != j)
(F[i][j][k] += F[i - l][j - 1][k - l] * C[i][l]) %= 777777777;
}
}
int main() {
cin >> a >> b;
a = (int)(log((double)a + 0.05) / log(2.0));
cout << an[a][b] << endl;
return 0;
for (a = 1; a <= 256; a <<= 1) {
cout << a << ": ";
cout << "{0, ";
memset(F, 0, sizeof(F));
DP();
for (b = 1; b < a; b++) cout << F[a][a][b] << ", ";
cout << F[a][a][b] << "}" << endl;
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void mini(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void maxi(T &a, T b) {
if (b > a) a = b;
}
int main() {
int n, m, a, b;
int G[1000][1000];
memset(G, 0, sizeof G);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
G[a - 1][b - 1] = 1;
G[b - 1][a - 1] = 1;
}
int node;
bool flag = false;
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < n; j++) t += G[i][j];
if (t == 0) {
node = i;
flag = true;
break;
}
if (flag) break;
}
cout << n - 1 << endl;
for (int i = 0; i < n; i++) {
if (i != node) {
cout << node + 1 << " " << i + 1 << endl;
}
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
bool ok = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int w, h, i, j, k, star = 0;
cin >> w >> h;
string s[w];
for (i = 0; i < w; i++) {
cin >> s[i];
for (j = 0; j < h; j++)
if (s[i][j] == '*') star++;
}
for (i = 1; i < w; i++) {
for (j = 1; j < h; j++) {
if (s[i][j] == '*') {
if ((j + 1 < h && s[i][j + 1] == '*') &&
(i + 1 < w && s[i + 1][j] == '*') && s[i][j - 1] == '*' &&
s[i - 1][j] == '*') {
ok = 1;
break;
}
}
}
if (ok) break;
}
if (!ok) return cout << "NO" << endl, 0;
int r = i, c = j;
for (j = c + 1; j < h; j++) {
if (s[r][j] == '*')
star--;
else
break;
}
for (j = c - 1; j >= 0; j--) {
if (s[r][j] == '*')
star--;
else
break;
}
for (i = r + 1; i < w; i++) {
if (s[i][c] == '*')
star--;
else
break;
}
for (i = r - 1; i >= 0; i--) {
if (s[i][c] == '*')
star--;
else
break;
}
if (star == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100111;
struct task {
int i, j, k;
};
inline bool compare(task a, task b) { return a.i > b.i; }
int n, a[maxn], m, sum[maxn], pr[maxn], parent[maxn], ans[maxn], start2[maxn];
vector<int> start[maxn];
task tasks[maxn];
int getpar(int v) {
if (parent[v] == v)
return v;
else
return parent[v] = getpar(parent[v]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]), sum[i + 1] = sum[i] + a[i], parent[i] = i;
scanf("%d", &m);
for (int i = 0; i < m; i++)
scanf("%d%d", &tasks[i].i, &tasks[i].j),
tasks[i].i = tasks[i].j - tasks[i].i, tasks[i].j -= 1, tasks[i].k = i;
stack<pair<int, int> > st;
st.push(make_pair(-1, -1));
for (int i = 0; i < n; i++) start2[i] = maxn;
for (int i = 0; i < n; i++) {
while (st.size() && st.top().first >= a[i]) {
st.pop();
}
pr[i] = st.top().second;
if (pr[i] != -1) {
int k = 0;
while (true) {
k = (sum[i + 1] - sum[pr[i] + 1] - a[pr[i]] * (i - pr[i])) /
(a[i] - a[pr[i]]);
if ((sum[i + 1] - sum[pr[i] + 1] - a[pr[i]] * (i - pr[i])) %
(a[i] - a[pr[i]]))
k++;
k = min(max(k, i - pr[i] + 1), maxn);
if (k - (i - pr[i]) >= start2[pr[i]]) {
st.pop();
pr[i] = st.top().second;
} else
break;
}
if (k < i + 2) start[i - k + 1].push_back(i), start2[i] = k;
}
st.push(make_pair(a[i], i));
}
sort(tasks, tasks + m, compare);
for (int cur = n - 1, i = 0; i < m; i++) {
while (cur > tasks[i].i) {
cur--;
for (int j = 0; j < start[cur].size(); j++)
if (parent[start[cur][j]] == start[cur][j]) {
parent[start[cur][j]] = getpar(pr[start[cur][j]]);
}
}
int aa = getpar(tasks[i].j), bb = tasks[i].j;
ans[tasks[i].k] = sum[bb + 1] - sum[aa + 1] +
a[aa] * (tasks[i].j - tasks[i].i + 1 - bb + aa);
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 21
|
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n == 2)
printf("2");
else
printf("1");
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int a[105], ans;
int main() {
scanf("%d", &a[0]);
for (int i = 1; i <= a[0]; ++i) {
scanf("%d", &a[i]);
ans += i * a[i];
}
printf("%d\n", ans);
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n;
const int maxn = 1000007;
pair<int, pair<int, int> > Q[maxn];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
Q[i].first = read() / 1050;
Q[i].second.first = read();
Q[i].second.second = i;
}
sort(Q + 1, Q + 1 + n);
for (int i = 1; i <= n; i++) cout << Q[i].second.second << " ";
cout << endl;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0);
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class TT>
bool pal(T a, TT n) {
int k = 0;
for (int i = 0; i <= n / 2; i++) {
if (a[i] != a[n - i - 1]) {
k = 1;
break;
}
}
return k ? 0 : 1;
}
bool ko(long long x) {
if (x == 1) return 0;
long long m = sqrt(x);
return (m * m == x);
}
bool ok(long long x) {
for (long long i = 1; i * i <= x; i++) {
if ((x % i != 0)) continue;
long long q = x / i;
if (ko(q) || ko(i)) return 0;
}
return 1;
}
int main() {
long long n, ans = 1;
cin >> n;
for (long long i = 1; i * i <= n; i++) {
if (n % i != 0) continue;
long long j = n / i;
if (ok(i)) umax(ans, i);
if (ok(j)) umax(ans, j);
}
cout << ans;
getchar();
getchar();
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int INP, AM, REACHEOF;
const int BUFSIZE = (1 << 12) + 17;
char BUF[BUFSIZE + 1], *inp = BUF;
const int MN = 100111;
int n, a[MN];
long long f[MN], g[MN];
vector<int> ke[MN];
bool cmp(int u, int v) {
if (f[u] != f[v]) return f[u] > f[v];
if (g[u] != g[v]) return g[u] > g[v];
return u < v;
}
void dfs(int u, int fu) {
vector<int> id;
id.clear();
for (int i = 0, _a = (ke[u].size()); i < _a; i++) {
int v = ke[u][i];
if (v == fu) continue;
dfs(v, u);
id.push_back(v);
}
sort(id.begin(), id.end(), cmp);
f[u] = 1;
g[u] = a[u] - 1;
int last = -1;
for (int i = 0, _a = (id.size()); i < _a; i++) {
int v = id[i];
if (g[u]) {
last = i;
f[u] += f[v];
f[u]++;
g[u]--;
}
}
for (int i = 0, _a = (last + 1); i < _a; i++) {
int v = id[i];
int can = min(g[u], g[v]);
g[u] -= can;
f[u] += 2 * can;
}
}
int main() {
ios ::sync_with_stdio(false);
while (cin >> n) {
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
for (int i = (1), _b = (n); i <= _b; i++) ke[i].clear();
for (int i = (2), _b = (n); i <= _b; i++) {
int u, v;
cin >> u >> v;
ke[u].push_back(v);
ke[v].push_back(u);
}
int s;
cin >> s;
++a[s];
dfs(s, -1);
cout << f[s] - 1 << endl;
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, a, s, d, otv = 0;
cin >> a;
map<long long, long long> ch;
map<long long, long long>::iterator ii;
vector<long long> dva;
for (i = 0; i < a; i++) {
cin >> d;
ch[d]++;
}
d = 1;
for (i = 0; i < 62; i++) {
dva.push_back(d);
d *= 2;
}
dva.push_back(d);
for (ii = ch.begin(); ii != ch.end(); ii++) {
long long kk = 0;
kk = 0;
for (i = 0; i < dva.size(); i++) {
long long oo;
oo = dva[i];
oo -= ii->first;
if (oo != ii->first)
if (ch[oo] == 0)
ch.erase(oo);
else {
kk = 1;
}
}
for (i = 0; i < dva.size(); i++)
if (kk == 0)
if (dva[i] - ii->first == ii->first) {
if (ii->second == 1) {
otv++;
kk = 1;
break;
}
kk = 1;
}
if (kk == 0) {
otv += ii->second;
}
}
cout << otv;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans_1, ans_2;
scanf("%d", &n);
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
ans_1 = i;
ans_2 = n / i;
}
}
printf("%d %d\n", ans_1, ans_2);
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
long long a[n], b[m];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long j = 0; j < m; j++) cin >> b[j];
for (long long ans = 0; ans <= 2e9; ans++) {
bool done = true;
for (long long i = 0; i < n; i++) {
bool yes = false;
for (long long j = 0; j < m; j++) {
if (((a[i] & b[j]) | ans) == ans) {
yes = true;
break;
}
}
if (!yes) {
done = 0;
break;
}
}
if (done) {
cout << ans << endl;
return;
}
}
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a_v, a_e, a_s;
cin >> a_v >> a_e >> a_s;
vector<vector<pair<int, int>>> graph(a_v);
map<int, bool> res;
vector<long long int> reslist;
long long int a, b, l;
for (int i = 0; i < a_e; i++) {
cin >> a >> b >> l;
graph[a - 1].push_back(make_pair(b - 1, l));
graph[b - 1].push_back(make_pair(a - 1, l));
}
long long int min = numeric_limits<long long int>::max();
for (int i = 0; i < a_s; i++) {
cin >> a;
res[a - 1] = true;
reslist.push_back(a - 1);
}
for (int it : reslist) {
for (auto v : graph[it]) {
if (!res[v.first] && v.second < min) {
min = v.second;
}
}
}
if (min != numeric_limits<long long int>::max())
cout << min;
else
cout << "-1";
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
scanf("%d%d", &a, &b);
int res = 0;
int c[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
for (int i = a; i <= b; i++) {
int t = i;
while (t) {
res += c[t % 10];
t /= 10;
}
}
printf("%d\n", res);
return 0;
}
| 2
|
#include <bits/stdc++.h>
#pragma optimize("O3")
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18 + 7;
const int base = 2e5 + 1;
const long long MAX = 1e6;
const double EPS = 1e-9;
const double PI = acos(-1.);
const int MAXN = 2 * 1e5 + 147;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long g = max((3 * a / 10), (a - (a / 250 * c)));
long long h = max((3 * b / 10), (b - (b / 250 * d)));
if (g == h) {
cout << "Tie";
} else if (g > h) {
cout << "Misha" << '\n';
} else {
cout << "Vasya" << '\n';
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
void rvereseArray(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int main() {
int n;
cin >> n;
int arr[n], arr2[n], cont = 0, l = -1, r = -1;
vector<int> res;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; ++i) arr2[i] = arr[i];
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (arr[i] != arr2[i]) {
if (l == -1)
l = i;
else
r = i;
}
}
rvereseArray(arr2, l, r);
for (int i = 0; i < n; i++) {
if (arr2[i] != arr[i]) {
cout << "no" << endl;
return 0;
}
}
if (l == r && l == -1) {
printf("yes\n%d %d", 1, 1);
} else {
printf("yes\n%d %d", l + 1, r + 1);
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[3][100005];
int n;
scanf("%d", &n);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n - i; j++) scanf("%d", &arr[i][j]);
sort(arr[i], arr[i] + n - i);
}
for (int i = 0; i < n; i++) {
if (arr[0][i] != arr[1][i]) {
printf("%d\n", arr[0][i]);
break;
}
}
for (int i = 0; i < n - 1; i++) {
if (arr[1][i] != arr[2][i]) {
printf("%d\n", arr[1][i]);
break;
}
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <class T>
ostream& prnt(ostream& out, T v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
return prnt(out, v);
}
template <class T>
ostream& operator<<(ostream& out, set<T> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, map<T1, T2> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ' ' << p.second << ')';
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
const long double PI = acos(-1);
int n, eq;
long long DP[2][51][51][51 * 101], sum;
pair<int, int> v[51];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i].first;
for (int i = 1; i <= n; i++) cin >> v[i].second;
sort(v + 1, v + n + 1,
[](pair<int, int> a, pair<int, int> b) { return a.first > b.first; });
memset(DP, 0x3f, sizeof(DP));
DP[0][0][0][0] = 0;
for (int i = 0; i < n; i++) {
memset(DP[(i & 1) ^ 1], 0x3f, sizeof(DP[i % 2]));
if (v[i].first != v[i + 1].first) {
for (int j = 0; j <= i / 2; j++) {
for (int k = 0; k <= eq; k++) {
for (int s = 0; s <= sum; s++) {
if (i - 2 * j > 0)
DP[(i & 1) ^ 1][j + 1][1][s] =
min(DP[(i & 1) ^ 1][j + 1][1][s], DP[i & 1][j][k][s]);
DP[(i & 1) ^ 1][j][0][s + v[i + 1].second] =
min(DP[(i & 1) ^ 1][j][0][s + v[i + 1].second],
DP[i & 1][j][k][s] + v[i + 1].first);
}
}
}
eq = 1;
} else {
eq++;
for (int j = 0; j <= i / 2; j++) {
for (int k = 0; k < eq; k++) {
for (int s = 0; s <= sum; s++) {
if (i - 2 * j - (eq - k - 1) > 0)
DP[(i & 1) ^ 1][j + 1][k + 1][s] =
min(DP[(i & 1) ^ 1][j + 1][k + 1][s], DP[i & 1][j][k][s]);
DP[(i & 1) ^ 1][j][k][s + v[i + 1].second] =
min(DP[(i & 1) ^ 1][j][k][s + v[i + 1].second],
DP[i & 1][j][k][s] + v[i + 1].first);
}
}
}
}
sum += v[i + 1].second;
}
long long ans = 1e18;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++) {
for (int s = 1; s <= sum; s++) {
ans = min(ans, min((long long)(1e15), DP[n & 1][j][k][s]) * 1000 / s +
(s == 0 ? 0 : DP[n & 1][j][k][s] * 1000 % s != 0));
}
}
cout << ans << '\n';
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
if (0) {
freopen("PA.INP", "r", stdin);
freopen("PA.OUT", "w", stdout);
}
ios_base::sync_with_stdio(false);
cin.tie(0);
long long r;
cin >> r;
r--;
pair<long long, long long> res;
for (int x = (1); x <= int(sqrt(r)); x++)
if (r % x == 0) {
long long a = r / x;
if ((a - x - 1) % 2 == 0 && (a - x - 1) / 2 > 0) {
res = {x, (a - x - 1) / 2};
break;
}
}
if (!res.first)
cout << "NO";
else
cout << res.first << " " << res.second;
return 0;
}
| 4
|
#include <bits/stdc++.h>
const int N = 2000005;
const int M = 10005;
const long long mod = 1000000007;
const double PI = acos(-1.0);
const double eps = 1e-10;
using namespace std;
int f[N], s[N], st;
long long m;
long long cal(int* f, long long x, long long y, long long h) {
int id = 0;
while (1) {
f[h] = id++;
h = (h * x + y) % m;
if (f[h]) {
st = f[h];
break;
}
}
return id - st;
}
vector<long long> solve(long long a, long long cl, long long tmp) {
vector<long long> t;
if (a < tmp)
t.push_back(a);
else {
for (int i = 0; i <= m; i++) {
long long x = a + i * cl;
t.push_back(x);
}
}
return t;
}
int main() {
long long h1, a1, x1, y1, h2, a2, x2, y2;
cin >> m;
cin >> h1 >> a1;
cin >> x1 >> y1;
cin >> h2 >> a2;
cin >> x2 >> y2;
long long clf = cal(f, x1, y1, h1);
int st1 = st;
long long cls = cal(s, x2, y2, h2);
int st2 = st;
if (f[a1] == 0 || s[a2] == 0) {
cout << -1 << endl;
return 0;
}
vector<long long> t1 = solve(f[a1], clf, st1);
vector<long long> t2 = solve(s[a2], cls, st2);
int l = 0, r = 0;
while (l < t1.size() && r < t2.size()) {
if (t1[l] > t2[r]) {
r++;
continue;
}
if (t1[l] < t2[r]) {
l++;
continue;
}
cout << t1[l] << endl;
return 0;
}
cout << -1 << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int mod = 1000000000 + 7;
char s[maxn];
long long b[maxn];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
scanf("%s", s);
int f[26];
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
f[s[i] - 'A']++;
}
sort(f, f + 26);
int k = 1;
for (int i = 24; i; i--) {
if (f[i] == f[25]) {
k++;
} else {
break;
}
}
b[0] = 1;
for (int i = 1; i <= n; i++) {
b[i] = (b[i - 1] * k) % mod;
}
printf("%I64d\n", b[n]);
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
string s;
cin >> n >> m >> s;
vector<int> pref(n);
for (int i = 0; i < m; ++i) {
int p;
cin >> p;
++pref[p - 1];
}
for (int i = n - 1; i > 0; --i) {
pref[i - 1] += pref[i];
}
vector<int> ans(26);
for (int i = 0; i < n; ++i) {
ans[s[i] - 'a'] += pref[i];
++ans[s[i] - 'a'];
}
for (int i = 0; i < 26; ++i) {
cout << ans[i] << " ";
}
cout << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
bool rev(long long x, long long y) { return x > y; }
void input_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cin >> a[i];
}
void print_vec(vector<long long> &v) {
for (auto i : v) cout << i << " ";
cout << endl;
}
void print_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cout << a[i] << " ";
cout << endl;
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
bool sortinrevbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
template <typename... T>
void input(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void print(T &&...args) {
((cout << args << endl), ...);
}
template <typename... T>
void deb(T &&...args) {
cout << "~~ ";
((cout << args << " "), ...);
cout << endl;
}
void stand8th() {
long long n;
input(n);
long long a[n];
input_arr(a, n);
sort(a, a + n);
if (a[n - 1] >= a[n - 2] + a[n - 3]) {
print("NO");
return;
}
print("YES");
for (long long i = 0; i < n - 2; i += 1) {
cout << a[i] << " ";
}
cout << a[n - 1] << " " << a[n - 2] << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tin = 1;
while (tin--) {
stand8th();
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long A[11];
long long dp[101][11];
long long c[101][101];
long long mod = 1e9 + 7;
long long C(int n, int k) {
if (n < 0 || k > n) return 0;
if (k == 0 || n == k) return 1;
if (c[n][k] != -1) return c[n][k];
return c[n][k] = (C(n - 1, k) + C(n - 1, k - 1)) % mod;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(c, -1, sizeof c);
long long n;
cin >> n;
for (int i = 0; i < 10; i++) cin >> A[i];
for (int i = A[9]; i <= n; i++) dp[i][9] = 1;
for (int i = 8; i >= 0; i--)
for (int len = A[i]; len <= n; len++)
for (int numi = A[i]; numi <= len; numi++)
dp[len][i] =
(dp[len][i] + dp[len - numi][i + 1] * C(len - (i == 0), numi)) %
mod;
long long ats = 0;
for (int i = 1; i <= n; i++) ats += dp[i][0], ats %= mod;
cout << ats;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10, inf = 1e9;
pair<int, int> a[MAXN], b[MAXN];
int l[MAXN];
double dist(pair<int, int> x, pair<int, int> y) {
long long px = x.first - y.first, py = y.second - x.second;
px *= px;
py *= py;
return sqrt(px + py);
}
int main() {
int n, m, x1, x2;
cin >> n >> m >> x1 >> x2;
for (int i = 1; i <= n; i++) {
int y;
cin >> y;
a[i] = make_pair(x1, y);
}
for (int i = 1; i <= m; i++) {
int y;
cin >> y;
b[i] = make_pair(x2, y);
}
for (int i = 1; i <= m; i++) cin >> l[i];
int i = 1, ind1 = 0, ind2 = 0;
double Min = inf;
pair<int, int> z = make_pair(0, 0);
for (int j = 1; j <= m; j++) {
while (i < n and dist(z, a[i]) + dist(a[i], b[j]) >
dist(z, a[i + 1]) + dist(a[i + 1], b[j]))
i++;
double dis = dist(z, a[i]) + dist(a[i], b[j]) + (double)l[j];
if (dis < Min) {
ind1 = i;
ind2 = j;
Min = dis;
}
}
cout << ind1 << " " << ind2 << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
scanf("%d", &q);
while (q--) {
int n;
scanf("%d", &n);
int arr[n], sorted_arr[n];
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
memcpy(sorted_arr, arr, sizeof(arr));
sort(sorted_arr, sorted_arr + n);
unordered_map<int, int> reducer;
int elems = 0;
for (int i = 0; i < n; i++) {
if (i == 0 || sorted_arr[i] != sorted_arr[i - 1]) {
reducer[sorted_arr[i]] = elems;
++elems;
}
}
for (int i = 0; i < n; i++) {
arr[i] = reducer[arr[i]];
}
if (elems == 1) {
printf("0\n");
continue;
}
int locc[elems], rocc[elems];
memset(locc, -1, sizeof(locc));
memset(rocc, -1, sizeof(rocc));
for (int i = 0; i < n; i++) {
int idx = arr[i];
if (locc[idx] == -1) locc[idx] = i;
rocc[idx] = i;
}
int ans = elems;
int j = 1;
priority_queue<pair<int, int> > range_rocc;
for (int i = 0; i < elems; i++) {
if (i == j) j++;
range_rocc.push({rocc[i], i});
while (range_rocc.top().second < i) {
range_rocc.pop();
}
while (locc[j] > range_rocc.top().first && j < elems) {
range_rocc.push({rocc[j], j});
j++;
}
int cand_ans = i + elems - j;
ans = min(ans, cand_ans);
}
printf("%d\n", ans);
}
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
char s1[500200];
string s[500200];
struct node {
int st, in;
node() { st = -1, in = -1; }
};
node nd[500200];
int k = 0;
pair<int, pair<int, int> > sortt[500200];
pair<int, pair<int, int> > t2[500200];
int pl[500200];
int t1[500200];
vector<int> p[500200];
vector<int> p1[500200];
void sortP() {
t1[sortt[0].first] = 0;
for (int i = 1; i < k; i++) {
if (sortt[i].first != sortt[i - 1].first) t1[sortt[i].first] = i;
}
for (int i = 0; i < k; i++) {
if (sortt[i].second.first == -1) {
t2[t1[sortt[i].first]++] = sortt[i];
}
p[sortt[i].second.first].push_back(i);
}
int nm;
for (int i = 0; i < k; i++) {
while (!p[i].empty()) {
nm = p[i].back();
p[i].pop_back();
t2[t1[sortt[nm].first]++] = sortt[nm];
}
}
for (int i = 0; i < k; i++) sortt[i] = t2[i];
}
void pre() {
int lg = 1;
for (int i = 0; i < k; i++) {
sortt[i].first = s1[i];
sortt[i].second.first = -1;
sortt[i].second.second = i;
}
sort(sortt, sortt + k);
while (lg <= k) {
int nm = 1;
for (int i = 1; i < k; i++) {
if (make_pair(sortt[i].first, sortt[i].second.first) !=
make_pair(sortt[i - 1].first, sortt[i - 1].second.first)) {
sortt[i - 1].first = nm;
nm++;
} else
sortt[i - 1].first = nm;
}
sortt[k - 1].first = nm;
for (int i = 0; i < k; i++) {
pl[sortt[i].second.second] = sortt[i].first;
}
for (int i = 0; i < k; i++) {
sortt[i].second.first = -1;
if (sortt[i].second.second + lg < k)
sortt[i].second.first = pl[sortt[i].second.second + lg];
}
sort(sortt, sortt + k);
lg *= 2;
}
}
int pre1[500500];
vector<int> lcp() {
pre1[sortt[0].second.second] = -1;
vector<int> res;
for (int i = 1; i < k; i++)
pre1[sortt[i].second.second] = sortt[i - 1].second.second;
int l = 0;
for (int i = 0; i < k; i++) {
while (i + l < k && pre1[i] + l < k && s1[i + l] == s1[pre1[i] + l]) l++;
res.push_back(l);
l = max(l - 1, 0);
}
return res;
}
int st1[200200];
int en1[200200];
struct query {
int l, r, k, in;
bool operator<(const query &z) const { return l > z.l; }
query() {}
query(const query &z) {
l = z.l;
r = z.r;
k = z.k;
in = z.in;
}
};
query qu[500500];
int dp[1600800];
void add(int a, int b, int x, int l = 0, int h = k, int p = 1) {
if (a == l && b == h) {
dp[p] += x;
return;
}
int m = (l + h) / 2;
if (b <= m) {
add(a, b, x, l, m, 2 * p);
} else if (a > m) {
add(a, b, x, m + 1, h, 2 * p + 1);
} else {
add(m + 1, b, x, m + 1, h, 2 * p + 1);
add(a, m, x, l, m, 2 * p);
}
dp[p] = dp[2 * p] + dp[2 * p + 1];
}
int cal(int a, int b, int x = 0, int l = 0, int h = k, int p = 1) {
if (a == l && b == h) {
return dp[p];
}
int m = (l + h) / 2;
if (b <= m) {
return cal(a, b, x, l, m, 2 * p);
} else if (a > m) {
return cal(a, b, x, m + 1, h, 2 * p + 1);
} else {
return cal(m + 1, b, x, m + 1, h, 2 * p + 1) + cal(a, m, x, l, m, 2 * p);
}
}
int res[500500];
int main() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
scanf("%s", s1);
s[i] = string(s1);
}
for (int i = 0; i < n; i++) {
int m = s[i].size();
for (int j = 0; j < m; j++) {
nd[k].st = i;
nd[k].in = j;
s1[k++] = s[i][j];
}
s1[k++] = 'a' - 1;
}
pre();
vector<int> lcps = lcp();
for (int i = k - 1; i >= 0; i--) {
int in = sortt[i].second.second;
if (nd[in].in == 0) {
en1[nd[in].st] = i;
for (int j = i + 1; j < k; j++) {
if (lcps[sortt[j].second.second] < s[nd[in].st].size()) break;
int in1 = sortt[j].second.second;
en1[nd[in].st] = j;
if (nd[in1].in == 0) {
en1[nd[in].st] = en1[nd[in1].st];
j = en1[nd[in1].st];
}
}
}
if (nd[in].st != -1) p[nd[in].st].push_back(i);
}
for (int i = 0; i < k; i++) {
int in = sortt[i].second.second;
if (nd[in].in == 0) {
st1[nd[in].st] = i;
for (int j = i - 1; j >= 0; j--) {
if (lcps[sortt[j + 1].second.second] < s[nd[in].st].size()) break;
int in1 = sortt[j].second.second;
st1[nd[in].st] = j;
if (nd[in1].in == 0) {
st1[nd[in].st] = st1[nd[in1].st];
j = st1[nd[in1].st];
}
}
}
}
for (int i = 0; i < q; i++) {
scanf("%d", &qu[i].l);
scanf("%d", &qu[i].r);
scanf("%d", &qu[i].k);
qu[i].l--;
qu[i].r--;
qu[i].k--;
qu[i].in = i;
}
sort(qu, qu + q);
for (int i = 0; i < q; i++) {
p1[qu[i].r].push_back(i);
}
int j = n - 1;
for (int i = 0; i < q; i++) {
while (j >= 0 && qu[i].l <= j) {
for (int k = 0; k < p1[j].size(); k++) {
int in = p1[j][k];
res[qu[p1[j][k]].in] -= cal(st1[qu[in].k], en1[qu[in].k]);
}
for (int k = 0; k < p[j].size(); k++) {
add(p[j][k], p[j][k], 1);
}
j--;
}
res[qu[i].in] += cal(st1[qu[i].k], en1[qu[i].k]);
}
for (int i = 0; i < q; i++) printf("%d\n", res[i]);
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
const long long mod = 1e9 + 7;
int a[maxn];
int b[maxn];
vector<int> u;
int T, n, k;
bool cal(long long x) {
long long ans = 1;
for (int i = 1; i <= n; i++) {
int p = upper_bound(a + 1, a + n + 1, x) - a - 1;
x++;
ans = (p - i + 1) % k;
if (ans == 0) {
return 0;
}
}
return 1;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
int l = 0, m = 0, r = a[k];
for (int i = 1; i <= n; i++) {
m = max(m, a[i] - i + 1);
}
l = m;
int ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (cal(mid)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
printf("%d\n", max(0, ans - m + 1));
for (int i = m; i <= ans; i++) {
printf("%d ", i);
}
printf("\n");
}
| 11
|
#include <bits/stdc++.h>
long long int p = 0, len;
long long int f(char s[]) {
long long int cnt = 0, i, r, d, val = 0;
len = strlen(s);
if (len <= 3) {
if (len == 3)
val = (s[0] - '0') * 100 + (s[1] - '0') * 10 + (s[2] - '0');
else if (len == 2)
val = (s[0] - '0') * 10 + (s[1] - '0');
else
val = s[0] - '0';
return val;
} else {
val = ((len - 1) * (len - 2) * (len - 3) * 9 * 9 * 9) / 6 +
((len - 1) * (len - 2) * 9 * 9) / 2 + (len - 1) * 9;
p = 0;
cnt = 0;
for (i = 0; i < len; i++) {
if (s[i] != '0') p++;
if (s[i] != '0' & cnt < 3) {
cnt++;
r = len - i - 1;
d = s[i] - '0';
if (cnt == 1) {
if (r > 0) val = val + (d - 1) * ((r * (r - 1) * 81) / 2 + r * 9 + 1);
}
if (cnt == 2) {
if (r > 0) {
val = val + (d - 1) * (9 * r + 1);
val = val + ((r * (r - 1) * 81) / 2 + 9 * r + 1);
} else {
val = val + (d - 1);
val = val + 1;
}
}
if (cnt == 3) {
if (r > 0) {
val = val + (d - 1);
val = val + (r * 9 + 1);
} else {
val = val + (d - 1);
val = val + 1;
}
}
}
}
val = val + 1;
return val;
}
}
int main() {
long long int Q, res1, res2, result;
char s1[20];
char s2[20];
scanf("%lld", &Q);
while (Q--) {
scanf("%s", s1);
scanf("%s", s2);
res1 = f(s1);
if (p <= 3 || len <= 3) res1 = res1 - 1;
res2 = f(s2);
result = res2 - res1;
printf("%lld\n", result);
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int mapp[51][51], rec[51][51], ans(1000000007);
inline long long read() {
int s(0);
bool w(1);
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
int main() {
register int n, m, a, b;
n = read();
m = read();
for (register int i = 1; i <= n; ++i) {
for (register int j = 1; j <= m; ++j) {
mapp[i][j] = read();
}
}
for (register int i = 1; i <= n; ++i) {
for (register int j = 1; j <= m; ++j) {
rec[i][j] = mapp[i][j] + rec[i][j - 1];
}
}
for (register int i = 1; i <= m; ++i) {
for (register int j = 1; j <= n; ++j) {
rec[j][i] = rec[j][i] + rec[j - 1][i];
}
}
a = read();
b = read();
register int anss;
for (register int i = 1; i <= n; ++i) {
for (register int j = 1; j <= m; ++j) {
if (i >= a && j >= b) {
anss = rec[i][j] - rec[i - a][j] - rec[i][j - b] + rec[i - a][j - b];
if (anss < ans) ans = anss;
}
if (i >= b && j >= a) {
anss = rec[i][j] - rec[i - b][j] - rec[i][j - a] + rec[i - b][j - a];
if (anss < ans) ans = anss;
}
}
}
printf("%d", ans);
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
pair<int, int> b[100100];
vector<int> q;
pair<int, pair<int, int> > a[100100];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i].first >> a[i].second.first;
a[i].second.first = 1 - a[i].second.first;
a[i].second.second = i;
}
sort(a, a + m);
int p = 0, k = 1, un = 0, uk = -1;
for (int i = 0; i < m; i++) {
if (a[i].second.first == 1 && p == 0) {
cout << -1 << endl;
return 0;
}
if (a[i].second.first == 0) {
p += k - 1;
k++;
q.push_back(k);
b[a[i].second.second] = make_pair(1, k);
} else {
if (uk == -1) {
un++;
uk = un - 1;
}
b[a[i].second.second] = make_pair(q[uk], q[un]);
uk--;
p--;
}
}
for (int i = 0; i < m; i++) cout << b[i].first << ' ' << b[i].second << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int n, k, amin, amax, a[1 << 20];
long long sum = 0;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
sort(a, a + n);
int moves = k;
for (int i = 0; i < n;) {
int j = i;
int g = 1e9 + 5;
while (j < n && a[i] == a[j]) {
j++;
}
if (j < n) {
g = a[j] - a[i];
}
if (g * 1LL * j <= moves) {
moves -= g * 1LL * j;
} else {
amin = a[i] + moves / j;
break;
}
i = j;
}
if (amin > sum / n) {
amin = sum / n;
}
moves = k;
reverse(a, a + n);
for (int i = 0; i < n;) {
int j = i;
int g = 1e9 + 5;
while (j < n && a[i] == a[j]) {
j++;
}
if (j < n) {
g = a[i] - a[j];
}
if (g * 1LL * j <= moves) {
moves -= g * 1LL * j;
} else {
amax = a[i] - moves / j;
break;
}
i = j;
}
if (amax < (sum + n - 1) / n) {
amax = (sum + n - 1) / n;
}
printf("%d\n", amax - amin);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int MOD = 1e9 + 7;
long long int ans = 0;
long long int ctr = 0;
while (k != 0) {
if (k % 2 == 1) {
ans = (ans + power(n, ctr, MOD) % MOD) % MOD;
} else {
}
ctr++;
k /= 2;
}
cout << ans % MOD << endl;
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, k, d[5555][5555], ans, l, r, x;
int main() {
cin >> n >> a >> b >> k;
d[a][0] = 1;
for (long long i = 1; i <= k; i++) {
for (long long j = 1; j <= n; j++)
if (j != b) {
long long len = ((j - b) >= 0 ? (j - b) : -(j - b)) - 1;
l = max((long long)1, j - len), r = min(n, j + len), x = d[j][(i - 1)];
d[l][i] += x;
if (d[l][i] >= 1000000007) d[l][i] -= 1000000007;
d[j][i] -= x;
if (d[j][i] < 0) d[j][i] += 1000000007;
d[j + 1][i] += x;
if (d[j + 1][i] >= 1000000007) d[j + 1][i] -= 1000000007;
d[r + 1][i] -= x;
if (d[r + 1][i] < 0) d[r + 1][i] += 1000000007;
}
for (long long j = 1; j <= n; j++) {
d[j][i] += d[j - 1][i];
if (d[j][i] >= 1000000007) d[j][i] -= 1000000007;
if (d[j][i] < 0) d[j][i] += 1000000007;
d[j][(i - 1)] = 0;
}
}
for (long long i = 1; i <= n; i++) {
ans += d[i][k];
if (ans >= 1000000007) ans -= 1000000007;
}
cout << ans;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int P = 1e9 + 7;
int n;
int ans[N];
char s[N];
int pw[N], hsh[N];
int subHash(int lst, int len);
int main() {
scanf("%d%s", &n, s + 1);
pw[0] = 1;
for (int i = 1; i <= n; ++i) {
pw[i] = pw[i - 1] * 26LL % P;
hsh[i] = (hsh[i - 1] * 26LL + (s[i] - 'a')) % P;
}
int cur = -1;
for (int i = (n + 1) / 2; i; --i) {
cur += 2;
if (i * 2 == n + 1) cur = -1;
while (cur != -1 && subHash(i + cur - 1, cur) != subHash(n - i + 1, cur))
cur -= 2;
ans[i] = cur;
}
for (int i = 1; i <= (n + 1) / 2; ++i) printf("%d ", ans[i]);
return 0;
}
int subHash(int lst, int len) {
int ret = (hsh[lst] - hsh[lst - len] * (long long)pw[len]) % P;
if (ret < 0) ret += P;
return ret;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
vector<int> cnt[200005];
int ans[200005];
int main(int argc, char** argv) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
cnt[t].push_back(i);
}
int now = 0;
for (int i = 1; i <= n; i++) {
while (now > 2 && !cnt[now].size()) {
now -= 3;
}
if (!cnt[now].size()) break;
ans[i] = cnt[now][cnt[now].size() - 1];
cnt[now].pop_back();
++now;
}
for (int i = 1; i <= n; i++) {
if (!ans[i]) {
puts("Impossible");
return 0;
}
}
puts("Possible");
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int n, cp[202], ok[202], sz[202], opt = 9999, cur;
vector<int> v[202], sel[3];
void tri(int st) {
cur = -1;
for (int i = (1); i <= (n); i++) ok[i] = 0;
for (int i = (0); i <= (2); i++) sel[i].clear();
for (int i = (1); i <= (n); i++)
if (ok[i] == sz[i]) sel[cp[i]].push_back(i);
int done = 0;
while (done < n) {
cur++;
for (int i = (0); i <= ((int)sel[st].size() - 1); i++) {
int to = sel[st][i];
done++;
for (int j = (0); j <= ((int)v[to].size() - 1); j++) {
int k = v[to][j];
ok[k]++;
if (ok[k] == sz[k]) sel[cp[k]].push_back(k);
}
}
sel[st].clear();
st = (st + 1) % 3;
}
opt = min(opt, cur);
return;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%d", &cp[i]), cp[i]--;
for (int i = (1); i <= (n); i++) {
scanf("%d", &sz[i]);
for (int j = (1); j <= (sz[i]); j++) {
int x;
scanf("%d", &x);
v[x].push_back(i);
}
}
for (int i = (0); i <= (2); i++) tri(i);
printf("%d\n", opt + n);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int N;
map<int, int> dp;
string s;
int main() {
int ctr_z, ctr_o, mvalue;
ctr_z = ctr_o = mvalue = 0;
cin >> N >> s;
for (int i = 0; i < N; i++) {
if (s[i] == '0')
ctr_z += 1;
else
ctr_o += 1;
if (ctr_z - ctr_o == 0) {
mvalue = i + 1;
continue;
}
if (dp.count(ctr_z - ctr_o))
mvalue = max(mvalue, i - dp[ctr_z - ctr_o]);
else
dp[ctr_z - ctr_o] = i;
}
cout << mvalue << "\n";
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const int mod = 1e9 + 7;
long long Pow(int m, int n) {
long long res = 1;
for (int i = 0; i < n; i++) res = (res * m) % mod;
return res;
}
int main() {
int m, n, k;
cin >> m >> n >> k;
if (k == 1 || k > m)
cout << Pow(n, m);
else if (k == m)
cout << Pow(n, (k + 1) / 2);
else if (!(k % 2))
cout << n;
else if (k % 2)
cout << (n * n) % mod;
return 0;
}
| 8
|
#include <iostream>
#include <vector>
using namespace std;
void merge (vector<int> &p, const vector<int> &q) {
int n = p.size();
for (int i = 1; i < n; i++){
p[i] ^= q[i - 1];
}
p[0] ^= q[n - 1];
}
int calc_ans (const vector<int> &p) {
int n = p.size();
int ans = 0;
for (int i = n / 2; i < n; i++) {
ans ^= p[i];
}
return ans;
}
const int MAX_N = 1e5 + 5;
int arr [MAX_N];
vector<int> adj [MAX_N];
int K;
vector<int> dp [MAX_N];
vector<int> updp [MAX_N];
void calc_dp (int u, int p) {
dp[u] = vector<int> (2 * K, 0);
dp[u][0] = arr[u];
for (int nxt : adj[u]) {
if (nxt != p) {
calc_dp(nxt, u);
merge(dp[u], dp[nxt]);
}
}
}
int ans [MAX_N];
void calc_updp (int u, int p) {
vector<int> cur (2 * K, 0);
cur[0] = arr[u];
merge(cur, updp[u]);
for (int nxt : adj[u]) {
if (nxt != p) {
merge(cur, dp[nxt]);
}
}
for (int nxt : adj[u]) {
if (nxt != p) {
merge(cur, dp[nxt]); // merge is its own inverse
updp[nxt] = cur;
merge(cur, dp[nxt]);
}
}
ans[u] = calc_ans(cur);
for (int nxt : adj[u]) {
if (nxt != p) {
calc_updp(nxt, u);
}
}
}
int main () {
ios::sync_with_stdio(false);
int n;
cin >> n >> K;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
calc_dp(1, 0);
updp[1] = vector<int> (2 * K, 0);
calc_updp(1, 0);
for (int i = 1; i <= n; i++) {
cout << (ans[i] != 0) << " ";
}
cout << '\n';
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
char s[1000000 + 13];
int cou[10];
int m7[10] = {1869, 1968, 1689, 6198, 1698, 1986, 1896};
int main() {
scanf("%s", s);
int l = (int)strlen(s);
for (int i = 0; i < l; i++) cou[s[i] - '0']++;
cou[1]--;
cou[6]--;
cou[8]--;
cou[9]--;
int tt = 0, t10 = 0;
for (int i = 0; i <= 9; i++) {
for (int j = 1; j <= cou[i]; j++) tt = (tt * 10 + i) % 7;
t10 += cou[i];
}
int t7 = 1;
for (int i = 1; i <= t10; i++) t7 = (t7 * 10) % 7;
for (int i = 0; i <= 6; i++) {
if (((t7 * i) % 7 + tt) % 7 == 0) {
cout << m7[i];
break;
}
}
for (int i = 0; i <= 9; i++) {
for (int j = 1; j <= cou[i]; j++) cout << i;
}
cout << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (long long i = 0; i < v.size(); ++i) {
os << v[i];
if (i != v.size() - 1) os << ", ";
}
os << "]";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "{";
for (auto it : v) {
os << it;
if (it != *v.rbegin()) os << ", ";
}
os << "}";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
os << "{";
for (auto it : v) {
os << it.first << " : " << it.second;
if (it != *v.rbegin()) os << ", ";
}
os << "}";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(";
os << v.first << ", " << v.second << ")";
return os;
}
void solve() {
string s;
cin >> s;
for (long long i = 1; i < s.length(); i++) {
if (s[i] != '?' && s[i] == s[i - 1]) {
cout << -1 << "\n";
return;
}
}
for (long long i = 0; i < s.length(); i++) {
if (s[i] != '?') continue;
if (i == 0) {
if (s[i + 1] != 'a') {
s[i] = 'a';
} else if (s[i + 1] != 'b') {
s[i] = 'b';
} else if (s[i + 1] != 'c') {
s[i] = 'c';
}
} else if (i == s.length() - 1) {
if (s[i - 1] != 'a') {
s[i] = 'a';
} else if (s[i - 1] != 'b') {
s[i] = 'b';
} else if (s[i - 1] != 'c') {
s[i] = 'c';
}
} else {
if (s[i - 1] != 'a' && s[i + 1] != 'a') {
s[i] = 'a';
} else if (s[i - 1] != 'b' && s[i + 1] != 'b') {
s[i] = 'b';
} else if (s[i - 1] != 'c' && s[i + 1] != 'c') {
s[i] = 'c';
}
}
}
cout << s << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long tc;
cin >> tc;
while (tc--) {
solve();
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
long long n;
char s[MAXN];
inline pair<long long, pair<long long, long long> > find(long long x) {
long long rt = ((n + 1) >> 1), delta = ((n + 1) >> 2);
long long fa = -1, ls = -1, rs = -1;
while (rt != x) {
fa = rt;
if (rt < x)
rt += delta;
else
rt -= delta;
delta >>= 1;
}
if (delta) ls = rt - delta, rs = rt + delta;
return make_pair(fa, make_pair(ls, rs));
}
inline void L(long long &x) {
pair<long long, pair<long long, long long> > tmp = find(x);
if (tmp.second.first != -1) x = tmp.second.first;
}
inline void R(long long &x) {
pair<long long, pair<long long, long long> > tmp = find(x);
if (tmp.second.second != -1) x = tmp.second.second;
}
inline void U(long long &x) {
pair<long long, pair<long long, long long> > tmp = find(x);
if (tmp.first != -1) x = tmp.first;
}
void solve() {
long long cur;
scanf("%lld\n%s", &cur, s + 1);
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
if (s[i] == 'L')
L(cur);
else if (s[i] == 'R')
R(cur);
else
U(cur);
}
printf("%lld\n", cur);
}
int main() {
int T;
scanf("%lld%d", &n, &T);
while (T--) solve();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int n, k, z[510][510], used[510][510], second[250000], u[250000], ans = -1;
char a[510][510];
vector<int> v;
void dfs(int i, int j, int t) {
used[i][j] = t;
if (i + 1 < n && !used[i + 1][j] && a[i + 1][j] == '.') dfs(i + 1, j, t);
if (j + 1 < n && !used[i][j + 1] && a[i][j + 1] == '.') dfs(i, j + 1, t);
if (j - 1 >= 0 && !used[i][j - 1] && a[i][j - 1] == '.') dfs(i, j - 1, t);
if (i - 1 >= 0 && !used[i - 1][j] && a[i - 1][j] == '.') dfs(i - 1, j, t);
}
int first(int x, int y) {
int i, j, res = 0;
i = x - 1;
for (j = y; j < y + k && i >= 0; j++) {
if (j < 0) continue;
if (a[i][j] == '.' && !u[used[i][j]])
res += second[used[i][j]], u[used[i][j]] = 1, v.push_back(used[i][j]);
}
i = x + k;
for (j = y; j < y + k && i < n; j++) {
if (j < 0) continue;
if (a[i][j] == '.' && !u[used[i][j]])
res += second[used[i][j]], u[used[i][j]] = 1, v.push_back(used[i][j]);
}
j = y - 1;
for (i = x; i >= 0 && i < x + k && j >= 0; i++) {
if (a[i][j] == '.' && !u[used[i][j]])
res += second[used[i][j]], u[used[i][j]] = 1, v.push_back(used[i][j]);
}
j = y + k;
for (i = x; i >= 0 && i < x + k && j < n; i++) {
if (a[i][j] == '.' && !u[used[i][j]])
res += second[used[i][j]], u[used[i][j]] = 1, v.push_back(used[i][j]);
}
res += k * k;
for (i = 0; i < v.size(); i++) u[v[i]] = 0;
v.clear();
return res;
}
int main() {
int i, j, l, h;
int t = 0;
cin >> n >> k;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[i][j] == '.' && !used[i][j]) {
t++;
dfs(i, j, t);
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[i][j] == '.') second[used[i][j]]++;
}
}
if (a[0][0] == 'X') z[0][0] = 1;
for (i = 1; i < n; i++) {
z[i][0] = z[i - 1][0];
if (a[i][0] == 'X') z[i][0]++;
z[0][i] = z[0][i - 1];
if (a[0][i] == 'X') z[0][i]++;
}
for (i = 1; i < n; i++) {
for (j = 1; j < n; j++) {
z[i][j] = z[i - 1][j] + z[i][j - 1] - z[i - 1][j - 1];
if (a[i][j] == 'X') z[i][j]++;
}
}
for (i = 0; i < n - k + 1; i++) {
for (j = 0; j < n - k + 1; j++) {
if (j == 0) {
for (l = i; l < i + k; l++) {
for (h = 0; h < k; h++) {
if (a[l][h] == '.') second[used[l][h]]--;
}
}
} else {
h = j - 1;
for (l = i; l < i + k; l++) {
if (a[l][h] == '.') second[used[l][h]]++;
}
h = j + k - 1;
for (l = i; l < i + k; l++) {
if (a[l][h] == '.') second[used[l][h]]--;
}
}
int r = first(i, j);
if (r > ans) {
ans = r;
}
}
for (l = i; l < i + k; l++) {
for (h = n - k; h < n; h++) {
if (a[l][h] == '.') second[used[l][h]]++;
}
}
}
cout << ans << endl;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
cout << max(abs(s[0] - t[0]), abs(s[1] - t[1])) << endl;
while (s != t) {
if (s[0] < t[0]) {
cout << "R";
s[0] += 1;
} else if (s[0] > t[0]) {
cout << "L";
s[0] -= 1;
}
if (s[1] < t[1]) {
cout << "U";
s[1] += 1;
} else if (s[1] > t[1]) {
cout << "D";
s[1] -= 1;
}
cout << endl;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
void doit(vector<int>& v, bool p) {
vector<int> ans;
ans.reserve(v.size());
if (v.size() % 2) {
if (p) {
for (int i = 5; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
ans.push_back(v[1]);
ans.push_back(v[3]);
ans.push_back(v[0]);
ans.push_back(v[2]);
ans.push_back(v[4]);
for (int i = 6; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
} else {
for (int i = 6; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
ans.push_back(v[3]);
ans.push_back(v[1]);
ans.push_back(v[4]);
ans.push_back(v[0]);
ans.push_back(v[2]);
for (int i = 5; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
}
} else {
if (p) {
for (int i = 4; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
ans.push_back(v[2]);
ans.push_back(v[0]);
ans.push_back(v[3]);
ans.push_back(v[1]);
for (int i = 5; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
} else {
for (int i = 5; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
ans.push_back(v[1]);
ans.push_back(v[3]);
ans.push_back(v[0]);
ans.push_back(v[2]);
for (int i = 4; i < (int)v.size(); i += 2) {
ans.push_back(v[i]);
}
}
}
for (int i = 0; i < (ans.size()); i++) v[i] = ans[i];
}
int main(int argc, char* argv[]) {
int N, M;
scanf("%d%d", &N, &M);
if (N == 1 && M == 1) {
printf("YES\n1\n");
return 0;
}
if (N == 3 && M == 3) {
printf("YES\n");
printf("5 3 8\n");
printf("7 1 6\n");
printf("2 9 4\n");
return 0;
}
if (N <= 3 && M <= 3) {
printf("NO\n");
return 0;
}
vector<vector<int> > ans(N);
for (int i = 0; i < (N); i++) ans[i].resize(M);
if (M >= 4) {
for (int i = 0; i < (N); i++) {
vector<int> row;
for (int j = 0; j < (M); j++) row.push_back(M * i + j + 1);
doit(row, i % 2);
for (int j = 0; j < (M); j++) ans[i][j] = row[j];
}
} else {
for (int j = 0; j < (M); j++) {
vector<int> col;
for (int i = 0; i < (N); i++) col.push_back(M * i + j + 1);
doit(col, j % 2);
for (int i = 0; i < (N); i++) ans[i][j] = col[i];
}
}
printf("YES\n");
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (M); j++) {
if (j) printf(" ");
printf("%d", ans[i][j]);
}
printf("\n");
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long MAX = 4005;
const double PI = 3.1415926;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
if (arr[i] >= 0) {
arr[i]++;
arr[i] = -arr[i];
}
}
long long mini = 1;
for (long long i = 0; i < n; ++i) {
mini = min(mini, arr[i]);
}
bool check = true;
if (n % 2) {
for (long long i = 0; i < n; ++i) {
if (arr[i] == mini && check) {
cout << abs(arr[i]) - 1 << " ";
check = false;
} else
cout << arr[i] << " ";
}
} else {
for (long long i = 0; i < n; ++i) {
cout << arr[i] << " ";
}
}
cout << "\n";
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 85;
const double eps = 1e-9;
int n, ct;
int l[N], r[N], b[N << 1];
double f[2][N][N], ans[N][N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &l[i], &r[i]), b[++ct] = l[i], b[++ct] = r[i];
sort(b + 1, b + ct + 1);
ct = unique(b + 1, b + ct + 1) - b - 1;
for (int i = 1; i <= n; i++)
l[i] = lower_bound(b + 1, b + ct + 1, l[i]) - b,
r[i] = lower_bound(b + 1, b + ct + 1, r[i]) - b;
for (int i = 1; i <= n; i++) {
for (int x = l[i]; x < r[i]; x++) {
double gg = 1.0 * (b[x + 1] - b[x]) / (b[r[i]] - b[l[i]]);
for (int x1 = 0; x1 <= n; x1++)
for (int x2 = 0; x2 <= n; x2++) f[0][x1][x2] = f[1][x1][x2] = 0;
int now = 0;
f[0][0][0] = 1;
for (int j = 1; j <= n; j++)
if (j != i) {
now = !now;
double L = b[l[j]], R = b[r[j]];
if (R <= b[x]) {
for (int x1 = 0; x1 < j; x1++)
for (int x2 = 0; x2 + x1 < j; x2++)
if (f[!now][x1][x2] > eps) {
double tmp = f[!now][x1][x2];
f[!now][x1][x2] = 0;
f[now][x1 + 1][x2] += tmp;
}
} else if (L > b[x]) {
for (int x1 = 0; x1 < j; x1++)
for (int x2 = 0; x2 + x1 < j; x2++)
if (f[!now][x1][x2] > eps) {
double tmp = f[!now][x1][x2];
f[!now][x1][x2] = 0;
f[now][x1][x2] += tmp;
}
} else {
double p1 = 1.0 * (b[x] - L) / (R - L),
p2 = 1.0 * (b[x + 1] - b[x]) / (R - L),
p3 = 1.0 * (R - b[x + 1]) / (R - L);
for (int x1 = 0; x1 < j; x1++)
for (int x2 = 0; x2 + x1 < j; x2++)
if (f[!now][x1][x2] > eps) {
double tmp = f[!now][x1][x2];
f[!now][x1][x2] = 0;
f[now][x1 + 1][x2] += tmp * p1;
f[now][x1][x2 + 1] += tmp * p2;
f[now][x1][x2] += tmp * p3;
}
}
}
for (int x1 = 0; x1 < n; x1++)
for (int x2 = 0; x2 + x1 < n; x2++) {
double tmp = f[now][x1][x2], p2 = 1.0 / (x2 + 1);
for (int k = 0; k <= x2; k++) ans[i][x1 + k + 1] += gg * tmp * p2;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%.10lf ", ans[i][j]);
puts("");
}
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 600000;
char S[maxn];
static int t, n, H;
bool Chk(int mid) {
int lef = t;
int th = H;
int maxh = 0;
for (int i = 1; i <= n; i++)
if (S[i] == 'H') maxh = i;
int maxS = 0;
int tmp = mid;
for (int i = 1; i <= n; i++)
if (S[i] == 'S') {
tmp++;
if (tmp == th) maxS = i;
}
if (tmp < th) return false;
if (maxS > maxh) maxh = maxS;
for (int i = 1; i <= n && th != 0; i++) {
lef--;
if (S[i] == 'H' && mid == 0) {
if ((maxh - i) * 2 <= lef) return true;
int times = 0, j, cnt = 0;
for (j = i; j <= n; j++) {
if (S[j] == 'H') times++;
if (S[j] == 'S') cnt++;
if (times == cnt) break;
}
if (times > cnt) return false;
lef -= 2 * (j - i);
th -= times;
if (th != 0) lef -= j - i;
i = j;
} else {
if (S[i] == 'S') mid++;
if (S[i] == 'H') mid--, th--;
}
}
return (lef >= 0 && th == 0);
}
int main() {
scanf("%d%d\n", &n, &t);
for (int i = 1; i <= n; i++) H += ((S[i] = getchar()) == 'H');
int l = -1, r = n + 10;
while (l + 1 < r) {
int mid = l + r >> 1;
if (Chk(mid))
r = mid;
else
l = mid;
}
if (r > n) r = -1;
printf("%d\n", r);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int a[502], dp[502][502], n, i, j, r, l;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i <= n; i++) dp[i][i] = dp[i][i + 1] = 1;
for (j = 2; j <= n; j++)
for (l = 0; l + j <= n; l++) {
r = j + l;
dp[l][r] = dp[l + 1][r];
for (i = l + 1; i < r; i++)
if (a[l] < a[i])
dp[l][r] = (dp[l][r] + 1LL * dp[l + 1][i] * dp[i][r]) % 1000000007;
}
cout << dp[1][n] << endl;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1000;
const long long INF64 = 1e18 + 1000;
const int N = 100 * 1000 + 10;
const int M = 1000;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, l, r;
cin >> n >> l >> r;
l--;
vector<int> a(n);
for (int i = 0; i < int(n); ++i) {
cin >> a[i];
}
vector<int> b(n);
for (int i = 0; i < int(n); ++i) {
cin >> b[i];
}
vector<int> a0(a.begin() + l, a.begin() + r);
vector<int> b0(b.begin() + l, b.begin() + r);
sort(a0.begin(), a0.end());
sort(b0.begin(), b0.end());
bool f = vector<int>(a.begin(), a.begin() + l) ==
vector<int>(b.begin(), b.begin() + l) &&
vector<int>(a.begin() + r, a.end()) ==
vector<int>(b.begin() + r, b.end());
cout << (f && a0 == b0 ? "TRUTH" : "LIE") << '\n';
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const long long int maxn = 2e5 + 16, maxk = 55, md = 1e9 + 7, inf = 2e16;
long long int gcd(long long int a, long long int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long int tav(long long int n, long long int k) {
long long int res = 1;
while (k > 0) {
if (k & 1) {
res *= n;
res %= md;
}
n *= n;
n %= md;
k >>= 1;
}
return res;
}
long double dp[maxn][maxk], sp[maxn], pa[maxn];
int opt[maxn][maxk], o = 2, a[maxn];
long long int ps[maxn];
long double ap(int l, int r) {
if (!l) return pa[r];
long double res = pa[r] - pa[l - 1], h, o;
h = sp[r] - sp[l - 1];
res -= ps[l - 1] * h;
return res;
}
void dvc(int l, int r, int opl, int opr) {
int m = (l + r) / 2, lm = min(m, opr + 1);
for (int i = opl; i < lm; i++) {
if (dp[i][o - 1] + ap(i + 1, m) < dp[m][o]) {
dp[m][o] = dp[i][o - 1] + ap(i + 1, m);
opt[m][o] = i;
}
}
if (r - l == 1) return;
dvc(l, m, opl, opt[m][o]);
dvc(m, r, opt[m][o], opr);
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 2; j <= k; j++) {
dp[i][j] = inf;
}
}
ps[0] = a[0];
pa[0] = 1;
sp[0] = (long double)1 / a[0];
dp[0][1] = 1;
for (int i = 1; i < n; i++) {
ps[i] = ps[i - 1] + a[i];
long double q = (long double)1 * ps[i] / a[i];
pa[i] = pa[i - 1] + q;
sp[i] = sp[i - 1] + (long double)1 / a[i];
dp[i][1] = pa[i];
}
for (; o <= k; o++) {
dvc(0, n, 0, n);
}
cout << dp[n - 1][k] << '\n';
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long N = 3e5 + 100;
vector<long long> g[N];
set<long long> unused;
void dfs(long long v, long long bad = -1) {
set<long long> cur = unused;
unused.clear();
for (auto u : g[v]) {
if (cur.count(u) || u == bad) {
cur.erase(u);
unused.insert(u);
}
}
for (auto u : cur) dfs(u);
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i < m; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
for (long long i = 1; i < n; i++) unused.insert(i);
dfs(0);
bool ok = (long long)unused.size() == 0;
ok &= n - 1 - (long long)g[0].size() >= k;
sort(g[0].begin(), g[0].end());
for (long long i = 1; i < n; i++) unused.insert(i);
long long cnt = 0;
for (long long v = 1; v < n; v++) {
if (binary_search(g[0].begin(), g[0].end(), v) || !unused.count(v))
continue;
dfs(v, 0);
cnt++;
}
ok &= cnt <= k;
cout << (ok ? "possible\n" : "impossible\n");
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
string s;
string t;
int n;
int main() {
cin >> s;
cin >> t;
string res = s;
n = s.length();
bool ct = true;
for (int i = n - 1; 0 <= i; i--) {
if (s[i] == t[i]) {
res[i] = '1';
continue;
}
if (ct)
res[i] = t[i];
else
res[i] = s[i];
ct = !ct;
}
if (!ct) {
cout << "impossible";
return 0;
}
cout << res;
return 0;
}
| 3
|
#include <bits/stdc++.h>
#define ls x<<1
#define rs x<<1|1
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
using namespace std;
typedef long long ll;
const int N=2e3+5;
const int mod=1e9+7;
int n,m,t,q;
int ans[N];
int L[20],R[20],U[20],D[20];
ll num[N],sum[N];
int main(){
num[1]=2;
rep(i,2,59){
num[i]=num[i-1]*2+2;
}
// sum[0]=2;
// sum[1]=6;
// rep(i,2,30){
// sum[i]=(num[i+1]-1)*num[i];
// }
scanf("%d",&t);
while(t--){
ll k;
scanf("%lld",&k);
if(k%2==1){
printf("-1\n");
continue;
}
int cnt=0;
k=k-2;
ans[++cnt]=1;
per(i,59,1){
while(k>=num[i]){
k-=num[i];
rep(j,1,i-1){
ans[++cnt]=0;
}
ans[++cnt]=1;
}
}
printf("%d\n",cnt);
rep(i,1,cnt){
printf("%d%c",ans[i]," \n"[i==cnt]);
}
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int cnt(int y, int m, int d) {
if (m < 3) y--, m += 12;
return 365 * y + y / 4 - y / 100 + y / 400 + (153 * m - 457) / 5 + d - 306;
}
int main() {
int a, b, c, t1, t2;
scanf("%d:%d:%d", &a, &b, &c);
t1 = cnt(a, b, c);
scanf("%d:%d:%d", &a, &b, &c);
t2 = cnt(a, b, c);
cout << abs(t1 - t2);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, m, limit;
vector<int> V[N], a[N];
int fa[N], dep[N], vis[N];
bool finished;
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline void ReportCycle(int u) {
printf("PATH\n");
vector<int> as;
as.clear();
while (u != 0) as.emplace_back(u), u = fa[u];
printf("%d\n", (int)as.size());
for (auto x : as) printf("%d ", x);
printf("\n");
finished = true;
return;
}
inline void build(int u) {
vis[u] = true;
if (finished) return;
if (dep[u] >= limit) {
ReportCycle(u);
return;
}
for (int v : a[u]) {
if (!vis[v]) {
fa[v] = u;
dep[v] = dep[u] + 1;
build(v);
}
}
}
int main() {
int T;
read(T);
while (T--) {
read(n), read(m);
finished = false;
limit = (n + 1) / 2;
for (int i = 1; i <= n; ++i) {
a[i].clear();
V[i].clear();
vis[i] = false;
dep[i] = 0;
}
for (int i = 1; i <= m; ++i) {
int u, v;
read(u), read(v);
a[u].emplace_back(v);
a[v].emplace_back(u);
}
dep[1] = 1;
build(1);
if (!finished) {
for (int i = 1; i <= n; ++i) V[dep[i]].emplace_back(i);
int paired = n;
for (int i = 1; i <= n; ++i)
if (V[i].size() & 1) {
V[i].pop_back();
--paired;
}
printf("PAIRING\n");
printf("%d\n", paired / 2);
for (int i = 1; i <= n; ++i) {
for (unsigned j = 0; j < V[i].size(); j += 2)
printf("%d %d\n", V[i][j], V[i][j + 1]);
}
}
}
return 0;
}
| 18
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
//TIAS MONDAL
const ll maxn=1e5+10;
const ll mod=1e9+7;
const ll m2=1e9+7;
const ll INF64 = ll(1e18);
const ll max2=1e3+10;
const ll N = 1000001;
const ll MAXN=2e5+10;
const ll ALPHABET_SIZE = 2;
int main()
{
/*#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
//long long tt = clock();
#endif*/
ios_base::sync_with_stdio(NULL); cin.tie(0); cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int t;
cin>>t;
while(t--)
{
int n,i;
cin>>n;
vector<int> v(n);
for(i=0;i<n;++i)
cin>>v[i];
cout<<3*n<<"\n";
for(i=1;i<=n;i+=2)
{
cout<<1<<" "<<i<<" "<<i+1<<"\n";
cout<<2<<" "<<i<<" "<<i+1<<"\n";
cout<<1<<" "<<i<<" "<<i+1<<"\n";
cout<<1<<" "<<i<<" "<<i+1<<"\n";
cout<<2<<" "<<i<<" "<<i+1<<"\n";
cout<<1<<" "<<i<<" "<<i+1<<"\n";
}
}
return(0);
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long n, tot, ans, now;
long long head[100005], nx[200005], to[200005], w[200005];
long long sum[100005], sz[100005];
struct node {
long long zhi, id, qwq;
};
vector<node> a[100005];
long long read() {
char aa = getchar();
long long pp = 1, kk = 0;
while (aa < '0' || aa > '9') {
if (aa == '-') pp = -1;
aa = getchar();
}
while (aa >= '0' && aa <= '9') {
kk = kk * 10 + aa - '0';
aa = getchar();
}
return kk * pp;
}
void write(long long z) {
if (z < 0) {
putchar('-');
z = -z;
}
if (z >= 10) {
write(z / 10);
}
putchar(z % 10 + '0');
}
void jia(long long aa, long long bb, long long cc) {
tot++;
nx[tot] = head[aa];
to[tot] = bb;
w[tot] = cc;
head[aa] = tot;
return;
}
void dfs(long long rt, long long fa, long long dd) {
sz[rt] = 1;
for (long long i = head[rt]; i; i = nx[i]) {
long long yy = to[i];
if (yy == fa) continue;
dfs(yy, rt, dd + w[i]);
sz[rt] += sz[yy];
sum[rt] += sum[yy] + 2 * w[i];
}
return;
}
bool cmp(node aa, node bb) { return sz[bb.id] * aa.zhi < sz[aa.id] * bb.zhi; }
void getans(long long rt, long long fa) {
for (long long i = head[rt]; i; i = nx[i]) {
long long yy = to[i];
if (yy == fa) continue;
a[rt].push_back((node){(sum[yy] + w[i] * 2), yy, w[i]});
}
sort(a[rt].begin(), a[rt].end(), cmp);
ans += now;
long long len = a[rt].size();
for (long long i = 0; i < len; ++i)
now += a[rt][i].qwq, getans(a[rt][i].id, rt), now += a[rt][i].qwq;
}
int main() {
n = read();
for (long long i = 1; i < n; ++i) {
long long x = read(), y = read(), z = read();
jia(x, y, z);
jia(y, x, z);
}
dfs(1, 1, 0);
getans(1, 1);
printf("%.11lf", (double)ans / (double)(n - 1));
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int val[1001][1001];
int n;
int main() {
int vali = 0, n = 0, q = 0, tmp, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &val[i][j]);
if (i == j) ans = (ans + val[i][j]) % 2;
}
cin >> q;
for (int k = 1; k <= q; k++) {
scanf("%d", &tmp);
if (tmp == 1) {
scanf("%d", &vali);
ans = (ans + 1) % 2;
} else if (tmp == 2) {
scanf("%d", &vali);
ans = (ans + 1) % 2;
} else if (tmp == 3) {
printf("%d", ans);
}
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = (int)1e9 + 7;
const int N = 3e5 + 100;
int n, m, k, p;
int w[N];
long long tot[N];
long long ans[N];
struct Node {
int a, b, id;
} q[N];
bool cmp(Node x1, Node x2) { return x1.b < x2.b; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
scanf("%d", &p);
k = sqrt(n);
int t = 0, a, b;
long long tmp;
for (int i = 1; i <= p; i++) {
scanf("%d%d", &a, &b);
if (b >= k) {
tmp = 0;
for (int i = a; i <= n; i += b) tmp += w[i];
ans[i] = tmp;
} else {
q[t].a = a;
q[t].b = b;
q[t].id = i;
t++;
}
}
sort(q, q + t, cmp);
for (int i = 0; i < t; i++) {
if (i == 0 || q[i].b != q[i - 1].b) {
b = q[i].b;
for (int i = n; i >= 1; i--) {
if (i + b > n)
tot[i] = w[i];
else
tot[i] = tot[i + b] + w[i];
}
}
ans[q[i].id] = tot[q[i].a];
}
for (int i = 1; i <= p; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 1 || n == 2) {
cout << 0 << endl;
} else {
int mxx = -1;
int i = n - 1;
for (i = n - 1; i >= 1; i--) {
if (a[i] > a[i - 1]) {
mxx = i;
break;
}
}
int ans = 0;
if (mxx == -1) {
cout << 0 << endl;
} else {
for (int j = mxx - 1; j >= 1; j--) {
if (a[j] < a[j - 1]) {
ans = j;
break;
}
}
cout << ans << endl;
}
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int arr[11111];
int out[11111];
int temp[11111];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = (1); i < (n); ++i) arr[i] = 1;
arr[n] = 0;
int qtd = 0;
int ct = 5;
while (arr[1] != n - 1) {
memcpy(temp, arr, sizeof arr);
out[qtd++] = n;
int j = n - 1;
int qt = 0;
while (j >= 1 && arr[j] == n - j) {
j--;
qt++;
out[qtd++] = n;
}
int act = qt;
while (j >= 1 && qt) {
arr[j] += temp[j + act];
out[qtd++] = j + act;
j--;
qt--;
}
while (j >= 1) {
arr[j] += temp[j + 1];
out[qtd++] = j + 1;
j--;
}
for (int i = qtd - 1; i >= 0; --i) printf("%d ", out[i]);
printf("\n");
k--;
qtd = 0;
ct--;
}
while (k--) {
for (int i = (0); i < (n); ++i) printf("%d ", n);
printf("\n");
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5;
int n;
int total[NMAX + 5];
int low[NMAX + 5];
char c[5 * NMAX + 5];
int suply[5 * NMAX + 5];
int demand[5 * NMAX + 5];
int main() {
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
fgets(c + 1, 5 * NMAX + 5, stdin);
for (int j = 1; c[j] == '(' || c[j] == ')'; j++) {
total[i] += (c[j] == '(' ? 1 : -1);
low[i] = min(low[i], total[i]);
}
if (total[i] > 0 && low[i] < 0) {
continue;
}
if (total[i] == 0 && low[i] != 0) {
continue;
}
if (total[i] < 0 && low[i] < total[i]) {
continue;
}
if (total[i] >= 0) {
suply[total[i]]++;
}
if (total[i] <= 0) {
demand[-total[i]]++;
}
}
int ans = 0;
for (int i = 1; i <= 5e5 + 2; i++) {
ans += min(suply[i], demand[i]);
}
ans += suply[0] / 2;
printf("%d", ans);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int H = (int)1e9 + 7;
char a[N];
char s[20000];
int n[200], u[200], when[200][200], ans[200];
int h[200][200];
int st[N];
int main() {
srand(time(NULL));
gets(a);
int alen = strlen(a), m;
scanf("%d ", &m);
for (int i = 0; i < ((int)(m)); ++i) {
gets(s);
int w = strlen(s);
for (int j = 0; j < w; j++) {
while (j < w && s[j] != ' ') {
h[i][n[i]] *= H;
h[i][n[i]] += s[j++];
}
n[i]++;
}
}
int e = 0;
for (int i = 0; i < alen; i++) {
int t = 1;
assert(a[i++] == '<');
if (a[i] == '/') {
t = 2;
i++;
}
int nowh = 0;
while (a[i] != '/' && a[i] != '>') {
nowh *= H;
nowh += a[i++];
}
if (a[i] == '/') {
t = 3;
i++;
}
for (int T = 1; T <= 2; T++) {
if (t & T) {
if (T == 1) {
st[e++] = nowh;
for (int j = 0; j < ((int)(m)); ++j) {
if (u[j] == n[j] - 1) {
if (nowh == h[j][u[j]]) ans[j]++;
} else {
if (nowh == h[j][u[j]]) {
u[j]++;
when[j][u[j]] = e - 1;
}
}
}
} else {
assert(st[--e] == nowh);
for (int j = 0; j < ((int)(m)); ++j) {
if (u[j] != 0 && when[j][u[j]] == e) {
u[j]--;
}
}
}
}
}
}
for (int i = 0; i < ((int)(m)); ++i) printf("%d\n", ans[i]);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool getmax(T& a, const T& b) {
return b > a ? (a = b, true) : false;
}
template <typename T>
inline bool getmin(T& a, const T& b) {
return b < a ? (a = b, true) : false;
}
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 15;
const int INF = 0x3f3f3f3f;
struct Segment_Tree {
int n;
int Max[maxm * 4];
int query(int id, int L, int R, int qL, int qR) {
if (qL <= L && R <= qR) return Max[id];
int M = (L + R) >> 1, res = 0;
if (qL <= M) getmax(res, query((id << 1), L, M, qL, qR));
if (qR > M) getmax(res, query(((id << 1) | 1), M + 1, R, qL, qR));
return res;
}
void modify(int id, int L, int R, int mx, int mv) {
if (L == R) {
Max[id] = mv;
return;
}
int M = (L + R) >> 1;
if (mx <= M)
modify((id << 1), L, M, mx, mv);
else
modify(((id << 1) | 1), M + 1, R, mx, mv);
Max[id] = max(Max[(id << 1)], Max[((id << 1) | 1)]);
}
inline void modify(int p, int v) { modify(1, 0, n - 1, p, v); }
inline int updateval(int p) {
int v = query(1, 0, n - 1, p + 1, n - 1);
modify(p, v + 1);
return v + 1;
}
} STx, STy;
set<int> Posx, Posy;
int x[maxn], y[maxm];
inline void plant(int p, int h) {
h += 2e5;
vector<int> tomodify;
for (set<int>::iterator it = Posy.begin(); it != Posy.end() && (*it) < h;
it++)
tomodify.push_back(*it);
((void)(0));
tomodify.push_back(h);
Posx.insert(p);
x[p] = h;
Posy.insert(h);
y[h] = p;
assert((int)tomodify.size() <= 10);
for (const int& i : tomodify) {
((void)(0));
STx.modify(y[i], -INF);
STy.modify(i, -INF);
}
for (int i = (int)tomodify.size() - 1; i >= 0; i--) {
int v = STx.updateval(y[tomodify[i]]);
STy.modify(tomodify[i], v);
((void)(0));
}
}
inline void cut(int leftr) {
vector<int> tomodify;
for (set<int>::iterator it = Posx.begin(); it != Posx.end() && leftr;
leftr--, it++)
tomodify.push_back(*it);
int p = tomodify[(int)tomodify.size() - 1], h = x[p];
((void)(0));
assert((int)tomodify.size() <= 10);
for (const int& i : tomodify) {
((void)(0));
STy.modify(x[i], -INF);
STx.modify(i, -INF);
}
for (int i = (int)tomodify.size() - 2; i >= 0; i--) {
int v = STy.updateval(x[tomodify[i]]);
STx.modify(tomodify[i], v);
((void)(0));
}
Posx.erase(p);
x[p] = -INF;
Posy.erase(h);
y[h] = -INF;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
STx.n = n;
STy.n = maxm;
for (int i = 0, type, a, b; i < m; i++) {
scanf("%d", &type);
if (type == 1) {
scanf("%d%d", &a, &b);
a--;
plant(a, b - i);
} else {
scanf("%d", &a);
cut(a);
}
assert(STx.Max[1] == STy.Max[1]);
printf("%d\n", STx.Max[1] == -INF ? 0 : STx.Max[1]);
}
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str = "6789TJQKA";
char fir[5], sec[5], trump;
scanf("%c %s %s", &trump, fir, sec);
if (fir[1] == trump && fir[1] != sec[1])
printf("YES\n");
else if (fir[1] != sec[1])
printf("NO\n");
else {
int one = 0, two = 0;
while (1) {
if (str[one] == fir[0]) break;
one++;
}
while (1) {
if (str[two] == sec[0]) break;
two++;
}
one > two ? printf("YES\n") : printf("NO\n");
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int dp[100005][2][2];
int solve(int idx, int prf, int sf) {
if (idx == n) return 0;
int &ret = dp[idx][prf][sf];
if (ret != -1) return ret;
ret = 0;
if (prf && !sf) {
ret = max(solve(idx + 1, 1, 0) + (a[idx]) * (-1),
max(solve(idx + 1, 0, 1) + (a[idx]) * (-1),
solve(idx + 1, 1, 1) + a[idx]));
} else if (!prf && sf) {
ret = solve(idx + 1, 0, 1) + (a[idx]) * (-1);
} else {
ret = max(solve(idx + 1, 0, 1) + (a[idx]) * (-1),
solve(idx + 1, 1, 1) + a[idx]);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
memset(dp, -1, sizeof dp);
cout << solve(0, 1, 0) << endl;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -f;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int maxn = 1e2 + 5;
int vis[maxn], NOW, num[maxn];
int dp[maxn], f[maxn][maxn];
int n, m, K, DP[maxn], s[maxn], t[maxn];
bool b[maxn][maxn];
int dfs(int x, int path) {
if (vis[x] == NOW) return DP[x];
vis[x] = NOW;
int tmp = -1;
for (int y = 1; y <= n; y++)
if (f[x][y] == 1 && f[x][t[path]] == f[y][t[path]] + 1)
tmp = max(tmp, dfs(y, path));
if (tmp == -1) tmp = 1e9;
if (tmp > dp[x]) tmp = dp[x];
return DP[x] = tmp;
}
int main() {
n = read(), m = read(), s[0] = read(), t[0] = read();
for (int i = 1; i < n; i++)
for (int j = i + 1; j <= n; j++) f[i][j] = f[j][i] = 1e9;
for (int i = 1, x, y; i <= m; i++) f[x = read()][y = read()] = 1;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
K = read();
for (int i = 1; i <= K; i++) {
s[i] = read(), t[i] = read();
if (f[s[i]][t[i]] == 1e9) continue;
for (int j = 1; j <= n; j++) {
if (f[s[i]][j] + f[j][t[i]] == f[s[i]][t[i]]) num[f[s[i]][j]]++;
}
for (int j = 1; j <= n; j++)
if (f[s[i]][j] + f[j][t[i]] == f[s[i]][t[i]]) {
if (num[f[s[i]][j]] == 1) b[i][j] = 1;
num[f[s[i]][j]] = 0;
}
}
for (int i = 1; i <= n; i++) dp[i] = DP[i] = 1e9;
dp[t[0]] = 0;
bool flag = 1;
while (flag) {
flag = 0;
for (int i = 1; i <= K; i++)
for (int j = 1; j <= n; j++) {
if (b[i][j]) {
NOW++;
int tmp = dfs(j, i) + 1;
if (tmp < dp[j]) {
flag = 1;
dp[j] = tmp;
}
}
}
}
if (dp[s[0]] == 1e9) dp[s[0]] = -1;
cout << dp[s[0]];
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
long long int insig;
void Out(vector<long long int> x) {
for (long long int i = 0; i < x.size(); i++) {
cout << x[i] << " ";
}
cout << endl;
}
int main() {
long long int T;
cin >> T;
long long int N, M;
long long int ans;
for (long long int i = 0; i < T; i++) {
cin >> N >> M;
long long int a[N][M];
vector<pair<long long int, pair<long long int, long long int> > > el;
for (long long int j = 0; j < N; j++) {
for (long long int z = 0; z < M; z++) {
cin >> a[j][z];
el.push_back(make_pair(a[j][z], make_pair(j, z)));
}
}
sort(el.begin(), el.end());
reverse(el.begin(), el.end());
if (N <= 3) {
ans = 0;
for (long long int j = 0; j < N; j++) {
ans += el[j].first;
}
cout << ans << endl;
} else {
vector<pair<pair<long long int, long long int>, long long int> > cc;
cc.push_back(make_pair(make_pair(el[0].second.second, el[0].second.first),
el[0].first));
cc.push_back(make_pair(make_pair(el[1].second.second, el[1].second.first),
el[1].first));
cc.push_back(make_pair(make_pair(el[2].second.second, el[2].second.first),
el[2].first));
cc.push_back(make_pair(make_pair(el[3].second.second, el[3].second.first),
el[3].first));
sort(cc.begin(), cc.end());
if (cc[0].first.first == cc[1].first.first &&
cc[2].first.first == cc[3].first.first &&
cc[2].first.first != cc[1].first.first) {
bool cnt1 = false;
bool cnt2 = false;
if (abs(cc[1].first.second - cc[0].first.second) != 2) {
cnt1 = true;
}
if (abs(cc[3].first.second - cc[2].first.second) != 2) {
cnt2 = true;
}
if (cnt1 ^ cnt2) {
cc.clear();
cc.push_back(make_pair(
make_pair(el[0].second.second, el[0].second.first), el[0].first));
cc.push_back(make_pair(
make_pair(el[1].second.second, el[1].second.first), el[1].first));
cc.push_back(make_pair(
make_pair(el[2].second.second, el[2].second.first), el[2].first));
cc.push_back(make_pair(
make_pair(el[4].second.second, el[4].second.first), el[4].first));
sort(cc.begin(), cc.end());
if (cc[0].first.first == cc[1].first.first &&
cc[2].first.first == cc[3].first.first &&
cc[2].first.first != cc[1].first.first) {
bool cnt3 = false;
bool cnt4 = false;
if (abs(cc[1].first.second - cc[0].first.second) != 2) {
cnt3 = true;
}
if (abs(cc[3].first.second - cc[2].first.second) != 2) {
cnt4 = true;
}
if (cnt3 ^ cnt4) {
cout << el[0].first + el[1].first + el[3].first + el[4].first
<< endl;
} else {
cout << el[0].first + el[1].first + el[2].first + el[4].first
<< endl;
}
} else {
cout << el[0].first + el[1].first + el[2].first + el[4].first
<< endl;
}
} else {
ans = 0;
for (long long int j = 0; j < N; j++) {
ans += el[j].first;
}
cout << ans << endl;
}
} else {
ans = 0;
for (long long int j = 0; j < N; j++) {
ans += el[j].first;
}
cout << ans << endl;
}
}
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void dout() { cerr << endl; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << H << ' ';
dout(T...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<int> k(n);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> k[i];
sum += k[i];
}
vector<pair<int, int>> a;
for (int i = 0; i < m; i++) {
int d, t;
cin >> d >> t;
a.emplace_back(d, t - 1);
}
sort(a.begin(), a.end());
int left = sum - 1, right = 2 * sum + 1;
while (left + 1 < right) {
int mid = (left + right) / 2;
vector<int> last(n, -1);
for (auto [d, t] : a) {
if (d > mid) break;
last[t] = d;
}
vector<pair<int, int>> aa;
for (int t = 0; t < n; t++) {
if (last[t] != -1) aa.emplace_back(last[t], t);
}
sort(aa.begin(), aa.end());
int used = 0;
auto kk = k;
for (auto [d, t] : aa) {
int can = d - used;
can = min(can, kk[t]);
kk[t] -= can;
used += can;
}
for (auto x : kk) {
used += x * 2;
}
if (used <= mid)
right = mid;
else
left = mid;
}
cout << right;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long long days[] = {0, 1, 2, 3, 1, 3, 2, 1};
long long a, b, c;
bool judge(long long k, long long st) {
long long ta = 0, tb = 0, tc = 0;
if (st + k - 1 < 7) {
for (long long i = 0; i < k; i++) {
long long typ = days[(st + i - 1) % 7 + 1];
if (typ == 1)
ta++;
else if (typ == 2)
tb++;
else
tc++;
}
if (ta > a || tb > b || tc > c) return false;
} else {
for (long long i = 0; st + i - 1 < 7; i++) {
long long typ = days[(st + i - 1) % 7 + 1];
if (typ == 1)
ta++;
else if (typ == 2)
tb++;
else
tc++;
}
k -= (7 - st + 1);
ta += (k / 7) * 3;
tb += (k / 7) * 2;
tc += (k / 7) * 2;
k %= 7;
for (long long i = 1; i <= k; i++) {
long long typ = days[i];
if (typ == 1)
ta++;
else if (typ == 2)
tb++;
else
tc++;
}
if (ta > a || tb > b || tc > c) return false;
}
return true;
}
signed main() {
long long ans = 0;
scanf("%lld%lld%lld", &a, &b, &c);
long long m = max(a / 3, max(b / 2, c / 2)) + 2;
m *= 7;
for (long long i = 1; i <= 7; i++) {
long long l = 0, r = 1e18;
while (l < r) {
long long mid = (l + r + 1) / 2;
if (judge(mid, i))
l = mid;
else
r = mid - 1;
}
ans = max(ans, l);
}
printf("%lld\n", ans);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
char mx[] = {'R', 'O', 'Y', 'G', 'B', 'V'};
int cl[] = {0, 1, 2, 3, 4, 5};
int p[3][6] = {1, 2, 4, 5, 6, 3, 5, 3, 1, 4, 2, 6, 4, 6, 3, 2, 5, 1};
int pos[6];
int q = 0;
int rr[6];
int used[6];
bool was[6][6][6][6][6][6];
void pr(int id) {
int res[6];
for (int i = 0; i < 6; i++) res[i] = rr[p[id][i] - 1];
for (int i = 0; i < 6; i++) rr[i] = res[i];
}
void rec(int num) {
if (num == 6) {
if (was[rr[0]][rr[1]][rr[2]][rr[3]][rr[4]][rr[5]]) return;
for (int j = 0; j < 4; j++) {
pr(0);
for (int k = 0; k < 4; k++) {
pr(1);
for (int t = 0; t < 4; t++) {
pr(2);
was[rr[0]][rr[1]][rr[2]][rr[3]][rr[4]][rr[5]] = true;
}
}
}
q++;
return;
}
for (int i = 0; i < 6; i++) {
if (used[i]) {
used[i]--;
rr[num] = i;
rec(num + 1);
used[i]++;
}
}
}
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < 6; j++)
if (s[i] == mx[j]) {
pos[i] = cl[j];
used[pos[i]]++;
}
}
rec(0);
cout << q;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int start = 48;
const int maxn = 1e5 + 5;
int n;
int a[maxn];
int s1[maxn], s2[maxn], ss1, ss2;
int d[maxn], dn;
struct NODE {
int s, t;
} ans[maxn];
int ansn;
bool cmp(NODE a, NODE b) {
if (a.s == b.s) return a.t < b.t;
return a.s < b.s;
}
void addans(int s, int t) {
if (ansn > 1) {
if (s == ans[ansn].s && t == ans[ansn].t) ansn--;
}
ansn++;
ans[ansn].s = s;
ans[ansn].t = t;
}
int gett(int x) {
int v1 = s1[x];
int v2 = s2[x];
if (a[x] == 1) {
if (v1 > v2)
return v1;
else
return -1;
} else if (v2 > v1)
return v2;
else
return -1;
}
int getnxt(int t, int former, int s[]) {
int l = 1, r = n, mid;
if (s[r] - s[former] < t) return n + 1;
while (l < r - 1) {
int mid = (l + r) >> 1;
if (s[mid] - s[former] >= t)
r = mid;
else
l = mid;
}
if (s[l] - s[former] == t)
return l;
else
return r;
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
s1[0] = s2[0] = 0;
for (int i = 1; i <= n; i++) {
s1[i] = s1[i - 1];
s2[i] = s2[i - 1];
if (a[i] == 1)
s1[i]++;
else
s2[i]++;
}
ansn = 0;
for (int i = 1; i <= n; i++) {
int t, former = i;
t = gett(i);
if (t == -1) continue;
int cnt1 = 0, cnt2 = 0;
if (s1[i] > s2[i])
cnt1++;
else
cnt2++;
int nxt1, nxt2, nxt;
while (1) {
nxt1 = getnxt(t, former, s1);
nxt2 = getnxt(t, former, s2);
nxt = min(nxt1, nxt2);
if (nxt == n + 1) break;
former = nxt;
if (nxt == nxt1)
cnt1++;
else
cnt2++;
if (nxt == n) {
if (nxt == nxt1) {
if (cnt1 > cnt2) addans(cnt1, t);
} else if (cnt1 < cnt2)
addans(cnt2, t);
break;
}
}
if (i == n) {
if (a[i] == 1) {
if (cnt1 > cnt2) addans(cnt1, t);
} else if (cnt1 < cnt2)
addans(cnt2, t);
}
}
printf("%d\n", ansn);
sort(ans + 1, ans + ansn + 1, cmp);
for (int i = 1; i <= ansn; i++) {
printf("%d %d\n", ans[i].s, ans[i].t);
}
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long T = 0, n = 0, m = 0, a, b, c;
pair<pair<long long, long long>, long long> d[1000001];
pair<long long, long long> tree[7000001];
long long mark[7000001];
void push_down(long long p) {
if (!mark[p]) return;
tree[p + p].first += mark[p];
tree[p + p + 1].first += mark[p];
mark[p + p] += mark[p];
mark[p + p + 1] += mark[p];
mark[p] = 0;
}
long long dc[1000001];
void modify(long long L, long long R, long long l, long long r, long long p,
long long x) {
if (L == l && R == r) {
if (L == R) tree[p].second = dc[L];
tree[p].first += x;
mark[p] += x;
push_down(p);
return;
}
push_down(p);
long long mid = (L + R) >> 1;
if (r <= mid)
modify(L, mid, l, r, p + p, x);
else if (l >= mid + 1)
modify(mid + 1, R, l, r, p + p + 1, x);
else
modify(L, mid, l, mid, p + p, x),
modify(mid + 1, R, mid + 1, r, p + p + 1, x);
tree[p] = max(tree[p + p], tree[p + p + 1]);
}
pair<long long, long long> query(long long L, long long R, long long l,
long long r, long long p) {
if (l == L && r == R) {
return tree[p];
}
push_down(p);
long long mid = (L + R) >> 1;
if (r <= mid)
return query(L, mid, l, r, p + p);
else if (l >= mid + 1)
return query(mid + 1, R, l, r, p + p + 1);
else
return max(query(L, mid, l, mid, p + p),
query(mid + 1, R, mid + 1, r, p + p + 1));
}
long long ans = 0;
pair<long long, long long> ansp =
pair<long long, long long>(13011111, 130111111);
long long fuck = 0;
int main() {
d[0] = pair<pair<long long, long long>, long long>(
pair<long long, long long>(-1, -1), 0);
cin >> m;
for (long long i = 1; i <= m; i++) {
cin >> a >> b >> c;
if (a < 0 || b < 0) continue;
if (b > a) swap(a, b);
d[++n] = pair<pair<long long, long long>, long long>(
pair<long long, long long>(b, a), c);
dc[n] = a;
fuck = max(fuck, a);
fuck = max(fuck, b);
}
sort(d + 1, d + n + 1);
sort(dc + 1, dc + n + 1);
m = unique(dc + 1, dc + n + 1) - dc - 1;
for (long long i = 1; i <= m; i++) modify(1, m, i, i, 1, -dc[i]);
ansp = pair<long long, long long>(fuck + 1, fuck + 1);
for (long long i = n; i >= 1; i--) {
modify(1, m, lower_bound(dc + 1, dc + m + 1, (d[i].first.second)) - dc, m,
1, d[i].second);
if (d[i].first.first != d[i - 1].first.first) {
pair<long long, long long> tans = query(
1, m, lower_bound(dc + 1, dc + m + 1, (d[i].first.first)) - dc, m, 1);
tans.first += d[i].first.first;
if (tans.first > ans) {
ans = tans.first;
ansp.first = d[i].first.first;
ansp.second = tans.second;
}
}
}
cout << ans << endl;
cout << ansp.first << " " << ansp.first << " " << ansp.second << " "
<< ansp.second << endl;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
void read_file() {}
int main() {
read_file();
int n;
int p[100000 + 9];
while (cin >> n) {
for (int k = 0; k < n; k++) cin >> p[k];
int i = 0;
while (i + 1 < n && p[i] < p[i + 1]) i++;
if (i + 1 == n) {
printf("yes\n%d %d\n", 1, 1);
continue;
}
int j = i;
while (j + 1 < n && p[j] > p[j + 1]) j++;
if ((i - 1 < 0 || p[i - 1] < p[j]) && (j + 1 >= n || p[i] < p[j + 1])) {
bool canWe = 1;
for (int k = j + 1; k < n - 1 && canWe; k++)
if (p[k] >= p[k + 1]) canWe = 0;
if (canWe == 1) {
printf("yes\n%d %d\n", i + 1, j + 1);
continue;
}
}
printf("no\n");
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct E {
int v, w, ne;
} edge[maxn << 1];
int n, head[maxn], tot = 1;
bool vis[maxn];
vector<int> ans;
void dfs(int x) {
vis[x] = true;
if (vis[(x * 2) % n] == false) dfs((x * 2) % n);
if (vis[(x * 2 + 1) % n] == false) dfs((x * 2 + 1) % n);
ans.push_back(x);
}
int main() {
scanf("%d", &n);
if (n % 2 == 1) {
printf("-1");
return 0;
}
dfs(0);
for (int i = ans.size() - 1; i >= 0; i--) printf("%d ", ans[i]);
printf("0");
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int UNKNOWN = -1;
int DP_WHITE[51][51][51][51];
int DP_COST[51][51][51][51];
string grid[51];
bool white(int x1, int x2, int y1, int y2) {
if (DP_WHITE[x1][x2][y1][y2] != UNKNOWN) return DP_WHITE[x1][x2][y1][y2];
if (x1 < x2 - 1) {
DP_WHITE[x1][x2][y1][y2] =
white(x1, x2 - 1, y1, y2) && white(x2 - 1, x2, y1, y2);
} else if (y1 < y2 - 1) {
DP_WHITE[x1][x2][y1][y2] =
white(x1, x2, y1, y2 - 1) && white(x1, x2, y2 - 1, y2);
} else {
DP_WHITE[x1][x2][y1][y2] = grid[x1][y1] == '.';
}
return DP_WHITE[x1][x2][y1][y2];
}
int cost(int x1, int x2, int y1, int y2) {
if (DP_COST[x1][x2][y1][y2] != UNKNOWN) return DP_COST[x1][x2][y1][y2];
if (x1 == x2 || y1 == y2) return 0;
int cur_min = (x2 - x1 > y2 - y1) ? x2 - x1 : y2 - y1;
for (int c = x1; c < x2; c++)
if (white(c, c + 1, y1, y2))
cur_min = (cur_min < cost(x1, c, y1, y2) + cost(c + 1, x2, y1, y2))
? cur_min
: cost(x1, c, y1, y2) + cost(c + 1, x2, y1, y2);
for (int r = y1; r < y2; r++)
if (white(x1, x2, r, r + 1))
cur_min = (cur_min < cost(x1, x2, y1, r) + cost(x1, x2, r + 1, y2))
? cur_min
: cost(x1, x2, y1, r) + cost(x1, x2, r + 1, y2);
DP_COST[x1][x2][y1][y2] = cur_min;
return DP_COST[x1][x2][y1][y2];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> grid[i];
}
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < n + 1; j++)
for (int k = 0; k < n + 1; k++)
for (int l = 0; l < n + 1; l++) {
DP_WHITE[i][j][k][l] = UNKNOWN;
DP_COST[i][j][k][l] = UNKNOWN;
}
cout << cost(0, n, 0, n) << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long MOD = 257;
const int maxn = 200;
const int max_len = 200;
struct widget;
struct Box {
string name;
long long x, y;
vector<Box *> box_inside;
vector<widget *> widget_inside;
long long border, space;
bool type;
vector<Box *> parent;
void init(const string s, const bool t) {
name = s;
x = y = 0;
border = space = 0;
type = t;
}
void update();
void pack(Box *new_parent) {
parent.push_back(new_parent);
new_parent->box_inside.push_back(this);
(*new_parent).update();
}
void set_space(const int new_space) {
space = new_space;
update();
}
void set_border(const int new_border) {
border = new_border;
update();
}
};
struct widget {
string name;
long long x, y;
void pack(Box *new_parent) {
new_parent->widget_inside.push_back(this);
(*new_parent).update();
}
void init(const string s, const int x1, const int y1) {
name = s;
x = x1;
y = y1;
}
};
void Box::update() {
if (type) {
x = 0;
y = 0;
for (size_t i = 0; i < box_inside.size(); ++i) {
x += box_inside[i]->x;
y = max(y, box_inside[i]->y);
}
for (size_t i = 0; i < widget_inside.size(); ++i) {
x += widget_inside[i]->x;
y = max(y, widget_inside[i]->y);
}
if (widget_inside.size() + box_inside.size() != 0) {
x += 2 * border + (box_inside.size() + widget_inside.size() - 1) * space;
y += 2 * border;
}
} else {
x = 0;
y = 0;
for (size_t i = 0; i < box_inside.size(); ++i) {
y += box_inside[i]->y;
x = max(x, box_inside[i]->x);
}
for (size_t i = 0; i < widget_inside.size(); ++i) {
y += widget_inside[i]->y;
x = max(x, widget_inside[i]->x);
}
if (widget_inside.size() + box_inside.size() != 0) {
y += 2 * border + (box_inside.size() + widget_inside.size() - 1) * space;
x += 2 * border;
}
}
for (size_t i = 0; i < parent.size(); ++i) (*parent[i]).update();
}
struct res {
string name;
long long x, y;
};
bool comp(const res a, const res b) {
if (a.name < b.name)
return 1;
else
return 0;
}
Box ar_of_box[maxn];
widget ar_of_widget[maxn];
int n, last_b, last_w;
char buf[max_len];
string s;
res res_ar[maxn];
int main() {
last_b = last_w = 0;
scanf("%d\n", &n);
for (int i = 0; i < n; ++i) {
cin.getline(buf, 200);
s = buf;
if (s.substr(0, 4) == "VBox")
ar_of_box[last_b++].init(s.substr(5, s.size() - 5), false);
if (s.substr(0, 4) == "HBox")
ar_of_box[last_b++].init(s.substr(5, s.size() - 5), true);
if (s.substr(0, 6) == "Widget") {
int x, y;
x = y = 0;
s.erase(0, 7);
string name = "";
int k = 0;
while (s[k] != '(') {
name += s[k];
++k;
}
++k;
while (s[k] >= '0' && s[k] <= '9') {
x = x * 10 + s[k] - '0';
++k;
}
++k;
while (s[k] >= '0' && s[k] <= '9') {
y = y * 10 + s[k] - '0';
++k;
}
ar_of_widget[last_w++].init(name, x, y);
}
if (s.find(".pack") != s.npos) {
string name1, name2;
name1 = name2 = "";
int k = 0;
while (s[k] != '.') {
name1 += s[k];
++k;
}
while (s[k] != '(') ++k;
++k;
while (s[k] != ')') {
name2 += s[k];
++k;
}
Box *parent = NULL;
for (int j = 0; j < last_b; ++j)
if (name1 == ar_of_box[j].name) parent = &ar_of_box[j];
for (int j = 0; j < last_b; ++j)
if (name2 == ar_of_box[j].name) ar_of_box[j].pack(parent);
for (int j = 0; j < last_w; ++j)
if (name2 == ar_of_widget[j].name) ar_of_widget[j].pack(parent);
}
if (s.find(".set_border") != s.npos) {
string name = "";
int k = 0;
int border = 0;
while (s[k] != '.') {
name += s[k];
++k;
}
while (s[k] != '(') ++k;
++k;
while (s[k] >= '0' && s[k] <= '9') {
border = border * 10 + s[k] - '0';
++k;
}
for (int j = 0; j < last_b; ++j)
if (name == ar_of_box[j].name) ar_of_box[j].set_border(border);
}
if (s.find(".set_spacing") != s.npos) {
string name = "";
int k = 0;
int space = 0;
while (s[k] != '.') {
name += s[k];
++k;
}
while (s[k] != '(') ++k;
++k;
while (s[k] >= '0' && s[k] <= '9') {
space = space * 10 + s[k] - '0';
++k;
}
for (int j = 0; j < last_b; ++j)
if (name == ar_of_box[j].name) ar_of_box[j].set_space(space);
}
}
for (int i = 0; i < last_b; ++i) {
res_ar[i].name = ar_of_box[i].name;
res_ar[i].x = ar_of_box[i].x;
res_ar[i].y = ar_of_box[i].y;
}
for (int i = 0; i < last_w; ++i) {
res_ar[i + last_b].name = ar_of_widget[i].name;
res_ar[i + last_b].x = ar_of_widget[i].x;
res_ar[i + last_b].y = ar_of_widget[i].y;
}
sort(&res_ar[0], &res_ar[last_b + last_w], comp);
for (int i = 0; i < last_b + last_w; ++i)
printf("%s %I64d %I64d\n", res_ar[i].name.c_str(), res_ar[i].x,
res_ar[i].y);
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int a[101][2501];
const int delta = 1000000007;
int main() {
string s = "abcdefghijklmnopqrstuvwxyz";
for (int i = 1; i <= 101; i++) {
for (int j = 0; j <= 2500; j++) {
if (j / i >= 26) {
a[i][j] = 0;
} else if (i == 1)
a[i][j] = 1;
else {
for (int k = 0; k <= min(25, j); k++) {
a[i - 1][j] = (a[i - 1][j] + a[i - 2][j - k]) % delta;
}
}
}
}
int t, s1 = 0, n = 0;
string s2;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> s2;
s1 = 0;
n = 0;
for (char a : s2) {
s1 += s.find(a);
n++;
}
cout << a[n][s1] - 1 << endl;
}
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int flag[1010][1010];
int m;
int n;
int main() {
int len = 60;
scanf("%d", &m);
int n = 1;
int idx = 3;
while (m) {
if (m & 1) {
flag[n][idx] = flag[idx][n] = 1;
idx++;
for (int i = 1; i < len - 1; i++) {
flag[idx - 1][idx] = flag[idx][idx - 1] = 1;
idx++;
}
flag[idx - 1][2] = flag[2][idx - 1] = 1;
}
m >>= 1;
len -= 2;
if (m) {
flag[n][idx] = flag[idx][n] = 1;
idx++;
flag[n][idx] = flag[idx][n] = 1;
idx++;
flag[idx - 2][idx] = flag[idx][idx - 2] = 1;
flag[idx - 1][idx] = flag[idx][idx - 1] = 1;
n = idx;
idx++;
}
}
printf("%d\n", idx - 1);
for (int i = 1; i <= idx - 1; i++) {
for (int j = 1; j <= idx - 1; j++) {
if (i == j)
printf("N");
else if (flag[i][j])
printf("Y");
else
printf("N");
}
puts("");
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, num, ans = 1;
vector<int> v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num;
v.push_back(num);
}
sort(v.begin(), v.end());
int prev = v[0];
for (int i = 1; i < n; i++) {
if (v[i] == prev) ans++;
prev = v[i];
}
cout << ans << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, c5;
scanf("%d%d%d%d%d", &c1, &c2, &c3, &c4, &c5);
int s{c1 + c2 + c3 + c4 + c5};
if (s % 5 || s == 0)
puts("-1");
else
printf("%d\n", s / 5);
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void run_case() {
int n;
cin >> n;
vector<string> v(2);
for (int i = 0; i < 2; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
if (v[0][i] == '1' && v[1][i] == '1') {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
int tc = 1;
cin >> tc;
while (tc--) {
run_case();
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long x, a = 0LL;
int main() {
scanf("%lld", &x);
;
for (long long int i = (long long int)2; i <= x; i++) {
if (i & 1)
a = a * 3 - 3;
else
a = a * 3 + 3;
a = a % 1000000007;
}
printf("%lld\n", a);
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int pos = 0;
int l, r;
for (int i = 0; i < t.size() and pos < s.size(); i++) {
if (t[i] == s[pos]) {
pos++;
l = i;
}
}
if (pos != s.size()) {
cout << "0\n";
return 0;
}
pos = s.size() - 1;
for (int i = t.size() - 1; i >= 0 and pos >= 0; i--) {
if (t[i] == s[pos]) {
pos--;
r = i;
}
}
if (pos != -1 or l >= r) {
cout << "0\n";
return 0;
}
cout << r - l << '\n';
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 207;
int N;
char s[maxn];
int f[37];
bool book[37];
int main() {
scanf("%d", &N);
scanf("%s", s + 1);
int ans = 0, re = 0;
int t;
for (int i = 1; i <= N; i++) {
if (s[i] <= 'Z')
memset(f, 0, sizeof(f)), memset(book, 0, sizeof(book)), re = 0;
else {
t = s[i] - 'a';
if (book[t]) continue;
book[t] = true;
for (int k = 0; k < 26; k++) {
if (!book[k]) continue;
re++;
ans = max(ans, re);
break;
}
}
}
printf("%d\n", ans);
return 0;
}
| 2
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.