solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int gcd(unsigned long long int a, unsigned long long int b) {
unsigned long long int max = a > b ? a : b;
unsigned long long int min = a < b ? a : b;
if (max % min == 0) return min;
if (max % min == 1) return 1;
return gcd(min, max % min);
}
int main() {
int flag = 0;
unsigned long long int l, r;
cin >> l >> r;
if (l - r < 2) {
cout << "-1";
return 0;
}
unsigned long long int i, j, k;
for (i = l; i <= r - 2; i++) {
for (j = i + 1; j <= r - 1; j++) {
if (gcd(i, j) == 1) {
for (k = j + 1; k <= r; k++) {
if (gcd(j, k) == 1 && gcd(i, k) != 1) {
flag = 1;
cout << i << " " << j << " " << k;
break;
}
}
}
if (flag == 1) break;
}
if (flag == 1) break;
}
if (flag == 0) cout << "-1";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, k;
int a[N];
int gcd(int x, int y) { return x % y ? gcd(y, x % y) : y; }
int main() {
long long T = 1, x, y, rt;
cin >> T;
while (T--) {
cin >> n;
int l, mx = inf;
for (int i = 1; i <= sqrt(n); i++) {
x = n / i, y = n - x;
if (x == 0 || y == 0) continue;
long long g = 1ll * x * y / gcd(x, y);
if (mx > g) {
mx = g;
l = i;
}
}
if (mx > n - 1) {
mx = n - 1;
l = n;
}
cout << n / l << " " << n - n / l << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pi = pair<int, int>;
const int MAXN = 100005;
const int MAXM = 100005;
struct bpm{
vector<int> gph[MAXN];
int dis[MAXN], l[MAXN], r[MAXM], vis[MAXN];
void clear(){ for(int i=0; i<MAXN; i++) gph[i].clear(); }
void add_edge(int l, int r){ gph[l].push_back(r); }
bool bfs(int n){
queue<int> que;
bool ok = 0;
memset(dis, 0, sizeof(dis));
for(int i=0; i<n; i++){
if(l[i] == -1 && !dis[i]){
que.push(i);
dis[i] = 1;
}
}
while(!que.empty()){
int x = que.front();
que.pop();
for(auto &i : gph[x]){
if(r[i] == -1) ok = 1;
else if(!dis[r[i]]){
dis[r[i]] = dis[x] + 1;
que.push(r[i]);
}
}
}
return ok;
}
bool dfs(int x){
if(vis[x]) return 0;
vis[x] = 1;
for(auto &i : gph[x]){
if(r[i] == -1 || (!vis[r[i]] && dis[r[i]] == dis[x] + 1 && dfs(r[i]))){
l[x] = i; r[i] = x;
return 1;
}
}
return 0;
}
int match(int n){
memset(l, -1, sizeof(l));
memset(r, -1, sizeof(r));
int ret = 0;
while(bfs(n)){
memset(vis, 0, sizeof(vis));
for(int i=0; i<n; i++) if(l[i] == -1 && dfs(i)) ret++;
}
return ret;
}
bool chk[MAXN + MAXM];
void rdfs(int x, int n){
if(chk[x]) return;
chk[x] = 1;
for(auto &i : gph[x]){
chk[i + n] = 1;
rdfs(r[i], n);
}
}
vector<int> getcover(int n, int m){ // solve min. vertex cover
match(n);
memset(chk, 0, sizeof(chk));
for(int i=0; i<n; i++) if(l[i] == -1) rdfs(i, n);
vector<int> v;
for(int i=0; i<n; i++) if(!chk[i]) v.push_back(i);
for(int i=n; i<n+m; i++) if(chk[i]) v.push_back(i);
return v;
}
}bpm;
int n, M[MAXN];
int proc[MAXN];
pi dap[MAXN];
vector<int> E[MAXN];
vector<int> R[MAXN];
queue<int> que;
int main(){
scanf("%d",&n);
for(int i=1; i<n; i++){
int s;
scanf("%d",&s);
E[i].resize(s);
for(auto &j : E[i]){
scanf("%d",&j);
R[j].push_back(i);
if(j != 1) bpm.add_edge(i, j);
}
}
int x = bpm.match(n + 1);
if(x != n - 1){
puts("-1");
return 0;
}
for(int i=1; i<n; i++) M[i] = bpm.l[i];
que.push(1);
vector<pi> edg;
while(!que.empty()){
int x = que.front();
que.pop();
for(auto &j : R[x]){
if(proc[j]) continue;
proc[j] = 1;
dap[j] = pi(M[j], x);
que.push(M[j]);
}
}
for(int i=1; i<n; i++) printf("%d %d\n", dap[i].first, dap[i].second);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
int n, l;
scanf("%d%d", &n, &l);
vector<int> x(n), b(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) scanf("%d%d", &x[i], &b[i]);
const int X = 2000000;
vector<double> sqrts(X + 1);
for (int(i) = (int)(0); (i) <= (int)(X); ++(i)) sqrts[i] = sqrt(i * 1.);
double lo = 0, up = sqrts[abs(x[n - 1] - l)] / b[n - 1] + 1;
vector<int> lastprev;
for (int(ii) = 0; (ii) < (int)(100); ++(ii)) {
double mid = (lo + up) / 2;
vector<double> dp(n);
vector<int> prev(n, -1);
for (int(i) = 0; (i) < (int)(n); ++(i))
dp[i] = sqrts[abs(x[i] - l)] - mid * b[i];
for (int(i) = 0; (i) < (int)(n); ++(i)) {
double t = dp[i];
for (int(j) = (int)(i + 1); (j) < (int)(n); ++(j)) {
double u = t + sqrts[abs(x[j] - x[i] - l)] - mid * b[j];
if (dp[j] > u) {
dp[j] = u;
prev[j] = i;
}
}
}
if (dp[n - 1] <= 0)
up = mid, lastprev = prev;
else
lo = mid;
}
vector<int> ans;
int i = n - 1;
while (i != -1) {
ans.push_back(i);
i = lastprev[i];
}
reverse((ans).begin(), (ans).end());
for (int(i) = 0; (i) < (int)(ans.size()); ++(i)) {
if (i != 0) putchar(' ');
printf("%d", ans[i] + 1);
}
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n = 4;
int dep[1250000];
int f[1250000][30];
int c[40];
int query(int x, int y) {
int ans = 0;
if (dep[x] > dep[y]) swap(x, y);
for (int p = 25; p >= 0; p--) {
if (dep[x] <= dep[f[y][p]]) {
y = f[y][p];
ans += c[p];
}
}
if (x == y) return ans;
for (int p = 25; p >= 0; p--)
if (f[x][p] != f[y][p]) {
x = f[x][p];
y = f[y][p];
ans = ans + 2 * c[p];
}
x = f[x][0];
y = f[y][0];
ans += 2;
return ans;
}
int main() {
c[0] = 1;
for (int i = 1; i <= 30; i++) c[i] = c[i - 1] * 2;
dep[1] = 1;
dep[2] = dep[3] = dep[4] = 2;
f[2][0] = f[3][0] = f[4][0] = 1;
int q, xx = 2, yy = 3;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int v, ans = 0;
scanf("%d", &v);
f[n + 1][0] = v;
f[n + 2][0] = v;
dep[n + 1] = dep[n + 2] = dep[v] + 1;
for (int j = 1; j <= 20; j++) {
f[n + 1][j] = f[f[n + 1][j - 1]][j - 1];
f[n + 2][j] = f[f[n + 2][j - 1]][j - 1];
}
int c1 = query(xx, n + 1), c2 = query(yy, n + 1), c3 = query(xx, yy);
if (c1 < c2) {
if (c2 > c3) {
xx = n + 1;
ans = c2;
} else
ans = c3;
} else {
if (c1 > c3) {
yy = n + 1;
ans = c1;
} else
ans = c3;
}
printf("%d\n", ans);
n += 2;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
long long LCM(long long a, long long b) { return a * (b / GCD(a, b)); }
const double EPS = 10e-9;
const double INF = (1LL << 30);
using namespace std;
std::string num2str(long long n) {
std::ostringstream result;
result << n;
return result.str();
}
long long str2num(const std::string& s) {
long long result;
std::istringstream ss(s);
ss >> result;
if (!ss) throw std::invalid_argument("StrToInt");
return result;
}
struct pair_comp {
bool operator()(pair<pair<long long, long long>, long long> const& lhs,
pair<pair<long long, long long>, long long> const& rhs) {
if (lhs.first.second == rhs.first.second)
return lhs.first.first < rhs.first.first;
return lhs.first.second < rhs.first.second;
}
};
int main() {
int N, M, r, c;
cin >> N >> M;
set<int> rows, cols;
for (int i = 0; i < (M); ++i) {
cin >> r >> c;
rows.insert(r);
cols.insert(c);
}
int cnt = 0, j;
int half = N % 2 == 1 ? (N + 1) / 2 : N / 2;
for (int i = 2; i <= (half); ++i) {
j = N + 1 - i;
if (i == j) continue;
if (rows.find(i) == rows.end()) cnt++;
if (rows.find(j) == rows.end()) cnt++;
if (cols.find(i) == cols.end()) cnt++;
if (cols.find(j) == cols.end()) cnt++;
}
if (N % 2 == 1) {
int v = 0, h = 0;
if (rows.find((N + 1) / 2) == rows.end()) h = 1;
if (cols.find((N + 1) / 2) == cols.end()) v = 1;
cnt += max(h, v);
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 1, C = 26 + 1;
int n, k;
string s;
long long ans[N];
long long sum[N][C];
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> k;
cin >> s;
ans[0] = 1;
for (int i = 0; i < n; ++i) {
char c = s[i] - 'a';
for (int j = i + 1; j >= 1; --j) {
ans[j] += ans[j - 1] - sum[j - 1][c];
sum[j - 1][c] = ans[j - 1];
}
}
long long end_ans = 0;
for (int i = n; i >= 0; --i) {
if (k >= ans[i]) {
end_ans += (n - i) * ans[i];
k -= ans[i];
} else {
end_ans += (n - i) * k;
k = 0;
break;
}
}
cout << (k ? -1 : end_ans) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<pair<int, int>> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr.begin(), arr.end());
map<int, int> beaconDestroyed;
for (int i = 0; i < n; i++) {
int j = lower_bound(arr.begin(), arr.end(),
make_pair(arr[i].first - arr[i].second, 0)) -
arr.begin();
int ans = i - j;
if (j > 0) ans += beaconDestroyed[arr[j - 1].first];
beaconDestroyed[arr[i].first] = ans;
}
beaconDestroyed[arr[0].first - 1] = 0;
long long minDestroyed = beaconDestroyed[arr[n - 1].first];
for (int i = n - 1; i >= 0; i--) {
minDestroyed = min(minDestroyed, n - i + beaconDestroyed[arr[i - 1].first]);
}
cout << minDestroyed << endl;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
char a[110];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int s = 0, j, i, k;
for (k = 0; k < n; k++) {
scanf("%s", a);
for (j = 0, i = 0; i < strlen(a); i++)
if (a[i] == '4' || a[i] == '7') j++;
if (j <= m) s++;
}
printf("%d\n", s);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long N;
void rec(long long d, int use, long long &cnt) {
if (d > N) return;
if (use == 0b111) cnt++;
rec(d * 10 + 7, use | 0b001, cnt);
rec(d * 10 + 5, use | 0b010, cnt);
rec(d * 10 + 3, use | 0b100, cnt);
}
int main() {
cin >> N;
long long res = 0;
rec(0, 0, res);
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
string s;
long long cnt_q[2011];
long long cnt_c[2011];
long long fact[2011];
long long re_fact[2011];
long long f[2011][2011];
long long g[2011][2011];
long long p(long long a, long long b) {
if (b == 0) return 1;
long long tmp = p(a, b / 2);
if (b % 2 == 0) return (tmp * tmp) % mod;
return ((tmp * tmp) % mod * a) % mod;
}
long long comb(long long n, long long k) {
if (k > n) return 0;
return ((fact[n] * re_fact[k]) % mod * re_fact[n - k]) % mod;
}
long long dp(long long pos, long long sum) {
if (pos >= s.size()) return 0;
if (f[pos][sum] != -1) return f[pos][sum];
long long cur = 0;
if (s[pos] == '(') {
long long cur_sum = (sum + 1) - cnt_c[pos];
if (cur_sum <= 0)
cur = p(2, cnt_q[pos]);
else if (cnt_q[pos] >= cur_sum)
cur = ((p(2, cnt_q[pos]) - g[cnt_q[pos]][cur_sum - 1]) % mod + mod) % mod;
cur = (cur + dp(pos + 1, sum + 1)) % mod;
} else if (s[pos] == ')')
cur = dp(pos + 1, sum);
else if (s[pos] == '?') {
long long cur_sum = (sum + 1) - cnt_c[pos];
if (cur_sum <= 0)
cur = p(2, cnt_q[pos + 1]);
else if (cnt_q[pos + 1] >= cur_sum)
cur = ((p(2, cnt_q[pos + 1]) - g[cnt_q[pos + 1]][cur_sum - 1]) % mod +
mod) %
mod;
cur = (cur + dp(pos + 1, sum + 1)) % mod;
cur = (cur + dp(pos + 1, sum)) % mod;
}
return f[pos][sum] = cur;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
for (long long i = 1; i <= 2000; i++) fact[i] = (fact[i - 1] * i) % mod;
re_fact[2000] = p(fact[2000], mod - 2);
for (long long i = 2000; i >= 1; i--) re_fact[i - 1] = (re_fact[i] * i) % mod;
for (long long i = 0; i <= 2000; i++) {
g[i][0] = 1;
for (long long j = 1; j <= i; j++)
g[i][j] = (g[i][j - 1] + comb(i, j)) % mod;
}
cin >> s;
for (long long i = s.size() - 1; i >= 0; i--) {
cnt_q[i] = cnt_q[i + 1];
cnt_c[i] = cnt_c[i + 1];
if (s[i] == ')')
cnt_c[i]++;
else if (s[i] == '?')
cnt_q[i]++;
}
for (long long i = 0; i <= 2000; i++)
for (long long j = 0; j <= 2000; j++) f[i][j] = -1;
cout << dp(0, 0);
}
| 4 |
#include <vector>
#include <iostream>
using namespace std;
int n, m;
int main() {
while (cin >> n >> m, n) {
int s = m;
vector<int> v(n, 0);
for (int i = 0; ; i = (i + 1 == n ? 0 : i + 1)) {
if (m != 0) v[i]++, m--;
else m = v[i], v[i] = 0;
if (m == 0 && s - m - v[i] == 0) {
cout << i << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fi first
#define se second
#define pb push_back
#define rep(i,a,n) for(ll i = a;i < n;i++)
#define vec vector<ll>
#define read(v) vec v(n,0); rep(i,0,n) {cin>>v[i];}
#define pairs pair<int,int>
#define mpp make_pair(a,b)
#define write(a,n) rep(i,0,n) {cout<<a[i]<<" ";}cout<<endl;
#define all(v) v.begin(),v.end()
#define srt(v) sort(v.rbegin(),v.rend())
#define scn(a) cin>>a
#define nl endl
#define watch(x) cout << (#x) << " is " << (x) << endl
#define gcd(a,b) __gcd(a,b)
#define bitcount(n) __builtin_popcount(n)
#define IOS ios_base::sync_with_stdio(false); cin.tie(NULL);
#define mod 1000000007
void solve()
{
int n;
cin >> n;
vec a(n);
map<int, int>mp;
for (int i = 0; i < n; i++)
cin >> a[i];
vector<int>ans;
for (int i = 0; i < n; i++)
{
if (mp.find(a[i]) == mp.end())
{
ans.push_back(a[i]);
mp[a[i]] = 0;
}
else
mp[a[i]]++;
}
sort(ans.begin(), ans.end());
for (auto x : mp)
{
int p = x.se;
while (p-- > 0)
ans.push_back(x.first);
}
write(ans, n);
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS
ll t = 1;
cin >> t;
while (t-- > 0)
{
solve();
}
#ifndef ONLINE_JUDGE
cout << "\nTime Elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " sec\n";
#endif
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int m;
cin >> m;
int h, j;
for (int i = 0; i < m; i++) {
cin >> h >> j;
if (j <= h + k && j >= h - k && h >= k - j && h <= 2 * n - j - k) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int>::iterator it;
map<int, int> S;
int n, m, i, t, a[100005], b[100005], v[100005], ans[100005], cnt, num, j;
int cmp(int a, int b) { return a > b; }
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
S[-b[i]]++;
}
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) {
t = m - a[i];
it = S.upper_bound(-t);
if (it != S.end()) {
ans[++cnt] = a[i] - it->first;
v[i] = 1;
it->second--;
if (it->second == 0) S.erase(it->first);
}
}
num = 0;
for (i = 1; i <= n; i++)
if (S[-b[i]]) {
S[-b[i]]--;
b[++num] = b[i];
}
sort(b + 1, b + num + 1, cmp);
int t = 0;
for (i = 1; i <= n; i++)
if (!v[i]) a[++t] = a[i];
for (i = 1; i <= num; i++) ans[++cnt] = (a[i] + b[i]) % m;
sort(ans + 1, ans + n + 1, cmp);
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[300], n, k, i;
cin >> n >> k;
n = 2 * n + 1;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
if (i % 2 == 1) {
if (a[i] > a[i - 1] + 1 && a[i] > a[i + 1] + 1 && k > 0) {
a[i]--;
k--;
}
}
cout << a[i] << " ";
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2][30][100100] = {0};
long long a[100100];
long long ans = 0;
vector<long long> v[100100];
void dfs(long long x, long long par) {
long long arr[2][30] = {0};
for (long long i = 0; i < v[x].size(); i++) {
if (v[x][i] == par) continue;
dfs(v[x][i], x);
for (long long j = 0; j <= 21; j++) {
long long zero = 0, one = 0;
zero += dp[0][j][x] * dp[0][j][v[x][i]];
zero += dp[1][j][x] * dp[1][j][v[x][i]];
one += dp[0][j][x] * dp[1][j][v[x][i]];
one += dp[1][j][x] * dp[0][j][v[x][i]];
zero += dp[0][j][v[x][i]];
one += dp[1][j][v[x][i]];
arr[0][j] += zero;
arr[1][j] += one;
dp[0][j][x] += dp[0][j][v[x][i]];
dp[1][j][x] += dp[1][j][v[x][i]];
}
}
for (long long j = 0; j <= 21; j++) {
if (a[x] & (1 << j)) {
swap(arr[0][j], arr[1][j]);
swap(dp[0][j][x], dp[1][j][x]);
dp[1][j][x]++;
arr[1][j]++;
} else {
dp[0][j][x]++;
arr[0][j]++;
}
ans += (1 << j) * arr[1][j];
}
}
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, -1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n, k, cnt = 0, mx;
string s;
cin >> n >> k;
cin >> s;
map<char, int> m;
int u = 0, v = 2;
if (k & 1) u = 1;
for (int i = 0; i < k / 2 + u; ++i) {
mx = -1;
for (int j = 0; j < n / k; ++j) {
int g = i + (j * k);
int g2 = (k - i - 1) + j * k;
if (g != g2) {
++m[s[g]];
++m[s[g2]];
} else
++m[s[g]];
}
for (auto it = (m).begin(); it != (m).end(); ++it)
mx = max(mx, it->second);
int g5 = i;
int g6 = (k - i - 1);
if (g5 == g6) v = 1;
cnt += ((n / k) * v - mx);
v = 2;
m.clear();
}
cout << cnt << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class DSU {
private:
vector<int> p, rank;
public:
DSU(int n) {
p.assign(n, -1);
rank.assign(n, 0);
}
int root(int x) {
if (p[x] < 0) {
return x;
}
return (p[x] = root(p[x]));
}
int sameSet(int x, int y) { return (root(x) == root(y)); }
void connect(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (rank[x] > rank[y]) {
p[y] = x;
} else {
p[x] = y;
if (rank[x] == rank[y]) {
rank[y]++;
}
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<pair<long long, pair<int, int> > > edges;
int su, sv;
for (int i = 0; i < m; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
if (i > 0) {
edges.push_back({w, {u, v}});
} else {
su = u;
sv = v;
}
}
sort(edges.begin(), edges.end());
DSU dsu(n + 1);
for (auto& e : edges) {
if (!dsu.sameSet(e.second.first, e.second.second)) {
dsu.connect(e.second.first, e.second.second);
}
if (dsu.sameSet(su, sv)) {
cout << e.first << '\n';
return 0;
}
}
cout << (int)1e9 << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long A[100005];
long long tree[100005];
int n, m, w;
void update(int idx, long long val) {
while (idx <= n + 1) {
tree[idx] += val;
idx += (idx & -idx);
}
return;
}
long long query(int idx) {
long long res = 0;
while (idx > 0) {
res += tree[idx];
idx -= (idx & -idx);
}
return res;
}
bool F(long long len) {
for (int i = 1; i <= n + 1; i++) tree[i] = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long val = query(i) + A[i];
if (val < len) {
val = len - val;
ans += val;
update(i, val);
update(min(i + w, n + 1), -val);
}
}
if (ans <= m) return true;
return false;
}
int main() {
long long L, R, M, ans = 1;
cin >> n >> m >> w;
for (int i = 1; i <= n; i++) cin >> A[i];
L = 1;
R = 10000000000LL;
while (L <= R) {
M = (L + R) / 2;
if (F(M)) {
ans = M;
L = M + 1;
} else
R = M - 1;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
namespace READ {
namespace DATA {
const int LEN = 1 << 19;
char buf[LEN], *p1, *p2;
} // namespace DATA
inline char gc() {
using namespace DATA;
return (p1 == p2) && (p2 = (p1 = buf) + fread(buf, 1, LEN, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int rd() {
int x = 0, f = 1;
char ch = gc();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = gc();
}
while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch ^ 48), ch = gc();
return x * f;
}
} // namespace READ
using namespace READ;
using namespace std;
namespace Double {
const double eps = 1e-12;
inline int equal(double x, double y) { return fabs(x - y) <= eps; }
inline int xislower(double x, double y) { return y - x > eps; }
inline int xisgreater(double x, double y) { return x - y > eps; }
} // namespace Double
using namespace Double;
int t = 0, a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
int main() {
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &f);
if (a != 0 && b != 0 && c != 0 && d != 0 && e != 0 && f != 0) {
double t = (1.0 * e * 1.0 * a * 1.0 * c) / (1.0 * b * 1.0 * d);
double ff = 1.0 * f;
if (xislower(t, ff))
puts("Ron");
else
puts("Hermione");
} else if (d == 0)
puts("Hermione");
else if (d != 0 && c == 0)
puts("Ron");
else if (c != 0 && d != 0 && b == 0)
puts("Hermione");
else if (b != 0 && c != 0 && d != 0 && a == 0)
puts("Ron");
else if (a != 0 && b != 0 && c != 0 && d != 0 && f == 0)
puts("Hermione");
else if (e == 0)
puts("Ron");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
vector<int> edges[MAXN];
void add_edge(int from, int to) {
edges[from].push_back(to);
edges[to].push_back(from);
}
int n, k;
int dfs(int x, int y, int& res) {
if (edges[x].size() == 1) return 0;
vector<int> v;
for (auto i : edges[x])
if (i != y) v.push_back(dfs(i, x, res) + 1);
sort(v.begin(), v.end(), greater<int>());
int ret = v[0];
for (int i = 1; i < (int)v.size(); i++) {
if (v[i - 1] + v[i] <= k) break;
res++;
ret = v[i];
}
return ret;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
}
int ans = 1;
for (int i = 1; i <= n; i++)
if (edges[i].size() > 1) {
dfs(i, 0, ans);
break;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long xa, xb, ya, yb, xc, yc;
long long ret;
long long com(long long x1, long long x2, long long y1, long long y2) {
return x1 * y2 - x2 * y1;
}
int main() {
cin >> xa >> ya >> xb >> yb >> xc >> yc;
ret = com(xc - xa, xb - xa, yc - ya, yb - ya);
if (ret == 0) {
cout << "TOWARDS" << endl;
} else if (ret < 0) {
cout << "LEFT" << endl;
} else {
cout << "RIGHT" << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
typedef long long i64;
const int P=1e9+7,N=2007;
int pw(int a,int n){
int v=1;
for(;n;n>>=1,a=(i64)a*a%P)if(n&1)v=(i64)v*a%P;
return v;
}
int fac[N*N],fiv[N*N],mx;
int n,k,f[N];
int C(int n,int m){
return (i64)fac[n]*fiv[m]%P*fiv[n-m]%P;
}
int main(){
scanf("%d%d",&n,&k);
if(k==1)return puts("1"),0;
mx=n*k;
for(int i=fac[0]=1;i<=mx;++i)fac[i]=i64(i)*fac[i-1]%P;
fiv[mx]=pw(fac[mx],P-2);
for(int i=mx;i;--i)fiv[i-1]=i64(i)*fiv[i]%P;
f[1]=1;
for(int i=1;i<=n;++i){
for(int j=1,s=0;j<=i;++j){
s=(s+f[j])%P;
f[j]=(i64)s*C(i*(k-1)+j-2,k-2)%P;
}
}
int ans=0;
for(int i=1;i<=n;++i)ans=(ans+f[i])%P;
ans=(i64)ans*fac[n]%P;
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
cout << b << ' ' << c << ' ' << c << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
vector<int> sorted(n);
vector<int> other(n);
for (int i = 0; i < n; i++) {
cin >> sorted[i];
other[i] = sorted[i];
}
sort(sorted.begin(), sorted.end());
bool can = 1;
for (int i = 0; i < n; i++) {
if (sorted[i] != other[i]) {
if (!can) {
cout << "NO\n";
return 0;
}
for (int j = n - 1; j > i; j--) {
if (other[j] == sorted[i]) {
swap(other[j], other[i]);
break;
}
}
can = 0;
}
}
cout << "YES\n";
return 0;
}
| 3 |
#include <stdio.h>
#define rep(i, n) for(int i = 0; i < n; ++i)
int main(void) {
int n, ans = 0, i;
rep(i, 3) {
scanf("%d", &n);
ans += n;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
vector<pair<int, int> >::iterator it;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, s1 = "";
int cnt = 0;
cin >> s;
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1])
s1 += s[i];
else {
s1 += s[i];
if (s1.size() % 2 == 0) cnt++;
s1 = "";
}
}
if (s1 != "")
if (s1.size() % 2) cnt++;
cout << cnt << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
template<typename tn> void read(tn &a){
tn x=0,f=1; char c=' ';
for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
a=x*f;
}
char ans[210];
ll A,B,C,D;
int cnt;
int main(){
int T;read(T);
while(T--){
read(A);read(B);read(C);read(D);
int flag=A<B;
if(flag){
swap(A,B);
C=A+B-C+1;D=A+B-D+1;
swap(C,D);
}
int L=(A+B)/(B+1);
int l=0,r=A/L+1;
while(l+1<r){
int mid=l+r>>1;
if((A-mid*L)*L>=B-mid) l=mid;
else r=mid;
}
int k=l;
cnt=0;
int len=k*(L+1);
len+=(A-k*L)-(B-k)/L;
for(int i=C;i<=D;i++)
if(i<=len) ans[++cnt]=i%(L+1)?'A':'B';
else ans[++cnt]=(A+B-i+1)%(L+1)?'B':'A';
if(flag){
reverse(ans+1,ans+cnt+1);
for(int i=1;i<=cnt;i++)
ans[i]=ans[i]=='A'?'B':'A';
}
for(int i=1;i<=cnt;i++)
putchar(ans[i]);
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int ans[4];
int main() {
int n;
scanf("%d", &n);
int t;
int t1, t2;
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
if (t) ans[t]++;
}
for (int i = 1; i <= 4; i++) sum += i * ans[i];
if (sum < 3 || sum == 5) {
printf("-1\n");
return 0;
}
int tmp = 0;
while (ans[1] && ans[2]) {
ans[1]--;
ans[2]--;
ans[3]++;
tmp++;
}
if (ans[1] > 0) {
tmp += ans[1] - ans[1] / 3;
if (ans[1] == 1 && ans[3] == 0) tmp++;
}
if (ans[2] > 0) {
tmp += ans[2] / 3 * 2;
if (ans[2] % 3 == 1)
tmp++;
else if (ans[2] % 3 == 2)
tmp += 2;
if (ans[2] % 3 == 1 && ans[4] == 0) tmp++;
}
printf("%d\n", tmp);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int A[100005], B[100005 / 2];
int solve(int n, int k) {
int maxS = 0, d, i, j;
for (i = n - 1, j = 0, d = 1; i >= 0; --i) {
B[j] += A[i];
if (maxS < B[j]) maxS = B[j];
if (j == k - 1 && d == 1)
d = -1;
else
j += d;
}
return maxS;
}
int main() {
int n, k, i;
scanf("%d %d", &n, &k);
for (i = 0; i < n; ++i) scanf("%d", A + i);
printf("%d\n", solve(n, k));
return 0;
}
| 2 |
#include <stdio.h>
double dp[128][1024][10];
int main(void)
{
int i, j, k;
int x, y, z;
int n;
int s;
for (k = 0; k <= 9; k++){
for (i = 0; i <= 101; i++){
for (j = 0; j <= 1000; j++){
dp[i][j][k] = 0;
}
}
}
dp[0][0][0] = 1;
for (k = 0; k <= 9; k++){
for (i = 0; i <= 101; i++){
for (j = 0; j <= 1000; j++){
dp[i + 1][j + i][k + 1] += dp[i][j][k];
dp[i + 1][j][k] += dp[i][j][k];
}
}
}
while (scanf("%d %d", &n, &s), n != 0 || s != 0){
// for (k = 0; k <= n; k++){
// for (i = 0; i <= 101; i++){
// for (j = 0; j <= s; j++){
// printf("%3d", dp[101][j][k]);
// }
// printf("\n");
// }
// printf("\n");
// }
printf("%.0lf\n", dp[101][s][n]);
}
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[110][2];
int n, k, d;
long long mod = 1e9 + 7;
long long dfs(int x, int flag) {
if (dp[x][flag] != -1) {
return dp[x][flag];
}
long long sum = 0, i;
for (i = 1; i <= k; ++i) {
if (x - i < 0) {
continue;
}
if (i >= d) {
sum += dfs(x - i, 1 | flag);
} else {
sum += dfs(x - i, 0 | flag);
}
sum %= mod;
}
dp[x][flag] = sum;
return sum;
}
int main() {
cin >> n >> k >> d;
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
dp[0][1] = 1;
cout << dfs(n, 0) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 44;
bool vis[N][N][2];
int f[N][N][2], p1[N][N][2], p2[N][N][2];
int s1[N], s2[N];
void update(int& f, int& p1, int& p2, int val, int sl, int sr) {
if (val < f || (val == f && (sl + sr < p1 + p2))) f = val, p1 = sl, p2 = sr;
}
int dp(int l, int r, int dif) {
if (!l || !r) return 0x7f7f7f7f;
if (l == 1 && r == 1) return (dif == 1) ? (0) : (0x7f7f7f7f);
if (vis[l][r][dif]) return f[l][r][dif];
vis[l][r][dif] = true;
for (int sl = 0; sl <= l; sl++)
for (int sr = 0; sr <= r; sr++) {
if (!sl && !sr) continue;
for (int i = 0; i < sr; i++) s1[i] = (dif + i) & 1;
s1[sr] = sl & 1;
for (int i = 0; i < sl; i++) s2[i] = i & 1;
s2[sl] = (dif + sr) & 1;
int red1 = 0, red2 = 0;
for (int i = 1; i <= sr && i < l - sl + sr; i++)
red1 += (s1[i] == s1[i - 1]);
for (int i = 1; i <= sl && i < r + sl - sr; i++)
red2 += (s2[i] == s2[i - 1]);
if (!red1 && !red2) continue;
update(f[l][r][dif], p1[l][r][dif], p2[l][r][dif],
dp(l + sr - sl - red1, r + sl - sr - red2, s1[0] != s2[0]) + 1, sl,
sr);
}
return f[l][r][dif];
}
typedef class Node {
public:
Node* suf;
int col, s;
Node() {}
Node(Node* suf, int col, int s) : suf(suf), col(col), s(s) {}
} Node;
int d;
int l = 1, r = 1;
Node *stl, *str;
Node nl[200005], nr[200005];
char buf[200005];
inline void init() {
int c1, c2;
scanf("%s", buf);
c1 = buf[0];
nl[0] = Node(nl + 1, -1, -233333);
nl[1] = Node(nl + 2, c1, 1);
for (int i = 1; buf[i]; i++)
if (buf[i] == buf[i - 1])
nl[l].s++;
else
l += 1, nl[l] = Node(nl + l + 1, buf[i], 1);
nl[l + 1].s = -1;
scanf("%s", buf);
c2 = buf[0];
nr[0] = Node(nr + 1, -1, -233333);
nr[1] = Node(nr + 2, c2, 1);
for (int i = 1; buf[i]; i++)
if (buf[i] == buf[i - 1])
nr[r].s++;
else
r += 1, nr[r] = Node(nr + r + 1, buf[i], 1);
nr[r + 1].s = -1;
d = (c1 != c2);
stl = nl, str = nr;
}
pair<int, int> swapS(int sl, int sr, int& l, int& r) {
Node *pl = stl, *psl, *pr = str, *psr;
int rl = 0, rr = 0;
for (int i = 0; i < sl; i++) pl = pl->suf, rl += pl->s;
for (int i = 0; i < sr; i++) pr = pr->suf, rr += pr->s;
psl = pl->suf, psr = pr->suf;
swap(stl, str);
pl->suf = psr;
pr->suf = psl;
if (pl->s > 0 && psr->s > 0 && pl->col == psr->col) {
pl->s += psr->s;
pl->suf = psr->suf;
r--;
}
if (pr->s > 0 && psl->s > 0 && pr->col == psl->col) {
pr->s += psl->s;
pr->suf = psl->suf;
l--;
}
return pair<int, int>(rl, rr);
}
pair<int, int> st1[4] = {pair<int, int>(1, 0), pair<int, int>(2, 1),
pair<int, int>(3, 0), pair<int, int>(1, 0)};
pair<int, int> st2[4] = {pair<int, int>(1, 0), pair<int, int>(2, 1),
pair<int, int>(0, 1), pair<int, int>(1, 0)};
pair<int, int> st3[4] = {pair<int, int>(0, 1), pair<int, int>(0, 3),
pair<int, int>(0, 3), pair<int, int>(0, 1)};
pair<int, int> st4[4] = {pair<int, int>(1, 1), pair<int, int>(2, 0),
pair<int, int>(3, 1), pair<int, int>(1, 1)};
pair<int, int> st5[4] = {pair<int, int>(1, 1), pair<int, int>(3, 1),
pair<int, int>(3, 1), pair<int, int>(1, 1)};
pair<int, int> st6[4] = {pair<int, int>(0, 2), pair<int, int>(1, 3),
pair<int, int>(1, 3), pair<int, int>(1, 1)};
pair<int, int> g(int x, int y, int d) {
if (x <= 10 && y <= 10) {
dp(x, y, d);
return pair<int, int>(p1[x][y][d], p2[x][y][d]);
}
if (!d) {
if (y == 1) return st1[x % 4];
if (y == 2) return st2[x % 4];
if (x == 1) return st3[y % 4];
if (x == 2)
return (y % 4 == 1) ? (pair<int, int>(1, 2)) : (pair<int, int>(0, 1));
return ((((x - y) % 4 + 4) % 4) == 1) ? (pair<int, int>(1, 0))
: (pair<int, int>(0, 1));
} else {
if (y == 1) return st4[x % 4];
if (y == 2) return st5[x % 4];
if (x == 1)
return (y % 4 == 2) ? (pair<int, int>(1, 3)) : (pair<int, int>(0, 2));
if (x == 2) return st6[y % 4];
return ((((x - y) % 4 + 4) % 4) == 2) ? (pair<int, int>(0, 2))
: (pair<int, int>(1, 1));
}
}
vector<pair<int, int> > opt;
inline void solve() {
memset(vis, false, sizeof(vis));
memset(f, 0x7f, sizeof(f));
while (l > 1 || r > 1) {
pair<int, int> s = g(l, r, d);
int sl = s.first, sr = s.second;
l = l - sl + sr, r = r + sl - sr;
opt.push_back(swapS(sl, sr, l, r));
d = (stl->suf->col != str->suf->col);
}
printf("%d\n", (signed)opt.size());
for (int i = 0; i < (signed)opt.size(); i++)
printf("%d %d\n", opt[i].first, opt[i].second);
}
int main() {
init();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[200], n, b[200], c[200];
long long ret = 1;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = i;
c[i] = 999999999;
}
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= n; j++) {
b[j] = a[b[j]];
if (b[j] == j) c[j] = min(c[j], i);
}
}
bool OK = true;
for (int i = 1; i <= n; i++) {
if (c[i] == 999999999) OK = false;
}
if (OK == false) {
cout << "-1" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
ret = lcm(ret, c[i]);
}
if (ret % 2 == 0) ret /= 2;
cout << ret << endl;
return 0;
}
| 3 |
#include<iostream>
#include<sstream>
#include<vector>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<complex>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cassert>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define each(i,c) for(__typeof(c.begin()) i=c.begin();i!=c.end();i++)
#define pb push_back
#define mp make_pair
#define all(c) c.begin(),c.end()
#define dbg(x) cerr<<__LINE__<<": "<<#x<<" = "<<(x)<<endl
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef long long ll;
const int inf=(int)1e9;
const double EPS=1e-9, INF=1e12;
const int to[][4] = {
{1, 2, 3, 4},
{2, -1, 4, -3},
{3, -4, -1, 2},
{4, 3, -2, -1}
};
int main(){
int n;
int a[4], b[4], c[4];
while(cin >> n, n){
while(n--){
rep(i, 4) cin >> a[i];
rep(i, 4) cin >> b[i];
rep(i, 4) c[i] = 0;
rep(i, 4) rep(j, 4){
int k = to[i][j];
int sg = k > 0;
k = abs(k) - 1;
c[k] += (sg ? 1 : -1) * a[i] * b[j];
}
rep(i, 4) cout << c[i] << (i == 3 ? "\n" : " ");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int kkk = 0, x = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') c = getchar(), x = -1;
while (c >= '0' && c <= '9')
kkk = (kkk << 3) + (kkk << 1) + (c - '0'), c = getchar();
return kkk * x;
}
int T, n, m, a[101][101], mem[10001][3], cnt;
char s[1001];
int calc(int x, int y) {
a[x][y] ^= 1;
return (x - 1) * m + y;
}
void print(int v) {
int x = v / m;
if (v % m)
printf("%d %d ", x + 1, v - x * m);
else
printf("%d %d ", x, m);
}
void P(int x, int y) {
mem[++cnt][0] = calc(x, y);
mem[cnt][1] = calc(3 - x, y);
mem[cnt][2] = calc(x, 3 - y);
}
void solve() {
int v = a[1][1] + a[1][2] + a[2][1] + a[2][2];
if (!v) return;
if (v == 1) {
int x, y, f = 1;
for (x = 1; x <= 2; ++x) {
for (y = 1; y <= 2; ++y)
if (a[x][y]) {
f = 0;
break;
}
if (!f) break;
}
P(x, y);
P(3 - x, y);
P(x, 3 - y);
}
if (v == 2) {
int x3, y3, x4, y4, f = 1;
for (x3 = 1; x3 <= 2; ++x3) {
for (y3 = 1; y3 <= 2; ++y3)
if (!a[x3][y3]) {
f = 0;
break;
}
if (!f) break;
}
f = 1;
for (x4 = 1; x4 <= 2; ++x4) {
for (y4 = 1; y4 <= 2; ++y4)
if (!a[x4][y4] && (x4 != x3 || y4 != y3)) {
f = 0;
break;
}
if (!f) break;
}
if (x3 == x4 || y3 == y4) {
P(x3, y3);
P(x4, y4);
} else {
P(3 - x3, y3);
P(3 - x4, y4);
}
}
if (v == 3) {
int x, y, f = 1;
for (x = 1; x <= 2; ++x) {
for (y = 1; y <= 2; ++y)
if (!a[x][y]) {
f = 0;
break;
}
if (!f) break;
}
P(3 - x, 3 - y);
}
if (v == 4) {
P(1, 1);
P(1, 2);
P(2, 1);
P(2, 2);
}
}
int main() {
T = read();
while (T--) {
n = read(), m = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
for (int j = 1; j <= m; ++j) a[i][j] = s[j - 1] - '0';
}
cnt = 0;
for (int i = n; i > 2; --i) {
for (int j = 1; j < m; ++j)
if (a[i][j]) {
mem[++cnt][0] = calc(i, j);
mem[cnt][1] = calc(i - 1, j);
mem[cnt][2] = calc(i - 1, j + 1);
}
if (a[i][m]) {
mem[++cnt][0] = calc(i, m);
mem[cnt][1] = calc(i - 1, m);
mem[cnt][2] = calc(i - 1, m - 1);
}
}
for (int i = m; i > 2; --i) {
if (!a[1][i] && !a[2][i]) continue;
if (a[1][i]) {
if (a[2][i]) {
mem[++cnt][0] = calc(1, i);
mem[cnt][1] = calc(2, i);
mem[cnt][2] = calc(1, i - 1);
} else {
mem[++cnt][0] = calc(1, i);
mem[cnt][1] = calc(1, i - 1);
mem[cnt][2] = calc(2, i - 1);
}
} else {
mem[++cnt][0] = calc(2, i);
mem[cnt][1] = calc(2, i - 1);
mem[cnt][2] = calc(1, i - 1);
}
}
solve();
printf("%d\n", cnt);
for (int i = 1; i <= cnt; ++i) {
print(mem[i][0]), print(mem[i][1]), print(mem[i][2]);
putchar('\n');
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int MAX = 1e6 + 11;
using namespace std;
int N, A[MAX], B[MAX], R1[MAX], R2[MAX], R[MAX];
int main() {
memset((R1), 0xFF, sizeof(R1));
memset((R2), 0xFF, sizeof(R2));
scanf("%d", &(N));
for (int i = 0; i < (N); ++i) scanf("%d%d", &(A[i]), &(B[i]));
for (int i = 0; i < (N); ++i) {
R1[A[i]] = i;
R2[B[i]] = i;
}
vector<int> beg, end;
if (N % 2 == 0) {
int pos = 0;
while (R1[pos] != -1) {
int x = R1[pos];
beg.push_back(B[x]);
pos = B[x];
}
pos = 0;
while (R2[pos] != -1) {
int x = R2[pos];
end.push_back(A[x]);
pos = A[x];
}
reverse(end.begin(), end.end());
} else {
int pos = 0;
while (R1[pos] != -1) {
int x = R1[pos];
if (B[x] == 0) break;
beg.push_back(B[x]);
pos = B[x];
}
for (int i = 0; i < (N); ++i) {
if (R1[B[i]] == -1) {
pos = B[i];
break;
}
}
end.push_back(pos);
while (R2[pos] != -1) {
int x = R2[pos];
end.push_back(A[x]);
pos = A[x];
}
reverse(end.begin(), end.end());
}
for (int i = 0; i < (int((end).size())); ++i) {
R[2 * i] = end[i];
}
for (int i = 0; i < (int((beg).size())); ++i) {
R[2 * i + 1] = beg[i];
}
for (int i = 0; i < (N); ++i) {
printf("%d ", R[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char str[100005];
char s[100005];
int main() {
while (gets(str)) {
stringstream ss(str);
bool ok = true;
int flag1 = false, flag2 = false, flag3 = false, flag4 = false;
bool first = true;
int gender = -1;
int cnt = 0;
while (ss >> s) {
if (!ok) continue;
int len = strlen(s);
if (first) {
first = false;
if (len >= 4 && strcmp(s + len - 4, "lios") == 0) {
gender = 0;
flag1 = true;
continue;
}
if (len >= 3 && strcmp(s + len - 3, "etr") == 0) {
gender = 0;
flag2 = true;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "initis") == 0) {
gender = 0;
flag3 = true;
continue;
}
if (len >= 5 && strcmp(s + len - 5, "liala") == 0) {
gender = 1;
flag1 = true;
continue;
}
if (len >= 4 && strcmp(s + len - 4, "etra") == 0) {
gender = 1;
flag2 = true;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "inites") == 0) {
gender = 1;
flag3 = true;
continue;
}
ok = false;
continue;
}
if (flag1) {
if (gender == 0) {
if (len >= 4 && strcmp(s + len - 4, "lios") == 0) {
flag1++;
continue;
}
if (len >= 3 && strcmp(s + len - 3, "etr") == 0) {
flag1 = false;
flag2 = true;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "initis") == 0) {
ok = false;
continue;
}
ok = false;
continue;
}
if (gender == 1) {
if (len >= 5 && strcmp(s + len - 5, "liala") == 0) {
flag1++;
continue;
}
if (len >= 4 && strcmp(s + len - 4, "etra") == 0) {
flag1 = false;
flag2 = true;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "inites") == 0) {
ok = false;
continue;
}
ok = false;
continue;
}
}
if (flag2) {
if (gender == 0) {
if (len >= 4 && strcmp(s + len - 4, "lios") == 0) {
ok = false;
continue;
}
if (len >= 3 && strcmp(s + len - 3, "etr") == 0) {
ok = false;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "initis") == 0) {
flag2 = false;
flag3 = true;
flag4 = true;
continue;
}
ok = false;
continue;
}
if (gender == 1) {
if (len >= 5 && strcmp(s + len - 5, "liala") == 0) {
ok = false;
continue;
}
if (len >= 4 && strcmp(s + len - 4, "etra") == 0) {
ok = false;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "inites") == 0) {
flag2 = false;
flag3 = true;
flag4 = true;
continue;
}
ok = false;
continue;
}
}
if (flag3) {
if (gender == 0) {
if (len >= 4 && strcmp(s + len - 4, "lios") == 0) {
ok = false;
continue;
}
if (len >= 3 && strcmp(s + len - 3, "etr") == 0) {
ok = false;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "initis") == 0) {
if (!flag4) ok = false;
continue;
}
ok = false;
continue;
}
if (gender == 1) {
if (len >= 5 && strcmp(s + len - 5, "liala") == 0) {
ok = false;
continue;
}
if (len >= 4 && strcmp(s + len - 4, "etra") == 0) {
ok = false;
continue;
}
if (len >= 6 && strcmp(s + len - 6, "inites") == 0) {
if (!flag4) ok = false;
continue;
}
ok = false;
continue;
}
continue;
}
}
if (ok && flag1 <= 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <functional>
#include <set>
#include <queue>
#include <cctype>
#include <climits>
#include <stack>
using namespace std;
int main(){
int n;
int r[1000],w[1000];
int sum_r=0,sum_w=0,idx=0;
while(scanf("%d",&n),n){
sum_r=sum_w=idx=0;
for(int i=0;i<n;i++){
scanf("%d %d",&r[i],&w[i]);
sum_r+=r[i];
sum_w+=w[i];
if(r[idx]<r[i]) idx=i;
}
int r0=r[idx],r=sum_r-r0;
w[idx]=0;
if(r0 <= r){
cout<<sum_r+sum_w<<endl;
}else{
int res=2*r0;
//vector<vector<bool> > dp(1001,vector<bool>(1000,false));
// bool cur[1001]={};
bool *cur = (bool*)malloc( sizeof(bool)*(r0-r+2) );
cur[0]=true;
for(int i=0;i<n;i++){
bool *next = (bool*)malloc( sizeof(bool)*(r0-r+2) );
for(int j=0;j<=r0-r;j++){
if(cur[j]){
next[j]=true;
if(j+w[i]<=r0-r)
next[j+w[i]]=true;
}
}
swap(cur,next);
}
int opt=r0-r;
while(!cur[opt]) opt--;
res+=sum_w-opt;
printf("%d\n",res);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> n;
int a;
cin >> a;
multiset<int> st;
for (int i = 1; i < n; ++i) {
int k;
cin >> k;
st.insert(k);
}
int res = 0;
while (a <= *(--st.end())) {
int k = *(--st.end());
st.erase(--st.end());
--k;
++a;
st.insert(k);
++res;
}
cout << res << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long n,k,sum =0,ans;
cin >> n >> k;
for(long i = k; i<=n+1; i++){
sum += i*n+i-(i*(i+1)/2)-(i*(i-1)/2)+1;
}
ans = sum % 1000000007;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char a[550][550];
int b[550][550];
int s[550][550];
int abs(int x) { return (x > 0 ? x : -x); }
int star(int i, int j) {
if (!(i > 0 && i < n - 1 && j > 0 && j < m - 1)) return 0;
for (int(dx) = (-1); (dx) < (2); (dx)++)
for (int(dy) = (-1); (dy) < (2); (dy)++)
if (abs(dx) + abs(dy) <= 1 && a[i + dx][j + dy] == '0') return 0;
return 1;
}
int sum(int i, int j) {
if (i < 0 || j < 0) return 0;
return s[i][j];
}
int get(int a, int b, int x, int y) {
if (a > x || b > y) return 0;
int ans = sum(x, y) - sum(a - 1, y) - sum(x, b - 1) + sum(a - 1, b - 1);
return ans;
}
int main() {
scanf("%d%d%d\n", &n, &m, &k);
for (int(i) = (0); (i) < (n); (i)++) scanf("%s\n", a[i]);
for (int(i) = (0); (i) < (n); (i)++)
for (int(j) = (0); (j) < (m); (j)++) b[i][j] = star(i, j);
for (int(i) = (0); (i) < (n); (i)++)
for (int(j) = (0); (j) < (m); (j)++)
s[i][j] = b[i][j] + sum(i - 1, j) + sum(i, j - 1) - sum(i - 1, j - 1);
long long ans = 0;
for (int(lo) = (0); (lo) < (n); (lo)++) {
for (int(hi) = (lo + 2); (hi) < (n); (hi)++) {
int r = 1;
int curr = 0;
for (int(l) = (0); (l) < (m - 2); (l)++) {
while (r < m - 1 && curr < k) {
curr += get(lo + 1, r, hi - 1, r);
r++;
}
if (curr >= k) {
ans += m - r;
}
curr -= get(lo + 1, l + 1, hi - 1, l + 1);
}
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 5000 + 5;
const ll INF = 1e17 + 5;
int n, m, k;
int a[N];
ll prefixSum[N];
ll mem[N][N];
ll dp(int i, int cnt) {
if (cnt == k) return 0;
if (i == n + 1) return -INF;
if (mem[i][cnt] != -1) return mem[i][cnt];
ll ans = dp(i + 1, cnt);
if (i + m - 1 <= n)
ans =
max(ans, prefixSum[i + m - 1] - prefixSum[i - 1] + dp(i + m, cnt + 1));
return mem[i][cnt] = ans;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
prefixSum[i] = prefixSum[i - 1] + 1ll * a[i];
}
memset(mem, -1, sizeof mem);
printf("%lld\n", dp(1, 0));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[2001], k, sum = 0, i;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = n - 1; i >= 0; i = i - k) sum += a[i] * 2 - 2;
cout << sum << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
int x, y, a, b;
cin >> x >> y >> a >> b;
int ct = 0;
int diff = (x * y) / gcd(x, y);
int i = a;
while (i <= b) {
if (i % x == 0 && i % y == 0) {
ct++;
break;
}
i++;
}
ct += (b - i) / diff;
cout << ct;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y, v;
};
point o, p, q, no1, no2;
double r, R, pi = 3.141592653, qt, dt, od, qo, qd, base = 0.000000001;
point f(point u, point v) {
u.x -= v.x;
u.y -= v.y;
return u;
}
double ccw(point u, point v) { return u.x * v.y - u.y * v.x; }
double dis(point u, point v) {
return sqrt((u.x - v.x) * (u.x - v.x) + (u.y - v.y) * (u.y - v.y));
}
double tichvohuong(point u, point v) { return u.x * v.x + u.y * v.y; }
bool check(double s) {
double goc, ans;
point np;
goc = s * p.v / R;
goc -= (int)(goc / (2 * pi)) * 2 * pi;
np.x = cos(goc) * p.x - sin(goc) * p.y;
np.y = sin(goc) * p.x + cos(goc) * p.y;
if ((ccw(f(np, q), no1) > 0) || (ccw(f(np, q), no2) < 0) || (dis(np, q) < qt))
ans = dis(np, q);
else {
goc = tichvohuong(np, q) / (dis(np, o) * dis(q, o));
goc = acos(goc) - acos(r / R) - acos(r / qo);
ans = dt + qd + goc * r;
}
ans /= q.v;
if (ans <= s)
return true;
else
return false;
}
void solve() {
double l = 0, h = 1000000000, mid;
while (l + base < h) {
mid = (l + h) / 2;
if (check(mid))
h = mid;
else
l = mid;
}
printf("%.9lf", (l + h) / 2);
}
void init() {
double cosalpha, sinalpha;
qo = dis(q, o);
qd = qo * qo - r * r;
qd = sqrt(qd);
dt = R * R - r * r;
dt = sqrt(dt);
qt = dt + qd;
cosalpha = qd / qo;
sinalpha = r / qo;
no1.x = cosalpha * (o.x - q.x) - sinalpha * (o.y - q.y);
no1.y = sinalpha * (o.x - q.x) + cosalpha * (o.y - q.y);
cosalpha = cosalpha;
sinalpha = -sinalpha;
no2.x = cosalpha * (o.x - q.x) - sinalpha * (o.y - q.y);
no2.y = sinalpha * (o.x - q.x) + cosalpha * (o.y - q.y);
if (ccw(no1, no2) < 0) {
point temp;
temp = no1;
no1 = no2;
no2 = temp;
}
}
int main() {
cin >> p.x >> p.y >> p.v;
cin >> q.x >> q.y >> q.v >> r;
R = dis(p, o);
o.x = 0;
o.y = 0;
init();
solve();
return 0;
}
| 3 |
#include <iostream>
#include <queue>
#include <algorithm>
#include <string>
using namespace std;
int dx[] = {0, -1, 1, 0};
int dy[] = {-1, 0, 0, 1};
class Pos
{
public:
int x,y,c;
Pos(int x, int y, int c)
:x(x), y(y), c(c)
{}
};
class Robot
{
public:
int p,c,h;
Robot(int p, int c, int h)
:p(p),c(c),h(h)
{}
bool operator<(const Robot& r) const
{
return c>r.c;
}
};
int main()
{
int fx,fy;
while(cin >> fx >> fy, (fx||fy))
{
int N=1;
int f[21][21],c[12][12];
for(int j=0; j<fy; j++)
{
string s;
cin >> s;
for(int i=0; i<fx; i++)
{
if(s[i]=='o')
{
f[i][j]=0;
}
else if(s[i]=='*')
{
f[i][j]=N;
N++;
}
else if(s[i]=='x')
{
f[i][j]=-2;
}
else f[i][j]=-1;
}
}
for(int j=0; j<N; j++)
for(int i=0; i<N; i++)
c[i][j]=-1;
for(int i=0; i<N; i++)
{
queue<Pos> q;
for(int x=0; x<fx; x++)
for(int y=0; y<fy; y++)
{
if(f[x][y] == i)
{
q.push(Pos(x,y,0));
}
}
bool tf[21][21]={0};
while(!q.empty())
{
Pos p=q.front(); q.pop();
if(f[p.x][p.y] >= 0 && f[p.x][p.y] <= 9)
{
c[i][f[p.x][p.y]] = p.c;
c[f[p.x][p.y]][i] = p.c;
}
tf[p.x][p.y]=1;
for(int j=0; j<4; j++)
{
int tx=p.x+dx[j], ty=p.y+dy[j];
if(tx<0||ty<0||tx>=fx||ty>=fy) continue;
if(tf[tx][ty]) continue;
if(f[tx][ty]==-2) continue;
tf[tx][ty]=1;
q.push(Pos(tx,ty,p.c+1));
}
}
}
priority_queue<Robot> q;
q.push(Robot(0,0,1));
bool g=false;
bool v[11][1<<11]={0};
while(!q.empty())
{
Robot r=q.top(); q.pop();
if(v[r.p][r.h]) continue;
v[r.p][r.h]=1;
if(r.h==(1<<N)-1)
{
g=true;
cout << r.c << endl;
break;
}
for(int i=1; i<N; i++)
{
if(c[r.p][i]==-1) continue;
if(r.h&(1<<i)) continue;
int th=r.h|(1<<i);
if(v[i][th]) continue;
q.push(Robot(i, r.c+c[r.p][i], th));
}
}
if(!g) cout << -1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
const int N = 10000;
const long NL = 1e6 + 5;
const long mod = 1e8 + 7;
const double eps = 1e-10;
using namespace std;
void readi(int &number);
void readll(long long &number);
void readull(unsigned long long &number);
int n, i, j, k, m, a, c, w;
int l[100005];
int t[200005], s[200005], dp[200005];
int main() {
readi(n);
m = c = a = 0;
for (i = 0; i < n + 1; i++) {
readi(l[i]);
dp[i] = c;
c += l[i];
if (l[i] > 1) a++;
if (l[i] == 1) {
a = a == 1 ? 0 : a;
}
}
if (a <= 1 && m <= 0) {
puts("perfect");
return 0;
}
puts("ambiguous");
t[0] = s[0] = 0;
if (l[0] > 1) {
j = 0;
w = 1;
} else
j = 1, w = 0;
printf("0 ");
for (i = 1; i < c; i++) {
if (l[j]) {
s[i] = dp[j];
w++;
}
if (l[j] == w) {
j += 1;
w = 0;
}
printf("%d ", s[i]);
}
puts("");
printf("0 ");
if (l[0] > 1) {
j = 0;
w = 1;
} else
j = 1, w = 0;
for (i = 1; i < c; i++) {
if (l[j]) {
t[i] = dp[j];
if (w && dp[j] - dp[j - 1] > 1) t[i]--;
w++;
}
if (l[j] == w) {
j++;
w = 0;
}
printf("%d ", t[i]);
}
puts("");
return 0;
}
void readi(int &number) {
bool negative = false;
register int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number = ~number + 1;
}
void readll(long long &number) {
bool negative = false;
register int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number = ~number + 1;
}
void readull(unsigned long long &number) {
register int c;
number = 0;
c = getchar();
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
}
| 3 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<utility>
#include<string>
using namespace std;
bool check(const string &s1,const string &s2,int d){
if(s1==s2)return true;
if(d==1){
if(s1.empty()&&s2.size()==1||s2.empty()&&s1.size()==1)return true;
int ld=abs(int(s1.size())-(int)(s2.size()));
if(ld>1)return false;
int h1=0,h2=0;
int t1=s1.size(),t2=s2.size();
while(h1<s1.size()&&h2<s2.size()&&s1[h1]==s2[h2]){
h1++;
h2++;
}
while(t1>0&&t2>0&&s1[t1-1]==s2[t2-1]){
t1--;
t2--;
}
if(ld==1){
return h1==t1||h2==t2;
}else{
return h1+1==t1||h1+2==t1&&s1[h1]==s2[t2-1]&&s1[t1-1]==s2[h2];
}
}else{
for(int i=0;i<s1.size()+1;i++){
string ns=s1;
ns.insert(ns.begin()+i,' ');
for(char c='a';c<='z';c++){
ns[i]=c;
if(check(ns,s2,1))return true;
}
}
for(int i=0;i<s1.size();i++){
if(check(s1.substr(0,i)+s1.substr(i+1),s2,1))return true;
string ns=s1;
for(char c='a';c<='z';c++){
ns[i]=c;
if(check(ns,s2,1))return true;
}
}
string ns=s1;
for(int i=0;i+1<s1.size();i++){
swap(ns[i],ns[i+1]);
if(check(ns,s2,1))return true;
swap(ns[i],ns[i+1]);
}
return false;
}
}
int main(){
for(int n;cin>>n,n;){
int d;
cin>>d;
string names[223];
for(int i=0;i<n;i++){
cin>>names[i];
}
sort(names,names+n);
vector<pair<string,string> > ans;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(check(names[i],names[j],d)){
ans.emplace_back(names[i],names[j]);
}
}
}
for(auto e:ans){
cout<<e.first<<','<<e.second<<endl;
}
cout<<ans.size()<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
map<pair<int, int>, int> dis;
map<pair<int, int>, bool> vis;
bool canplace(int row, int col) {
if (row > 0 and row <= 1e9 and col > 0 and col <= 1e9 and
mp[pair<int, int>(row, col)] == 1 and
vis[pair<int, int>(row, col)] == false)
return true;
return false;
}
int bfs(int x0, int y0, int x1, int y1) {
int row[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int col[8] = {1, 1, 1, 0, -1, -1, -1, 0};
queue<pair<int, int>> q;
q.push(pair<int, int>(x0, y0));
vis[pair<int, int>(x0, y0)] = true;
while (!q.empty()) {
pair<int, int> x;
x = q.front();
if (x == pair<int, int>(x1, y1)) return dis[pair<int, int>(x1, y1)];
q.pop();
for (int i = 0; i < 8; i++) {
if (canplace(x.first + row[i], x.second + col[i])) {
q.push(pair<int, int>(x.first + row[i], x.second + col[i]));
vis[pair<int, int>(x.first + row[i], x.second + col[i])] = true;
dis[pair<int, int>(x.first + row[i], x.second + col[i])] =
dis[pair<int, int>(x.first, x.second)] + 1;
}
}
}
return -1;
}
int main() {
int x0, y0, x1, y1;
cin >> x0 >> y0 >> x1 >> y1;
int n;
cin >> n;
pair<int, int> p;
int a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
for (int j = b; j <= c; j++) {
mp[pair<int, int>(a, j)] = 1;
}
}
cout << bfs(x0, y0, x1, y1) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x;
cin >> n >> x;
long long arr[(1 << 18)];
vector<long long> v;
v.push_back(0);
arr[0] = 1;
for (long long i = 1; i < (1 << 18); i++) arr[i] = 0;
for (long long i = 1; i < (1 << n); i++) {
if (arr[i ^ x]) continue;
v.push_back(i);
arr[i] = 1;
}
cout << v.size() - 1 << "\n";
for (int i = 1; i < v.size(); i++) {
cout << (v[i] ^ v[i - 1]) << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, p = 1;
cin >> n >> m;
if (n < 2) {
for (int j = 1; j <= m; j++) cout << 1 << endl;
} else {
for (int i = 1; i <= m; i++) {
for (int j = 0; j < n - 1; j++)
if (1 + j + p < n)
cout << 1 + j + p << ' ';
else
cout << n << ' ';
cout << n << endl;
if (p < n) p *= 2;
}
}
return 0;
}
| 4 |
#include<iostream>
#include<cstdio>
#include<map>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<stack>
#include<queue>
#include<deque>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
#define ll long long
#define fi first
#define se second
#define PII pair<int,int>
#define scd(a) scanf("%d",&a)
#define scdd(a,b) scanf("%d%d",&a,&b)
#define scddd(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define rep(i,n) for(int i = 0; (i)<(n); i++)
#define rep1(i,n) for(int i = 1; (i)<=(n); i++)
#define pb(a) push_back(a)
#define mst(a,b) memset(a, b, sizeof a)
using namespace std;
vector<PII> v;
priority_queue<ll> q;
ll res,cnt;
ll ans;
void solve()
{
int n;
scd(n);
while(n--)
{
ll x;cin>>x;
res+=x,cnt++;
if(x<0) q.push(-x);
while(res<0&&q.size()){
res+=q.top();q.pop();cnt--;
}
ans=max(ans,cnt);
}
cout<<ans;
}
int main()
{
int t=1;
//cin>>t;
while(t--) solve();
}
| 3 |
#include <bits/stdc++.h>
#define ll long long
#define read(x) scanf("%d",&x)
using namespace std;
const int maxn = 1e5 + 10;
int n;
int p[maxn], pos[maxn];
multiset <int> s;
multiset<int>::iterator a1,a2,x,y,b1,b2;
int main()
{
cin>>n;
for(int i=1;i<=n;i++) {
read(p[i]);
pos[p[i]] = i;
}
s.insert(0); s.insert(0);
s.insert(n+1); s.insert(n+1);
ll res = 0;
for (int i=n;i>=1;i--){
s.insert(pos[i]);
x = y = s.lower_bound(pos[i]); //第一个大于等于pos[i]
a2 = --x; a1 = --x;
b1 = ++y ; b2 = ++y;
res += 1ll*(*a2-*a1)*(*b1-pos[i])*i;
res += 1ll*(pos[i]-*a2)*(*b2-*b1)*i;
}
cout<<res<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
void solve() {
int a, b, n;
cin >> a >> b >> n;
string s1 = to_string(a);
string tmp = s1;
int init_len = s1.size();
for (int i = 1; i <= n; i++) {
bool ok1 = false;
for (int j = 0; j <= 9; j++) {
s1 += (j + '0');
if (stoi(s1) % b == 0) {
ok1 = true;
break;
} else
s1.pop_back();
}
if (ok1) break;
}
int val = n - (int)s1.size() + init_len;
if (val == n) {
cout << -1 << '\n';
return;
}
while (val--) s1.push_back('0');
cout << s1 << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct node {
int id;
long long val;
} a[N];
bool cmp(node a, node b) { return a.val > b.val; }
int n, ans1;
long long pre[N], suf[N], A, cf, cm, m, ans, ans2, fin[N];
bool check(int ll, long long cur, long long goal) {
int l = ll, r = n + 1;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid].val >= goal)
l = mid + 1;
else
r = mid;
}
return cur >= goal * (n + 1 - l) - suf[l];
}
int _get(int ll, long long goal) {
int l = ll, r = n + 1;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid].val >= goal)
l = mid + 1;
else
r = mid;
}
return l;
}
void upd(int st1, long long st2) {
long long w = st1 * cf + st2 * cm;
if (w > ans) {
ans = w;
ans1 = st1;
ans2 = st2;
}
}
int main() {
scanf("%d%I64d%I64d%I64d%I64d", &n, &A, &cf, &cm, &m);
for (int i = 1; i <= n; i++) {
a[i].id = i;
scanf("%I64d", &a[i].val);
}
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i].val;
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] + a[i].val;
for (int i = 0; i <= n; i++) {
long long cur = m;
cur -= A * i - pre[i];
if (cur < 0) break;
long long l = 0, r = A;
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (check(i + 1, cur, mid)) {
l = mid;
} else
r = mid;
}
if (check(i + 1, cur, r))
upd(i, r);
else
upd(i, l);
}
int g = _get(ans1 + 1, ans2);
for (int i = 1; i <= ans1; i++) a[i].val = A;
for (int i = g; i <= n; i++) a[i].val = ans2;
for (int i = 1; i <= n; i++) fin[a[i].id] = a[i].val;
cout << ans << endl;
for (int i = 1; i <= n; i++) cout << fin[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, m;
int a[501], b[501], dp[501][501], prea[501][501], preb[501][501];
int ans;
int ax, ay;
std::unordered_map<int, std::vector<int>> mb;
std::vector<int> ab;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
std::cin >> n;
a[0] = -1;
for (int i = 1; i <= n; i++) std::cin >> a[i];
std::cin >> m;
b[0] = -1;
mb[-1].push_back(0);
for (int i = 1; i <= m; i++) {
std::cin >> b[i];
mb[b[i]].push_back(i);
}
for (int i = 1; i <= n; i++)
if (mb.count(a[i]))
for (const int& j : mb[a[i]]) {
for (int k = i - 1; k >= 0; k--)
if (a[k] < a[i])
if (mb.count(a[k]))
for (const int& l : mb[a[k]])
if (l < j) {
if (dp[i][j] < dp[k][l] + 1) {
dp[i][j] = dp[k][l] + 1;
prea[i][j] = k;
preb[i][j] = l;
}
} else
break;
if (ans < dp[i][j]) {
ans = dp[i][j];
ax = i;
ay = j;
}
}
std::cout << ans << '\n';
std::stack<int> st;
while (ax && ay) {
st.push(a[ax]);
int na = prea[ax][ay];
int nb = preb[ax][ay];
ax = na;
ay = nb;
}
while (!st.empty()) {
std::cout << st.top() << ' ';
st.pop();
}
std::cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long int INF = 4294967297;
constexpr double pi = 3.14159265358979;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
string s;
cin >> n >> s;
vector<char> f;
for (char x; cin >> x;) {
f.push_back(x);
}
bool was = 0;
for (long long int i = 0; i < n; ++i) {
char x = s[i], y = f[x - 49];
if (y < x) {
if (was)
return cout << s, 0;
else
continue;
} else {
if (x == y && !was) continue;
was = 1;
s[i] = f[s[i] - 49];
}
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 4e5 + 5;
struct edge_t {
int u, v, next;
} G[N << 1];
int maxn[N << 2], head[N], siz[N], ans[N], tops[N];
int n, tot, dfn;
inline void addedge(int u, int v) {
G[++tot] = (edge_t){u, v, head[u]}, head[u] = tot;
G[++tot] = (edge_t){v, u, head[v]}, head[v] = tot;
}
void update(int u) { maxn[u] = max(maxn[u << 1], maxn[u << 1 | 1]); }
void change(int u, int l, int r, int x, int y) {
if (l == r) {
maxn[u] = y;
return;
}
int mid = (l + r) >> 1;
if (mid >= x)
change(u << 1, l, mid, x, y);
else
change(u << 1 | 1, mid + 1, r, x, y);
update(u);
}
int query(int u, int l, int r, int L, int R) {
if (l > r) return 0;
if (l <= L && R <= r) return maxn[u];
int mid = (L + R) >> 1, ans = 0;
if (mid >= l) ans = max(ans, query(u << 1, l, r, L, mid));
if (mid + 1 <= r) ans = max(ans, query(u << 1 | 1, l, r, mid + 1, R));
return ans;
}
void dfs1(int u, int fa) {
tops[u] = ++dfn;
siz[u] = 1;
for (register int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (v == fa) continue;
dfs1(v, u);
siz[u] += siz[v];
}
if (siz[u] <= (n >> 1)) change(1, 1, n, tops[u], siz[u]);
}
void dfs2(int u, int fa, int mx) {
bool qaq = 1;
if (n - siz[u] > (n >> 1) && max(max(query(1, 1, tops[u] - 1, 1, n),
query(1, tops[u] + siz[u], n, 1, n)),
mx) >= n - siz[u] - (n >> 1))
ans[u] = 1;
if (n - siz[u] <= (n >> 1))
mx = max(mx, n - siz[u]);
else
qaq = 0;
if (siz[u] <= (n >> 1)) change(1, 1, n, tops[u], 0);
for (register int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (v == fa) continue;
dfs2(v, u, mx);
if (siz[v] > (n >> 1)) {
qaq = 0;
if (query(1, tops[u], tops[u] + siz[u] - 1, 1, n) >= siz[v] - (n >> 1))
ans[u] = 1;
}
}
if (qaq) ans[u] = 1;
if (siz[u] <= (n >> 1)) change(1, 1, n, tops[u], siz[u]);
}
int main() {
read(n);
for (register int i = 1; i < n; i++) {
int u, v;
read(u);
read(v);
addedge(u, v);
}
dfs1(1, 0);
dfs2(1, 0, 0);
for (register int i = 1; i <= n; i++) print(ans[i], i == n ? '\n' : ' ');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void pre() {}
void solve() {}
int main() {
int n;
cin >> n;
int m;
cin >> m;
int r[m + 1];
for (int i = 0; i < (m + 1); ++i) {
r[i] = (i * i) % m;
}
int cnt[m + 1];
for (int i = (1); i <= (m); ++i) {
cnt[i] = 0;
cnt[i] += (n / m);
if (i <= (n % m)) cnt[i]++;
}
long long cnt1 = 0;
for (int i = (1); i <= (m); ++i) {
for (int j = (1); j <= (m); ++j) {
if ((r[i] + r[j]) % m == 0) cnt1 += (long long)cnt[i] * cnt[j];
}
}
cout << cnt1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
unsigned long long h, n;
cin >> h >> n;
bool isL = true;
unsigned long long ans = 0;
unsigned long long p = 0;
while (h != 0) {
p = pow(2, h - 1);
if (p > n && isL) {
ans += 1;
isL = !isL;
} else if (p > n && !isL) {
ans += pow(2, h);
} else if (p < n && isL) {
ans += pow(2, h);
} else if (p == n && !isL) {
ans += pow(2, h);
} else {
ans += 1;
isL = !isL;
}
if (p < n) {
n -= p;
}
h--;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Tree {
int l, r, MAX;
};
Tree tree[200010 * 4];
int x[200010], y[200010], xx[200010], yy[200010], idx[200010], idy[200010],
p[200010];
char s[10];
set<int> S[200010];
int ansx, ansy;
void build(int t, int l, int r) {
tree[t].l = l, tree[t].r = r, tree[t].MAX = -1;
if (l == r) return;
int mid = (l + r) / 2;
build(t * 2, l, mid);
build(t * 2 + 1, mid + 1, r);
}
void pushup(int t) { tree[t].MAX = max(tree[t * 2].MAX, tree[t * 2 + 1].MAX); }
void update(int t, int x, int y, int v) {
if (tree[t].l == tree[t].r) {
if (v == 1) {
S[x].insert(y);
tree[t].MAX = max(tree[t].MAX, y);
} else {
S[x].erase(y);
tree[t].MAX = S[x].empty() ? -1 : *(--S[x].end());
}
return;
}
int mid = (tree[t].l + tree[t].r) / 2;
if (x <= mid)
update(t * 2, x, y, v);
else
update(t * 2 + 1, x, y, v);
pushup(t);
}
void query(int t, int l, int r, int v) {
if (l <= tree[t].l && tree[t].r <= r) {
if (tree[t].l == tree[t].r) {
if (tree[t].MAX > v)
ansx = tree[t].l, ansy = *S[tree[t].l].lower_bound(v + 1);
return;
}
if (tree[2 * t].MAX > v)
query(t * 2, l, r, v);
else if (tree[2 * t + 1].MAX > v)
query(t * 2 + 1, l, r, v);
return;
}
int mid = (tree[t].l + tree[t].r) / 2;
if (r <= mid)
query(t * 2, l, r, v);
else if (l > mid)
query(t * 2 + 1, l, r, v);
else {
query(t * 2, l, r, v);
if (ansx == -1) query(t * 2 + 1, l, r, v);
}
}
int main() {
int n, X, Y;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s%d%d", s, &x[i], &y[i]);
xx[i] = x[i];
yy[i] = y[i];
if (s[0] == 'a') p[i] = 0;
if (s[0] == 'r') p[i] = -1;
if (s[0] == 'f') p[i] = 1;
}
sort(xx + 1, xx + n + 1);
sort(yy + 1, yy + n + 1);
X = unique(xx + 1, xx + n + 1) - xx - 1;
Y = unique(yy + 1, yy + n + 1) - yy - 1;
for (int i = 1; i <= n; i++)
idx[i] = lower_bound(xx + 1, xx + X + 1, x[i]) - xx;
for (int i = 1; i <= n; i++)
idy[i] = lower_bound(yy + 1, yy + Y + 1, y[i]) - yy;
build(1, 1, X);
for (int i = 1; i <= n; i++) {
if (p[i] == 0) update(1, idx[i], idy[i], 1);
if (p[i] == -1) update(1, idx[i], idy[i], -1);
if (p[i] == 1) {
ansx = -1, ansy = -1;
if (idx[i] < X) query(1, idx[i] + 1, X, idy[i]);
if (ansx == -1)
printf("-1\n");
else
printf("%d %d\n", xx[ansx], yy[ansy]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI =
3.14159265358979323846264338327950288419716939937510582097494459230;
const long long MOD = 1e9 + 7;
const long long INF = 1e14;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
long long mpow(long long a, long long b, long long p = MOD) {
a = a % p;
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % p;
a = (a * a) % p;
b = b >> 1;
}
return res % p;
}
const long long N = 50005;
vector<long long> a[N];
long long ans[N];
void dfs(long long node, long long p = -1) {
ans[node] = p;
for (auto x : a[node]) {
if (x != p) dfs(x, node);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, r1, r2;
cin >> n >> r1 >> r2;
for (int i = 1; i <= (int)(n); ++i) {
if (i == r1) continue;
long long x;
cin >> x;
a[i].push_back(x);
a[x].push_back(i);
}
dfs(r2);
for (int i = 1; i <= (int)(n); ++i) {
if (i == r2) continue;
cout << ans[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int qq = 1e5 + 10;
const long long INF = 1e18 + 10;
int main() {
int n;
cin >> n;
cout << n * 2 - 1 << " 2" << endl;
cout << "1 2" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000111222;
const int max_n = 211;
struct point {
int x, y;
};
long long get_sqr(const point& p1, const point& p2, const point& p3) {
long long res = 0;
res += (p2.x - p1.x) * 1LL * (p1.y + p2.y);
res += (p3.x - p2.x) * 1LL * (p2.y + p3.y);
res += (p1.x - p3.x) * 1LL * (p3.y + p1.y);
return abs(res);
}
point p[max_n];
int dp[max_n][max_n], n, k;
long long all_sqr[max_n][max_n][max_n];
bool check(long long sz) {
for (int l = 2; l < n; ++l) {
for (int st = 0; st < n; ++st) {
int fn = (st + l) % n;
dp[st][fn] = 0;
long long curr_sqr = 0;
int curr_st = 0;
for (int i = st + 1; i != fn; ++i) {
int pr = i - 1;
if (i == n) i -= n;
if (i == fn) break;
if (curr_sqr < sz) {
curr_st = i;
curr_sqr += all_sqr[fn][pr][i];
}
if (all_sqr[st][fn][i] >= sz) {
dp[st][fn] = max(dp[st][fn], dp[st][i] + dp[i][fn] + 1);
}
}
if (curr_sqr >= sz) {
dp[st][fn] = max(dp[st][fn], 1 + dp[curr_st][fn]);
}
if (dp[st][fn]) {
int pr = (curr_st - 1 + n) % n;
assert(curr_st != fn);
for (int fnn = fn - 1; fnn != st; --fnn) {
int nxt = fnn + 1;
if (fnn < 0) fnn += n;
if (fnn == st) break;
curr_sqr += all_sqr[fnn][curr_st][nxt];
long long nxt_sqr = all_sqr[fnn][pr][curr_st];
while (curr_sqr - nxt_sqr >= sz && curr_st != st) {
curr_sqr -= nxt_sqr;
curr_st = pr;
--pr;
if (pr < 0) pr += n;
nxt_sqr = all_sqr[fnn][pr][curr_st];
}
dp[st][fn] = max(dp[st][fn], dp[curr_st][fnn] + 1);
if (curr_st == st) break;
}
} else {
dp[st][fn] = curr_sqr >= sz;
}
if (dp[st][fn] >= k + 1) {
return true;
}
}
}
return false;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> p[i].x >> p[i].y;
}
auto stt = clock();
for (int i = 0; i < n; ++i) {
for (int q = 0; q < n; ++q) {
for (int w = 0; w < n; ++w) {
all_sqr[i][q][w] = get_sqr(p[i], p[q], p[w]);
}
}
}
long long l = 1, r = 1LL * inf * inf;
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << "\n";
}
| 5 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define OP(m) cout << m << endl
typedef long long ll;
typedef unsigned long long ull;
int main()
{
int n;
string s;
int w, l, d;
bool p = 0;
while (cin >> n, n)
{
if (p)
cout << endl;
p = 1;
multimap<int, string, greater<int>> mp;
rep(i, n)
{
cin >> s >> w >> l >> d;
mp.insert(make_pair(3 * w + d, s));
}
for (auto a : mp)
cout << a.second << "," << a.first << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string s;
int a2[] = {2, 4, 8, 6}, a3[] = {3, 9, 7, 1}, a4[] = {4, 6};
cin >> s;
int n = 0;
for (int i = 0; i < s.size(); ++i) n = (n * 10 + (s[i] - '0')) % 4;
if (n < 4) n += 4;
cout << (1 + a2[(n - 1) % 4] + a3[(n - 1) % 4] + a4[(n - 1) % 2]) % 5 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int P = 135;
int n, p, q, i, j, C[P], a[P], ans;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
scanf("%d%d%d", &n, &p, &q);
if (n - 1 < p) p = n - 1;
for (C[0] = 1, i = 1; i <= p; i++) {
a[i] = n + 1 - i;
int k = i;
for (j = 1; k > 1 && j <= i; j++) {
int gd = gcd(k, a[j]);
k /= gd;
a[j] /= gd;
}
for (C[i] = 1, j = 1; j <= i; j++) C[i] = C[i] * a[j];
}
for (i = 1; i <= q; i++) {
int pw = 1, sum = 0;
for (j = 0; j <= p; j++, pw *= i) sum += C[j] * pw;
ans ^= sum * i;
}
printf("%u", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, ans = 1, i;
cin >> n;
string s;
cin >> s;
for (i = 0; i < s.length() - 1; i++) {
if (s[i] != s[i + 1]) ans++;
}
ans = min(n, ans + 2);
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 260;
const int MOD = (int)(1e9) + 7;
int main() {
ios_base::sync_with_stdio(false);
int q;
cin >> q;
while (q--) {
long long k;
cin >> k;
auto get = [&](long long d, long long i, long long j) {
long long ans = 0;
ans = j * (j + 1) / 2 - i * (i - 1) / 2;
ans = max(ans, 0LL);
return ans * d;
};
vector<long long> p10(19);
p10[0] = 1;
for (int i = 1; i <= 18; i++) {
p10[i] = 10LL * p10[i - 1];
}
long long running = 0;
long long gotten = 0;
int d;
for (d = 0; d <= 17; d++) {
long long want = (9 * p10[d] * running) + get(d + 1, 1, 9 * p10[d]);
if (want > k || gotten + want > k) break;
running += 9 * p10[d] * (d + 1);
gotten += want;
}
k -= gotten;
long long lo = p10[d] - 1;
long long hi = p10[d + 1] - 1;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2;
long long taken = mid - (p10[d] - 1);
if (taken * running + get(d + 1, 1, mid - p10[d] + 1) >= k) {
hi = mid - 1;
} else {
lo = mid;
}
}
long long taken = lo - (p10[d] - 1);
long long s = running * taken + get(d + 1, 1, lo - p10[d] + 1);
++lo;
k -= s;
long long g = 0;
int p;
for (p = 0; p <= 17; p++) {
if (g + (p + 1) * (p10[p] * 9) > k) break;
g += (p + 1) * (p10[p] * 9);
}
k -= g;
if (k == 0) {
cout << 9 << '\n';
continue;
}
long long which = p10[p] + (k - 1) / (p + 1);
string shit = to_string(which);
cout << shit[(k - 1) % (p + 1)] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<pair<pair<int, int>, int> > s;
pair<pair<int, int>, int> a[100005];
int ans[100005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i;
}
sort(a, a + n);
int t = 0;
for (int i = 0; i < n; i++) {
int st;
for (int j = i; j < min(n, i + m); j++) {
s.insert(make_pair(make_pair(a[j].first.second, a[j].first.first),
a[j].second));
st = a[j].first.first;
}
t = max(t, st);
while (s.size()) {
pair<pair<int, int>, int> p = *s.begin();
s.erase(p);
t += p.first.first;
ans[p.second] = t;
int x = 1;
while (p.first.first == (*s.begin()).first.first) {
ans[s.begin()->second] = t;
s.erase(s.begin());
x++;
}
t += 1 + x / 2;
t -= p.first.first;
if (s.size() == 0) t += 2 * p.first.first;
}
i += m - 1;
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 6;
const int inf = (int)1e9 * 2;
const int mod = (int)1e9 + 7;
int n;
long long a[maxn], cnt;
inline int fun(int x) {
if (x == 0) return 0;
if (x % 2 == 0) return fun(x / 2);
return fun(x / 2) + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[fun(x)]++;
}
for (int i = 0; i < 100000; i++) {
cnt += a[i] * 1ll * (a[i] - 1) / 2;
}
printf("%lld\n", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int p, e, i;
};
vector<node> lst;
bool vis[1 << 18];
bool cmp1(const node &lhs, const node &rhs) {
if (lhs.p == rhs.p) {
return lhs.e > rhs.e;
}
return lhs.p > rhs.p;
}
bool cmp2(const node &lhs, const node &rhs) { return lhs.e < rhs.e; }
int main() {
int n, k;
cin >> n >> k;
lst.resize(n);
for (int i = 0; i < n; i++) {
cin >> lst[i].p >> lst[i].e;
lst[i].i = i;
}
if (k == n + 1) {
cout << 0 << '\n';
return 0;
}
sort(lst.begin(), lst.end(), cmp1);
long long answer = -1;
int pk = lst[k - 1].p;
if ((int)(lst.size()) >= pk + 2) {
sort(lst.begin(), lst.end(), cmp2);
long long my_e = 0;
for (int i = 0; i < pk + 2; i++) {
my_e += lst[i].e;
}
answer = my_e;
}
if ((int)(lst.size()) >= pk + 1) {
memset(vis, false, sizeof vis);
vector<node> buf;
int large_cnt = 0;
for (int i = 0; i < (int)(lst.size()); i++) {
if (lst[i].p == pk + 1 || lst[i].p == pk) buf.push_back(lst[i]);
if (lst[i].p > pk + 1) {
++large_cnt;
}
}
sort(buf.begin(), buf.end(), cmp2);
long long my_e = 0;
int cnt = 0;
for (int i = 0; i <= (int)(buf.size()) - k + large_cnt; i++) {
my_e += buf[i].e;
vis[buf[i].i] = true;
++cnt;
}
sort(lst.begin(), lst.end(), cmp2);
for (int i = 0, j = 0; j < pk + 1 - cnt; i++) {
if (!vis[lst[i].i]) {
my_e += lst[i].e;
++j;
}
}
if (answer == -1)
answer = my_e;
else
answer = min(answer, my_e);
}
if ((int)(lst.size()) >= pk) {
memset(vis, false, sizeof vis);
vector<node> buf;
int large_cnt = 0;
for (int i = 0; i < (int)(lst.size()); i++) {
if (lst[i].p == pk || lst[i].p == pk - 1) buf.push_back(lst[i]);
if (lst[i].p > pk) {
++large_cnt;
}
}
sort(buf.begin(), buf.end(), cmp2);
long long my_e = 0;
int cnt = 0;
for (int i = 0; i <= (int)(buf.size()) - k + large_cnt; i++) {
my_e += buf[i].e;
vis[buf[i].i] = true;
++cnt;
}
sort(lst.begin(), lst.end(), cmp2);
for (int i = 0, j = 0; j < pk - cnt; i++) {
if (!vis[lst[i].i]) {
my_e += lst[i].e;
++j;
}
}
if (answer == -1)
answer = my_e;
else
answer = min(answer, my_e);
}
cout << answer;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
const int M = 5010;
const int q = 71;
int n, m;
string s;
int lHash[M][M], rHash[M][M], cnt[M];
short pal[M][M];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.length();
s = '#' + s;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
lHash[i][j] = ((lli)lHash[i][j - 1] * q + (lli)s[j]) % 1000000007;
for (int i = n; i >= 1; i--)
for (int j = i; j <= n; j++)
rHash[i][j] = ((lli)rHash[i + 1][j] * q + (lli)s[i]) % 1000000007;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
m = (j - i - 1) / 2;
if (lHash[i][i + m] == rHash[j - m][j]) pal[i][j] = pal[i][i + m] + 1;
cnt[pal[i][j]]++;
}
for (int i = n - 1; i >= 1; i--) cnt[i] += cnt[i + 1];
for (int i = 1; i <= n; i++) cout << cnt[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int n;
cin >> n;
char s[105];
cin >> s;
int sum = 0;
int flag = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') sum++;
if (s[i] == '0') flag = 1;
if (flag == 1) {
cout << sum;
sum = 0;
flag = 0;
}
}
cout << sum << endl;
return 0;
}
| 1 |
#include<iostream>
#include<string>
using namespace std;
int main(){
int x,a,b;
cin>>x>>a>>b;
if(abs(a-x)>abs(b-x))cout<<"B"<<endl;
else cout<<"A"<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int MN=260000;
int x[520][520];
int cnt[MN][4];
int main(){
int n,m;
cin>>n>>m;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cin>>x[i][j];
}
}
int res=0;
for(int i=0;i<n;i++){
for(int j=0;j<m-1;j++){
if(x[i][j]%2==1){
x[i][j]--;
x[i][j+1]++;
cnt[res][0]=i;
cnt[res][1]=j;
cnt[res][2]=i;
cnt[res][3]=j+1;
res++;
}
}
}
int ax=m-1;
for(int i=0;i<n-1;i++){
if(x[i][ax]%2==1){
x[i][ax]--;
x[i+1][ax]++;
cnt[res][0]=i;
cnt[res][1]=ax;
cnt[res][2]=i+1;
cnt[res][3]=ax;
res++;
}
}
cout<<res<<endl;
for(int i=0;i<res;i++){
cout<<cnt[i][0]+1<<" "<<cnt[i][1]+1<<" "<<cnt[i][2]+1<<" "<<cnt[i][3]+1<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, sA = 0, sB = 0;
long long common = 0, first = 0, second = 0;
string a, b;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> a >> b;
for (long long i = 0; i < 2 * n; i++) {
if (a[i] == '1' && b[i] == '1')
common++;
else if (a[i] == '1')
first++;
else if (b[i] == '1')
second++;
}
for (long long i = 1; i <= 2 * n; i++) {
if (i % 2) {
if (common > 0) {
sA++;
common--;
} else if (first > 0) {
sA++;
first--;
} else
second--;
} else {
if (common > 0) {
sB++;
common--;
} else if (second > 0) {
sB++;
second--;
} else
first--;
}
}
if (sA > sB)
cout << "First";
else if (sA == sB)
cout << "Draw";
else
cout << "Second";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3e5 + 10;
const long long INF = 1e18 + 10;
const long long LOG = 1e7 + 19;
const long long MOD = 998244353;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
long long dp[1010][1010], a[1010][1010];
vector<pair<long long, pair<long long, long long> > > vec;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
vec.push_back(make_pair(a[i][j], make_pair(i, j)));
}
}
sort(vec.begin(), vec.end());
long long r, c;
cin >> r >> c;
long long k = n * m, p = 0, x = 0, x2 = 0, y = 0, y2 = 0;
for (int i = 0; i < k;) {
int j = i;
while (j < k && vec[i].first == vec[j].first) {
j++;
}
for (int l = i; l < j; l++) {
long long s = vec[l].second.first, t = vec[l].second.second;
dp[s][t] =
((p + x2 + i * s * s - 2 * s * x + y2 + i * t * t - 2 * t * y) % MOD +
MOD) %
MOD * pw(i, MOD - 2, MOD) % MOD;
}
for (int l = i; l < j; l++) {
long long s = vec[l].second.first, t = vec[l].second.second;
p = (p + dp[s][t]) % MOD;
x = (x + s) % MOD;
x2 = (x2 + s * s) % MOD;
y = (y + t) % MOD;
y2 = (y2 + t * t) % MOD;
}
i = j;
}
cout << dp[r][c];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Dat{ int x, y, i; };
int n, m;
vector<Dat> pv;
vector<int> sv[200010];
set<int> ss, ts;
int main(){
scanf("%d%d", &n, &m);
for(int i = 1, x, y; i <= n; i++){
scanf("%d%d", &x, &y);
pv.push_back({x, y, i});
sv[y].push_back(i);
ss.insert(i);
}
sort(pv.begin(), pv.end(), [](Dat a, Dat b){ return a.x == b.x ? a.y > b.y : a.x < b.x; });
for(int i = 1, j = 0; i <= m; i++){
while(j < pv.size() && pv[j].x < i) j++;
for(auto &t : sv[i]) ts.insert(t);
if(j < pv.size()){ ss.erase(pv[j].i); j++; }
else{
while(!ts.empty()){
auto t = ts.begin();
if(ss.find(*t) != ss.end()){
ss.erase(*t);
ts.erase(t);
break;
}
ts.erase(t);
}
}
}
printf("%d\n", ss.size());
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int pre[N], a[N];
void dfs(int x) {
if (x == 0) {
printf("RUN %d\n", a[1] - a[0] - 2);
return;
}
dfs(pre[x]);
printf("JUMP %d\n", a[x] - a[pre[x] + 1] + 2);
if (a[x + 1] - a[x] - 2) printf("RUN %d\n", a[x + 1] - a[x] - 2);
}
int main() {
int n, m, s, d;
cin >> n >> m >> s >> d;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
a[n++] = m + 1;
a[n++] = -1;
sort(a, a + n);
n = unique(a, a + n) - a;
int now = 0;
memset(pre, -1, sizeof pre);
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] - a[i] - 2 < s) continue;
if (i > now) {
cout << "IMPOSSIBLE\n";
return 0;
}
int pos = a[i + 1] - 1 + d;
int p = lower_bound(a, a + n, pos) - a - 1;
if (now < p) {
for (int j = now + 1; j <= p; j++) pre[j] = i;
now = p;
}
}
if (pre[n - 2] == -1)
cout << "IMPOSSIBLE\n";
else
dfs(n - 2);
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string &a) { cin >> a; }
template <class T>
void scan(vector<T> &);
template <class T, size_t size>
void scan(array<T, size> &);
template <class T, class L>
void scan(pair<T, L> &);
template <class T, size_t size>
void scan(T (&)[size]);
template <class T>
void scan(vector<T> &a) {
for (auto &i : a) scan(i);
}
template <class T>
void scan(deque<T> &a) {
for (auto &i : a) scan(i);
}
template <class T, size_t size>
void scan(array<T, size> &a) {
for (auto &i : a) scan(i);
}
template <class T, class L>
void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T, size_t size>
void scan(T (&a)[size]) {
for (auto &i : a) scan(i);
}
template <class T>
void scan(T &a) {
cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
string stin() {
string s;
cin >> s;
return s;
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
vector<int> iota(int n) {
vector<int> a(n);
iota(begin(a), end(a), 0);
return a;
}
template <class T>
void UNIQUE(vector<T> &x) {
sort(begin(x), end(x));
x.erase(unique(begin(x), end(x)), x.end());
}
int in() {
int x;
cin >> x;
return x;
}
long long lin() {
unsigned long long x;
cin >> x;
return x;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string &a) { cout << a; }
void print(double a) { cout << a; }
template <class T>
void print(const vector<T> &);
template <class T, size_t size>
void print(const array<T, size> &);
template <class T, class L>
void print(const pair<T, L> &p);
template <class T, size_t size>
void print(const T (&)[size]);
template <class T>
void print(const vector<T> &a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
cout << endl;
}
template <class T>
void print(const deque<T> &a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, size_t size>
void print(const array<T, size> &a) {
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, class L>
void print(const pair<T, L> &p) {
cout << '(';
print(p.first);
cout << ",";
print(p.second);
cout << ')';
}
template <class T>
void print(set<T> &x) {
for (auto e : x) print(e), cout << " ";
cout << endl;
}
template <class T>
void print(multiset<T> &x) {
for (auto e : x) print(e), cout << " ";
cout << endl;
}
template <class T, size_t size>
void print(const T (&a)[size]) {
print(a[0]);
for (auto i = a; ++i != end(a);) {
cout << " ";
print(*i);
}
}
template <class T>
void print(const T &a) {
cout << a;
}
int out() {
putchar('\n');
return 0;
}
template <class T>
int out(const T &t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
int out(const Head &head, const Tail &...tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
long long gcd(long long a, long long b) {
while (b) {
long long c = b;
b = a % b;
a = c;
}
return a;
}
long long lcm(long long a, long long b) {
if (!a || !b) return 0;
return a * b / gcd(a, b);
}
vector<pair<long long, long long>> factor(long long x) {
vector<pair<long long, long long>> ans;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
ans.push_back({i, 1});
while ((x /= i) % i == 0) ans.back().second++;
}
if (x != 1) ans.push_back({x, 1});
return ans;
}
vector<int> divisor(int x) {
vector<int> ans;
for (int i = 1; i * i <= x; i++)
if (x % i == 0) {
ans.push_back(i);
if (i * i != x) ans.push_back(x / i);
}
return ans;
}
int popcount(long long x) { return __builtin_popcountll(x); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int n) { return uniform_int_distribution<int>(0, n - 1)(rng); }
template <class... T>
void err(const T &...) {}
struct Setup_io {
Setup_io() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
}
} setup_io;
template <const int sz = 5 * 10000000, typename T = long long>
struct IO {
char reader[sz], writer[sz];
char *now, *now2 = writer;
IO() {
reader[fread(reader, sizeof(char), sizeof(char) * sz, stdin)];
now = reader;
}
inline T read() {
while (*now && *now <= 32) now++;
if (*now == '-') {
now++;
T res = 0;
while ('0' <= *now and *now <= '9') {
res = res * 10 + *now++ - '0';
}
return -res;
} else {
T res = 0;
while ('0' <= *now and *now <= '9') {
res = res * 10 + *now++ - '0';
}
return res;
}
}
inline void write(T x, char margin = ' ') {
if (x == 0) {
putchar('0');
putchar(margin);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
*now2 = '0' + x % 10;
now2++;
x /= 10;
}
do {
now2--;
putchar(*now2);
} while (now2 != writer);
putchar(margin);
}
};
constexpr int N = 701;
using B = bitset<700>;
B b[N];
B r[N][N];
int a[N];
int n;
IO<10000, int> io;
int main() {
n = io.read();
for (long long i = 0; i < n; ++i) a[i] = io.read();
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < n; ++j)
if (gcd(a[i], a[j]) > 1) b[i][j] = true;
for (long long i = 0; i < n; ++i) r[i][i] = b[i];
for (long long d = 1; d <= n - 1; ++d) {
for (long long i = 0; i <= n - 1 - d; ++i) {
int j = i + d;
if (r[i + 1][j][i]) r[i][j] = b[i];
if (r[i][j - 1][j]) r[i][j] |= b[j];
for (long long k = i + 1; k <= j - 1; ++k) {
if (r[i][k - 1][k] and r[k + 1][j][k]) {
r[i][j] |= b[k];
}
}
}
}
for (long long i = 0; i < n; ++i) {
if (r[0][n - 1][i]) {
cout << "Yes\n";
return 0;
}
}
cout << "No" << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x, y, z, t1, t2, t3;
int stair() { return t1 * abs(y - x); }
int elev() { return t2 * abs(z - x) + t3 * 3 + t2 * abs(x - y); }
int main() {
cin >> x >> y >> z >> t1 >> t2 >> t3;
if (stair() >= elev()) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
vector<long long> arr;
vector<long long> st;
void updatest(long long p, long long beg, long long end, long long index);
void buildst(long long p, long long beg, long long end);
int rmq(long long p, long long beg, long long end, long long lb, long long ub);
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long x, y, a, b;
cin >> x >> y >> a >> b;
vector<pair<long long, long long> > v;
for (long long i = a; i <= x; i++) {
for (long long j = b; j <= y; j++) {
if (i > j) {
v.push_back(make_pair(i, j));
}
}
}
cout << v.size() << endl;
for (long long i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
return 0;
}
void updatest(long long p, long long beg, long long end, long long index) {
if (beg == end) {
return;
} else {
long long c1 = 2 * p, c2 = 2 * p + 1;
if (index > (beg + end) / 2) {
updatest(c2, ((beg + end) / 2) + 1, end, index);
} else {
updatest(c1, beg, (beg + end) / 2, index);
}
if (arr[st[c1]] < arr[st[c2]])
st[p] = st[c1];
else
st[p] = st[c2];
}
}
void buildst(long long p, long long beg, long long end) {
if (beg == end)
st[p] = beg;
else {
long long c1 = 2 * p, c2 = 2 * p + 1;
buildst(c1, beg, (beg + end) / 2);
buildst(c2, ((beg + end) / 2) + 1, end);
if (arr[st[c1]] <= arr[st[c2]])
st[p] = st[c1];
else
st[p] = st[c2];
}
}
int rmq(long long p, long long beg, long long end, long long lb, long long ub) {
if (lb > end || ub < beg)
return -1;
else {
if (lb <= beg && ub >= end)
return st[p];
else {
long long rmq_left = rmq(2 * p, beg, (beg + end) / 2, lb, ub);
long long rmq_right = rmq(2 * p + 1, ((beg + end) / 2) + 1, end, lb, ub);
if (rmq_left == -1)
return rmq_right;
else if (rmq_right == -1)
return rmq_left;
else
return (arr[rmq_left] < arr[rmq_right] ? rmq_left : rmq_right);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void Freopen() {
freopen(
"title"
".in",
"r", stdin);
freopen(
"title"
".out",
"w", stdout);
}
long long read() {
long long 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 long long N = 1e5 + 5;
const long long S = 400;
const long double INF = 1e18;
long long f[N], a[N], n, be[N], id[N], sqr, l[S], r[S], maxn, ans;
struct Sqr {
long long k, b, st[S], top, re;
long long data(long long x) { return f[x] + k * a[x] + b; }
long double slope(long long x, long long y) {
if (a[x] == a[y]) return f[x] > f[y] ? -INF : INF;
return 1.0L * (f[x] - f[y]) / (a[x] - a[y]);
}
void build(long long l, long long r) {
for (long long i = l; i <= r; i++) f[i] += k * a[i] + b;
k = b = top = 0;
re = 1;
for (long long i = l; i <= r; i++) {
long long x = id[i];
while (top > 1 && slope(st[top - 1], st[top]) < slope(st[top], x)) top--;
st[++top] = x;
}
}
pair<long long, long long> query() {
while (re < top && data(st[re]) <= data(st[re + 1])) re++;
return pair<long long, long long>(data(st[re]), st[re]);
}
} t[S];
signed main() {
n = read(), sqr = sqrt(n);
for (long long i = 1; i <= n; i++) a[i] = read(), f[i] = a[i];
for (long long i = 1; i <= n; i++)
be[i] = (i - 1) / sqr + 1, id[i] = i, l[be[i]] = l[be[i]] ? l[be[i]] : i,
r[be[i]] = i;
maxn = be[n];
for (long long i = 1; i <= maxn; i++) {
sort(id + l[i], id + r[i] + 1,
[](long long x, long long y) { return a[x] < a[y]; });
t[i].build(l[i], r[i]);
}
while (true) {
pair<long long, long long> re = pair<long long, long long>(0, 0);
for (long long i = 1; i <= maxn; i++) re = max(re, t[i].query());
if (!re.first) return cout << ans, signed();
ans += re.first, f[re.second] = -INF;
for (long long i = 1; i < be[re.second]; i++) t[i].b += a[re.second];
for (long long i = be[re.second] + 1; i <= maxn; i++) t[i].k++;
for (long long i = l[be[re.second]]; i < re.second; i++)
f[i] += a[re.second];
for (long long i = re.second + 1; i <= r[be[re.second]]; i++) f[i] += a[i];
t[be[re.second]].build(l[be[re.second]], r[be[re.second]]);
}
return signed();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
void setup() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
struct seg_tree {
struct node {
int val;
node(int _val = 0x7f7f7f7f) { val = _val; }
node operator+(const node &y) { return {min(val, y.val)}; }
};
int S;
vector<node> arr;
seg_tree(int _S) {
S = _S;
arr = vector<node>(2 * S);
}
void upd(int i, node v) {
i += S + 1;
arr[i] = v;
while (i > 1) {
i /= 2;
arr[i] = arr[2 * i] + arr[2 * i + 1];
}
}
node query(int i, int j) {
node res;
for (i += S + 1, j += S + 1; i <= j; i /= 2, j /= 2) {
if ((i & 1) == 1) res = res + arr[i++];
if ((j & 1) == 0) res = res + arr[j--];
}
return res;
}
};
int find(seg_tree &seg, int i, int k) {
int lo = 0, hi = i;
int ans = 0;
while (lo <= hi) {
int mi = (lo + hi) / 2;
int lv = seg.query(mi, i).val;
if (lv <= k) {
ans = mi;
lo = mi + 1;
} else
hi = mi - 1;
}
return ans;
}
int look(vector<int> &all, int v) {
return lower_bound(all.begin(), all.end(), v) - all.begin();
}
const int MAXQ = 200005;
int N, Q;
seg_tree rows(1 << 19), cols(1 << 19);
int L[MAXQ], LC[MAXQ];
int R[MAXQ], RC[MAXQ];
char T[MAXQ];
vector<bool> ater, atec;
int main() {
setup();
cin >> N >> Q;
rows.upd(0, 0);
cols.upd(0, 0);
vector<int> all;
all.push_back(0);
for (int i = 0; i < Q; i++) {
cin >> L[i] >> R[i] >> T[i];
all.push_back(L[i]);
all.push_back(R[i]);
}
sort(all.begin(), all.end());
all.resize(unique(all.begin(), all.end()) - all.begin());
ater.resize(all.size());
atec.resize(all.size());
for (int i = 0; i < Q; i++) {
int LC = look(all, L[i]);
int RC = look(all, R[i]);
if (T[i] == 'U') {
if (atec[LC] || ater[RC]) {
cout << 0 << "\n";
continue;
}
int b = find(rows, RC, LC);
cols.upd(LC, b);
cout << all[RC] - all[b] << "\n";
atec[LC] = true;
} else {
if (ater[RC] || atec[LC]) {
cout << 0 << "\n";
continue;
}
int b = find(cols, LC, RC);
rows.upd(RC, b);
cout << all[LC] - all[b] << "\n";
ater[RC] = true;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template<typename elemType>
inline void Read(elemType& T) {
elemType X = 0, w = 0; char ch = 0;
while (!isdigit(ch)) { w |= ch == '-'; ch = getchar(); }
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
T = (w ? -X : X);
}
int G[1005][1005];
vector<pair<int, int> > vec, temp;
int T, m, k;
bool cmp(pair<int, int>& A, pair<int, int>& B) {
if (A.first == B.first) return A.second < B.second;
return A.first > B.first;
}
void construct(int n) {
int p = 0;
for (int i = 2;i <= n;i += 2) {
for (int j = 1;j <= n;j += 2) {
if (p >= vec.size()) break;
if (!vec[p].first) ++p;
if (p >= vec.size()) break;
G[i][j] = vec[p].second; --vec[p].first;
}
}
for (int i = 1;i <= n;i += 2) {
for (int j = 1;j <= n;j += 2) {
if (p >= vec.size()) break;
if (!vec[p].first) ++p;
if (p >= vec.size()) break;
G[i][j] = vec[p].second;--vec[p].first;
}
}
for (int i = 1;i <= n;i += 2) {
for (int j = 2;j <= n;j += 2) {
if (p >= vec.size()) break;
if (!vec[p].first) ++p;
if (p >= vec.size()) break;
G[i][j] = vec[p].second;--vec[p].first;
}
}
for (int i = 1;i <= n;++i) {
for (int j = 1;j <= n;++j) {
printf("%d", G[i][j]);
if (j < n) printf(" ");
G[i][j] = 0;
}
printf("\n");
}
}
int main() {
Read(T);
while (T--) {
Read(m); Read(k);
vec.clear();
for (int i = 1; i <= k; ++i) {
int x; Read(x);
if (x) vec.push_back(make_pair(x, i));
}
sort(vec.begin(), vec.end(), cmp);
int n = 1;
for (n = 1;;++n)
if (n * n - (n / 2) * (n / 2) >= m && n * ((n + 1) / 2) >= vec[0].first) break;
printf("%d\n", n);
construct(n);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 47;
const long long LINF = (long long)INF * INF;
const int MAX = 2e5;
const int MOD = 998244353;
const double EPS = 1e-9;
const double PI = acos(-1.);
long long l, r;
int k;
pair<int, int> dpT[1 << 10][18][2][2];
int a[18];
long long power[18];
const int MAXA = 18;
pair<int, int> dp(int mask, int pos, int less, int was) {
if (__builtin_popcount(mask) > k) return make_pair(0, 0);
if (pos == MAXA) return make_pair(0, 1);
if (dpT[mask][pos][less][was] != make_pair(-1, -1))
return dpT[mask][pos][less][was];
pair<int, int> ret = make_pair(0, 0);
if (less) {
for (int i = (0); i < (10); ++i) {
int xx = 1;
int yy = 1 << i;
if (was == 0 && i == 0) {
xx = 0;
yy = 0;
}
ret.first += ((1LL * i * power[pos] % MOD) *
dp(mask | yy, pos + 1, less, xx).second) %
MOD;
ret.first %= MOD;
ret.first += dp(mask | yy, pos + 1, less, xx).first;
ret.first %= MOD;
ret.second += dp(mask | yy, pos + 1, less, xx).second;
ret.second %= MOD;
}
} else {
for (int i = (0); i < (a[pos]); ++i) {
int xx = 1;
int yy = 1 << i;
if (was == 0 && i == 0) {
xx = 0;
yy = 0;
}
ret.first += ((1LL * i * power[pos] % MOD) *
dp(mask | yy, pos + 1, 1, xx).second) %
MOD;
ret.first %= MOD;
ret.first += dp(mask | yy, pos + 1, 1, xx).first;
ret.first %= MOD;
ret.second += dp(mask | yy, pos + 1, 1, xx).second;
ret.second %= MOD;
}
int xx = 1;
int yy = 1 << a[pos];
if (was == 0 && a[pos] == 0) {
xx = 0;
yy = 0;
}
ret.first += ((1LL * a[pos] * power[pos] % MOD) *
dp(mask | yy, pos + 1, 0, xx).second) %
MOD;
ret.first %= MOD;
ret.first += dp(mask | yy, pos + 1, 0, xx).first;
ret.first %= MOD;
ret.second += dp(mask | yy, pos + 1, 0, xx).second;
ret.second %= MOD;
}
return dpT[mask][pos][less][was] = ret;
}
int main() {
ios_base::sync_with_stdio(0);
power[MAXA - 1] = 1;
for (int i = (MAXA - 1) - 1; i >= (0); --i) {
power[i] = power[i + 1] * 10;
power[i] %= MOD;
}
cin >> l >> r >> k;
long long ans = 0;
long long x;
memset(dpT, -1, sizeof(dpT));
memset(a, 0, sizeof(a));
x = r;
int pos = MAXA - 1;
while (x) {
a[pos] = x % 10;
x /= 10;
pos--;
}
ans += dp(0, 0, 0, 0).first;
memset(dpT, -1, sizeof(dpT));
memset(a, 0, sizeof(a));
x = l - 1;
pos = MAXA - 1;
while (x) {
a[pos] = x % 10;
x /= 10;
pos--;
}
ans -= dp(0, 0, 0, 0).first;
ans %= MOD;
if (ans < 0) {
ans += MOD;
}
ans %= MOD;
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 10000007;
inline int rd() {
int x = 0;
char c = getchar();
bool f = false;
while (!isdigit(c)) {
if (c == '-') f = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long sqr(long long x) { return x * x; }
double dp[19005][1002];
int k, q;
int main() {
scanf("%d", &k);
scanf("%d", &q);
dp[0][0] = 1.0;
for (int i = 1; i <= 10050; i++) {
for (int j = 1; j <= k; j++) {
dp[i][j] += 1.0 * dp[i - 1][j] * 1.0 * j / k;
dp[i][j] += 1.0 * dp[i - 1][j - 1] * 1.0 * (k - j + 1) / k;
}
}
while (q--) {
int x;
scanf("%d", &x);
for (int i = 1; i <= 10050; i++) {
if (dp[i][k] * 2000.0 > (x - 1e-7)) {
cout << i << endl;
break;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
const long long INF = -1ull / 4;
int n, q;
long long a, b;
long long v[MAX_N];
int c[MAX_N];
long long dp[MAX_N];
long long mx1, mx2;
int main() {
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%I64d", v + i);
}
for (int i = 0; i < n; i++) {
scanf("%d", c + i);
c[i]--;
}
while (q--) {
scanf("%I64d %I64d", &a, &b);
mx1 = mx2 = -INF;
fill_n(dp, n, -INF);
for (int i = 0; i < n; i++) {
long long odp = dp[c[i]];
dp[c[i]] = max(dp[c[i]], max((odp == mx1 ? mx2 : mx1), 0ll) + v[i] * b);
dp[c[i]] = max(dp[c[i]], odp + v[i] * a);
if (dp[c[i]] >= mx1) {
if (odp != mx1) {
mx2 = mx1;
}
mx1 = dp[c[i]];
} else if (dp[c[i]] > mx2) {
mx2 = dp[c[i]];
}
}
printf("%I64d\n", max(0ll, mx1));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int a, b;
cin >> a >> b;
if (b < a) {
cout << b * (b + 1) / 2 << "\n";
} else {
cout << (a - 1) * a / 2 + 1 << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-14;
const long long maxn = 10050;
const long long mod = 1e9 + 7;
bool in[maxn];
struct BIT {
private:
long long tree[maxn + 10];
public:
void add(long long x, long long v = 1) {
for (x++; x < maxn; x += x & -x) tree[x] += v;
}
long long get(long long x) {
long long ret = 0;
for (x++; x; x -= x & -x) ret += tree[x];
return ret;
}
long long range(long long l, long long r) {
if (l > r) return 0;
return get(r) - (l > 0 ? get(l - 1) : 0);
}
} bit;
struct Segment {
long long x1, y1, x2, y2;
} seg[maxn];
vector<long long> max_y[maxn], min_y[maxn];
inline bool cmp(const long long &a, const long long &b) {
return seg[a].y2 > seg[b].y2;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> hor;
for (long long i = 0; i < n; ++i) {
cin >> seg[i].x1 >> seg[i].y1 >> seg[i].x2 >> seg[i].y2;
seg[i].x1 += 5000;
seg[i].x2 += 5000;
seg[i].y1 += 5000;
seg[i].y2 += 5000;
if (seg[i].y1 > seg[i].y2) {
swap(seg[i].y1, seg[i].y2);
swap(seg[i].x1, seg[i].x2);
}
if (seg[i].x1 == seg[i].x2) {
max_y[seg[i].y2].push_back(i);
min_y[seg[i].y1].push_back(i);
} else {
hor.push_back(i);
}
}
long long ans = 0;
sort((hor).begin(), (hor).end(), cmp);
for (long long i = 0; i < (long long)(hor).size(); ++i) {
for (long long j = 0; j < n; ++j)
if (in[j]) {
in[j] = false;
bit.add(seg[j].x1, -1);
}
long long maxi = maxn - 1;
while (maxi >= seg[hor[i]].y2) {
for (auto x : max_y[maxi]) {
assert(!in[x]);
bit.add(seg[x].x1, 1);
in[x] = true;
}
maxi--;
}
long long mini = maxn - 1;
while (mini > seg[hor[i]].y2) {
for (auto x : min_y[mini]) {
assert(in[x]);
bit.add(seg[x].x1, -1);
in[x] = false;
}
mini--;
}
long long a = seg[hor[i]].x1, b = seg[hor[i]].x2;
for (long long j = i + 1; j < (long long)(hor).size(); ++j) {
if (seg[hor[j]].y2 == seg[hor[i]].y2) continue;
while (mini > seg[hor[j]].y2) {
for (auto x : min_y[mini])
if (in[x]) {
in[x] = false;
bit.add(seg[x].x1, -1);
}
mini--;
}
long long c = seg[hor[j]].x1, d = seg[hor[j]].x2;
if (a > b) swap(a, b);
if (c > d) swap(c, d);
long long x = bit.range(max(a, c), min(b, d));
ans += x * (x - 1) / 2;
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define me memset
#define rep(a,b,c) for(int a=b;a<=c;++a)
#define per(a,b,c) for(int a=b;a>=c;--a)
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
using namespace std;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
ll gcd(ll a,ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b) {return a/gcd(a,b)*b;}
int main(){
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int _;
cin>>_;
while(_--){
int n,l,r,s;
cin>>n>>l>>r>>s;
vector<int> a(n+1);
vector<bool> st(n+1,false);
int k=r-l+1;
int low=k*(k+1)/2;
int high=k*(n-k+1+n)/2;
if(s<low || s>high) {cout<<-1<<'\n';continue;}
int diff=s-low;
int block=diff/k;
int rest=diff%k;
rep(i,1,k){
a[i]=i+block;
}
per(i,k,1){
if(rest==0) break;
a[i]++;
rest--;
}
rep(i,1,k) st[a[i]]=true;
rep(i,1,l-1){
rep(j,1,n){
if(!st[j]){
st[j]=true;
cout<<j<<' ';
break;
}
}
}
rep(i,1,k){
cout<<a[i]<<' ';
}
rep(i,r+1,n){
rep(j,1,n){
if(!st[j]){
st[j]=true;
cout<<j<<' ';
break;
}
}
}
cout<<'\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long pri[200005], ni[200005], dp[2005];
void extgcd(long long a, long long b, long long& d, long long& x,
long long& y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
extgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long inverse(long long a, long long n) {
long long d, x, y;
extgcd(a, n, d, x, y);
return d == 1 ? (x + n) % n : -1;
}
void init() {
pri[0] = 1;
for (int i = 1; i <= 200000; i++) {
pri[i] = pri[i - 1] * i % mod;
}
ni[200000] = inverse(pri[200000], mod);
for (int i = 200000 - 1; i >= 1; i--) {
ni[i] = (ni[i + 1] * (i + 1)) % mod;
}
ni[0] = 1;
}
long long c(int i, int j) { return ((pri[i] * ni[j]) % mod * ni[i - j]) % mod; }
struct node {
int x;
int y;
} a[2005];
bool cmp(node l, node r) {
if (l.x == r.x) return l.y < r.y;
return l.x < r.x;
}
int main() {
int h, w, n;
scanf("%d%d%d", &h, &w, &n);
init();
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].x, &a[i].y);
a[n].x = h;
a[n].y = w;
sort(a, a + n + 1, cmp);
for (int i = 0; i <= n; i++) {
int l = a[i].x - 1;
int r = a[i].y - 1;
dp[i] = c(l + r, l);
for (int j = 0; j < i; j++) {
if (a[i].x >= a[j].x && a[i].y >= a[j].y) {
l = a[i].x - a[j].x;
r = a[i].y - a[j].y;
dp[i] = (dp[i] - (dp[j] * c(l + r, l)) % mod + mod) % mod;
}
}
}
printf("%lld\n", dp[n]);
return 0;
}
| 3 |
/*
读错题做了假题呜呜呜
*/
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define For(i,x,y) for(ll i = (ll)(x);i <= (ll)(y);++i)
#define FOr(i,x,y) for(ll i = (ll)(x);i >= (ll)(y);--i)
#define rep(i,x,y) for(ll i = (ll)(x);i < (ll)(y);++i)
#define fi first
#define se second
#define pa pair<ll,ll>
#define pb push_back
#define y1 y11111111111111
#define debug puts("@@@@@@@@@@@@@@@@@@@")
#define cpy(a,b) memcpy(a,b,sizeof(b))
inline ll read()
{
ll x = 0,f = 1;char ch = getchar();
while(ch < '0' || ch > '9'){if(ch == '-')f = -1;ch = getchar();}
while(ch >= '0' && ch <= '9'){x = x*10+ch-'0';ch = getchar();}
return x*f;
}
void write(ll x)
{
if(x < 0) putchar('-'), x= -x;
if(x > 9)write(x/10);
putchar(x%10+'0');
}
const ll N=200010,mod=1e9+7;
ll fac[N],inv[N],n,k;
ll ppow(ll x,ll k){
ll ans=1;
for(;k;k>>=1,x=x*x%mod)if(k&1)ans=ans*x%mod;
return ans;
}
void init(ll n){
fac[0]=1;For(i,1,n)fac[i]=fac[i-1]*i%mod;
inv[0]=1;For(i,1,n)inv[i]=ppow(fac[i],mod-2);
}
ll C(ll n,ll m){
if (n<m)return 0;
return fac[n]*inv[m]%mod*inv[n-m]%mod;
}
ll fangan(ll n,ll k,ll i){
n-=(i-1)*(k-1);
return C(n,i);
}
int main(){
init(200010);
ll T=read();
for(;T--;){
n=read(); k=read(); ll ans=0;
For(i,1,n){
ans=(ans+fangan(n,k,i)*ppow(C(n,i),mod-2))%mod;
}
++ans; ans%=mod;
cout<<ans<<endl;
}
}
/*
*/
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m, x, y;
cin >> n >> m;
int _min = 200000;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &x, &y);
_min = min(_min, y - x + 1);
}
cout << _min << endl;
int k = 0;
for (int i = 1; i <= n; ++i) {
if (i == n)
printf("%d\n", k);
else
printf("%d ", k);
++k;
if (k == _min) k = 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
const long long maxx = (long long)1e12;
const int maxn = (int)1e6 + 5;
int n;
long long b;
long long a[maxn];
int e[maxn];
bool read() {
if (scanf("%d%lld", &n, &b) < 2) {
return false;
}
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &e[i]);
}
return true;
}
pair<long long, int> tosort[maxn];
int isGood[maxn];
int k;
vector<long long> ps;
vector<vector<int>> good;
bool add(int msk, int id) {
if (((int)(good[msk]).size()) >= k && e[good[msk].back()] <= e[id]) {
return false;
}
if (((int)(good[msk]).size()) >= k) {
good[msk].pop_back();
}
int pos = ((int)(good[msk]).size());
good[msk].push_back(id);
while (pos && e[good[msk][pos]] < e[good[msk][pos - 1]]) {
swap(good[msk][pos], good[msk][pos - 1]);
pos--;
}
return true;
}
vector<vector<long long>> dp, ndp;
void solve() {
long long g = a[0];
for (int i = 1; i < n; i++) {
g = gcd(g, a[i]);
}
if (g == 1) {
printf("0\n");
return;
}
{
ps.clear();
long long x = g;
for (long long d = 2; d * d <= x; d++) {
if (!(x % d)) {
ps.push_back(d);
while (!(x % d)) {
x /= d;
}
}
}
if (x > 1) {
ps.push_back(x);
}
}
k = ((int)(ps).size());
for (int i = 0; i < n; i++) {
long long x = 1;
auto &cur = a[i];
for (int j = 0; j < k; j++) {
while (!(cur % ps[j])) {
cur /= ps[j];
x *= ps[j];
}
}
cur = x;
}
for (int i = 0; i < n; i++) {
tosort[i] = make_pair(a[i], e[i]);
}
sort(tosort, tosort + n);
for (int i = 0; i < n; i++) {
a[i] = tosort[i].first;
e[i] = tosort[i].second;
}
good.clear();
good.resize((1 << k));
for (int i = 0; i < n; i++) {
isGood[i] = false;
}
for (int j = 0; j < n;) {
int i = j;
while (j < n && a[j] == a[i]) {
j++;
}
vector<int> qs(k, 0);
{
long long x = a[i];
for (int it = 0; it < k; it++) {
while (!(x % ps[it])) {
x /= ps[it];
qs[it]++;
}
}
}
for (int msk = 0; msk < (1 << k); msk++) {
long long y = 1;
for (int it = 0; it < k; it++) {
if (!(msk & (1 << it))) {
continue;
}
for (int it0 = 0; it0 < qs[it]; it0++) {
y *= ps[it];
}
}
if (y > b) {
continue;
}
int pos = i;
while (pos < j) {
if (!add(msk, pos)) {
break;
}
pos++;
}
}
}
for (auto i : good) {
for (auto j : i) isGood[j] = true;
}
dp = vector<vector<long long>>((1 << k), vector<long long>(k + 1, infll));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
if (!isGood[i]) {
continue;
}
ndp = vector<vector<long long>>((1 << k), vector<long long>(k + 1, infll));
vector<int> qs(k, 0);
{
long long x = a[i];
for (int it = 0; it < k; it++) {
while (!(x % ps[it])) {
x /= ps[it];
qs[it]++;
}
}
}
vector<int> ok(1 << k);
for (int msk = 0; msk < (1 << k); msk++) {
long long y = 1;
for (int it = 0; it < k; it++) {
if (!(msk & (1 << it))) {
continue;
}
for (int it0 = 0; it0 < qs[it]; it0++) {
y *= ps[it];
}
}
ok[msk] = (y <= b);
}
for (int msk = 0; msk < (1 << k); msk++) {
for (int cnt = 0; cnt <= k; cnt++) {
auto cur = dp[msk][cnt];
if (cur >= infll) {
continue;
}
{
auto &nxt = ndp[msk][cnt];
nxt = min(nxt, cur);
}
if (cnt >= k) {
continue;
}
int msk1 = (((1 << k) - 1) ^ msk);
for (int nmsk = msk1; nmsk > 0; nmsk = ((nmsk - 1) & msk1)) {
if (!ok[nmsk]) {
continue;
}
auto &nxt = ndp[msk | nmsk][cnt + 1];
nxt = min(nxt, cur + e[i]);
}
}
}
swap(dp, ndp);
}
long long res = infll;
for (int cnt = 1; cnt <= k; cnt++) {
if (dp[(1 << k) - 1][cnt] < infll) {
res = min(res, cnt * dp[(1 << k) - 1][cnt]);
}
}
if (res >= infll) {
res = -1;
}
printf("%lld\n", res);
}
int main() {
precalc();
while (read()) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = ~0ull >> 2;
int _;
int main() {
for (scanf("%d", &_); _; _--) {
long long n;
scanf("%lld", &n);
int ccount[105] = {0};
int now = 0, p = -1;
while (n) {
ccount[now++] = n % 3;
n /= 3;
if (ccount[now - 1] == 2) p = now - 1;
}
now--;
if (p == -1) {
long long ans = 0;
for (int i = now; i >= 0; i--) ans = ans * 3 + ccount[i];
cout << ans << endl;
} else {
while (ccount[p] >= 2) {
ccount[p++] = 0;
ccount[p] += 1;
}
now = max(now, p);
for (int i = 0; i < p; i++) ccount[i] = 0;
long long ans = 0;
for (int i = now; i >= 0; i--) ans = ans * 3 + ccount[i];
cout << ans << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[(int)2e5], n, x = 0;
int main() {
cin >> n;
for (int i = 0; i++ < n;) {
cin >> a[i];
x += !a[i];
}
if (!a[n] && (a[n - 1] || x != 2)) {
cout << "YES\n";
for (int i = 0; i++ < n - 2;) cout << "(" << a[i] << "->";
cout << a[n - 1];
for (int i = 0; i++ < n - 2;) cout << ")";
if (n - 1) cout << "->0";
} else
cout << "NO";
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.