solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
int a[5], g[9] = {0, 1, -1, 2, -2, 3, -3, 4, -4};
for (int i = 0; i < 5; i++) scanf("%d", a + i);
int k;
scanf("%d", &k);
string s;
map<string, int> mp;
map<int, string> rmp;
mp.insert(make_pair("S", 0));
mp.insert(make_pair("M", 1));
mp.insert(make_pair("L", 2));
mp.insert(make_pair("XL", 3));
mp.insert(make_pair("XXL", 4));
rmp.insert(make_pair(0, "S"));
rmp.insert(make_pair(1, "M"));
rmp.insert(make_pair(2, "L"));
rmp.insert(make_pair(3, "XL"));
rmp.insert(make_pair(4, "XXL"));
for (int i = 0; i < k; i++) {
cin >> s;
n = mp[s];
for (int j = 0; j < 9; j++) {
m = g[j] + n;
if (rmp.find(m) != rmp.end() && a[m] > 0) {
a[m]--;
cout << rmp[m] << endl;
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
map<int, int> mpp;
map<int, int>::iterator it;
set<string> s;
set<pair<int, int> >::iterator iter;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
bool isprime(long long p) {
if (p < 2) return false;
if (p == 2) return true;
if (p % 2 == 0) return false;
double limit = sqrt(p);
for (long long i = 3; i <= limit; i += 2) {
if ((p % i) == 0) return false;
}
return true;
}
int n, m;
vector<vector<long long> > d(31, vector<long long>(5));
void calc(int x = 0, int y = 0, int mask = 0, int next_mask = 0) {
if (x == n) return;
if (y >= m)
d[x + 1][next_mask] += d[x][mask];
else {
int my_mask = 1 << y;
if (mask & my_mask)
calc(x, y + 1, mask, next_mask);
else {
calc(x, y + 1, mask, next_mask | my_mask);
if (y + 1 < m && !(mask & my_mask) && !(mask & (my_mask << 1)))
calc(x, y + 2, mask, next_mask);
}
}
}
long long fac(long long n) {
long long an = 1;
while (n > 1) {
an *= n;
n--;
}
return an;
}
long long a[100];
int main() {
ios::sync_with_stdio(false);
long long n, mn = 100500, mx = 0, mni, mxi;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] > mx) {
mx = a[i];
mxi = i;
}
if (a[i] < mn) {
mn = a[i];
mni = i;
}
}
if (mni > mxi) swap(mni, mxi);
long long an = max(mxi, n - mni - 1);
if (abs(mni - mxi) > an) an = abs(mni - mxi);
cout << an;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 300 + 5;
const int INF = (1 << 29);
vector<vector<int> > tmp, res[10], g, mat;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
g.resize(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i].push_back(INF);
for (int i = 0; i < m; i++) {
int u, v, c1, c2;
cin >> u >> v >> c1 >> c2;
u--;
v--;
g[u][v] = -c1;
g[v][u] = -c2;
}
res[0] = g;
for (int l = 1; l < 10; l++) {
res[l] = res[l - 1];
for (int x = 0; x < n; x++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
res[l][i][j] = min(res[l][i][j], res[l - 1][i][x] + res[l - 1][x][j]);
}
mat = g;
int ans = 1;
for (int l = 9; l >= 0; l--) {
tmp = mat;
for (int x = 0; x < n; x++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
tmp[i][j] = min(tmp[i][j], mat[i][x] + res[l][x][j]);
bool flag = false;
for (int i = 0; i < n; i++)
if (tmp[i][i] < 0) {
flag = true;
break;
}
if (!flag) {
ans += (1 << l);
mat = tmp;
}
}
if (ans == (1 << 10))
cout << 0 << endl;
else
cout << ans + 1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, -1, 0, 1};
const int drr[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dcc[8] = {0, -1, -1, -1, 0, 1, 1, 1};
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int i = 0; i < ((int)((t).size())); i++) s << t[i] << " ";
return s;
}
class UnionFind {
private:
vector<int> rank, p;
public:
UnionFind(int n) {
for (int i = 0; i < n; i++) p.push_back(i);
rank.assign(n, 0);
}
int findSet(int s) { return (p[s] == s) ? s : (p[s] = findSet(p[s])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (isSameSet(i, j)) return;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y])
p[y] = x;
else {
p[x] = y;
if (rank[x] == rank[y]) rank[y]++;
}
}
};
bool fcomp(double A, double B) {
double EPSILON = numeric_limits<double>::epsilon();
double diff = A - B;
return fabs(diff) < EPSILON;
}
double x_y(int x1, int y1, int x2, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
int(n);
scanf("%d", &(n));
vector<pair<int, int> > dt(n), ans;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i] >> dt[i].first;
dt[i].second = i;
}
sort((dt).begin(), (dt).end());
int ys = 1;
if (dt[0].first != 0) ys = 0;
ans.push_back({1e6, 0});
for (int i = 1; i < n; i++) {
sort((ans).begin(), (ans).end());
reverse((ans).begin(), (ans).end());
if (dt[i].first > i) {
ys = 0;
break;
}
int nw = ans[0].first + 1;
if (dt[i].first) {
nw = ans[dt[i].first - 1].first - 1;
}
ans.push_back({nw, i});
sort((ans).begin(), (ans).end());
for (int j = 0; j < ans.size() - 1; j++) {
if (ans[j].first == ans[j + 1].first) {
for (int k = j + 1; k < ans.size(); k++) {
ans[k].first++;
}
break;
}
}
}
if (!ys) {
printf("-1\n");
return 0;
}
int res[n];
for (int i = 0; i < ans.size(); i++) {
res[ans[i].second] = ans[i].first;
}
for (int i = 0; i < n; i++) {
cout << s[dt[i].second] << " " << res[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int dp[N][N][130];
vector<pair<int, int> > G[N];
int n, m;
bool DP(int x, int y, int k) {
if (dp[x][y][k] != -1) return dp[x][y][k];
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i].first, cost = G[x][i].second;
if (cost >= k && DP(y, v, cost) == 0) return dp[x][y][k] = 1;
}
return dp[x][y][k] = 0;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
char c;
cin >> u >> v >> c;
G[u].push_back(pair<int, int>(v, c));
}
memset(dp, -1, sizeof dp);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
DP(i, j, 0);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%c", dp[i][j][0] ? 'A' : 'B');
puts("");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int z = 0, o = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 1)
o++;
else
z++;
}
if (z != 0 && o != 0) return 1;
int crr[n];
for (int i = 0; i < n; i++) crr[i] = arr[i];
sort(crr, crr + n);
for (int i = 0; i < n; i++) {
if (arr[i] != crr[i]) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
bool flag = solve();
if (flag)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 2 |
#include <bits/stdc++.h>
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
const long long MOD = 1000000007LL;
const long long MAX = 500000LL;
using namespace std;
int main() {
long long N;
cin >> N;
if (N % 2 == 0) {
cout << "NO" << endl;
return 0;
}
vector<long long> res(2 * N);
for (long long i = 0; i < N; i++) {
if (i % 2 == 0) {
res[i] = 1 + i;
} else {
res[i] = 2 * N - i + 1;
}
}
for (long long i = N; i < 2 * N; i++) {
if (res[i - N] % 2 == 0) {
res[i] = res[i - N] - 1;
} else {
res[i] = res[i - N] + 1;
}
}
cout << "YES" << endl;
for (long long i = 0; i < 2 * N; i++) {
cout << res[i];
if (i == 2 * N - 1) {
cout << endl;
} else {
cout << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e4;
const long long INF = 1e18 + 10;
const long long MOD = 1e9 + 7;
const long double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int d, n, m;
cin >> d >> n >> m;
vector<pair<int, int> > v(m + 1, {0, 0});
for (int i = (1), ThxMK = (m + 1); i < ThxMK; ++i)
cin >> v[i].first >> v[i].second;
sort(begin(v), end(v));
stack<pair<int, int> > second;
second.push({d, 0});
vector<int> who(m + 1);
for (int i = m; i; i--) {
while (second.top().second >= v[i].second) second.pop();
who[i] = second.top().first;
second.push(v[i]);
}
v.push_back({d, 0});
int act = n;
long long res = 0;
for (int i = (1), ThxMK = (int(v.size())); i < ThxMK; ++i) {
act -= v[i].first - v[i - 1].first;
if (act < 0) {
cout << -1 << '\n';
return 0;
}
if (who[i] - v[i].first <= act) continue;
res += 1LL * min(n - act, who[i] - v[i].first - act) * v[i].second;
act += min(n - act, who[i] - v[i].first - act);
}
cout << res << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
static const double eps = 1e-9;
struct line {
complex<double> p, q;
};
double pon(line a, complex<double> p) {
complex<double> v = p - a.p;
complex<double> u = a.q - a.p;
complex<double> f = v / u;
if (abs(f.imag()) > eps) return -1;
return f.real();
}
bool isA(line a, line b, line c) {
if (a.p != b.p) return false;
double ag = arg((a.q - a.p) / (b.q - b.p));
if (abs(ag) > atan2(1.0, 0.0) + eps) return false;
double p1 = pon(a, c.p);
double p2 = pon(b, c.q);
if (p1 < 0.2 - eps || p1 > eps + 0.8) return false;
if (p2 < 0.2 - eps || p2 > eps + 0.8) return false;
return true;
}
bool tryAllSwap(line a, line b, line c) {
for (int i = 0; i < 8; ++i) {
if (isA(a, b, c)) return true;
if (i % 1 == 0) swap(a.p, a.q);
if (i % 2 == 0) swap(b.p, b.q);
if (i % 4 == 0) swap(c.p, c.q);
}
return false;
}
bool tryAllPerm(line ls[3]) {
int ix[] = {0, 1, 2};
do
if (tryAllSwap(ls[ix[0]], ls[ix[1]], ls[ix[2]])) return true;
while (next_permutation(&ix[0], &ix[3]));
return false;
}
int main() {
int T;
cin >> T;
while (T--) {
line ls[3];
for (int i = 0; i < 3; ++i) {
double x1, y1, x2, y2;
scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
ls[i].p = complex<double>(x1, y1);
ls[i].q = complex<double>(x2, y2);
}
cout << (tryAllPerm(ls) ? "YES" : "NO") << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 2e5 + 100;
int col[sz];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b, c, i, j, k, q, p, x, y, ct, ct1, m, l, r, x1, y1, h, sum1, in, z,
mid, n, mx;
char ch;
double d;
string str1, str2, str;
bool bl, bl1;
int t, cs = 1;
int len;
cin >> n >> str;
len = n;
int dp[27];
memset(dp, 0, sizeof dp);
int cur = 0;
for (int i = 0; i < len; i++) {
int id = str[i] - 'a';
int mx = 0, idx = 0;
for (int j = id + 1; j < 26; j++) {
if (mx < dp[j]) mx = dp[j], idx = j;
}
dp[id] = mx + 1;
col[i] = mx + 1;
cur = max(cur, mx + 1);
}
cout << cur << '\n';
for (int i = 0; i < n; i++) cout << col[i] << " ";
cout << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int64_t fns = 90;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int64_t q;
cin >> q;
vector<int64_t> fibs(fns);
fibs[0] = 1;
fibs[1] = 2;
for (int64_t i = 2; i < fns; i++) {
fibs[i] = fibs[i - 1] + fibs[i - 2];
}
for (int64_t cq = 0; cq < q; cq++) {
int64_t ip;
cin >> ip;
vector<bool> chosen(fns);
for (int64_t j = fns - 1; j >= 0; j--) {
chosen[j] = (ip >= fibs[j]);
if (chosen[j]) ip -= fibs[j];
}
vector<int64_t> sz;
int64_t ls = -1;
for (int64_t i = 0; i < fns; i++) {
if (chosen[i]) {
sz.push_back(i - ls);
ls = i;
}
}
int64_t tk = 0;
int64_t ntk = 1;
for (auto s : sz) {
int64_t ot = tk;
int64_t on = ntk;
ntk = ot + on;
tk = ((s - 1) / 2) * on + (s / 2) * ot;
}
cout << (tk + ntk) << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ds[4000010][10];
queue<int> q;
bool Free[4000010];
int n, m, res;
void doit(int d, int c) {
int u = d + c - 1;
int v = d + (n - c + 1) - 1 + m + n - 1;
ds[u][0]++;
ds[u][ds[u][0]] = v;
ds[v][0]++;
ds[v][ds[v][0]] = u;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= 2 * (m + n - 1); i++) ds[i][0] = 0;
for (int i = 1; i <= n; i++) {
doit(1, i);
doit(m, i);
}
for (int i = 2; i <= m - 1; i++) {
doit(i, 1);
doit(i, n);
}
memset(Free, true, sizeof(Free));
res = 0;
int u, v;
for (int i = 1; i <= 2 * (m + n - 1); i++)
if (Free[i]) {
res++;
q.push(i);
Free[i] = false;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 1; i <= ds[u][0]; i++) {
v = ds[u][i];
if (Free[v]) {
Free[v] = false;
q.push(v);
}
}
}
}
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = double;
using matr = vector<vector<ll>>;
using dbl = long double;
using ui = unsigned int;
mt19937 rnd;
ll random(ll limit) {
limit = max(limit, (ll)0);
uniform_int_distribution<ll> uniform_dist(0, limit);
return uniform_dist(rnd);
}
int num = 1000;
struct xui {
ll arr[5];
};
bool cmp(xui x, xui y) {
if (x.arr[0] * y.arr[1] > x.arr[1] * y.arr[0]) return 0;
if (x.arr[0] * y.arr[1] < x.arr[1] * y.arr[0]) return 1;
for (int i = 2; i < 5; i++) {
if (x.arr[i] > y.arr[i]) return 0;
if (y.arr[i] > x.arr[i]) return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
rnd = mt19937(6348065);
int n;
cin >> n;
vector<ll> xl(n), xr(n), y(n);
for (int i = 0; i < n; i++) cin >> xl[i] >> xr[i] >> y[i];
vector<xui> kek;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (y[i] < y[j]) {
ll dy = y[i] - y[j];
ll dx1 = xl[i] - xr[j];
ll dx2 = xr[i] - xl[j];
kek.push_back({dx1, dy, 0, j, i});
kek.push_back({dx2, dy, 1, j, i});
}
}
}
sort(kek.begin(), kek.end(), cmp);
int cur_l = -1;
int min_y = 1e9;
int min_l = 1e9;
for (int i = 0; i < n; i++) {
if (y[i] < min_y) {
min_y = y[i];
min_l = xl[i];
cur_l = i;
} else {
if (y[i] == min_y && min_l > xl[i]) {
cur_l = i;
min_l = xl[i];
}
}
}
int cur_r = -1;
int max_y = -1e10;
int max_x = -1e10;
for (int i = 0; i < n; i++) {
if (y[i] > max_y) {
max_y = y[i];
max_x = xr[i];
cur_r = i;
} else {
if (y[i] == max_y && max_x < xr[i]) {
cur_r = i;
max_x = xr[i];
}
}
}
ld ans = 1e18;
ld mina = -1e12;
int num_e = 0;
for (auto q : kek) {
ld cur_a = q.arr[0] * 1.0 / q.arr[1];
if (num_e == 0) {
ld mem;
mem = xr[cur_r] - xl[cur_l] -
max(cur_a * (y[cur_r] - y[cur_l]), mina * (y[cur_r] - y[cur_l]));
if (mem < ans) {
if (num--) {
ld l = 1e18;
ld r = -1e18;
for (int i = 0; i < n; i++) {
ld c_l = xl[i] - cur_a * y[i];
ld c_r = xr[i] - cur_a * y[i];
l = min(l, c_l);
r = max(r, c_r);
}
ld l1 = 1e18;
ld r1 = -1e18;
for (int i = 0; i < n; i++) {
ld c_l = xl[i] - mina * y[i];
ld c_r = xr[i] - mina * y[i];
l1 = min(l1, c_l);
r1 = max(r1, c_r);
}
mem = min(r - l, r1 - l1);
}
ans = mem;
}
}
if (cur_r == q.arr[3]) cur_r = q.arr[4];
if (cur_l == q.arr[4]) cur_l = q.arr[3];
if (q.arr[2] == 1)
num_e++;
else
num_e--;
mina = cur_a;
}
cur_l = -1;
max_y = -1e9;
min_l = 1e9;
for (int i = 0; i < n; i++) {
if (y[i] > max_y) {
max_y = y[i];
min_l = xl[i];
cur_l = i;
} else {
if (y[i] == max_y && min_l > xl[i]) {
cur_l = i;
min_l = xl[i];
}
}
}
cur_r = -1;
min_y = 1e9;
max_x = -1e9;
for (int i = 0; i < n; i++) {
if (y[i] < min_y) {
min_y = y[i];
max_x = xr[i];
cur_r = i;
} else {
if (y[i] == min_y && max_x < xr[i]) {
cur_r = i;
max_x = xr[i];
}
}
}
ld dy = y[cur_l] - y[cur_r];
ld mem;
ld cur_a = 1e12;
mem = xr[cur_r] - xl[cur_l] -
max(cur_a * (y[cur_r] - y[cur_l]), mina * (y[cur_r] - y[cur_l]));
if (mem < ans) {
ans = mem;
}
cout.precision(100);
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const double pi = acos(-1);
const int mod = 1e9 + 7;
long long fastpow(long long b, long long e) {
if (!e) return 1;
long long ret = fastpow(b, e / 2);
ret = (ret * ret) % mod;
if (e % 2) ret = (ret * b) % mod;
return ret;
}
long long mi(int x) { return fastpow(x, mod - 2); }
char grid[40][40];
char prv[40][40];
int cmp(int n, int m, int prvn, int prvm) {
for (int i = 0; i < min(n, prvn); i++) {
string s1, s2;
for (int j = 0; j < prvm; j++) s1.push_back(prv[i][j]);
for (int j = 0; j < m; j++) s2.push_back(grid[i][j]);
int ret;
if (s1 > s2)
ret = 1;
else if (s1 < s2)
ret = -1;
else
ret = 0;
if (ret != 0) return ret;
}
return 0;
}
int main() {
vector<string> s;
int a[7];
for (int i = 0; i < 6; i++) {
string x;
cin >> x;
s.push_back(x);
a[i] = i;
}
sort(s.begin(), s.end());
bool isprv = 0;
int resn = -1, resm = -1;
do {
if (s[a[0]][0] != s[a[4]][0] || s[a[0]].back() != s[a[5]][0]) continue;
if (s[a[1]].size() != s[a[2]].size() + s[a[0]].size() - 1) continue;
if (s[a[5]].size() != s[a[3]].size() + s[a[4]].size() - 1) continue;
for (int i = 0; i < 40; i++) {
for (int j = 0; j < 40; j++) grid[i][j] = '.';
}
for (int i = 0; i < s[a[0]].size(); i++) {
grid[0][i] = s[a[0]][i];
}
for (int i = 0; i < s[a[4]].size(); i++) {
grid[i][0] = s[a[4]][i];
}
for (int i = 0; i < s[a[5]].size(); i++) {
grid[i][s[a[0]].size() - 1] = s[a[5]][i];
}
bool ok = 1;
for (int i = 0; i < s[a[1]].size(); i++) {
int x = s[a[4]].size() - 1;
if (grid[x][i] != s[a[1]][i] && grid[x][i] != '.') {
ok = 0;
break;
}
grid[x][i] = s[a[1]][i];
}
if (!ok) continue;
int x = s[a[5]].size() - 1;
int y = s[a[0]].size() - 1;
for (int i = 0; i < s[a[2]].size(); i++, y++) {
if (grid[x][y] != s[a[2]][i] && grid[x][y] != '.') {
ok = 0;
break;
}
grid[x][y] = s[a[2]][i];
}
if (!ok) continue;
x = s[a[4]].size() - 1;
y = s[a[1]].size() - 1;
for (int i = 0; i < s[a[3]].size(); i++, x++) {
if (grid[x][y] != s[a[3]][i] && grid[x][y] != '.') {
ok = 0;
break;
}
grid[x][y] = s[a[3]][i];
}
if (!ok) continue;
int n = s[a[5]].size();
int m = s[a[1]].size();
if (isprv) {
int ret = cmp(n, m, resn, resm);
if (ret == 1) {
for (int i = 0; i < 40; i++) {
for (int j = 0; j < 40; j++) prv[i][j] = '.';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) prv[i][j] = grid[i][j];
}
resn = n, resm = m;
}
} else {
for (int i = 0; i < 40; i++) {
for (int j = 0; j < 40; j++) prv[i][j] = '.';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
prv[i][j] = grid[i][j];
}
}
resn = n, resm = m;
isprv = 1;
}
} while (next_permutation(a, a + 6));
if (resn != -1) {
for (int i = 0; i < resn; i++) {
for (int j = 0; j < resm; j++) cout << prv[i][j];
cout << '\n';
}
return 0;
}
puts("Impossible");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
int num, from = -1, to = -1;
cin >> num;
string x;
cin >> x;
for (int i = 0; i < (int)(x.length()); i++) {
if (x[i] == 'R') {
from = i;
break;
}
}
for (int i = 0; i < (int)(x.length()); i++) {
if (x[i] == 'L') {
to = i;
break;
}
}
if (from != -1 && to != -1)
cout << min(from, to) + 1 << " " << max(from, to);
else if (from != -1) {
for (int i = x.length() - 1; i >= 0; i--) {
if (x[i] == 'R') {
cout << i + 1 << " " << i + 2;
break;
}
}
} else if (to != -1) {
for (int i = x.length() - 1; i >= 0; i--) {
if (x[i] == 'L') {
cout << i + 1 << " ";
break;
}
}
cout << to;
}
return 0;
}
| 2 |
#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;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
struct point {
long long int x, y;
};
long double modld(long double x, long long int y) {
long long int z = floor(x);
z %= y;
return (long double)z + x - floor(x);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int h, m, s, t1, t2;
cin >> h >> m >> s >> t1 >> t2;
h *= 3600;
m *= 60;
long double Time = h + m + s;
long double angh, angm, angs;
angh = (Time) / 120;
angm = (Time) / 10;
angs = Time * 6;
angh = modld(angh, 360);
angm = modld(angm, 360);
angs = modld(angs, 360);
if (t1 > t2) {
swap(t1, t2);
}
long double angt1 = 30 * t1, angt2 = 30 * t2;
if (angt1 == 360) {
angt1 = 0;
}
if (angt2 == 360) {
angt2 = 0;
}
if (angt1 > angt2) {
swap(angt1, angt2);
}
bool flag1 = true, flag2 = true;
if ((angh >= angt1 && angh <= angt2) || (angm >= angt1 && angm <= angt2) ||
(angs >= angt1 && angs <= angt2)) {
flag1 = false;
}
if ((angh >= angt2 || angh <= angt1) || (angm >= angt2 || angm <= angt1) ||
(angs >= angt2 || angs <= angt1)) {
flag2 = false;
}
if (flag1 || flag2) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
long long int p[m + 1];
p[0] = 0;
for (int i = 1; i <= m; i++) {
cin >> p[i];
if (p[i] == n || p[i] == 1) {
cout << "NO" << endl;
return 0;
}
}
sort(p, p + m + 1);
for (int i = 1; i <= m - 2; i++) {
if (p[i] + 2 == p[i + 1] + 1 && p[i + 1] + 1 == p[i + 2]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
char str[N];
int main() {
scanf("%s", str);
int n = strlen(str);
int f = 0;
for (int i = 0; i < n; i++) {
if (str[i] != 'a') {
f = 1;
}
}
if (!f) {
for (int i = 0; i < n - 1; i++) printf("a");
printf("z\n");
} else {
f = 0;
for (int i = 0; i < n; i++) {
if (f == 0 && str[i] != 'a') {
f = 1;
}
if (f == 1 && str[i] == 'a') {
f = 2;
}
if (f == 1)
printf("%c", str[i] - 1);
else
printf("%c", str[i]);
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
void solve() {
int a = 1, b = 1, c, ans = 0;
cin >> c;
while (c >= 0) {
if (c - a >= 0) ans++;
c -= a;
b++;
a += b;
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, a[100], ok = 1;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 1; i < n; i++)
if (a[i] - a[i - 1] == 1) ok = 2;
cout << ok << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int v[110][2];
int memo[3500][110][2];
int MOD;
int calcula(int tam, int ind, int a) {
if (tam == x) return 1;
if (tam > x) return 0;
int res = 0;
if (memo[tam][ind][a] != -1) return memo[tam][ind][a];
int y = v[ind][a];
for (int i = 0; i < n; i++) {
if (i == ind) continue;
if (v[i][0] == y) {
res = (res + calcula(tam + y, i, 1)) % MOD;
}
if (v[i][1] != v[i][0] && v[i][1] == y) {
res = (res + calcula(tam + y, i, 0)) % MOD;
}
}
return memo[tam][ind][a] = res;
}
int main() {
MOD = 1000000007;
scanf("%d %d", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%d %d", &v[i][0], &v[i][1]);
}
memset(memo, -1, sizeof(memo));
int res = 0;
for (int i = 0; i < n; i++) {
res = (res + calcula(v[i][0], i, 1)) % MOD;
if (v[i][0] != v[i][1]) {
res = (res + calcula(v[i][1], i, 0)) % MOD;
}
}
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 5;
const int mod = 1000000007;
struct Point {
int x;
int y;
};
int dis(Point p1, Point p2) {
return ((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
}
double calc(double A, double B, double C, double D) {
double X = (A * D - B * C) * (C - D);
double Y = (A * D - B * C) * (B - A);
double DEN = 2 * A * B - B * B + 2 * C * D - D * D - A * A - C * C;
return (X * X + Y * Y) / (DEN * DEN);
}
double calct(double A, double B, double C, double D) {
double X = A * B - B * B + C * D - D * D;
double Y = 2 * A * B - B * B + 2 * C * D - D * D - A * A - C * C;
return X / Y;
}
Point p1[N], p2[N];
int main() {
int n;
scanf("%d", &n);
double d1, d2;
cin >> d1 >> d2;
int fd = 1;
for (int i = 1; i <= n; i++) {
cin >> p1[i].x >> p1[i].y;
cin >> p2[i].x >> p2[i].y;
}
int ans = 0;
if ((dis(p1[1], p2[1]) < (d1 * d1))) ans++, fd = 0;
for (int i = 2; i <= n; i++) {
double A = p1[i].x - p2[i].x;
double B = p1[i - 1].x - p2[i - 1].x;
double C = p1[i].y - p2[i].y;
double D = p1[i - 1].y - p2[i - 1].y;
if (calct(A, B, C, D) <= 1 && calct(A, B, C, D) >= 0) {
if (calc(A, B, C, D) <= d1 * d1 && fd) {
ans++;
fd = 0;
}
} else {
if ((dis(p1[i - 1], p2[i - 1]) <= d1 * d1 ||
dis(p1[i], p2[i]) <= d1 * d1) &&
fd) {
ans++;
fd = 0;
}
}
if (dis(p1[i], p2[i]) > d2 * d2) fd = 1;
}
printf("%d ", ans);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000;
int c[1001][1001];
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
long long s = 0, sij = 0, si = 0, sj = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int p = (i - 1) * 4 + 2, q = (j - 1) * 4 + 2;
scanf("%d", &c[i][j]);
s += c[i][j];
sij += (long long)c[i][j] * (p * p + q * q);
si += c[i][j] * p;
sj += c[i][j] * q;
}
}
int x, y;
long long ans = inf;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
int p = i * 4, q = j * 4;
long long temp = s * (p * p + q * q) - 2 * si * p - 2 * sj * q + sij;
if (temp < ans) {
ans = temp;
x = i;
y = j;
}
}
}
printf("%I64d\n%d %d\n", ans, x, y);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int ways(long long int n) {
long long int ret = 0;
for (long long int i = 2; i <= 1e6; i++) {
long long int tmp = i * i * i;
long long int tmp1 = n / tmp;
ret += tmp1;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int m;
cin >> m;
long long int low = 0, high = 1e18;
long long int ans = -1;
while (low <= high) {
long long int mid = (low + high) / 2;
if (ways(mid) >= m) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
if (ways(ans) == m)
cout << ans;
else
cout << -1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
void rot(int &i, int &j, int t) {
int ni, nj;
if (t == -1) {
ni = j;
nj = n - i + 1;
} else {
ni = m - j + 1;
nj = i;
}
i = ni;
j = nj;
swap(n, m);
}
void inv(int &i, int &j) { j = m - j + 1; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int on, om;
cin >> on >> om;
int x, y, z;
cin >> x >> y >> z;
x %= 4;
y %= 2;
z %= 4;
int p;
cin >> p;
int mx[p], my[p];
for (int i = 0; i < p; i++) {
cin >> mx[i] >> my[i];
n = on;
m = om;
for (int j = 0; j < x; j++) rot(mx[i], my[i], -1);
for (int j = 0; j < y; j++) inv(mx[i], my[i]);
for (int j = 0; j < z; j++) rot(mx[i], my[i], 1);
}
for (int i = 0; i < p; i++) cout << mx[i] << " " << my[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
map<pair<int, int>, int> tt;
map<int, int> xx, yy;
for (int i = 0, x, y; i < n; i++) {
scanf("%d %d", &x, &y), xx[x]++, yy[y]++;
tt[make_pair(x, y)]++;
}
long long ans = 0;
for (map<int, int>::iterator it = xx.begin(); it != xx.end(); it++)
ans += 1ll * it->second * (it->second - 1);
for (map<int, int>::iterator it = yy.begin(); it != yy.end(); it++)
ans += 1ll * it->second * (it->second - 1);
for (map<pair<int, int>, int>::iterator it = tt.begin(); it != tt.end();
it++)
ans -= 1ll * (it->second - 1) * (it->second);
cout << ans / 2 << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r;
cin >> n >> pos >> l >> r;
if (l == 1 && r == n)
cout << 0 << endl;
else if (l == 1 && r != n)
cout << abs(r - pos) + 1;
else if (r == n && l != 1)
cout << abs(pos - l) + 1;
else
cout << r - l + min(abs(pos - l), abs(pos - r)) + 2;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using vi = vector<int>;
const int N = 1e6 + 100;
int n, q, tr[N];
void add(int x, int v) {
for (; x <= n; x += x & -x) tr[x] += v;
}
int qry(int x) {
int ret = 0;
for (; x; x -= x & -x) ret += tr[x];
return ret;
}
int ind(int kth) {
if (qry(n) == 0) return 0;
int l = 1, r = n, mid;
while (l < r) qry(mid = l + r >> 1) >= kth ? r = mid : l = mid + 1;
return l;
}
signed main() {
scanf("%d %d", &n, &q);
for (int i = 1, a; i <= n; i++) scanf("%d", &a), add(a, 1);
for (int i = 1, k; i <= q; i++) {
scanf("%d", &k);
if (k > 0) {
add(k, 1);
} else {
k = -k;
add(ind(k), -1);
}
}
printf("%d\n", ind(1));
fprintf(stderr, "time=%.4f\n", (db)clock() / CLOCKS_PER_SEC);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n;
double p[N][N], d[N], pr[N];
int vis[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
int x;
scanf("%d", &x);
p[i][j] = x / 100.0;
}
for (int i = 1; i <= n; i++) d[i] = 1, pr[i] = 1 - p[i][n];
if (n == 1) {
printf("0.000000000");
return 0;
}
vis[n] = 1;
d[n] = 0;
for (int i = 1; i < n; i++) {
int u = 0;
double mn = 1e18;
for (int j = 1; j <= n; j++)
if (!vis[j] && d[j] / (1 - pr[j]) < mn) mn = d[j] / (1 - pr[j]), u = j;
vis[u] = 1;
if (u == 1) {
printf("%.10lf", d[1] / (1 - pr[1]));
break;
}
for (int j = 1; j <= n; j++)
d[j] += (d[u] / (1 - pr[u])) * p[j][u] * pr[j], pr[j] *= (1 - p[j][u]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int main() {
int t, n, i;
cin >> t;
while (t--) {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
cout << min(a[n - 2] - 1, n - 2) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500010;
int A[MAXN];
int cnt[2 * MAXN];
vector<int> pv[2 * MAXN];
void updmx(int &mx1, int &mx2, int a) {
mx2 = max(mx2, a);
if (mx1 < mx2) swap(mx1, mx2);
}
void updans(long long &ans, int x, int y) {
if (x >= 2 && y >= 2) ans = max(ans, (long long)x * y);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
for (int i = 0; i < N; i++) {
cnt[A[i]]++;
if (pv[A[i]].size() < 2) pv[A[i]].push_back(A[i]);
}
for (int i = 1; i < 2 * MAXN; i++) {
cnt[i] += cnt[i - 1];
if (pv[i].empty()) {
if (!pv[i - 1].empty()) pv[i].push_back(pv[i - 1][0]);
if (pv[i - 1].size() > 1) pv[i].push_back(pv[i - 1][1]);
} else if (pv[i].size() < 2 && !pv[i - 1].empty())
pv[i].push_back(pv[i - 1][0]);
}
long long ans = 0;
for (int y = 2; y < MAXN; y++) {
int mx1 = -1, mx2 = -1;
long long sum = 0;
for (int k = 1; k * y < MAXN; k++)
sum += (long long)(cnt[k * y + y - 1] - cnt[k * y - 1]) * k;
for (int k = MAXN / y; k >= 0; k--) {
if (mx1 >= 0)
updans(ans, min(sum - k - 1, (long long)(k * y + y + mx1) / 2), y);
if (mx2 >= 0) {
updans(ans, min(sum - 2 * k - 2, (long long)k * y + y + mx2), y);
updans(ans, min({sum - 2 * k - 1, (long long)k * y + mx1}), y);
}
int t = k * y + y - 1;
if (!pv[t].empty() && pv[t][0] >= k * y) {
if (mx1 >= 0) updans(ans, min(sum - 2 * k - 1, (long long)pv[t][0]), y);
updmx(mx1, mx2, pv[t][0] - k * y);
}
if (pv[t].size() > 1 && pv[t][1] >= k * y)
updmx(mx1, mx2, pv[t][1] - k * y);
if (mx1 >= 0) updans(ans, min(sum - k, (long long)(k * y + mx1) / 2), y);
if (mx2 >= 0) updans(ans, min(sum - 2 * k, (long long)k * y + mx2), y);
}
}
cout << ans << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[7] = {0};
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
arr[a - 1]++;
}
if (arr[0] != n / 3) {
cout << "-1";
} else if (arr[1] + arr[2] != n / 3) {
cout << "-1";
} else if (arr[3] + arr[5] != n / 3) {
cout << "-1";
} else if (arr[3] > arr[1]) {
cout << "-1";
} else {
n /= 3;
while (n--) {
cout << "1 ";
if (arr[1]) {
cout << "2 ";
arr[1]--;
if (arr[3]) {
cout << "4";
arr[3]--;
} else if (arr[5]) {
cout << "6";
arr[5]--;
}
} else if (arr[2]) {
cout << "3 ";
arr[2]--;
if (arr[5]) {
cout << "6";
arr[5]--;
}
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 500;
const int INF = 0x3f3f3f3f;
int N, M;
char Flag[Maxn + 5][Maxn + 5];
int f[Maxn + 2][26 + 2][26 + 2];
int p[Maxn + 2][26 + 2][26 + 2][2];
int Cost(int i, int A, int B) {
int ret = 0;
for (int j = 1; j <= M; j++) {
if (j & 1)
ret += (Flag[i][j] != (A + 'a'));
else
ret += (Flag[i][j] != (B + 'a'));
}
return ret;
}
void Prepare() {
memset(f, 0x3f, sizeof f);
for (int A = 0; A < 26; A++)
for (int B = 0; B < 26; B++)
if (A != B) f[1][A][B] = Cost(1, A, B);
}
char Ans[Maxn + 5][Maxn + 5];
void Print(int A, int B) {
int t1, t2;
for (int i = N; i >= 1; i--) {
for (int j = 1; j <= M; j++) {
if (j & 1)
Ans[i][j] = A + 'a';
else
Ans[i][j] = B + 'a';
}
t1 = p[i][A][B][0], t2 = p[i][A][B][1];
A = t1, B = t2;
}
for (int i = 1; i <= N; i++) puts(Ans[i] + 1);
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; i++) scanf("%s", Flag[i] + 1);
Prepare();
for (int i = 1; i <= N; i++)
for (int A = 0; A < 26; A++)
for (int B = 0; B < 26; B++) {
if (A == B) continue;
int cos = Cost(i, A, B);
for (int pA = 0; pA < 26; pA++) {
if (pA == A) continue;
for (int pB = 0; pB < 26; pB++) {
if (pA == pB) continue;
if (pB == B) continue;
if (f[i - 1][pA][pB] == INF) continue;
if (f[i][A][B] > f[i - 1][pA][pB] + cos) {
f[i][A][B] = f[i - 1][pA][pB] + cos;
p[i][A][B][0] = pA;
p[i][A][B][1] = pB;
}
}
}
}
int ans = INF, A, B;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
if (ans > f[N][i][j]) {
ans = f[N][i][j];
A = i, B = j;
}
printf("%d\n", ans);
Print(A, B);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 200100;
struct node {
int x, y;
} a[2100], b[2100];
struct edge {
int next, to;
} e[4000100];
long long jc[N], inv[N], ans, f[2100][40], g[2100][40];
int n, m, num, s, head[2100], q[2100], tot = 0, du[2100];
void tj() { s = (s >> 1) + (s & 1); }
void add(int x, int y) {
e[++tot].next = head[x];
head[x] = tot;
e[tot].to = y;
du[y]++;
}
long long ksm(long long x, int y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return res;
}
long long c(int x, int y) {
return ((jc[x] * inv[y]) % mod * inv[x - y]) % mod;
}
void ycl() {
jc[0] = 1;
for (long long i = 1; i <= 200000; i++) jc[i] = (jc[i - 1] * i) % mod;
inv[0] = 1;
for (int i = 1; i <= 200000; i++) inv[i] = ksm(jc[i], mod - 2);
}
void topsort() {
int i, j, x, y, fp = 1, rp = 0;
for (i = 1; i <= num; i++)
for (j = 1; j <= num; j++)
if ((j != i) && (a[i].x <= a[j].x) && (a[i].y <= a[j].y)) add(i, j);
for (i = 1; i <= num; i++)
if (!du[i]) q[++rp] = i;
while (fp <= rp) {
x = q[fp++];
for (i = head[x]; i; i = e[i].next) {
y = e[i].to;
du[y]--;
if (!du[y]) q[++rp] = y;
}
}
}
int main() {
int i, j, k;
scanf("%d%d%d%d", &n, &m, &num, &s);
for (i = 1; i <= num; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
if ((a[i].x == 1) && (a[i].y == 1)) {
num--;
tj();
--i;
}
}
topsort();
for (i = 1; i <= num; i++) b[i] = a[i];
for (i = 1; i <= num; i++) a[i] = b[q[i]];
if ((a[num].x == n) && (a[num].y == m)) num--, tj();
ycl();
a[++num].x = n;
a[num].y = m;
for (i = 1; i <= num; i++)
for (j = 0; j <= 21; j++) {
f[i][j] = c(a[i].x + a[i].y - 2, a[i].x - 1);
for (k = 1; k < i; k++)
if ((a[k].x <= a[i].x) && (a[k].y <= a[i].y))
f[i][j] = (f[i][j] -
(c(a[i].x - a[k].x + a[i].y - a[k].y, a[i].x - a[k].x) *
g[k][j]) %
mod +
mod) %
mod;
if (j)
g[i][j] = (f[i][j] - f[i][j - 1] + mod) % mod;
else
g[i][j] = f[i][j];
}
i = 0;
ans = 0;
while (s != 1) {
ans = (ans + (long long)s * g[num][i]) % mod;
tj();
++i;
}
if (i)
ans = (ans + c(n + m - 2, n - 1) - f[num][i - 1] + mod) % mod;
else
ans = (ans + c(n + m - 2, n - 1)) % mod;
ans = (ans * ksm(c(n + m - 2, n - 1), mod - 2)) % mod;
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char c;
int f = 1;
while (!isdigit(c = getchar()))
if (c == '-') f = -1;
x = (c & 15);
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + (c & 15);
x *= f;
}
int n, m, dis[205], tot, cst;
struct ii {
int y, z;
} e[1000005];
vector<int> bi[205];
void init() {
int i;
for (i = 1; i <= n; i++) bi[i].clear();
tot = 0;
}
void add(int x, int y, int z) {
tot++;
bi[x].push_back(tot * 2 - 2);
bi[y].push_back(tot * 2 - 1);
e[tot * 2 - 2] = (ii){y, z};
e[tot * 2 - 1] = (ii){x, z};
}
bool bfs(int s, int t) {
queue<int> qx;
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
qx.push(s);
while (!qx.empty()) {
int x = qx.front();
qx.pop();
for (__typeof((bi[x]).begin()) it = (bi[x]).begin(); it != (bi[x]).end();
++it) {
if (e[*it].z && dis[e[*it].y] > dis[x] + 1) {
dis[e[*it].y] = dis[x] + 1;
qx.push(e[*it].y);
}
}
}
return dis[t] < dis[201];
}
int dfs(int x, int tt, int flw) {
if (!flw || x == tt) return flw;
int ans = 0;
for (__typeof((bi[x]).begin()) it = (bi[x]).begin(); it != (bi[x]).end();
++it) {
if (e[*it].z && dis[e[*it].y] == dis[x] + 1) {
int t = dfs(e[*it].y, tt, min(flw, e[*it].z));
flw -= t;
ans += t;
e[*it].z -= t;
e[(*it) ^ 1].z += t;
}
}
dis[x] = -1;
return ans;
}
int dinic(int s, int t) {
int ans = 0;
while (bfs(s, t)) {
ans += dfs(s, t, 0x3f3f3f3f);
}
return ans;
}
int i, j, px[1005], py[1005], pz[1005], sum;
vector<int> v;
vector<int> res, bi2[205];
int vis[205], c[205][205];
void solve(vector<int> v) {
if (v.size() == 1) return;
int x = v[0], y = v[1], i, j;
init();
for ((i) = 1; (i) <= (m); (i)++) {
add(px[i], py[i], pz[i]);
}
int val = dinic(x, y);
bfs(x, y);
vector<int> vl, vr;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
if (dis[*it] < dis[201])
vl.push_back(*it);
else
vr.push_back(*it);
for ((i) = 1; (i) <= (n); (i)++)
for ((j) = 1; (j) <= (n); (j)++)
if ((dis[i] < dis[201]) ^ (dis[j] < dis[201]))
c[i][j] = min(c[i][j], val);
solve(vl);
solve(vr);
}
void solve2(vector<int> v) {
if (v.size() == 1) {
res.push_back(v[0]);
return;
}
int x = v[0], y = v[1], i;
for ((i) = (2); (i) <= (v.size() - 1); (i)++) {
if (c[x][v[i]] < c[x][y]) {
y = v[i];
}
}
init();
for ((i) = 1; (i) <= (m); (i)++) {
add(px[i], py[i], pz[i]);
}
sum += dinic(x, y);
bfs(x, y);
vector<int> vl, vr;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
if (dis[*it] < dis[201])
vl.push_back(*it);
else
vr.push_back(*it);
solve2(vl);
solve2(vr);
}
int main() {
read(n);
read(m);
for ((i) = 1; (i) <= (m); (i)++) {
read(px[i]);
read(py[i]);
read(pz[i]);
}
for ((i) = 1; (i) <= (n); (i)++) {
v.push_back(i);
}
memset(c, 0x3f, sizeof(c));
solve(v);
solve2(v);
printf("%d\n", sum);
for (__typeof((res).begin()) it = (res).begin(); it != (res).end(); ++it)
printf("%d ", *it);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
namespace std {
bool operator<(const complex<double>& a, const complex<double>& b) {
return real(a) != real(b) ? real(a) > real(b) : imag(a) > imag(b);
}
} // namespace std
char s[110011];
char w[20][4];
int main() {
scanf("%s", s);
int n;
scanf("%d", &n);
for (int i = (0); i < (int)(n); i++) {
scanf("%s", w[i]);
}
int ans = 0;
int i = 0;
while (s[i + 1]) {
int f = -1;
for (int j = (0); j < (int)(n); j++) {
if ((s[i] == w[j][0] && s[i + 1] == w[j][1]) ||
(s[i + 1] == w[j][0] && s[i] == w[j][1])) {
f = j;
}
}
if (f == -1) {
i++;
continue;
}
int j = i;
while (s[j] == w[f][0] || s[j] == w[f][1]) {
j++;
}
while (i > 0 && s[i] == s[i - 1]) i--;
while (j < n && s[j - 1] == s[j]) j++;
int cf = 0;
for (int k = (i); k < (int)(j); k++) {
cf += s[k] == w[f][0];
}
ans += min(cf, j - i - cf);
i = j;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
int read() {
char c;
while ((c = getchar()) < '-')
;
if (c == '-') {
int x = (c = getchar()) - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return -x;
}
int x = c - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return x;
}
int sgn(const long double &x, const long double &eps = 1e-12) {
return x < -eps ? -1 : x > eps;
}
long double sqr(const long double &x) { return x * x; }
struct Point {
long double x, y;
};
long double dis2(const Point &a, const Point &b) {
return sqr(a.x - b.x) + sqr(a.y - b.y);
}
Point operator-(const Point &a, const Point &b) {
return {a.x - b.x, a.y - b.y};
}
Point operator+(const Point &a, const Point &b) {
return {a.x + b.x, a.y + b.y};
}
long double operator^(const Point &a, const Point &b) {
return a.x * b.x + a.y * b.y;
}
long double operator*(const Point &a, const Point &b) {
return a.x * b.y - b.x * a.y;
}
Point operator*(const Point &a, const long double &b) {
return {a.x * b, a.y * b};
}
Point O;
long double r, r2;
struct Polygon {
vector<Point> p;
int n;
long double area;
void init() {
n = read();
p.resize(n + 1);
double px, py;
for (int i = 0; i <= n - 1; ++i) {
scanf("%lf%lf", &px, &py);
p[i] = {px, py};
}
p[n] = p[0];
area = 0;
for (int i = 0; i <= n - 1; ++i) area += p[i] * p[i + 1];
area = abs(area) / 2;
}
bool point_in_polygon() {
int ret = 0;
for (int i = 0; i <= n - 1; ++i) {
Point u = p[i], v = p[i + 1];
if (sgn(u.y - v.y) <= 0) swap(u, v);
if (sgn(O.y - u.y) > 0 || sgn(O.y - v.y) <= 0) continue;
ret += sgn((v - O) * (u - O)) > 0;
}
return ret & 1;
}
bool has_intersection() {
for (int i = 0; i <= n - 1; ++i) {
if (sgn(dis2(p[i], O) - r2) <= 0) return 1;
if (sgn((O - p[i]) ^ (p[i + 1] - p[i])) > 0 &&
sgn((O - p[i + 1]) ^ (p[i] - p[i + 1])) > 0)
if (sgn(sqr((O - p[i]) * (p[i + 1] - p[i])) -
r2 * dis2(p[i], p[i + 1])) <= 0)
return 1;
}
return point_in_polygon();
}
};
int main() {
long double width, height;
int n;
cin >> width >> height >> n;
vector<Polygon> poly(n);
for (int i = 0; i <= n - 1; ++i) poly[i].init();
int q;
cin >> q;
for (int tmp = 1; tmp <= q; ++tmp) {
double Ox, Oy, Or;
scanf("%lf%lf%lf", &Ox, &Oy, &Or);
O = {Ox, Oy};
r = Or;
r2 = sqr(r);
long double area = 0;
vector<int> ans;
for (int i = 0; i <= n - 1; ++i)
if (poly[i].has_intersection()) {
area += poly[i].area;
ans.push_back(i);
}
printf("%f %d", (double)area, int(ans.size()));
for (auto x : ans) printf(" %d", x);
puts("");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const char p[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
char a[110][110], ans[110][110];
int main(void) {
int T;
scanf("%d", &T);
while (T--) {
int r, c, k;
scanf("%d%d%d", &r, &c, &k);
for (int i = 1; i <= r; ++i) {
scanf("%s", a[i] + 1);
}
int cnt = 0;
for (int i = 1; i <= r; ++i) {
for (int j = 1; j <= c; ++j) {
if (a[i][j] == 'R') cnt++;
}
}
int per = cnt / k, pls = cnt % k, now = 0, pcnt = 0;
for (int i = 1; i <= r; ++i) {
if (i % 2) {
for (int j = 1; j <= c; ++j) {
if (a[i][j] == 'R') pcnt++;
if (pls && pcnt == per + 2) {
now++;
pcnt = 1;
pls--;
} else if (!pls && pcnt == per + 1) {
now++;
pcnt = 1;
}
ans[i][j] = p[now];
}
} else {
for (int j = c; j >= 1; --j) {
if (a[i][j] == 'R') pcnt++;
if (pls && pcnt == per + 2) {
now++;
pcnt = 1;
pls--;
} else if (!pls && pcnt == per + 1) {
now++;
pcnt = 1;
}
ans[i][j] = p[now];
}
}
}
for (int i = 1; i <= r; ++i) {
for (int j = 1; j <= c; ++j) {
printf("%c", ans[i][j]);
}
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 10;
int a[maxn], pos[maxn];
bool prime[maxn];
vector<int> primes;
vector<pair<int, int> > ans;
void _swap(int p1, int p2) {
swap(a[p1], a[p2]);
swap(pos[a[p1]], pos[a[p2]]);
}
void go(int cur) {
int dist = pos[cur] - cur + 1;
auto cangoIT = upper_bound(primes.begin(), primes.end(), dist);
cangoIT--;
int cango = *cangoIT;
ans.push_back(make_pair(pos[cur] - cango + 1, pos[cur]));
_swap(pos[cur], pos[cur] - cango + 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
memset(prime, 1, sizeof(prime));
for (int i = 2; i < maxn; i++)
if (prime[i]) {
primes.push_back(i);
for (int j = i + i; j < maxn; j += i) prime[j] = false;
}
for (int i = 1; i <= n; i++)
while (pos[i] != i) go(i);
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 110000;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setiosflags(ios::fixed) << setprecision(12);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string str;
cin >> str;
if (str.size() == 2) {
if (str[1] > str[0]) {
cout << "YES\n";
cout << 2 << "\n";
cout << str[0] << " " << str[1] << "\n";
} else {
cout << "NO\n";
}
} else {
cout << "YES\n";
cout << 2 << "\n";
cout << str[0] << " ";
for (int i = 1; i < n; i++) {
cout << str[i];
}
cout << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1600 + 5;
const int dr[] = {0, 0, 1, -1, 1, -1, 1, -1};
const int dc[] = {1, -1, 0, 0, 1, 1, -1, -1};
int n, m, nr, nc, cnt, ct;
bool grid[MAX][MAX], x[MAX][MAX], y[MAX][MAX], z[MAX][MAX], val;
vector<int> ans;
pair<int, int> cur;
bool inside(int r, int c) { return r > 0 && r <= n && c > 0 && c <= m; }
void dfs(int r, int c) {
grid[r][c] = 0;
x[r][c] = 1;
for (int i = 0; i <= 3; i++) {
nr = r + dr[i], nc = c + dc[i];
if (!grid[nr][nc]) continue;
dfs(nr, nc);
}
}
void cs() {
for (int r = 1; r <= n; r++)
for (int c = 1; c <= m; c++) {
if (!x[r][c]) continue;
if (!inside(r + 1, c + 1)) continue;
val = 1;
for (int i = r; i <= r + 1; i++)
for (int j = c; j <= c + 1; j++)
if (!x[i][j]) val = 0;
if (val)
for (int i = r; i <= r + 1; i++)
for (int j = c; j <= c + 1; j++) y[i][j] = 1;
}
}
void cas() {
for (int r = 1; r <= n; r++)
for (int c = 1; c <= m; c++) {
if (!x[r][c]) continue;
if (!inside(r - 1, c - 1)) continue;
if (!inside(r + 2, c + 2)) continue;
val = 1;
for (int i = r - 1; i <= r + 2; i++)
for (int j = c - 1; j <= c + 2; j++)
if (!x[i][j]) {
val = 0;
break;
}
if (val)
for (int i = r - 1; i <= r + 2; i++)
for (int j = c - 1; j <= c + 2; j++) z[i][j] = 1;
}
for (int r = 1; r <= n; r++)
for (int c = 1; c <= m; c++) z[r][c] ^= y[r][c];
}
void cast() {
for (int r = 1; r <= n; r++)
for (int c = 1; c <= m; c++) {
if (!z[r][c]) continue;
if (!inside(r + 1, c + 1)) continue;
val = 1;
for (int i = r; i <= r + 1; i++)
for (int j = c; j <= c + 1; j++)
if (!z[i][j]) val = 0;
y[r][c] = val;
}
}
void df(int r, int c) {
ct++;
y[r][c] = 0;
for (int i = 0; i <= 7; i++) {
nr = r + dr[i], nc = c + dc[i];
if (!y[nr][nc]) continue;
df(nr, nc);
}
}
void hit() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (!y[i][j]) continue;
ct = 0;
df(i, j);
if (ct > 3) cnt++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> grid[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (!grid[i][j]) continue;
memset(x, 0, sizeof x);
memset(y, 0, sizeof y);
memset(z, 0, sizeof z);
dfs(i, j);
cs();
cas();
memset(y, 0, sizeof y);
cast();
cnt = 0;
hit();
ans.push_back(cnt);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (auto i : ans) cout << i << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m;
vector<int> fre[N];
vector<pair<int, int> > tmp;
long long a[N];
void opf() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void inp() {
cin >> n >> m;
for (int(i) = (int)(1); (i) <= (int)(n); ++(i)) cin >> a[i];
}
void solve() {
int k = n / m;
for (int(i) = (int)(1); (i) <= (int)(n); ++(i)) fre[a[i] % m].push_back(i);
long long res = 0;
for (int(r) = (int)(0); (r) <= (int)(2 * m - 1); ++(r)) {
int cur = r % m;
while (fre[cur].size() > k) {
int pos = fre[cur].back();
fre[cur].pop_back();
tmp.push_back(pair<int, int>(r, pos));
}
while (fre[cur].size() < k && tmp.size()) {
int val = tmp.back().first;
int pos = tmp.back().second;
fre[cur].push_back(pos);
tmp.pop_back();
a[pos] += r - val;
res += r - val;
}
}
cout << res << '\n';
for (int(i) = (int)(1); (i) <= (int)(n); ++(i)) cout << a[i] << ' ';
}
int main() {
opf();
inp();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 1;
map<long long, long long> mp, pm;
map<char, long long> hs;
deque<long long> v, vc, ve, vv, vd;
deque<char> p, pe;
deque<string> ts, ss, st, rs;
deque<double> sd, ds;
long long a, b, c, d, e, f, cnt, ans, r, n, l, x, y, mx;
long double q, t, cnt1, cnt2;
string g, h, w, o, m, s;
char z, u;
bool re, rt;
vector<pair<long long, long long> > pr, rp, pp;
map<pair<long long, long long>, long long> aw, wa;
void cout_(deque<long long> ree) {
for (long long i = 0; i < ree.size(); i++) cout << ree[i] << " ";
cout << endl;
return;
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(0);
cin >> a;
if (a == 2)
return cout << 1 << endl << 2, 0;
else if (a == 1)
return cout << 1 << endl << 1, 0;
v.push_back(1);
a--;
cnt = 2;
while (1) {
if (a >= cnt * 2 + 1) {
v.push_back(cnt);
a -= cnt;
cnt++;
} else {
v.push_back(a);
break;
}
}
cout << v.size() << endl;
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
struct num {
vector<long long> z;
num() { z = vector<long long>(5); }
num operator+(const num &b) const {
num c;
for (int i = 0; i < 5; ++i) {
c.z[i] = z[i] + b.z[i];
}
return c;
}
num operator-(const num &b) const {
num c;
for (int i = 0; i < 5; ++i) {
c.z[i] = z[i] - b.z[i];
}
return c;
}
num operator*(const num &b) const {
num c;
for (int i = 0; i < 5; ++i) {
for (int j = 0; j < 5; ++j) {
c.z[(i + j) % 5] += z[i] * b.z[j];
}
}
return c;
}
num shift(int w) {
num res;
for (int i = 0; i < 5; ++i) {
res.z[(i + w) % 5] = z[i];
}
return res;
}
};
long long power(long long x, long long y) {
long long res = 1;
for (; y; y >>= 1, x *= x) {
if (y & 1) {
res *= x;
}
}
return res;
}
num power(num x, int y) {
num res;
res.z[0] = 1;
for (; y; y >>= 1, x = x * x) {
if (y & 1) {
res = res * x;
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<num> a(N);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
++a[x].z[0];
}
vector<num> temp(10);
int base[5];
base[0] = 1;
for (int i = 1; i < 5; i++) base[i] = 10 * base[i - 1];
function<void(bool)> dft = [&](bool idft) {
for (int i = 0; i < 5; i++) {
for (int k = 0; k < N; k++) {
if ((k / base[i]) % 10 == 0) {
fill(temp.begin(), temp.end(), num());
for (int u = 0; u < 10; u++) {
for (int v = 0; v < 10; v++) {
int w = u * v % 10;
if (idft) w = 10 - w;
if (w & 1)
temp[u] = temp[u] - a[k + v * base[i]].shift(w + 5 >> 1);
else
temp[u] = temp[u] + a[k + v * base[i]].shift(w >> 1);
}
}
for (int u = 0; u < 10; u++) a[k + u * base[i]] = temp[u];
}
}
}
};
dft(false);
for (int i = 0; i < N; ++i) {
a[i] = power(a[i], n);
}
dft(true);
long long inv = power(3125, LLONG_MAX);
for (int i = 0; i < n; ++i) {
cout << ((a[i].z[0] - a[i].z[1] >> 5) * inv & (1ll << 58) - 1) << "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int cnt = 0;
int cnt2 = 1;
vector<int> v;
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
cnt++;
v.push_back(cnt2);
cnt2 = 1;
} else
cnt2++;
}
v.push_back(cnt2);
cout << cnt << "\n";
for (int i = 1; i < v.size(); i++) cout << v[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 500;
const long long mod = 1e9 + 7;
const long double eps = 0.0000000000001;
int fi[N], la[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
int n, k;
cin >> n >> k;
for (int i = 0; i <= n; i++) {
fi[i] = 2e9;
la[i] = 2e9;
}
for (int i = 0; i < k; i++) {
int x;
cin >> x;
if (fi[x] == 2e9) fi[x] = i;
la[x] = i;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (i > 1) {
if (fi[i] > la[i - 1] || la[i - 1] == 2e9) ans++;
}
if (i < n) {
if (fi[i] > la[i + 1] || la[i + 1] == 2e9) ans++;
}
if (fi[i] == 2e9) ans++;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9e18L;
const long long mod = 1e9 + 7;
long long power(long long x, long long y) {
long long res = 1;
int mod = 1e9 + 7;
while (y > 0) {
if (y & 1) (res = res * x) %= mod;
(x = x * x) %= mod;
y = y >> 1;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = s.size();
if (n <= 2) {
cout << s << '\n';
return 0;
}
int cnt = 1;
vector<pair<char, long long>> v;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1])
cnt++;
else {
v.push_back({s[i - 1], cnt});
cnt = 1;
}
}
v.push_back({s[n - 1], cnt});
int m = v.size();
for (int i = 1; i < m; i++) {
if (v[i].second >= 2 && v[i - 1].second >= 2) {
v[i].second = 1;
v[i - 1].second = 2;
}
if (v[i].second > 2) v[i].second = 2;
}
string res = "";
for (auto x : v) {
long long k = min(x.second, 2LL);
while (k--) res += x.first;
}
cout << res << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N, M;
cin >> N >> M;
vector<vector<int>> A(N, vector<int>(M)), Prefix(N, vector<int>(M));
vector<vector<long long>> DP(N, vector<long long>(M, -999999999));
for (int x = 0; x < N; x++) {
for (int i = 0; i < M; i++) {
cin >> A[x][i];
if (i) Prefix[x][i] = Prefix[x][i - 1];
Prefix[x][i] += A[x][i];
}
}
for (int x = 0; x < M; x++) DP[0][x] = Prefix[0][x];
for (int x = 1; x < N; x++) {
if (x & 1) {
long long maxi = -999999999;
for (int i = M - 1; i > 0; i--) {
maxi = max(maxi, DP[x - 1][i]);
DP[x][i - 1] = Prefix[x][i - 1] + maxi;
}
} else {
long long maxi = -999999999;
for (int i = 0; i < M - 1; i++) {
maxi = max(maxi, DP[x - 1][i]);
DP[x][i + 1] = Prefix[x][i + 1] + maxi;
}
}
}
long long maxi = -999999999;
for (int x = 0; x < M; x++) maxi = max(maxi, DP[N - 1][x]);
cout << maxi << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1 &a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 100000;
struct Input {
string s;
bool read() { return getline(cin, s) && ((int)(s).size()); }
void init(const Input &input) { *this = input; }
};
struct Data : Input {
vector<int> ans;
void write() {
int res = 0;
for (int i = int(0); i < int(((int)(ans).size()) - 1); ++i) {
res += ans[i + 1] < ans[i];
}
cout << res << endl;
for (int i = int(0); i < int(((int)(ans).size())); ++i) {
if (i) {
printf(" ");
}
printf("%d", ans[i] + 1);
}
puts("");
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
int n;
int t[N];
deque<pair<int, int> > a[2][2];
int go[N];
void solve() {
n = ((int)(s).size());
memset(go, -1, sizeof go);
for (int i = int(0); i < int(n); ++i) {
t[i] = (s[i] == 'L');
}
for (int i = int(0); i < int(n); ++i) {
bool ok = 0;
for (int q = int(0); q < int(2); ++q) {
if (((int)(a[q][!t[i]]).size())) {
go[a[q][!t[i]].back().second] = i;
a[q][t[i]].push_back(make_pair(a[q][!t[i]].back().first, i));
a[q][!t[i]].pop_back();
ok = 1;
break;
}
}
if (!ok) {
a[t[i]][t[i]].push_back(make_pair(i, i));
}
}
while (((int)(a[0][0]).size()) + ((int)(a[0][1]).size()) +
((int)(a[1][0]).size()) + ((int)(a[1][1]).size()) >
1) {
;
;
bool ok = 0;
for (int x = int(0); x < int(2); ++x) {
for (int y = int(0); y < int(2); ++y) {
for (int z = int(0); z < int(2); ++z) {
if (((int)(a[x][y]).size()) && ((int)(a[!y][z]).size()) &&
(make_pair(x, y) != pair<int, int>(!y, z) ||
((int)(a[x][y]).size()) >= 2)) {
go[a[x][y].front().second] = a[!y][z].back().first;
int st = a[x][y].front().first;
int fn = a[!y][z].back().second;
a[x][y].pop_front();
a[!y][z].pop_back();
a[x][z].push_back(make_pair(st, fn));
ok = 1;
}
}
}
}
if (ok) {
;
continue;
};
deque<pair<int, int> > &p = a[0][1];
deque<pair<int, int> > &q = a[1][0];
int x = p.back().first, y = p.back().second;
int z = q.back().first, w = q.back().second;
p.pop_back();
q.pop_back();
if (x > z) {
swap(x, z);
swap(y, w);
}
int f = go[x];
go[x] = z;
a[t[x]][t[w]].push_back(make_pair(x, w));
a[t[f]][t[y]].push_back(make_pair(f, y));
;
};
;
;
;
int st = -1;
for (int x = int(0); x < int(2); ++x) {
for (int y = int(0); y < int(2); ++y) {
if (((int)(a[x][y]).size())) {
st = a[x][y].back().first;
}
}
}
while (st != -1) {
;
ans.push_back(st);
st = go[st];
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long prime = 1e9 + 7;
int main() {
int n;
bool flag = false;
cin >> n;
long long a[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
flag = false;
if (a[i][j] != 1) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < n; l++) {
if (a[i][l] + a[k][j] == a[i][j]) {
flag = true;
break;
}
}
if (flag) {
break;
}
}
if (!flag) {
cout << "No";
return 0;
}
}
}
}
cout << "Yes";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int len = 2e5 + 5;
const long long inf = 1e16;
pair<long long, int> tree[4 * len];
long long lazy[4 * len], pref[len], arr[len];
vector<pair<long long, int> > vec;
void build(int p, int l, int r) {
if (l == r)
tree[p] = make_pair(pref[l], l);
else {
int mid = (l + r) / 2;
build(2 * p, l, mid);
build(2 * p + 1, mid + 1, r);
tree[p] = max(tree[2 * p], tree[2 * p + 1]);
}
}
void prop(int p, int l, int r) {
if (lazy[p] == 0) return;
tree[p].first += lazy[p];
if (l != r) {
lazy[2 * p] += lazy[p];
lazy[2 * p + 1] += lazy[p];
}
lazy[p] = 0;
}
void update(int p, int l, int r, int i, int j, long long v) {
prop(p, l, r);
if (i <= l && r <= j)
lazy[p] += v;
else {
int mid = (l + r) / 2;
if (i <= mid) update(2 * p, l, mid, i, j, v);
if (j > mid) update(2 * p + 1, mid + 1, r, i, j, v);
prop(2 * p, l, mid), prop(2 * p + 1, mid + 1, r);
tree[p] = max(tree[2 * p], tree[2 * p + 1]);
}
}
pair<long long, int> query(int p, int l, int r, int i, int j) {
prop(p, l, r);
if (i <= l && r <= j) return tree[p];
pair<long long, int> ans = make_pair(-inf, 0);
int mid = (l + r) / 2;
if (i <= mid) ans = max(ans, query(2 * p, l, mid, i, j));
if (j > mid) ans = max(ans, query(2 * p + 1, mid + 1, r, i, j));
return ans;
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &arr[i]);
for (int i = 1; i <= n; i++) pref[i] = arr[i] + pref[i - 1];
for (int i = n; i >= 1; i--) pref[i] = pref[i] - 2 * pref[i - 1];
build(1, 1, n);
while (q--) {
int i;
long long v;
scanf("%d %lld", &i, &v);
v = v - arr[i];
arr[i] += v;
update(1, 1, n, i, i, v);
if (i < n) update(1, 1, n, i + 1, n, -v);
pair<long long, int> cur;
while (cur = query(1, 1, n, 1, n), cur.first > 0) {
vec.push_back(cur);
update(1, 1, n, cur.second, cur.second, -cur.first - 1);
}
if (cur.first == 0)
printf("%d\n", cur.second);
else
printf("-1\n");
while (!vec.empty()) {
cur = vec.back();
vec.pop_back();
update(1, 1, n, cur.second, cur.second, cur.first + 1);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, C = 500000, inf = 1 << 30;
int n, m, cnt = 1, cnt1, G[N];
struct iedge {
int nx, t, f;
} E[N << 1];
int S, T;
int a[N], b[N], c[N], l[N], r[N];
int p[55][210];
inline int f(int x, int y) { return a[x] * y * y + b[x] * y + c[x]; }
inline void addedge(int x, int y, int f) {
E[++cnt].t = y;
E[cnt].nx = G[x];
E[cnt].f = f;
G[x] = cnt;
E[++cnt].t = x;
E[cnt].nx = G[y];
E[cnt].f = 0;
G[y] = cnt;
}
int dis[N];
queue<int> Q;
inline bool bfs() {
while (!Q.empty()) Q.pop();
memset(dis, -1, sizeof(dis));
dis[S] = 0;
Q.push(S);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = G[x]; i; i = E[i].nx)
if (E[i].f && dis[E[i].t] == -1) {
dis[E[i].t] = dis[x] + 1;
Q.push(E[i].t);
if (E[i].t == T) return true;
}
}
return false;
}
int cur[N];
int dfs(int x, int f) {
if (x == T || !f) return f;
int used = 0, w;
for (int i = G[x]; i; i = E[i].nx)
if (E[i].f && dis[E[i].t] == dis[x] + 1) {
w = dfs(E[i].t, min(E[i].f, f - used));
E[i].f -= w;
E[i ^ 1].f += w;
if ((used += w) == f) return f;
}
return used;
}
int main() {
scanf("%d%d", &n, &m);
T = n * 210;
for (int i = 1; i <= n; i++) scanf("%d%d%d", a + i, b + i, c + i);
for (int i = 1; i <= n; i++) {
scanf("%d%d", l + i, r + i);
for (int j = l[i]; j <= r[i]; j++) p[i][j + 100] = ++cnt1;
addedge(S, p[i][l[i] + 100], C - f(i, l[i]));
for (int j = l[i]; j < r[i]; j++)
addedge(p[i][j + 100], p[i][j + 101], C - f(i, j + 1));
addedge(p[i][r[i] + 100], T, inf);
}
for (int i = 1, u, v, d; i <= m; i++) {
scanf("%d%d%d", &u, &v, &d);
for (int j = l[v]; j <= r[v]; j++) {
if (j + d > r[u]) continue;
if (j + d >= l[u])
addedge(p[u][j + d + 100], p[v][j + 100], inf);
else
addedge(S, p[v][j + 100], inf);
}
}
int ans = 0;
while (bfs()) memcpy(cur, G, sizeof(cur)), ans += dfs(S, inf);
printf("%d\n", n * C - ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
long long rows, cols;
scanf("%lld", &rows);
while (rows--) {
long long sub_p = 0, sub_unp = 0, max_p = 0, max_unp = 0, sum = 0;
long long num[2] = {0, 0};
scanf("%lld", &cols);
scanf("%lld", &num[1]);
for (; cols > 0; cols--) {
num[0] = num[1];
if (cols > 1) scanf("%d", &num[1]);
;
sub_p = num[1] - num[0] + (sub_p > 0 ? sub_p : 0);
max_p = (sub_p > max_p ? sub_p : max_p);
sum += num[0];
cols--;
num[0] = num[1];
if (cols > 1) scanf("%d", &num[1]);
;
sub_unp = num[0] - num[1] + (sub_unp > 0 ? sub_unp : 0);
max_unp = (sub_unp > max_unp ? sub_unp : max_unp);
}
printf("%lld\n", sum + (max_p > max_unp ? max_p : max_unp));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
long long int t;
bool flag;
long long int n, m, i, j, k, temp;
vector<long long int> nums, vec;
long long int count = 0;
string s;
map<long long int, long long int> mapp;
cin >> n;
count = 0;
long long int count_2 = 0;
for (i = 0; i < n; i++) {
cin >> temp, nums.push_back(temp);
mapp[temp]++;
if (mapp[temp] == 4) {
count++;
count_2--;
}
if (mapp[temp] == 2) count_2++;
if (mapp[temp] > 4) {
if (mapp[temp] % 2 == 0) count_2++;
}
}
char c;
cin >> t;
long long int x;
while (t--) {
cin >> c;
cin >> x;
if (c == '+') {
mapp[x]++;
if (mapp[x] == 4) {
count++;
count_2--;
}
if (mapp[x] == 2) count_2++;
if (mapp[x] > 4) {
if (mapp[x] % 2 == 0) count_2++;
}
if (count < 1)
cout << "NO" << endl;
else if (count > 1)
cout << "YES" << endl;
else if (count_2 > 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else {
mapp[x]--;
if (mapp[x] + 1 == 4) {
count--;
count_2++;
}
if (mapp[x] + 1 == 2) count_2--;
if (mapp[x] + 1 > 4) {
if (mapp[x] % 2 == 1) count_2--;
}
if (count < 1)
cout << "NO" << endl;
else if (count > 1)
cout << "YES" << endl;
else if (count_2 > 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
nums.clear();
vec.clear();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000;
struct people {
string name;
int score;
};
int main() {
int n;
cin >> n;
int x[n];
int y[n];
int ans = 0;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++) {
int ri = 0, lef = 0, up = 0, dow = 0;
for (int e = 0; e < n; e++) {
if (x[e] > x[i] && y[e] == y[i]) {
ri++;
} else if (x[e] < x[i] && y[e] == y[i]) {
lef++;
} else if (x[e] == x[i] && y[e] > y[i])
up++;
else if (x[e] == x[i] && y[e] < y[i])
dow++;
}
if (ri && dow && lef && up) ans++;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<char, int> > vec;
bool used[100100];
bool p[100100];
int n, m;
set<int> st, us;
int main() {
scanf("%d %d", &n, &m);
memset(used, false, sizeof(used));
for (int i = 0; i < m; i++) {
pair<char, int> a;
cin >> a.first >> a.second;
a.second--;
vec.push_back(a);
}
for (int i = 0; i < m; i++) {
if (!used[vec[i].second]) {
if (vec[i].first == '-')
st.insert(vec[i].second);
else
us.insert(vec[i].second);
used[vec[i].second] = true;
}
}
set<int>::iterator it;
if (st.size() > 0) {
memset(p, false, sizeof(p));
for (int i = 0; i < n; i++)
if (!used[i]) p[i] = true;
for (it = st.begin(); it != st.end(); it++) p[*it] = true;
} else
memset(p, true, sizeof(p));
for (int i = 0; i < m; i++) {
char c = vec[i].first;
int id = vec[i].second;
if (c == '-') {
st.erase(id);
if (st.size() > 0) p[id] = false;
if (p[id]) us.insert(id);
} else {
set<int>::iterator it = us.find(id);
if (it != us.end()) us.erase(it);
for (it = us.begin(); it != us.end(); it++) p[*it] = false;
st.insert(id);
us.clear();
}
}
int ans = 0;
for (int i = 0; i < n; i++)
if (p[i]) ans++;
printf("%d\n", ans);
if (ans == 0) return 0;
int cnt = 0;
for (int i = 0; i < n; i++)
if (p[i]) {
cnt++;
if (cnt == ans)
printf("%d\n", i + 1);
else
printf("%d ", i + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, avail = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p >> q;
if (p + 2 <= q) avail++;
}
cout << avail;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 2005;
const double eps = 1e-8;
char mat[maxn][maxn];
vector<int> cnt[maxn];
int main() {
string ans = "YES";
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> mat[i][j];
if (mat[i][j] == '1') cnt[j].push_back(i);
}
int vis[maxn] = {};
for (int i = 1; i <= m; i++) {
if (cnt[i].size() != 1) continue;
for (int j = 0; j < cnt[i].size(); j++) vis[cnt[i][j]] = 1;
}
int tmp = 0;
for (int i = 1; i <= n; i++)
if (vis[i]) tmp++;
if (tmp == n) ans = "NO";
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > v(n);
int sumL = 0, sumR = 0;
for (int i = 0; i < n; ++i) {
cin >> v[i].first >> v[i].second;
sumL += v[i].first;
sumR += v[i].second;
}
int prevBeauty = abs(sumL - sumR), beautyIndex = -1;
for (int i = 0; i < n; ++i) {
if (abs(sumL - v[i].first + v[i].second - sumR + v[i].second - v[i].first) >
prevBeauty) {
prevBeauty = abs(sumL - v[i].first + v[i].second - sumR + v[i].second -
v[i].first);
beautyIndex = i;
}
}
cout << beautyIndex + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
int a[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};
int c1 = 0;
for (i = 0; i < 16; i++) {
if (a[i] == n && a[i + 1] == m) {
c1 = 1;
}
}
if (c1 == 1) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T SQR(T x) {
return x * x;
}
template <typename T>
inline T MIN(T x, T y) {
return (x < y) ? x : y;
}
template <typename T>
inline T MAX(T x, T y) {
return (x > y) ? x : y;
}
template <typename T>
inline void UPDATE_MIN(T& x, T y) {
if (y < x) {
x = y;
}
}
template <typename T>
inline void UPDATE_MAX(T& x, T y) {
if (x < y) {
x = y;
}
}
template <typename T>
inline int ARGMAX(T cont) {
return max_element(cont.begin(), cont.end()) - cont.begin();
}
template <typename T>
inline int ARGMIN(T cont) {
return min_element(cont.begin(), cont.end()) - cont.begin();
}
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
template <typename T, typename... Args>
inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (__typeof(n - 1) i = (0), __tmpvar__end60 = (n - 1); i < __tmpvar__end60;
i++)
s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
template <class T>
inline string TOSTR(const T& x) {
stringstream ss;
ss << x;
return ss.str();
}
inline int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
inline long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
inline long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
struct pairhash {
template <typename T, typename U>
std::size_t operator()(const std::pair<T, U>& x) const {
return std::hash<T>()(x.first) ^ std::hash<U>()(x.second);
}
};
template <typename K, typename V>
V GetWithDef(const std::unordered_map<K, V>& m, const K& key, const V& defval) {
auto it = m.find(key);
return (it == m.end()) ? defval : it->second;
}
template <typename K, typename V>
void SetDef(std::unordered_map<K, V>& m, const K& key, const V& defval) {
auto it = m.find(key);
if (it == m.end()) m[key] = defval;
}
const int MOD = 1000 * 1000 * 1000 + 7;
const double PI = 3.1415926535897932384626433832795l;
int N, M;
int dist_sum[200123] = {};
int dist[200123] = {};
int cnt[200123] = {};
int curcnt[200123] = {};
long long ans = -31337;
long long onedist = -1;
long long different_distances = 0;
void die() {
cout << -1 << endl;
exit(0);
}
void copy() {
for (__typeof(N) i = (0), __tmpvar__end160 = (N); i < __tmpvar__end160; i++) {
curcnt[i] = cnt[i];
}
}
void add_answer(long long dist) {
1;
if (ans == -31337) {
ans = dist;
} else if (ans != dist) {
die();
}
}
void add_dist(long long dist) {
1;
if (onedist == -1)
onedist = dist;
else if (onedist != dist)
different_distances = 1;
}
void check(int start, int dx, int pathlen, long long resdist) {
copy();
1;
int pos = start;
for (__typeof(pathlen) i = (0), __tmpvar__end181 = (pathlen);
i < __tmpvar__end181; i++) {
if (curcnt[pos] <= 0) return;
curcnt[pos]--;
if (pos == 0) dx = 1;
if (pos == N - 1) dx = -1;
if (i != pathlen - 1) {
if (dx == 1) {
resdist += dist[pos];
} else {
resdist += dist[pos - 1];
}
pos += dx;
}
}
1;
add_answer(resdist);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
int base_dist;
cin >> base_dist;
dist_sum[0] = 0;
for (__typeof(N) i = (1), __tmpvar__end207 = (N); i < __tmpvar__end207; i++) {
cin >> dist_sum[i];
dist_sum[i] -= base_dist;
dist[i - 1] = dist_sum[i] - dist_sum[i - 1];
add_dist(dist[i - 1]);
}
long long pathlen = 0;
cin >> M;
for (__typeof(M) i = (0), __tmpvar__end219 = (M); i < __tmpvar__end219; i++) {
int pos;
cin >> pos;
cnt[pos - 1]++;
pathlen++;
}
for (__typeof(N) i = (0), __tmpvar__end225 = (N); i < __tmpvar__end225; i++) {
1;
}
int nlaps = pathlen / (2 * N - 2);
int all_zero = 1;
int all_one = 1;
for (__typeof(N) i = (0), __tmpvar__end229 = (N); i < __tmpvar__end229; i++) {
if (i == 0 || i == N - 1)
cnt[i] -= nlaps;
else
cnt[i] -= nlaps * 2;
all_zero &= (cnt[i] == 0);
all_one &= (cnt[i] == 1);
}
pathlen -= nlaps * (2 * N - 2);
1;
long long pathdist = nlaps * 1ll * dist_sum[N - 1] * 2ll;
if (all_zero) {
if (different_distances) die();
cout << (pathdist - dist[0]) << endl;
return 0;
}
if (all_one) {
cout << (pathdist + dist_sum[N - 1]) << endl;
return 0;
}
check(0, 1, pathlen, pathdist);
check(1, 1, pathlen, pathdist);
check(1, -1, pathlen, pathdist);
check(N - 1, -1, pathlen, pathdist);
check(N - 2, 1, pathlen, pathdist);
check(N - 2, -1, pathlen, pathdist);
check(N / 2, -1, pathlen, pathdist);
check(N / 2, 1, pathlen, pathdist);
int mxcnt = -1;
for (__typeof(N) i = (0), __tmpvar__end258 = (N); i < __tmpvar__end258; i++)
UPDATE_MAX(mxcnt, cnt[i]);
for (__typeof(N - 2) i = (2), __tmpvar__end261 = (N - 2);
i < __tmpvar__end261; i++) {
if (cnt[i] == mxcnt && cnt[i - 1] < cnt[i]) {
check(i, -1, pathlen, pathdist);
check(i, 1, pathlen, pathdist);
}
if (cnt[i] == mxcnt && cnt[i + 1] < cnt[i]) {
check(i, 1, pathlen, pathdist);
check(i, -1, pathlen, pathdist);
}
}
cout << ans << endl;
return 0;
}
| 8 |
/*
*User: ybw20051114
*Time: 2021.02.15 22:35:05
*/
#include <bits/stdc++.h>
using namespace std;
#ifndef use_ios11
#define use_ios11
using namespace std;
struct ins
{
int ans;
ins() { ans = 1; }
#define endl '\n'
void read()
{
}
void read1(char &s)
{
char c = getchar();
for (; !isprint(c) || c == ' ' || c == '\n' || c == '\t'; c = getchar())
;
s = c;
if (c == EOF)
ans = 0;
}
void read1(string &s)
{
s = "";
char c = getchar();
for (; !isprint(c) || c == ' ' || c == '\n' || c == '\t'; c = getchar())
;
for (; isprint(c) && c != ' ' && c != '\n' && c != '\t'; c = getchar())
s += c;
if (c == EOF)
ans = 0;
}
template <typename T>
void read1(T &n)
{
T x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
{
if (c == '-')
f = -1;
if (c == EOF)
{
ans = 0;
return;
}
}
for (; isdigit(c); c = getchar())
x = x * 10 + c - 48;
n = x * f;
if (c == EOF)
ans = 0;
if (c != '.')
return;
T l = 0.1;
while ((c = getchar()) <= '9' && c >= '0')
x = x + (c & 15) * l, l *= 0.1;
n = x * f;
if (c == EOF)
ans = 0;
}
void write() {}
void write1(string s)
{
int n = s.size();
for (int i = 0; i < n; i++)
putchar(s[i]);
}
void write1(const char *s)
{
int n = strlen(s);
for (int i = 0; i < n; i++)
putchar(s[i]);
}
void write1(char s) { putchar(s); }
void write1(float s, int x = 6)
{
char y[10001];
sprintf(y, "%%.%df", x);
printf(y, s);
}
void write1(double s, int x = 6)
{
char y[10001];
sprintf(y, "%%.%dlf", x);
printf(y, s);
}
void write1(long double s, int x = 6)
{
char y[10001];
sprintf(y, "%%.%dLf", x);
printf(y, s);
}
template <typename T>
void write1(T n)
{
if (n < 0)
n = -n, putchar('-');
if (n > 9)
write1(n / 10);
putchar('0' + n % 10);
}
template <typename T>
friend ins operator>>(ins x, T &n);
template <typename T>
friend ins operator<<(ins x, T n);
operator bool() { return ans; }
};
template <typename T>
ins operator>>(ins x, T &n)
{
if (!x.ans)
return x;
x.read1(n);
return x;
}
template <typename T>
ins operator<<(ins x, T n)
{
x.write1(n);
return x;
}
ins yin;
ins yout;
#endif
#define int long long
vector<pair<int,int>> a;
int n1,n2,n3,n4;
const int maxn = 3e5 + 10;
int aa[maxn];
int b[maxn];
int c[maxn];
int d[maxn];
struct sgt
{
int a[maxn];
struct pos{int sum;}x[maxn<<2];
void pushup(int p){x[p].sum=min(x[p<<1].sum,x[p<<1|1].sum);}
void build(int p,int l,int r)
{
if(l==r)
x[p].sum=a[l];
else
{
int mid=(l+r)>>1;
build(p<<1,l,mid);
build(p<<1|1,mid+1,r);
pushup(p);
}
}
void mo(int p,int l,int r,int ll,int d)
{
if(l==r)
{
x[p].sum=d;
return ;
}
int mid=(l+r)>>1;
if(mid>=ll)mo(p<<1,l,mid,ll,d);
else mo(p<<1|1,mid+1,r,ll,d);
pushup(p);
}
} x;
void solve()
{
int m=0;
vector<int> a[maxn];
yin >> m;
for(int i=1;i<=m;i++)
{
int x=0,y=0;
yin>>x>>y;
a[y].push_back(x);
}
memset(x.a, 0, sizeof(x.a));
memset(x.x, 0, sizeof(x.x));
for(int i=1;i<=n1;i++)
x.mo(1, 1, n1, i, aa[i]);
int j = 0;
for(int i=1;i<=n2;i++)
{
for(auto xx:a[i])
x.mo(1, 1, n1, xx, INT_MAX);
b[i]=x.x[1].sum+b[i];
for(auto xx:a[i])
x.mo(1, 1, n1, xx, aa[xx]);
}
}
signed main()
{
yin>>n1>>n2>>n3>>n4;
for(int i=1;i<=n1;i++)
yin>>aa[i];
for(int i=1;i<=n2;i++)yin>>b[i];
for(int i=1;i<=n3;i++)yin>>c[i];
for(int i=1;i<=n4;i++)yin>>d[i];
solve();
n1=n2;
n2=n3;
for(int i=1;i<=n1;i++)aa[i]=b[i];
for(int i=1;i<=n2;i++)
b[i] = c[i];
solve();
n1=n3;
n2=n4;
for(int i=1;i<=n1;i++)
aa[i] = b[i];
for(int i=1;i<=n2;i++)
b[i] = d[i];
solve();
long long ans=INT_MAX;
for(int i=1;i<=n4;i++)ans=min(ans,(long long)b[i]);
if(ans>=INT_MAX)puts("-1");
else
yout << ans << endl;
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
vector<int> x, y;
for (int i = 1; i <= 2 * n; i++) {
int xx, yy;
cin >> xx >> yy;
if (xx == 0) y.push_back(abs(yy));
else x.push_back(abs(xx));
}
assert(x.size() == n);
sort(x.begin(), x.end());
sort(y.begin(), y.end());
double res = 0;
for (int i = 0; i < n; i++) {
res += sqrt(1ll * x[i] * x[i] + 1ll * y[i] * y[i]);
}
cout << fixed << setprecision(10) << res << '\n';
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
typedef int arr32[40100];
typedef long long arr64[40100];
struct str {
int x, y;
} dot[40100];
arr32 nex, pas, mark, val, line;
arr64 sum;
long long ans;
int n, m, q, p;
bool cmp(const str &a, const str &b) { return (a.x < b.x); }
int main() {
scanf("%d %d %d %d", &n, &m, &p, &q);
for (int i = 1; i <= p; i++) {
scanf("%d %d", &dot[i].x, &dot[i].y);
}
sort(dot + 1, dot + p + 1, cmp);
int bg = 1;
for (int U = 1; U <= n; U++) {
for (; bg <= p && dot[bg].x < U; bg++)
;
memset(mark, 0, sizeof(mark));
memset(val, 0, sizeof(val));
nex[0] = m + 1;
pas[m + 1] = 0;
for (int u = bg; u <= p; u++) mark[dot[u].y] = 1;
for (int i = 1; i <= m; i++) {
if (!mark[i]) continue;
nex[i] = m + 1;
pas[i] = pas[m + 1];
pas[nex[i]] = i;
nex[pas[i]] = i;
}
for (int u = bg; u <= p; u++) val[dot[u].y]++;
int ed = p;
int top = 0;
for (int D = n; D >= U; D--) {
for (; ed >= bg && dot[ed].x == D; ed--) {
int R = dot[ed].y, L = dot[ed].y;
int js = 0;
for (; L > 0 && js < q; L = pas[L]) js += val[L];
for (int tims = 0; tims <= q && R <= m; R = nex[R], tims++) {
for (; js > q && L < dot[ed].y; L = nex[L]) js -= val[nex[L]];
if (js == q && L < dot[ed].y) {
line[++top] = D;
sum[top] = (long long)(nex[R] - R) * (long long)(nex[L] - L);
}
js += val[nex[R]];
}
if (!(--val[dot[ed].y])) {
nex[pas[dot[ed].y]] = nex[dot[ed].y];
pas[nex[dot[ed].y]] = pas[dot[ed].y];
}
}
}
long long js = 0;
for (int D = U; D <= n; D++) {
for (; top > 0 && line[top] == D; top--) js += sum[top];
ans += js;
}
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long res =
2 * 4 * 3 * pow(4, n - 3) + pow(3, 2) * 4 * pow(4, n - 4) * (n - 3);
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
char str[N];
int main() {
int n;
scanf("%d", &n);
getchar();
for (int j = 0; j < n; j++) {
scanf("%s", &str);
int a = 0, b = 0;
for (int i = 0; str[i]; i++) {
if (str[i] == 'E')
a++;
else
++b;
}
if (a && b == 1)
puts("NO");
else
puts("YES");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class prob {
public:
long long time, left, right;
};
signed main() {
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
prob a[n];
for (long long i = 0; i < n; i++)
cin >> a[i].time >> a[i].left >> a[i].right;
long long inl = m;
long long inr = m;
long long flag = 0;
for (long long i = 0; i < n; i++) {
long long ran = a[0].time;
if (i != 0) ran = a[i].time - a[i - 1].time;
long long l = inl - ran;
long long r = inr + ran;
if (r < a[i].left || a[i].right < l) {
cout << "NO" << endl;
flag = 1;
break;
} else {
inl = max(l, a[i].left);
inr = min(r, a[i].right);
}
}
if (flag == 0) cout << "YES" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dx[] = {-1, 0, 1, 0};
long long dy[] = {0, -1, 0, 1};
vector<pair<long long, long long> > aux(10000);
vector<bool> vis(10000);
long long n, l, b, f;
bool call(long long x, long long len) {
if (x + len > l) return false;
long long r = x + len;
x -= b;
r += f;
for (long long i = 0; i < n; i++)
if (vis[i]) {
if (min(aux[i].second, r) > max(aux[i].first, x)) return false;
}
return true;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> l >> b >> f;
cin >> n;
for (long long i = 0; i < n; i++) {
long long t, len;
cin >> t >> len;
if (t == 1) {
vector<long long> x;
x.push_back(0);
x.push_back(l);
for (long long j = 0; j < i; j++)
if (vis[j]) x.push_back(aux[j].second + b);
sort(x.begin(), x.end());
long long st = -1;
for (auto j : x)
if (call(j, len)) {
st = j;
break;
}
cout << st << "\n";
if (st == -1) {
vis[i] = false;
continue;
}
vis[i] = true;
aux[i] = {st, st + len};
} else {
vis[i] = false;
vis[len - 1] = false;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mem[10][101], c[101][101], a[15];
long long nCr(long long n, long long r) {
if (n == r || r == 0)
return 1;
else if (c[n][r] != -1)
return c[n][r];
return c[n][r] = (nCr(n - 1, r - 1) + nCr(n - 1, r)) % 1000000007;
}
long long dp(long long cur, long long n) {
if (cur == 9) return a[cur] <= n;
long long &ret = mem[cur][n], m = cur ? n : n - 1;
if (ret != -1) return ret;
ret = 0;
for (long long i = a[cur]; i <= m; i++)
ret = (ret + (nCr(m, i) * dp(cur + 1, n - i)) % 1000000007) % 1000000007;
return ret;
}
int main() {
memset(c, -1, sizeof(c));
long long n, total = 0, ans = 0;
scanf("%lld", &n);
for (long long i = 0; i < 10; i++) scanf("%lld", a + i), total += a[i];
for (long long i = total; i <= n; i++)
memset(mem, -1, sizeof(mem)), ans = (ans + dp(0, i)) % 1000000007;
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int kef[60], sas[60];
int main() {
int n, L;
scanf("%d %d", &n, &L);
for (int i = 0; i < n; i++) scanf("%d", kef + i);
for (int i = 0; i < n; i++) scanf("%d", sas + i);
if (n == 1) {
puts("YES");
return 0;
}
int sum_kef = 0, sum_sas = 0;
for (int i = n - 1; i > 0; i--) {
kef[i] -= kef[i - 1];
sas[i] -= sas[i - 1];
sum_kef += kef[i];
sum_sas += sas[i];
}
kef[0] = L - sum_kef;
sas[0] = L - sum_sas;
for (int i = 0; i < n; i++) {
bool flag = true;
for (int j = 0; j < n; j++) {
if (kef[j] != sas[(i + j) % n]) flag = false;
}
if (flag) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
int k;
std::cin >> n;
std::cin >> k;
for (int i = 0; i < k; i++) {
if (n % 10 == 0) {
n /= 10;
} else {
n -= 1;
}
}
std::cout << n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, i;
cin >> n;
int a[n];
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n / 2; i++) cout << -1 * (a[n - i + 1]) << " ";
for (i = (n / 2) + 1; i <= n; i++) cout << a[n - i + 1] << " ";
cout << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
bool a = false;
cin >> n;
for (long long i = 1; i < n; i++) {
for (long long j = 1; j < n; j++) {
if (((n - i - j) % 3) != 0 && (i % 3) != 0 && (j % 3) != 0) {
cout << i << " " << j << " " << (n - i - j) << endl;
a = true;
break;
}
}
if (a) break;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
const long long N = 1e5 + 5;
const long long MOD = (1e9 + 7);
const long long MOD1 = 998244353;
const double PI = 3.14159265;
const int INF32 = 2e9;
const long long INF64 = 2e18;
int k;
pair<int, int> arr[4] = {{1, 1}, {1, 2}, {1, 3}, {1, 4}};
bool boo;
string s;
void KEK() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
printf("%d %d\n", arr[k].first, arr[k].second);
k++;
k %= 4;
} else {
if (boo)
printf("3 3\n");
else
printf("3 1\n");
boo ^= 1;
}
}
}
int main() { KEK(); }
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int h[100005];
long long int l[100005];
long long int r[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, i, ans = -1;
cin >> n;
for (i = 1; i <= n; i++) cin >> h[i];
l[1] = 1;
for (i = 2; i <= n; i++) l[i] = min(l[i - 1] + 1, h[i]);
r[n] = 1;
for (i = (n - 1); i >= 1; i--) r[i] = min(r[i + 1] + 1, h[i]);
for (i = 1; i <= n; i++) ans = max(ans, min(l[i], r[i]));
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void qs(int, int);
vector<pair<int, int> > a;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n;
scanf("%d", &n);
a.resize(n);
for (int i = 0; i < n; i++) {
scanf("%i", &a[i].first);
a[i].second = i;
}
qs(0, n - 1);
vector<int> t1;
vector<int> t2;
if (n % 2 == 0) {
for (int i = 0; i < n; i += 2) {
t1.push_back(a[i].second);
t2.push_back(a[i + 1].second);
}
} else {
long long m1 = 0, m2 = 0;
for (int i = 0; i < n - 2; i += 2) {
m1 += a[i].first;
m2 += a[i + 1].first;
t1.push_back(a[i].second);
t2.push_back(a[i + 1].second);
}
if (m1 > m2)
t2.push_back(a[n - 1].second);
else
t1.push_back(a[n - 1].second);
}
printf("%d\n", (int)t1.size());
for (int i = 0; i < (int)t1.size(); i++) printf("%d ", t1[i] + 1);
printf("\n%d\n", (int)t2.size());
for (int i = 0; i < (int)t2.size(); i++) printf("%d ", t2[i] + 1);
return 0;
}
void qs(int st, int fn) {
int l = st, r = fn, m = a[(l + r) / 2].first;
while (l <= r) {
while (a[l].first > m) l++;
while (a[r].first < m) r--;
if (l <= r) swap(a[l++], a[r--]);
}
if (r > st) qs(st, r);
if (l < fn) qs(l, fn);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200042;
vector<int> G[MAXN];
long long Res[MAXN], Cnt[MAXN][5], Sum[MAXN][5];
bool visited[MAXN];
int n, k;
long long dfs(int w) {
Res[w] = 0;
visited[w] = true;
long long tCnt[5], tSum[5];
for (int i = (0); i <= ((int)k - 1); ++i) {
tCnt[i] = 0;
tSum[i] = 0;
}
tCnt[0] = 1;
for (int i = (0); i <= ((int)G[w].size() - 1); ++i) {
int u = G[w][i];
if (!visited[u]) {
dfs(u);
Res[w] += Res[u];
for (int l = (0); l <= ((int)k - 1); ++l) {
for (int r = (0); r <= ((int)k - 1); ++r) {
long long val =
tSum[l] * Cnt[u][r] + tCnt[l] * Sum[u][r] + tCnt[l] * Cnt[u][r];
if (((l + r + 1) % k) != 0) {
val += (k - ((l + r + 1) % k)) * tCnt[l] * Cnt[u][r];
}
Res[w] += (val / k);
}
}
for (int j = (0); j <= ((int)k - 1); ++j) {
tCnt[(j + 1) % k] += Cnt[u][j];
tSum[(j + 1) % k] += Sum[u][j] + Cnt[u][j];
}
}
}
for (int i = (0); i <= ((int)k - 1); ++i) {
Cnt[w][i] = tCnt[i];
Sum[w][i] = tSum[i];
}
return Res[w];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = (0); i <= ((int)n - 1 - 1); ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
cout << dfs(0) << "\n";
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define foin(i, a, b) for (int i=a; i<b; i++)
long long INFLL = LLONG_MAX;
int INFI = INT_MAX;
long INFL = LONG_MAX;
void solve()
{
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
ll sum = 0;
ll maxi = 0;
foin(i, 0, n)
{ ll b; cin >> b;
sum += b;
maxi = max(maxi, b);
}
ll x = (sum + n - 2) / (n - 1);
ll h = max(maxi, x);
cout << ( h * (n - 1)) - sum << endl;
}
}
int main()
{
ios_base::sync_with_stdio(false); cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("error.txt", "w", stderr);
freopen("output.txt", "w", stdout);
#endif
solve();
cout << "\n";
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int INF = 0x3f3f3f3f;
int a[MAXN], b[MAXN], l[MAXN], r[MAXN];
queue<int> Q;
vector<int> G[MAXN];
int dis[MAXN];
bool vis[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) b[i] = a[i] & 1;
memset(dis, 0x3f, sizeof(dis));
int x;
for (int i = 1; i <= n; ++i) {
x = i + a[i];
if (x >= 1 && x <= n) {
G[x].push_back(i);
l[i] = x;
} else
l[i] = -INF;
x = i - a[i];
if (x >= 1 && x <= n) {
G[x].push_back(i);
r[i] = x;
} else
r[i] = -INF;
}
for (int i = 1; i <= n; ++i) {
if (l[i] > 0 && b[i] + b[l[i]] == 1)
dis[i] = 1;
else if (r[i] > 0 && b[i] + b[r[i]] == 1)
dis[i] = 1;
}
for (int i = 1; i <= n; ++i)
if (dis[i] == 1) Q.push(i);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto i : G[u]) {
if (!vis[i]) {
dis[i] = min(dis[i], dis[u] + 1);
Q.push(i);
}
}
}
for (int i = 1; i <= n; ++i)
printf("%d%c", dis[i] < INF ? dis[i] : -1, i == n ? '\n' : ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void mergesort(vector<int> &, int, int);
vector<long int> Num;
vector<int> A, B;
int main() {
int n;
cin >> n;
vector<int> index;
A.resize(n + 1, 0);
B.resize(n + 1, 0);
Num.push_back(0);
for (int i = 1; i <= n; i++) {
int temp;
cin >> temp;
Num.push_back(temp);
}
if (n <= 2) {
cout << "0" << endl;
return 0;
}
index.push_back(0);
for (int i = 1; i <= n; i++) {
index.push_back(i);
}
mergesort(index, 1, n);
long long int answer = 0;
for (int i = 2; i <= n - 1; i++) {
answer += (long long)A[i] * B[i];
}
cout << answer << endl;
}
void mergesort(vector<int> &index, int left, int right) {
if (right - left < 1) return;
int mid = (left + right) / 2;
mergesort(index, left, mid);
mergesort(index, mid + 1, right);
vector<int> a, b;
for (int i = left; i <= mid; i++) a.push_back(index[i]);
for (int i = mid + 1; i <= right; i++) b.push_back(index[i]);
int i = 0, j = 0, now;
for (now = left; now <= right; now++) {
if (i >= a.size()) {
index[now] = b[j];
j++;
} else if (j >= b.size()) {
A[a[i]] += b.size();
index[now] = a[i];
i++;
} else if (Num[a[i]] <= Num[b[j]]) {
A[a[i]] += j;
index[now] = a[i];
i++;
} else {
B[b[j]] += (a.size() - i);
index[now] = b[j];
j++;
}
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
char in[30][1001], out[30][30];
int t, i;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%s", in[i]);
if (in[i][strlen(in[i]) - 1] == 'o')
strcpy(out[i], "FILIPINO");
else if (in[i][strlen(in[i]) - 1] == 'u')
strcpy(out[i], "JAPANESE");
else if (in[i][strlen(in[i]) - 1] == 'a')
strcpy(out[i], "KOREAN");
}
for (i = 0; i < t; i++) printf("\n%s", out[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const N = 300000 + 10;
int a1[N], a2[N];
int s1, s2, n, p, k1, k2;
struct Node {
int id, c;
bool operator<(const Node &e) const { return c < e.c; }
} s[N], tmp[N];
int Move(int l, int r, int k) {
for (int i = r + 1; i < n; i++) s[i - k] = s[i];
return n - k;
}
bool solve(int &k, int &p, int a[N], int ss, int n) {
for (k = 1; k <= n; k++) {
p = lower_bound(s, s + n, (Node){0, (int)ceil(1.0 * ss / k)}) - s;
if (p + k - 1 < n) {
int cnt = 0;
for (int i = p; i <= p + k - 1; i++) a[++cnt] = s[i].id;
return true;
}
}
return false;
}
void Print() {
printf("Yes\n");
printf("%d %d\n", k1, k2);
for (int i = 1; i <= k1; i++) printf("%d ", a1[i]);
printf("\n");
for (int i = 1; i <= k2; i++) printf("%d ", a2[i]);
printf("\n");
}
int main() {
scanf("%d%d%d", &n, &s1, &s2);
for (int i = 0; i < n; i++) scanf("%d", &s[i].c), s[i].id = i + 1;
sort(s, s + n);
bool flag = true;
memcpy(tmp, s, sizeof(s));
bool flag1 = solve(k1, p, a1, s1, n);
int nn = Move(p, p + k1 - 1, k1);
bool flag2 = solve(k2, p, a2, s2, nn);
if (!flag1 || !flag2) {
memcpy(s, tmp, sizeof(tmp));
bool flag3 = solve(k2, p, a2, s2, n);
int nn = Move(p, p + k2 - 1, k2);
bool flag4 = solve(k1, p, a1, s1, nn);
if (!flag3 || !flag4) printf("No\n"), flag = false;
}
if (flag) Print();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, w, indx;
};
int invalid;
vector<int> visit(1005), chk(1005), height(1005), depth(1005), up(1005);
vector<edge> adj[1005];
void dfs(int node, int dest) {
chk[node] = 1;
if (node == dest) chk[node] = 2;
up[node] = -1;
for (auto x : adj[node]) {
if (x.indx == invalid) continue;
if (chk[x.v]) {
if (depth[node] < depth[x.v])
up[node]--;
else if (depth[node] > depth[x.v])
up[node]++;
continue;
}
depth[x.v] = 1 + depth[node];
dfs(x.v, dest);
up[node] += up[x.v];
chk[node] = max(chk[node], chk[x.v]);
}
}
int main() {
int i, j, k;
int n, m, s, t;
cin >> n >> m >> s >> t;
for (i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
dfs(s, t);
visit = chk;
height = depth;
if (visit[s] != 2) return puts("0\n0");
int cur = s, mn = INT_MAX;
vector<int> ans;
while (cur != t) {
for (auto x : adj[cur]) {
if (visit[x.v] == 2 && height[x.v] > height[cur]) {
invalid = x.indx;
fill(chk.begin(), chk.end(), 0);
dfs(s, t);
if (chk[s] != 2) {
if (x.w < mn) {
mn = x.w;
ans.clear();
ans.push_back(x.indx);
}
}
for (i = 1; i <= n; ++i) {
for (auto y : adj[i]) {
if (y.indx != invalid && chk[i] == 2 && chk[y.v] == 2 &&
depth[i] < depth[y.v] && up[y.v] == 0) {
if (x.w + y.w < mn) {
mn = x.w + y.w;
ans.clear();
ans.push_back(x.indx);
ans.push_back(y.indx);
}
}
}
}
invalid = 0;
cur = x.v;
break;
}
}
}
if (mn == INT_MAX) return puts("-1");
cout << mn << endl;
cout << ans.size() << endl;
for (i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
}
| 9 |
#include <bits/stdc++.h>
int main(int argc, char **args) {
int i, size, diff, *input, succ = 1;
scanf("%d", &size);
input = (int *)malloc((size - 1) * sizeof(*input));
scanf("%d", &diff);
diff = size - diff;
for (i = 0; i < size - 1; i++) {
scanf("%d", &input[i]);
if (i + 1 != (input[i] + (i % 2 ? diff : size - diff)) % size) {
succ = 0;
}
}
printf("%s\n", succ ? "Yes" : "No");
free(input);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 40;
int a[maxN][maxN];
int b[maxN][maxN];
int flips[maxN][maxN];
int n, x;
int check(int mask) {
memset(flips, 0, sizeof(flips));
for (int i = 0; i < x; ++i) {
if (mask & (1 << i)) {
flips[x - 1][i] = 1;
}
}
for (int i = 0; i + 1 < x; ++i) {
for (int j = 0; j < x; ++j) {
flips[i + x][j] = flips[i][j] ^ flips[x - 1][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j + 1 < x; ++j) {
flips[i][j + x] = flips[i][j] ^ flips[i][x - 1];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
b[i][j] = a[i][j];
if (flips[i][j]) {
b[i][j] = -b[i][j];
}
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
res += b[x - 1][i];
}
for (int i = 0; i + 1 < x; ++i) {
for (int j = 0; j < n; ++j) {
b[i][j] += b[i + x][j];
}
}
for (int i = 0; i + 1 < x; ++i) {
int cres1 = 0, cres2 = 0;
for (int j = 0; j + 1 < x; ++j) {
cres1 += abs(b[i][j] + b[i][j + x]);
cres2 += abs(b[i][j] - b[i][j + x]);
}
res += max(cres1 + b[i][x - 1], cres2 - b[i][x - 1]);
}
return res;
}
int solve(vector<vector<int> > a) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
::a[i][j] = a[i][j];
}
}
x = (n + 1) / 2;
int res = -1000000000LL;
for (int i = 0; i < (1 << x); ++i) {
res = max(res, check(i));
}
return res;
}
int getsum(const vector<vector<int> >& a) {
int ret = 0;
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < a.size(); ++j) {
ret += a[i][j];
}
}
return ret;
}
int solvebrut(vector<vector<int> > a) {
set<vector<vector<int> > > s;
int ans = getsum(a);
queue<vector<vector<int> > > q;
s.insert(a);
q.push(a);
while (!q.empty()) {
vector<vector<int> > cur = q.front();
ans = max(ans, getsum(cur));
q.pop();
for (int i = 0; i + x - 1 < n; ++i) {
for (int j = 0; j + x - 1 < n; ++j) {
vector<vector<int> > buf = cur;
for (int i1 = i; i1 < i + x; ++i1) {
for (int j1 = j; j1 < j + x; ++j1) {
buf[i1][j1] = -buf[i1][j1];
}
}
if (!s.count(buf)) {
s.insert(buf);
q.push(buf);
}
}
}
}
return ans;
}
vector<vector<int> > gen() {
n = (rand() % 3) * 2 + 1;
vector<vector<int> > a(n, vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] = rand() % 5;
if (rand()) a[i][j] = -a[i][j];
}
}
return a;
}
int main() {
scanf("%d", &n);
vector<vector<int> > a(n, vector<int>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%d", &a[i][j]);
}
}
cout << solve(a) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, syc;
long long ar[1000005], ans;
long long cnt[1000005 * 10];
bool p[1000005 * 10];
void read() {
long long t, i;
cin >> n;
for (i = 1; i <= n; i++) scanf("%I64d", ar + i), cnt[ar[i]]++;
return;
}
void init() {
for (int i = 1e7; i >= 0; i--) cnt[i] += cnt[i + 1];
}
void solve() {
long long bas, son, ort, t, sy, i, j, k;
read();
init();
sort(ar + 1, ar + n + 1);
ans = 1;
for (i = 2; i <= ar[n]; i++)
if (!p[i]) {
bas = 1;
son = 1LL << 62;
syc = 0;
for (k = i; k <= ar[n]; k *= i) {
for (j = k; j <= ar[n]; j += k, sy++) {
syc += cnt[j];
p[j] = 1;
}
}
while (bas < son) {
ort = (bas + son) / 2;
t = ort;
sy = 0;
while (t) sy += t / i, t /= i;
if (sy >= syc)
son = ort;
else
bas = ort + 1;
}
ans = ((ans) > (bas) ? (ans) : (bas));
}
cout << ans << endl;
return;
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 10;
int par[N];
pair<int, int> ed[2 * N], edg1[N], edg2[N];
bool id[N], v1[N], v2[N], flag = 0;
vector<pair<int, int> > ans;
vector<int> a[N];
long long root(long long x) {
if (par[x] == -1) return x;
return par[x] = root(par[x]);
}
void merge(long long x, long long y) {
x = root(x), y = root(y);
if (x == y) return;
par[x] = y;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
ed[i].first = u;
ed[i].second = v;
a[u].push_back(v);
a[v].push_back(u);
}
int s, e, ds, de;
cin >> s >> e >> ds >> de;
for (int i = 0; i < m; i++) {
int u, v;
u = ed[i].first;
v = ed[i].second;
if ((u == s && v == e) || (u == e && v == s)) flag = true;
}
memset(par, -1, sizeof par);
for (int i = 0; i < m; i++) {
int u = ed[i].first, v = ed[i].second;
if (u == s || u == e || v == s || v == e) continue;
if (root(u) == root(v)) continue;
merge(u, v);
ans.push_back({u, v});
}
for (int i = 1; i <= n; i++) {
if (i == s || i == e) continue;
id[root(i)] = true;
}
int cnts = 0, cnte = 0;
vector<int> t;
for (auto u : a[s]) {
v1[root(u)] = true;
edg1[root(u)] = {u, s};
}
for (auto u : a[e]) {
v2[root(u)] = true;
edg2[root(u)] = {u, e};
}
for (int i = 1; i <= n; i++) {
if (id[i]) {
if (v1[i] && !v2[i]) {
ans.push_back(edg1[i]);
cnts++;
} else if (!v1[i] && v2[i]) {
ans.push_back(edg2[i]);
cnte++;
} else if (v1[i] && v2[i])
t.push_back(i);
else {
cout << "No\n";
return 0;
}
}
}
int res1 = ds - cnts, res2 = de - cnte;
if (res1 == 0 || res2 == 0) {
cout << "No\n";
return 0;
}
if (t.size() == 0) {
if (!flag) {
cout << "No\n";
return 0;
}
ans.push_back({s, e});
cout << "Yes\n";
for (int i = 0; i < n - 1; i++) {
cout << ans[i].first << " " << ans[i].second << '\n';
}
return 0;
}
int sz = t.size();
if (res1 + res2 <= sz) {
cout << "No\n";
return 0;
}
for (int i = 0; i < min(sz, res1); i++) {
ans.push_back(edg1[t[i]]);
}
for (int i = min(sz, res1) - 1; i < sz; i++) {
ans.push_back(edg2[t[i]]);
}
cout << "Yes\n";
for (int i = 0; i < n - 1; i++)
cout << ans[i].first << " " << ans[i].second << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int k = 0;
for (int i = 0; i < s.length(); i += 2) {
if ((s[i] == '8' && t[i] == '[') || (s[i] == '[' && t[i] == '(') ||
(s[i] == '(' && t[i] == '8'))
k++;
else if ((t[i] == '8' && s[i] == '[') || (t[i] == '[' && s[i] == '(') ||
(t[i] == '(' && s[i] == '8'))
k--;
}
if (k > 0)
cout << "TEAM 1 WINS\n";
else if (k < 0)
cout << "TEAM 2 WINS\n";
else
cout << "TIE\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void prep() {
cin.tie(0);
cin.sync_with_stdio(0);
};
const int mod = (int)1e9 + 7;
const int MX = (int)2e4 + 10;
int main() {
prep();
srand(time(0));
int n;
cin >> n;
long long res = 1;
set<int> st;
int sell = (int)1e9;
int buy = 0;
while (n--) {
string s;
int x;
cin >> s >> x;
if (s == "ACCEPT") {
if (x > sell || x < buy) return puts("0"), 0;
if (x < sell && x > buy) {
res <<= 1;
res %= mod;
}
auto it = st.find(x);
assert(it != st.end());
auto prv = prev(it);
auto nxt = next(it);
buy = it != st.begin() ? *prv : 0;
sell = nxt != st.end() ? *nxt : (int)1e9;
st.erase(it);
} else {
st.insert(x);
}
}
auto lf = st.upper_bound(buy);
auto rg = st.lower_bound(sell);
int dis = distance(lf, rg);
res *= dis + 1;
cout << res % mod << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int h = -2;
for (int i = 0; i < s.size(); ++i) {
if (s[i + 1] == '/') {
for (int j = 0; j < h; ++j) {
cout << ' ';
}
cout << s[i] << s[i + 1] << s[i + 2] << s[i + 3] << '\n';
i += 3;
h -= 2;
} else {
h += 2;
for (int j = 0; j < h; ++j) {
cout << ' ';
}
cout << s[i] << s[i + 1] << s[i + 2] << '\n';
i += 2;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
string str;
cin >> n >> m;
cin >> str;
vector<char> make_pair;
for (char i = 'a'; i <= 'z'; i++) {
make_pair.push_back(i);
}
char a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
for (char i = 'a'; i <= 'z'; i++) {
if (make_pair[i - 'a'] == a) {
make_pair[i - 'a'] = b;
} else if (make_pair[i - 'a'] == b) {
make_pair[i - 'a'] = a;
}
}
}
for (int i = 0; i < str.size(); i++) {
str[i] = make_pair[str[i] - 'a'];
}
cout << str << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, x2, y1, y2, mx;
cin >> x1 >> y1 >> x2 >> y2;
mx = abs(x2 - x1);
cout << max(mx, abs(y2 - y1));
return 0;
}
| 0 |
/*
西江月·证明
即得易见平凡，仿照上例显然；留作习题答案略，读者自证不难。
反之亦然同理，推论自然成立；略去过程Q.E.D.，由上可知证毕。
*/
/*
BULB: 0.5h
result of thinking: Aided.
#(bad)网络流 #dp状态设计 #MeetInTheMiddle #FMT
start coding: 09:20
AC:
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ldouble;
template<class T> bool chmin(T &x, const T &y) {
return x > y ? (x = y, true) : false;
}
template<class T> bool chmax(T &x, const T &y) {
return x < y ? (x = y, true) : false;
}
const int inf = 0x3f3f3f3f;
int pow5[11], n, m, a[7], b[7], c[7][7], f1[1953135], f2[1953135];
bool valid(int al, int ar, int state) {
for (int i = 1; i <= m; i++) {
if (state / pow5[m - i] % 5 > b[i])
return false;
}
for (int i = al; i <= ar; i++) {
if (state / pow5[m + ar - i] % 5 > a[i])
return false;
}
return true;
}
int main() {
pow5[0] = 1;
for (int i = 1; i <= 9; i++)
pow5[i] = pow5[i - 1] * 5;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d", a + i);
for (int i = 1; i <= m; i++)
scanf("%d", b + i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &c[i][j]);
}
}
if (n <= 3) {
memset(f1, 0x3f, sizeof(f1));
f1[0] = 0;
for (int u = 1; u <= n; u++) {
for (int v = 1; v <= m; v++) {
for (int i = pow5[n + m] - 1; i >= 0; i--) {
if (!valid(1, n, i))
continue;
int maxFlow = min(a[u] - i / pow5[m + n - u] % 5,
b[v] - i / pow5[m - v] % 5);
for (int d = 1; d <= maxFlow; d++) {
chmin(f1[i + d * (pow5[m + n - u] + pow5[m - v])],
f1[i] + c[u][v]);
}
}
}
}
int ans = inf, aFULL = 0;
for (int i = 1; i <= n; i++)
aFULL += pow5[m + n - i] * a[i];
for (int i = 0; i < pow5[m]; i++) {
if (valid(1, n, i)) {
chmin(ans, f1[aFULL + i]);
}
}
printf("%d\n", ans < inf ? ans : -1);
return 0;
}
memset(f1, 0x3f, sizeof(f1));
f1[0] = 0;
for (int u = 1; u <= 3; u++) {
for (int v = 1; v <= m; v++) {
for (int i = pow5[3 + m] - 1; i >= 0; i--) {
if (!valid(1, 3, i))
continue;
int maxFlow = min(a[u] - i / pow5[3 + m - u] % 5,
b[v] - i / pow5[m - v] % 5);
for (int d = 1; d <= maxFlow; d++) {
chmin(f1[i + d * (pow5[3 + m - u] + pow5[m - v])],
f1[i] + c[u][v]);
}
}
}
}
memset(f2, 0x3f, sizeof(f2));
f2[0] = 0;
for (int u = 4; u <= n; u++) {
for (int v = 1; v <= m; v++) {
for (int i = pow5[n - 3 + m] - 1; i >= 0; i--) {
if (!valid(4, n, i))
continue;
int maxFlow = min(a[u] - i / pow5[m + n - u] % 5,
b[v] - i / pow5[m - v] % 5);
for (int d = 1; d <= maxFlow; d++) {
chmin(f2[i + d * (pow5[m + n - u] + pow5[m - v])],
f2[i] + c[u][v]);
}
}
}
}
int a1FULL = 0, a2FULL = 0, bFULL = 0, ans = inf;
for (int i = 1; i <= 3; i++)
a1FULL += a[i] * pow5[3 + m - i];
for (int i = 4; i <= n; i++)
a2FULL += a[i] * pow5[n + m - i];
for (int i = 1; i <= m; i++)
bFULL += b[i] * pow5[m - i];
for (int i = 1; i <= m; i++) {
for (int j = 0; j < pow5[m]; j++) {
if (valid(4, n, j) && j / pow5[m - i] % 5) {
chmin(f2[a2FULL + j], f2[a2FULL + j - pow5[m - i]]);
}
}
}
for (int i = 0; i < pow5[m]; i++) {
if (valid(1, 3, i)) {
chmin(ans, f1[a1FULL + i] + f2[a2FULL + bFULL - i]);
}
}
printf("%d\n", ans < inf ? ans : -1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300500;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
int n, m;
cin >> n >> m;
string a, b;
cin >> a >> b;
int dp[n + 1][m + 1];
int ans = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else {
if (a[i - 1] == b[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 2;
} else {
dp[i][j] = max(0, max(dp[i - 1][j], dp[i][j - 1]) - 1);
}
}
ans = max(ans, dp[i][j]);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int a[100005], n, b[100005];
void solve() {
bool f1, f2;
f1 = f2 = 0;
int x;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) {
x = b[i];
if (x < a[i]) {
if (!f2) {
cout << "NO\n";
return;
}
} else if (x > a[i]) {
if (!f1) {
cout << "NO\n";
return;
}
}
if (a[i] == -1) {
f2 = 1;
} else if (a[i] == 1)
f1 = 1;
}
cout << "YES\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
uint64_t rnd_data = 0xDEADBEEFDULL;
inline void my_srand(int seed) { rnd_data = ((uint64_t)seed << 16) | 0x330E; }
inline int my_rand() {
rnd_data = rnd_data * 0x5DEECE66DULL + 0xB;
return (rnd_data >> 17) & 0x7FFFFFFF;
}
template <typename T>
void my_random_shuffle(T b, T e) {
for (int i = (1); i <= (int)((int)(e - b) - 1); i++) {
swap(b[i], b[my_rand() % (i + 1)]);
}
}
template <class _T>
inline _T sqr(const _T &x) {
return x * x;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uin(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(b, a) ? a = b, true : false;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uax(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(a, b) ? a = b, true : false;
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
int n, m, k;
deque<int> a[320][320];
int c0[320][320];
deque<int> b[320][320];
char s[102400];
int ans[102400 * 4][4];
inline void pa() {
return;
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) {
for (int t = 0; t < (int)(a[i][j].size()); t++) {
cerr << a[i][j][t];
}
cerr << " ";
}
cerr << endl;
}
cerr << endl;
}
void mv(int x1, int y1, int x2, int y2) {
if (x1 == x2 && y1 == y2) return;
ans[k][0] = x1;
ans[k][1] = y1;
ans[k][2] = x2;
ans[k][3] = y2;
k++;
assert(!a[x1][y1].empty());
int c = a[x1][y1].back();
a[x1][y1].pop_back();
a[x2][y2].push_front(c);
}
int main() {
k = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) {
scanf("%s", s);
int l = strlen(s);
c0[i][j] = l;
for (int t = 0; t < (int)(l); t++) {
a[i][j].push_back(s[t] - '0');
}
}
}
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) {
scanf("%s", s);
int l = strlen(s);
for (int t = 0; t < (int)(l); t++) {
b[i][j].push_back(s[t] - '0');
}
}
}
pa();
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) {
for (int t = 0; t < (int)(c0[i][j]); t++) {
int c = a[i][j].back();
if (c == 0) {
if (i == 0) {
mv(i, j, i, (j + 1) % m);
} else {
mv(i, j, 0, j);
}
} else {
if (i == 1) {
mv(i, j, i, (j + 1) % m);
} else {
mv(i, j, 1, j);
}
}
}
}
}
pa();
for (int j = 0; j < (int)(m); j++) {
if (j == 0) continue;
while (!a[0][j].empty()) {
mv(0, j, 0, 0);
}
}
for (int j = 0; j < (int)(m); j++) {
if (j == 1) continue;
while (!a[1][j].empty()) {
mv(1, j, 1, 1);
}
}
pa();
for (int i = (n - 1); i >= (int)(2); i--) {
for (int j = (m)-1; j >= 0; j--) {
for (int t = (b[i][j].size()) - 1; t >= 0; t--) {
int c = b[i][j][t];
if (c == 0) {
mv(0, 0, 0, j);
mv(0, j, i, j);
} else {
mv(1, 1, 1, j);
mv(1, j, i, j);
}
}
}
}
for (int i = (2) - 1; i >= 0; i--) {
for (int j = (m - 1); j >= (int)(2); j--) {
for (int t = (b[i][j].size()) - 1; t >= 0; t--) {
int c = b[i][j][t];
if (c == 0) {
mv(0, 0, i, 0);
mv(i, 0, i, j);
} else {
mv(1, 1, i, 1);
mv(i, 1, i, j);
}
}
}
}
pa();
int need101 = 0;
for (int t = 0; t < (int)(b[0][0].size()); t++) {
need101 += b[0][0][t] == 1;
}
for (int t = 0; t < (int)(b[1][1].size()); t++) {
need101 += b[1][1][t] == 1;
}
int need010 = 0;
for (int t = 0; t < (int)(b[0][0].size()); t++) {
need010 += b[0][0][t] == 0;
}
for (int t = 0; t < (int)(b[1][1].size()); t++) {
need010 += b[1][1][t] == 0;
}
for (int t = 0; t < (int)(need101); t++) {
mv(1, 1, 1, 0);
}
for (int t = 0; t < (int)(need010); t++) {
mv(0, 0, 0, 1);
}
pa();
for (int i = 0; i < (int)(2); i++) {
for (int j = 0; j < (int)(2); j++) {
for (int t = (b[i][j].size()) - 1; t >= 0; t--) {
int c = b[i][j][t];
if (c == 0) {
int x = i, y = j;
if (x)
x = 0;
else
y ^= 1;
mv(x, y, i, j);
} else {
int x = i, y = j;
if (!x)
x = 1;
else
y ^= 1;
mv(x, y, i, j);
}
pa();
}
}
}
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) {
assert(a[i][j] == b[i][j]);
}
}
printf("%d\n", k);
for (int i = 0; i < (int)(k); i++) {
for (int j = 0; j < (int)(4); j++) {
printf("%d%c", ans[i][j] + 1, " \n"[j == 3]);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[3000];
void bfs(int d[], int s) {
queue<int> q;
fill_n(d, 3000, (1 << 20));
q.push(s);
d[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < (int)(edge[u].size()); i++) {
int v = edge[u][i];
if (d[v] == (1 << 20)) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
}
int dist[3000][3000];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(m); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
int s1, t1, l1, s2, t2, l2;
int ans = -1;
cin >> s1 >> t1 >> l1 >> s2 >> t2 >> l2;
s1--;
t1--;
s2--;
t2--;
for (int i = 0; i < (int)(n); i++) {
bfs(dist[i], i);
}
if (dist[s1][t1] <= l1 && dist[s2][t2] <= l2) {
ans = max(0, m - dist[s1][t1] - dist[s2][t2]);
}
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) {
if (dist[s1][i] + dist[i][j] + dist[j][t1] <= l1 &&
dist[s2][i] + dist[i][j] + dist[j][t2] <= l2) {
ans = max(ans, m - dist[s1][i] - dist[s2][i] - dist[i][j] -
dist[j][t1] - dist[j][t2]);
}
if (dist[s1][i] + dist[i][j] + dist[j][t1] <= l1 &&
dist[s2][j] + dist[j][i] + dist[i][t2] <= l2) {
ans = max(ans, m - dist[s1][i] - dist[s2][j] - dist[i][j] -
dist[j][t1] - dist[i][t2]);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string str1, str2;
cin >> str1 >> str2;
long long y = str1[1] - str2[1];
long long x = str2[0] - str1[0];
bool left = x > 0 ? false : true;
bool up = y > 0 ? false : true;
x = abs(x);
y = abs(y);
long long dia = min(x, y);
long long sta = max(x, y);
bool x_dir = x > y ? true : false;
cout << sta << '\n';
for (long long i = 0; i < dia; i++) {
if (left && up)
cout << "LU" << '\n';
else if (left && !up)
cout << "LD" << '\n';
else if (!left && up)
cout << "RU" << '\n';
else
cout << "RD" << '\n';
}
for (long long i = 0; i < sta - dia; i++) {
if (x_dir) {
if (left)
cout << "L" << '\n';
else
cout << "R" << '\n';
} else {
if (up)
cout << "U" << '\n';
else
cout << "D" << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v;
map<int, int> p;
map<int, int> k;
int x = 0, length = 0;
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
v.push_back(x);
}
for (int i = 0; i < m; i++) {
scanf("%d", &x);
k[i + 1] = x;
length += x;
p[i + 1] = 0;
}
for (int i = 0; i < length; i++) {
if (p.count(v[i])) {
p[v[i]]++;
} else
p[v[i]] = 1;
}
for (int i = 0; i < n - length + 1; i++) {
if (i != 0) {
p[v[i - 1]]--;
p[v[i + length - 1]]++;
}
if (p == k) {
printf("YES\n");
break;
} else if (i == n - length) {
printf("NO\n");
break;
}
}
}
| 3 |
#include <bits/stdc++.h>
int a[200000];
int main() {
int n, x;
scanf("%d%d", &n, &x);
--x;
int m = 1e9, mi;
for (int i = 0; i != n; ++i) {
scanf("%d", a + i);
if (m > a[i]) {
m = a[i];
mi = i;
} else if (m == a[i]) {
if (i <= x || mi > x) {
mi = i;
}
}
}
long long t = 1LL * m * n;
if (mi <= x) {
t += x - mi;
} else {
t += x + n - mi;
}
for (int i = 0; i != n; ++i) {
if (i == mi)
printf("%I64d ", t);
else {
if (mi <= x) {
if (i > mi && i <= x) --a[i];
} else if (i > mi || i <= x)
--a[i];
printf("%d ", a[i] - m);
}
}
putchar('\n');
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.