solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int n, m, arr[102], DP[(1 << 21)];
pair<int, int> moves[25];
int dp(int mask) {
int done = __builtin_popcount(mask);
if (done == m) return 0;
if (DP[mask] != -1) return DP[mask];
int player = moves[done].second, next_move = moves[done].first;
if (player == 1) {
int ans = -(1000000007LL);
for (int i = 0; i < m; i++) {
if ((mask >> i) & 1) continue;
if (next_move == 1)
ans = max(ans, arr[i] + dp(mask | (1 << i)));
else
ans = max(ans, dp(mask | (1 << i)));
}
return DP[mask] = ans;
} else {
int ans = (1000000007LL);
for (int i = 0; i < m; i++) {
if ((mask >> i) & 1) continue;
if (next_move == 1)
ans = min(ans, -arr[i] + dp(mask | (1 << i)));
else
ans = min(ans, dp(mask | (1 << i)));
}
return DP[mask] = ans;
}
assert(0);
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<int>());
cin >> m;
char str[2];
for (int i = 0; i < m; i++) {
int player;
cin >> str >> player;
if (str[0] == 'p')
moves[i] = {1, player};
else
moves[i] = {-1, player};
}
memset(DP, -1, sizeof(DP));
cout << dp(0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MXN = 300010;
int main() {
int n;
scanf("%d", &n);
std::map<int, int> first, last;
static int ary[MXN];
static int cut[MXN];
static long long sum[MXN];
for (int i = 1; i <= n; i++) {
scanf("%d", &ary[i]);
if (ary[i] > 0) {
cut[i] = cut[i - 1];
sum[i] = sum[i - 1] + ary[i];
} else {
cut[i] = cut[i - 1] + 1;
sum[i] = sum[i - 1];
}
if (first.count(ary[i]) == 0) first[ary[i]] = i;
}
for (int i = n; i >= 1; i--) {
if (last.count(ary[i]) == 0) last[ary[i]] = i;
}
int ansCut = -1, al, ar;
long long ansSum;
std::map<int, int>::iterator it;
for (it = first.begin(); it != first.end(); it++) {
int l = it->second;
int r = last[it->first];
if (l == r) continue;
long long get = it->first * 2 + sum[r - 1] - sum[l];
int toCut = n - r + l - 1 + cut[r - 1] - cut[l];
if (ansCut == -1 || ansSum < get) {
ansSum = get;
ansCut = toCut;
al = l, ar = r;
}
}
int cc = 0;
printf("%I64d %d\n", ansSum, ansCut);
for (int i = 1; i < al; i++) printf("%d%c", i, ++cc == ansCut ? '\n' : ' ');
for (int i = al + 1; i < ar; i++) {
if (ary[i] <= 0) printf("%d%c", i, ++cc == ansCut ? '\n' : ' ');
}
for (int i = ar + 1; i <= n; i++)
printf("%d%c", i, ++cc == ansCut ? '\n' : ' ');
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int str_to_min(string s){
int num=0;
num+=(s[0]-'0')*600;
num+=(s[1]-'0')*60;
num+=(s[3]-'0')*10;
num+=(s[4]-'0');
return num;
}
int main(){
int N,T;
cin>>N>>T;
int cnt=0;
string s1,s2,s3,s4;
cin>>s1>>s2;
vector<string>name;
vector<int>tim;
for(int i=1;i<N;i++){
cin>>s1>>s2>>s3>>s4;
name.push_back(s2);
int tmp=str_to_min(s3)-str_to_min(s1);
tim.push_back(tmp);
if(tmp>=T)cnt++;
}
cin>>s1>>s2;
cout<<cnt<<endl;
for(int i=0;i<name.size();i++){
if(tim[i]>=T){
cout<<name[i]<<" "<<tim[i]<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, c;
c = 0;
cin >> n;
long int x;
vector<long int> r;
vector<long int>::iterator it;
long long int sum = 0;
for (i = 0; i < n; i++) {
cin >> x;
r.push_back(x);
}
sort(r.begin(), r.end());
for (it = r.begin(); it != r.end(); it++) {
if (sum <= (*it)) {
c++;
sum += (*it);
}
}
cout << c;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2003;
char a[N][N];
vector<pair<int, int> > q;
pair<int, int> tmp;
int n, m;
inline bool f(int x, int y) {
int res = 0;
if (a[x][y] != '.') return false;
if (a[x + 1][y] == '.') res++;
if (a[x - 1][y] == '.') res++;
if (a[x][y - 1] == '.') res++;
if (a[x][y + 1] == '.') res++;
if (res == 1) return true;
return false;
}
inline void check(int x, int y) {
if (f(x + 1, y)) q.push_back(make_pair(x + 1, y));
if (f(x - 1, y)) q.push_back(make_pair(x - 1, y));
if (f(x, y + 1)) q.push_back(make_pair(x, y + 1));
if (f(x, y - 1)) q.push_back(make_pair(x, y - 1));
}
inline void g(int x, int y) {
if (a[x + 1][y] == '.') {
a[x][y] = '^';
a[x + 1][y] = 'v';
check(x + 1, y);
}
if (a[x - 1][y] == '.') {
a[x][y] = 'v';
a[x - 1][y] = '^';
check(x - 1, y);
}
if (a[x][y + 1] == '.') {
a[x][y + 1] = '>';
a[x][y] = '<';
check(x, y + 1);
}
if (a[x][y - 1] == '.') {
a[x][y - 1] = '<';
a[x][y] = '>';
check(x, y - 1);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
getchar();
for (int j = 1; j <= m; ++j) {
a[i][j] = getchar();
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (f(i, j)) q.push_back(make_pair(i, j));
while (!q.empty()) {
tmp = q.back();
q.pop_back();
g(tmp.first, tmp.second);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; j++)
if (a[i][j] == '.') return cout << "Not unique", 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%c", a[i][j]);
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod) {
x += y;
if (x >= mod) x -= mod;
}
void et() {
puts("-1");
exit(0);
}
vector<int> mpA[300105];
vector<pair<int, int> > mp[300105];
struct tj {
int dfn[300105], sta[300105], low[300105], color = 0, ii = 0, cnt = 0,
belong[300105];
bool ins[300105];
void tarjan(int x, int pid) {
dfn[x] = low[x] = ++ii;
sta[++cnt] = x;
ins[x] = 1;
for (auto child : mp[x])
if (child.second != pid) {
int v = child.first;
if (!dfn[v]) {
tarjan(v, child.second);
low[x] = min(low[x], low[v]);
} else if (ins[v]) {
low[x] = min(low[x], dfn[v]);
}
}
if (dfn[x] == low[x]) {
++color;
int t;
do {
t = sta[cnt];
cnt--;
ins[t] = 0;
belong[t] = color;
} while (dfn[t] != low[t]);
}
}
} T;
int R;
void Rotate(int &element) {
element = (element + R) % n;
if (element == 0) {
element = n;
}
}
int pos[300105], d[300105], p[300105][20], orderId, ed[300105];
void dfs(int x, int pa) {
p[x][0] = pa;
pos[x] = ++orderId;
d[x] = d[pa] + 1;
for (int c : mpA[x])
if (c != pa) dfs(c, x);
ed[x] = ++orderId;
}
vector<pair<int, int> > ES;
vector<int> nodes, snodes;
set<int> relNodes;
int relSize;
vector<pair<int, int> > mp1[300105];
int dfn[300105], sta[300105], low[300105], color, ii, cnt, belong[300105], Id;
bool ins[300105];
void tarjan(int x, int pid) {
dfn[x] = low[x] = ++ii;
sta[++cnt] = x;
ins[x] = 1;
for (auto child : mp1[x])
if (child.second != pid) {
int v = child.first;
if (!dfn[v]) {
tarjan(v, child.second);
low[x] = min(low[x], low[v]);
} else if (ins[v]) {
low[x] = min(low[x], dfn[v]);
}
}
if (dfn[x] == low[x]) {
++color;
int t;
do {
t = sta[cnt];
cnt--;
ins[t] = 0;
belong[t] = color;
} while (dfn[t] != low[t]);
}
}
bool ckAns() {
int col = -1;
for (int x : nodes) {
if (col == -1)
col = belong[x];
else {
if (col != belong[x]) return 0;
}
}
return 1;
}
void clearAll() {
nodes.clear();
snodes.clear();
Id = 0;
color = 0;
ii = 0;
cnt = 0;
for (int x : relNodes) {
mp1[x].clear();
dfn[x] = 0;
low[x] = 0;
belong[x] = 0;
ins[x] = 0;
}
relSize = 0;
relNodes.clear();
}
int lca(int a, int b) {
if (d[a] > d[b]) swap(a, b);
int f = d[b] - d[a];
for (int i = 0; (1 << i) <= f; i++)
if ((1 << i) & f) b = p[b][i];
if (a != b) {
for (int i = 19; i >= 0; i--)
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
}
a = p[a][0];
}
return a;
}
bool cmp(int a, int b) { return pos[a] < pos[b]; }
void addEdge(int u, int v) {
mp1[u].push_back({v, ++Id});
mp1[v].push_back({u, Id});
relNodes.insert(u);
relNodes.insert(v);
}
void dealLca() {
sort(snodes.begin(), snodes.end(), cmp);
relSize = unique(snodes.begin(), snodes.end()) - snodes.begin();
for (int j = 1; j < relSize; j++) {
int u = snodes[j - 1], v = snodes[j];
int w = lca(u, v);
if (w) snodes.push_back(w);
}
sort(snodes.begin(), snodes.end(), cmp);
relSize = unique(snodes.begin(), snodes.end()) - snodes.begin();
vector<int> sta;
for (int(j) = 0; (j) < (int)(relSize); (j)++) {
while (!sta.empty() && ed[snodes[j]] > ed[sta.back()]) {
sta.pop_back();
}
if (!sta.empty()) {
addEdge(sta.back(), snodes[j]);
}
sta.push_back(snodes[j]);
}
}
void fmain() {
int q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0, u, v; i < m; i++) {
scanf("%d%d", &u, &v);
if (u == v) continue;
mp[u].push_back({v, ++Id});
mp[v].push_back({u, Id});
ES.push_back({u, v});
}
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (T.belong[i] == 0) T.tarjan(i, 0);
set<pair<int, int> > cacheEd;
for (auto p : ES) {
int u = T.belong[p.first], v = T.belong[p.second];
if (u == v) continue;
if (u > v) swap(u, v);
if (cacheEd.count({u, v})) continue;
cacheEd.insert({u, v});
mpA[u].push_back(v);
mpA[v].push_back(u);
}
for (int(i) = 1; (i) <= (int)(T.color); (i)++)
if (pos[i] == 0) {
dfs(i, 0);
}
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i <= n; i++) p[i][j] = p[p[i][j - 1]][j - 1];
for (int i = 1, tn, tm, tmp, u, v; i <= q; i++) {
scanf("%d%d", &tn, &tm);
clearAll();
for (int(j) = 0; (j) < (int)(tn); (j)++) {
scanf("%d", &tmp);
Rotate(tmp);
tmp = T.belong[tmp];
nodes.push_back(tmp);
relNodes.insert(tmp);
snodes.push_back(tmp);
}
for (int(j) = 0; (j) < (int)(tm); (j)++) {
scanf("%d%d", &u, &v);
Rotate(u);
Rotate(v);
u = T.belong[u];
v = T.belong[v];
addEdge(u, v);
snodes.push_back(u);
snodes.push_back(v);
}
dealLca();
for (int z : relNodes)
if (belong[z] == 0) tarjan(z, 0);
bool ok = ckAns();
puts(ok ? "YES" : "NO");
if (ok) (R += i) %= n;
}
}
int main() {
fmain();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string to_string(const vector<T>& vc, int w) {
if (vc.empty()) return "";
if (w + 1 == vc.size()) return to_string(vc[w]);
return to_string(vc[w]) + "," + to_string(vc, w + 1);
}
template <typename T>
string to_string(const vector<T>& vc) {
return "{" + to_string(vc, 0) + "}";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
class DebugStream {
} LOG;
template <typename T>
DebugStream& operator<<(DebugStream& s, const T&) {
return s;
}
const int MAX = 1001000;
int a[MAX];
int main() {
int T;
scanf("%d", &T);
for (int t = 0; t < int(T); t++) {
int n;
scanf("%d", &n);
for (int i = 0; i < int(n); i++) {
scanf("%d", a + i);
a[i]--;
}
int x = 0, y = n - 1;
while (x < n && a[x] == x) x++;
while (y >= 0 && a[y] == y) y--;
if (x == n) {
printf("0\n");
} else {
bool p = true;
for (int i = x; i <= y; i++)
if (a[i] == i) p = false;
if (p) {
printf("1\n");
} else {
printf("2\n");
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200 * 1000 + 9;
const int INF = 1e9;
int n;
pair<int, int> pts[maxN];
map<pair<int, int>, long long> cnt;
void read() {
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
pts[i] = make_pair(x, y);
cnt[make_pair(x, y)]++;
}
}
bool cmpSecond(const pair<int, int> &lhs, const pair<int, int> &rhs) {
return make_pair(lhs.second, lhs.first) < make_pair(rhs.second, rhs.first);
}
void solv() {
sort(pts, pts + n);
pts[n].first = 2 * INF;
long long res = 0;
int s = 0;
for (int i = 1; i <= n; i++) {
if (pts[i].first != pts[i - 1].first) {
long long len = i - 1 - s + 1;
res += len * (len - 1) / 2;
s = i;
}
}
sort(pts, pts + n, cmpSecond);
pts[n].second = 2 * INF;
s = 0;
for (int i = 1; i <= n; i++) {
if (pts[i].second != pts[i - 1].second) {
long long len = i - 1 - s + 1;
res += len * (len - 1) / 2;
s = i;
}
}
for (map<pair<int, int>, long long>::iterator it = cnt.begin();
it != cnt.end(); it++)
res -= (it->second) * (it->second - 1) / 2;
cout << res << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
read();
solv();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 + 1e5;
const int MAXM = 1 + 5e3;
int n, m, n1, n2, n3, col[MAXN], kt, vis[MAXN], dp[MAXM][MAXM], cnt, ma,
res[MAXN], cnt1;
vector<int> g[MAXN], f[MAXN][3];
pair<int, int> p[MAXN];
void dfs(int u) {
vis[u] = 1;
if (g[u].size() == 0) {
p[cnt].first++;
f[cnt][0].push_back(u);
col[u] = 0;
}
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (vis[v] == 1) {
if (col[u] == col[v] && col[u] != -1) {
kt = 1;
return;
}
continue;
}
if (col[u] == col[v] && col[u] == -1) {
col[u] = 1;
col[v] = 0;
p[cnt].first++;
p[cnt].second++;
f[cnt][0].push_back(v);
f[cnt][1].push_back(u);
dfs(v);
continue;
}
if (col[u] != col[v]) {
col[v] = !col[u];
if (col[v] == 0) {
p[cnt].first++;
f[cnt][0].push_back(v);
} else {
p[cnt].second++;
f[cnt][1].push_back(v);
}
dfs(v);
continue;
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
cin >> n1 >> n2 >> n3;
for (int i = 1; i <= n; ++i) col[i] = -1;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (vis[i] == 0) {
++cnt;
dfs(i);
}
if (kt == 1) {
cout << "NO";
return 0;
}
for (int i = 1; i <= cnt; ++i) ma = ma + max(p[i].first, p[i].second);
dp[0][0] = 1;
for (int i = 1; i <= cnt; ++i) {
for (int j = ma; j >= 0; --j) {
if (j >= p[i].first) dp[i][j] = max(dp[i][j], dp[i - 1][j - p[i].first]);
if (j >= p[i].second)
dp[i][j] = max(dp[i][j], dp[i - 1][j - p[i].second]);
}
}
if (dp[cnt][n2] == 0) {
cout << "NO";
return 0;
}
for (int i = cnt; i >= 1; --i) {
if (dp[i - 1][n2 - p[i].first] == 1) {
n2 -= p[i].first;
for (int j = 0; j < f[i][0].size(); ++j) {
res[f[i][0][j]] = 2;
}
for (int j = 0; j < f[i][1].size(); ++j) {
res[f[i][1][j]] = 1;
}
continue;
}
if (dp[i - 1][n2 - p[i].second] == 1) {
n2 -= p[i].second;
for (int j = 0; j < f[i][1].size(); ++j) {
res[f[i][1][j]] = 2;
}
for (int j = 0; j < f[i][0].size(); ++j) {
res[f[i][0][j]] = 1;
}
continue;
}
}
for (int i = 1; i <= n; ++i) {
if (res[i] == 1 && cnt1 < n1) {
++cnt1;
continue;
}
if (res[i] == 1 && cnt1 >= n1) res[i] = 3;
}
cout << "YES" << '\n';
for (int i = 1; i <= n; ++i) cout << res[i];
return 0;
}
| 5 |
#include<cstdio>
#include<unordered_map>
#define int long long
std::unordered_map<int,int>f;
int t,n,a,b,c,d;
inline int mn(int x,int y)
{return x<y?x:y;}
int dfs(int x)
{
if(f.count(x))return f[x];
f[x]=1e18;
if(x<=2e9)f[x]=mn(f[x],x*d);
if(!(x%2))f[x]=mn(f[x],dfs(x/2)+a);
if(!(x%3))f[x]=mn(f[x],dfs(x/3)+b);
if(!(x%5))f[x]=mn(f[x],dfs(x/5)+c);
if(x%2)f[x]=mn(f[x],dfs(x-1)+d);
if(x%3)f[x]=mn(f[x],dfs(x-x%3)+x%3*d);
if(x%5)f[x]=mn(f[x],dfs(x-x%5)+x%5*d);
if(x%2)f[x]=mn(f[x],dfs(x+1)+d);
if(x%3)f[x]=mn(f[x],dfs(x-x%3+3)+(3-x%3)*d);
if(x%5)f[x]=mn(f[x],dfs(x-x%5+5)+(5-x%5)*d);
return f[x];
}
signed main()
{
for(scanf("%lld",&t);t;--t)
scanf("%lld%lld%lld%lld%lld",&n,&a,&b,&c,&d),
f.clear(),f[0]=0,printf("%lld\n",dfs(n));
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long h[100001] = {0};
long long hops[100001] = {0};
long long previous[100001] = {0};
long long ans[100001] = {0};
int main() {
int n, d;
cin >> n >> d;
int end_point = 1;
for (int i = 1; i <= n; ++i) {
cin >> h[i];
hops[i] = 1;
for (int j = max(1, i - 500); j < i; j++) {
if (abs(h[i] - h[j]) >= d && hops[j] + 1 > hops[i]) {
hops[i] = hops[j] + 1;
previous[i] = j;
}
if (hops[i] > hops[end_point]) {
end_point = i;
}
}
}
cout << hops[end_point] << '\n';
int T = previous[end_point];
int cnt = 0;
ans[cnt] = end_point;
while (T) {
ans[++cnt] = T;
T = previous[T];
}
for (int i = cnt; i >= 0; i--) {
cout << ans[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, mi, mx, rem;
cin >> n;
mi = mx = (n / 7) * 2;
rem = n % 7;
if (rem >= 2) {
mx += 2;
} else if (rem > 0) {
mx++;
}
if (rem > 5) {
mi++;
}
cout << mi << " " << mx << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
struct Edge {
int to, id;
Edge(int to, int id): to(to), id(id) {}
};
vector<Edge> g[55];
vector<int> es;
bool dfs(int v, int tv, int p=-1) {
if (v == tv) return true;
for (Edge e : g[v]) {
if (e.to == p) continue;
if (dfs(e.to, tv, v)) {
es.push_back(e.id);
return true;
}
}
return false;
}
int main() {
int n, m;
cin >> n;
rep(i,n-1) {
int a, b;
cin >> a >> b;
--a; --b;
g[a].emplace_back(b, i);
g[b].emplace_back(a, i);
}
cin >> m;
vector<ll> eset(m);
rep(i,m) {
int a, b;
cin >> a >> b;
--a; --b;
es = vector<int>();
dfs(a,b);
for (int e : es) {
eset[i] |= 1ll<<e;
}
}
ll ans = 0;
rep(i,1<<m) {
ll mask = 0;
rep(j,m) {
if (i>>j&1) mask |= eset[j];
}
int white = __builtin_popcountll(mask);
ll now = 1ll<<(n-1-white); // 2^(n-1-white)
if (__builtin_popcountll(i)%2 == 0) ans += now;
else ans -= now;
}
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fr first
#define sc second
typedef pair<int, int> Pii;
typedef pair<int, Pii> Pip;
typedef vector<int> Vi;
const int INF = (1<<25);
const int MAX_V = 101;
const int dx[]={1,0,-1,0}, dy[]={0,-1,0,1};
int w, h, f, m;
int c[10][10];
struct State {
int x, y, l, r, oxy, cost;
State(int x_, int y_, int l_, int r_, int oxy_, int cost_) {
x=x_; y=y_; l=l_; r=r_; oxy=oxy_; cost=cost_;
}
State(){}
};
bool operator<(const State& a, const State& b) {
return a.cost > b.cost;
}
int d[10][10][10][10][51];
int solve(int o) {
if( o < 2 ) return INF;
for(int y=0; y<10; y++) {
for(int x=0; x<10; x++) {
for(int l=0; l<10; l++) {
for(int r=0; r<10; r++) {
for(int m=0; m<51; m++) {
d[y][x][l][r][m] = INF;
}
}
}
}
}
priority_queue<State> q;
for(int x=0; x<w; x++) {
int cost = -1 * min(c[0][x], 0);
int oxy = min(m, o - 1 + max(c[0][x], 0));
d[0][x][x][x][oxy] = cost;
q.push(State(x, 0, x, x, oxy, cost));
}
int res = INF;
while( !q.empty() ) {
State p = q.top(); q.pop();
int x = p.x, y = p.y, l = p.l, r = p.r;
int oxy = p.oxy, cost = d[y][x][l][r][oxy];
if( oxy == 0 ) continue;
if( f < cost ) return INF;
if( y == h-1 ) {
res = cost;
break;
}
if( oxy == 1 ) continue;
for(int dx=-1; dx<=1; dx+=2) {
int mx = x + dx;
if( mx < 0 || w <= mx ) continue;
int l_ = min(l, mx), r_ = max(r, mx);
int next_cost = cost, next_oxy;
if( l_ == l && r_ == r ) {
next_oxy = oxy -1;
}
else {
next_cost += -1 * min(c[y][mx], 0);
next_oxy = min(m, oxy - 1 + max(c[y][mx], 0));
}
if( next_cost < d[y][mx][l_][r_][next_oxy] ) {
d[y][mx][l_][r_][next_oxy] = next_cost;
q.push(State(mx, y, l_, r_, next_oxy, next_cost));
}
}
if( y < h-1 ) {
int next_cost = cost + -1 * min(c[y+1][x], 0);
int next_oxy = min(m, oxy - 1 + max(c[y+1][x], 0));
if( next_cost < d[y+1][x][x][x][next_oxy] ) {
d[y+1][x][x][x][next_oxy] = next_cost;
q.push(State(x, y+1, x, x, next_oxy, next_cost));
}
}
}
if( f < res ) return INF;
return res;
}
int main() {
while( cin >> w >> h, w || h ) {
int o;
cin >> f >> m >> o;
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
cin >> c[y][x];
}
}
int ans = solve(o);
if( ans == INF ) cout << "NA" << endl;
else cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, L, a[200005], b[200005 << 2], c[200005], m;
int judge(int mid) {
int l = 1, r = m;
for (int i = 1; i <= n; i++) {
while (a[i] - mid > b[l]) ++l;
while (a[i] + mid < b[r]) --r;
if (l > r) return 0;
++l, ++r;
}
return 1;
}
int main() {
cin >> n >> L;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> c[i];
sort(c + 1, c + 1 + n);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) b[i] = c[i] - L;
for (int i = 1; i <= n; i++) b[i + n] = c[i];
for (int i = 1; i <= n; i++) b[i + 2 * n] = c[i] + L;
m = 3 * n;
int l = 0, r = L, ans, mid;
while (l < r) {
mid = l + r >> 1;
if (judge(mid))
ans = mid, r = mid;
else
l = mid + 1;
}
cout << r << '\n';
}
| 6 |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
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 << "]" << endl;}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define deb(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define deb(x...)
#endif
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
#define ff first
#define ss second
#define pb push_back
#define MESSI ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define all(x) (x).begin(), (x).end()
#define rep(i,a,b) for(ll i=a ; i<b ; ++i)
#define VectorInput(v,n) for(ll i=0;i<n;i++)cin>>v[i];
#define VectorPrint(v) for(ll i=0;i<v.size();i++)cout<<v[i]<<" ";
#define line "\n"
#define YES "YES"
#define NO "NO"
#define Variable(x) ll x;cin>>x;
const ll MOD = 1e9 + 7;
const ll maxn = 1e6 + 4;
const ll INF = 1e18;
ll answer()
{
ll n;cin>>n;
bool rem=false;
ll count=0;
while(true)
{
if(n==1)break;
count++;
rem=rem || (n%2==0?true:false);
n=n>>1;
}
return pow(2,count)-1;
}
int main()
{
MESSI
int t;cin>>t;
while(t--)cout<<answer()<<line;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
struct node {
double a, b;
} e[100010];
int n;
double getl(node X, node Y) {
double d1 = (X.a - Y.a) * (X.a - Y.a);
double d2 = (X.b - Y.b) * (X.b - Y.b);
return sqrt(d1 + d2);
}
double getlength(node A, node B, node C, double &temp) {
double a = getl(A, C);
double b = getl(B, C);
double c = getl(A, B);
temp = max(a, b);
if (a * a >= b * b + c * c) return b;
if (b * b >= a * a + c * c) return a;
double pp = (a + b + c) / 2;
double s = (pp - a) * (pp - b) * (pp - c) * pp;
s = sqrt(s);
double d = s * 2 / c;
return d;
}
int main() {
node t;
int i, j;
while (cin >> n) {
cin >> t.a >> t.b;
for (i = 0; i < n; i++) cin >> e[i].a >> e[i].b;
double maxn = -(double)10000000;
;
double minx = (double)10000000;
;
double temp;
for (i = 0; i < n; i++) {
minx = min(minx, getlength(e[i], e[(i + 1) % n], t, temp));
maxn = max(maxn, temp);
}
double ans = PI * (maxn * maxn - minx * minx);
printf("%.10lf\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int isUp(char ch);
int main() {
char arr[1001];
scanf("%s", arr);
if (!isUp(arr[0])) {
arr[0] -= 32;
}
printf("%s\n", arr);
}
int isUp(char ch) {
if (ch >= 'A' && ch <= 'Z')
return 1;
else
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define MAXN 100010
#define int long long
using namespace std;
int a[MAXN],b[MAXN],cnt[MAXN];
int fa[MAXN],size[MAXN],ans;
int fi(int now){
if(fa[now]==now) return now;
return fa[now]=fi(fa[now]);
}
void con(int x,int y){
int fx=fi(x),fy=fi(y);
if(fx==fy) return ;
ans+=size[fx]*size[fy];
fa[fx]=fy,size[fy]+=size[fx];
}
signed main(){
int n,m,qwq;
cin>>n>>m; qwq=(n-1)*n/2;
for(int i=1;i<=n;i++) fa[i]=i,size[i]=1;
for(int i=1;i<=m;i++)
scanf("%lld%lld",&a[i],&b[i]);
for(int i=m;i;i--)
cnt[i]=qwq-ans,con(a[i],b[i]);
for(int i=1;i<=m;i++)
printf("%lld\n",cnt[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int pos[maxn], ans[maxn], a[maxn];
vector<int> e[maxn];
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
e[r].push_back(l);
}
for (int j = 0; j < e[a[n]].size(); j++) {
int v = e[a[n]][j];
ans[v]++;
}
int now = n;
for (int i = n - 1; i >= 1; i--) {
if (i + ans[a[i]] == now) {
now--;
continue;
}
for (int j = 0; j < e[a[i]].size(); j++) {
int v = e[a[i]][j];
if (pos[v] < pos[a[i]]) {
ans[v]++;
}
}
}
cout << n - now << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, ab;
cin >> a >> b >> ab;
long long ans = a + b + ab * 2;
if (abs(b - a) > 1)
cout << ans - abs(b - a) + 1;
else
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long power(unsigned long long x, int y, int p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool cmp(pair<string, int> &a, pair<string, int> &b) {
return a.second < b.second;
}
void sort(map<string, int> &M) {
vector<pair<string, int> > A;
for (auto &it : M) {
A.push_back(it);
}
sort(A.begin(), A.end(), cmp);
for (auto &it : A) {
cout << it.first << ' ' << it.second << endl;
}
}
unsigned long long modInverse(unsigned long long n, int p) {
return power(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n, int r, int p) {
if (n < r) return 0;
if (r == 0) return 1;
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
long long gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long int a, long long int b) { return (a / gcd(a, b)) * b; }
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int find(long long int s, long long int n, long long int pos) {
long long int mid = s + n / 2;
if (mid == pos) {
return 1;
} else if (mid > pos) {
return 1 + find(mid + 1, n, pos);
} else {
return 1 + find(s, mid, pos);
}
}
long long int fact(long long int n, long long int p) {
return (n == 1 || n == 0) ? 1 : (n * (fact(n - 1, p)));
}
long long int num(long long int n, long long int ans) {
n /= 10;
if (n == 0) {
return ans;
} else {
return ans + num(n, ans + 1);
}
}
long long int nof(long long int n) {
if (n == 1) {
return 1;
}
long long int ans = 2;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i * i != n) {
ans += 2;
} else {
ans++;
}
}
}
return ans;
}
long long int getsum(long long int n) {
long long int ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
long long int power(long long int num, long long int deg, long long int m) {
if (!deg) return 1;
if (deg % 2) {
return (power(num, deg - 1, m) * num) % m;
} else {
long long int sqrt_res = power(num, deg / 2, m);
return (sqrt_res * sqrt_res) % m;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) {
long long int n, m;
cin >> n >> m;
set<long long int> st;
vector<long long int> ans(n + 1);
for (long long int i = 1; i <= n; i++) {
st.insert(i);
}
long long int p, q, r;
for (long long int i = 0; i < m; i++) {
cin >> p >> q >> r;
for (auto j = st.lower_bound(p); j != st.upper_bound(q);) {
if (*j >= p && ans[*j] == 0 && *j != r) {
auto pp = j;
ans[*j] = r;
j++;
st.erase(pp);
} else {
j++;
}
}
}
ans[r] = 0;
for (long long int itr = 1; itr < ans.size(); itr++) {
cout << ans[itr] << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[1000 + 10][12][12];
bool w[120];
int up[1000 + 10][12][12];
int j[1000 + 10];
void javab(int m, int x, int y) {
if (m == 0) {
return;
}
j[m - 1] = up[m][x][y];
javab(m - 1, y - x, j[m - 1]);
}
int main() {
string s;
int m;
cin >> s >> m;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
w[i + 1] = 1;
}
}
for (int i = 1; i <= 10; i++) {
if (w[i] == 1) {
dp[1][i][i] = 1;
}
}
for (int i = 2; i <= m; i++) {
for (int j = 1; j <= 10; j++) {
for (int k = 1; k <= 10; k++) {
for (int t = 1; t <= 10; t++) {
if (dp[i - 1][j][k] == 1 && w[t] == 1 && t != k && t > j) {
if (i == 2) {
dp[i][t - j][t] = 1;
up[i][t - j][t] = k;
} else {
if (j != k) {
dp[i][t - j][t] = 1;
up[i][t - j][t] = k;
}
}
}
}
}
}
}
int x = -1;
int y = -1;
int z = m;
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
if (dp[m][i][j] == 1) {
x = i;
y = j;
}
}
}
if (x == -1) {
cout << "NO";
return 0;
} else {
cout << "YES" << endl;
j[m] = y;
javab(m, x, y);
}
for (int i = 1; i <= m; i++) {
cout << j[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using std::sort;
int n;
char s[100000 + 1];
struct SH {
unsigned int s, h;
};
struct SH cnt[100000 + 1];
unsigned long long ans;
void read() {
scanf("%d", &n);
ans = 0;
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
int l = strlen(s);
unsigned int sum = 0;
for (int j = 0; j < l; ++j)
if (s[j] == 's')
++sum;
else
ans += sum;
cnt[i].s = sum;
cnt[i].h = l - sum;
}
}
bool compareSH(struct SH &x, struct SH &y) { return x.s * y.h > y.s * x.h; }
void chief() {
sort(&cnt[1], &cnt[n] + 1, compareSH);
unsigned int sum = 0;
for (int i = 1; i <= n; ++i) {
ans += (unsigned long long)sum * cnt[i].h;
sum += cnt[i].s;
}
}
void write() { printf("%I64u\n", ans); }
int main() {
read();
chief();
write();
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long n, m, a, b, c, k, temp, x, y;
const int MAXN = 1e5 + 11, mod = 1e9 + 7;
inline long long max(long long a, long long b) { return ((a > b) ? a : b); }
inline long long min(long long a, long long b) { return ((a > b) ? b : a); }
inline vector<long long> read(int n) {
vector<long long> v(n);
for (int i = 0; i < v.size(); i++) cin >> v[i];
return v;
}
int SZ;
struct matrix {
vector<vector<long long>> arr;
void reset() {
arr.clear();
arr.resize(n, vector<long long>(n, 0));
}
void makeiden() {
reset();
for (int i = 0; i < SZ; i++) arr[i][i] = 1;
}
matrix operator+(const matrix &o) const {
matrix res;
res.reset();
for (int i = 0; i < SZ; i++) {
for (int j = 0; j < SZ; j++) {
res.arr[i][j] = (arr[i][j] + o.arr[i][j]) % mod;
}
}
return res;
}
matrix operator*(const matrix &o) const {
matrix res;
res.reset();
for (int i = 0; i < SZ; i++) {
for (int j = 0; j < SZ; j++) {
res.arr[i][j] = 0;
for (int k = 0; k < SZ; k++) {
res.arr[i][j] =
(res.arr[i][j] + (arr[i][k] * o.arr[k][j]) % mod) % mod;
}
}
}
return res;
}
};
long long f[100], cnt[3];
matrix power(matrix a, long long b) {
matrix res;
res.makeiden();
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
void sol() {
cin >> n >> k;
SZ = n;
matrix T;
T.reset();
vector<long long> v = read(n);
for (int i = 0; i < n; i++) {
int bits = 0;
for (int j = 0; j < 60; j++) {
if ((1LL << j) & v[i]) bits++;
}
cnt[bits % 3]++;
f[i] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
x = v[i] ^ v[j];
int bits = 0;
for (int b = 0; b < 60; b++) {
if ((1LL << b) & x) bits++;
}
if (bits % 3 == 0) T.arr[i][j] = 1;
}
}
T = power(T, k - 1);
long long sum = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) sum += (f[j] * T.arr[i][j]) % mod, sum %= mod;
cout << sum;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
for (int i = 1; i <= test; i++) sol();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long inv[5110], fac[5110], s_inv[5110];
void prepare() {
fac[0] = inv[0] = s_inv[0] = 1;
inv[1] = s_inv[1] = fac[1] = 1;
for (long long i = (2); i <= (5100); ++i) {
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
s_inv[i] = s_inv[i - 1] * inv[i] % MOD;
fac[i] = fac[i - 1] * i % MOD;
}
}
long long c(long long n, long long k) {
if (n == k) return 1;
if (k > n || k < 0) return 0;
return fac[n] * s_inv[k] % MOD * s_inv[n - k] % MOD;
}
long long g(long long s, long long p, long long m) {
long long ret = 0, sign = -1;
for (long long i = (0); i <= (p); ++i) {
sign *= -1;
ret =
(ret + sign * c(p, i) % MOD * c(s - i * (m + 1) + p - 1, p - 1) % MOD) %
MOD;
}
return ret;
}
long long power(long long x, long long y) {
long long ret = 1;
while (y > 0) {
if (y & 1) ret = ret * x % MOD;
x = x * x % MOD;
y >>= 1;
}
return ret;
}
int main() {
prepare();
long long p, s, r;
scanf("%lld %lld %lld", &p, &s, &r);
long long P = 0, Q = c(s - r + p - 1, p - 1);
for (long long t = (r); t <= (s); ++t)
for (long long q = 1; q * t <= s && q <= p; ++q) {
P = (P +
c(p - 1, q - 1) * g(s - q * t, p - q, t - 1) % MOD * inv[q] % MOD) %
MOD;
}
printf("%lld\n", P * power(Q, MOD - 2) % MOD);
return 0;
}
| 5 |
#include <iostream>
#include <map>
using namespace std;
const int N = 2e5 + 10;
int n, k, a[N], cum[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] += k-1;
a[i] %= k;
cum[i+1] = (a[i] + cum[i]) % k;
}
long long res = 0;
map<int,int> cnt;
for (int i = 0; i <= n; i++) {
if (i >= k) cnt[cum[i-k]]--;
res += cnt[cum[i]]++;
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
string s;
cin >> s;
unordered_map<char, int> mp;
for (int i = 0; i < s.length(); i++) {
mp[s[i]]++;
}
string ans = "";
for (auto f : mp) {
if (f.second % k == 0) {
for (int i = 0; i < (f.second / k); i++) {
ans += f.first;
}
} else {
cout << -1 << endl;
return 0;
}
}
string gg = "";
while (k--) {
gg += ans;
}
cout << gg << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for(int i=0; i<(a); i++)
typedef long long ll;
const ll mod = 998244353;
int main()
{
ll n, s; cin >> n >> s;
vector<ll> a(n);
for (int i=0; i<n; i++){
cin >> a[i];
}
vector<vector<ll>> dp(n+2, vector<ll>(s+1, 0));
ll ans = 0;
rep(i, n) {
(dp[i][0] += 1) %= mod;
(dp[i+1][0] += 1) %= mod;
rep(j, s+1-a[i]) {
(dp[i+1][j+a[i]] += dp[i][j]) %= mod;
}
(ans += dp[i+1][s]) %= mod;
dp[i+2] = dp[i+1];
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 1000010;
const int MOD = 1000000007;
const int INF = 0x7fffffff;
const int dir4[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
const int dir8[8][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{-1, 1}, {1, -1}, {-1, -1}, {1, 1}};
const double eps = 1e-16;
const double PI = acos(-1.0);
inline int sign(double x) { return (x > eps) - (x < -eps); }
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T Min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T Max(T a, T b) {
return a > b ? a : b;
}
int f[N];
vector<int> v;
set<int> S;
set<int>::iterator it;
struct Node {
char str[5];
int t;
} node[N];
int main() {
int n, m;
while (scanf("%d%d", &(n), &(m)) != EOF) {
v.clear();
S.clear();
for (int i = 1; i <= n; i++) f[i] = 1;
int ans = n;
for (int i = 0; i < (m); i++) scanf("%s %d", node[i].str, &node[i].t);
for (int i = 0; i < (m); i++) {
if (node[i].str[0] == '+') {
if (S.empty() && i - 1 >= 0 && node[i - 1].str[0] == '-' &&
node[i - 1].t == node[i].t) {
S.insert(node[i].t);
v.push_back(node[i].t);
continue;
}
if (v.size() != 0 || i > 0) {
if (f[node[i].t] == 1) ans--;
f[node[i].t] = 0;
}
S.insert(node[i].t);
v.push_back(node[i].t);
} else {
it = S.find(node[i].t);
if (it == S.end()) {
for (int j = 0; j < (int)v.size(); j++) {
if (f[v[j]] == 1) {
ans--;
f[v[j]] = 0;
}
}
S.insert(node[i].t);
}
if (S.size() != 1) {
if (f[node[i].t] == 1) {
ans--;
f[node[i].t] = 0;
}
} else {
if (i + 1 < m &&
(node[i + 1].str[0] != '+' || node[i + 1].t != node[i].t)) {
if (f[node[i].t] == 1) {
ans--;
f[node[i].t] = 0;
}
}
}
S.erase(node[i].t);
}
}
printf("%d\n", (ans));
int flag = 0;
for (int i = 1; i <= n; i++) {
if (!f[i]) continue;
if (flag) printf(" ");
printf("%d", i);
flag = 1;
}
if (ans) printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string word;
stack<char> letters;
bool p1 = true;
cin >> word;
for (int i = 0; i < word.length(); i++) {
if (letters.empty()) {
letters.push(word[i]);
} else {
if (word[i] == letters.top()) {
letters.pop();
p1 = !p1;
} else {
letters.push(word[i]);
}
}
}
if (p1) {
cout << "No\n";
} else {
cout << "Yes\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
int main() {
int n, b;
cin >> n >> b;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int ans = b;
for (int i = 0; i < n; i++) {
int mx = 0;
for (int j = i + 1; j < n; j++) mx = max(mx, a[j]);
ans = max(ans, b / a[i] * mx + b - b / a[i] * a[i]);
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const long long LINF = 1LL << 60;
const double inf = 1e15;
long long mod = 1e9 + 9;
char READ_DATA;
int SIGNAL_INPUT;
template <typename Type>
inline Type ru(Type &v) {
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
v = v * 10 + READ_DATA - '0';
v *= SIGNAL_INPUT;
return v;
}
inline long long modru(long long &v) {
long long p = 0;
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
p = v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9') {
v = (v * 10 + READ_DATA - '0') % mod;
p = (p * 10 + READ_DATA - '0') % (mod - 1);
}
v *= SIGNAL_INPUT;
return p;
}
template <typename A, typename B>
inline char ru(A &x, B &y) {
if (ru(x) == EOF) return EOF;
ru(y);
return 2;
}
template <typename A, typename B, typename C>
inline char ru(A &x, B &y, C &z) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
return 3;
}
template <typename A, typename B, typename C, typename D>
inline char ru(A &x, B &y, C &z, D &w) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
ru(w);
return 4;
}
struct Edge {
int u, v, next;
long long w, cap, flow;
Edge(int _u = 0, int _v = 0, int nxt = -1, long long _w = 1,
long long _cap = 0) {
u = _u;
v = _v;
w = _w;
cap = _cap;
flow = 0;
next = nxt;
}
int operator<(const Edge &b) const { return w < b.w; }
};
const int maxn = 3e5 + 3, N = 3e5, SZ = 320;
double eps = 1e-7, pi = acos(-1.0);
unsigned long long seed = 131, smod = (1LL << 32) - 267;
double n, a;
int main() {
ru(n, a);
double r = (n - 2) * 180 / n;
r /= (n - 2);
double ans = LINF;
int v = 0;
for (int i = 1; i <= n - 2; ++i) {
if (abs(a - r * i) < ans) {
ans = abs(a - r * i);
v = 2 + i;
}
}
cout << 2 << " " << 1 << " " << v;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[1010];
int main() {
scanf("%s", s);
int l = strlen(s);
int dian, e_;
for (int i = 0; i < l; i++) {
if (s[i] == '.') dian = i;
if (s[i] == 'e') e_ = i;
}
if (s[0] == '0') {
int p = -1;
for (int i = dian + 1; i < e_; i++) {
if (s[i] != '0') p = i;
}
if (p == -1)
printf("0\n");
else {
for (int i = 0; i <= p; i++) printf("%c", s[i]);
printf("\n");
}
} else {
int u = 0;
for (int i = e_ + 1; i < l; i++) {
u = u * 10 + (s[i] - '0');
}
if (u == 0) {
int p = 0;
for (int i = dian + 1; i < e_; i++) {
if (s[i] != '0') p = i;
}
for (int i = 0; i <= p; i++) printf("%c", s[i]);
printf("\n");
} else {
int k = e_ - dian - 1;
if (k < u) {
printf("%c", s[0]);
int h = 0;
for (int i = 2; h <= k && i < e_; h++, i++) {
printf("%c", s[i]);
}
for (; h < u; h++) {
printf("0");
}
printf("\n");
} else {
printf("%c", s[0]);
for (int i = 2; i <= u + 1; i++) {
printf("%c", s[i]);
}
int p = -1;
for (int i = u + 2; i < e_; i++) {
if (s[i] != '0') p = i;
}
if (p != -1) {
printf(".");
for (int i = u + 2; i <= p; i++) {
printf("%c", s[i]);
}
printf("\n");
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, i, last[28], tmp[28];
long long ans[28];
char s[300005];
int main() {
scanf("%s", s);
for (i = 0; i <= 26; i++) last[i] = -1;
int length = strlen(s);
for (i = 0; i < length; i++) {
last[s[i] - 'a'] = i;
for (int j = 0; j <= 26; j++) tmp[j] = last[j];
sort(tmp, tmp + 27);
for (int j = 26; j; j--) ans[26 - j + 1] += tmp[j] - tmp[j - 1];
}
for (i = 1; i <= 26; i++)
if (!ans[i]) break;
printf("%d\n", i - 1);
for (int j = 1; j < i; j++) printf("%I64d\n", ans[j]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l;
int d[300200];
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int boolean = 1;
cin >> n >> k >> l;
for (long long i = 1; i <= n; i++) {
cin >> d[i];
if (d[i] > l) boolean = 0;
}
int b, c;
b = k;
c = 0;
for (int i = 1; i <= n; ++i) {
int cur = min(l - d[i], k);
if (cur == k) {
b = k;
continue;
}
b = max(b + 1, 2 * k - cur);
if (b > 2 * k) {
c++;
if (cur < c) boolean = 0;
} else {
c = 0;
}
}
cout << (boolean ? "YES" : "NO") << endl;
}
}
| 2 |
/**বিসমিল্লাহির রহমানির রহীম **/
#include<bits/stdc++.h>
#define pi acos(-1.0)
#define eps 1e-9
#define ff first
#define ss second
#define nl '\n'
#define sp ' '
#define CLR(a) memset(a,0,sizeof(a))
#define SET(a) memset(a,-1,sizeof(a))
#define all(x) x.begin(),x.end()
#define allr(x) x.rbegin(),x.rend()
#define sz(x) (int)(x).size()
#define Fast_Read ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
#define Precision(x) cout.setf(ios::fixed); cout.precision(x);
using namespace std;
int dx[]={0,0,1,-1,-1,-1,1,1};
int dy[]={1,-1,0,0,-1,1,1,-1};
typedef long long ll;
template < class T> inline T bitOn(T n,T pos){return n |((T)1<<pos);}
template < class T> inline T bitOff(T n,T pos){return n & ~((T)1<<pos);}
template < class T> inline T isOn(T n,T pos){return (bool)(n & ((T)1<<pos));}
template < class T> inline T lcm(T a, T b){return (a/__gcd(a, b)) * b;}
#ifdef obaydullah
#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
template < typename Arg1 >
void __f(const char* name, Arg1&& arg1){
cerr << name << " is " << 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) << " is " << arg1 <<" | ";
__f(comma+1, args...);
}
#else
#define debug(...)
#endif
template<class T>
istream& operator>>(istream& is, vector<T>& input){
for(T& in:input) is >> in; return is;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T> &input){
bool isFirst=true;for(const T& out:input){if(isFirst){os<<out;isFirst=false;}else os<<" "<<out;}return os;
}
///******************************************START******************************************
void solve(){
int n; cin>>n;
vector<int>v(n); cin>>v;
int sub = 0;
for(int i = 1;i<n-1;i++){
if(v[i]>v[i-1] && v[i]>v[i+1]) sub++;
else if(v[i]<v[i-1] && v[i]<v[i+1]) sub++;
}
int ans = sub;
for(int i = 1;i<n-1;i++){
int x = 0, y = 0, z = 0;
int val = v[i];
for(int j = max(1, i-5);j<min(n-1, i+5);j++){
if(v[j]>v[j-1] && v[j]>v[j+1]) x++;
else if(v[j]<v[j-1] && v[j]<v[j+1]) x++;
}
v[i] = v[i-1];
for(int j = max(1, i-5);j<min(n-1, i+5);j++){
if(v[j]>v[j-1] && v[j]>v[j+1]) y++;
else if(v[j]<v[j-1] && v[j]<v[j+1]) y++;
}
v[i] = v[i+1];
for(int j = max(1, i-5);j<min(n-1, i+5);j++){
if(v[j]>v[j-1] && v[j]>v[j+1]) z++;
else if(v[j]<v[j-1] && v[j]<v[j+1]) z++;
}
v[i] = val;
ans = min(ans, sub - (x - y));
ans = min(ans, sub - (x - z));
}
cout<<ans<<nl;
}
int main(){
Fast_Read
Precision(10)
#ifdef obaydullah
double start_time = clock();
///freopen ("output.txt","w",stdout);
///freopen ("input.txt","r",stdin);
#endif
int tc=1; cin>>tc;
while(tc--){
solve();
}
#ifdef obaydullah
double end_time = clock();
cerr<<"Time = "<<fixed<<setprecision(10)<<(end_time - start_time) / CLOCKS_PER_SEC<<'\n';
#endif
return 0;
}
/**
**/
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<string, int> m;
map<string, int>::iterator it;
for (int i = 0; i < (n - 1); i++) {
string x = s.substr(i, 2);
it = m.find(x);
if (it == m.end())
m.insert({x, 1});
else
m[x]++;
}
string ans;
int max = 0;
for (it = m.begin(); it != m.end(); it++) {
if (it->second > max) {
ans = it->first;
max = it->second;
}
}
cout << ans << endl;
}
| 2 |
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#include <cmath>
using namespace std;
double prim(int n, vector< vector<double> > &G){
double ans = 0.0;
priority_queue< pair<double,int> > wait;
bool connected[n];
fill(connected,connected+n,false);
wait.push(make_pair(0.0,0));
while(!wait.empty()){
double cost = -wait.top().first;
int v = wait.top().second;
wait.pop();
if(connected[v]) continue;
ans += cost;
connected[v] = true;
for(int i = 0; i < n; ++i){
if(!connected[i]){
wait.push(make_pair(-G[v][i],i));
}
}
}
return ans;
}
int main(){
int n;
while(cin >> n, n){
double x[n], y[n], z[n], r[n];
for(int i = 0; i < n; ++i){
cin >> x[i] >> y[i] >> z[i] >> r[i];
}
vector< vector<double> > dist(n,vector<double>(n,0));
for(int i = 0; i < n; ++i){
for(int j = 0; j < n; ++j){
dist[i][j] = max(0.0,sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]))-r[i]-r[j]);
}
}
printf("%.3f\n",prim(n,dist));
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 10;
const long long mod = 998244353;
const long long inf = 2e18;
const long long INF = 2e9;
long long n, m, k;
long long F(long long m) {
if (m <= 0) return 0;
long long ans = m;
while (!(m & 1)) m >>= 1;
if (m >= INF) return inf;
return ans + m * (m - 3) / 2;
}
signed main() {
cin >> n;
set<long long> s;
for (long long t = 0; t <= 59; t++) {
long long X = (1ll << t);
long long hi = n / X + 10;
long long lo = 1;
while (hi - lo > 1) {
long long tm = (hi + lo) / 2;
if (F(X * (2 * tm - 1)) >= n)
hi = tm;
else
lo = tm;
}
lo *= 2;
lo--;
hi *= 2;
hi--;
if (F(X * lo) == n) s.insert(X * lo);
if (F(X * hi) == n) s.insert(X * hi);
if (F(X * (hi + 2)) == n) s.insert(X * (hi + 2));
if (F(X * (hi + 4)) == n) s.insert(X * (hi + 4));
}
if (s.empty())
cout << -1;
else
for (auto x : s) cout << x << "\n";
}
| 2 |
#include <cstdio>
#include <vector>
#include <algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
const ll INF=1LL<<61;
struct vertex{
int p,d;
bool operator<(const vertex &v)const{ return p!=v.p?p<v.p:d<v.d; }
};
int main(){
for(int n;scanf("%d",&n),n;){
vertex V[4000];
int d_sum=0;
rep(i,n){
scanf("%d%d",&V[i].p,&V[i].d);
d_sum+=V[i].d;
}
sort(V,V+n);
// corner case
if(n==2){ printf("%d\n",abs(V[1].p-V[0].p)); continue; }
// impossible
if(d_sum<2*n-2){ puts("-1"); continue; }
int n1=0,n2=0;
vertex V1[4000],V2[4000];
rep(i,n){
if(V[i].d==1) V1[n1++]=V[i];
else V2[n2++]=V[i];
}
vector<int> p1,p2;
rep(i,n1) p1.push_back(V1[i].p);
rep(i,n2){
int d=V2[i].d;
if(i> 0 ) d--;
if(i<n2-1) d--;
rep(_,d) p2.push_back(V2[i].p);
}
// O(n^3) time, O(n^3) space solution
/*
// dp[i+1][j+1] := ( p1[0..i] からいくつかを使って p2[0..j] をすべてマッチさせるときの最小コスト )
vector< vector<ll> > dp(p2.size()+1,vector<ll>(p1.size()+1,INF));
rep(i,p2.size()+1) dp[i][0]=0;
rep(i,p2.size()) rep(j,p1.size()) {
dp[i+1][j+1]=min(dp[i][j+1],dp[i][j]+abs(p2[i]-p1[j]));
}
*/
// O(n^3) time, O(n) space solution
/*
// j についてのループを逆向きに回すことで, dp 配列の i 方向を使いまわす
ll dp[4001];
rep(j,p1.size()+1) dp[j]=(j==0?0:INF);
rep(i,p2.size()){
for(int j=(int)p1.size()-1;j>=0;j--) dp[j+1]=min(dp[j+1],dp[j]+abs(p2[i]-p1[j]));
}
*/
// O(n^2) time, O(n) space solution
int Left[4000],Right[4000]; // V1[i] とマッチさせる V2 の候補は V2[Left[i]..Right[i]-1]
rep(i,n1){
int cost_min=abs(V1[i].p-V2[0].p),j0=0;
rep(j,n2) if(cost_min>abs(V1[i].p-V2[j].p)) {
cost_min=abs(V1[i].p-V2[j].p);
j0=j;
}
int cen=lower_bound(p2.begin(),p2.end(),V2[j0].p)-p2.begin();
Left [i]=max(cen-n1,0);
Right[i]=min(cen+n1,(int)p2.size());
}
ll dp[4001];
int jl=0,jr=0; // p2[i] とマッチさせる p1 の候補は p1[jl..jr-1]
rep(j,p1.size()+1) dp[j]=(j==0?0:INF);
rep(i,p2.size()){
// update jl, jr
for(;jl<p1.size();jl++) if(i<Right[jl]) break;
for(;jr<p1.size();jr++) if(i< Left[jr]) break;
// update dp[]
for(int j=jr-1;j>=jl;j--) dp[j+1]=min(dp[j+1],dp[j]+abs(p2[i]-p1[j]));
}
printf("%lld\n",dp[p1.size()]+p2.back()-p2.front());
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long change[30][30];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s, t, ans = "";
cin >> s >> t;
char a, b;
long long n, i, j, k, l, sum = 0, min1, imin;
cin >> n;
for (i = 1; i <= 26; i++) {
for (j = 1; j <= 26; j++) {
if (i == j) {
change[i][j] = 0;
} else {
change[i][j] = inf;
}
}
}
for (i = 1; i <= n; i++) {
cin >> a >> b >> j;
change[a - 'a' + 1][b - 'a' + 1] = min(change[a - 'a' + 1][b - 'a' + 1], j);
}
for (i = 1; i <= 26; i++) {
for (j = 1; j <= 26; j++) {
for (k = 1; k <= 26; k++) {
if (change[j][k] > change[j][i] + change[i][k]) {
change[j][k] = change[j][i] + change[i][k];
}
}
}
}
if (s.length() != t.length()) {
cout << -1;
return 0;
}
for (i = 0; i < s.length(); i++) {
min1 = inf;
imin = 0;
k = s[i] - 'a' + 1;
l = t[i] - 'a' + 1;
for (j = 1; j <= 26; j++) {
if (min1 > change[k][j] + change[l][j]) {
imin = j;
min1 = change[k][j] + change[l][j];
}
}
sum += min1;
a = imin + 'a' - 1;
ans += a;
if (min1 == inf) {
cout << -1;
return 0;
}
}
cout << sum << endl << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
set<int> h, w;
vector<int> ans;
scanf("%d", &n);
for (int i = 0; i < n * n; i++) {
scanf("%d%d", &x, &y);
if (h.find(x) == h.end() && w.find(y) == w.end()) {
ans.push_back(i + 1);
h.insert(x);
w.insert(y);
}
}
for (int i = 0; i < ans.size(); i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, p = 1e9 + 7;
int n, m;
int a[N][N], shr[N][N], slr[N][N], f[N][N][2], shf[N][N], slf[N][N];
char s[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) {
if (s[j] == 'R')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
if (n == 1 && m == 1) {
printf("1");
return 0;
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
shr[i][j] = shr[i][j + 1] + a[i][j];
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
slr[i][j] = slr[i + 1][j] + a[i][j];
}
}
if (a[n][m]) {
printf("0");
return 0;
}
f[n][m][0] = f[n][m][1] = 1;
shf[n][m] = 1, slf[n][m] = 1;
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (i == n && j == m) continue;
int t = m - shr[i][j + 1] + 1;
f[i][j][0] = (shf[i][j + 1] - shf[i][t] + p) % p;
t = n - slr[i + 1][j] + 1;
f[i][j][1] = (slf[i + 1][j] - slf[t][j] + p) % p;
slf[i][j] = (slf[i + 1][j] + f[i][j][0]) % p;
shf[i][j] = (shf[i][j + 1] + f[i][j][1]) % p;
}
}
printf("%d", (f[1][1][0] + f[1][1][1]) % p);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main()
{ string s;
cin>>s;
int n=s.size();
if(s.substr(0,(n-1)/2)==s.substr((n+3)/2-1))
{
cout<<"Yes"<<endl;
}
else
{cout<<"No"<<endl;}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105000;
const double eps = 1e-12;
struct point {
double x, y;
int idx;
};
bool cmp(point a, point b) { return (a.x < b.x || (a.x == b.x && a.y < b.y)); }
bool eq(double a, double b) { return abs(a - b) <= eps; }
double crossProduct(point a, point b, point c) {
return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);
}
bool isCCW(point a, point b, point c) {
return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) >= 0;
}
int n;
int x[MAXN], y[MAXN];
vector<point> p, hull;
int main() {
scanf("%d", &n);
p.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &x[i], &y[i]);
p[i].x = x[i];
p[i].y = y[i] - 1.0 * x[i] * x[i];
p[i].idx = i;
}
sort(p.begin(), p.end(), cmp);
vector<point> up;
point head = p[0], tail = p.back();
up.push_back(head);
for (int i = 1; i < (int)p.size(); i++) {
if (i == (int)p.size() - 1 || !isCCW(tail, head, p[i])) {
while ((int)up.size() >= 2 && isCCW(up[up.size() - 2], up.back(), p[i]))
up.pop_back();
if ((int)up.size() > 0 && eq(up.back().x, p[i].x)) up.pop_back();
up.push_back(p[i]);
}
}
cout << (int)up.size() - 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
int n,q;cin>>n>>q;
vector<ll> v;
v.push_back(n);
while(q--){
ll a;cin>>a;
while(v.size()&&v.back()>=a)v.pop_back();
v.push_back(a);
}
int L=v.size();
vector<ll> t(L,0),ans(n+1,0);
t[L-1]=1;
for(int i=L-1;i>=0;i--){
ll k=v[i];
int j=i;
while(j){
if(v[0]>k)break;
int l=0,r=j;
while(r-l>1){
int mid=(r+l)>>1;
(v[mid]>k?r:l)=mid;
}
t[l]+=t[i]*(k/v[l]);
k%=v[l];
j=l;
}
ans[0]+=t[i];
ans[k]-=t[i];
}
for(int i=0;i<n;i++){
cout<<ans[i]<<endl;
ans[i+1]+=ans[i];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
int nq;
cin >> n >> nq;
while (nq--) {
long long iq;
cin >> iq;
for (long long s = (n - iq) + (iq - 1) / 2; !(iq % 2); s /= 2) iq += s + 1;
cout << (iq + 1) / 2 << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, i, j;
cin >> n >> m;
for (i = 0; i < 2225; i++) printf("1");
puts("");
for (i = 0; i < 2224; i++) printf("8");
printf("9");
puts("");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a <= b ? true : false;
}
template <class T>
bool uax(T &a, T b) {
return a >= b ? true : false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
long long H;
int n;
cin >> H >> n;
vector<long long> a(n);
long long sum = 0;
long long gap = 0;
long long h = H;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum -= a[i];
h += a[i];
if (h <= 0) {
cout << i + 1 << endl;
return 0;
}
gap = max(gap, sum);
}
if (sum <= 0) {
cout << -1 << endl;
return 0;
}
long long whole = (H - gap) / sum;
H -= whole * sum;
long long result = whole * n;
for (int i = 0;; i++) {
H += a[i % n];
result++;
if (H <= 0) {
cout << result << endl;
break;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 101;
vector<pair<int, int> > G[mxN];
int vis[mxN];
void dfs(int u, int ci) {
vis[u] = 1;
for (pair<int, int> to : G[u]) {
int v = to.first;
int col = to.second;
if (!vis[v] && ci == col) dfs(v, ci);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
G[u].push_back({v, c});
G[v].push_back({u, c});
}
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
int cnt = 0;
for (int i = 1; i <= m; i++) {
memset(vis, 0, sizeof(vis));
dfs(u, i);
if (vis[v]) cnt++;
}
cout << cnt << endl;
}
}
| 4 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
vector<long long int>sizes;
vector<vector<int>>edges;
int dfs(const int now) {
long long int num = sizes[now];
for (auto e : edges[now]) {
num += dfs(e);
}
return sizes[now] = num;
}
long long int dfs2(const int now) {
vector<long long >v;
long long int ans = 0;
for (auto e : edges[now]) {
v.emplace_back(sizes[e]);
}
sort(v.begin(), v.end());
int sum = 0;
for (int i = 0; i < v.size(); ++i) {
ans += sum;
sum += v[i];
}
return ans;
}
int main() {
int N; cin >> N;
edges.resize(N);
sizes.resize(N);
vector<int>roots;
vector<int>nums(N);
vector<vector<int>>revedges(N);
for (int i = 0; i < N; ++i) {
int M, L; cin >> M >> L;
sizes[i] = M;
if (L != -1) {
edges[L].push_back(i);
revedges[i].push_back(L);
nums[L]++;
}
else {
roots.emplace_back(i);
}
}
queue<int>que;
for (int i = 0; i < nums.size(); ++i) {
if (!nums[i])que.push(i);
}
while (!que.empty()) {
const int now = que.front();
que.pop();
long long int num = sizes[now];
for (auto e : edges[now]) {
num += sizes[e];
}
for (auto re : revedges[now]) {
nums[re]--;
if (!nums[re])que.push(re);
}
sizes[now] = num;
}
long long int ans = 0;
for (int i = 0; i < N;++i) {
ans += dfs2(i);
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char s[2200];
cin >> s;
int l = strlen(s);
int i = 0;
int total = 0;
for (i = 1; i < l; i++) {
if (i % n == 0) {
if (s[i - 1] == s[i - 2] && s[i - 2] == s[i - 3]) total++;
}
}
cout << total;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, x[100001], y[100001];
unsigned long long getSum(int *h) {
unsigned long long sum = 0, sumH = 0;
for (int i = 0; i < n; i++) {
sum += (unsigned long long)h[i] * (unsigned long long)h[i] * (n - 1);
sum -= 2ULL * (unsigned long long)h[i] * sumH;
sumH += h[i];
}
return sum;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &x[i], &y[i]);
unsigned long long sum = getSum(x) + getSum(y);
printf("%I64d\n", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int mod = 1000000007;
const double pi = acos(-1);
const long long OO = INT_MAX;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
int n;
cin >> n;
int prev = 0;
int cur = 0;
int col = 2;
vector<vector<int> > ans;
while (cur >= prev) {
vector<vector<int> > arr;
vector<int> temp;
for (int i = 0; i < col; i++) temp.push_back(i + 1);
int cc = col + 1;
arr.push_back(temp);
int c = 0;
while (c <= col) {
temp.clear();
for (int i = 0; i < arr.size(); i++) temp.push_back(arr[i][c]);
while (temp.size() < col) {
temp.push_back(cc);
cc++;
}
c++;
if (temp.size() > col || temp.back() > n) break;
arr.push_back(temp);
}
prev = cur;
cur = arr.size();
col++;
if (cur >= prev) ans = arr;
}
cout << prev << '\n';
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j] << ' ';
cout << '\n';
}
}
| 3 |
#include <stdio.h>
typedef long long ll;
int main(void) {
ll i, j, k, n, m, ra, rb, na, nb;
scanf("%lld%lld%lld", &n, &m, &k);
ll uf[n], a[m], b[m], c, d, ans[n];
for(i = 0; i < n; ++i) uf[i] = i, ans[i] = 0;
for(i = 0; i < m; ++i) {
scanf("%lld%lld", &a[i], &b[i]);
a[i]--, b[i]--;
na = a[i], nb = b[i], ra = 0, rb = 0;
while(uf[na] != na) na = uf[na], ra++;
while(uf[nb] != nb) nb = uf[nb], rb++;
uf[a[i]] = na, uf[b[i]] = nb;
if(na != nb) {
if(ra < rb) uf[na] = nb;
else uf[nb] = na;
}
}
for(i = 0; i < n; ++i) {
na = i;
while(uf[na] != na) na = uf[na];
uf[i] = na;
ans[na]++;
}
for(i = 0; i < n; ++i) ans[i] = ans[uf[i]];
for(i = 0; i < m; ++i) ans[a[i]]--, ans[b[i]]--;
for(i = 0; i < k; ++i) {
scanf("%lld%lld", &c, &d);
c--, d--;
if(uf[c] == uf[d]) ans[c]--, ans[d]--;
}
for(i = 0; i < n; ++i) printf("%lld ", ans[i] - 1);
return 0;
} | 0 |
#include <iostream>
#include <cmath>
using namespace std;
int main(void)
{
double x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
cout.setf(ios::fixed, ios::floatfield);
cout<<sqrt(pow(x1-x2,2.0)+pow(y1-y2,2.0));
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a14;
inline int rd(int l, int r) { return rand() % (r - l + 1) + l; }
const int mxn = 5e5 + 3;
int to[mxn * 2], nxt[mxn * 2], fir[mxn], gn = 1, n, m;
void gadd(int x, int y) {
to[++gn] = y, nxt[gn] = fir[x], fir[x] = gn, to[++gn] = x, nxt[gn] = fir[y],
fir[y] = gn;
}
int dfn[mxn], low[mxn], dn, tk[mxn], sn, be[mxn], bn, eh[mxn], e2[mxn];
int dp[mxn];
int xl[mxn * 2], xn, h1[mxn], h2[mxn], vd[mxn], vv[mxn];
void tar(int x, int e = 0) {
dfn[x] = low[x] = ++dn, tk[++sn] = x;
for (register int i = fir[x]; i; i = nxt[i]) {
int y = to[i];
if (!dfn[y]) {
tar(y, i ^ 1), eh[y] = i, low[x] = min(low[x], low[y]);
if (low[y] > dfn[x])
--sn;
else if (low[y] == dfn[x]) {
++bn;
xn = 0;
int z = e2[tk[sn]];
be[z >> 1] = bn, xl[++xn] = z >> 1;
do z = eh[tk[sn--]], be[z >> 1] = bn, xl[++xn] = z >> 1;
while (to[z] != y);
int mn = 1e9, mx = 0, t1, t2;
for (int j = 1, k; j <= xn; ++j) {
k = xl[j];
if (k < mn) mn = k, t2 = j;
if (k > mx) mx = k, t1 = j;
}
for (int j = 1; j <= xn; ++j) xl[j + xn] = xl[j];
h1[bn] = mx, h2[bn] = mn;
bool ok = 1;
if (t1 > t2) t2 += xn;
assert(t1 < t2);
for (int j = t1 + 1; j < t2; ++j) ok &= xl[j] < xl[j - 1];
for (int j = t2 + 1; j < t1 + xn; ++j) ok &= xl[j] > xl[j - 1];
vd[bn] = ok;
}
} else if (i != e && dfn[y] < low[x])
low[x] = dfn[y], e2[x] = i;
}
}
int main() {
a14 = scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; ++i) a14 = scanf("%d%d", &x, &y), gadd(x, y);
tar(1);
for (int i = 1; i <= n; ++i) assert(dfn[i]);
for (int i = 1; i <= n; ++i) dp[i] = 1;
for (int i = m; i; --i) {
int x = to[i * 2], y = to[i * 2 + 1], H = dp[x] + dp[y];
dp[x] = dp[y] = H;
if (be[i]) {
int k = be[i];
if (i == h2[k] && vd[k])
dp[x] -= vv[k], dp[y] -= vv[k];
else if (i == h1[k])
vv[k] = H;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", dp[i] - 1);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Dian = 200005;
const int Bian = Dian * 2;
const int M = Dian;
const int Segment_Size = Dian * 4;
int fir[Dian], ne[Bian], to[Bian], cnt, n, m;
int dp[Dian], depth[Dian], fa[Dian], Bigson[Dian], top[Dian], S[Dian],
dep[Dian], info[Dian];
struct One {
int from, to, C, LCA;
} Road[M];
vector<One> G[Dian];
void add(int x, int y) {
ne[++cnt] = fir[x];
fir[x] = cnt;
to[cnt] = y;
}
void getinfo(int x, int f) {
S[x] = 1;
dep[x] = dep[f] + 1;
int mx = -1;
for (int i = fir[x]; i; i = ne[i]) {
int V = to[i];
getinfo(V, x);
if (S[V] > mx) Bigson[x] = V, mx = S[V];
S[x] += S[V];
}
}
void getidx(int x, int T) {
top[x] = T;
if (Bigson[x]) getidx(Bigson[x], T);
for (int i = fir[x]; i; i = ne[i]) {
int V = to[i];
if (V == Bigson[x]) continue;
getidx(V, V);
}
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
if (dep[y] < dep[x]) return y;
return x;
}
void read(void) {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++) {
scanf("%d", &fa[i]);
add(fa[i], i);
}
getinfo(1, 0);
getidx(1, 1);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &Road[i].from, &Road[i].to, &Road[i].C);
Road[i].LCA = LCA(Road[i].from, Road[i].to);
G[Road[i].LCA].push_back(Road[i]);
}
}
int getans(One Query) {
int x = Query.from, y = Query.to, now = Query.C;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
now = now + info[top[x]] - info[Bigson[x]];
x = fa[top[x]];
}
if (dep[x] > dep[y]) swap(x, y);
now = now + info[x] - info[Bigson[y]];
return now;
}
int dfs(int x, int f) {
int sum = 0;
for (int i = fir[x]; i; i = ne[i]) sum += dfs(to[i], x);
info[x] = info[Bigson[x]] + sum;
dp[x] = sum;
for (int i = 0; i < (int)G[x].size(); i++)
dp[x] = max(dp[x], getans(G[x][i]));
info[x] -= dp[x];
return dp[x];
}
void doit(void) { printf("%d\n", dfs(1, 0)); }
int main(void) {
read();
doit();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "white" << endl;
cout << "1 2" << endl;
} else {
cout << "black" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int x, y;
cin >> x >> y;
if (min(min(x - 1, n - x), min(y - 1, m - y)) <= 4) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include<iostream>
#include<string>
using namespace std;
char map[20][20];
int dx[4]={0,0,-1,1},dy[4]={-1,1,0,0};
char dm[4]={'^','v','<','>'};
int main(){
int t;
cin>>t;
for(int r=0;r<t;r++){
if(r!=0)cout<<endl;
int h,w;
cin>>h>>w;
int set,x,y;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cin>>map[i][j];
for(int k=0;k<4;k++){
if(map[i][j]==dm[k]){
set=k;
y=i;
x=j;
map[i][j]='.';
}
}
}
}
int n;
char z;
cin>>n;
for(int u=0;u<n;u++){
cin>>z;
if(z=='U'){
set=0;
}
if(z=='D'){
set=1;
}
if(z=='L'){
set=2;
}
if(z=='R'){
set=3;
}
if(z=='S'){
int f=y,g=x;
while(true){
if(f<0||f==h||g<0||g==w){
break;
}
if(map[f][g]=='*'){
map[f][g]='.';
break;
}
if(map[f][g]=='#'){
break;
}
f+=dy[set];
g+=dx[set];
}
}
else{
if(y+dy[set]>=0&&y+dy[set]<h&&x+dx[set]>=0&&x+dx[set]<w){
if(map[y+dy[set]][x+dx[set]]=='.'){
y+=dy[set];
x+=dx[set];
}
}
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(i==y&&j==x){
cout<<dm[set];
}
else{
cout<<map[i][j];
}
}
cout<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int speeds[101];
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> speeds[i];
}
sort(speeds, speeds + n);
cout << speeds[n - k] << endl;
return 0;
}
| 2 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
int q;
cin >> q;
while(q--){
string s, t;
cin >> s >> t;
const int n = s.size();
if(s == t){
cout << 0 << endl;
continue;
}
int f = 0, b = n - 1, a = n - 1;
while(s[f] == t[f]){ ++f; }
while(s[b] == '0'){ --b; }
while(t[a] == '0'){ --a; }
int answer = 0;
while(b > f){
if(s[b - 1] == '1'){
s[b] = '0';
}else{
s[b - 1] = '1';
s[b] = '0';
}
--b;
++answer;
}
while(b < a){
if(s[b] == '0'){
s[b] = '0';
s[b + 1] = '1';
}else{
s[b + 1] = '1';
}
++b;
++answer;
}
while(b > a){
if(s[b - 1] == '0'){
s[b] = '0';
s[b - 1] = '1';
}else{
s[b] = '0';
}
--b;
++answer;
}
cout << answer << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m = 998244353) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
long long inverse(long long a, long long m = 998244353) {
return power(a, m - 2, m);
}
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
set<int> ss;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i]) ss.insert(a[i]);
}
for (int i = 0; i < n; i++) cin >> b[i];
int curr = 0;
if (!ss.count(1)) {
set<int> tss = ss;
vector<int> c = b;
int pos;
for (int i = 0; i < n; i++)
if (c[i] == 1) pos = i;
bool ans = true;
for (int i = 0; i < pos; i++) {
int d = (n + i - pos) % n + 1;
if (!tss.count(d)) {
ans = false;
break;
}
tss.erase(d);
tss.insert(c[i]);
c[i] = d;
}
for (int i = (pos + 1) % n; i != pos; i = (i + 1) % n) {
int d = (n + i - pos) % n + 1;
if (c[i] != d) {
ans = false;
break;
}
}
if (ans) {
cout << pos << endl;
return 0;
}
curr = pos + 1;
}
int ans = curr;
for (int i = curr; i < n; i++) {
if (!b[i]) continue;
int temp = i - b[i] + 2;
ans = max(ans, temp);
}
cout << ans + n << endl;
}
| 1 |
#include <cstdio>
#include <iostream>
#define ll long long
using namespace std;
const int N=1e6+10;
ll sum[N][2],num[N];
char str[N];
int n;
int main ()
{
scanf("%d%s",&n,str+1);
for(int i=1;i<=n;i++)
sum[i][0]=sum[i-1][0]+(str[i]=='M'),sum[i][1]=sum[i-1][1]+(str[i]=='C'),num[i]=num[i-1]+(str[i]=='C')*sum[i][0];
int q,m; scanf("%d",&q);
while(q--)
{
scanf("%d",&m);
ll ans=0;
for(int i=1;i<=n;i++)
if(str[i]=='D')
{
int r=min(n,i+m-1);
ans+=num[r]-num[i]-sum[i][0]*(sum[r][1]-sum[i][1]);
}
printf("%lld\n",ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct cell {
long long root_vertix, com_len;
cell() {}
cell(long long x, long long y) {
root_vertix = x;
com_len = y;
}
bool operator<(const cell &x) const { return com_len < x.com_len; }
};
long long root[100002];
long long n, m, p, q;
long long find_root(long long x) {
if (root[x] <= 0) return x;
return root[x] = find_root(root[x]);
}
bool merge(long long x, long long y, long long len) {
x = find_root(x);
y = find_root(y);
if (x == y) {
root[x] -= len;
return false;
} else {
root[x] = root[x] - len + root[y];
root[y] = x;
return 1;
}
}
int main() {
cin >> n >> m >> p >> q;
long long components = n;
fill(root, root + n + 1, 0);
for (int i = 0; i < m; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (merge(x, y, z)) components--;
}
if (components < q || p < (components - q) ||
(components == n && q == n && p > 0)) {
cout << "NO" << endl;
return 0;
} else
cout << "YES" << endl;
priority_queue<cell> qq;
for (int i = 1; i <= n; i++)
if (root[i] <= 0) qq.push(cell(i, root[i]));
long long diff = components - q;
long long same = p - diff;
while (diff--) {
cell x, y;
x = qq.top();
qq.pop();
y = qq.top();
qq.pop();
long long len = min((long long)1000000000, -x.com_len - y.com_len + 1);
cout << x.root_vertix << " " << y.root_vertix << endl;
merge(x.root_vertix, y.root_vertix, len);
x.com_len = root[x.root_vertix];
qq.push(x);
}
long long vertix;
for (int i = 1; i <= n; i++)
if (root[i] > 0) {
vertix = i;
break;
}
while (same--) cout << vertix << " " << root[vertix] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x1, x2;
while (cin >> n >> x1 >> x2) {
vector<pair<int, int> > arr(n, pair<int, int>());
for (int i = 0; i < n; i++) {
cin >> arr[i].first;
arr[i].second = i;
}
sort(arr.begin(), arr.end(), greater<pair<int, int> >());
int ind = 0, ind1 = 0;
bool bisa = false, bisa1 = false;
for (int i = 0; i < n; i++) {
if (x1 > x2) {
double haha = (double)x1 / (i + 1);
if (arr[i].first >= haha) {
ind = i;
bisa = true;
break;
}
} else {
double haha = (double)x2 / (i + 1);
if (arr[i].first >= haha) {
ind = i;
bisa = true;
break;
}
}
}
if (bisa) {
for (int i = ind + 1; i < n; i++) {
if (x1 > x2) {
double haha = (double)x2 / (i + 1 - ind - 1);
if (arr[i].first >= haha) {
ind1 = i;
bisa1 = true;
break;
}
} else {
double haha = (double)x1 / (i + 1 - ind - 1);
if (arr[i].first >= haha) {
ind1 = i;
bisa1 = true;
break;
}
}
}
}
if (bisa && bisa1) {
cout << "Yes" << endl;
if (x1 > x2) {
cout << ind + 1 << " " << abs(ind1 - ind) << endl;
for (int i = 0; i <= ind; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
for (int i = ind + 1; i <= ind1; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
} else {
cout << abs(ind1 - ind) << " " << ind + 1 << endl;
for (int i = ind + 1; i <= ind1; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
for (int i = 0; i <= ind; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
}
} else {
int ind = 0, ind1 = 0;
bool bisa = false, bisa1 = false;
for (int i = 0; i < n; i++) {
if (x1 < x2) {
double haha = (double)x1 / (i + 1);
if (arr[i].first >= haha) {
ind = i;
bisa = true;
break;
}
} else {
double haha = (double)x2 / (i + 1);
if (arr[i].first >= haha) {
ind = i;
bisa = true;
break;
}
}
}
if (bisa) {
for (int i = ind + 1; i < n; i++) {
if (x1 < x2) {
double haha = (double)x2 / (i + 1 - ind - 1);
if (arr[i].first >= haha) {
ind1 = i;
bisa1 = true;
break;
}
} else {
double haha = (double)x1 / (i + 1 - ind - 1);
if (arr[i].first >= haha) {
ind1 = i;
bisa1 = true;
break;
}
}
}
}
if (bisa && bisa1) {
cout << "Yes" << endl;
if (x1 < x2) {
cout << ind + 1 << " " << abs(ind1 - ind) << endl;
for (int i = 0; i <= ind; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
for (int i = ind + 1; i <= ind1; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
} else {
cout << abs(ind1 - ind) << " " << ind + 1 << endl;
for (int i = ind + 1; i <= ind1; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
for (int i = 0; i <= ind; i++) {
cout << arr[i].second + 1 << " ";
}
cout << endl;
}
} else {
cout << "No" << endl;
}
}
}
return 0;
}
| 2 |
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <queue>
#include <set>
#include <map>
#include <complex>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define MP make_pair
#define PB push_back
#define inf 1000000007
#define rep(i,n) for(int i=0;i<(int)(n);++i)
typedef complex<double> C;
namespace std
{
bool operator < (const C a, const C b) {
return a.real() != b.real() ? a.real() < b.real() : a.imag() < b.imag();
}
}
//??£??????
C normalize(C c)
{
return c / abs(c);
}
//?§????(rad)
double getarg(C a,C b){
return arg(b*conj(a));
}
//??????
double cross(const C a, const C b)
{
return imag(conj(a)*b);
}
//??????
double dot(const C a, const C b)
{
return real(conj(a)*b);
}
int ccw(C a, C b, C c)
{
b -= a; c -= a;
if(cross(b, c) > 0) return +1; // counter clockwise
if(cross(b, c) < 0) return -1; // clockwise
if(dot(b, c) < 0) return +2; // c--a--b on line
if(norm(b) < norm(c)) return -2; // a--b--c on line
return 0; //b--a--c on line
}
vector<C> convex_hull(vector<C> ps)
{
int n = (int)ps.size(), k = 0;
sort(ps.begin(), ps.end());
vector<C> ch(2*n);
for (int i = 0; i < n; ch[k++] = ps[i++]){
while (k >= 2 && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) k--;
}
for (int i = n-2, t = k+1; i >= 0; ch[k++] = ps[i--]){
while (k >= t && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) k--;
}
ch.resize(k-1);
return ch;
}
int contains(const vector<C>& ps, const C p)
{
bool flag = false;
rep(i,ps.size()) {
C a = ps[i] - p, b = ps[(i+1)%ps.size()] - p;
if (imag(a) > imag(b)) swap(a, b);
if (imag(a) <= 0 && 0 < imag(b)){
if (cross(a, b) < 0) flag = !flag;
}
if (cross(a, b) == 0 && dot(a, b) <= 0) return 1;
}
return flag ? 2 : 0;
}
int main(){
int n;
cin >> n;
vector<double>x(n),y(n);
rep(i,n){
cin >> x[i] >> y[i];
}
bool flag = 0;
for(int i=0;i<n;i++){
vector<C> ps;
vector<C> conv;
for(int j=0;j<i;j++){
complex<double> z(x[j],y[j]);
ps.push_back(z);
}
complex<double> z(x[i],y[i]);
if(ps.size()>2){
conv = convex_hull(ps);
if(contains(conv,z)==2){
flag = 1;
break;
}
}
vector<C> ps2;
for(int j=i+1;j<n;j++){
complex<double> z(x[j],y[j]);
ps2.push_back(z);
}
if(ps2.size()>2){
conv = convex_hull(ps2);
if(contains(conv,z)==2){
flag = 1;
break;
}
}
}
if(flag){
cout << "Impossible" << endl;
}else{
cout << "Possible" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<pair<int, int>> b;
for (int i = 1; i <= 100; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (abs(a[j] - i) > 1) sum += abs(a[j] - i) - 1;
}
b.push_back(make_pair(sum, i));
}
sort(b.begin(), b.end());
cout << b[0].second << " " << b[0].first;
return 0;
}
| 1 |
#include <bits/stdc++.h>
static int solve();
using ll = long long;
int main(int argc, char* argv[]) {
int tc = 1;
while (tc--) solve();
return 0;
}
static constexpr int MOD = 998244353;
const int N = 5005;
int tp[N][N];
int fact[N];
int n, ans[N];
static int solve() {
scanf("%d", &n);
tp[1][1] = 1;
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= i; ++j)
tp[i][j] =
(j * 1LL * tp[i - 1][j] + (i - j + 1) * 1LL * tp[i - 1][j - 1]) % MOD;
}
fact[n] = 1;
for (int i = n; i > 1; --i) fact[i - 1] = fact[i] * 1LL * i % MOD;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= i; ++j) {
ans[j] = (ans[j] + fact[i] * 1LL * tp[i][j]) % MOD;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n + 1), b(n + 1), c(n + 1), ans(n + 1);
for (long long i = 1; i <= n; ++i) cin >> a[i];
for (long long i = 1; i <= n; ++i) cin >> b[i];
for (long long i = 1; i <= n; ++i) cin >> c[i];
ans[1] = a[1];
for (long long i = 2; i <= n; ++i) {
if (ans[i - 1] != a[i] && a[i] != ans[1]) {
ans[i] = a[i];
} else if (ans[i - 1] != b[i] && b[i] != ans[1]) {
ans[i] = b[i];
} else if (ans[i - 1] != c[i] && c[i] != ans[1]) {
ans[i] = c[i];
}
}
for (long long i = 1; i <= n; ++i) {
cout << ans[i] << ' ';
}
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
long long a[10000];
cin >> N;
for (int i = 0; i < N; i++) scanf("%lld", &a[i]);
sort(a, a + N);
long long int ans = a[N - 1] - a[0] + 1 - N;
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, p[222][222];
string s, r[222];
bool f[222][222];
int main() {
cin >> m >> a >> b;
cin >> s;
n = s.size();
f[0][0] = true;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
for (int k = a; k <= b; k++)
if (j >= k && f[i - 1][j - k]) {
f[i][j] = true;
p[i][j] = k;
break;
}
if (!f[m][n]) {
cout << "No solution";
return 0;
}
int i = n;
for (int j = m - 1; j >= 0; j--) {
int k = p[j + 1][i];
r[j] = s.substr(i - k, k);
i -= k;
}
for (int i = 0; i < m; i++) cout << r[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200100], pos;
long long ans;
map<int, int> cnt;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == m) pos = i;
}
int x = 0, y = 0;
cnt[0]++;
for (int i = pos - 1; i >= 1; i--) {
if (a[i] > m)
x++;
else
y++;
cnt[x - y]++;
}
int bal = 0;
ans += cnt[0];
for (int i = pos + 1; i <= n; i++) {
if (a[i] > m)
bal++;
else
bal--;
ans += cnt[-bal];
}
bal = 0;
ans += cnt[1];
for (int i = pos + 1; i <= n; i++) {
if (a[i] > m)
bal++;
else
bal--;
ans += cnt[-bal + 1];
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
int total = 0;
for (int i = 0; i < n; i++) {
int cur;
cin >> cur;
cur = 86400 - cur;
total += cur;
if (total >= t) {
cout << i + 1 << endl;
return 0;
}
}
return 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000009, mn = 101000;
int n, m, k, Q, i, j, rt;
int lg[mn], h[mn][20];
int l[mn], r[mn], le[mn], ri[mn];
pair<int, int> a[mn], f[mn];
bool cmp(int i, int j) { return a[i].second < a[j].second; }
void RMQ() {
int i, j;
for (i = 1; i <= n; ++i) h[i][0] = i;
for (j = 1; j <= lg[n]; ++j)
for (i = 1; i <= n - (1 << j) + 1; ++i)
h[i][j] = max(h[i][j - 1], h[i + (1 << (j - 1))][j - 1], cmp);
}
int ask(int i, int j) {
if (i > j) return -1;
int k = lg[j - i + 1];
return max(h[i][k], h[j - (1 << k) + 1][k], cmp);
}
int build(int x, int y) {
if (x > y) return 0;
int rt = ask(x, y);
le[rt] = build(x, rt - 1);
ri[rt] = build(rt + 1, y);
l[rt] = a[x].first, r[rt] = a[y].first;
int L = le[rt], R = ri[rt];
if (!L && !R)
f[rt].first = f[rt].second = 0;
else if (!L)
f[rt].first = max(f[R].first, f[R].second + 1), f[rt].second = f[R].first;
else if (!R)
f[rt].first = max(f[L].first, f[L].second + 1), f[rt].second = f[L].first;
else {
f[rt].second = f[L].first + f[R].first;
f[rt].first = max(f[rt].second, 1 + max(f[L].first + f[R].second,
f[L].second + f[R].first));
}
return rt;
}
pair<int, int> query(int t, int x, int y) {
if (!t || x > r[t] || y < l[t]) return make_pair(0, -1);
if (x <= l[t] && y >= r[t]) return f[t];
if (y < a[t].first) return query(le[t], x, y);
if (x > a[t].first) return query(ri[t], x, y);
pair<int, int> res, f1 = query(le[t], x, y), f2 = query(ri[t], x, y);
res.second = f1.first + f2.first;
res.first = res.second;
if (f1.second != -1) res.first = max(res.first, 1 + f1.second + f2.first);
if (f2.second != -1) res.first = max(res.first, 1 + f1.first + f2.second);
return res;
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= k; ++i) scanf("%d%d", &a[i].first, &a[i].second);
int A, B, C, D;
scanf("%d%d%d%d", &A, &B, &C, &D);
for (i = k + 1; i <= n; ++i) {
a[i].first = ((long long)A * a[i - 1].first + B) % mo;
a[i].second = ((long long)C * a[i - 1].second + D) % mo;
}
sort(a + 1, a + 1 + n);
lg[1] = 0;
for (i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
RMQ();
rt = build(1, n);
scanf("%d", &Q);
while (Q--) {
scanf("%d%d", &i, &j);
pair<int, int> res = query(rt, i, j);
printf("%d\n", res.first);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int t, a, b, c, d;
cin >> t >> a >> b >> c >> d;
if ((a - b) * t <= c + d && (a + b) * t >= c - d)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 100000;
vector<int> g[MAXN + 1];
int used[MAXN + 1], ptr[MAXN + 1], deg[MAXN + 1], was[MAXN + 1];
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
set<pair<int, int> > s;
for (int i = 1; i <= n; i++) {
if ((int)g[i].size() == 1) s.insert({1, i});
deg[i] = (int)g[i].size();
}
set<pair<int, int> > ss;
for (int t = 0; !s.empty(); t++) {
int v = s.begin()->second;
int cnt = s.begin()->first;
if (deg[v] != 1 || used[v]) {
ss.insert({cnt, v});
s.erase(s.begin());
continue;
}
used[v] = 1;
for (int i = ptr[v]; i < (int)g[v].size(); i++, ptr[v]++) {
int u = g[v][i];
if (!used[u]) {
s.erase(s.begin());
if (s.find(make_pair(cnt + 1, u)) != s.end() ||
(deg[v] == 1 && !was[u])) {
if (s.find(make_pair(cnt + 1, u)) == s.end()) was[u] = 1;
deg[u]--;
}
s.insert({cnt + 1, u});
}
}
}
if ((int)ss.size() > 2) {
cout << "-1\n";
} else {
int res = 0;
for (auto it : ss) res += it.first - 1;
while (res % 2 == 0) res /= 2;
cout << res << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(vector<int> a, vector<int> b) { return a.size() < b.size(); }
int main() {
int a, b;
cin >> a >> b;
int ans = 0;
for (int i = a; i <= b; i++) {
int n = i;
int m = 0;
while (n > 0) {
m = n % 10;
(m == 0 || m == 6 || m == 9) ? ans += 6
: (m == 2 || m == 3 || m == 5) ? ans += 5
: (m == 4) ? ans += 4
: (m == 7) ? ans += 3
: (m == 8) ? ans += 7
: ans += 2;
n /= 10;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, x2, y2, x3, y3;
scanf("%d%d%d%d%d%d", &x1, &y1, &x2, &y2, &x3, &y3);
printf("3\n");
printf("%d %d\n", x2 - x3 + x1, y2 - y3 + y1);
printf("%d %d\n", x1 - x2 + x3, y1 - y2 + y3);
printf("%d %d\n", x3 - x1 + x2, y3 - y1 + y2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N + 111 - 1) / 111 * 111 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, a, f[5], s;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a;
f[a % 3]++;
}
if (f[1] < f[2])
s = f[1];
else
s = f[2];
s = s + f[0] / 2;
cout << s;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n;
int m;
int arr[100];
int x;
int y;
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
if ((x - 1) >= 1) {
arr[x - 2] = arr[x - 2] + (y - 1);
}
if ((x + 1) <= n) {
arr[x] = arr[x] + (arr[x - 1] - y);
}
arr[x - 1] = 0;
}
for (i = 0; i < n; i++) {
printf("%d\n", arr[i]);
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
set<int>iset;
cin>>a;
for(int i=0;i<a;i++)
{
cin>>b;
iset.insert(b);
}
cout<<iset.size();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 10;
const long long MOD = 1e9 + 7;
int n;
long long quickpow(long long a, long long b) {
if (b < 0) return 0;
long long ret = 1;
a %= MOD;
while (b) {
if (b & 1) ret = (ret * a) % MOD;
b >>= 1;
a = (a * a) % MOD;
}
return ret % MOD;
}
int main() {
string s;
cin >> s;
long long sum = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0') {
sum = sum * 4 % MOD;
} else {
sum = (sum * 4 + quickpow(2, i)) % MOD;
}
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, w, m;
struct ST {
int x, y;
} A[100001];
struct ft {
int p, q;
} C[100001], BB[100001];
struct DT {
ft x, y;
} B[100001];
int com(ft a, ft b) {
long long int aa = (long long int)a.p * b.q - (long long int)a.q * b.p;
if (aa > (long long int)0)
return 1;
else if (aa == (long long int)0) {
return 0;
} else {
return -1;
}
}
bool cmp2(ft &r1, ft &r2) { return com(r1, r2) < 0; }
bool cmp(DT &r1, DT &r2) {
return com(r1.x, r2.x) != 0 ? com(r1.x, r2.x) < 0 : com(r1.y, r2.y) > 0;
}
int fnd(ft a) {
int s = 1, e = m, mm;
mm = (s + e) / 2;
while (com(BB[mm], a) != 0) {
if (com(BB[mm], a) < 0) {
s = mm + 1;
} else {
e = mm - 1;
}
mm = (s + e) / 2;
}
return mm;
}
int abbs(int x) { return x < 0 ? -x : x; }
long long int sg[100001 * 8], sgm;
int main() {
int i, j;
scanf("%d%d", &n, &w);
for (i = 1; i <= n; i++) {
scanf("%d%d", &A[i].x, &A[i].y);
B[i].x.p = abbs(A[i].x), B[i].x.q = abbs(A[i].y + w);
B[i].y.p = abbs(A[i].x), B[i].y.q = abbs(A[i].y - w);
C[i].p = abbs(A[i].x), C[i].q = abbs(A[i].y - w);
}
sort(B + 1, B + n + 1, cmp);
sort(C + 1, C + n + 1, cmp2);
BB[1].p = C[1].p, BB[1].q = C[1].q, m = 1;
for (i = 2; i <= n; i++) {
if (com(C[i - 1], C[i]) != 0) {
++m;
BB[m].p = C[i].p, BB[m].q = C[i].q;
}
}
long long int ans = 0;
for (sgm = 1; sgm < m; sgm *= 2)
;
for (i = n; i >= 1; i--) {
int loc = fnd(B[i].y);
long long int sm = 0;
int ss = sgm, ee = loc + sgm - 1;
while (ss <= ee) {
if (ss % 2 == 1) {
sm += sg[ss];
ss++;
}
if (ee % 2 == 0) {
sm += sg[ee];
ee--;
}
ss /= 2;
ee /= 2;
}
ans += sm;
for (j = loc + sgm - 1; j >= 1; j /= 2) {
sg[j]++;
}
}
printf("%lld", ans);
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)n;++i)
#define all(v) (v).begin(),(v).end()
using namespace std;
typedef pair<int,int>P;
typedef complex<double> C;
//??????
double cross(const C& a, const C& b) {
return imag(conj(a)*b);
}
//????§???¢?????¢???
double area(const vector<C> &ps) {
double A = 0;
rep(i,ps.size()){
A += cross(ps[i],ps[(i+1) % ps.size()]);
}
return A / 2.0;
}
int main()
{
vector<C> vec;
int n;
scanf("%d",&n);
rep(i,n){
int x,y;
cin >> x >> y;
vec.push_back(C(x,y));
}
printf("%.1f\n",area(vec));
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int lsone(int n) { return (n & -n); }
void mult(long long int a[25][25], long long int b[25][25],
long long int c[25][25], int m, int n, int p) {
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= p; j++) {
c[i][j] = 0;
for (int k = 1; k <= n; k++) {
c[i][j] += (a[i][k] * b[k][j]) % 1000000007;
c[i][j] %= 1000000007;
}
}
}
}
void mat_pow(long long int a[25][25], long long int c[25][25], int n,
long long int p) {
if (p == 0) {
for (int i = 1; i <= n; i++) c[i][i] = 1;
} else if (p == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) c[i][j] = a[i][j];
}
} else {
long long int d[25][25];
mat_pow(a, d, n, p / 2);
if (p % 2) {
long long int e[25][25];
mult(d, d, e, n, n, n);
mult(e, a, c, n, n, n);
} else {
mult(d, d, c, n, n, n);
}
}
}
long long int pow1(long long int a, long long int b) {
if (b == 0)
return 1ll;
else if (b == 1)
return a;
else {
long long int x = pow1(a, b / 2);
x *= x;
x %= 1000000007;
if (b % 2) {
x *= a;
x %= 1000000007;
}
return x;
}
}
int n, m, k, s, temp, dist[10][10], a[2010][2010], mdist[10], q[101000];
vector<vector<int> > mat(21000);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> k >> s;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> temp;
a[i][j] = temp;
mat[(temp - 1) * m + j].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= m; j++)
sort(mat[(i - 1) * m + j].begin(), mat[(i - 1) * m + j].end());
}
for (int i = 1; i <= n; i++) {
memset(mdist, -1, sizeof(mdist));
for (int j = 1; j <= m; j++) {
for (int x = 1; x <= k; x++) {
if (mdist[x] != -1) mdist[x]++;
int minim = n, maxim = 0;
if (mat[(x - 1) * m + j].size() > 0) {
minim = mat[(x - 1) * m + j][0];
maxim = mat[(x - 1) * m + j][mat[(x - 1) * m + j].size() - 1];
}
int dist1 = i - minim, dist2 = maxim - i;
mdist[x] = max(mdist[x], max(dist1, dist2));
dist[a[i][j]][x] = max(dist[a[i][j]][x], mdist[x]);
dist[x][a[i][j]] = dist[a[i][j]][x];
}
}
}
for (int i = 1; i <= n; i++) {
memset(mdist, -1, sizeof(mdist));
for (int j = m; j >= 1; j--) {
for (int x = 1; x <= k; x++) {
if (mdist[x] != -1) mdist[x]++;
int minim = n, maxim = 0;
if (mat[(x - 1) * m + j].size() > 0) {
minim = mat[(x - 1) * m + j][0];
maxim = mat[(x - 1) * m + j][mat[(x - 1) * m + j].size() - 1];
}
int dist1 = i - minim, dist2 = maxim - i;
mdist[x] = max(mdist[x], max(dist1, dist2));
dist[a[i][j]][x] = max(dist[a[i][j]][x], mdist[x]);
dist[x][a[i][j]] = dist[a[i][j]][x];
}
}
}
int ans = 0;
for (int i = 1; i <= s; i++) {
cin >> q[i];
}
for (int i = 2; i <= s; i++) {
ans = max(ans, dist[q[i - 1]][q[i]]);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int M = 35;
const int mod = 998244353;
int n, m;
int cnt0;
long long a[N];
long long wB[N];
long long wA[19][N];
long long ans[N];
long long qpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % mod;
b >>= 1;
a = a * a % mod;
}
return r;
}
long long popcount(long long x) {
int r = 0;
for (int i = 0; i < m; ++i)
if (x & 1ll << i) {
r++;
}
return r;
}
struct Basis {
long long a[M];
bool insert(long long x) {
for (int i = m - 1; ~i; --i)
if (x & 1ll << i) {
x ^= a[i];
}
for (int i = m - 1; ~i; --i)
if ((x & 1ll << i) && !a[i]) {
a[i] = x;
for (int j = m - 1; j > i; --j)
if (a[j] & 1ll << i) {
a[j] ^= x;
}
return 1;
}
return 0;
}
} T;
void dfs(vector<long long> A, int x, long long w, bool type) {
if (x == A.size()) {
if (!type) {
++wB[w];
} else {
int cnt = popcount(w ^ (w & ((1ll << m / 2) - 1)));
++wA[cnt][w & ((1ll << m / 2) - 1)];
}
return;
}
dfs(A, x + 1, w, type);
dfs(A, x + 1, w ^ A[x], type);
}
struct FWT {
int n;
void prepare(int len) {
for (n = 1; n <= len; n <<= 1)
;
}
void fwt(long long *a, int f) {
long long rev = 1;
if (f == -1) rev = qpow(2, mod - 2);
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += i << 1) {
for (int k = 0; k < i; ++k) {
long long x = a[j + k], y = a[j + k + i];
a[j + k] = (x + y) * rev % mod;
a[j + k + i] = (x - y + mod) * rev % mod;
}
}
}
}
} F;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
for (int i = 1; i <= n; ++i)
if (!T.insert(a[i])) {
cnt0++;
}
vector<long long> A, B;
for (int i = 0; i < m / 2; ++i)
if (T.a[i]) B.push_back(T.a[i]);
for (int i = m / 2; i < m; ++i)
if (T.a[i]) A.push_back(T.a[i]);
dfs(B, 0, 0, 0);
dfs(A, 0, 0, 1);
F.prepare((1ll << 17) - 1);
F.fwt(wB, 1);
for (int i = 0; i <= 18; ++i) {
F.fwt(wA[i], 1);
for (int j = 0; j < F.n; ++j) wA[i][j] = wA[i][j] * wB[j] % mod;
F.fwt(wA[i], -1);
for (int j = 0; j < F.n; ++j) {
int cnt = popcount(j);
(ans[cnt + i] += wA[i][j]) %= mod;
}
}
for (int i = 0; i <= m; ++i) {
ans[i] = ans[i] * qpow(2, cnt0) % mod;
printf("%lld ", ans[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char mp[110][110];
int d[110][110];
int p[1000010];
int pre[1000010];
int dp[1000010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", mp[i] + 1);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &p[i]);
memset(d, 0x3f, sizeof(d));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (mp[i][j] == '1') d[i][j] = mp[i][j] - '0';
for (int i = 1; i <= n; i++) d[i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
memset(dp, 0x3f, sizeof(dp));
dp[1] = 1;
for (int i = 2; i <= m; i++) {
int D = max(1, i - n);
for (int j = i - 1; j >= D; j--) {
if (d[p[j]][p[i]] == (i - j)) {
if (dp[j] + 1 < dp[i]) {
dp[i] = dp[j] + 1;
pre[i] = j;
}
}
}
}
printf("%d\n", dp[m]);
vector<int> v;
int now = m;
while (now) {
v.push_back(p[now]);
now = pre[now];
}
for (int i = v.size() - 1; i >= 0; i--) printf("%d ", v[i]);
return 0;
}
| 3 |
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
struct S{
int idx, val;
double score;
S(int i, int v, double s) :
idx(i), val(v), score(s) {}
bool operator < (const S& st) const {
if(score != st.score) return score > st.score;
if(idx != st.idx) return idx < st.idx;
return val > st.val;
}
};
int main(){
int N;
while(cin>>N && N){
int a[20];
REP(i, N) cin>>a[i];
priority_queue<S> que;
FOR(v, 1, 100001) que.push(S(1, v, (double)abs(a[0] - v) / a[0]));
bool used[20][150001] = {};
while(!que.empty()){
S s = que.top(); que.pop();
if(s.idx == N){
printf("%.12f\n", s.score);
break;
}
if(used[s.idx][s.val]) continue;
used[s.idx][s.val] = true;
for(int k = 1; k * s.val <= 150000; k++){
int nv = k * s.val;
que.push(S(s.idx + 1, nv, max(s.score, (double)abs(a[s.idx] - nv) / a[s.idx])));
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (int)1e9 + 7;
int t, k;
int dp[100001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.setf(ios::fixed), cout.precision(20);
cin >> t >> k;
dp[0] = 1;
for (int i = 1; i < k; i++) {
dp[i] = 1;
}
for (int i = k; i <= 100000; i++) {
dp[i] = (dp[i - 1] + dp[i - k]) % mod;
}
for (int i = 1; i <= 100000; i++) {
dp[i] += dp[i - 1];
dp[i] %= mod;
}
for (int i = 0; i < t; i++) {
int a, b;
cin >> a >> b;
cout << (dp[b] - ((a == 0) ? 0 : dp[a - 1]) + mod) % mod << "\n";
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define rep(i,x,y) for(register int i = x;i <= y; ++ i)
#define repd(i,x,y) for(register int i = x;i >= y; -- i)
using namespace std;
typedef long long ll;
template<typename T>inline void read(T&x)
{
char c;int sign = 1; x = 0;
do { c = getchar(); if(c == '-') sign = -1; }while(!isdigit(c));
do { x = x * 10 + c - '0'; c = getchar(); }while(isdigit(c));
x *= sign;
}
const int M = 4e5 + 50;
int n,m,cnt;
struct EDGE { int u,v;ll w; }e[M];
const bool cmp(EDGE a,EDGE b) { return a.w < b.w; }
ll v[M];int p[M];
ll ans;
int get_fa(int x) { return p[x] == x ? x : p[x] = get_fa(p[x]); }
int main()
{
read(n); read(m);
rep(i,0,2 * n) v[i] = INT_MAX;
rep(i,1,m)
{
int a,b,c;
read(a); read(b); read(c);
e[++cnt].u = a+1;e[cnt].v = b+1;e[cnt].w = c;
v[a] = min(v[a],c+1LL);
v[b] = min(v[b],c+2LL);
}
rep(i,1,2*n)
{
v[i] = min(v[i],v[i-1]+2);
v[i%n] = min(v[i%n],v[i]);
}
rep(i,0,n-1)
e[++cnt].u = i + 1,
e[cnt].v = (i+1)%n + 1,
e[cnt].w = v[i];
sort(e + 1,e + 1 + cnt,cmp);
rep(i,1,n) p[i] = i;
rep(i,1,cnt)
{
int u = get_fa(e[i].u),v = get_fa(e[i].v);
if(u != v)
{
p[u] = v;
ans += e[i].w;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int c = 0;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) {
int a, b;
cin >> a >> b;
c += (a + b > 0);
}
}
cout << c << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 7;
const int INF = 1e9;
int s, k, n, m, x, y, p, q, a, b, c, d, caseno = 0;
int ar[MAX], ans = 0;
int MAIN() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
scanf("%d", &a);
if (i == j) ans ^= a;
}
scanf("%d", &m);
while (m--) {
scanf("%d", &a);
;
if (a <= 2) {
scanf("%d", &b);
ans ^= 1;
} else
printf("%d", ans);
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
int start = clock();
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int size[500100], f[500100], l[500100], soli[30][30];
int main() {
cin >> n;
string s;
getline(cin, s);
for (int i = 0; i < n; i++) {
getline(cin, s);
size[i] = s.size();
f[i] = s[0] - 'a';
l[i] = s[s.size() - 1] - 'a';
}
for (int i = 0; i <= 'z' - 'a'; i++)
for (int j = 0; j <= 'z' - 'a'; j++) soli[i][j] = 0;
soli[f[0]][l[0]] = size[0];
for (int i = 1; i < n; i++) {
for (int j = 0; j <= 'z' - 'a'; j++)
if (soli[j][f[i]] != 0)
if (soli[j][f[i]] + size[i] > soli[j][l[i]])
soli[j][l[i]] = soli[j][f[i]] + size[i];
if (soli[f[i]][l[i]] < size[i]) soli[f[i]][l[i]] = size[i];
}
int max = soli[0][0];
for (int i = 1; i <= 'z' - 'a'; i++)
if (soli[i][i] > max) max = soli[i][i];
cout << max;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> done;
vector<pair<int, int> > grads1, grads2;
vector<long long> sols;
int n, q;
scanf("%d%d", &n, &q);
vector<int> vals;
vals.resize(n);
for (int c = 0; c < n; c++) scanf("%d", &vals[c]);
for (int c = 0; c < n - 1; c++)
grads1.push_back(pair<int, int>(abs(vals[c + 1] - vals[c]), c));
grads2 = grads1;
sort(grads2.begin(), grads2.end());
sols.resize(n - 1);
vector<int> left(n - 1), right(n - 1);
for (int c = n - 2; c >= 0; c--) {
auto l = done.upper_bound(grads2[c].second);
auto u = done.lower_bound(grads2[c].second + 1);
if (l == done.begin())
left[grads2[c].second] = 0;
else
left[grads2[c].second] = *(--l);
if (u == done.end())
right[grads2[c].second] = n - 1;
else
right[grads2[c].second] = *u;
done.insert(grads2[c].second);
done.insert(grads2[c].second + 1);
}
int i, j;
while (q--) {
scanf("%d%d", &i, &j);
long long r = 0;
i--;
j--;
for (int c = i; c < j; c++) {
r += (long long)grads1[c].first * (min(right[c], j) - c) *
(c + 1 - max(left[c], i));
}
cout << r << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> table;
int main() {
int n;
while (cin >> n) {
table.clear();
for (int i = 0; i < n; i++) {
string t;
cin >> t;
table["void"] = 0;
if (t[4] == 'd') {
string a, b;
cin >> a >> b;
string bare;
int ast = 0;
int amp = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '&')
amp++;
else if (a[i] == '*')
ast++;
else
bare += a[i];
}
int cnt = 0;
if (table.count(bare) == 0 || table[bare] < 0) {
cnt = -1;
} else {
cnt = table[bare] - amp + ast;
}
table[b] = cnt;
} else {
string a;
cin >> a;
string bare;
int ast = 0;
int amp = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '&')
amp++;
else if (a[i] == '*')
ast++;
else
bare += a[i];
}
int cnt = 0;
if (table.count(bare) == 0 || table[bare] < 0) {
cnt = -1;
} else {
cnt = table[bare] - amp + ast;
}
if (table.count(bare) == 0) {
cout << "errtype" << endl;
} else if (cnt < 0) {
cout << "errtype" << endl;
} else {
cout << "void";
for (int i = 0; i < cnt; i++) {
cout << "*";
}
cout << endl;
}
}
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[100005];
for (int j = 0; j < n; j++) {
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &a[i]);
}
sort(a, a + m);
int o = min(a[m - 1], a[m - 2]) - 1;
printf("%d\n", min(o, m - 2));
}
}
| 1 |
Subsets and Splits