solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000000;
const int M1 = 1000000007;
const int M2 = 998244353;
const int N = 100005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m, k, a, b, temp, x, y;
cin >> n >> m;
vector<int> vertical;
for (int i = 0; i < n; i++) {
cin >> temp;
vertical.push_back(temp);
}
sort(vertical.begin(), vertical.end());
vector<int> start;
vector<int> endd;
start.push_back(1);
for (int i = 0; i < n; i++) {
start.push_back(vertical[i]);
endd.push_back(vertical[i]);
}
endd.push_back(MAX);
int pre[n + 2];
for (int i = 0; i < n + 2; i++) {
pre[i] = 0;
}
for (int i = 0; i < m; i++) {
cin >> x >> y >> temp;
if (x == 1) {
int first = lower_bound(start.begin(), start.end(), x) - start.begin();
int second = lower_bound(endd.begin(), endd.end(), y) - endd.begin();
if (endd[second] == y) {
second += 2;
first++;
} else {
second++;
first++;
}
if (first <= second) {
pre[first]++;
pre[second]--;
}
}
}
cout << "\n";
int sm = pre[0];
int ans = MAX;
for (int i = 0; i < n + 1; i++) {
sm += pre[i + 1];
ans = min(ans, i + sm);
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class graph {
int v, e;
list<pair<int, int> > *adj;
list<pair<int, int> > *clrs;
public:
graph(int v_, int e_) : v(v_), e(e_) {
adj = new list<pair<int, int> >[v];
clrs = new list<pair<int, int> >[e];
}
void add_edge(int x, int y, int w) {
adj[x].push_back(make_pair(y, w));
adj[y].push_back(make_pair(x, w));
}
void dfs() {
int k = 0;
int *visited = new int[v];
for (int c = 0; c < e; c++) {
for (int i = 0; i < v; i++) visited[i] = 0;
for (int i = 0; i < v; i++) {
if (visited[i] == 0) {
dfs_visit(i, visited, k, c);
k++;
}
}
}
}
void dfs_visit(int s, int *visited, int k, int c) {
visited[s] = 1;
list<pair<int, int> >::iterator it;
for (it = adj[s].begin(); it != adj[s].end(); it++) {
if (visited[(*it).first] == 0 and (*it).second == c) {
clrs[(*it).second].push_back(make_pair(s, k));
clrs[(*it).second].push_back(make_pair((*it).first, k));
dfs_visit((*it).first, visited, k, c);
}
}
}
int findnum(int x, int y) {
int cnt, fx, fy, kx, ky;
cnt = 0;
list<pair<int, int> >::iterator it;
for (int i = 0; i < e; i++) {
fx = fy = 0;
for (it = clrs[i].begin(); it != clrs[i].end(); it++) {
if ((*it).first == x) {
fx = 1;
kx = (*it).second;
} else if ((*it).first == y) {
fy = 1;
ky = (*it).second;
}
if (fx and fy) break;
}
if ((fx and fy) and kx == ky) cnt++;
}
return cnt;
}
void print() {
list<pair<int, int> >::iterator it;
for (int i = 0; i < v; i++) {
printf("%d : ", i);
for (it = clrs[i].begin(); it != clrs[i].end(); it++) {
printf("[%d %d] ", (*it).first, (*it).second);
}
printf("\n");
}
}
};
int main() {
int n, e, x, y, w, q, *arrx, *arry;
scanf("%d%d", &n, &e);
graph g(n, e);
for (int i = 0; i < e; i++) {
scanf("%d%d%d", &x, &y, &w);
x--;
y--;
w--;
g.add_edge(x, y, w);
}
g.dfs();
scanf("%d", &q);
arrx = new int[q];
arry = new int[q];
for (int i = 0; i < q; i++) {
scanf("%d%d", &arrx[i], &arry[i]);
arrx[i]--;
arry[i]--;
}
for (int i = 0; i < q; i++) {
printf("%d\n", g.findnum(arrx[i], arry[i]));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2 = "";
cin >> s1;
for (int i = 0; i < s1.size(); i++) {
if (s2.back() != s1[i]) {
s2 += s1[i];
} else {
s2.pop_back();
}
}
cout << s2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, w[200005], root, tmp;
vector<int> ch[200005];
void dfsw(int u) {
w[u] = 1;
for (int v : ch[u]) dfsw(v), w[u] += w[v];
}
void dfsd(int u) {
for (int v : ch[u])
if (!(w[v] & 1)) dfsd(v);
cout << u << '\n';
for (int v : ch[u])
if ((w[v] & 1)) dfsd(v);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
if (!(n & 1)) {
cout << "NO" << '\n';
return 0;
}
for (int i = 1; i <= n; i++) {
cin >> tmp;
if (tmp != 0)
ch[tmp].push_back(i);
else
root = i;
}
cout << "YES" << '\n';
dfsw(root);
dfsd(root);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
double t,x; cin >>t>>x;
cout << (t/x) << endl;
} | 0 |
#include <bits/stdc++.h>
const long long P = 1e9 + 7;
const long long N = 1e5 + 9;
long long n, m, k, x;
std::vector<long long> G[N];
long long dp[N][11][3], tmp[N][11][3], ntmp[N][11][3];
void dfs(long long u, long long fa) {
ntmp[u][0][0] = k - 1;
ntmp[u][1][1] = 1;
ntmp[u][0][2] = m - k;
for (auto v : G[u]) {
if (v == fa) continue;
dfs(v, u);
memset(tmp[u], 0, sizeof tmp[u]);
for (long long i = 0; i <= x; i++) {
for (long long h = 0; h <= i; h++) {
tmp[u][i][0] =
(tmp[u][i][0] +
ntmp[u][i - h][0] * (dp[v][h][0] + dp[v][h][1] + dp[v][h][2])) %
P;
tmp[u][i][1] = (tmp[u][i][1] + ntmp[u][i - h][1] * dp[v][h][0]) % P;
tmp[u][i][2] =
(tmp[u][i][2] + ntmp[u][i - h][2] * (dp[v][h][0] + dp[v][h][2])) %
P;
}
}
for (long long i = 0; i <= x; i++) {
for (long long j = 0; j < 3; j++) {
ntmp[u][i][j] = tmp[u][i][j];
}
}
}
for (long long i = 0; i <= x; i++) {
for (long long j = 0; j < 3; j++) {
dp[u][i][j] = ntmp[u][i][j];
}
}
return;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cin >> n >> m;
for (long long i = 1; i <= n - 1; i++) {
long long u, v;
std::cin >> u >> v;
G[u].emplace_back(v);
G[v].emplace_back(u);
}
std::cin >> k >> x;
dfs(1, 0);
long long ans = 0;
for (long long i = 0; i <= x; i++) {
for (long long j = 0; j < 3; j++) {
ans = (ans + dp[1][i][j]) % P;
}
}
std::cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n, m;
cin >> n >> m;
if(2*n < m){
cout << n + (m - 2*n)/4;
}else{
cout << m/2;
}
return 0;
} | 0 |
#include <iostream>
long long euler_phi (long long n) {
long long ret = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret -= (ret / i);
while (n % i == 0) {
n /= i;
}
}
}
if (n > 1) ret -= (ret / n);
return ret;
}
int main() {
long long n;
std::cin >> n;
std::cout << euler_phi(n) << '\n';
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define foru(i, l, r) for(int i = l; i <= r; i++)
#define ford(i, r, l) for(int i = r; i >= l; i--)
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
typedef pair<ii, ii> iiii;
const int N = 1e5 + 5;
const int oo = 1e18 + 7, mod = 1e9 + 7;
int n, m, nxt[N];
ii mn_time[N];
void process(){
cin >> n >> m;
for(int i = 0; i <= m; i++) mn_time[i] = {oo, oo};
mn_time[0] = {0, 0};
for(int i = 1; i <= n; i++){
int t, x, y;
cin >> t >> x >> y;
for(int j = 0; j <= m; j++){
if(t == 1) nxt[j] = (j + ((x + 99999) / 100000));
else nxt[j] = ((j * x + 99999) / 100000);
//cout << j << " " << nxt[j] << "\n";
}
for(int j = 0; j <= m; j++){
if(nxt[j] > m) continue;
if(mn_time[j].fi == oo) continue;
//cout << j << " " << mn_time[j].fi << " " << mn_time[j].se << "\n";
if(mn_time[j] != make_pair(i, y)){
//cout << j << "\n";
if(mn_time[j].fi < i){
if(mn_time[nxt[j]].fi >= i) mn_time[nxt[j]] = {i, 1};
}
else{
if(mn_time[nxt[j]].fi > i) mn_time[nxt[j]] = {i, mn_time[j].se + 1};
else if(mn_time[nxt[j]].fi == i) mn_time[nxt[j]].se = min(mn_time[nxt[j]].se, mn_time[j].se + 1);
}
}
}
}
for(int i = 1; i <= m; i++){
if(mn_time[i].fi == oo) cout << -1 << " ";
else cout << mn_time[i].fi << " ";
//cout << " " << mn_time[i].se << "\n";
}
}
signed main(){
ios_base::sync_with_stdio(0);
process();
} | 4 |
#include <bits/stdc++.h>
using namespace std;
bool best[101];
int main() {
int n, m, kol = 0;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int j = m - 1; j >= 0; j--) {
int k_max = 0, max = -1;
vector<int> v;
for (int i = 0; i < n; i++) {
if (a[i][j] - '0' > max) {
max = a[i][j] - '0';
k_max = 0;
v.clear();
}
if (a[i][j] - '0' == max) {
k_max++;
v.push_back(i);
}
}
for (int i = 0; i < v.size(); i++) {
if (!best[v[i]]) {
kol++;
best[v[i]] = true;
}
}
}
cout << kol << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
int n, i, x, y, mini = 0, maxi = 0;
cin >> n;
for (i = 0; i < 3; i++) {
cin >> x >> y;
mini += x;
maxi += y;
v.push_back(make_pair(x, y));
}
if (n == mini) {
for (i = 0; i < 3; i++) cout << v[i].first << " ";
} else if (n == maxi) {
for (i = 0; i < 3; i++) cout << v[i].second << " ";
} else {
int diff = n - mini;
for (i = 0; i < 3; i++) {
if (v[i].second - v[i].first <= diff) {
cout << v[i].second << " ";
diff -= v[i].second - v[i].first;
} else {
cout << v[i].first + diff << " ";
diff = 0;
}
}
}
return 0;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
void solve()
{
string str;
char c;
while(cin >> str)
{
cin >> c;
string Answer;
int size = str.size();
if(c == 'X')
{
break;
}
else if(c == 'L')
{
if('A' <= str[0] && str[0] <= 'Z')
{
Answer += str[0] - 'A' + 'a';
}
else if('a' <= str[0] && str[0] <= 'z')
{
Answer += str[0];
}
bool flag = false;
for(int i = 1; i < size; ++i)
{
if(str[i] == '_')
{
flag = true;
continue;
}
if(flag && 'a' <= str[i] && str[i] <= 'z')
{
Answer += str[i] - 'a' + 'A';
flag = false;
continue;
}
Answer += str[i];
flag = false;
}
}
else if(c == 'U')
{
if('A' <= str[0] && str[0] <= 'Z')
{
Answer += str[0];
}
else if('a' <= str[0] && str[0] <= 'z')
{
Answer += str[0] - 'a' + 'A';
}
bool flag = false;
for(int i = 1; i < size; ++i)
{
if(str[i] == '_')
{
flag = true;
continue;
}
if(flag && 'a' <= str[i] && str[i] <= 'z')
{
Answer += str[i] - 'a' + 'A';
flag = false;
continue;
}
Answer += str[i];
flag = false;
}
}
else if(c == 'D')
{
if('A' <= str[0] && str[0] <= 'Z')
{
Answer += str[0] - 'A' + 'a';
}
else if('a' <= str[0] && str[0] <= 'z')
{
Answer += str[0];
}
for(int i = 1; i < size; ++i)
{
if(str[i] == '_')
{
Answer += '_';
continue;
}
if('A' <= str[i] && str[i] <= 'Z')
{
Answer += '_';
Answer += str[i] - 'A' + 'a';
continue;
}
Answer += str[i];
}
}
cout << Answer << endl;
}
}
int main()
{
solve();
return(0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline string get() {
char ch[2000010];
scanf("%s", ch);
return ch;
}
const int MAX_LG = 21;
const int maxn = 2e6 + 10;
const int maxm = 1e5 + 10;
const int base = 29;
const int mod = 1e9 + 7;
const int base2 = 31;
const int mod2 = 1e9 + 9;
const int INF = 2e18 + 100;
const int SQ = 317;
int last;
int sz = 1;
int len[maxn];
int link[maxn];
int nxt[maxn][26];
inline void addLetter(int c) {
int p = last;
last = sz++;
len[last] = len[p] + 1;
for (; p != -1 && nxt[p][c] == 0; p = link[p]) {
nxt[p][c] = last;
}
if (p == -1) {
link[last] = 0;
return;
}
int q = nxt[p][c];
if (len[q] == len[p] + 1) {
link[last] = q;
return;
}
int cl = sz++;
for (int j = 0; j < 26; j++) nxt[cl][j] = nxt[q][j];
link[cl] = link[q];
len[cl] = len[p] + 1;
link[q] = link[last] = cl;
for (; nxt[p][c] == q; p = link[p]) nxt[p][c] = cl;
}
int cnt[maxn];
bool mark[maxn];
inline void calc(int state) {
if (mark[state]) return;
mark[state] = true;
for (int i = 0; i < 26; i++) {
if (nxt[state][i]) {
calc(nxt[state][i]);
cnt[state] += cnt[nxt[state][i]];
}
}
}
int kmp[maxn];
inline int repeat(string &t) {
int tmp = 0;
for (int i = 1; i < t.size(); i++) {
while (tmp && t[tmp] != t[i]) tmp = kmp[tmp - 1];
if (t[tmp] == t[i]) tmp++;
kmp[i] = tmp;
}
int v = (int)t.size() - kmp[(int)t.size() - 1];
if ((int)t.size() % v == 0) return v;
return (int)t.size();
}
inline int Count(string &t) {
int ret = 0;
int state = 0, ln = 0;
int lim = repeat(t);
for (int i = 0; i < (int)t.size() + lim - 1; i++) {
int cur = i % ((int)t.size());
while (state != -1 && nxt[state][t[cur] - 'a'] == 0) {
state = link[state];
if (state != -1) ln = len[state];
}
if (state == -1)
state = ln = 0;
else
state = nxt[state][t[cur] - 'a'], ln++;
if (ln == t.size()) {
ret += cnt[state];
ln--;
assert(len[link[state]] <= ln);
if (len[link[state]] == ln) state = link[state];
}
}
return ret;
}
int32_t main() {
link[0] = -1;
string s = get();
for (int i = 0; i < s.size(); i++) addLetter(s[i] - 'a');
for (int p = last; p != -1; p = link[p]) cnt[p]++;
calc(0);
int n = in();
for (int i = 0; i < n; i++) {
string t = get();
printf("%d\n", Count(t));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[500005];
int b[500005];
vector<int> v;
int vis[102][102];
char gr[102][102];
int main() {
int n, i, j, k, kk, p, q, res;
int t;
cin >> n >> kk;
getchar();
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> gr[i][j];
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
int co = 0;
for (k = j; k < j + kk; k++) {
if (k >= n) break;
if (gr[i][k] == '.') co++;
}
if (co == kk) {
for (k = j; k < j + kk; k++) {
vis[i][k] = vis[i][k] + 1;
}
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
int co = 0;
for (k = j; k < j + kk; k++) {
if (k >= n) break;
if (gr[k][i] == '.') co++;
}
if (co == kk) {
for (k = j; k < j + kk; k++) {
vis[k][i] = vis[k][i] + 1;
}
}
}
}
p = -1;
q = -1;
int mxx = -1;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (vis[i][j] > mxx) {
p = i + 1;
q = j + 1;
mxx = vis[i][j];
}
}
}
cout << p << " " << q << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
while (true) {
bool stop = true;
int m = n;
while (m > 0) {
if (m % 3 == 2) stop = false;
m /= 3;
}
if (stop) break;
n++;
}
cout << n << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
long long k, b, n, ans0, ans, x, sum[1000001], cnt[1000001];
int main() {
cin >> k >> b >> n;
if (!b) {
for (long long i = 1; i <= n; i++) {
cin >> x;
cnt[0] = (!x) ? (cnt[0] + 1) : 0;
ans += cnt[0];
}
cout << ans << endl;
} else {
--k, --b;
for (long long i = 1; i <= n; i++) {
cin >> x;
cnt[i] = (!x) ? (cnt[i - 1] + 1) : 0;
sum[i] = (sum[i - 1] + x) % k;
}
m[0] = 1;
for (long long i = 1; i <= n; i++) {
long long tmp = (sum[i] - b - 1 + k) % k;
ans += m[tmp];
m[sum[i]]++;
if (tmp == sum[i]) ans -= cnt[i];
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int ans;
if (n <= 2) {
cout << '1' << endl;
continue;
}
if ((n - 2) % x != 0) {
ans = (n - 2) / x + 2;
} else {
ans = (n - 2) / x + 1;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int n;
int long long val;
int long long ans;
cin >> t;
while (t--) {
cin >> n;
vector<int long long> v;
for (int i = 0; i < n; i++) {
cin >> val;
v.push_back(val);
}
int long long neg = 0;
int long long ans = 0;
for (int i = 0; i < n; i++) {
if (v[i] < 0) {
neg += v[i];
} else {
if (neg < 0) {
ans += neg;
neg = 0;
}
neg += v[i];
}
}
if (neg < 0) {
ans += neg;
}
cout << -1 * ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double st[2002][2002];
int main() {
ios_base::sync_with_stdio(true);
int n, t;
double p;
scanf("%d %lf %d", &n, &p, &t);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= t; j++)
st[i][j] = ((p) * (1 + st[i - 1][j - 1]) + (1 - p) * (st[i][j - 1]));
}
printf("%.6lf\n", st[n][t]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans[100], tot = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
ans[i] = n / m;
tot += ans[i];
}
if (tot == n)
for (int i = 0; i < m; i++) {
cout << ans[i];
if (i != m - 1) cout << " ";
}
else {
for (int i = 0; i < n - tot; i++) ans[i]++;
for (int i = 0; i < m; i++) {
cout << ans[i];
if (i != m - 1) cout << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
int f[N], a[N], r[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
int ans = 1;
for (int i = 0; i < n; i++) {
if (i == 0 || i == n - 1) {
f[i] = 1;
continue;
}
f[i] = min(f[i - 1] + 1, min(a[i - 1] + 1, min(a[i], a[i + 1] + 1)));
}
for (int i = n - 2; i >= 0; i--) {
f[i] = min(f[i], f[i + 1] + 1);
ans = max(ans, f[i]);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, a[N], b[N];
pair<int, int> s[N];
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) {
int si;
scanf("%d", &si);
s[i] = make_pair(si, i);
}
sort(s, s + n);
int B = (n - 1) / 3 + 1;
for (int i = (B << 1); i < (n); ++i) {
b[s[i].second] = n - i - 1;
a[s[i].second] = s[i].first - b[s[i].second];
}
for (int i = (B); i < (B << 1); ++i) {
b[s[i].second] = i;
a[s[i].second] = s[i].first - i;
}
for (int i = (0); i < (B); ++i) {
a[s[i].second] = i;
b[s[i].second] = s[i].first - i;
}
puts("YES");
for (int i = (0); i < (n); ++i) printf("%d%c", a[i], " \n"[i == n - 1]);
for (int i = (0); i < (n); ++i) printf("%d%c", b[i], " \n"[i == n - 1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long int INF = 1e18;
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
bool checkp2(long long int n) { return n && !(n & (n - 1)); }
long long int numsetbit(long long int n) {
long long int count = 0;
for (; n; count++) {
n = n & (n - 1);
}
return count;
}
long long int powe(long long int x, long long int n, const long long int mod) {
x = x % mod;
long long int po = 1;
while (n) {
if (n & 1) {
po = (po * x) % mod;
}
n = n >> 1;
x = ((x % mod) * (x % mod)) % mod;
}
return po;
}
long long int powm(long long int x, long long int n) {
long long int po = 1;
while (n) {
if (n & 1) {
po = (po * x);
}
n = n >> 1;
x = (x * x);
}
return po;
}
bool isPrime(long long int x) {
if (x < 2) return 0;
for (long long int y = 2; y * y <= x; y++) {
if (x % y == 0) {
return 0;
}
}
return true;
}
const long long int mod = 1e9 + 7;
void solve() {
long long int n;
cin >> n;
if (n == 2) {
cout << "2" << endl;
cout << "1 2" << endl;
return;
}
cout << "2" << endl;
cout << n << " " << n - 2 << endl;
cout << n - 1 << " " << n - 1 << endl;
for (long long int i = 0; i < n - 3; i++) {
cout << n - i - 1 << " " << n - i - 3 << endl;
}
}
int main() {
init();
long long int t = 1;
cin >> t;
for (long long int i = 1; i <= t; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, a, b, c, d, l1, l2, r1, r2;
int main() {
cin >> t;
while (t--) {
cin >> n >> a >> b >> c >> d;
l1 = (a - b) * n;
r1 = (a + b) * n;
l2 = c - d;
r2 = c + d;
if (l1 > l2) {
swap(l1, l2);
swap(r1, r2);
}
if (l1 == l2)
cout << "Yes" << endl;
else if (r1 < l2)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct AhoCorasick {
static const int UNDEF = 0;
static const int MAXN = 128;
static const int CHARSET = 4;
int end;
int tag[MAXN];
int fail[MAXN];
int trie[MAXN][CHARSET];
void init() {
tag[0] = UNDEF;
fill(trie[0], trie[0] + CHARSET, -1);
end = 1;
}
void add(int m, const int* s, int t) {
int p = 0;
for (int i = 0; i < m; ++i) {
if (trie[p][*s] == -1) {
tag[end] = UNDEF;
fill(trie[end], trie[end] + CHARSET, -1);
trie[p][*s] = end++;
}
p = trie[p][*s];
++s;
}
tag[p] = t;
}
void build() {
queue<int> bfs;
fail[0] = 0;
for (int i = 0; i < CHARSET; ++i) {
if (trie[0][i] != -1) {
fail[trie[0][i]] = 0;
bfs.push(trie[0][i]);
} else {
trie[0][i] = 0;
}
}
while (!bfs.empty()) {
int p = bfs.front();
tag[p] = max(tag[p], tag[fail[p]]);
bfs.pop();
for (int i = 0; i < CHARSET; ++i) {
if (trie[p][i] != -1) {
fail[trie[p][i]] = trie[fail[p]][i];
bfs.push(trie[p][i]);
} else {
trie[p][i] = trie[fail[p]][i];
}
}
}
}
} ac;
const int TTL = 12;
const int MAXN = 1024;
const long long MOD = 1000000009LL;
long long dp[MAXN][AhoCorasick::MAXN][TTL];
int main() {
int n, m, l;
int a[80];
char buf[80];
long long ans;
const char pat[] = "ATCG";
scanf("%d%d", &n, &m);
ac.init();
for (int i = 0; i < m; ++i) {
scanf("%s", buf);
l = strlen(buf);
for (int i = 0; i < l; ++i) {
a[i] = strchr(pat, buf[i]) - pat;
}
ac.add(l, a, l);
}
ac.build();
dp[0][0][0] = 1LL;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < ac.end; ++j) {
for (int k = 0; k < TTL; ++k) {
if (dp[i][j][k] == 0) {
continue;
}
for (int t = 0; t < 4; ++t) {
int jj = ac.trie[j][t];
if (ac.tag[jj] > k) {
dp[i + 1][jj][0] += dp[i][j][k];
dp[i + 1][jj][0] %= MOD;
} else if (k + 1 < TTL) {
dp[i + 1][jj][k + 1] += dp[i][j][k];
dp[i + 1][jj][k + 1] %= MOD;
}
}
}
}
}
ans = 0;
for (int j = 0; j < ac.end; ++j) {
ans += dp[n][j][0];
}
printf("%d\n", (int)(ans % MOD));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
long long n, m, a, b, q, ans = 0;
signed main() {
q = read();
while (q--) {
n = read(), a = read(), b = read();
ans = 0;
if (a * 2 <= b)
cout << n * a << endl;
else {
ans += (n / 2) * b;
n -= 2 * (n / 2);
if (!n) {
cout << ans << endl;
continue;
} else
cout << ans + a << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool compose(int n) {
for (int i = 2; i <= (n / 2); i++) {
if (n % i == 0) {
return true;
}
}
return false;
}
int main() {
int n, a, b;
cin >> n;
for (int i = n / 2; i >= 2; i--) {
if ((compose(i)) && compose(n - i)) {
a = i;
b = n - i;
i = 0;
}
}
cout << a << " " << b << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long power(long long a, long long n);
int main() {
string s;
cin >> s;
long long n = s.length(), k, ans = 0, temp = 0, now;
cin >> k;
for (int i = 0; i < n; i++) {
if (s[i] == '0' || s[i] == '5') {
ans = (ans + power(2, i)) % mod;
}
}
temp = power(2, n);
now = power(temp, k) - 1;
if (now < 0) now += mod;
temp--;
if (temp < 0) temp += mod;
now = (now * power(temp, mod - 2)) % mod;
ans = (ans * now) % mod;
cout << ans << endl;
}
long long power(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
n >>= 1;
}
return ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Coor {
int x, y;
};
long long commonS(const pair<Coor, Coor>& rect1, const pair<Coor, Coor>& rect2);
int main() {
int t;
cin >> t;
while (t--) {
int m, n;
Coor a1, a2;
cin >> m >> n >> a1.x >> a1.y >> a2.x >> a2.y;
if (a1.x > a2.x) swap(a1.x, a2.x);
if (a1.y > a2.y) swap(a1.y, a2.y);
a2.x -= (a1.x - 1);
a1.x = 1;
a2.y -= (a1.y - 1);
a1.y = 1;
int gapX = m - a2.x;
int gapY = n - a2.y;
pair<Coor, Coor> rect1 = make_pair(Coor{1, 1}, Coor{1 + gapX, 1 + gapY});
pair<Coor, Coor> rect2 = make_pair(Coor{m - gapX, n - gapY}, Coor{m, n});
cout << (long long)m * n - commonS(rect1, rect2) << endl;
}
}
long long commonS(const pair<Coor, Coor>& rect1,
const pair<Coor, Coor>& rect2) {
long long subtract = 0;
long long gapX = rect1.second.x - rect2.first.x;
long long gapY = rect1.second.y - rect2.first.y;
if (gapX >= 0 && gapY >= 0) subtract = (gapX + 1) * (gapY + 1);
long long oneRect = (long long)(rect1.second.x - rect1.first.x + 1) *
(rect1.second.y - rect1.first.y + 1);
return (oneRect + oneRect - subtract);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long k, n, m, a[100], b[100];
struct matrix {
long long a[100][100];
matrix() {
for (int i = 0; i < 100; ++i)
for (int j = 0; j < 100; ++j) a[i][j] = (i == j) ? 0 : 2000000000000ll;
}
void inf() {
for (int i = 0; i < 100; ++i)
for (int j = 0; j < 100; ++j) a[i][j] = 2000000000000ll;
}
} ans, p;
matrix operator*(const matrix &a, const matrix &b) {
matrix c;
c.inf();
for (int i = 0; i < k; ++i)
for (int j = 0; j < k; ++j)
for (int t = 0; t < k; ++t)
c.a[i][j] = min(c.a[i][j], (a.a[i][t] + b.a[t][j]));
return c;
}
void read(void) {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int j = 0; j < n; ++j) cin >> b[j];
}
void make(void) {
matrix t;
k = 2 * n + 1;
for (int r = 0; r < n; ++r) {
t.inf();
for (int i = 0; i < k; ++i) t.a[i][i + 1] = a[r];
for (int i = 1; i < k; ++i) t.a[i][i - 1] = b[r];
p = p * t;
}
while (m) {
if (m & 1) ans = ans * p;
p = p * p;
m >>= 1;
}
cout << ans.a[0][0] << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
read();
make();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1ll;
while (b > 0) {
if (b % 2ll) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2ll;
}
return res;
}
long long GCD(long long a, long long b) {
if (b == 0) return a;
return GCD(b, a % b);
}
long long fact(long long n) {
long long res = 1;
for (long long i = 2; i <= n; i++) {
res = (res * i) % 1000000007;
}
return res % 1000000007;
}
bool comp(pair<string, long long> a, pair<string, long long> b) {
if (a.second != b.second) return a.second > b.second;
return a.first < b.first;
}
void solve() {
long long x, y;
cin >> x >> y;
for (long long i = 1; i <= x; i++) {
for (long long j = 1; j <= y; j++) {
if (i % 4 == 1 || i % 4 == 3) {
cout << '#';
} else if (i % 4 == 2) {
if (j == y) {
cout << '#';
} else {
cout << '.';
}
} else if (i % 4 == 0) {
if (j == 1) {
cout << '#';
} else {
cout << '.';
}
}
}
cout << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tc = 1;
while (tc--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long z, n, k;
cin >> n >> k;
z = k * ((n / k) + 1);
cout << z;
}
| 1 |
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
string S;
cin >> S;
reverse(S.begin(), S.end());
cout << S << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const long long MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long add(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a + b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long mul(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a * b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long pow_mod(long long a, long long b, long long m = MOD) {
long long res = 1LL;
a = a % m;
while (b) {
if (b & 1) res = mul(res, a, m);
b >>= 1;
a = mul(a, a, m);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 5000 + 5;
int n, q;
int a[N];
int l[N];
int r[N];
int preffix[3][N];
int query(int L, int R, int x) {
if (L > R) return 0;
return preffix[x][R] - preffix[x][L - 1];
}
int main() {
scanf("%d %d", &(n), &(q));
for (int i = 0; i < q; i++) {
scanf("%d %d", &(l[i]), &(r[i]));
a[l[i]] += 1;
a[r[i] + 1] -= 1;
}
int painted = 0;
for (int i = 1; i <= n; i++) {
a[i] += a[i - 1];
if (a[i] > 0) painted += 1;
}
for (int i = 1; i <= 2; i++) {
for (int j = 1; j <= n; j++) {
preffix[i][j] = preffix[i][j - 1];
if (a[j] == i) preffix[i][j] += 1;
}
}
int ans = 0;
for (int i = 0; i < q; i++) {
for (int j = i + 1; j < q; j++) {
int L1 = l[i];
int R1 = r[i];
int L2 = l[j];
int R2 = r[j];
if (L1 > L2) {
swap(L1, L2);
swap(R1, R2);
}
int Li = max(L1, L2);
int Ri = min(R1, R2);
int cand = painted;
if (Li > Ri) {
cand -= query(L1, R1, 1) + query(L2, R2, 1);
} else {
if (Ri < R2)
cand -=
query(L1, Li - 1, 1) + query(Li, Ri, 2) + query(Ri + 1, R2, 1);
else
cand -=
query(L1, Li - 1, 1) + query(Li, Ri, 2) + query(Ri + 1, R1, 1);
}
ans = max(ans, cand);
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b, c, ty;
} a[100010];
struct Tnode {
int x, f, tag, ls, rs;
} t[3000000];
int n, m, k, K, ans, rt, tot;
bool cmp(node x, node y) { return x.a < y.a; }
int getfull(int l, int r) {
int s = 0;
l--;
for (int j = 1; j <= k; j <<= 1)
s |= (((r / j - l / j) - (j * 2 <= k ? (r / j / 2 - l / j / 2) : 0)) & 1) *
j;
return s;
}
void update(int n) {
if (t[n].tag)
t[n].x = t[n].f;
else
t[n].x = t[t[n].ls].x ^ t[t[n].rs].x;
}
void modify(int &n, int l, int r, int L, int R, int k) {
if (!n) n = ++tot, t[n].f = getfull(l, r);
if ((L <= l) && (r <= R))
t[n].tag += k;
else {
int mid = (l + r) >> 1;
if (L <= mid) modify(t[n].ls, l, mid, L, R, k);
if (mid < R) modify(t[n].rs, mid + 1, r, L, R, k);
}
update(n);
}
void work() {
scanf("%d %d %d", &n, &m, &k);
for (K = 1; K * 2 <= k; K <<= 1)
;
for (int i = 1, A, B, C, D; i <= m; i++) {
scanf("%d %d %d %d", &A, &B, &C, &D);
a[i] = (node){A, B, D, 1}, a[i + m] = (node){C + 1, B, D, -1};
}
sort(a + 1, a + 2 * m + 1, cmp);
for (int i = 1; i <= 2 * m; i++) {
if (a[i - 1].a != a[i].a) {
int x = getfull(a[i - 1].a, a[i].a - 1), y = t[rt].x, sx = 0, sy = 0, s;
for (int j = K; j; j >>= 1) {
s = -sx * sy, sx += (x & j) > 0, sy += (y & j) > 0, s += sx * sy;
if (s & 1) ans ^= j;
}
}
modify(rt, 1, n, a[i].b, a[i].c, a[i].ty);
}
puts(ans ? "Hamed" : "Malek");
}
int main() {
work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[300050];
int dp[300050];
int prv[300050];
map<int, int> mp[300050];
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
int n;
scanf("%d", &n);
long long res = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
prv[i] = -1;
dp[i] = 0;
mp[i].clear();
if (mp[i - 1].count(a[i])) {
int pos = mp[i - 1][a[i]];
prv[i] = pos;
swap(mp[i], mp[pos - 1]);
mp[i][a[pos - 1]] = pos - 1;
dp[i] = dp[pos - 1] + 1;
res += dp[i];
}
mp[i][a[i]] = i;
}
printf("%lld\n", res);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
int main() {
string s;
cin >> s;
vector<long long> v(s.size() + 2, 0);
vector<long long> pt(s.size() + 2, 0);
long long curr = 1;
long long t = 1;
for (int i = 1; i < v.size(); i++) {
v[i] = (curr * t) % MOD;
t++;
curr *= 10;
t %= MOD;
curr %= MOD;
v[i] += v[i - 1];
v[i] %= MOD;
}
t = 1;
for (int i = 0; i < pt.size(); i++) {
pt[i] = t;
t *= 10;
t %= MOD;
}
long long ans = 0;
for (long long i = 0; i < s.size(); i++) {
long long x = (i + 1) * (i) / 2;
x %= MOD;
ans += (s[i] - '0') * (((pt[s.size() - i - 1]) * x) % MOD);
ans %= MOD;
ans += (s[i] - '0') * (v[s.size() - i - 1]);
ans %= MOD;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
vector<int> v[100];
int n;
cin >> n;
int ar[1000];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i < n; i++) {
int t;
for (int j = 0; j < ar[i]; j++) {
cin >> t;
v[i].push_back(t);
}
}
int m = 1000012;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < v[i].size(); j++) {
sum += v[i][j] * 5;
}
sum = sum + v[i].size() * 15;
if (sum < m) {
m = sum;
}
}
cout << m;
return 0;
}
| 1 |
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define INF 1000000000
int main(){
int n,k;
while(cin >> n >> k,n+k){
int d[110][110];
for(int i = 0; i < 110; i++)for(int j = 0; j < 110; j++)d[i][j] = i==j?0:INF;
for(int i = 0; i < k; i++){
int a;
cin >> a;
int from,to,cost;
if(a == 1){
cin >> from >> to >> cost;
from--;to--;
if(d[from][to] > cost){
d[from][to] = d[to][from] = cost;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
//from to を経由する
d[i][j] = min(d[i][j],d[i][from]+d[from][to]+d[to][j]);
d[i][j] = min(d[i][j],d[i][to]+d[to][from]+d[from][j]);
d[j][i] = d[i][j];
}
}
}
}
else{
cin >> from >> to;
from--;to--;
if(d[from][to] == INF)puts("-1");
else cout << d[from][to] << endl;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N;
cin >> M;
char mas[N][M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> mas[i][j];
}
}
int posx1, posy1;
for (int i = 0; i < N; i++) {
int ok = 0;
for (int j = 0; j < M; j++) {
if (mas[i][j] == 'B') {
posx1 = i;
posy1 = j;
ok = 1;
break;
}
}
if (ok == 1) {
break;
}
}
int posx2, posy2;
posx2 = posx1;
posy2 = posy1;
while (mas[posx2][posy2] == 'B') {
posx2++;
posy2++;
}
posx1++;
posy1++;
posx1 = posx1 + (posx2 - posx1) / 2;
posy1 = posy1 + (posy2 - posy1) / 2;
cout << posx1 << " " << posy1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:500000000000")
void ending() { exit(0); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << n;
} else {
long long pow = 1;
while (pow <= n) pow *= 2;
cout << pow - 1;
}
ending();
;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 20;
long long n, ans[maxn], p, cur_time, tmp, it, x, update_time = -1;
vector<pair<long long, long long>> ar;
priority_queue<long long> q;
queue<long long> q2;
set<long long> s2;
void por() {
while (it < n && ar[it].first <= cur_time) {
q.push(ar[it].second);
it++;
}
}
int main() {
cin >> n >> p;
for (long long i = 0; i < n; i++) {
cin >> tmp;
ar.push_back({tmp, n - i});
}
sort(ar.begin(), ar.end());
cur_time = ar[0].first;
while (q.size() || it != n || q2.size()) {
por();
if (update_time > cur_time) {
if (q.size()) {
auto koft = s2.end();
koft--;
if (*koft < q.top()) {
q2.push(q.top());
s2.insert(q.top());
q.pop();
}
}
} else if (update_time == cur_time && s2.size()) {
x = q2.front();
ans[n - x] = cur_time;
q2.pop();
s2.erase(x);
if (q.size() && !s2.size()) {
q2.push(q.top());
s2.insert(q.top());
q.pop();
} else if (q.size()) {
auto koft = s2.end();
koft--;
if (*koft < q.top()) {
q2.push(q.top());
s2.insert(q.top());
q.pop();
}
}
if (q2.size()) update_time += p;
} else if (update_time < cur_time) {
if (q.size()) {
q2.push(q.top());
s2.insert(q.top());
q.pop();
update_time = cur_time + p;
}
}
tmp = cur_time;
if (tmp < update_time) tmp = update_time;
if (it != n && (ar[it].first < tmp || tmp == cur_time)) tmp = ar[it].first;
cur_time = tmp;
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y;
cin >> n >> m >> x >> y;
vector<int> A(n), B(m);
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < m; i++) cin >> B[i];
vector<pair<int, int> > C;
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] - x <= B[j] && A[i] + y >= B[j])
C.push_back(make_pair(++i, ++j));
else if (B[j] < A[i])
j++;
else
i++;
}
cout << C.size() << endl;
for (int i = 0; i < C.size(); i++)
cout << C[i].first << ' ' << C[i].second << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int N = 1000 + 5;
const int M = 2e5 + 5;
const int INF = 0x3f3f3f3f;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
namespace LCT {
struct Node {
Node *son[2], *fa;
bool rev;
inline int type() {
if (fa->son[0] == this) {
return 0;
} else if (fa->son[1] == this) {
return 1;
} else {
return 2;
}
}
inline void pushUp();
inline void pushDown();
};
Node pool[M];
int poolCnt;
Node *null;
inline void Node::pushUp() {}
inline void Node::pushDown() {
if (rev) {
swap(son[0], son[1]);
if (son[0] != null) {
son[0]->rev ^= true;
}
if (son[1] != null) {
son[1]->rev ^= true;
}
rev = false;
}
}
inline void init(const int MX) {
null = &pool[0];
for (int i = 1; i <= MX; ++i) {
pool[i].fa = pool[i].son[0] = pool[i].son[1] = null;
}
}
inline void rotate(Node *now) {
Node *fa = now->fa, *gr = fa->fa;
int nowType = now->type(), faType;
if (nowType == 2) {
return;
}
faType = fa->type();
fa->son[nowType] = now->son[nowType ^ 1];
now->son[nowType ^ 1]->fa = fa;
now->son[nowType ^ 1] = fa;
fa->fa = now;
if (faType != 2) {
gr->son[faType] = now;
}
now->fa = gr;
fa->pushUp();
now->pushUp();
}
inline void splay(Node *now) {
static Node *stack[M];
int top = 0;
while (now->type() != 2) {
stack[++top] = now;
now = now->fa;
}
stack[++top] = now;
while (top != 0) {
stack[top--]->pushDown();
}
now = stack[1];
int nowType = now->type(), faType;
while (nowType != 2) {
Node *fa = now->fa;
faType = fa->type();
if (faType != 2) {
if (nowType == faType) {
rotate(fa);
} else {
rotate(now);
}
}
rotate(now);
nowType = now->type();
}
}
inline void access(Node *now) {
Node *prev = null;
while (now != null) {
splay(now);
now->son[1] = prev;
now->pushUp();
prev = now;
now = now->fa;
}
}
inline void makeRoot(Node *now) {
access(now);
splay(now);
now->rev = true;
}
inline Node *findRoot(Node *now) {
access(now);
splay(now);
while (now->son[0] != null) {
now->pushDown();
now = now->son[0];
}
return now;
}
inline Node *findRoot(int id) { return findRoot(pool + id); }
inline void link(Node *u, Node *v) {
makeRoot(u);
if (findRoot(v) != u) {
u->fa = v;
}
}
inline void link(int u, int v) { link(pool + u, pool + v); }
inline void cut(Node *u, Node *v) {
makeRoot(u);
if (findRoot(v) == u && u->son[1] == null && u->fa == v) {
u->fa = v->son[0] = null;
}
}
inline void cut(int u, int v) { cut(pool + u, pool + v); }
} // namespace LCT
namespace Seg {
struct Node {
int min, cnt, tag;
};
Node node[M * 4];
inline void pushUp(int u) {
node[u].min = std::min(node[((u) << 1)].min, node[((u) << 1 | 1)].min);
node[u].cnt = 0;
if (node[u].min == node[((u) << 1)].min) {
node[u].cnt += node[((u) << 1)].cnt;
}
if (node[u].min == node[((u) << 1 | 1)].min) {
node[u].cnt += node[((u) << 1 | 1)].cnt;
}
}
inline void pushDown(int u) {
if (!node[u].tag) {
return;
}
node[((u) << 1)].min += node[u].tag;
node[((u) << 1)].tag += node[u].tag;
node[((u) << 1 | 1)].min += node[u].tag;
node[((u) << 1 | 1)].tag += node[u].tag;
node[u].tag = 0;
}
void build(int u, int l, int r) {
node[u].min = 0;
node[u].cnt = r - l + 1;
if (l == r) {
return;
}
int mid = (l + r) >> 1;
build(((u) << 1), l, mid);
build(((u) << 1 | 1), mid + 1, r);
pushUp(u);
}
void update(int u, int l, int r, int ul, int ur, int x) {
if (ul <= l && r <= ur) {
node[u].min += x;
node[u].tag += x;
return;
}
pushDown(u);
int mid = (l + r) >> 1;
if (ul <= mid) {
update(((u) << 1), l, mid, ul, ur, x);
}
if (mid < ur) {
update(((u) << 1 | 1), mid + 1, r, ul, ur, x);
}
pushUp(u);
}
pair<int, int> query(int u, int l, int r, int ql, int qr) {
if (qr < l || ql > r) {
return (pair<int, int>){INF, 0};
}
if (ql <= l && r <= qr) {
return (pair<int, int>){node[u].min, node[u].cnt};
}
pushDown(u);
int mid = (l + r) >> 1;
pair<int, int> res = (pair<int, int>){INF, 0}, pir;
if (ql <= mid) {
res = std::min(res, query(((u) << 1), l, mid, ql, qr));
}
if (mid < qr) {
pir = query(((u) << 1 | 1), mid + 1, r, ql, qr);
if (res.first > pir.first) {
res = pir;
} else if (res.first == pir.first) {
res.second += pir.second;
}
}
return res;
}
} // namespace Seg
int n, m, e;
int f[N][N];
vector<int> gt[M], lt[M];
int main() {
read(n), read(m);
e = n * m;
LCT::init(e);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
read(f[i][j]);
}
}
long long ans = 0;
for (int x = 1, nx, ny; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
for (int i = 0; i < 4; ++i) {
nx = x + dx[i], ny = y + dy[i];
if (nx > 0 && nx <= n && ny > 0 && ny <= m) {
if (f[x][y] > f[nx][ny]) {
lt[f[x][y]].emplace_back(f[nx][ny]);
} else {
gt[f[x][y]].emplace_back(f[nx][ny]);
}
}
}
}
}
Seg::build(1, 1, e);
int r = 0;
for (int l = 1; l <= e; ++l) {
bool cir = false;
for (int nr = r + 1; nr <= e; ++nr) {
vector<int> vec;
for (const auto &v : lt[nr]) {
if (v >= l) {
if (LCT::findRoot(nr) == LCT::findRoot(v)) {
cir = true;
break;
}
LCT::link(nr, v);
vec.emplace_back(v);
}
}
for (const auto &v : vec) {
LCT::cut(nr, v);
}
if (cir) {
break;
}
++r;
int edge = 0;
for (const auto &v : lt[nr]) {
if (v >= l) {
LCT::link(nr, v);
++edge;
}
}
Seg::update(1, 1, e, nr, e, -edge);
Seg::update(1, 1, e, nr, nr, r - l + 1);
}
pair<int, int> res = Seg::query(1, 1, e, l, r);
if (res.first == 1) {
ans += res.second;
}
for (const auto &v : gt[l]) {
if (v <= r) {
LCT::cut(l, v);
Seg::update(1, 1, e, v, e, 1);
}
}
Seg::update(1, 1, e, l, r, -1);
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n,r;
int p,c;
while(true){
cin>>n>>r;
if(n==0&&r==0)return 0;
vector<int> ca(n);
vector<int> t(n,0);
vector<int> t2(n,0);
for(int i=0;i<n;i++)ca[i]=n-i;
for(int i=0;i<r;i++){
cin>>p>>c;
for(int j=0;j<c;j++){
t[p-1+j]=ca[p-1+j];
}
for(int k=0;k<p-1;k++){
t2[c+k]=ca[k];
}
for(int k=0;k<p-1;k++){
ca[c+k]=t2[c+k];
}
for(int j=0;j<c;j++){
ca[j]=t[p-1+j];
}
}
cout<<ca[0]<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool horses(int x1, int y1, int x2, int y2) {
return ((abs(x1 - x2) == 1 && abs(y1 - y2) == 2) ||
(abs(x1 - x2) == 2 && abs(y1 - y2) == 1));
}
bool horse_and_ladia(int x1, int y1, int x2, int y2) {
return (horses(x1, y1, x2, y2) || (x1 == x2 || y1 == y2));
}
int main() {
int A[8][8], i, j, xh, yh, xl, yl, answer = 0;
string s1, s2;
cin >> s1 >> s2;
xh = s2[0] - 'a', yh = 7 - (s2[1] - '0' - 1), xl = s1[0] - 'a',
yl = 7 - (s1[1] - '0' - 1);
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
if ((i == yh && j == xh) || (i == yl && j == xl))
continue;
else {
if (horses(j, i, xh, yh) || horse_and_ladia(j, i, xl, yl)) answer++;
}
}
}
cout << 62 - answer << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[500020];
int a[500020], ac;
int n, T, q, fh;
int ok(int x) {
int c = x, ti = 0, nd = 0, bk = 0, md = 0, fr = fh;
if (x + ac < q) return 0;
if (x < q) fr = max(fr, a[q - x - 1]);
for (int i = 0; i < n; i++) {
if (s[i] == 'S') {
c++;
if (nd != 0) {
if (c >= nd) {
c -= nd;
if (ti + fr - i + fr - bk <= T) return 1;
ti += 2 * (i - bk);
md += nd;
nd = 0;
if (ti > T) break;
}
}
} else if (s[i] == 'H') {
if (c)
c--, md++;
else {
if (nd == 0) {
nd++;
bk = i;
} else
nd++;
}
}
if (md == q) break;
ti++;
}
if (nd) return 0;
return ti <= T;
}
int main() {
cin >> n >> T, T--;
scanf("%s", s);
for (int i = 0; i < n; i++)
if (s[i] == 'H')
q++, fh = max(fh, i);
else if (s[i] == 'S')
a[ac++] = i;
int l = 0, r = n + 5;
while (l < r) {
int m = l + r >> 1;
if (ok(m))
r = m;
else
l = m + 1;
}
if (l == n + 5)
cout << -1 << endl;
else
cout << l << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans1 = 0, ans2 = 0;
cin >> n >> m;
if (n > m) {
swap(n, m);
}
ans1 = ans2 = n;
ans1 += m - n - 1;
cout << ans1 << " " << ans2;
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int d;
while (cin >> d){
int s = 0;
for (int i = 1; i*d < 600; i++){
s += (i*d)*(i*d)*d;
}
cout << s << endl;
}
return 0;
} | 0 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
#define U(v) cerr << #v << ": " << (v) << endl
template <class T>
struct BIT {
vector<T> a;
BIT(int size) : a(size, 0) {}
T sum(int r) const {
T sm = 0;
for (--r; r >= 0; r = (r & r + 1) - 1)
sm += a[r];
return sm;
}
T sum(int l, int r) const {
return sum(r) - sum(l);
}
T at(int i) const {
return sum(i, i + 1);
}
void add(int i, T v) {
for (; i < (int)a.size(); i |= i + 1)
a[i] += v;
}
void set(int i, T v) {
add(i, v - at(i));
}
};
template <class T>
struct BIT2 {
BIT<T> a, b;
BIT2(int size) : a(size), b(size) {}
T sum(int r) const {
return a.sum(r) + b.sum(r) * r;
}
T sum(int l, int r) const {
return sum(r) - sum(l);
}
T at(int i) const {
return sum(i, i + 1);
}
void _add(int r, T v) {
a.add(r, v * r);
b.add(r, -v);
}
void add(int l, int r, T v) {
_add(l, -v);
_add(r, v);
}
void add(int i, T v) {
add(i, i + 1, v);
}
};
int main() {
int n, q;
cin >> n >> q;
BIT2<long long> bit(n);
while (q--) {
int com, s, t, x;
cin >> com >> s >> t;
--s;
if (com) {
cout << bit.sum(s, t) << endl;
} else {
cin >> x;
bit.add(s, t, x);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool check(int xa, int ya, int xb, int yb, long long xc, long long yc) {
long long k1 = xb - xa;
long long k2 = yb - ya;
if (xc != 0) {
long long wNum = k1 * yc - k2 * xc;
long long wDen = xc * xc + yc * yc;
if (wNum % wDen) return false;
long long w = wNum / wDen;
long long qNum = k1 - w * yc;
if (qNum % xc) return false;
return true;
} else {
return (k1 % yc == 0) && (k2 % yc == 0);
}
}
int main() {
ios_base::sync_with_stdio(false);
int xa, xb, xc, ya, yb, yc;
cin >> xa >> ya >> xb >> yb >> xc >> yc;
if (xc == 0 && yc == 0) {
if ((xa == xb && ya == yb) || (xa == -yb && ya == xb) ||
(xa == -xb && ya == -yb) || (xa == yb && ya == -xb))
cout << "YES";
else
cout << "NO";
return 0;
}
if (check(xa, ya, xb, yb, xc, yc) || check(ya, -xa, xb, yb, xc, yc) ||
check(-xa, -ya, xb, yb, xc, yc) || check(-ya, xa, xb, yb, xc, yc))
cout << "YES";
else
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int a[n], b[n];
vector<int> v;
for (int i = 0; i < n; i++) cin >> a[i];
for (int j = 0; j < n; j++) {
cin >> b[j];
if (b[j] == 0) {
v.push_back(a[j]);
}
}
sort(v.rbegin(), v.rend());
int j = 0;
for (int i = 0; i < n; i++) {
if (b[i] == 0) {
a[i] = v[j++];
}
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s,s1;
cin>>s;
cin>>s1;
int a=0;
for(int i=0;i<3;i++)
{
if(s[i]==s1[i])a++;
}
cout<<a;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> v;
int n, k;
string x[9];
class state {
public:
int mask;
string str;
};
int tar;
void generate() {
queue<state> q;
state sr, ns;
for (int i = 0; i < k; ++i) {
sr.str = (char)(i + '0');
sr.mask = 1 << i;
q.push(sr);
}
while (!q.empty()) {
sr = q.front();
q.pop();
if (sr.mask == (1 << k) - 1) {
v.push_back(sr.str);
}
for (int i = 0; i < k; ++i) {
if (!(1 << i & sr.mask)) {
ns.mask = sr.mask | 1 << i;
ns.str = sr.str + (char)(i + '0');
q.push(ns);
}
}
}
}
int main() {
cin >> n >> k;
int res = 1 << 30;
for (int i = 0; i < n; ++i) cin >> x[i];
generate();
for (int i = 0; i < v.size(); ++i) {
int a[9] = {0};
string per = v[i];
for (int j = 0; j < n; ++j)
for (int k = 0; k < per.size(); ++k)
a[j] = a[j] * 10 + x[j][per[k] - '0'] - '0';
sort(a, a + n);
res = min(res, a[n - 1] - a[0]);
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[300007], rest[300007];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
rest[i % 2] += (a[i] + 1) / 2;
rest[(i + 1) % 2] += a[i] / 2;
}
cout << min(rest[0], rest[1]) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t, n, m, q, i, j, k, x, y, z;
set<long long int> s;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
if (x != 0) s.insert(x);
}
cout << s.size() << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int grid[5][5];
int no[20];
int vis[20];
int hv[20];
bool pl;
int sum;
int N;
bool four() {
grid[2][2] = hv[7];
int t1, t2, t3;
int s = sum - (grid[2][0] + grid[2][1] + grid[2][2]);
bool plx = false;
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
t1 = i;
vis[i] = 1;
plx = true;
break;
}
}
if (!plx) return false;
grid[2][3] = s;
s = sum - (grid[2][2] + grid[1][2] + grid[0][2]);
plx = false;
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
t2 = i;
vis[i] = 1;
plx = true;
break;
}
}
if (!plx) {
vis[t1] = 0;
return false;
}
grid[3][2] = s;
plx = false;
s = sum - (grid[0][0] + grid[1][1] + grid[2][2]);
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
t3 = i;
vis[i] = 1;
plx = true;
break;
}
}
if (!plx) {
vis[t1] = 0;
vis[t2] = 0;
return false;
}
grid[3][3] = s;
return true;
}
bool check() {
if (n == 4)
return four();
else {
int sum1 = 0;
for (int i = 0; i < n; i++) {
sum1 = 0;
for (int j = 0; j < n; j++) {
grid[i][j] = hv[i * n + j];
sum1 += grid[i][j];
}
if (sum1 != sum) return false;
}
for (int j = 0; j < n; j++) {
sum1 = 0;
for (int i = 0; i < n; i++) {
sum1 += grid[i][j];
}
if (sum1 != sum) return false;
}
sum1 = 0;
for (int i = 0; i < n; i++) sum1 += grid[i][i];
if (sum1 != sum) return false;
sum1 = 0;
for (int i = 0, j = n - 1; i < n; i++, j--) sum1 += grid[i][j];
if (sum1 != sum) return false;
return true;
}
}
void print() {
printf("%d\n", sum);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j) printf(" ");
printf("%d", grid[i][j]);
}
printf("\n");
}
}
void back(int pos, int lv) {
if (pos == lv) {
if (check()) {
pl = true;
print();
return;
}
}
int t1, t2, t3;
if (n == 4) {
if (pos == 3) {
int s = sum - (hv[0] + hv[1] + hv[2]);
bool plx = false;
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
t1 = i;
vis[i] = 1;
plx = true;
break;
}
}
if (!plx) return;
grid[0][0] = hv[0];
grid[0][1] = hv[1];
grid[0][2] = hv[2];
grid[0][3] = s;
}
if (pos == 6) {
int s = sum - (hv[3] + hv[4] + hv[5]);
bool plx = false;
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
vis[i] = 1;
t1 = i;
plx = true;
break;
}
}
if (!plx) return;
grid[1][0] = hv[3];
grid[1][1] = hv[4];
grid[1][2] = hv[5];
grid[1][3] = s;
}
if (pos == 7) {
int s = sum - (hv[0] + hv[3] + hv[6]);
bool plx = false;
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
vis[i] = 1;
t1 = i;
plx = true;
break;
}
}
if (!plx) return;
grid[2][0] = hv[6];
grid[3][0] = s;
s = sum - (grid[0][3] + grid[1][2] + grid[3][0]);
plx = false;
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
vis[i] = 1;
plx = true;
t2 = i;
break;
}
}
if (!plx) {
vis[t1] = 0;
return;
}
grid[2][1] = s;
s = sum - (grid[1][1] + grid[0][1] + grid[2][1]);
plx = false;
for (int i = 0; i < N; i++) {
if (no[i] == s && vis[i] == 0) {
vis[i] = 1;
t3 = i;
plx = true;
break;
}
}
if (!plx) {
vis[t1] = 0;
vis[t2] = 0;
return;
}
grid[3][1] = s;
}
}
for (int i = 0; i < N; i++) {
if (vis[i] == 0) {
vis[i] = 1;
hv[pos] = no[i];
back(pos + 1, lv);
vis[i] = 0;
}
if (pl) return;
}
if (n != 4) return;
if (pos == 3 || pos == 6 || pos == 7) {
vis[t1] = 0;
}
if (pos == 7) {
vis[t2] = 0;
vis[t3] = 0;
}
}
int bal[20];
int kus[20];
int main() {
scanf("%d", &n);
N = n * n;
for (int i = 0; i < N; i++) {
scanf("%d", &no[i]);
sum += no[i];
}
sort(no, no + n);
sum /= n;
if (n == 4) {
back(0, 8);
} else
back(0, N);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ice, dis = 0, kid;
char sign;
cin >> n >> ice;
for (int i = 0; i < n; i++) {
cin >> sign >> kid;
if (sign == '+')
ice += kid;
else {
if (kid <= ice)
ice -= kid;
else
dis++;
}
}
cout << ice << " " << dis << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
int min = INT_MAX;
int flag = 0;
int count = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
if (ar[i] < min) min = ar[i];
if (i < n - 1) {
if (ar[i] == 0 && ar[i + 1] == 0) flag = 1;
}
if (ar[0] == 0 || ar[n - 1] == 0) flag = 1;
}
while (!flag) {
int min2 = INT_MAX;
for (int i = 0; i < n; i++) {
if (ar[i] != 0) ar[i] = ar[i] - min;
if (ar[i] < min2 && ar[i] != 0) min2 = ar[i];
if (i > 0) {
if (ar[i] == 0 && ar[i - 1] == 0) {
flag = 1;
}
}
if (ar[0] == 0 || ar[n - 1] == 0) {
flag = 1;
}
}
count += min;
min = min2;
}
cout << count << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
using UL = unsigned int;
using ULL = unsigned long long;
using LL = long long;
#define rep(i, n) for(UL i = 0; i < (n); i++)
int main() {
map<string,UL> S;
UL Q; scanf("%u",&Q);
rep(q,Q){
UL c; scanf("%u",&c);
if(c==0){
char buf[21]; UL x; scanf("%s%u",buf,&x);
S[buf]=x;
}
if(c==1){
char buf[21]; scanf("%s",buf);
auto f=S.find(buf);
printf("%u\n",(f==S.end()) ? 0 : f->second);
}
if(c==2){
char buf[21]; scanf("%s",buf);
S.erase(buf);
}
if(c==3){
string L,R;
char buf[21];
scanf("%s",buf); L=string(buf);
scanf("%s",buf); R=string(buf);
auto f=S.lower_bound(L);
for(;f!=S.end();f++){
if(f->first>R) break;
printf("%s %u\n",f->first.c_str(),f->second);
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int S = 30001;
const int K = 400;
int N, D, X, val[S];
int dp[S][800];
int check(int x, int d) {
if (x >= S) return 0;
if (d <= 0) return -S;
int &k = dp[x][d - D + 400];
if (k) return k - 1;
k = max(k, check(x + d - 1, d - 1));
k = max(k, check(x + d, d));
k = max(k, check(x + d + 1, d + 1));
k += val[x] + 1;
return k - 1;
}
int main() {
cin >> N >> D;
for (int i = 0; i < N; i++) {
cin >> X;
val[X] += 1;
}
cout << check(D, D) << '\n';
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma optimize("gtsy", on)
using namespace std;
const long double EPS = 1e-8;
const int INF = (int)1e9 + 10;
const int MOD = (int)1e9 + 7;
const int N = (int)2e5 + 10;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
;
cout << (n & (1 << 5)) + ((n & (1 << 4)) >> 4) + ((n & (1 << 3)) >> 1) +
((n & (1 << 2)) << 1) + (n & (1 << 1)) + ((n & 1) << 4);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m, s, t;
vector<int> g[N];
void bfs(int _s, int _t, vector<int> &d) {
d[_s] = 0;
queue<int> q;
q.push(_s);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i];
if (d[y] > d[x] + 1) {
d[y] = d[x] + 1;
q.push(y);
}
}
}
}
int mx[N][N];
int main() {
scanf("%d %d %d %d", &n, &m, &s, &t);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[x].emplace_back(y);
g[y].emplace_back(x);
mx[x][y] = mx[y][x] = 1;
}
vector<int> ds(n + 1, 0x3f3f3f3f);
vector<int> dt(n + 1, 0x3f3f3f3f);
bfs(s, t, ds);
bfs(t, s, dt);
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
if (mx[i][j]) continue;
int foo = min(ds[i] + dt[j] + 1, ds[j] + dt[i] + 1);
ans += ds[t] <= foo;
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void minimize(int &a, int b) { a = std::min(a, b); }
void maximize(int &a, int b) { a = std::max(a, b); }
int main() {
int maxi = 2 * 1000 * 1000 * 1000;
int mini = -maxi;
int n;
cin >> n;
while (n--) {
string str1;
cin >> str1;
int x;
cin >> x;
string str2;
cin >> str2;
if (str2 == "N") {
if (str1 == ">=")
str1 = "<";
else if (str1 == "<")
str1 = ">=";
else if (str1 == "<=")
str1 = ">";
else
str1 = "<=";
}
if (str1 == ">=")
maximize(mini, x);
else if (str1 == ">")
maximize(mini, x + 1);
else if (str1 == "<=")
minimize(maxi, x);
else
minimize(maxi, x - 1);
}
if (mini <= maxi)
cout << mini;
else
cout << "Impossible";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 1e-9;
int n, m;
double res;
pair<int, int> p[4], best[4];
set<pair<int, int> > s;
inline double sqr(double a) { return a * a; }
inline double dist(pair<int, int> a, pair<int, int> b) {
return sqrt(sqr(a.first - b.first) + sqr(a.second - b.second));
}
void gen(int x) {
if (x >= 4) {
double ans = 0;
for (int i = 0; i < 3; ++i) {
ans += dist(p[i], p[i + 1]);
}
if (ans > res) {
res = ans;
for (int i = 0; i < 4; ++i) {
best[i] = p[i];
}
}
return;
}
for (set<pair<int, int> >::iterator it = s.begin(); it != s.end(); ++it) {
p[x] = *it;
bool fl = false;
for (int i = 0; i < x; ++i) {
if (p[i] == p[x]) {
fl = true;
break;
}
}
if (!fl) {
gen(x + 1);
}
}
}
inline void add(int x, int y) {
if (x >= 0 && x <= n && y >= 0 && y <= m) {
s.insert(make_pair(x, y));
}
}
int main() {
cin >> n >> m;
res = 0;
for (int i = -1; i <= 1; ++i) {
for (int j = -1; j <= 1; ++j) {
add(i, j);
add(n + i, j);
add(n + i, m + j);
add(i, m + j);
}
}
gen(0);
for (int i = 0; i < 4; ++i) {
cout << best[i].first << " " << best[i].second << endl;
}
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<cassert>
#include<algorithm>
#include<cmath>
#include<cstdio>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-6)
#define equals(a,b) (fabs((a)-(b))<EPS)
using namespace std;
typedef long long ll;
struct Edge {
int s,t;
ll c,d;
};
int V,E;
bool LT(double a,double b) { return !equals(a,b) && a < b; }
bool LTE(double a,double b) { return equals(a,b) || a < b; }
int par[10010];
int find(int x) {
if( x == par[x] ) return x;
return par[x] = find(par[x]);
}
void unit(int x,int y) {
x = find(x), y = find(y);
if( x != y ) par[x] = y;
}
double x;
bool cmp(Edge a, Edge b) {
double v1 = a.d - a.c * x;
double v2 = b.d - b.c * x;
return LT(v2,v1);
}
void compute(vector<Edge> &vec) {
double L = 0, R = 2.0 * 1e20;
double sum_c = 0, sum_d = 0;
rep(i,E) {
sum_c += vec[i].c;
sum_d += vec[i].d;
}
rep(_,120) {
double M = ( L + R ) * 0.5;
x = M;
sort(vec.begin(),vec.end(),cmp);
double c=0,d=0;
rep(i,V) par[i] = i;
rep(i,E) {
int s = vec[i].s, t = vec[i].t;
if( find(s)!=find(t) ) {
unit(s,t);
c += vec[i].c;
d += vec[i].d;
}
}
c = sum_c - c;
d = sum_d - d;
if( equals(c,0) && equals(d,0) ) {
puts("0");
return;
}
double v = d / c;
if( LTE(v,M) ) R = M;
else L = M;
}
printf("%.10f\n",L);
}
int main() {
cin >> V >> E;
vector<Edge> vec(E);
rep(i,E) {
int a,b,c,d;
cin >> a >> b >> c >>d;
vec[i] = (Edge){a,b,c,d};
}
compute(vec);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
bool re = false;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (a == 1) re = true;
}
if (re)
cout << "HARD";
else
cout << "EASY";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2222][2222];
int main(){
int N;
cin >> N;
vector<long long> A(N);
for(auto &i:A)cin >> i;
vector<pair<long long,int>> c(N);
for(int i=0;i<N;i++)c[i]=make_pair(A[i],i);
sort(c.begin(),c.end());
reverse(c.begin(),c.end());
for(int xy=1;xy<=N;xy++){
long long C=c[xy-1].first;
int p=c[xy-1].second;
for(int x=0;x<=min(N,xy);x++){
int y=xy-x;
if(0<x && x<N)dp[x][y]=max(dp[x][y],dp[x-1][y]+C*(p-(x-1)));
if(0<y && y<N)dp[x][y]=max(dp[x][y],dp[x][y-1]+C*((N-1)-(y-1)-p));
}
}
long long ans=0;
for(int i=0;i<=N;i++)ans=max(ans,dp[i][N-i]);
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, num;
cin >> n >> m;
int num_o = 0, num_no = 0;
for (int i = 0; i < n; i++) {
cin >> num;
if (num == 1)
num_o++;
else
num_no++;
}
int l, r;
for (int i = 0; i < m; i++) {
cin >> l >> r;
if ((r - l + 1) % 2) {
cout << 0;
} else {
if (num_o < (r - l + 1) / 2 || num_no < (r - l + 1) / 2)
cout << 0;
else
cout << 1;
}
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int s1 = 0, s2 = 0;
int x[105], y[105];
bool pos = false;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
for (int i = 0; i < n; i++) {
s1 += x[i];
s2 += y[i];
if (x[i] % 2 != y[i] % 2) {
pos = true;
}
}
s1 = s1 % 2;
s2 = s2 % 2;
if (s1 == 0 && s2 == 0) {
cout << "0" << endl;
} else if (s1 == 1 && s2 == 1) {
if (pos)
cout << "1" << endl;
else
cout << "-1" << endl;
} else {
cout << "-1" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, t, n, m, k, l, r, temp, mini, maxi = -1, flag, result, cnt;
scanf("%d", &n);
stack<int> S;
S.push(-1);
for (i = 0; i < n; i++) {
scanf("%d", &k);
S.push(k);
maxi = max(maxi, k);
temp = S.top();
S.pop();
while (S.top() == temp) {
S.pop();
S.push(temp + 1);
maxi = max(maxi, temp + 1);
temp = S.top();
S.pop();
}
S.push(temp);
maxi = max(maxi, temp);
}
printf("%d\n", maxi + 2 - (int)S.size());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int BUBEN = sqrt(200 * 1000);
struct node {
node* go[26];
node* dpgo[26];
node* link;
node* parent;
int lst;
int dp;
int id;
node() {
for (int i = 0; i < 26; i++) {
go[i] = NULL;
dpgo[i] = NULL;
}
parent = NULL;
lst = -1;
id = -1;
link = NULL;
dp = -1;
}
};
void add(node* v, const string& s, int id) {
for (int i = 0; i < (int)s.length(); i++) {
int x = s[i] - 'a';
if (v->go[x] == NULL) v->go[x] = new node();
v->go[x]->parent = v;
v->go[x]->lst = x;
v = v->go[x];
}
v->id = id;
}
void del(node* v, const string& s) {
for (int i = 0; i < (int)s.length(); i++) {
int x = s[i] - 'a';
v = v->go[x];
}
v->id = -1;
}
int getId(node* v, const string& s) {
for (int i = 0; i < (int)s.length(); i++) {
int x = s[i] - 'a';
v = v->go[x];
}
return v->id;
}
const int MAXN = 300 * 1000 + 7;
char buf[MAXN];
string getString() {
scanf("%s", buf);
return string(buf);
}
string strs[MAXN];
bool alive[MAXN];
int strCnt = 0;
node* ahoRoot = new node();
void dfsClear(node* v) {
if (v == NULL) return;
for (int i = 0; i < 26; i++) {
v->dpgo[i] = NULL;
}
v->link = NULL;
v->dp = -1;
for (int i = 0; i < 26; i++) {
dfsClear(v->go[i]);
}
}
node* go(node* v, int x);
node* getLink(node* v) {
if (v->link != NULL) return v->link;
if (v == ahoRoot || v->parent == ahoRoot) {
v->link = ahoRoot;
} else {
v->link = go(getLink(v->parent), v->lst);
}
return v->link;
}
node* go(node* v, int x) {
if (v->dpgo[x] != NULL) return v->dpgo[x];
if (v->go[x] != NULL) {
v->dpgo[x] = v->go[x];
} else if (v == ahoRoot) {
v->dpgo[x] = v;
} else {
v->dpgo[x] = go(getLink(v), x);
}
return v->dpgo[x];
}
int calcDp(node* v) {
if (v->dp != -1) return v->dp;
if (v == ahoRoot) {
v->dp = 0;
return 0;
} else {
v->dp = 0;
if (v->id == 2) {
v->dp = 1;
}
v->dp += calcDp(getLink(v));
}
return v->dp;
}
int main() {
int n;
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
int type;
scanf("%d ", &type);
if (type == 1) {
strCnt++;
strs[strCnt] = getString();
if ((int)strs[strCnt].length() > BUBEN) {
dfsClear(ahoRoot);
add(ahoRoot, strs[strCnt], 2);
} else {
add(ahoRoot, strs[strCnt], 1);
}
} else if (type == 2) {
string cur = getString();
del(ahoRoot, cur);
if ((int)cur.length() > BUBEN) {
dfsClear(ahoRoot);
}
} else if (type == 3) {
string s = getString();
long long res = 0;
for (int i = 0; i < (int)s.length(); i++) {
node* v = ahoRoot;
for (int j = i; j < min((int)s.length(), i + BUBEN); j++) {
v = v->go[s[j] - 'a'];
if (v == NULL) break;
if (v->id != -1) {
res++;
}
}
}
node* v = ahoRoot;
for (int i = 0; i < (int)s.length(); i++) {
v = go(v, s[i] - 'a');
res += calcDp(v);
}
printf("%lld\n", res);
fflush(stdout);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, w[10010], a[5010], x[5010], s, f[10010], h[10010], p;
vector<int> b[10010];
long long ans;
inline void dp(int i) {
for (auto j : b[i]) {
dp(j);
w[i] += w[j];
}
}
int main() {
int i, j, k, l;
scanf("%d", &n);
m = n;
while (n--) {
scanf("%d", &i);
w[max(i, 1)]++;
}
n = p = 5000;
for (i = 2; i <= n; i++) {
for (j = 2; i % j; j++)
;
a[i] = j;
}
for (i = 2; i <= n; i++) {
for (j = i, k = a[j], l = x[k]; j > 1; j /= a[j]) {
if (j > a[j] && a[j] != a[j / a[j]]) {
k = a[j / a[j]];
l = x[k];
}
x[a[j]]++;
s++;
}
h[i] = s;
for (j = k + 1; j <= i; j++) l += x[j];
for (j = i - 1; h[j] > l; j = f[j]) k = j;
if (h[j] == l)
f[i] = j;
else {
f[i] = ++p;
f[p] = j;
f[k] = p;
h[p] = l;
}
ans += (long long)w[i] * h[i];
}
for (i = 1; i <= p; i++) b[f[i]].push_back(i);
dp(1);
for (i = 1, j = 2; j <= p; j++)
if (w[j] > m / 2 && h[j] > h[i]) i = j;
for (; i > 1; i = f[i]) ans -= (long long)(w[i] * 2 - m) * (h[i] - h[f[i]]);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 203;
int a[NMAX], inside[NMAX], outside[NMAX];
int main() {
cin.sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int sol = -(1 << 30), sum = 0, st, dr, insize, outsize;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
st = i;
dr = j;
sum = 0, insize = 0, outsize = 0;
for (int ind = st; ind <= dr; ind++) {
sum += a[ind];
inside[++insize] = a[ind];
}
for (int ind = 1; ind < st; ind++) {
outside[++outsize] = a[ind];
}
for (int ind = dr + 1; ind <= n; ind++) {
outside[++outsize] = a[ind];
}
sort(outside, outside + outsize + 1);
sort(inside, inside + insize + 1);
int insecv = 1;
int sfarsit = outsize;
for (int steps = 1; steps <= k && insecv <= insize && sfarsit; steps++) {
if (inside[insecv] < outside[sfarsit]) {
sum = sum - inside[insecv] + outside[sfarsit];
insecv++, sfarsit--;
} else
break;
}
sol = max(sol, sum);
}
}
cout << sol << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool nd = false;
int n, k;
vector<int> diff, dc;
set<string> chk, t, chk2;
vector<string> s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> k >> n;
s.assign(k, "");
for (int i = 0; i < k; ++i) {
cin >> s[i];
string z = s[i];
sort(z.begin(), z.end());
chk.insert(z);
chk2.insert(s[i]);
}
if (k == 1 || chk2.size() == 1) {
swap(s[0][0], s[0][s[0].size() - 1]);
cout << s[0];
return 0;
}
vector<int> chh(26, 0);
for (auto i : s[0]) chh[i - 'a']++;
for (auto i : chh)
if (i > 1) nd = true;
string x1 = *chk2.begin(), x2 = *chk2.rbegin();
for (int i = 0; i < s[0].size(); ++i) {
if (x1[i] != x2[i]) diff.push_back(i);
}
if (diff.size() > 4 || chk.size() > 1) {
cout << -1;
return 0;
}
dc = diff;
sort(diff.begin(), diff.end());
t.insert(x1);
while (next_permutation(diff.begin(), diff.end())) {
string z = x1;
for (int i = 0; i < diff.size(); ++i) {
z[dc[i]] = x1[diff[i]];
}
t.insert(z);
}
for (auto i : t) {
for (auto j : s) {
int cnt = 0;
for (int k = 0; k < i.size(); ++k) {
if (j[k] != i[k]) {
cnt++;
}
}
if (!(cnt == 2 || (nd && cnt == 0))) goto nxt;
}
cout << i;
return 0;
nxt:
continue;
}
cout << -1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long MAXN = 200010;
struct node {
long long v, m;
} st[MAXN];
long long vis[MAXN], s, t, n, k;
bool calc(long long w) {
long long ans = 0;
for (int i = 1; i <= k; i++) {
long long cut = vis[i] - vis[i - 1];
if (w < cut) return false;
if (w >= 2 * cut)
ans += cut;
else
ans += 3 * cut - w;
if (ans > t) return false;
}
return true;
}
int main() {
scanf("%I64d %I64d %I64d %I64d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%I64d %I64d", &st[i].m, &st[i].v);
for (int i = 1; i <= k; i++) scanf("%I64d", &vis[i]);
vis[0] = 0;
vis[++k] = s;
sort(vis, vis + k + 1);
int ok = 1;
long long low = 0, high = 2 * s;
while (low < high) {
long long mid = (low + high) / 2;
if (calc(mid))
high = mid, ok = 0;
else
low = mid + 1;
}
long long ans = INF;
for (int i = 1; i <= n; i++)
if (st[i].v >= high && ans > st[i].m) ans = st[i].m;
if (ans == INF || ok)
printf("-1\n");
else
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <cstdio>
const int MAXN = 51;
const int ZERO = 2551;
const int MAXM = ZERO*2;
typedef long long LL;
LL F[MAXN][MAXM];
int C[MAXN];
int main()
{
int N, A, i, j, x;
scanf("%d%d", &N, &A);
F[0][ZERO] = 1;
for(i=1; i<=N; ++i)
{
scanf("%d", &x);
x -= A;
for(j=MAXN; j+MAXN<MAXM; ++j)
F[i][j] = F[i-1][j] + F[i-1][j-x];
}
printf("%lld\n", F[N][ZERO]-1);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;int i;cin>>S;
do{
S.erase(S.size()-2);
for(i=0;i<S.size()/2;i++){if(S.at(i)!=S.at(i+S.size()/2))break;}
if(i==S.size()/2)break;
}while(1);
cout<<S.size()<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3, Mod = 1e9 + 7;
int main() {
int n;
cin >> n;
int a1, a2, a3, b1, b2, b3;
cin >> a1 >> a2 >> a3;
cin >> b1 >> b2 >> b3;
int maxi = min(a1, b2) + min(a2, b3) + min(a3, b1);
int mini = max(0, a1 + b2 - n);
mini = max(mini, a2 + b3 - n);
mini = max(mini, a3 + b1 - n);
cout << mini << " " << maxi << endl;
}
| 5 |
#include<iostream>
#include<vector>
struct Sweets{
int i, p, q, r;
};
int main(){
int n;
while(std::cin >> n, n){
std::vector<Sweets> v;
for(;n--;){
Sweets s;
std::cin >> s.i >> s.p >> s.q >> s.r;
v.push_back(s);
}
int P, Q, R, C;
std::cin >> P >> Q >> R >> C;
for(int i=0;i<v.size();i++){
Sweets s = v[i];
int cal = s.p * 4 + s.q * 9 + s.r * 4;
if(s.p <= P && s.q <= Q && s.r <= R && cal <= C){
}else{
v.erase(v.begin() + i--);
}
}
if(v.empty()){
std::cout << "NA" << std::endl;
}else{
for(int i=0;i<v.size();i++){
std::cout << v[i].i << std::endl;
}
}
}
} | 0 |
#include <iostream>
using namespace std;
int main(){
int w;
while(cin >> w && w != -1){
int c = 0;
c += 1150;
c += 125 * max(0,min(w-10,10));
c += 140 * max(0,min(w-20,10));
c += 160 * max(0,w-30);
cout << 4280 - c << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105, M = 1005;
double f[N][M * N], sum[N][N * M];
int n, m, V;
int a[N];
int main() {
scanf("%d%d", &n, &m);
if (m == 1) return puts("1.000000000000"), 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) V += a[i];
f[0][0] = m - 1;
for (int i = 1; i <= n * m; i++) sum[0][i] = m - 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n * m; j++) {
int l = max(j - m, 0), r = j;
f[i][j] += (sum[i - 1][r] - sum[i - 1][l]) * 1.0 / (m - 1);
if (j - a[i] >= 0) f[i][j] -= f[i - 1][j - a[i]] * 1.0 / (m - 1);
sum[i][j + 1] = sum[i][j] + f[i][j];
}
}
printf("%.10lf\n", sum[n][V] + 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
cout << (n / 2) + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) ll(x.size())
void solve() {
ll n;
cin >> n;
vector<ll> pos(2 * n + 1, -1);
REP(i, n) {
ll a;
scanf("%lld", &a);
pos[a] = i + 1;
}
ll ans = 0;
FOR(d, 3, 2 * n) {
for (ll i = 1; i * i < d; i++) {
if (d % i != 0) {
continue;
}
ll j = d / i;
if (pos[i] == -1 || pos[j] == -1) {
continue;
}
ll x = pos[i] + pos[j];
if (x == d) {
ans++;
}
}
}
cout << ans << "\n";
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int v[100005], b[100005];
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &v[i]);
for (int i = 0; i < N; i++) scanf("%d", &b[i]);
long long joy = 0;
for (int i = 0; i < N; i++) {
if (v[i] * 2 < b[i])
joy--;
else {
long long aux = min(v[i], b[i] / 2);
aux = aux * (aux + ((b[i] % 2) ? 1 : 0));
if (aux == 0)
joy--;
else
joy += aux;
}
}
printf("%lld\n", joy);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
bool S[123456];
vector<int> g[123456];
int deg[123456];
bool need[123456];
bool dfs1(int idx, int par) {
bool f = S[idx];
for (auto &to : g[idx]) {
if (to == par) continue;
f |= dfs1(to, idx);
}
need[idx] = f;
return f;
}
template <typename Data, typename T>
struct ReRooting {
struct Node {
int to, rev;
Data data;
};
using F1 = function<T(T, T)>;
using F2 = function<T(T, int, int, Data)>;
vector<vector<Node> > g;
vector<vector<T> > ldp, rdp;
vector<int> lptr, rptr;
const F1 f1;
const F2 f2;
const T ident;
ReRooting(int n, const F1 &f1, const F2 &f2, const T &ident)
: g(n), ldp(n), rdp(n), lptr(n), rptr(n), f1(f1), f2(f2), ident(ident) {}
void add_edge(int u, int v, const Data &d) {
g[u].emplace_back((Node){v, (int)g[v].size(), d});
g[v].emplace_back((Node){u, (int)g[u].size() - 1, d});
}
T dfs(int idx, int par) {
while (lptr[idx] != par && lptr[idx] < g[idx].size()) {
auto &e = g[idx][lptr[idx]];
ldp[idx][lptr[idx] + 1] =
f1(ldp[idx][lptr[idx]], f2(dfs(e.to, e.rev), idx, e.to, e.data));
++lptr[idx];
}
while (rptr[idx] != par && rptr[idx] >= 0) {
auto &e = g[idx][rptr[idx]];
rdp[idx][rptr[idx]] =
f1(rdp[idx][rptr[idx] + 1], f2(dfs(e.to, e.rev), idx, e.to, e.data));
--rptr[idx];
}
if (par < 0) return rdp[idx][0];
return f1(ldp[idx][par], rdp[idx][par + 1]);
}
vector<T> solve() {
for (int i = 0; i < g.size(); i++) {
ldp[i].assign(g[i].size() + 1, ident);
rdp[i].assign(g[i].size() + 1, ident);
lptr[i] = 0;
rptr[i] = (int)g[i].size() - 1;
}
vector<T> ret;
for (int i = 0; i < g.size(); i++) {
ret.push_back(dfs(i, -1));
}
return ret;
}
};
int main() {
cin >> N >> M;
for (int i = 1; i < N; i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
deg[a]++;
deg[b]++;
}
int root = -1;
for (int i = 0; i < M; i++) {
int x;
cin >> x;
--x;
S[x] = true;
root = x;
}
dfs1(root, -1);
auto f1 = [](int a, int b) { return max(a, b); };
auto f2 = [](int a, int src, int to, int cost) { return a + cost; };
ReRooting<int, int> uku(N, f1, f2, 0);
int ret = 0;
for (int i = 0; i < N; i++) {
if (need[i]) {
ret++;
for (auto to : g[i]) {
if (need[to]) {
if (i < to) uku.add_edge(i, to, 1);
}
}
}
}
ret = (ret - 1) * 2;
if (ret == 0) {
for (int i = 0; i < N; i++) {
if (S[i]) {
cout << i + 1 << endl;
cout << 0 << endl;
return 0;
}
}
return 0;
}
auto latte = uku.solve();
int q = 0, idx = 0;
for (int i = 0; i < N; i++) {
if (need[i]) {
if (q < latte[i]) {
q = latte[i];
idx = i + 1;
}
}
}
cout << idx << endl;
cout << ret - q << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[1001];
int dif[1001];
a[0] = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dif[i - 1] = a[i] - a[i - 1];
}
vector<int> len;
len.push_back(n);
for (int i = 1; i < n; i++) {
int j, k;
for (j = i, k = 0; j < n; j++, k++) {
if (dif[j] != dif[k]) break;
}
if (j == n) {
len.push_back(i);
}
}
cout << len.size() << "\n";
sort(len.begin(), len.end());
for (auto x : len) cout << x << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m, a, b;
vector<pair<long long, long long>> v;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
vector<long long> v1;
long long prev = 1;
for (int i = 0; i < n; i++) {
long long val = v[i].first * v[i].second - 1;
v1.push_back(prev);
v1.push_back(prev + val);
prev = prev + val + 1;
}
for (int i = 0; i < m; i++) {
cin >> a;
auto ind = upper_bound(v1.begin(), v1.end(), a) - v1.begin();
if (ind & 1) ind++;
cout << ind / 2 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int a[10000000], b[100];
bool used[1000000];
int main() {
long long int n, ans = 0, len = 0;
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
for (int i = 2; i <= sqrt(n * 1.0); i++) {
if (n % i == 0) {
len++;
a[len] = i;
if (n / i != i) {
len++;
a[len] = n / i;
}
}
}
len++;
a[len] = 1;
len++;
a[len] = n;
int y = n;
while (y > 0) {
b[y % 10] = 1;
y = y / 10;
}
for (int i = 1; i <= len; i++) {
int x = a[i];
while (x > 0) {
int l = x % 10;
if (b[l] == 1) {
ans++;
break;
}
x = x / 10;
}
}
cout << ans;
return 0;
}
| 2 |
#include <iostream>
#include <string>
#include <queue>
#include <numeric>
#include <algorithm>
using namespace std;
int main(){
int n, p;
while(cin >> n >> p, n|p){
vector<int> people(n);
int stone = p;
bool finish = false;
for(int i=0; !finish; i++){
i = i%n;
if(stone != 0){
people[i]++;
stone--;
}else{
stone += people[i];
people[i] = 0;
}
if(people[i] == p){
cout << i << endl;
finish = true;
}
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
string s;
int main()
{
cin>>s;
if(s[s.size()-1]!='s')
{
cout<<s<<'s';
}
else
{
cout<<s<<"es";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x7f7f7f7f;
long long GCD(long long a, long long b) { return 0 == b ? a : GCD(b, a % b); }
const long long mod = 1e9 + 7;
const double pi = acos(-1);
struct noode {
int num, index, x;
} b[2100];
int main() {
ios_base::sync_with_stdio(false);
int a[2100];
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = 0;
cout << n + 1 << endl;
for (int i = n; i >= 1; i--) {
int add = (i - 1 - (a[i] + ans) % n + n) % n;
cout << 1 << " " << i << " " << add << endl;
ans += add;
}
cout << 2 << " " << n << " " << n << endl;
}
| 3 |
#include <bits/stdc++.h>
#define int long long
#define ALL(c) begin(c),end(c)
using namespace std;
signed main() {
vector<int> a(4),b(2);
for(int i=0; i<4; i++) cin>>a[i];
for(int i=0; i<2; i++) cin>>b[i];
sort(ALL(a));
sort(ALL(b));
cout<<(accumulate(ALL(a),0ll)-a[0])+(accumulate(ALL(b),0ll)-b[0])<<endl;
return 0;
} | 0 |
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
char s[110];
int n, sol = 110;
int chk( char c ){
int ret = 0;
int last = -1;
s[n] = c;
for ( int i = 0; i <= n; i++ )
if ( s[i] == c ){
ret = max(ret, i - last - 1);
last = i;
}
return (last < 0) ? 110 : ret;
}
int main(){
scanf("%s", s);
n = strlen(s);
for ( char c = 'a'; c <= 'z'; c++ )
sol = min(sol, chk(c));
printf("%d\n", sol);
return 0;
} | 0 |
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
int top[100][100];
int h[100][100];
int Rotation[4][6]={
{5,1,4,3,0,2}, //南
{0,5,2,4,1,3}, //東
{4,1,5,3,2,0}, //北
{0,4,2,5,3,1} //西
};
struct P{int x,y;} d[4]={
{0,-1}, //南
{1,0}, //東
{0,1}, //北
{-1,0} //西
};
int main(){
int i,j,n,t,f,x,y;
while(cin>>n,n){
memset(top, 0, sizeof(top));
memset(h, 0, sizeof(h));
while(n--){
cin >> t >> f;
int tD[6], D[6]={3,5,4,2,1,6};
while(D[4] != t || D[0] != f){
memcpy(tD, D, sizeof(D));
int r = rand()%4;
for(i=0;i<6;i++) D[Rotation[r][i]] = tD[i];
}
x = 50;
y = 50;
while(h[x][y] != 0){
int dt = -1;
for(j=6;j>3;j--){
for(i=0;i<4;i++) if(D[i]==j)break;
if(i>=4 || h[x+d[i].x][y+d[i].y] >= h[x][y]) continue;
dt = i;
break;
}
if(dt<0) break;
x += d[dt].x;
y += d[dt].y;
memcpy(tD, D, sizeof(D));
for(i=0;i<6;i++) D[Rotation[dt][i]] = tD[i];
}
h[x][y] ++;
top[x][y] = D[4];
}
int sum[7]={0};
for(i=0;i<100;i++)
for(j=0;j<100;j++)
sum[top[i][j]] ++;
cout<<sum[1]<<' '<<sum[2]<<' '<<sum[3]<<' '<<sum[4]<<' '<<sum[5]<<' '<<sum[6]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
long long b[100005], s, mx;
bool t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> t;
if (t)
s += a[i];
else
b[i] = a[i];
if (i) b[i] += b[i - 1];
}
mx = b[k - 1];
for (int i = 1; i < n - k + 1; i++) mx = max(mx, b[i + k - 1] - b[i - 1]);
cout << s + mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[4], dp[302][302];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
if (n == 1) {
if (a[0])
printf("BitLGM\n");
else
printf("BitAryo\n");
return 0;
}
if (n == 3) {
if (a[0] ^ a[1] ^ a[2])
printf("BitLGM\n");
else
printf("BitAryo");
} else {
dp[0][0] = 0;
for (int i = 0; i <= a[0]; ++i)
for (int j = 0; j <= a[1]; ++j)
if (i + j) {
for (int k = 1; k <= i; ++k)
if (!dp[i - k][j]) {
dp[i][j] = 1;
break;
}
if (!dp[i][j])
for (int k = 1; k <= j; ++k)
if (!dp[i][j - k]) {
dp[i][j] = 1;
break;
}
if (!dp[i][j])
for (int k = 1; k <= min(i, j); ++k)
if (!dp[i - k][j - k]) dp[i][j] = 1;
}
if (dp[a[0]][a[1]])
printf("BitLGM\n");
else
printf("BitAryo");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h> // clang-format off
using namespace std;
using Int = long long;
#define REP_(i, a_, b_, a, b, ...) for (int i = (a), lim_i = (b); i < lim_i; i++)
#define REP(i, ...) REP_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
struct SetupIO { SetupIO() { cin.tie(nullptr), ios::sync_with_stdio(false), cout << fixed << setprecision(13); } } setup_io;
#ifndef _MY_DEBUG
#define dump(...)
#endif // clang-format on
/**
* author: knshnb
* created: Fri Mar 20 14:03:30 JST 2020
**/
signed main() {
Int n;
cin >> n;
if (n == 1) {
cout << "1\n0\n";
} else if (n == 2) {
cout << "2\n0\n11\n";
} else {
cout << n - 1 << endl;
REP(i, 2, n + 1) {
cout << 1;
REP(j, i - 2) cout << 0;
cout << "1\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int evenp[n], oddp[n], evens[n], odds[n];
oddp[0] = v[0];
evenp[0] = 0;
for (int i = 1; i < n; i++) {
if (i % 2 == 0) {
oddp[i] = v[i] + oddp[i - 1];
evenp[i] = evenp[i - 1];
} else {
evenp[i] = v[i] + evenp[i - 1];
oddp[i] = oddp[i - 1];
}
}
if ((n - 1) % 2 == 0) {
odds[n - 1] = v[n - 1];
evens[n - 1] = 0;
} else {
odds[n - 1] = 0;
evens[n - 1] = v[n - 1];
}
for (int i = n - 2; i >= 0; i--) {
if (i % 2 == 0) {
odds[i] = v[i] + odds[i + 1];
evens[i] = evens[i + 1];
} else {
evens[i] = v[i] + evens[i + 1];
odds[i] = odds[i + 1];
}
}
int cnt = 0;
for (int i = 0; i < n; i++) {
int odd, even;
if (i % 2 == 0) {
if (i > 0) {
odd = oddp[i - 1] + evens[i];
even = evenp[i - 1] + odds[i] - v[i];
} else {
odd = evens[i];
even = odds[i] - v[i];
}
} else {
if (i > 0) {
odd = oddp[i - 1] + evens[i] - v[i];
even = evenp[i - 1] + odds[i];
} else {
odd = evens[i] - v[i];
even = odds[i];
}
}
if (odd == even) {
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.