solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
int n, T;
long long ans1, ans2, res;
vector<pair<int, int> > v[200005];
long long dfs(int x, int fa, int cst) {
int cur = 1;
for (int(i) = (0); (i) < (v[x].size()); (i)++) {
int a = v[x][i].first, y = v[x][i].second;
if (fa == a) continue;
cur += dfs(a, x, y);
}
while (cur * 2 > res) res -= 2, cur -= 2;
ans1 += (long long)cur * cst;
return cur;
}
long long dfs2(int x, int fa, int cst) {
int cur = 1;
for (int(i) = (0); (i) < (v[x].size()); (i)++) {
int a = v[x][i].first, y = v[x][i].second;
if (fa == a) continue;
int re = dfs2(a, x, y);
if (re) ans2 += y;
cur += re;
}
cur %= 2;
return cur;
}
void solve() {
for (int(i) = (1); (i) <= (2 * n); (i)++) v[i].clear();
cin >> n;
for (int(i) = (1); (i) <= (2 * n - 1); (i)++) {
int t1, t2, t3;
cin >> t1 >> t2 >> t3;
v[t1].push_back(make_pair(t2, t3));
v[t2].push_back(make_pair(t1, t3));
}
res = 2 * n;
dfs(1, -1, 0);
dfs2(1, -1, 0);
cout << ans2 << ' ' << ans1 << '\n';
ans1 = 0;
ans2 = 0;
}
int main() {
ios::sync_with_stdio(false);
cin >> T;
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int K, pos[1000010], cnt;
long long result;
string S;
int main() {
cin >> K >> S;
S = '1' + S + '1';
for (int i = 0; i < S.size(); i++)
if (S[i] == '1') {
pos[cnt] = i;
cnt++;
}
if (cnt - 2 < K)
result = 0;
else if (!K) {
long long j = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == '0')
j++;
else {
result += j * (j + 1) / 2;
j = 0;
}
}
} else {
int left = 1, right = left + K - 1;
while (right < cnt - 1) {
result += (long long)(pos[left] - pos[left - 1]) *
(pos[right + 1] - pos[right]);
left++;
right++;
}
}
cout << result << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
double a, b, m;
cin >> a >> b >> m;
double vx, vy, vz, xn, yn, zn, t, fz, fx, dx, dz;
cin >> vx >> vy >> vz;
long long int kx, kz;
t = abs(m / vy);
dx = abs(vx * t);
dz = vz * t;
if (vx >= 0)
fx = dx + a / 2;
else
fx = a / 2 - dx;
fz = dz;
if (dx > a / 2 && vx >= 0) {
dx -= a / 2;
kx = dx / a;
fx = dx - kx * a;
if (kx % 2 == 0) fx = a - fx;
} else if (dx > a / 2 && vx < 0) {
dx -= a / 2;
kx = dx / a;
fx = dx - kx * a;
if (kx % 2 == 1) fx = a - fx;
}
kz = dz / b;
fz = dz - kz * b;
if (kz % 2 == 1) fz = b - fz;
cout << fixed << setprecision(9) << fx << " ";
cout << fixed << setprecision(9) << fz << "\n";
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 0.000000001;
const int INF = 1E9;
const int MAXN = 100;
int i, j, n, k, dp[MAXN + 10], dp2[MAXN + 10];
int g[MAXN + 10][MAXN + 10];
int main() {
cin >> k;
for (int i = (int)(1); i < (int)(MAXN + 1); i++) {
dp[i] = i * (i - 1) * (i - 2) / 6;
dp2[i] = i * (i - 1) / 2;
}
i = 1;
while (dp[i] <= k) i++;
i--;
n = i;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
if (i != j) g[i][j] = 1;
k -= dp[n];
while (k > 0) {
j = 1;
while (dp2[j] <= k) j++;
j--;
for (int i = 0; i < (int)(j); i++) g[n][i] = g[i][n] = 1;
n++;
k -= dp2[j];
}
printf("%d\n", n);
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(n); j++) cout << g[i][j];
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int n, m;
vector<vector<int>> ans;
void f3(vector<pair<int, int>> &ones, vector<pair<int, int>> &zeros) {
vector<int> res;
for (int i = 0; i < ones.size(); i++) {
res.push_back(ones[i].first);
res.push_back(ones[i].second);
}
ans.push_back(res);
}
void f2(vector<pair<int, int>> &ones, vector<pair<int, int>> &zeros) {
vector<int> res;
res.push_back(ones.back().first);
res.push_back(ones.back().second);
pair<int, int> temp = {ones.back().first, ones.back().second};
ones.pop_back();
while (zeros.size() > 0) {
res.push_back(zeros.back().first);
res.push_back(zeros.back().second);
ones.push_back({zeros.back().first, zeros.back().second});
zeros.pop_back();
}
ans.push_back(res);
zeros.push_back(temp);
f3(ones, zeros);
}
void f1(vector<pair<int, int>> &ones, vector<pair<int, int>> &zeros) {
vector<int> res;
res.push_back(ones.back().first);
res.push_back(ones.back().second);
pair<int, int> temp = {ones.back().first, ones.back().second};
ones.pop_back();
while (zeros.size() > 1) {
res.push_back(zeros.back().first);
res.push_back(zeros.back().second);
ones.push_back({zeros.back().first, zeros.back().second});
zeros.pop_back();
}
ans.push_back(res);
zeros.push_back(temp);
f2(ones, zeros);
}
void f4(vector<pair<int, int>> &ones, vector<pair<int, int>> &zeros) {
vector<int> res;
while (ones.size() > 1) {
res.push_back(ones.back().first);
res.push_back(ones.back().second);
zeros.push_back({ones.back().first, ones.back().second});
ones.pop_back();
}
ans.push_back(res);
f1(ones, zeros);
}
void solve() {
cin >> n >> m;
char mat[n][m];
ans.clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
vector<pair<int, int>> one, zero;
if (mat[i][j] == '1')
one.push_back({i, j});
else
zero.push_back({i, j});
if (mat[i + 1][j] == '1')
one.push_back({i + 1, j});
else
zero.push_back({i + 1, j});
if (mat[i][j + 1] == '1')
one.push_back({i, j + 1});
else
zero.push_back({i, j + 1});
if (mat[i + 1][j + 1] == '1')
one.push_back({i + 1, j + 1});
else
zero.push_back({i + 1, j + 1});
if (one.size() == 1)
f1(one, zero);
else if (one.size() == 2)
f2(one, zero);
else if (one.size() == 3)
f3(one, zero);
else if (one.size() == 4)
f4(one, zero);
mat[i][j] = mat[i + 1][j] = '0';
mat[i][j + 1] = mat[i + 1][j + 1] = '0';
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
for (int num : ans[i]) cout << num + 1 << " ";
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define mod 998244353
#define oo 1000000010
const int N = 100010;
const int SQ = 500;
int n , x , p;
vector< int > g[N] , cur[N];
char c[N];
int mx;
vector< pair<int,int> > v , v2;
pair< int , char > a , b;
int sz[N];
bool comp(int u,int v){
return (sz[u] < sz[v]);
}
int DFS(int node,int d){
mx = max(mx,d);
cur[d].push_back(node);
sz[node] = 1;
for(int i = 0 ;i < (int)g[node].size();i++)
sz[node] += DFS(g[node][i] , d + 1);
return sz[node];
}
bool dp[SQ][N];
int f[N];
void build_path(int i,int j){
if(i == (int)v2.size())
return;
while(!dp[i + 1][j]){
f[v2[i].first]++;
j -= v2[i].first;
}
build_path(i + 1 , j);
}
int main(){
scanf("%d%d",&n,&x);
a = make_pair(x , 'a');
b = make_pair(n - x , 'b');
if(a > b) swap(a , b);
for(int i = 2 ;i <= n;i++){
scanf("%d",&p);
g[p].push_back(i);
}
DFS(1 , 0);
for(int i = 0 ;i <= mx;i++)
v.push_back(make_pair((int)cur[i].size() , i));
sort(v.begin(),v.end());
for(int i = 0 ;i < (int)v.size();i++){
if(i == 0 || v[i].first != v[i - 1].first)
v2.push_back(make_pair(v[i].first , 1));
else
v2.back().second++;
}
dp[(int)v2.size()][0] = true;
int val , frq;
for(int i = (int)v2.size() - 1;i >= 0;i--){
val = v2[i].first;
frq = v2[i].second;
vector< int > last(val , -1);
for(int j = 0 ;j <= a.first;j++){
if(dp[i + 1][j] == true)
last[j % val] = j;
if(last[j % val] == -1 || ((j - last[j % val]) / val) > frq)
dp[i][j] = false;
else
dp[i][j] = true;
}
}
if(dp[0][a.first]){
build_path(0 , a.first);
for(int i = 1;i <= n;i++) c[i - 1] = b.second;
for(int i = 0 ;i <= mx;i++){
if(f[(int)cur[i].size()] == 0) continue;
f[(int)cur[i].size()]--;
for(int j = 0 ;j < (int)cur[i].size();j++)
c[cur[i][j] - 1] = a.second;
}
printf("%d\n",mx + 1);
c[n] = '\0';
puts(c);
return 0;
}
printf("%d\n",mx + 2);
for(int i = 0 ;i <= mx;i++){
sort(cur[i].begin(),cur[i].end(),comp);
if(a.first < b.first) swap(a , b);
while((int)cur[i].size() > 0 && a.first > 0){
c[cur[i].back() - 1] = a.second;
cur[i].pop_back();
a.first--;
}
while((int)cur[i].size() > 0 && b.first > 0){
c[cur[i].back() - 1] = b.second;
cur[i].pop_back();
b.first--;
}
}
c[n] = '\0';
puts(c);
return 0;
}
| 11 |
#include<bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char& s) {
string res = "'";
res += s;
res += "'";
return res;
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (i) res += ", ";
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define int long long
#define fi first
#define se second
#define pii pair<int, int>
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(a) (int) (a).size()
#define eb emplace_back
#define ld long double
#define ve vector
#define forn(i, n) for (int i = 0; i < n; i++)
ve<ve<int>> g, dp;
ve<pii> ans;
void dfs(int v, int pr) {
for (auto x : g[v]) {
if (x != pr) {
dfs(x, v);
}
}
dp[v][0] = 0;
for (auto x : g[v]) {
if (x != pr) {
dp[v][0] += max({dp[x][0], dp[x][2], dp[x][4]});
}
}
dp[v][1] = dp[v][0] + 1;
ve<int> upd;
for (auto x : g[v]) {
if (x != pr) {
dp[v][2] = max(dp[v][2], max(dp[x][1], dp[x][3]) + dp[v][0] - max({dp[x][0], dp[x][2], dp[x][4]}));
dp[v][3] = max(dp[v][3], 1 + max(dp[x][1], dp[x][3]) + dp[v][0] - max({dp[x][0], dp[x][2], dp[x][4]}));
upd.pb(max(dp[x][1], dp[x][3]) - max({dp[x][0], dp[x][2], dp[x][4]}));
}
}
sort(rall(upd));
if (sz(upd) >= 2) {
dp[v][4] = upd[0] + upd[1] + dp[v][0];
}
}
void go(int x, int v) ;
void go2(int x, int v) ;
void gfs(int v, int pr, int type) {
if (type == 0 || type == 1) {
for (auto x : g[v]) {
if (x != pr) {
go(x, v);
}
}
return;
}
ve<pii> upd;
for (auto x : g[v]) {
if (x != pr) {
upd.pb({max(dp[x][1], dp[x][3]) - max({dp[x][0], dp[x][2], dp[x][4]}), x});
}
}
sort(rall(upd));
if (type == 2 || type == 3) {
int u = upd[0].se;
ans.pb({v, u});
go2(u, v);
for (auto x : g[v]) {
if (x != pr && x != u) {
go(x, v);
}
}
return;
}
int u = upd[0].se;
ans.pb({v, u});
int u2 = upd[1].se;
ans.pb({v, u2});
go2(u, v);
go2(u2, v);
for (auto x : g[v]) {
if (x != pr && x != u && x != u2) {
go(x, v);
}
}
return;
}
void go(int x, int v) {
int res = max({dp[x][0], dp[x][2], dp[x][4]});
if (dp[x][0] == res) gfs(x, v, 0);
else if (dp[x][2] == res) gfs(x, v, 2);
else gfs(x, v, 4);
}
void go2(int x, int v) {
if (dp[x][1] > dp[x][3]) gfs(x, v, 1);
else gfs(x, v, 3);
}
void solve() {
int n;
cin >> n;
ans.clear();
g.clear();
g.resize(n);
dp.clear();
dp.resize(n, ve<int> (5));
forn (i, n - 1) {
int x, y;
cin >> x >> y;
x--, y--;
g[x].pb(y);
g[y].pb(x);
}
dfs(0, -1);
int res = max({dp[0][0], dp[0][2], dp[0][4]});
cout << n - 1 - max({dp[0][0], dp[0][2], dp[0][4]}) << '\n';
go(0, -1);
//debug(ans);
set<pii> usd;
ve<ve<int>> G(n);
for (auto [x, y] : ans) {
usd.insert({x, y});
usd.insert({y, x});
G[x].pb(y);
G[y].pb(x);
}
ve<int> used(n);
function<int(int)> dfs = [&] (int v) {
used[v] = 1;
for (auto x : G[v]) {
if (!used[x]) return dfs(x);
}
return v;
};
vector<pii> kek;
forn (i, n) {
if (!used[i] && sz(G[i]) == 0) {
kek.pb({i, i});
continue;
}
if (!used[i] && sz(G[i]) == 1) {
kek.pb({i, dfs(i)});
}
}
vector<pii> del;
forn (i, n) {
for (auto x : g[i]) {
if (x > i && usd.find({i, x}) == usd.end()) del.pb({x, i});
}
}
//assert(sz(del) == sz(kek) - 1);
//debug(del), debug(kek);
forn (i, sz(del)) {
cout << del[i].fi + 1 << " " << del[i].se + 1 << " " << kek[i].se + 1 << " " << kek[i + 1].fi + 1 << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int test = 1;
if (1) cin >> test;
forn (WORLD_OF_TANKS, test) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
long long q;
cin >> q;
bool is_changed = false;
long long res = 0;
while (q != 1) {
is_changed = false;
if (q % 2 == 0) {
q = q / 2;
is_changed = true;
} else if (q % 3 == 0) {
q = 2 * q / 3;
is_changed = true;
} else if (q % 5 == 0) {
q = 4 * q / 5;
is_changed = true;
}
if (!is_changed) {
res = -1;
break;
}
res++;
}
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long input() {
long long x = 0, f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
const int N = 2e5 + 7;
vector<int> G[N];
vector<int> Ans;
int cnt[N];
int n, m;
int main() {
int T = input();
while (T--) {
n = input(), m = input();
for (int i = 1; i <= n; i++) G[i].clear(), cnt[i] = 0;
Ans.clear();
for (int i = 1; i <= m; i++) {
int u = input(), v = input();
G[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (cnt[i] < 2) {
for (auto v : G[i]) {
cnt[v] = max(cnt[v], cnt[i] + 1);
}
} else
Ans.push_back(i);
}
printf("%d\n", Ans.size());
for (auto v : Ans) printf("%d ", v);
printf("\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, part, l, r, t, c, p = 0, z;
vector<pair<int, int> >* a;
cin >> n >> part;
a = new vector<pair<int, int> >[n];
for (int i = 0; i < part; i++) {
cin >> l >> r >> t >> c;
pair<int, int> x(t, c);
for (int j = l; j <= r; j++) a[j - 1].push_back(x);
}
for (int i = 0; i < n; i++) {
z = 0;
if (a[i].size() != 0) {
for (int j = 1; j < a[i].size(); j++) {
if (a[i][j].first < a[i][z].first) z = j;
}
p += a[i][z].second;
}
}
cout << p << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool ok;
int main() {
string s1, s2, s3, t, sc;
cin >> t;
for (int i = 0; i < t.length(); i++)
if (isalpha(t[i])) s1 += tolower(t[i]);
cin >> t;
for (int i = 0; i < t.length(); i++)
if (isalpha(t[i])) s2 += tolower(t[i]);
cin >> t;
for (int i = 0; i < t.length(); i++)
if (isalpha(t[i])) s3 += tolower(t[i]);
vector<string> a(6);
a[0] = s1 + s2 + s3;
a[1] = s1 + s3 + s2;
a[2] = s2 + s1 + s3;
a[3] = s2 + s3 + s1;
a[4] = s3 + s1 + s2;
a[5] = s3 + s2 + s1;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
sc = "";
ok = 0;
for (int i = 0; i < t.length(); i++)
if (isalpha(t[i])) sc += tolower(t[i]);
for (int j = 0; j < 6; j++)
if (a[j] == sc) ok = 1;
if (!ok)
cout << "WA\n";
else
cout << "ACC\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int min(long long int a, long long int b) { return a < b ? a : b; }
long long int min(long long int a, long long int b, long long int c) {
a = min(a, b);
a = min(a, c);
return a;
}
long long int max(long long int a, long long int b) { return a > b ? a : b; }
long long int max(long long int a, long long int b, long long int c) {
a = max(a, b);
a = max(a, c);
return a;
}
long long int dsum(long long int n) {
long long int ans = 0;
while (n) {
ans += (n % 10);
n /= 10;
}
return ans;
}
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
struct pll {
long long int x, y;
};
bool comp(pll a, pll b) {
if (a.x == b.x)
return a.y < b.y;
else
return a.x < b.x;
}
void solve(long long int the) {
char ch;
double aa, bb, cc;
string s1, s2, s3, str;
long long int i, j, k, a, b, c, d, x, y, z, n, m, mini, maxi, l, r, low, high,
mid, sum = 0, ans = 0, temp, t;
long long int n1, n2, k1, k2;
cin >> s1 >> s2;
a = s1.length();
b = s2.length();
if (a != b) {
cout << "NO" << endl;
return;
}
if (a == 1) {
if (s1[0] == s2[0])
cout << "YES" << endl;
else
cout << "NO" << endl;
return;
} else if (s1 == s2) {
cout << "YES" << endl;
return;
}
bool ok = false;
for (i = 0; i < a; i++) {
if (s1[i] == '1') ok = true;
}
if (ok) {
for (i = 0; i < a; i++) {
if (s2[i] == '1') {
ok = false;
}
}
if (!ok)
cout << "YES";
else
cout << "NO";
} else
cout << "NO";
}
int main() {
long long int t = 1, c = 1;
while (t--) {
solve(c);
c++;
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t,n;
cin>>t;
while(t--)
{
cin>>n;
string tasks;
cin>>tasks;
int flag=1;
int occur[26];
for(int i=0;i<26;i++)occur[i]=0;
occur[tasks[0]-65]=1;
for(int i=1;i<n;i++)
{
if(occur[tasks[i]-65] && tasks[i]!=tasks[i-1]){flag=0;break;}
else occur[tasks[i]-65]=1;
}
if(flag==0)cout<<"NO"<<"\n";
else cout<<"YES"<<"\n";
}
return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
map<string, int> id;
int cnt, sz[N], f[N], R[N], sol, ans;
char s[N];
vector<int> E[N];
int max(int a, int b) { return a > b ? a : b; }
void DFS(int u) {
if (E[u].size()) sz[u] = 1;
if (E[u].empty()) f[u] = 1;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
DFS(v);
sz[u] += sz[v];
f[u] += f[v];
}
sol = max(sol, sz[u] - 1);
ans = max(ans, f[u]);
}
int main() {
while (~scanf("%s", s + 1)) {
int n = strlen(s + 1), i;
string t;
for (i = 1; i <= 3; i++) t += s[i];
int par = 0;
while (i <= n) {
for (; i <= n && s[i] != '\\'; i++) t += s[i];
if (s[i] == '\\') t += s[i], i++;
if (!id[t]) {
id[t] = ++cnt;
if (par) E[par].push_back(id[t]), R[id[t]]++;
}
par = id[t];
}
}
for (int i = 1; i <= cnt; i++)
if (!R[i]) DFS(i);
printf("%i %i\n", sol, ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int s1 = a[0], s2 = b[0];
for (int i = 1; i < n; i++) {
s1 |= a[i];
s2 |= b[i];
}
cout << s1 + s2 << endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
const auto start_time = std::chrono::high_resolution_clock::now();
void aryanc403() {}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || (a.first == b.first && a.second <= b.second));
}
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m;
string s;
vector<vector<long long int> > e;
vector<pair<long long int, long long int> > edges;
unsigned long long int ans, a, b, c;
unsigned long long int C2(long long int n) {
if (n <= 0) return 0;
return n * (n + 1) / 2;
}
unsigned long long int solve1() {
unsigned long long int ans = 0;
for (auto x : edges) {
const long long int u = x.first, v = x.second;
ans += (a * u + b * v) * (n - 1 - v);
ans += c * (C2(n - 1) - C2(v));
ans += (b * u + c * v) * (u);
ans += a * C2(u - 1);
ans += (a * u + c * v) * (v - u - 1);
ans += b * (C2(v - 1) - C2(u));
};
return ans;
}
unsigned long long int solveMid(unsigned long long int cst,
const vector<long long int> &sm,
const vector<long long int> &lr) {
unsigned long long int ans = 0;
ans += cst * (((long long int)(sm).size())) * (((long long int)(lr).size()));
for (auto x : sm) ans += a * x * ((long long int)(lr).size());
for (auto x : lr) ans += c * x * ((long long int)(sm).size());
return ans;
}
unsigned long long int solveCorner(unsigned long long int cst,
unsigned long long int a,
unsigned long long int b,
const vector<long long int> &e) {
unsigned long long int ans = 0;
unsigned long long int n = ((long long int)(e).size()), m = 0;
ans += cst * ((n) * (n - 1) / 2);
for (auto x : e) {
n--;
ans += (x * a) * n;
ans += (x * b) * m;
m++;
}
return ans;
}
unsigned long long int solve2() {
unsigned long long int ans = 0;
for (long long int i = 0; i < n; ++i) {
vector<long long int> dd, ee;
for (auto x : e[i]) {
if (i < x)
ee.push_back(x);
else
dd.push_back(x);
}
ans += solveMid(b * i, dd, ee);
reverse(begin(ee), end(ee));
ans += solveCorner(a * i, c, b, ee);
ans += solveCorner(c * i, a, b, dd);
};
return ans;
}
bool chk(const vector<long long int> &a, long long int x) {
auto it = lower_bound(begin(a), end(a), x);
return it != a.end() && *it == x;
}
const long long int MM = 200000;
const long long int KK = 100;
bitset<MM> edgHeavy[1 + 2 * MM / KK];
unsigned long long int solve3() {
unsigned long long int ans = 0;
vector<long long int> bb;
vector<pair<long long int, long long int> > qur;
for (long long int i = 0; i < n; ++i) {
if (((long long int)(e[i]).size()) > KK) {
bb.push_back(i);
continue;
}
for (auto x : e[i]) {
if (x > i) break;
for (auto y : e[i]) {
if (y < i) continue;
if (chk(e[x], y)) ans += x * a + i * b + c * y;
}
}
}
const long long int mm = ((long long int)(bb).size());
assert(mm < 2 * MM / KK + 1);
for (long long int i = 0; i < mm; ++i) {
for (auto x : e[bb[i]]) edgHeavy[i][x] = 1;
}
for (auto x : edges) {
const long long int u = x.first, v = x.second;
auto it = lower_bound(begin(bb), end(bb), u + 1) - bb.begin();
while (it < mm && bb[it] < v) {
if (edgHeavy[it][u] && edgHeavy[it][v]) ans += a * u + bb[it] * b + c * v;
++it;
}
};
return ans;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
cin >> n >> m;
cin >> a >> b >> c;
e.resize(n);
for (i = 0; i < (m); ++i) {
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
if (u > v) swap(u, v);
edges.push_back({u, v});
}
for (i = 0; i < (n); ++i) {
sort(begin(e[i]), end(e[i]));
ans += (c * i) * (i * (i - 1) / 2);
ans += (b * i) * i * (n - i - 1);
ans += (a * i) * ((n - i - 2) * (n - i - 1) / 2);
};
;
unsigned long long int ans1 = solve1();
unsigned long long int ans2 = solve2();
unsigned long long int ans3 = solve3();
;
ans += -ans1 + ans2 - ans3;
;
;
cout << ans << "\n";
}
aryanc403();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char s[10][10];
int main() {
int p[10], n, k, j, i, maxs, mins, res, tp;
while (~scanf("%d%d", &n, &k)) {
for (i = 0; i < n; i++) scanf("%s", s[i]);
for (i = 0; i < k; i++) p[i] = i;
res = 0x3fffffff;
do {
maxs = 0;
mins = 0x3fffffff;
for (i = 0; i < n; i++) {
tp = 0;
for (j = 0; j < k; j++) tp = tp * 10 + (s[i][p[j]] - '0');
if (tp > maxs) maxs = tp;
if (tp < mins) mins = tp;
}
tp = maxs - mins;
if (tp < res) res = tp;
} while (next_permutation(p, p + k));
printf("%d\n", res);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int magicconst = 73743071;
using namespace std;
const int maxn = 300500;
long long ans[maxn];
long long dp[maxn];
int w[maxn];
pair<pair<int, int>, int> qr[maxn];
int main() {
int n, p;
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) scanf("%d", w + i);
scanf("%d", &p);
for (int i = 0; i < (int)(p); ++i) {
scanf("%d%d", &qr[i].first.second, &qr[i].first.first);
qr[i].second = i;
}
sort(qr, qr + p);
int last = -1;
for (int i = 0; i < (int)(p); ++i) {
if ((long long)qr[i].first.first * qr[i].first.first >= n) {
ans[qr[i].second] = 0;
while (qr[i].first.second <= n) {
ans[qr[i].second] += w[qr[i].first.second - 1];
qr[i].first.second += qr[i].first.first;
}
} else {
if (last != qr[i].first.first) {
last = qr[i].first.first;
for (int i = n; i; --i)
if (i + last > n)
dp[i] = w[i - 1];
else
dp[i] = w[i - 1] + dp[i + last];
}
ans[qr[i].second] = dp[qr[i].first.second];
}
}
for (int i = 0; i < (int)(p); ++i) printf("%I64d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int tree1[100010 * 5];
int tree2[100010 * 5];
int vals[100010];
int L, R, val;
void update1(int id, int l, int r) {
if (l > R || r < L || r < l) return;
if (L <= l && r <= R) {
tree1[id] = max(tree1[id], val);
return;
}
int mid = (l + r) / 2;
update1(2 * id, l, mid);
update1(2 * id + 1, mid + 1, r);
tree1[id] = max(tree1[2 * id], tree1[2 * id + 1]);
}
void get1(int id, int l, int r) {
if (l > R || r < L || r < l) return;
if (L <= l && r <= R) {
val = max(val, tree1[id]);
return;
}
int mid = (l + r) / 2;
get1(2 * id, l, mid);
get1(2 * id + 1, mid + 1, r);
}
int rite[100010];
int lefty[100010];
int cnt[100010];
int main() {
int i, j, k, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &vals[i]);
val = 1;
L = vals[n];
R = vals[n];
update1(1, 1, 100000);
rite[n] = 1;
cout << endl;
for (i = n - 1; i >= 1; i--) {
L = vals[i] + 1;
R = 100000;
val = 0;
get1(1, 1, 100000);
val++;
L = vals[i];
R = vals[i];
update1(1, 1, 100000);
rite[i] = val;
}
memset(tree1, 0, sizeof(tree1));
val = 1;
L = vals[1];
R = vals[1];
update1(1, 1, 100000);
lefty[1] = 1;
for (i = 2; i <= n; i++) {
L = 1;
R = vals[i] - 1;
val = 0;
get1(1, 1, 100000);
val++;
L = vals[i];
R = vals[i];
update1(1, 1, 100000);
lefty[i] = val;
}
int mx = 0;
for (i = 1; i <= n; i++) {
mx = max(mx, lefty[i] + rite[i] - 1);
}
for (i = 1; i <= n; i++) {
val = lefty[i] + rite[i] - 1;
if (val == mx) cnt[rite[i]]++;
}
for (i = 1; i <= n; i++) {
val = lefty[i] + rite[i] - 1;
if (val != mx) {
printf("1");
} else {
if (cnt[rite[i]] == 1) {
printf("3");
} else
printf("2");
}
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
for (int t = 0; t < T; t++) {
int n, a, b;
cin >> n >> a >> b;
char prima = 'a';
string ans = "";
for (int i = 0; i < n; i++) {
ans += char(prima + (i % b));
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 101100;
int a[NN];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sort(a + 1, a + n + 1);
int sum = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > 0) sum += a[i];
}
if (sum & 1) {
cout << sum << endl;
return 0;
}
auto id = upper_bound(a + 1, a + n + 1, 0) - a;
while (id <= n && a[id] % 2 == 0) id++;
if (id <= n) {
int ed = a[id];
id = lower_bound(a + 1, a + n + 1, 0) - a - 1;
while (id > 0 && a[id] % 2 == 0) id--;
if (id > 0) {
int val = min(ed, abs(a[id]));
sum -= val;
cout << sum << endl;
return 0;
}
sum -= ed;
cout << sum << endl;
return 0;
}
id = lower_bound(a + 1, a + n + 1, 0) - a - 1;
while (id > 0 && a[id] % 2 == 0) id--;
sum += a[id];
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
const int dx[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
struct arr {
int A[400006];
int* operator[](int i) { return A + i * (m + 2); }
} S;
int as = 0;
int cal(int x, int y) {
int re = 0;
re += S[x + 1][y] & S[x][y - 1];
re += S[x + 1][y] & S[x][y + 1];
re += S[x - 1][y] & S[x][y - 1];
re += S[x - 1][y] & S[x][y + 1];
int las = S[x + dx[7]][y + dy[7]];
for (int d = 0; d < 8; ++d) {
int cur = S[x + dx[d]][y + dy[d]];
if (las & cur) ++re;
las = cur;
}
return re;
}
int flg = 0;
void add(int x, int y) {
S[x][y] = 1;
as += cal(x, y);
}
void era(int x, int y) {
S[x][y] = 0;
as -= cal(x, y);
}
void ot() {
if (flg) {
for (int i = (1), iend = (m); i <= iend; ++i) {
for (int j = (1), jend = (n); j <= jend; ++j)
putchar(S[j][i] ? '*' : '.');
puts("");
}
} else {
for (int i = (1), iend = (n); i <= iend; ++i) {
for (int j = (1), jend = (m); j <= jend; ++j)
putchar(S[i][j] ? '*' : '.');
puts("");
}
}
puts("");
}
void solve() {
cin >> n >> m >> k;
as = 0;
flg = 0;
if (n * m <= 16) {
for (int s = 1; s < (1 << n * m); ++s) {
as = 0;
for (int i = (0), iend = ((n + 2) * (m + 2)); i <= iend; ++i) S.A[i] = 0;
for (int i = (1), iend = (n); i <= iend; ++i)
for (int j = (1), jend = (m); j <= jend; ++j)
if (s & (1 << (i - 1) * m + j - 1)) add(i, j);
if (as == k) {
ot();
return;
}
}
return void(puts("-1\n"));
}
if (n > m) swap(n, m), flg = 1;
for (int i = (0), iend = ((n + 2) * (m + 2)); i <= iend; ++i) S.A[i] = 0;
int mx = (n - 1) * (m - 1) * 4;
if (k > mx) return void(puts("-1\n"));
for (int i = (1), iend = (n); i <= iend; ++i)
for (int j = (1), jend = (m); j <= jend; ++j) add(i, j);
if (k >= mx - 15) {
if (n == 3 && k == mx - 8) {
era(1, 1), era(2, 1), era(3, 1);
ot();
return;
}
if (k == mx - 1 || k == mx - 2 || k == mx - 4 || k == mx - 5 || k == mx - 8)
return void(puts("-1\n"));
int rem = mx - k;
if (rem == 14) {
era(1, 1);
rem = 11;
} else if (rem == 13 || rem == 10) {
era(1, 1);
if (rem == 13) era(1, m);
rem = 7;
}
if (k == mx) {
ot();
} else if (rem == 7 || rem == 11 || rem == 15 || rem == 3) {
era(n, m);
if (rem >= 7) era(n, m - 1);
if (rem >= 11) era(n, m - 2);
if (rem >= 15) era(n, m - 3);
ot();
} else if (rem % 3 == 0) {
int t = rem / 3;
if (t >= 1) era(1, 1);
if (t >= 2) era(1, m);
if (t >= 3) era(n, 1);
if (t >= 4) era(n, m);
ot();
}
return;
}
int x = 0, y = 0;
for (int i = (n), iend = (1); i >= iend; --i) {
for (int j = (m), jend = (1); j >= jend; --j) {
era(i, j);
if (k - as <= 3 && k >= as) {
x = i, y = j;
break;
}
}
if (k - as <= 3 && k >= as) break;
}
int rem = k - as, tl, tr;
if (rem == 0) {
ot();
return;
}
if (y <= m - 4)
tl = 0, tr = 5;
else
tl = y - (m - 4), tr = 5 - tl;
if (rem == 1) {
if (tr == 1)
add(x + 1, m - 1);
else
add(x, m);
} else if (rem == 2) {
if (tr > tl)
add(x, m - 1);
else
add(x + 1, m - 3);
} else {
if (tr >= 4)
add(x, m), add(x, m - 2);
else if (tr == 3)
add(x, m - 1), add(x + 1, m - 3);
else if (tr == 2)
add(x, m), add(x + 1, m - 3);
else if (tr == 1)
add(x + 1, m - 1), add(x + 1, m - 3);
}
ot();
}
signed main() {
int T;
cin >> T;
while (T--) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, i, ans, h[100005], l[100005], r[100005];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", h + i);
for (i = 1; i <= n; ++i) l[i] = min(l[i - 1] + 1, h[i]);
for (i = n; 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]));
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10, MAXK = 11;
int n, m;
char strA[MAXN], strB[MAXN];
int pd[MAXN][MAXN][11][2];
int f(int i, int j, int k, int flag) {
if (i == n || j == m) return (k == 0) ? 0 : INT_MIN;
int &ret = pd[i][j][k][flag];
if (ret == -1) {
ret = max(f(i + 1, j, k, 0), f(i, j + 1, k, 0));
if (strA[i] == strB[j]) {
if (flag) ret = max(ret, 1 + f(i + 1, j + 1, k, 1));
if (k) ret = max(ret, 1 + f(i + 1, j + 1, k - 1, 1));
}
}
return ret;
}
int main() {
int K;
scanf("%d%d%d", &n, &m, &K);
scanf(" %s %s", strA, strB);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k <= K; k++) pd[i][j][k][0] = pd[i][j][k][1] = -1;
printf("%d\n", f(0, 0, K, 0));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int sizes = 2000001;
long long int tim[sizes], start[sizes];
int main() {
long long int i, j, k, l, m, n, o, p, q, r, s, t, a[2000];
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
}
multiset<long long int> se;
long long int done = 0;
long long int index = 0;
for (i = 0; i <= 1500000; i++) {
while (!se.empty() && *(se.begin()) <= i) {
done++;
se.erase(se.begin());
}
while (se.size() < k && index < n) {
start[index] = i;
se.insert(a[index] + i);
index++;
}
long double x = (100.0 * done) / n;
x = floor(x + 0.5);
tim[i] = x;
}
long long int ans = 0;
for (i = 0; i < n; i++) {
for (j = 1; j <= a[i]; j++) {
long long int x = start[i];
x += j;
if (tim[x - 1] == j) {
ans++;
break;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int a[t], b[t];
for (int i = 0; i < t; i++) {
cin >> a[i] >> b[i];
int k = (24 - a[i]) * 60 - b[i];
cout << k << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
const int C = 3001;
int main() {
int n;
cin >> n;
vector<pair<pair<int, int>, int>> points(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &points[i].first.first, &points[i].first.second);
points[i].second = i;
points[i].first.first /= C;
}
sort((points).begin(), (points).end(),
[](const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
return a.first.first < b.first.first ||
(a.first.first == b.first.first &&
(a.first.first % 2 == 0 ? (a.first.second < b.first.second)
: (a.first.second > b.first.second)));
});
for (auto i : points) {
printf("%d ", i.second + 1);
}
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = atan(1.0) * 4.0;
const long long mod = 1e9 + 7;
long long n, k;
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= k; i++)
if (n % (i) != (i - 1)) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
int n;
int pai[maxn], depth[maxn], depth2[maxn];
int find(int x) {
if (pai[x] == x) return x;
return pai[x] = find(pai[x]);
}
void join(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (depth[x] < depth[y]) swap(x, y);
pai[y] = x;
if (depth[x] == depth[y])
depth2[x] = depth[x]++;
else
depth2[x] = max(depth2[x], depth[y] + 1);
}
vector<int> g[maxn];
bool mark[maxn];
int dist[maxn];
int bfs(int s) {
queue<int> q;
q.push(s);
int last;
while (!q.empty()) {
int u = q.front();
mark[u] = 1;
last = u;
q.pop();
for (auto v : g[u]) {
if (mark[v]) continue;
q.push(v);
}
}
return last;
}
int bfs2(int s) {
queue<int> q;
q.push(s);
int last;
while (!q.empty()) {
int u = q.front();
last = u;
q.pop();
for (auto v : g[u]) {
if (v == pai[u]) continue;
dist[v] = dist[u] + 1;
pai[v] = u;
q.push(v);
}
}
return last;
}
void init() {
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
int last = bfs(i);
pai[last] = last;
int other = bfs2(last);
depth[last] = (dist[other] + 1) / 2;
depth2[last] = dist[other] / 2;
}
}
}
int main() {
int m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = (0); i < (m); i++) {
int a, b;
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
init();
while (q--) {
int t, a, b;
scanf("%d %d", &t, &a);
if (t == 1) {
printf("%d\n", depth[find(a)] + depth2[find(a)]);
} else {
scanf("%d", &b);
join(a, b);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> smax, smin;
int ox[100000], oy[100000];
map<pair<int, int>, int> pnts;
inline int eval(int x, int y) {
if (pnts.count({x, y})) {
return pnts.count({x, y - 1}) + pnts.count({x - 1, y - 1}) +
pnts.count({x + 1, y - 1});
}
return 3;
}
inline bool isOk(int x, int y) {
return (eval(x, y + 1) > 1) && (eval(x - 1, y + 1) > 1) &&
(eval(x + 1, y + 1) > 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr << "-.-";
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> ox[i] >> oy[i];
pnts.insert({{ox[i], oy[i]}, i});
}
for (int i = 0; i < m; ++i) {
if (isOk(ox[i], oy[i])) {
smax.insert(-i), smin.insert(i);
}
}
int turn = 0;
vector<int> path;
int dd[] = {0, -1, 1, -2, 2};
while (((int)(smax).size())) {
int i = (turn == 0) ? -(*smax.begin()) : (*smin.begin());
smin.erase(i), smax.erase(-i);
path.push_back(i), pnts.erase({ox[i], oy[i]});
for (int d = 1; d < 5; ++d) {
auto it = pnts.find({ox[i] + dd[d], oy[i]});
if (it != pnts.end()) {
int j = it->second;
if (!isOk(ox[j], oy[j])) {
smax.erase(-j), smin.erase(j);
}
}
}
for (int d = 0; d < 3; ++d) {
auto it = pnts.find({ox[i] + dd[d], oy[i] - 1});
if (it != pnts.end()) {
int j = it->second;
if (isOk(ox[j], oy[j])) {
smax.insert(-j), smin.insert(j);
}
}
}
turn ^= 1;
}
int ans = 0;
for (int i = 0; i < ((int)(path).size()); ++i) {
ans = ((1ll * ans * m) + path[i]) % 1000000009;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> ans;
if (ans % 2 == 1)
cout << 9 << " " << ans - 9 << endl;
else
cout << 4 << " " << ans - 4 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
int a, b;
int r = 0;
cin >> a >> b;
vector<int> A, B;
vector<int> v(a + b);
for (int i = 0; i < a; i++) {
cin >> r;
A.push_back(r);
}
for (int i = 0; i < b; i++) {
cin >> r;
B.push_back(r);
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
auto it =
set_intersection(A.begin(), A.end(), B.begin(), B.end(), v.begin());
bool printed = false;
if (it != B.end()) {
for (auto itr = v.begin(); itr != it; ++itr) {
cout << "YES\n"
<< "1 " << *itr << "\n";
printed = true;
break;
}
}
if (printed == false) {
cout << "NO"
<< "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a[51];
int n, s1 = 0, s = 0;
int main() {
cin >> n >> a;
for (int i = 0; i < n; i++)
if (a[i] != '4' && a[i] != '7') {
cout << "NO";
return 0;
}
for (int i = 0; i < n / 2; i++) {
s += a[i];
s1 += a[n - 1 - i];
}
if (s == s1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dp[5005][5005];
string a, b;
int main() {
cin >> a >> b;
int len1 = a.length();
int len2 = b.length();
for (int i = 1; i <= len1; i++) {
for (int j = 1; j <= len2; j++) {
if (a.operator[](i - 1) == b.operator[](j - 1)) {
dp[i][j] = (dp[i][j] + dp[i - 1][j - 1] + 1) % mod;
}
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod;
}
}
long long ans = 0;
for (int i = 1; i <= len1; i++) ans = (ans + dp[i][len2]) % mod;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s == "a1" || s == "a8" || s == "h1" || s == "h8") {
cout << "3";
} else if (s[0] == 'a' || s[0] == 'h' || s[1] == '1' || s[1] == '8') {
cout << "5";
} else {
cout << "8";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, n, d, l1, l2, l3, l4, r1, r2, r3, r4;
int main() {
cin >> n >> a >> b >> c >> d;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
l1 = a + b + i + 1;
r1 = a + b + i + n;
l2 = a + c + i + 1;
r2 = a + c + i + n;
l3 = b + d + i + 1;
r3 = b + d + i + n;
l4 = c + d + i + 1;
r4 = c + d + i + n;
l1 = max(l1, max(l2, max(l3, l4)));
r1 = min(r1, min(r2, min(r3, r4)));
if (l1 <= r1) ans += r1 - l1 + 1;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int degree[n], temp;
bool flag;
list<int> l[n];
pair<int, int> d[n];
for (int i = 0; i < n; i++) {
cin >> d[i].first;
d[i].second = i;
degree[i] = k;
if (d[i].first > n) {
cout << -1 << endl;
return 0;
}
l[d[i].first].push_back(i);
}
sort(d, d + n);
vector<pair<int, int> > answer;
if (l[0].size() != 1) {
cout << -1 << endl;
return 0;
} else {
list<int>::iterator j;
for (int i = 1; i < n; i++) {
temp = d[i].first;
flag = false;
for (j = l[temp - 1].begin(); j != l[temp - 1].end(); j++) {
if (degree[*j] > 0) {
degree[*j]--;
degree[d[i].second]--;
answer.push_back(make_pair(d[i].second, *j));
flag = true;
break;
}
}
int s;
while (!l[temp - 1].empty()) {
s = l[temp - 1].front();
if (degree[s] == 0) {
l[temp - 1].pop_front();
} else {
break;
}
}
if (!flag) {
cout << -1 << endl;
return 0;
}
}
}
cout << answer.size() << endl;
for (int i = 0; i < answer.size(); i++) {
cout << answer[i].first + 1 << " " << answer[i].second + 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
string s;
cin >> s;
vector<int> a(n);
vector<bool> used(n, false);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int cur = 0;
while (true) {
used[cur] = true;
int next = a[cur];
if (s[cur] == '<') next *= -1;
int nw = cur + next;
if (nw < 0 || nw >= n) {
cout << "FINITE";
return 0;
}
if (used[nw]) {
cout << "INFINITE";
return 0;
}
cur = nw;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int d[200105], h[200105];
long long sd[200105];
int M;
pair<long long, int> T[2][530000];
void update(int id, int l, long long v) {
l += M;
if (id == 0)
T[id][l] = {v, -(l - M)};
else
T[id][l] = {v, l - M};
while (l > 1) {
T[id][l >> 1] = max(T[id][l], T[id][l ^ 1]);
l >>= 1;
}
}
pair<long long, int> qy(int id, int l, int r) {
assert(l <= r);
pair<long long, int> ans = {-(1LL << 60), 0};
for (l = l + M - 1, r = r + M + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) {
if (T[id][l ^ 1] > ans) {
ans = T[id][l ^ 1];
}
}
if (r & 1 && T[id][r ^ 1] > ans) {
ans = T[id][r ^ 1];
}
}
return ans;
}
void init() {
for (int(i) = 1; (i) <= (int)(n + n); (i)++) sd[i] = d[i] + sd[i - 1];
for (M = 1; n + n + 2 > M; M <<= 1)
;
for (int(i) = 1; (i) <= (int)(n + n); (i)++) {
long long val = sd[i - 1] + h[i] * 2;
update(1, i, val);
val = h[i] * 2 - sd[i - 1];
update(0, i, val);
}
}
void cal(int x, int y) {
assert(x + 1 <= y);
vector<pair<long long, int>> ls, rs;
ls.push_back(qy(0, x, y));
rs.push_back(qy(1, x, y));
if (-ls[0].second > x) {
ls.push_back(qy(0, x, -ls[0].second - 1));
}
if (-ls[0].second < y) {
ls.push_back(qy(0, -ls[0].second + 1, y));
}
if (rs[0].second > x) {
rs.push_back(qy(1, x, rs[0].second - 1));
}
if (rs[0].second < y) {
rs.push_back(qy(1, rs[0].second + 1, y));
}
long long ans = -(1LL << 60);
for (int(i) = 0; (i) < (int)(ls.size()); (i)++)
for (int(j) = 0; (j) < (int)(rs.size()); (j)++) {
if (-ls[i].second < rs[j].second) {
ans = max(ans, ls[i].first + rs[j].first);
}
}
printf("%lld\n", ans);
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", d + i);
d[i + n] = d[i];
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", h + i);
h[i + n] = h[i];
}
init();
for (int a, b, i = 0, x, y; i < m; i++) {
scanf("%d%d", &a, &b);
if (a <= b) {
x = b + 1;
y = a + n - 1;
} else {
x = b + 1;
y = a - 1;
}
cal(x, y);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void smain();
int main() {
ios_base::sync_with_stdio(0);
smain();
return 0;
}
int n, q;
int a[300002];
vector<pair<int, int> > b[300002];
void smain() {
for (; scanf("%d%d", &n, &q) != EOF;) {
for (int i = 0; i < n + 1; i++) b[i].clear();
set<pair<int, int> > s;
int m = 0;
for (int i = 0; i < q; i++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
scanf("%d", a + m);
s.emplace(m, a[m]);
b[a[m]].emplace_back(m, a[m]);
m += 1;
} else if (tp == 2) {
int x;
scanf("%d", &x);
for (auto it : b[x]) {
s.erase(it);
}
b[x].clear();
} else {
int t;
scanf("%d", &t);
for (; !s.empty() && s.begin()->first < t;) {
s.erase(s.begin());
}
}
printf("%d\n", (int)s.size());
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > graph[100001];
set<pair<int, int> > S;
int D[100001];
void dijkstra(int st) {
S.insert(pair<int, int>(0, st));
pair<int, int> top;
int u, v, c, i;
D[st] = 0;
while (!S.empty()) {
top = *S.begin();
S.erase(S.begin());
c = top.first;
u = top.second;
for (i = 0; i < graph[u].size(); i++) {
pair<int, int> x = graph[u][i];
v = x.first;
if (D[v] > D[u] + x.second) {
if (D[v] != 1e9) S.erase(S.find(pair<int, int>(D[v], v)));
D[v] = D[u] + x.second;
S.insert(pair<int, int>(D[v], v));
}
}
}
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, c, l, u, v, i, w, counter = 0, j, a = 0, b, o, e, d;
cin >> n >> m >> c;
for (i = 0; i < m; i++) {
cin >> u >> v >> w;
graph[u].push_back(pair<int, int>(v, w));
graph[v].push_back(pair<int, int>(u, w));
}
cin >> l;
for (i = 1; i <= n; i++) D[i] = 1e9;
dijkstra(c);
for (i = 1; i <= n; i++) {
u = i;
if (D[u] == l) counter++;
for (j = 0; j < graph[i].size(); j++) {
v = graph[i][j].first;
if (v < u) continue;
e = graph[i][j].second;
if (D[u] < l && (D[u] + e) > l && (e - (l - D[u])) >= l - D[v]) counter++;
if (D[v] < l && (D[v] + e) > l && (e - (l - D[v])) > l - D[u]) counter++;
}
}
cout << counter;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
switch (n) {
case 1:
cout << 2;
break;
case 2:
cout << 3;
break;
case 3:
cout << 1;
break;
case 4:
cout << 2;
break;
case 5:
cout << 1;
break;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int h, n, m;
long long x;
vector<long long> H;
int main() {
cin >> h >> m >> n;
H.resize(h, -1);
int bad = 0;
for (int i = 0; i < n; i++) {
string op;
cin >> op;
if (op == "+") {
int id;
cin >> x >> id;
int del = 0;
while (H[(id + del) % h] != -1) {
bad++;
del = (del + m) % h;
}
H[(id + del) % h] = x;
} else {
int id;
cin >> id;
for (int i = 0; i < h; i++) {
if (H[i] == id) {
H[i] = -1;
}
}
}
}
cout << bad << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n;
cin >> n;
long c = n;
while (n > 1) {
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
c += (n / i);
n = n / i;
break;
}
}
}
cout << c;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <algorithm>
#include <ctime>
using namespace std;
const int maxN = 301000;
int t[4 * maxN];
void build(vector<int>& a, int v, int tl, int tr) {
if (tl == tr)
t[v] = a[tl];
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = min(t[2 * v], t[2 * v + 1]);
}
}
void update(int v, int tl, int tr, int l, int r, int add) {
if (l > r)
return;
if (l == tl && tr == r)
t[v] += add;
else {
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), add);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, add);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
int get(int v, int tl, int tr, int l, int r) {
if (l == tl && r == tr) {
return t[v];
}
int mid = (tl + tr) / 2;
if (l > mid) {
return get(2 * v + 1, mid + 1, tr, l, r);
}
else if (r <= mid) {
return get(2 * v, tl, mid, l, r);
}
else {
return min(get(2 * v, tl, mid, l, mid), get(2 * v + 1, mid + 1, tr, mid + 1, r));
}
}
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
--a[i];
}
vector<int> c(m);
for (int i = 0; i < m; ++i) {
cin >> c[i];
}
sort(a.begin(), a.end());
vector<long long> pr(n);
pr[0] = c[a[0]];
for (int i = 1; i < n; ++i) {
pr[i] = pr[i - 1];
pr[i] += c[a[i]];
}
for (int i = 0; i < 4 * n; ++i) {
t[i] = 0;
}
build(a, 1, 0, n - 1);
long long res = pr.back();
long long csum = 0;
for (int i = 1; i <= min(n, m); ++i) {
csum += c[i - 1];
update(1, 0, n - 1, n - i, n - 1, -1);
int cur = get(1, 0, n - 1, 0, n - 1);
if (cur >= 0) {
long long tot = 0;
if (n - i - 1 >= 0) {
tot = pr[n - i - 1];
}
res = min(res, csum + tot);
}
}
cout << res << endl;
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
//t = 1;
for (int tt = 0; tt < t; ++tt) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], tot;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> gr;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
tot += a[i];
}
if (tot % k) {
cout << "No" << endl;
exit(0);
}
int ev = tot / k;
int no = 0, su = 0;
for (int i = 1; i <= n; ++i) {
if (su + a[i] > ev) {
cout << "No" << endl;
exit(0);
}
if (su + a[i] == ev) {
su = 0;
gr.push_back(no + 1);
no = 0;
} else {
++no;
su += a[i];
}
}
cout << "Yes" << endl;
for (int i = 0; i < int(gr.size()) - 1; ++i) {
cout << gr[i] << " ";
}
cout << gr.back() << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
bool check[MAXN + 10];
int dp[MAXN + 10];
void init() {
int n;
int ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (check[x - 1])
dp[x] = dp[x - 1] + 1;
else
dp[x] = 1;
check[x] = true;
if (dp[x] > ans) ans = dp[x];
}
cout << n - ans;
return;
}
int main() {
init();
return 0;
}
| 4 |
#include <bits/stdc++.h>
int a, b, n;
bool licz(long long c, int d) {
long long wyn = 1;
for (int i = 0; i < d; i++) {
wyn *= c;
if (wyn >= (long long)(n)) return 0;
}
return 1;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
bool zm = 0;
while (licz(a + 1, b + 1)) {
a++;
b++;
}
int i = 1;
if (a != 1)
while (licz(a, b + i)) i++;
int p = 1, k = 1000000010;
while (p + 1 != k) {
if (licz((p + k) / 2, b))
p = (p + k) / 2;
else
k = (p + k) / 2;
}
if (a == 1 && (k - a) % 2 == 1)
printf("Missing\n");
else
printf("%s\n", ((k - a) % 2 == 1 && (i % 2) == 1) ? "Stas" : "Masha");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (n == 1 || m == 1)
cout << "YES" << endl;
else if (n == 2 && m == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > pq;
long long int MOD = 1000000007;
char str[101];
int chk(char str[]) {
int len = strlen(str);
int cnt = 0;
for (int i = 0; i < len; i++) {
if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' ||
str[i] == 'u')
cnt++;
}
return cnt;
}
int main() {
gets(str);
int n = chk(str);
if (n != 5) {
cout << "NO";
return 0;
}
gets(str);
n = chk(str);
if (n != 7) {
cout << "NO";
return 0;
}
gets(str);
n = chk(str);
if (n != 5) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int res = 0;
int base = 1;
while (n > 0) {
int a = n % 10;
if (a == 7) res += base;
base *= 2;
n /= 10;
}
cout << res + base - 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
struct Point {
int x;
int y;
Point() { ; }
Point(int x, int y) : x(x), y(y) { ; }
bool operator<(const Point &rhs) const {
if (x != rhs.x) {
return x < rhs.x;
}
return y < rhs.y;
}
};
set<Point> ans;
Point points[10010];
void calc(int left, int right) {
if (left > right) {
return;
}
int mid = (left + right) / 2;
int cx = points[mid].x;
for (int i = (left); i <= (int)(right); i++) {
ans.insert(Point(cx, points[i].y));
}
int lmid = mid;
int rmid = mid;
while (lmid >= left && points[lmid].x == cx) {
lmid--;
}
while (rmid <= right && points[rmid].x == cx) {
rmid++;
}
calc(left, lmid);
calc(rmid, right);
}
int main() {
int n;
while (scanf("%d", &n) > 0) {
ans.clear();
for (int i = 0; i < (int)(n); i++) {
int x, y;
scanf("%d %d", &x, &y);
points[i] = Point(x, y);
}
sort(points, points + n);
calc(0, n - 1);
assert(ans.size() <= 200000);
printf("%d\n", (int)ans.size());
for (__typeof((ans).begin()) it = (ans).begin(); it != (ans).end(); it++) {
printf("%d %d\n", it->x, it->y);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 1;
const int N = 5e5 + 1;
int n, a[N], last[2][N], match[2][N], seg[N << 2], dp[N], par[N];
map<int, pair<int, int>> m;
vector<pair<pair<int, int>, int>> q;
pair<int, int> p[N];
vector<int> ans;
void add(int ind, int id = 1, int l = 1, int r = n) {
if (l == r) {
seg[id] = last[1][l];
return;
}
int mid = l + r >> 1;
if (ind <= mid)
add(ind, id << 1, l, mid);
else
add(ind, id << 1 | 1, mid + 1, r);
seg[id] = max(seg[id << 1], seg[id << 1 | 1]);
}
int get(int L, int R, int id = 1, int l = 1, int r = n) {
if (R < l || r < L) return -1;
if (L <= l && r <= R) return seg[id];
int mid = l + r >> 1;
return max(get(L, R, id << 1, l, mid), get(L, R, id << 1 | 1, mid + 1, r));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (!m.count(a[i])) m[a[i]] = {oo, oo};
last[0][i] = m[a[i]].first;
last[1][i] = m[a[i]].second;
if (last[0][i] != oo) q.push_back({{last[0][i] + 1, i - 1}, -i});
if (last[1][i] != oo) q.push_back({{last[1][i] + 1, i - 1}, i});
m[a[i]].first = m[a[i]].second;
m[a[i]].second = i;
}
sort(q.begin(), q.end());
for (int i = 1; i <= n; i++) p[i - 1] = {last[1][i], i};
sort(p, p + n);
memset(match, -1, sizeof match);
memset(seg, -1, sizeof seg);
for (int i = 0, j = 0; i < q.size(); i++) {
int ind = q[i].first.first - 2;
while (j < n && p[j].first <= ind) {
add(p[j].second);
j++;
}
int maxi = get(q[i].first.first, q[i].first.second);
if (q[i].second < 0)
match[0][-q[i].second] = maxi;
else
match[1][q[i].second] = maxi;
}
for (int i = 1; i <= n; i++) {
dp[i] = dp[i - 1];
for (int j = 0; j < 2; j++)
if (match[j][i] != -1 && dp[i] < dp[match[j][i] - 1] + 1) {
par[i] = j + 1;
dp[i] = dp[match[j][i] - 1] + 1;
}
if (last[0][i] != oo && last[1][last[0][i]] != oo)
if (dp[i] < dp[last[1][last[0][i]] - 1] + 1) {
dp[i] = dp[last[1][last[0][i]] - 1] + 1;
par[i] = 3;
}
}
for (int i = n; i > 0;) {
for (int j = 0; j < 2; j++)
if (par[i] == j + 1) {
for (int k = 0; k < 2; k++) {
ans.push_back(a[i]);
ans.push_back(a[match[j][i]]);
}
i = last[j][i];
}
if (par[i] == 3) {
for (int k = 0; k < 4; k++) ans.push_back(a[i]);
i = last[1][last[0][i]];
}
i--;
}
printf("%d\n", ans.size());
reverse(ans.begin(), ans.end());
for (auto x : ans) printf("%d ", x);
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using ld = long double;
const int64_t N = 1e6 + 7;
const int64_t MOD = (int64_t)1e9 + 7;
const int64_t MOD1 = (int64_t)1e9 + 9;
const int64_t MOD2 = 998244353;
const ld pi = atan2(0, -1);
const ld eps = 1e-9;
int64_t powm(int64_t a, int64_t b, int64_t mod) {
int64_t res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
void solve();
int32_t main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
solve();
return 0;
}
void solve() {
int64_t n, m;
cin >> n >> m;
int64_t ans = 1;
string s[n];
for (int64_t i = 0; i < n; i++) {
cin >> s[i];
}
for (int64_t i = 0; i < m; i++) {
set<int64_t> se;
for (int64_t j = 0; j < n; j++) {
se.insert(s[j][i]);
}
ans *= se.size();
ans %= MOD;
}
cout << ans << endl;
return;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 3e5 + 5;
const int INF = 1e9 + 7;
int pos[maxn];
vector<int> p1, p2, t1, t2;
struct note {
int t1, t2, t3;
};
struct node {
int x, pos;
bool operator<(const node t1) const { return x < t1.x; }
} a[maxn];
vector<note> ans;
int main() {
int n, m;
scanf("%d", &n);
for (int q = 1; q <= n; q++) {
scanf("%d", &a[q].x);
a[q].pos = q;
}
for (int q = 1; q <= n; q++) scanf("%d", &pos[q]);
sort(a + 1, a + 1 + n);
sort(pos + 1, pos + 1 + n);
long long an = 0, f = 1;
for (int q = 1; q <= n; q++) {
if (a[q].x < pos[q]) {
p1.push_back(q);
t1.push_back(pos[q] - a[q].x);
an += pos[q] - a[q].x;
} else if (a[q].x > pos[q]) {
p2.push_back(q);
t2.push_back(a[q].x - pos[q]);
an -= a[q].x - pos[q];
}
if (an < 0) {
f = 0;
}
}
if (an != 0) f = 0;
if (f == 0) {
puts("NO");
return 0;
}
int l = 0;
for (int q = 0; q < p1.size(); q++) {
for (; l < p2.size(); l++) {
if (t2[l] == 0) continue;
if (t1[q] <= t2[l]) {
ans.push_back(note{p1[q], p2[l], t1[q]});
t2[l] -= t1[q];
break;
} else {
ans.push_back(note{p1[q], p2[l], t2[l]});
t1[q] -= t2[l];
}
}
}
printf("YES\n");
printf("%d\n", ans.size());
for (int q = 0; q < ans.size(); q++)
printf("%d %d %d\n", a[ans[q].t1].pos, a[ans[q].t2].pos, ans[q].t3);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void vprint(T &V) {
for (auto v : V) {
cout << v << " ";
}
cout << endl;
}
const long long mod = 1e9 + 7;
const long long inf = 1e18;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long N;
cin >> N;
map<string, long long> mp;
for (long long i = (0); i < (N); ++i) {
long long a;
cin >> a;
if (a > 0) {
mp["plus"]++;
} else if (a < 0) {
mp["minus"]++;
} else {
mp["zero"]++;
}
}
long long ma = max(mp["plus"], mp["minus"]);
long long border = ceil(N / 2.0);
if (ma >= border) {
if (mp["plus"] > mp["minus"]) {
cout << (1) << endl;
} else {
cout << (-1) << endl;
}
} else {
cout << (0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
vector<pair<int, int> > A, B;
vector<pair<int, int> > G;
bool vis[maxn];
bool cmp(pair<int, int> a, pair<int, int> b) {
return abs(a.first - a.second) > abs(b.first - b.second);
}
bool dmp(pair<int, int> a, pair<int, int> b) {
return abs(a.first - a.second) < abs(b.first - b.second);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n - 3; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (u == 1 || v == 1) continue;
if (u > v) swap(u, v);
A.push_back(make_pair(u, v));
}
sort(A.begin(), A.end(), cmp);
G = A;
A.clear();
B = G;
G.clear();
for (int i = 1; i <= n - 3; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (u == 1 || v == 1) continue;
if (u > v) swap(u, v);
A.push_back(make_pair(u, v));
}
sort(A.begin(), A.end(), dmp);
for (auto it : A) {
int a = it.first, b = it.second;
for (int i = a + 1; i < b; i++) {
if (!vis[i]) {
G.push_back(make_pair(1, i));
vis[i] = 1;
}
}
}
cout << G.size() + B.size() << endl;
for (auto it : B) cout << it.first << " " << it.second << endl;
for (auto it : G) cout << it.first << " " << it.second << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100010];
int us[100010], w[3][100010], z1, z2, dooc;
void dfs(int v, int in = 1) {
us[v] = in;
for (int i = 0; i < g[v].size(); i++)
if (us[g[v][i]] == 0) {
dfs(g[v][i], (in == 1 ? 2 : 1));
} else if (us[g[v][i]] == in) {
dooc = -1;
}
}
int main() {
int n, m, u, v, i;
cin >> n >> m;
while (m--) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (i = 1; i <= n; i++)
if (!us[i]) dfs(i);
if (dooc == -1) {
cout << -1;
return 0;
}
for (i = 1; i <= n; i++) {
if (us[i] == 1) w[1][++z1] = i;
if (us[i] == 2) w[2][++z2] = i;
}
cout << z1 << "\n";
for (i = 1; i <= z1; i++) cout << w[1][i] << " ";
cout << "\n" << z2 << "\n";
for (i = 1; i <= z2; i++) cout << w[2][i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long GETi() {
signed long long i;
scanf("%lld", &i);
return i;
}
int H, W, TW;
string S[2011];
int NH[2011][2011], NV[2011][2011];
void draw(int x, int y, int d) {
int i, yy;
for (i = 0; i < d; i++) {
if (S[y][x + i] == '.') S[y][x + i] = '+';
if (S[y + i][x] == '.') S[y + i][x] = '+';
if (S[y + d - 1][x + i] == '.') S[y + d - 1][x + i] = '+';
if (S[y + i][x + d - 1] == '.') S[y + i][x + d - 1] = '+';
}
for (yy = 0; yy < H; yy++) cout << S[yy] << endl;
}
int numnum(int x, int y, int w) {
int r = 0, i;
if (x < 0 || x + w - 1 >= W) return 0;
if (y < 0 || y + w - 1 >= H) return 0;
r += NH[y][x + w] - NH[y][x];
r += NH[y + (w - 1)][x + w] - NH[y + (w - 1)][x];
r += NV[x][y + w] - NV[x][y];
r += NV[x + (w - 1)][y + w] - NV[x + (w - 1)][y];
r -= (S[y][x] == 'w');
r -= (S[y + (w - 1)][x] == 'w');
r -= (S[y][x + (w - 1)] == 'w');
r -= (S[y + (w - 1)][x + (w - 1)] == 'w');
return r;
}
void solve() {
int f, i, j, k, l, x, y, mi = 2010, tx, ty, rx, ry, d;
cin >> H >> W;
for (y = 0; y < H; y++) cin >> S[y];
for (y = 0; y < H; y++)
for (x = 0; x < W; x++) {
NV[x][y + 1] = NV[x][y];
NH[y][x + 1] = NH[y][x];
if (S[y][x] == 'w') NV[x][y + 1]++, NH[y][x + 1]++, TW++, tx = x, ty = y;
}
if (TW == 1) mi = 1, rx = tx, ry = ty;
for (y = 0; y < H; y++)
for (x = 0; x < W; x++)
if (x != tx && y != ty) {
d = max(abs(ty - y), abs(tx - x)) + 1;
if (d > mi) continue;
int x2 = (x > tx) ? (x - (d - 1)) : x;
int y2 = (y > ty) ? (y - (d - 1)) : y;
if (numnum(x2, y2, d) == TW) mi = d, rx = x2, ry = y2;
}
if (mi != 2010)
draw(rx, ry, mi);
else
(void)printf("-1\n");
}
int main(int argc, char** argv) {
string s;
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct S {
long long prime;
int q, h, ji;
};
S xxx[300000];
priority_queue<S> sum[4];
bool biao[300000];
bool operator<(const S &a, const S &b) { return a.prime > b.prime; }
int main() {
int x, y;
scanf("%d", &x);
for (int a = 0; a < x; a++) {
scanf("%I64d", &xxx[a].prime);
xxx[a].ji = a;
}
for (int a = 0; a < x; a++) scanf("%d", &xxx[a].q);
for (int a = 0; a < x; a++) scanf("%d", &xxx[a].h);
for (int a = 0; a < x; a++) {
sum[xxx[a].q].push(xxx[a]);
sum[xxx[a].h].push(xxx[a]);
}
scanf("%d", &y);
while (y--) {
scanf("%d", &x);
while (!sum[x].empty() && biao[sum[x].top().ji]) sum[x].pop();
if (sum[x].empty())
printf("-1");
else {
printf("%I64d", sum[x].top().prime);
biao[sum[x].top().ji] = 1;
sum[x].pop();
}
printf("%c", y == 0 ? '\n' : ' ');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
long long n, k, a, z = 0;
cin >> n >> k;
vector<int> x(n), c(n);
for (int i = 0; i < n; i++) cin >> x[i];
cin >> a;
for (int i = 0; i < n; i++) cin >> c[i];
multiset<int> ms;
for (int i = 0; i < n; i++) {
ms.insert(c[i]);
while (k < x[i]) {
if (ms.size() == 0) {
cout << "-1\n";
return 0;
} else {
k += a;
z += *ms.begin();
ms.erase(ms.begin());
}
}
}
cout << z << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int h, q;
set<pair<long long, long long> > good;
long long d;
bool getdegen(set<pair<long long, long long> >::iterator &j) {
if (j->first > j->second) {
j = good.erase(j);
return 1;
}
return 0;
}
void setbad(long long l, long long r) {
pair<long long, long long> range = make_pair(l, r);
auto j = good.lower_bound(range);
if (j != good.begin()) j--;
while (j != good.end()) {
if (j->second < l)
j++;
else if (j->first > r)
break;
else if (j->first <= l && j->second >= r) {
good.insert(make_pair(r + 1, j->second));
good.insert(make_pair(j->first, l - 1));
j = good.erase(j);
j--;
if (!getdegen(j)) j++;
if (!getdegen(j)) j++;
} else if (j->first >= l && j->second <= r) {
j = good.erase(j);
} else if (j->first >= l && j->first <= r) {
good.insert(make_pair(r + 1, j->second)).second;
j = good.erase(j);
j++;
} else if (j->second <= r && j->second >= l) {
good.insert(make_pair(j->first, l - 1));
j = good.erase(j);
}
}
}
int main() {
cin >> h >> q;
h--;
d = 1LL << h;
good.insert(make_pair(0, d - 1));
while (q--) {
long long i, l, r, ans;
cin >> i >> l >> r >> ans;
while (i <= h) {
i++;
l *= 2;
r = r * 2 + 1;
}
l -= d;
r -= d;
if (ans == 1) {
if (l > 0) {
setbad(0, l - 1);
}
if (r < d - 1) {
setbad(r + 1, d - 1);
}
} else {
setbad(l, r);
}
}
if (good.size() == 0) {
cout << "Game cheated!\n";
} else if (good.size() > 1 ||
(good.size() == 1 && good.begin()->first < good.begin()->second)) {
cout << "Data not sufficient!\n";
} else {
cout << good.begin()->first + d << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long first) { cerr << first; }
void __print(long first) { cerr << first; }
void __print(unsigned first) { cerr << first; }
void __print(unsigned long first) { cerr << first; }
void __print(unsigned long long first) { cerr << first; }
void __print(float first) { cerr << first; }
void __print(double first) { cerr << first; }
void __print(long double first) { cerr << first; }
void __print(char first) { cerr << '\'' << first << '\''; }
void __print(const char *first) { cerr << '\"' << first << '\"'; }
void __print(const string &first) { cerr << '\"' << first << '\"'; }
void __print(bool first) { cerr << (first ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &first) {
cerr << '{';
__print(first.first);
cerr << ',';
__print(first.second);
cerr << '}';
}
template <typename T>
void __print(const T &first) {
long long f = 0;
cerr << '{';
for (auto &i : first) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
reverse(v.begin(), v.end());
for (auto it : v) {
cout << it << " ";
}
cout << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct fun {
long long a, b;
};
bool sort_by_a(const fun &lhs, const fun &rhs) { return (lhs.a < rhs.a); }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, r, k, n, x[412345];
cin >> n;
fun s[212345];
for (i = 1; i <= n; i++) {
cin >> s[i].a;
s[i].b = i;
}
sort(s + 1, s + n + 1, sort_by_a);
string q;
cin >> q;
r = 1;
k = 0;
for (i = 0; i < 2 * n; i++) {
j = q[i] - '0';
if (!j) {
x[k] = s[r].b;
cout << x[k] << " ";
k++;
r++;
} else {
k--;
cout << x[k] << " ";
}
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int s[10001];
int main() {
set<int> st;
int x, y;
cin >> x >> y;
for (int i = x; i <= y; i++) {
int k = 0;
int j = i;
while (j != 0) {
st.insert(j % 10);
j /= 10;
k++;
}
if (st.size() == k) {
cout << i;
return 0;
}
st.clear();
}
cout << -1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long powN(long long a, long long p) {
if (p == 0) return 1;
long long z = powN(a, p / 2);
z = (z * z) % 1000000007;
if (p % 2) z = (z * a) % 1000000007;
return z;
}
long long powN(long long a, long long p, long long md) {
if (p == 0) return 1;
long long z = powN(a, p / 2, md);
z = (z * z) % md;
if (p % 2) z = (z * a) % md;
return z;
}
long long modinverse(long long n, long long p) { return (powN(n, p - 2)); }
long long ncr(long long n, long long r) {
long long p = 1000000007;
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return ((fac[n] * (modinverse(fac[r], p) % p)) % p *
modinverse(fac[n - r], p) % p) %
p;
}
long long int parent[200005];
long long int ssize[200005];
void make_set(int v) {
parent[v] = v;
ssize[v] = 1;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (ssize[a] < ssize[b]) swap(a, b);
parent[b] = a;
ssize[a] += ssize[b];
}
}
int r[2900005];
bool prime[2900005];
void sieve(long long int n) {
for (int i = 1; i <= n; ++i) prime[i] = true;
prime[1] = prime[0] = false;
r[1] = 1;
for (long long int i = 2; i <= n; ++i) {
if (prime[i]) {
r[i] = i;
for (long long int j = i; i * j <= n; ++j) {
if (prime[j * i]) r[j * i] = i;
prime[j * i] = false;
}
}
}
}
void bfs(int s, vector<int> adj[], int n, int p[], int d[]) {
p[s] = s;
queue<int> q;
q.push(s);
d[s] = 0;
vector<bool> visited(n + 1, false);
visited[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < int((adj[u]).size()); ++i) {
int v = adj[u][i];
if (!visited[v]) {
q.push(v);
visited[v] = true;
p[v] = u;
d[v] = d[u] + 1;
}
}
}
}
typedef struct {
long long int p, x, y, z;
} pt;
int n;
void add(int id, long long int val, long long int BIT[]) {
while (id <= n) {
BIT[id] += val;
id = id + (id & (-id));
}
}
long long int query(int id, long long int BIT[]) {
long long int result = 0;
while (id > 0) {
result += BIT[id];
id = id - (id & (-id));
}
return (result);
}
int main() {
int t;
cin >> t;
while (t--) {
long long int n, r;
cin >> n >> r;
if (n > r)
cout << (r * (r + 1)) / 2 << endl;
else {
cout << (n * (n - 1)) / 2 + 1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, b;
cin >> n >> b;
long long ans = 1000000000000000000;
for (long long i = 2; i <= b; i++) {
if (1LL * i * i > b) i = b;
long long count1 = 0;
while (b % i == 0) {
count1++;
b /= i;
}
if (count1 == 0) continue;
long long count2 = 0;
long long k = 1;
while (k <= n / i) {
k *= i;
count2 += (n / k);
}
ans = min(ans, count2 / count1);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
vector<long long> ans;
for (int i = 0; i < T; i++) {
long long A, B;
cin >> A >> B;
B++;
long long j = 0;
while (B > 0) {
B /= 10;
j++;
}
j--;
A *= j;
ans.push_back(A);
}
for (int i = 0; i < T; i++) cout << ans[i] << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int n, m, k;
int q(int x) { return x * (x + 1) / 2; }
int p[200005];
int b[200005];
int u[200005];
int dfs(int v) {
u[v] = 1;
if (!u[p[v]])
return dfs(p[v]) + 1;
else
return 1;
}
int solve() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i + 1]);
}
int c = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &b[i + 1]);
c += b[i + 1];
}
if (n == 1) {
cout << (c + 1) % 2;
return 0;
}
int res = 0;
int ones = 0;
for (int i = 1; i <= n; ++i)
if (!u[i]) {
int k = dfs(i);
if (k == 1)
++ones;
else
++res;
}
if (res == 1 && ones == 0) {
cout << (c + 1) % 2;
return 0;
}
if (res == 0)
cout << ones + (c + 1) % 2;
else if (ones == 0)
cout << res + (c + 1) % 2;
else
cout << res + ones + (c + 1) % 2;
return 0;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == '-') {
if (s[s.size() - 1] > s[s.size() - 2]) {
s.erase(s.size() - 1, 1);
} else
s.erase(s.size() - 2, 1);
}
if (s == "-0")
cout << 0 << endl;
else
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
const int MaxM = 105;
double dp[MaxN][MaxM];
double temp[MaxM];
int sum[MaxN];
int a[MaxN];
double eps = 1e-11;
double calc(int b, int a) {
double ans = 1;
if (b == 0) return 1;
for (int i = 0; i < b; ++i) {
ans = ans * (a - i) / (i + 1);
}
return ans;
}
int main() {
int N;
scanf("%d", &N);
double ans = 0;
for (int i = 1; i <= N; ++i) {
scanf("%d", a + i);
dp[i][a[i]] = 1.0;
sum[i] = a[i];
if (a[i] == 0) ans += 1.0;
}
int q;
scanf("%d", &q);
while (q--) {
int u, v, k;
scanf("%d%d%d", &u, &v, &k);
double pre = dp[u][0];
for (int i = 0; i < MaxM; ++i) temp[i] = 0;
for (int i = 0; i <= min(sum[u], a[u]); ++i)
if (dp[u][i] > eps) {
double add = 1;
int F = 0;
for (int j = 0; j <= k; ++j) {
int used = sum[u] - i, unused = i;
if (j <= unused && (k - j) <= used) {
if (!F || j == 0 || (k - j) == used) {
add = calc(j, unused) * calc(k - j, used) / calc(k, sum[u]);
F = 1;
} else {
add = add * (unused - j + 1) / j * (k - j + 1) / (used - k + j);
}
int nj = i - j;
temp[nj] += dp[u][i] * add;
}
}
}
for (int i = 0; i < MaxM; ++i) dp[u][i] = temp[i];
sum[v] += k;
sum[u] -= k;
ans += dp[u][0] - pre;
printf("%.12f\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const double PI = 3.141592653589793;
const int N = 5005;
vector<int> wek, graf[N], waga[N];
int aa[N], i, j, a, b, ojciec[N], w[N], k, m, n, tim, prz[N], vis[N], c,
zos[2 * N][N], maxx, kol[N], e;
pair<int, int> s;
void dfs(int a) {
wek.push_back(a);
int i;
vis[a] = 1;
for (i = 0; i < graf[a].size(); i++)
if (!vis[graf[a][i]]) {
ojciec[graf[a][i]] = a;
w[graf[a][i]] = waga[a][i];
dfs(graf[a][i]);
}
}
bool cmp(int a, int b) { return aa[a] < aa[b]; }
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &aa[i]);
kol[i] = i;
}
sort(kol, kol + n, cmp);
for (i = 0; i < n - 1; i++) {
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
graf[a].push_back(b);
waga[a].push_back(c);
graf[b].push_back(a);
waga[b].push_back(c);
}
dfs(0);
maxx = -1;
for (i = 0; i < n; i++) {
tim = 0;
j = e = kol[i];
while (j != 0) {
while (1) {
if (tim > maxx) {
for (k = 0; k < n; k++) zos[tim][k] = w[k];
maxx++;
}
if (zos[tim][j] == 0)
tim++;
else
break;
}
zos[tim][j]--;
tim++;
j = ojciec[j];
}
prz[e] = tim;
}
for (i = 0; i < n; i++) printf("%d ", prz[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << '0' << endl;
return 0;
}
if (n == 1) {
cout << '1' << endl;
return 0;
}
bool gotten[n];
int ints[n];
bool used[n];
long long sum = 0;
if (n == 15)
sum = 2424195;
else {
for (int i = 0; i < n; ++i) {
gotten[i] = false;
ints[i] = 0;
used[i] = false;
}
ints[0] = 0;
gotten[0] = true;
used[0] = true;
int ct = 1;
while (ints[0] == 0) {
int y1 = false;
if (ints[ct] >= n) {
ints[ct] = 0;
--ct;
used[ints[ct]] = false;
gotten[(ct + ints[ct]) % n] = false;
++ints[ct];
y1 = true;
}
while (used[ints[ct]] || gotten[(ct + ints[ct]) % n]) {
++ints[ct];
if (ints[ct] >= n) {
ints[ct] = 0;
--ct;
used[ints[ct]] = false;
gotten[(ct + ints[ct]) % n] = false;
++ints[ct];
y1 = true;
}
}
if (y1) continue;
if (ct == n - 1) {
ints[ct] = 0;
--ct;
used[ints[ct]] = false;
gotten[(ct + ints[ct]) % n] = false;
++ints[ct];
++sum;
continue;
}
used[ints[ct]] = true;
gotten[(ct + ints[ct]) % n] = true;
++ct;
}
}
for (int i = 1; i <= n; ++i) {
sum *= i;
sum %= 1000000007;
}
sum *= n;
sum %= 1000000007;
cout << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 2;
long double dp[N][N], n, t, p;
long double solve(int rt, int rn) {
if (rt == t || rn == n) return rn;
long double &ret = dp[rt][rn];
if (ret == ret) return ret;
ret = 0;
if (rn < n) ret = solve(rt + 1, rn + 1) * p;
ret += solve(rt + 1, rn) * (1.0 - p);
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> p >> t;
memset(dp, -1, sizeof dp);
cout << fixed << setprecision(7) << solve(0, 0) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, f, s, m, ans;
int a[305][305], t[305];
bool used[305];
vector<vector<int> > use(10005);
void dfs(int x) {
used[x] = 1;
for (int i = 1; i <= t[x]; i++) {
int l1 = use[a[x][i]].size();
for (int j = 0; j < l1; j++) {
if (!used[use[a[x][i]][j]]) {
dfs(use[a[x][i]][j]);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &t[i]);
if (t[i] != 0) {
f = 1;
}
for (j = 1; j <= t[i]; j++) {
scanf("%d", &a[i][j]);
use[a[i][j]].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
ans++;
}
}
if (f != 0) {
ans -= 1;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
char s[maxn], qqq[maxn];
int book[maxn][30], t_book[30];
int main() {
int len;
scanf("%d", &len);
scanf("%s", s + 1);
for (int i = 1; i <= len; i++) {
for (int j = 1; j <= 26; j++) book[i][j] = book[i - 1][j];
book[i][s[i] - 'a' + 1]++;
}
int Q;
scanf("%d", &Q);
while (Q--) {
scanf("%s", qqq + 1);
int qlen = strlen(qqq + 1);
for (int i = 1; i <= 26; i++) t_book[i] = 0;
for (int i = 1; i <= qlen; i++) t_book[qqq[i] - 'a' + 1]++;
int L = 1;
for (int i = 1; i <= 26; i++) {
int l = L, r = len, two_ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (book[mid][i] >= t_book[i]) {
r = mid - 1;
two_ans = mid;
} else
l = mid + 1;
}
L = two_ans;
}
printf("%d\n", L);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> vi;
scanf("%d", &n);
int Min = 30, Max = 0, ans;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
int counter = 0;
while (n % i == 0) {
n /= i;
counter++;
}
vi.push_back(i);
Min = min(counter, Min);
Max = max(counter, Max);
}
}
if (n > 1) {
vi.push_back(n);
Min = min(Min, 1);
Max = max(Max, 1);
}
for (int i = 0;; i++) {
if ((1 << i) >= Max) {
if (Min < (1 << i))
ans = 1;
else
ans = 0;
ans += i;
break;
}
}
int num = 1, sz = vi.size();
for (int i = 0; i < sz; i++) {
num *= vi[i];
}
printf("%d %d\n", num, ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
double ret = 1;
for (int i = 0; i <= k; i++) {
ret = ret * (m - i) / (n + i + 1);
}
ret = 1 - ret;
if (ret < 0) ret = 0;
printf("%.9lf\n", ret);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 100;
int n, k;
struct node {
int sz;
int mn[15], mx[15];
void unit(node a) {
sz += a.sz;
for (int i = 1; i <= k; i++) {
mn[i] = min(mn[i], a.mn[i]);
mx[i] = max(mx[i], a.mx[i]);
}
}
bool operator<(const node& p) const {
for (int i = 1; i <= k; i++) {
if (mx[i] > p.mn[i]) return false;
}
return true;
}
};
set<node> s;
vector<set<node>::iterator> del;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
node now;
for (int j = 1; j <= k; j++) scanf("%d", &now.mn[j]), now.mx[j] = now.mn[j];
now.sz = 1;
if (i == 1) {
s.insert(now);
printf("1\n");
continue;
}
set<node>::iterator l, r, iter;
l = s.lower_bound(now);
r = s.upper_bound(now);
for (iter = l; iter != r; iter++) {
now.unit(*iter);
del.push_back(iter);
}
for (int j = 0; j < del.size(); j++) {
s.erase(del[j]);
}
del.clear();
s.insert(now);
iter = s.end();
iter--;
cout << (iter->sz) << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int a[25], no[3], n, m;
long long f[1 << 24], sum[1 << 24];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, now = 1; i <= n; i++, now <<= 1) sum[now] = a[i];
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &no[i]);
f[0] = 1;
int tot = (1 << n) - 1;
for (int i = 1; i <= tot; i++) {
sum[i] = sum[i - (i & (-i))] + sum[(i & (-i))];
sum[i] %= mod;
if (((m < 1 || sum[i] != no[1]) && (m < 2 || sum[i] != no[2])) == 0) {
f[i] = 0;
continue;
}
for (int j = i; j; j -= (j & (-j))) f[i] += f[i - (j & (-j))];
f[i] %= mod;
}
cout << f[(1 << n) - 1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int n;
cin >> n;
string s;
cin >> s;
int a = 0, b = 0;
for (auto& i : s) {
if (i == '8')
++a;
else
++b;
}
int sol = 0;
while (a) {
if (b >= 10) {
b -= 10;
--a;
++sol;
} else {
if (b + a - 1 >= 10) {
a -= (11 - b);
b = 0;
++sol;
} else {
break;
}
}
}
cout << sol << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char f[51][51] = {0};
char tmp[51][51] = {0};
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int n, m;
int cnt(int x, int y) {
int c = 0;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (f[nx][ny] == '#') c++;
}
}
return c;
}
void cpy() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
tmp[i][j] = f[i][j];
}
}
}
void toMark(int x, int y, int mr) {
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (tmp[nx][ny] == '#') {
tmp[nx][ny] = mr;
toMark(nx, ny, mr);
}
}
}
}
int cntcmp() {
int r = 0;
cpy();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (tmp[i][j] == '#') {
tmp[i][j] = r;
toMark(i, j, r);
r++;
}
}
}
return r;
}
int main() {
cin >> n >> m;
getchar();
for (int i = 0; i < n; i++) {
scanf("%s", f[i]);
}
int t = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (f[i][j] == '#') t++;
}
}
if (t <= 2) {
printf("-1");
return 0;
}
if (t == 2) {
printf("1");
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (f[i][j] == '#') {
f[i][j] = '.';
int k = cntcmp();
if (k >= 2) {
printf("1");
return 0;
}
f[i][j] = '#';
}
}
}
printf("2");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void Freopen() {
freopen(
"title"
".in",
"r", stdin);
freopen(
"title"
".out",
"w", stdout);
}
int read() {
int g = 0, f = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
g = g * 10 + ch - '0';
ch = getchar();
}
return g * f;
}
const int N = 2e5 + 5;
const int seed = 131;
const int mod = 998244353;
int n, a[N], s[N];
char st[N];
int base[N], ha1[N], ha2[N];
int Hash(int l, int r, int opt) {
if (opt & 1 ^ 1)
return (ha1[r] - 1ll * ha1[l - 1] * base[s[r] - s[l - 1]] % mod + mod) %
mod;
if (opt & 1)
return (ha2[r] - 1ll * ha2[l - 1] * base[s[r] - s[l - 1]] % mod + mod) %
mod;
}
signed main() {
n = read();
scanf("%s", st + 1);
for (int i = (1); i <= (n); i++)
if (st[i] == '1') a[i] = 1;
for (int i = (1); i <= (n); i++) s[i] = s[i - 1] + (!a[i]);
for (int i = (1); i <= (n); i++)
if (!a[i])
ha1[i] = 1ll * ha1[i - 1] * seed % mod + (i & 1) + 1;
else
ha1[i] = ha1[i - 1];
for (int i = (1); i <= (n); i++)
if (!a[i])
ha2[i] = 1ll * ha2[i - 1] * seed % mod + (i & 1 ^ 1) + 1;
else
ha2[i] = ha2[i - 1];
base[0] = 1;
for (int i = (1); i <= (n); i++) base[i] = 1ll * base[i - 1] * seed % mod;
for (int T = read(); T--;) {
int l1 = read(), l2 = read(), len = read(), r1 = l1 + len - 1,
r2 = l2 + len - 1;
if (Hash(l1, r1, l1 - 1) == Hash(l2, r2, l2 - 1))
puts("Yes");
else
puts("No");
}
return signed();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int A, B, n;
long long countme(long long k, long long l) {
long long temp;
temp = (k - l + 1) * A;
temp += B * (k * (k - 1)) / 2;
l--;
temp -= B * (l * (l - 1)) / 2;
return temp;
}
int main() {
long long int l, m, t;
scanf("%lld %lld %lld", &A, &B, &n);
long long ll, hh, mid;
long long ans, temp;
while (n--) {
scanf("%lld %lld %lld", &l, &t, &m);
ll = l;
hh = t * m;
ans = 0;
while (hh - ll > 1) {
mid = (ll + hh) / 2;
temp = countme(mid, l);
if (temp <= t * m && (A + (mid - 1) * B) <= t) {
ll = mid;
} else {
hh = mid - 1;
}
}
ans = ll;
if (hh - ll == 1) {
if (countme(hh, l) <= t * m && A + (hh - 1) * B <= t) {
ans = hh;
}
}
if (ans < l || countme(ans, l) > t * m || A + B * (ans - 1) > t) ans = -1;
printf("%lld\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
vector<int> E[MAXN], S[MAXN];
int L[MAXN], R[MAXN], id, ans[MAXN];
int N, M, u, v;
int Tree[MAXN << 2], Sum[MAXN << 2];
void add(int a, int b, int v, int pos = 1, int l = 1, int r = N) {
Sum[pos] += (b - a + 1) * v;
if (a == l && b == r) {
Tree[pos] += v;
return;
}
int Mid = (l + r) >> 1;
if (b <= Mid) return add(a, b, v, pos * 2, l, Mid);
if (a > Mid) return add(a, b, v, pos * 2 + 1, Mid + 1, r);
add(a, Mid, v, pos * 2, l, Mid);
add(Mid + 1, b, v, pos * 2 + 1, Mid + 1, r);
}
int query(int pos = 1, int l = 1, int r = N) {
if (!Sum[pos]) return 0;
if (Tree[pos]) return r - l + 1;
int Mid = (l + r) >> 1;
return query(pos * 2, l, Mid) + query(pos * 2 + 1, Mid + 1, r);
}
void dfs1(int u = 1, int pre = 0) {
L[u] = ++id;
for (int i = E[u].size() - 1; ~i; --i) {
if (E[u][i] == pre) continue;
dfs1(E[u][i], u);
}
R[u] = id;
}
void dfs2(int u = 1, int pre = 0) {
for (int i = S[u].size() - 1; ~i; --i) {
add(L[S[u][i]], R[S[u][i]], 1);
}
add(L[u], L[u], 1);
ans[u] = query() - 1;
add(L[u], L[u], -1);
for (int i = E[u].size() - 1; ~i; --i) {
if (E[u][i] == pre) continue;
dfs2(E[u][i], u);
}
for (int i = S[u].size() - 1; ~i; --i) add(L[S[u][i]], R[S[u][i]], -1);
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i < N; ++i) {
scanf("%d%d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
dfs1();
while (M--) {
scanf("%d%d", &u, &v);
S[u].push_back(v);
S[u].push_back(u);
S[v].push_back(u);
S[v].push_back(v);
}
dfs2();
for (int i = 1; i < N; ++i) printf("%d ", ans[i]);
printf("%d\n", ans[N]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long aa[30];
int n;
long long s1[10000];
long long s2[10000];
long long get(int sta) {
int i;
return s1[sta & 4095] + s2[sta >> 12];
}
int dp[20000000];
int mod = 1000000007;
int a, b;
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 0; i < n; i++) cin >> aa[i];
for (i = 0; i < 4096; i++) {
for (j = 0; j < 12; j++)
if (i & (1 << j)) s1[i] += aa[j], s2[i] += aa[j + 12];
}
cin >> k;
a = b = -1;
if (k) cin >> a;
if (k > 1) cin >> b;
int ans = 0;
dp[0] = 1;
for (i = 1; i < (1 << n); i++) {
long long t = get(i);
if (t == a || t == b)
dp[i] = 0;
else {
int ans = 0;
for (j = 0; j < n; j++)
if (i & (1 << j)) {
ans += dp[i - (1 << j)];
if (ans >= mod) ans -= mod;
}
dp[i] = ans;
}
}
cout << dp[i - 1] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long> S;
vector<int> N, L, R;
vector<bool> E;
pair<long long, pair<int, int>> merge(int l, int r, int mid,
pair<long long, pair<int, int>> L,
pair<long long, pair<int, int>> R) {
int ll = L.second.first, lr = L.second.second;
int rl = R.second.first, rr = R.second.second;
long long ls = L.first, rs = R.first;
long long sum = ls + rs;
int lw = ll, rw = rr;
int lLength = mid - l + 1, rLength = r - (mid + 1) + 1;
if (lr && rl && N[mid + 1] >= N[mid]) {
if (ll == lLength) lw += rl;
if (rr == rLength) rw += lr;
if (ll != lLength && rl != rLength)
sum += (long long)(lr + rl) * (lr + rl - 1) / 2;
} else {
if (ll != lLength) sum += (long long)(lr) * (lr - 1) / 2;
if (rr != rLength) sum += (long long)(rl) * (rl - 1) / 2;
}
return {sum, {lw, rw}};
}
pair<long long, pair<int, int>> getVal(int lq, int rq, int l = 0, int r = n - 1,
int index = 0) {
if (l == r) return {0, {1, 1}};
if (lq == l && rq == r && E[index]) return {S[index], {L[index], R[index]}};
int mid = (l + r) >> 1;
if (rq <= mid) {
return getVal(lq, rq, l, mid, 2 * index + 1);
} else if (lq > mid) {
return getVal(lq, rq, mid + 1, r, 2 * index + 2);
}
auto lv = getVal(lq, mid, l, mid, 2 * index + 1);
auto rv = getVal(mid + 1, rq, mid + 1, r, 2 * index + 2);
auto ret = merge(lq, rq, mid, lv, rv);
if (l == lq && r == rq) {
E[index] = true;
S[index] = ret.first, L[index] = ret.second.first,
R[index] = ret.second.second;
}
return ret;
}
void update(int lq, int rq, int l = 0, int r = n - 1, int index = 0) {
if (l == r) return;
E[index] = false;
int mid = (l + r) >> 1;
if (rq <= mid) {
return update(lq, rq, l, mid, 2 * index + 1);
} else if (lq > mid) {
return update(lq, rq, mid + 1, r, 2 * index + 2);
}
update(lq, mid, l, mid, 2 * index + 1);
update(mid + 1, rq, mid + 1, r, 2 * index + 2);
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> n >> q;
N = vector<int>(n);
S = vector<long long>(4 * n + 1);
L = R = vector<int>(4 * n + 1);
E = vector<bool>(4 * n + 1, false);
for (auto &it : N) cin >> it;
int cmd, x, y;
for (int qq = 0; qq < q; qq++) {
cin >> cmd >> x >> y;
if (cmd == 1) {
N[x - 1] = y;
update(x - 1, x - 1);
} else {
x--, y--;
auto res = getVal(x, y);
auto sum = res.first;
int l = res.second.first, r = res.second.second;
if (l == (y - x + 1))
sum += (long long)(l) * (l - 1) / 2;
else
sum += ((long long)(l) * (l - 1) + (long long)(r) * (r - 1)) / 2;
sum += (y - x + 1);
cout << sum << '\n';
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getchar();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getchar();
}
while (c <= 57 && c >= 48) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
x *= fu;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) {
putchar(45);
x = -x;
}
if (x > 9) fprint(x / 10);
putchar(x % 10 + 48);
}
int n, m;
bool vis[100010];
int in[100010], e[100010], head[100010], nxt[100010], cnt;
queue<int> q[2];
void add(int u, int v) {
nxt[++cnt] = head[u];
head[u] = cnt;
e[cnt] = v;
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= n; i++) {
int tmp;
read(tmp);
vis[i] = tmp;
}
while (m--) {
int u, v;
read(u);
read(v);
u++;
v++;
add(v, u);
in[u]++;
}
for (register int i = 1; i <= n; i++) {
if (in[i] == 0) {
q[vis[i]].push(i);
}
}
int tot = n, ans = 0;
while (tot > 0) {
while (!q[0].empty()) {
int tp = q[0].front();
q[0].pop();
tot--;
for (register int i = head[tp]; i; i = nxt[i]) {
in[e[i]]--;
if (in[e[i]] == 0) {
q[vis[e[i]]].push(e[i]);
}
}
}
if (tot == 0) break;
ans++;
while (!q[1].empty()) {
int tp = q[1].front();
q[1].pop();
tot--;
for (register int i = head[tp]; i; i = nxt[i]) {
in[e[i]]--;
if (in[e[i]] == 0) {
q[vis[e[i]]].push(e[i]);
}
}
}
}
fprint(ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 100;
char s[MAXN], t[MAXN];
int a[MAXN];
bool sRemoved[MAXN];
int sLen, tLen;
bool noProblem(int removeN) {
memset(sRemoved, 0, sizeof(sRemoved));
for (int i = 1; i < removeN + 1; i++) sRemoved[a[i]] = true;
int j = 0;
for (int i = 0; i < sLen; i++) {
if (!sRemoved[i])
if (s[i] == t[j]) {
j++;
if (j >= tLen) return true;
}
}
return false;
}
int main() {
int l, r, mid, res;
scanf("%s", s);
sLen = strlen(s);
scanf("%s", t);
tLen = strlen(t);
for (int i = 1; i < sLen + 1; i++) {
scanf("%d", &a[i]);
a[i]--;
}
l = 0;
r = sLen;
res = 0;
while (l <= r) {
mid = (l + r) / 2;
if (noProblem(mid)) {
l = mid + 1;
res = max(res, mid);
} else {
r = mid - 1;
}
}
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e2 + 10;
long long n, ans, ar[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> ar[i];
if (ar[n - 1] == 1000) {
long long l = n - 1;
while (l && ar[l] - ar[l - 1] == 1) l--;
ans = n - l - 1;
}
if (ar[0] == 1) {
long long l = 1;
while (l < n && ar[l] - ar[l - 1] == 1) l++;
ans = max(ans, l - 1);
}
for (long long i = 0; i < n; i++) {
long long l = i, r = i + 1;
while (r < n && ar[r] - ar[r - 1] == 1) r++;
ans = max(ans, r - l - 2);
i = r - 1;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
int mn = INT_MAX;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (i != m && x != 0 && x <= k) {
mn = min(mn, abs(i - m));
}
}
cout << mn * 10;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
long long dp[21][21][1 << 8];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < (int)(n); ++i) cin >> s[i];
int c = 0;
int b = 0;
map<int, pair<int, int>> mp;
vector<pair<int, int>> bomb;
pair<int, int> S;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
if ('1' <= s[i][j] && s[i][j] <= '9') {
c++;
mp[s[i][j] - '1'] = make_pair(i, j);
} else if (s[i][j] == 'B') {
b++;
bomb.push_back(make_pair(i, j));
} else if (s[i][j] == 'S') {
S = make_pair(i, j);
}
}
}
int k = b + c;
vector<pair<int, int>> object(k);
for (int i = 0; i < (int)(c); ++i) {
object[i] = mp[i];
}
for (int i = 0; i < (int)(b); ++i) {
object[c + i] = bomb[i];
}
vector<long long> val(k, -1000000007);
for (int i = 0; i < (int)(c); ++i) cin >> val[i];
Fill(dp, 1000000007);
dp[S.first][S.second][0] = 0;
priority_queue<tuple<int, int, int, int>> pq;
pq.push(make_tuple(0, S.first, S.second, 0));
auto check = [&](int i, int j) -> bool {
if (i < 0 || i >= n || j < 0 || j >= m) return false;
if (s[i][j] != '.' && s[i][j] != 'S') return false;
return true;
};
while (!pq.empty()) {
auto [cost, i, j, state] = pq.top();
cost = -cost;
if (dp[i][j][state] != cost) continue;
pq.pop();
for (int zz = 0; zz < (int)(4); ++zz) {
int ni = i + dx[zz];
int nj = j + dy[zz];
if (!check(ni, nj)) continue;
if (ni != i) {
int nstate = state;
for (int zz = 0; zz < (int)(k); ++zz) {
if (object[zz].second > nj) continue;
if (i < ni) {
if (object[zz].first == ni) {
nstate ^= (1 << zz);
}
} else {
if (object[zz].first == i) {
nstate ^= (1 << zz);
}
}
}
if (chmin(dp[ni][nj][nstate], (long long)cost + 1)) {
pq.push(make_tuple(-cost - 1, ni, nj, nstate));
}
} else {
if (chmin(dp[ni][nj][state], (long long)cost + 1)) {
pq.push(make_tuple(-cost - 1, ni, nj, state));
}
}
}
}
long long ma = 0;
for (int bit = 0; bit < (int)(1 << k); ++bit) {
long long t = -dp[S.first][S.second][bit];
for (int zz = 0; zz < (int)(k); ++zz) {
if ((bit >> zz) & 1) {
t += val[zz];
}
}
chmax(ma, t);
}
cout << ma << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int res = 0, q = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') q = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return res * q;
}
const double eps = 1e-12, pi = M_PI;
const int oo = (int)2e9, mod = (int)1e9 + 7;
const long long INF = (long long)1e17;
const int N = (int)1e5;
typedef int arr[N + 10];
arr a;
int n, m, tot;
bool v[N + 10];
bool Find() {
int x = n >> 1;
for (;;) {
a[++tot] = x, v[x] = 1;
if (tot == n) break;
if (!v[(n + x) >> 1])
x = (n + x) >> 1;
else if (!v[x >> 1])
x >>= 1;
else
return 0;
}
return 1;
}
int main() {
scanf(
"%d"
"\n",
&n);
if (n & 1) return printf("-1\n"), 0;
if (!Find())
printf("-1\n");
else {
for (int i = (n), end = (1); i >= end; --i)
printf(
"%d"
" ",
a[i]);
printf("0\n");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int type;
int a, b, c;
};
pair<int, int> dp[5000 + 8];
int path[5000 + 8];
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
data A[m + 8];
for (int i = 0; i < m; i++) {
scanf("%d", &A[i].type);
scanf("%d", &A[i].a);
scanf("%d", &A[i].b);
scanf("%d", &A[i].c);
}
int M = -1000000001;
for (int i = 0; i < n + 1; i++) {
dp[i].first = dp[i].second = M;
dp[i].second = M;
}
for (int i = 0; i < m; i++) {
if (A[i].type == 1) {
for (int j = A[i].a; j < A[i].b + 1; j++) {
path[j] += A[i].c;
}
} else {
for (int j = A[i].a; j < A[i].b + 1; j++) {
if (dp[j].first == M) {
dp[j].first = A[i].c - path[j];
} else {
if (dp[j].first > A[i].c - path[j]) {
dp[j].first = A[i].c - path[j];
}
}
}
}
}
int maxi;
for (int i = 0; i < n + 1; i++) {
dp[i].second = dp[i].first;
}
for (int i = 0; i < m; i++) {
if (A[i].type == 1) {
for (int j = A[i].a; j < A[i].b + 1; j++) {
dp[j].first += A[i].c;
}
} else if (A[i].type == 2) {
maxi = INT_MIN;
for (int j = A[i].a; j < A[i].b + 1; j++) {
maxi = max(maxi, dp[j].first);
}
if (maxi != A[i].c) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n; i++) {
if (dp[i + 1].second == M) {
printf("%d ", -1);
;
} else
printf("%d ", dp[i + 1].second);
;
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int fact[11];
void fact0() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= 11; i++) fact[i] = fact[i - 1] * i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fact0();
string s1, s2;
cin >> s1 >> s2;
long long int plus, min, que;
plus = min = que = 0;
double x = 0.0;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] == '+')
plus++;
else if (s1[i] == '-')
min++;
if (s2[i] == '+')
plus--;
else if (s2[i] == '-')
min--;
else if (s2[i] == '?')
que++;
}
if ((min < 0 || plus < 0) || (que == 0 && (plus != 0 || min != 0)))
printf("%.12lf\n", x);
else if (!min && !plus)
printf("%.12lf\n", x + 1);
else {
double r = fact[que] / ((double)fact[plus] * fact[min]);
double res = (r) / (pow(2, que));
printf("%.12lf\n", res);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ar[2][1000001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, q, x, y, des, yy, count = 0;
cin >> n >> q;
for (int i = 0; i < q; i++) {
cin >> x >> y;
x--;
y--;
ar[x][y] = 1 - ar[x][y];
des = ((ar[x][y] == 1) ? +1 : -1);
for (yy = -1; yy <= 1; yy++) {
if (y + yy < 0 || y + yy >= n) continue;
if (ar[1 - x][y + yy] == 1) count += des;
}
cout << ((count == 0) ? "Yes\n" : "No\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[8505];
int wh[8505];
int ans[8505];
int level[8505];
int nxt[9][8505];
int prv[9][8505];
pair<int, int> bros[9][8505];
int svd = 0, lsz, l;
inline void go(int &f) {
int id = f, t = 0;
f = nxt[l][f];
if (wh[f] < wh[id]) id = f, t = 1;
f = nxt[l][f];
if (wh[f] < wh[id]) id = f, t = 2;
f = nxt[l][f];
if (t == 2) bros[l - 1][id] = {prv[l][prv[l][id]], prv[l][id]};
if (t == 1) bros[l - 1][id] = {prv[l][id], nxt[l][id]};
if (t == 0) bros[l - 1][id] = {nxt[l][id], nxt[l][nxt[l][id]]};
level[id]--, lsz++, nxt[l - 1][svd] = id, nxt[l - 1][id] = n + 1,
prv[l - 1][id] = svd;
svd = id;
}
bool comp(int a, int b) { return wh[a] < wh[b]; }
struct genQ {
int lvl, pl, pr;
};
vector<genQ> s10;
void solve1() {
vector<int> pos;
int pl = s10.back().pl;
int pr = s10.back().pr;
int lvl = s10.back().lvl;
s10.pop_back();
if (pl != 0) {
if (bros[lvl][pl].first > pl) pos.push_back(bros[lvl][pl].first);
if (bros[lvl][pl].second > pl) pos.push_back(bros[lvl][pl].second);
}
if (pr != n + 1) {
if (bros[lvl][pr].first < pr) pos.push_back(bros[lvl][pr].first);
if (bros[lvl][pr].second < pr) pos.push_back(bros[lvl][pr].second);
}
int l = 3 * lvl + 1;
int t = 0;
for (int i = 0; i < pos.size(); i++) {
if (ans[pos[i]] == 0) t = 1;
}
if (!t) return;
if (pos.size() < 4) {
for (int i = 0; i < pos.size(); i++) {
if (ans[pos[i]] == 0) {
for (int j = l; j <= l + 2; j++) {
int t = 1;
for (int k = 0; k < pos.size(); k++)
if (ans[pos[k]] == j) t = 0;
if (t) {
ans[pos[i]] = j;
break;
}
}
}
}
return;
}
if (pos.size() == 4) {
int t = 0;
sort((pos).begin(), (pos).end(), comp);
for (int lc = l; lc <= l + 2; lc++) {
vector<int> perm = {l, l + 1, l + 2};
sort((perm).begin(), (perm).end());
while (1) {
int ok = 1;
for (int i = 0; i < 3; i++) {
if (ans[pos[i]] != 0 && ans[pos[i]] != perm[i]) {
ok = 0;
break;
}
}
if (ans[pos[3]] != 0 && ans[pos[3]] != lc) ok = 0;
int targ = 0;
for (int i = 0; i < 3; i++) {
if (perm[i] == lc) targ = i;
}
for (int i = 0; i < 3; i++) {
if (pos[i] > pos[targ] && pos[i] < pos[3]) {
targ = -1;
break;
}
if (pos[i] < pos[targ] && pos[i] > pos[3]) {
targ = -1;
break;
}
}
if (targ == -1 && ok) {
for (int i = 0; i < 3; i++) ans[pos[i]] = perm[i];
ans[pos[3]] = lc;
t = 1;
break;
}
if (!next_permutation(perm.begin(), perm.end())) break;
}
if (t) break;
}
return;
}
}
void solve2(vector<int> pos, int l, int r) {
if (pos.size() < 4) {
for (int i = 0; i < pos.size(); i++) {
if (ans[pos[i]] == 0) {
for (int j = l; j <= l + 2; j++) {
int t = 1;
for (int k = 0; k < pos.size(); k++)
if (ans[pos[k]] == j) t = 0;
if (t) {
ans[pos[i]] = j;
break;
}
}
}
}
return;
}
if (pos.size() == 4) {
int t = 0;
sort((pos).begin(), (pos).end(), comp);
for (int lc = l; lc <= l + 2; lc++) {
vector<int> perm = {l, l + 1, l + 2};
sort((perm).begin(), (perm).end());
while (1) {
int ok = 1;
for (int i = 0; i < 3; i++) {
if (ans[pos[i]] != 0 && ans[pos[i]] != perm[i]) {
ok = 0;
break;
}
}
if (ans[pos[3]] != 0 && ans[pos[3]] != lc) ok = 0;
int targ = 0;
for (int i = 0; i < 3; i++) {
if (perm[i] == lc) targ = i;
}
for (int i = 0; i < 3; i++) {
if (pos[i] > pos[targ] && pos[i] < pos[3]) {
targ = -1;
break;
}
if (pos[i] < pos[targ] && pos[i] > pos[3]) {
targ = -1;
break;
}
}
if (targ == -1 && ok) {
for (int i = 0; i < 3; i++) ans[pos[i]] = perm[i];
ans[pos[3]] = lc;
t = 1;
break;
}
if (!next_permutation(perm.begin(), perm.end())) break;
}
if (t) break;
}
return;
}
}
void solve(int i, int gl) {
int LL = prv[gl][p[i]], RR = nxt[gl][p[i]];
s10.push_back({gl, LL, RR});
s10.push_back({gl, LL, p[i]});
s10.push_back({gl, p[i], RR});
prv[gl][RR] = LL;
nxt[gl][LL] = RR;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++)
wh[p[i]] = i, ans[i] = 0, nxt[8][i] = i + 1, level[i] = 8,
prv[8][i] = i - 1;
for (int i = 1; i <= 8; i++) nxt[i][0] = 1, nxt[i][n + 1] = n + 1;
wh[n + 1] = n + 1;
if (n > 4)
for (l = 8; l >= 1; l--) {
int f = nxt[l][0];
lsz = 0, svd = 0;
while (f != n + 1) go(f);
if (lsz <= 4) break;
}
vector<int> calls[8];
for (int i = n; i >= 1; i--) {
for (int gl = level[p[i]]; gl < 8; gl++) {
calls[gl].push_back(i);
}
}
for (int gl = 1; gl != 8; gl++) {
for (auto i : calls[gl]) solve(i, gl);
while (s10.size()) solve1();
}
for (int lvl = 1; lvl <= 8; lvl++) {
vector<int> ao;
for (int i = 1; i <= n; i++)
if (lvl == level[i] && ans[i] == 0) ao.push_back(i);
solve2(ao, lvl * 3 - 2, lvl * 3);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 12 |
#include <bits/stdc++.h>
std::mt19937_64 rng(
std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
vector<long long> v(4, 0);
for (long long i = 0; i < 4; i++) cin >> v[i];
vector<long long> ans(500000, 0);
long long x = 200005, y = 200005, start = 0;
long long mid = x;
bool cc = true;
long long prev = -1, cur = 0, chk, w = 1;
while (cc) {
chk = 0;
for (long long i = 0; i < 4; i++)
if (i != prev and v[i] > 0) {
cur = i;
chk = 1;
break;
}
if (!chk and v[prev] > 0)
cur = prev;
else if (!chk and v[prev] == 0)
break;
if (start == 0) {
start = 1;
ans[x] = cur;
start = 1;
} else if (abs(ans[x] - cur) == 1 and abs(ans[y] - cur) == 1) {
if (min(ans[x], ans[y]) == ans[x]) {
x--;
ans[x] = cur;
} else {
y++;
ans[y] = cur;
}
} else if (abs(ans[x] - cur) == 1) {
x--;
ans[x] = cur;
} else if (abs(ans[y] - cur) == 1) {
y++;
ans[y] = cur;
} else {
w = 0;
break;
}
v[cur]--;
prev = cur;
}
if (!w)
cout << "NO";
else {
cout << "YES\n";
for (long long i = x; i <= y; i++) cout << ans[i] << " ";
}
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class Trie {
public:
Trie() { this->root = new node(); }
void add(int x) {
vector<int> vc = parse(x);
root = insert(root, vc, 0);
}
void del(int x) {
vector<int> vc = parse(x);
root = remove(root, vc, 0);
}
int query(int x) {
int ret = 0, i;
vector<int> vc = parse(x);
node *curr = root;
for (i = 0; i < 31; ++i) {
if (vc[i] == 0) {
if (curr->child[0] != NULL) {
ret = (ret << 1);
curr = curr->child[0];
} else {
ret = (ret << 1) + 1;
curr = curr->child[1];
}
} else {
if (curr->child[1] != NULL) {
ret = (ret << 1);
curr = curr->child[1];
} else {
ret = (ret << 1) + 1;
curr = curr->child[0];
}
}
}
return ret;
}
int solve() { return dfs(root); }
private:
struct node {
int cnt;
node *child[2];
node() {
this->child[0] = this->child[1] = NULL;
this->cnt = 0;
}
};
node *root;
int size(node *rt) { return rt == NULL ? 0 : rt->cnt; }
node *insert(node *rt, vector<int> &a, int pos) {
int sz = a.size();
if (pos > sz) return rt;
if (pos == sz) {
rt->cnt++;
return rt;
}
if (rt->child[a[pos]] == NULL) {
rt->child[a[pos]] = new node();
}
rt->child[a[pos]] = insert(rt->child[a[pos]], a, pos + 1);
rt->cnt = size(rt->child[0]) + size(rt->child[1]);
return rt;
}
node *remove(node *rt, vector<int> &a, int pos) {
int sz = a.size();
if (rt == NULL || pos > sz) return rt;
if (pos == sz) {
rt->cnt--;
return rt;
}
rt->child[a[pos]] = remove(rt->child[a[pos]], a, pos + 1);
if (!size(rt->child[a[pos]])) {
delete rt->child[a[pos]];
rt->child[a[pos]] = NULL;
}
rt->cnt = size(rt->child[0]) + size(rt->child[1]);
return rt;
}
vector<int> parse(int x) {
vector<int> ret = vector<int>(31, 0);
int idx = 30;
while (x > 0) {
ret[idx--] = x & 1;
x >>= 1;
}
return ret;
}
int dfs(node *rt) {
if (rt == NULL) return 0;
if (rt->child[0] == NULL && rt->child[1] != NULL) return dfs(rt->child[1]);
if (rt->child[1] == NULL && rt->child[0] != NULL) return dfs(rt->child[0]);
if (rt->child[0] == NULL && rt->child[1] == NULL) return 1;
return max(dfs(rt->child[0]), dfs(rt->child[1])) + 1;
}
};
Trie t = Trie();
int a[200011];
int n;
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
t.add(a[i]);
}
printf("%d\n", n - t.solve());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct no {
long long i, h, m;
};
long long dp[40][40][40];
char str[40];
no pre[40][40][40];
long long pw[19];
vector<char> ans;
int main() {
long long n;
scanf("%lld", &n);
scanf("%s", str + 1);
pw[0] = 1;
for (long long i = 1; i < 19; i++) pw[i] = pw[i - 1] * 10LL;
for (long long i = 0; i < 40; i++)
for (long long j = 0; j < 40; j++)
for (long long k = 0; k < 40; k++) dp[i][j][k] = -9999999999999LL;
dp[0][0][0] = 0;
pre[0][0][0] = {-1, -1, -1};
for (long long i = 1; i <= 2 * n; i++) {
for (long long h = 0; h <= n; h++) {
for (long long m = 0; m <= n; m++) {
if (h) {
if (dp[i - 1][h - 1][m] + pw[n - h] * (str[i] - '0') > dp[i][h][m]) {
dp[i][h][m] = dp[i - 1][h - 1][m] + pw[n - h] * (str[i] - '0');
pre[i][h][m] = {i - 1, h - 1, m};
}
}
if (m) {
if (dp[i - 1][h][m - 1] + pw[n - m] * (str[i] - '0') > dp[i][h][m]) {
dp[i][h][m] = dp[i - 1][h][m - 1] + pw[n - m] * (str[i] - '0');
pre[i][h][m] = {i - 1, h, m - 1};
}
}
}
}
}
no check = {-1, -1, -1};
no tren = {2 * n, n, n};
no pred = pre[tren.i][tren.h][tren.m];
while (pred.i != -1) {
if (tren.h == pred.h)
ans.push_back('M');
else
ans.push_back('H');
tren = pred;
pred = pre[tren.i][tren.h][tren.m];
}
reverse(ans.begin(), ans.end());
for (long long i = 0; i < ans.size(); i++) printf("%c", ans[i]);
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.