solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int t, n, x, y, ans, maxn;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &x, &y);
ans = maxn = 1 << 30;
int f = 0;
if (n == 2) {
printf("%d %d\n", x, y);
continue;
}
int p = y - x;
for (register int i = p; i >= 1; --i) {
if (p % i) continue;
f = max(x % i ? x % i : i, x - i * (n - (p / i) - 1));
if (f > x) continue;
if (f + i * (n - 1) >= y && f + i * (n - 1) < maxn) {
maxn = f + i * (n - 1);
ans = i;
if (maxn == y) break;
}
}
for (register int i =
max(x % ans ? x % ans : ans, x - ans * (n - (p / ans) - 1));
i <= maxn; i += ans)
printf("%d ", i);
puts("");
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int m,j,z=0;
cin>>m;
for(j=1;j<m;j++) z+=(m-1)/j;
cout<<z<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
int main() {
int n;
string s;
cin >> n >> s;
vector<int> b;
string t = s;
for (int i = 0; i < (int)(n - 1); i++) {
if (t[i] == 'W') {
t[i] = 'B';
if (t[i + 1] == 'W')
t[i + 1] = 'B';
else
t[i + 1] = 'W';
b.push_back(i);
}
}
bool ok = true;
for (int i = 0; i < (int)(n); i++) {
if (t[i] != 'B') ok = false;
}
if (ok) {
cout << b.size() << endl;
for (int i = 0; i < (int)(b.size()); i++) cout << b[i] + 1 << " ";
cout << endl;
return 0;
}
vector<int> w;
t = s;
for (int i = 0; i < (int)(n - 1); i++) {
if (t[i] == 'B') {
t[i] = 'W';
if (t[i + 1] == 'W')
t[i + 1] = 'B';
else
t[i + 1] = 'W';
w.push_back(i);
}
}
ok = true;
for (int i = 0; i < (int)(n); i++) {
if (t[i] != 'W') ok = false;
}
if (ok) {
cout << w.size() << endl;
for (int i = 0; i < (int)(w.size()); i++) cout << w[i] + 1 << " ";
cout << endl;
return 0;
}
cout << -1 << endl;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const int N = 2e3 + 7;
unsigned long long h1[N], h2[N][N];
char s[N][N], t[N][N];
int n, m;
void init() {
for (int i = 1; i <= n; i++) {
unsigned long long h = 0;
for (int j = 1; j <= m; j++) h = h * 131 + s[i][j];
h1[i] = h;
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j + m - 1 <= n; j++) {
unsigned long long h = 0;
for (int k = j; k <= j + m - 1; k++) h = h * 131 + t[i][k];
h2[i][j] = h;
}
}
}
bool judge(int first, int second) {
for (int i = 1; i <= m; i++)
if (h1[first + i - 1] != h2[i][second]) return false;
return true;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) scanf("%s", t[i] + 1);
init();
for (int i = 1; i + m - 1 <= n; i++)
for (int j = 1; j + m - 1 <= n; j++)
if (judge(i, j)) {
printf("%d %d\n", i, j);
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
int main()
{
int v, e;
cin >> v >> e;
vector<vector<int>> adj(v, vector<int>());
vector<int> indeg(v, 0);
for (int i = 0; i < e; i++) {
int s, t;
cin >> s >> t;
adj[s].push_back(t);
indeg[t]++;
}
queue<int> q;
for (int i = 0; i < v; i++) {
if (indeg[i] == 0) {
q.push(i);
}
}
vector<int> ans;
while (!q.empty()) {
int u = q.front();
q.pop();
ans.push_back(u);
for (auto v : adj[u]) {
indeg[v]--;
if (indeg[v] == 0) {
q.push(v);
}
}
}
for (auto u : ans) {
cout << u << endl;
}
}
| 0 |
#include<iostream>
#define inf 1000000000
using namespace std;
int n,m;
int C[100][100];
int prim(){
int from[100],now[100],visit[100];
int ans=0;
for(int i=0;i<100;i++){
from[i]=visit[i]=0;
now[i]=inf;
}
now[0]=0;
from[0]=-1;
while(1){
int mini=inf,mino;
for(int i=0;i<n;i++){
if(visit[i]==1){
continue;
}
if(mini>now[i]){
mini=now[i];
mino=i;
}
}
if(mini==inf){
break;
}
visit[mino]=1;
if(from[mino]!=-1)
ans+=C[mino][from[mino]];
for(int i=0;i<n;i++){
if(C[mino][i]==inf || visit[i]==1){
continue;
}
if(now[i]>C[mino][i]){
now[i]=C[mino][i];
from[i]=mino;
}
}
}
return ans;
}
int main(){
while(1){
cin>>n>>m;
if(n==0)break;
for(int i=0;i<100;i++){
for(int j=0;j<100;j++){
C[i][j]=inf;
}
}
for(int i=0;i<m;i++){
int a,b,c;
cin>>a>>b>>c;
C[a][b]=C[b][a]=c;
}
printf("%d\n",prim());
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int TotalPoint, TotalEdge;
int Start, End, Sp;
int Ans, AllCost;
bool Visit[201];
bool VisitDfs[201];
int Dist[201];
int U[201], D[201];
vector<int> Edge[201];
vector<int> Stream[201];
vector<int> Cost[201];
vector<int> Size[201];
inline void AddEdge(int From, int To, int NowStream, int NowCost) {
Edge[From].push_back(To);
Edge[To].push_back(From);
Stream[From].push_back(NowStream);
Stream[To].push_back(0);
Cost[From].push_back(NowCost);
Cost[To].push_back(-NowCost);
Size[From].push_back(Edge[To].size() - 1);
Size[To].push_back(Edge[From].size() - 1);
}
inline bool Spfa(int Start, int End) {
register queue<int> Queue;
register int i;
for (i = 1; i <= Sp; i++) {
VisitDfs[i] = false;
Visit[i] = false;
Dist[i] = 2147483647;
}
Visit[Start] = true;
Dist[Start] = 0;
Queue.push(Start);
while (!Queue.empty()) {
register int Top;
Top = Queue.front();
Queue.pop();
Visit[Top] = false;
for (i = 0; i < Edge[Top].size(); i++) {
register int Next;
Next = Edge[Top][i];
if (Dist[Top] + Cost[Top][i] < Dist[Next] && Stream[Top][i]) {
Dist[Next] = Dist[Top] + Cost[Top][i];
if (!Visit[Next]) {
Visit[Next] = true;
Queue.push(Next);
}
}
}
}
return Dist[End] != 2147483647;
}
inline int Dfs(int Now, int End, int Min) {
if (!Min || Now == End) {
return Min;
}
register int Return;
Return = 0;
VisitDfs[Now] = 1;
register int i;
for (i = 0; i < Edge[Now].size(); i++) {
register int Next = Edge[Now][i];
if (Dist[Now] + Cost[Now][i] == Dist[Next] && Stream[Now][i] &&
!VisitDfs[Next]) {
register int MinStream;
MinStream = Dfs(Next, End, min(Min, Stream[Now][i]));
Stream[Now][i] -= MinStream;
Stream[Next][Size[Now][i]] += MinStream;
Min -= MinStream;
Return += MinStream;
AllCost += MinStream * Cost[Now][i];
}
}
return Return;
}
inline void Mcmf() {
while (Spfa(Start, End)) {
Ans = Ans + Dfs(Start, End, 2147483647);
}
}
int main(void) {
register int i, j;
cin >> TotalPoint >> TotalEdge;
Start = TotalPoint * 2 + 1;
End = TotalPoint * 2 + 2;
Sp = TotalPoint * 2 + 2;
for (i = 1; i <= TotalPoint; i++) {
U[i] = 1;
D[i] = TotalPoint;
}
for (i = 1; i <= TotalEdge; i++) {
register int Left, Right, Opt, Value;
cin >> Opt >> Left >> Right >> Value;
for (j = Left; j <= Right; j++) {
if (Opt == 1) {
U[j] = max(U[j], Value);
} else {
D[j] = min(D[j], Value);
}
}
}
for (i = 1; i <= TotalPoint; i++) {
AddEdge(Start, i, 1, 0);
}
for (i = 1; i <= TotalPoint; i++) {
for (j = U[i]; j <= D[i]; j++) {
AddEdge(i, j + TotalPoint, 1, 0);
}
}
for (i = 1; i <= TotalPoint; i++) {
for (j = 1; j <= TotalPoint; j++) {
AddEdge(i + TotalPoint, End, 1, 2 * j - 1);
}
}
Mcmf();
if (Ans == TotalPoint) {
cout << AllCost << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int bit[200005];
bool comp(pair<double, double> pr1, pair<double, double> pr2) {
if (pr1.first < pr2.first) {
return true;
} else if (pr1.first == pr2.first) {
if (pr1.second > pr2.second) {
return true;
} else {
return false;
}
} else {
return false;
}
}
bool comp1(pair<double, double> pr1, pair<double, double> pr2) {
if (pr1.second < pr2.second) {
return true;
} else {
return false;
}
}
int getsum(int in) {
int sum = 0;
while (in > 0) {
sum += bit[in];
in -= in & (-in);
}
return sum;
}
void update(int n, int in, int val) {
while (in <= n) {
bit[in] += val;
in += in & (-in);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
int n, w;
cin >> n >> w;
pair<int, int> pr[n + 1];
for (int i = 1; i <= n; i++) {
int x, v;
cin >> x >> v;
pr[i] = make_pair(x, v);
}
pair<double, double> ar[n + 1];
for (int i = 1; i <= n; i++) {
double t1 = (double)pr[i].first / ((double)pr[i].second - (double)w);
double t2 = (double)pr[i].first / ((double)pr[i].second + (double)w);
if (t1 < 0) {
t1 *= -1.00;
}
if (t2 < 0) {
t2 *= -1.00;
}
ar[i] = make_pair(t1, t2);
}
sort(ar + 1, ar + n + 1, comp);
for (int i = 1; i <= n; i++) {
ar[i].first = (double)i;
}
sort(ar + 1, ar + n + 1, comp1);
map<double, int> mp;
for (int i = 1; i <= n; i++) {
if (mp.find(ar[i].second) != mp.end()) {
ar[i].second = mp[ar[i].second];
} else {
mp[ar[i].second] = i;
ar[i].second = i;
}
}
int ans[n + 1];
for (int i = 1; i <= n; i++) {
ans[(int)ar[i].first] = ar[i].second;
}
memset(bit, 0, sizeof(bit));
long long int ttl = 0LL;
for (int i = n; i >= 1; i--) {
ttl += (long long int)getsum(ans[i]);
update(n, ans[i], 1);
}
cout << ttl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int m=0,n,l=0; cin>>n;
unordered_map<int,int> mp;
for(int i=0; i<n; ++i){
int a; cin>>a;
++mp[a]; m=max(m,a);
}
vector<bool> b(m+1,true);
for(int i=2; i<=m; ++i){
int s=0;
if(b[i]==true) for(int j=1; i*j<=m; ++j) {b[i*j]=false; s+=mp[i*j];}
if(s==n){ cout<<"not coprime"; return 0;}
else l=max(l,s);
}
if(l<2){ cout<<"pairwise coprime"; return 0;}
else cout<<"setwise coprime";
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int M=100010;
bool stu[410][410];
int n,m,a[M],b[M];
bool cant[410];
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
scanf("%d%d",a+i,b+i);
for(int i=1;i<=n;i++)
{
stu[i][i]=1;
for(int j=m;j>=1;j--)
{
bool x=stu[i][a[j]],y=stu[i][b[j]];
if(x&&y){cant[i]=1;break;}
else if(x) stu[i][b[j]]=1;
else if(y) stu[i][a[j]]=1;
}
}
int ans=0;
for(int i=1;i<n;i++)
{
if(cant[i]) continue;
for(int j=i+1;j<=n;j++)
{
if(cant[j]) continue;
bool flag=1;
for(int k=1;k<=n;k++)
if(stu[i][k]&&stu[j][k]) flag=0;
ans+=flag;
}
}
printf("%d\n",ans);
return 0;
}
//asdsdhuivhxcivbghlawhfuhssdfasfsdfs
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,i,j;
string s,t;
cin>>n;
cin>>s;
cin>>t;
for(i=0;i<n;i++)
{
cout<<s[i]<<t[i];
}
cout<<endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize(3)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC target("sse3", "sse2", "sse")
#pragma GCC target("avx", "sse4", "sse4.1", "sse4.2", "ssse3")
#pragma GCC target("f16c")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
"no-stack-protector")
using namespace std;
const int block_size = 320;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 7;
const long double eps = 1e-9;
const double PI = atan(1) * 4;
template <typename T>
inline int sign(const T &a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline void in(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
long long twop(int x) { return 1LL << x; }
template <typename A, typename B>
inline void in(A &x, B &y) {
in(x);
in(y);
}
template <typename A, typename B, typename C>
inline void in(A &x, B &y, C &z) {
in(x);
in(y);
in(z);
}
template <typename A, typename B, typename C, typename D>
inline void in(A &x, B &y, C &z, D &d) {
in(x);
in(y);
in(z);
in(d);
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
namespace SOLVE {
void main() {}
} // namespace SOLVE
long long dp[5010][5010];
long long a[5010];
int main() {
long long n, k, x;
in(n, k, x);
long long ans = 0;
memset(dp, 0xcf, sizeof(dp));
dp[0][0] = 0;
for (long long i = 1; i < n + 1; i++) in(a[i]);
for (long long i = 1; i < x + 1; i++) {
deque<int> q;
q.push_back(0);
for (long long j = 1; j < n + 1; j++) {
while (j - q[0] > k) q.pop_front();
dp[i][j] = dp[i - 1][q[0]] + a[j];
while (((int)q.size()) && dp[i - 1][j] > dp[i - 1][q.back()])
q.pop_back();
q.push_back(j);
}
}
ans = -1;
for (long long i = 1; i < n + 1; i++) {
if (n - i < k) upmax(ans, dp[x][i]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
int l2, l1;
int s1[100000], s2[100000];
int change(int s[], long long x) {
int cnt = 0;
while (x > 0) {
s[++cnt] = x & 1;
x >>= 1;
}
return cnt;
}
int axiao(int l, int x) {
if (l1 < l) return 1;
if (l1 > l) return 0;
for (int i = l1; i > x; i--) {
if (s1[i] != 1) return 1;
}
if (s1[x] == 0) return 1;
return 0;
}
int bda(int l, int x) {
if (l2 > l) return 1;
if (l2 < l) return 0;
for (int i = l2; i > x; i--) {
if (s2[i] != 1) {
return 0;
}
}
if (s2[x] == 1) {
return 1;
}
for (int i = x - 1; i > 0; i--) {
if (s2[i] == 0) {
return 0;
}
}
return 1;
}
int main() {
cin >> a >> b;
l1 = change(s1, a);
l2 = change(s2, b);
int cnt = 0;
for (int j = l1; j <= l2; j++)
for (int i = 1; i < j; i++) {
if (axiao(j, i) && bda(j, i)) cnt++;
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 60;
long long pow2[sz];
void solve(long long a, long long b, long long m) {
int maxn = 55;
for (int q = maxn; q > 0; q--) {
long long cur = 0;
vector<long long> r(q, 1);
r[0] = a;
vector<long long> coef(q, 1);
for (int i = 0; i < q - 1; i++) {
coef[i] = pow2[q - i - 2];
}
for (int i = 0; i < q; i++) {
cur += coef[i] * r[i];
if (coef[i] * r[i] < 0) {
cur = -1;
break;
}
}
if (cur > b || cur < 0) continue;
for (int i = 1; i < q; i++) {
long long left = 1;
long long right = m;
long long mid;
while (left <= right) {
mid = (left + right) / 2;
if (cur + (mid - 1) * coef[i] <= b && cur + (mid - 1) * coef[i] > 0) {
r[i] = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
cur += (r[i] - 1) * coef[i];
}
if (cur == b) {
cout << q << " ";
long long sum = 0;
for (int i = 0; i < q; i++) {
long long pre = sum;
sum += r[i];
cout << sum << " ";
sum += pre;
}
cout << "\n";
return;
}
}
cout << "-1\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
pow2[0] = 1;
for (int i = 1; i < sz; i++) {
pow2[i] = pow2[i - 1] * 2;
}
while (q--) {
long long a, b, m;
cin >> a >> b >> m;
solve(a, b, m);
}
return 0;
}
| 4 |
#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 << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void pre() {}
int n, m;
int a[(1 << 21) + 9];
int f[(1 << 21) + 9];
void fx(int x) {
if (a[2 * x] == a[2 * x + 1] && a[2 * x] == 0) {
a[x] = 0;
return;
}
int bg = 2 * x, sm = 2 * x + 1;
if (a[2 * x] < a[2 * x + 1]) swap(bg, sm);
a[x] = a[bg];
fx(bg);
bg = 2 * x, sm = 2 * x + 1;
if (a[2 * x] < a[2 * x + 1]) swap(bg, sm);
if (a[2 * x] == a[2 * x + 1]) {
if (x > m)
f[x] = x;
else
f[x] = 0;
} else if (f[bg] == bg)
f[x] = x;
else if (a[f[bg]] > a[f[sm]])
f[x] = f[bg];
else
f[x] = f[sm];
}
vector<int> ans;
void solve() {
int h, g;
cin >> h >> g;
n = (1 << h) - 1;
m = (1 << g) - 1;
for (int i = 1; i <= (n); ++i) cin >> a[i], a[i + n] = 0;
for (int i = 1; i <= (n); ++i) f[i] = i, f[i + n] = 0;
a[2 * n + 1] = f[2 * n + 1] = 0;
ans.clear();
ans.reserve(n - m);
for (int i = 0; i < (n - m); ++i) {
int x = f[1];
ans.push_back(f[1]);
fx(f[1]);
x /= 2;
while (x >= 1) {
int bg = 2 * x, sm = 2 * x + 1;
if (a[2 * x] < a[2 * x + 1]) swap(bg, sm);
if (a[2 * x] == a[2 * x + 1]) {
if (x > m)
f[x] = x;
else
f[x] = 0;
} else if (f[bg] == bg)
f[x] = x;
else if (a[f[bg]] > a[f[sm]])
f[x] = f[bg];
else
f[x] = f[sm];
x /= 2;
}
}
long long sum = 0;
for (int i = 1; i <= (m); ++i) sum += a[i];
cout << sum << '\n';
for (auto &i : ans) cout << i << ' ';
cout << '\n';
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pre();
int n;
cin >> n;
for (int i = 0; i < (n); ++i) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct aa {
int a[4];
} Ans[1010];
int ans, n, i, j, num, a[110];
long long T;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void work(int x) {
if (x == 0) {
ans++;
Ans[ans] = (aa){n + 1, n - 1, n + 1, n};
ans++;
Ans[ans] = (aa){n + 2, n - 1, n + 2, n};
ans++;
Ans[ans] = (aa){n - 1, n + 1, n, n + 1};
ans++;
Ans[ans] = (aa){n - 1, n + 2, n, n + 2};
return;
}
if (x == 1) {
ans++;
Ans[ans] = (aa){n + 1, n - 1, n + 1, n};
ans++;
Ans[ans] = (aa){n - 1, n + 1, n, n + 1};
ans++;
Ans[ans] = (aa){n - 1, n + 2, n, n + 2};
return;
}
if (x == 2) {
ans++;
Ans[ans] = (aa){n + 1, n - 1, n + 1, n};
ans++;
Ans[ans] = (aa){n - 1, n + 1, n, n + 1};
return;
}
if (x == 3) {
ans++;
Ans[ans] = (aa){n + 2, n - 1, n + 2, n};
ans++;
Ans[ans] = (aa){n - 1, n + 1, n, n + 1};
ans++;
Ans[ans] = (aa){n - 1, n + 2, n, n + 2};
return;
}
if (x == 4) {
ans++;
Ans[ans] = (aa){n + 1, n - 1, n + 1, n};
ans++;
Ans[ans] = (aa){n + 2, n - 1, n + 2, n};
return;
}
ans++;
Ans[ans] = (aa){n + 1, n - 1, n + 1, n};
}
int main() {
T = read();
while (T) {
num++;
a[num] = T % 6;
T /= 6;
}
for (i = 1; i <= num / 2; i++) swap(a[i], a[num - i + 1]);
n = 2;
ans = 2;
Ans[1] = (aa){1, 2, 2, 2};
Ans[2] = (aa){2, 1, 2, 2};
for (i = 1; i <= num; i++) {
work(a[i]);
n += 2;
if (i == num) break;
ans++;
Ans[ans] = (aa){n, n - 1, n + 1, n - 1};
ans++;
Ans[ans] = (aa){n, n - 2, n + 1, n - 2};
ans++;
Ans[ans] = (aa){n + 1, n - 3, n + 2, n - 3};
ans++;
Ans[ans] = (aa){n + 1, n - 2, n + 2, n - 2};
ans++;
Ans[ans] = (aa){n - 1, n, n - 1, n + 1};
ans++;
Ans[ans] = (aa){n - 2, n, n - 2, n + 1};
ans++;
Ans[ans] = (aa){n - 2, n + 1, n - 2, n + 2};
ans++;
Ans[ans] = (aa){n - 3, n + 1, n - 3, n + 2};
}
write(n);
putchar(' ');
write(n);
puts("");
write(ans);
puts("");
for (i = 1; i <= ans; i++) {
for (j = 0; j <= 3; j++) write(Ans[i].a[j]), putchar(' ');
puts("");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
class Solution;
class LinearBasis {
public:
friend class Solution;
LinearBasis() : size(0) { fill(begin(bs), end(bs), 0); }
LinearBasis& operator=(const LinearBasis& other) {
copy(begin(other.bs), end(other.bs), begin(bs));
size = other.size;
return *this;
}
void add(int num) {
for (int i = N - 1; i >= 0; --i) {
if (num & (1 << i)) {
if (bs[i] == 0) {
bs[i] = num;
++size;
break;
} else {
num ^= bs[i];
}
}
}
}
bool isValid(int num) {
if (num == 0) {
return true;
}
for (int i = N - 1; i >= 0; --i) {
if (num & (1 << i)) {
num ^= bs[i];
if (num == 0) {
return true;
}
}
}
return false;
}
protected:
int bs[N];
int size;
};
class Solution {
public:
Solution(vector<int>& _A, int n) : nums(_A), size(n) { init(); }
int query(int l, int x) {
if (l <= 0) {
return 0;
}
l = min(l, size);
if (lbs[l].isValid(x)) {
return powM(2, l - lbs[l].size);
} else {
return 0;
}
}
private:
int size;
vector<int> nums;
vector<LinearBasis> lbs;
const int M = 1e9 + 7;
void init() {
lbs.clear();
lbs.resize(size + 1);
for (int i = 0; i < size; ++i) {
int a = nums[i];
lbs[i + 1] = lbs[i];
lbs[i + 1].add(a);
}
}
long long normalize(long long a) {
a %= M;
if (a < 0) {
a += M;
}
return a;
}
long long addM(long long a, long long b) { return normalize(a + b); }
long long mulM(long long a, long long b) { return normalize(a * b); }
long long powM(long long x, long long e) {
long long res = 1;
while (e > 0) {
if (e & 0x1) {
res = mulM(res, x);
}
x = mulM(x, x);
e >>= 1;
}
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> nums(n);
for (int i = 0; i < n; ++i) {
cin >> nums[i];
}
Solution sol(nums, n);
for (int i = 0, l = 0, x = 0; i < q; ++i) {
cin >> l >> x;
cout << sol.query(l, x) << endl;
}
return 0;
}
| 6 |
#include <iostream>
#include <string>
#include <set>
#include <queue>
#define rep(i, n) for(i = 0; i < n; i++)
#define int long long
using namespace std;
int mod = 998244353;
int countMod3Renzoku(string s) {
int i, j, k, l, m, m3 = 0;
rep(i, s.length()) m3 += (s[i] - 'a');
m3 %= 3;
static int dp[200001][3][3][2] = {0}; //dp[cnt][mod3][lastChar][flag]
rep(i, 3) dp[1][i][i][0] = 1;
for (i = 1; i < s.length(); i++) {
rep(j, 3) {
rep(k, 3) {
rep(l, 2) {
rep(m, 3) {
dp[i + 1][(j + m) % 3][m][l | (k == m)] += dp[i][j][k][l];
dp[i + 1][(j + m) % 3][m][l | (k == m)] %= mod;
}
}
}
}
}
int ret = 0;
rep(i, 3) { ret += dp[s.length()][m3][i][1]; ret %= mod; }
return ret;
}
int allSearch(string s) {
set<string> dict;
queue<string> que;
que.push(s);
dict.insert(s);
while (!que.empty()) {
string t = que.front(); que.pop();
int i, j;
rep(i, (int)t.length() - 1) {
if (t[i] != t[i + 1]) {
rep(j, 3) if (j + 'a' != t[i] && j + 'a' != t[i + 1]) break;
char repl = j + 'a';
string u = t;
u[i] = repl;
u[i + 1] = repl;
if (dict.find(u) == dict.end()) {
que.push(u);
dict.insert(u);
}
}
}
}
return dict.size();
}
signed main() {
string s;
cin >> s;
int i;
rep(i, s.length() - 1) if (s[i] != s[i + 1]) break;
if (i == s.length() - 1) { cout << 1 << endl; }
else if (s.length() <= 3) { cout << allSearch(s) << endl; }
else {
int res = countMod3Renzoku(s);
rep(i, s.length() - 1) if (s[i] == s[i + 1]) break;
if (i == s.length() - 1) res++;
res %= mod;
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int TOUR = 1 << 21, MOD = 1000000007, H = 3137;
struct tour {
int brot, brzat, dodot;
tour(int brot, int brzat, int dodot)
: brot(brot), brzat(brzat), dodot(dodot) {}
tour() {}
int vel() { return 2 * (brot + dodot); }
} t[2 * TOUR];
tour Merge(const tour &l, const tour &r) {
int dodr = max(0, r.dodot - (l.brot + l.dodot - l.brzat));
return tour(l.brot + r.brot, l.brzat + r.brzat, l.dodot + dodr);
}
char s[TOUR];
int len;
int hes[TOUR];
int pot[TOUR];
int Mul(int a, int b) { return ((long long)a * b) % MOD; }
int Add(int a, int b) { return (a + b) % MOD; }
int Sub(int a, int b) { return (a - b + MOD) % MOD; }
void GenHes() {
pot[0] = 1;
for (int i = 1; i < TOUR; i++) pot[i] = Mul(pot[i - 1], H);
for (int i = 1; i <= 2 * len; i++)
hes[i] = Add(Mul(hes[i - 1], H), s[(i - 1) % len] - '(' + 1);
}
int Manji(int a, int b) {
a++;
b++;
int lo = 0, hi = len;
for (; lo < hi;) {
int mid = (lo + hi + 1) / 2;
if (Sub(hes[a + mid - 1], Mul(hes[a - 1], pot[mid])) ==
Sub(hes[b + mid - 1], Mul(hes[b - 1], pot[mid])))
lo = mid;
else
hi = mid - 1;
}
return s[(a + lo - 1) % len] < s[(b + lo - 1) % len];
}
void Ispis(int poc, int dodot, int dodzat) {
for (int i = 0; i < dodot; i++) printf("(");
for (int i = 0; i < len; i++, poc++) printf("%c", s[poc % len]);
for (int i = 0; i < dodzat; i++) printf(")");
printf("\n");
}
void GenTour() {
for (int i = 2 * TOUR - 1; i; i--) {
if (i < TOUR)
t[i] = Merge(t[2 * i], t[2 * i + 1]);
else {
int poz = i - TOUR;
if (poz >= 2 * len) continue;
if (s[poz % len] == '(')
t[i] = tour(1, 0, 0);
else
t[i] = tour(0, 1, 1);
}
}
}
tour Vrati(int pos, int lo, int hi, int begin, int end) {
if (lo >= end || hi <= begin) return tour(0, 0, 0);
if (lo >= begin && hi <= end) return t[pos];
return Merge(Vrati(2 * pos + 0, lo, (lo + hi) / 2, begin, end),
Vrati(2 * pos + 1, (lo + hi) / 2, hi, begin, end));
}
int main() {
tour rje = tour(0, 0, 0);
int indr = 0;
scanf("%s", s);
len = (int)strlen(s);
GenTour();
GenHes();
for (int i = 0; i < len; i++) {
tour tmp = Vrati(1, 0, TOUR, i, i + len);
if (!i || tmp.vel() < rje.vel() ||
(tmp.vel() == rje.vel() && Manji(i, indr))) {
rje = tmp;
indr = i;
}
}
Ispis(indr, rje.dodot, rje.dodot + rje.brot - rje.brzat);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200003;
int t[3][maxn];
int a[maxn], b[maxn], c[maxn];
int tr[maxn * 4];
int getsum(int type, int r) {
int ans = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ans += t[type][r];
return ans;
}
void inc(int type, int r) {
for (; r < maxn; r = (r | (r + 1))) t[type][r]++;
}
void build(int v, int l, int r) {
if (r - l == 1) {
tr[v] = 1;
return;
}
int c = (l + r) / 2;
build(v * 2 + 0, l, c);
build(v * 2 + 1, c, r);
tr[v] = tr[v * 2 + 0] + tr[v * 2 + 1];
}
void update(int v, int l, int r, int pos) {
if (r - l == 1) {
tr[v] = 0;
return;
}
int c = (l + r) / 2;
if (pos < c)
update(v * 2 + 0, l, c, pos);
else
update(v * 2 + 1, c, r, pos);
tr[v] = tr[v * 2 + 0] + tr[v * 2 + 1];
}
int getk(int v, int l, int r, int cnt) {
if (r - l == 1) return l;
int c = (l + r) / 2;
if (tr[v * 2 + 0] >= cnt)
return getk(v * 2 + 0, l, c, cnt);
else
return getk(v * 2 + 1, c, r, cnt - tr[v * 2 + 0]);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int z = 0;
for (int i = n - 1; i >= 0; i--) {
int posa = getsum(0, a[i]);
int posb = getsum(1, b[i]);
c[i] = (posa + posb + z) % (n - i);
z = (posa + posb + z) / (n - i);
inc(0, a[i]);
inc(1, b[i]);
}
build(1, 0, n);
for (int i = 0; i < n; i++) {
c[i] = getk(1, 0, n, c[i] + 1);
update(1, 0, n, c[i]);
}
for (int i = 0; i < n; i++) cout << c[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct node {
long long sum, rmx, lmx, mn, mx, d;
node(long long sum = 0, long long rmx = 0, long long lmx = 0,
long long mn = 0, long long mx = 0, long long d = 0)
: sum(sum), rmx(rmx), lmx(lmx), mn(mn), mx(mx), d(d) {}
} t[4 * N];
long long w, s[N];
int n, m, k, tot, in[N], out[N], head[N], nex[N << 1], to[N << 1], id[N << 1];
long long wi[N << 1];
void add(int u, int v, long long w, int _id) {
to[++tot] = v;
nex[tot] = head[u];
head[u] = tot;
wi[tot] = w;
id[tot] = _id;
}
void update(int k) {
t[k].sum = t[k << 1].sum + t[k << 1 | 1].sum;
t[k].rmx = max(t[k << 1].rmx,
max(t[k << 1 | 1].rmx - t[k << 1].sum,
t[k << 1 | 1].mx + t[k << 1].sum - 2 * t[k << 1].mn));
t[k].lmx = max(t[k << 1].lmx,
max(t[k << 1 | 1].lmx - t[k << 1].sum,
t[k << 1].mx - 2 * (t[k << 1 | 1].mn + t[k << 1].sum)));
t[k].mn = min(t[k << 1].mn, t[k << 1 | 1].mn + t[k << 1].sum);
t[k].mx = max(t[k << 1].mx, t[k << 1 | 1].mx + t[k << 1].sum);
t[k].d = max(max(t[k << 1].d, t[k << 1 | 1].d),
max(t[k << 1 | 1].rmx - t[k << 1].sum + t[k << 1].mx,
t[k << 1].lmx + t[k << 1 | 1].mx + t[k << 1].sum));
}
void build(int l, int r, int k) {
if (l == r) {
long long x = s[l];
t[k] = node(x, -x, -x, x, x, 0);
return;
}
int m = l + r >> 1;
build(l, m, k << 1);
build(m + 1, r, k << 1 | 1);
update(k);
}
void fix(int l, int r, int k, int x) {
if (l == r) {
build(l, r, k);
return;
}
int m = l + r >> 1;
if (x <= m)
fix(l, m, k << 1, x);
else
fix(m + 1, r, k << 1 | 1, x);
update(k);
}
void dfs(int u, int fa) {
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == fa) continue;
in[id[i]] = ++m;
s[m] = wi[i];
dfs(v, u);
out[id[i]] = ++m;
s[m] = -wi[i];
}
}
int main() {
scanf("%d%d%lld", &n, &k, &w);
for (int i = 1; i < n; i++) {
long long w;
int u, v;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
}
dfs(1, 0);
build(1, m, 1);
long long lastans = 0;
while (k--) {
int d;
long long e;
scanf("%d%lld", &d, &e);
d = (d + lastans) % (n - 1) + 1;
e = (e + lastans) % w;
s[in[d]] = e;
s[out[d]] = -e;
fix(1, m, 1, in[d]);
fix(1, m, 1, out[d]);
printf("%lld\n", lastans = t[1].d);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long A1, A2, B1, B2;
int conta2[2], conta3[2];
long long area1, area2;
int mosse, minl;
int main() {
cin >> A1 >> A2 >> B1 >> B2;
area1 = A1 * A2;
area2 = B1 * B2;
while (area1 % 2 == 0) {
area1 /= 2;
conta2[0]++;
}
while (area1 % 3 == 0) {
area1 /= 3;
conta3[0]++;
}
while (area2 % 2 == 0) {
area2 /= 2;
conta2[1]++;
}
while (area2 % 3 == 0) {
area2 /= 3;
conta3[1]++;
}
if (area1 != area2) {
cout << "-1";
return 0;
}
minl = min(conta3[0], conta3[1]);
conta3[0] -= minl;
conta3[1] -= minl;
while (conta3[0]) {
if (A1 % 3 == 0) {
A1 /= 3;
A1 *= 2;
} else {
A2 /= 3;
A2 *= 2;
}
conta2[0]++;
conta3[0]--;
mosse++;
}
while (conta3[1]) {
if (B1 % 3 == 0) {
B1 /= 3;
B1 *= 2;
} else {
B2 /= 3;
B2 *= 2;
}
conta2[1]++;
conta3[1]--;
mosse++;
}
minl = min(conta2[0], conta2[1]);
conta2[0] -= minl;
conta2[1] -= minl;
while (conta2[0]) {
if (A1 % 2 == 0) {
A1 /= 2;
} else {
A2 /= 2;
}
conta2[0]--;
mosse++;
}
while (conta2[1]) {
if (B1 % 2 == 0) {
B1 /= 2;
} else {
B2 /= 2;
}
conta2[1]--;
mosse++;
}
cout << mosse << endl;
cout << A1 << " " << A2 << endl;
cout << B1 << " " << B2 << endl;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<cstdio>
using namespace std;
int main()
{
int N;
scanf("%d",&N);
while(N-- > 0)
{
int n;
cin >> n;
int dp[n][n];
int vec[n];
for(int i=0;i<n;i++)
{
cin >> vec[i];
for(int j=0;j<n;j++)
dp[i][j] = 0;
}
int mex = 0;
for(int i=0;i<n;i++)
dp[i][(i+1)%n] = abs(vec[i]-vec[(i+1)%n]),mex = max(mex,dp[i][(i+1)%n]);
for(int i=2;i<n;i++)//幅
{
for(int j=0;j<n;j++)//index
{
for(int k=j;k<=j+i-1;k++)//中間地点
{
if(k == j)
{
dp[j][(j+i)%n] = max(dp[j][(j+i)%n],dp[j][(j+i-1)%n]+abs(vec[j]-vec[(j+i)%n]));
mex = max(mex,dp[j][(j+i)%n]);
continue;
}
dp[j][(j+i)%n] = max(dp[j][(j+i)%n],
dp[k%n][(j+i)%n]+dp[j][k%n]);
}
mex = max(mex,dp[j][(j+i)%n]);
}
}
cout << mex << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, d = 1, x;
int main() {
cin >> n;
while (n > 0) {
for (int i = 0; i < 5 && n > 0; i++) {
n -= d;
x = i;
}
d *= 2;
}
if (x == 0)
cout << "Sheldon";
else if (x == 1)
cout << "Leonard";
else if (x == 2)
cout << "Penny";
else if (x == 3)
cout << "Rajesh";
else if (x == 4)
cout << "Howard";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vll>;
using vb = vector<bool>;
const int INF = 2e9 + 5;
const ll LLINF = (1LL << 60) + 5;
int main() {
cin.tie(0), cin.sync_with_stdio(0), cout.tie(0), cout.sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vi v(n);
for (int &i : v) cin >> i;
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
if (v.size() == 1) {
cout << v.front() << '\n';
continue;
}
vi biggest{v.back()};
for (int i = v.size() - 2; i >= 0; i--) {
bool ok = 1;
for (int x : biggest) {
if (x % v[i] == 0) ok = 0;
}
if (ok) biggest.push_back(v[i]);
if (biggest.size() == 3) break;
}
vi second_biggest{v[v.size() - 2]};
for (int i = v.size() - 3; i >= 0; i--) {
bool ok = 1;
for (int x : second_biggest) {
if (x % v[i] == 0) ok = 0;
}
if (ok) second_biggest.push_back(v[i]);
if (second_biggest.size() == 3) break;
}
cout << max(accumulate(biggest.begin(), biggest.end(), 0),
accumulate(second_biggest.begin(), second_biggest.end(), 0))
<< '\n';
}
return cout << endl, 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string S[100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
string s;
cin >> s >> n;
for (int i = 0; i < n; ++i) cin >> S[i];
sort(S, S + n);
for (int i = 0; i < n; ++i)
if (S[i].size() >= s.size() && S[i].substr(0, s.size()) == s)
return cout << S[i] << endl, 0;
cout << s << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
const int kM = 1000000007;
int n;
long long s, a, ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
ans = (ans + s * a) % kM;
s = (s + a) % kM;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void input() {
long long int n, b, a, ma;
cin >> n >> b >> a;
ma = a;
long long int v[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int c = 0;
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i]) {
if (a == ma) {
a -= 1;
ans = i + 1;
} else if (b > 0) {
b -= 1;
if (a < ma) {
a += 1;
}
ans = i + 1;
} else if (a > 0) {
a -= 1;
ans = i + 1;
} else {
break;
}
} else {
if (a > 0) {
a -= 1;
ans = i + 1;
} else if (b > 0) {
b -= 1;
ans = i + 1;
} else {
break;
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1e16;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int c[n + 1];
for (int i = 0; i <= n - 1; i++) cin >> c[i];
vector<string> s(n), rs(n);
vector<vector<long long int>> dp(n, vector<long long int>(2));
for (int i = 0; i <= n - 1; i++) {
cin >> s[i];
rs[i] = s[i];
reverse(rs[i].begin(), rs[i].end());
}
dp[0][0] = 0, dp[0][1] = c[0];
for (int i = 1; i <= n - 1; i++) {
dp[i][0] = 1e15;
dp[i][1] = 1e15;
if (s[i] >= s[i - 1]) {
dp[i][0] = min(dp[i][0], dp[i - 1][0]);
}
if (s[i] >= rs[i - 1]) {
dp[i][0] = min(dp[i][0], dp[i - 1][1]);
}
if (rs[i] >= s[i - 1]) {
dp[i][1] = min(dp[i][1], dp[i - 1][0] + c[i]);
}
if (rs[i] >= rs[i - 1]) {
dp[i][1] = min(dp[i][1], dp[i - 1][1] + c[i]);
}
}
long long int ans = min(dp[n - 1][0], dp[n - 1][1]);
if (ans == 1e15) {
cout << "-1";
return 0;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<bool> vb;
typedef vector<vi> vvi;
typedef vector<long long> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<pair<ll, ll>> vpll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef queue<int> qi;
typedef queue<ll> qll;
typedef deque<int> dqi;
typedef deque<ll> dqll;
#define pb(x) push_back(x)
#define pob() pop_back()
#define r(i, s, n) for(ll i = s; i < n; i++)
#define rr(i, e, s) for(ll i = e; i >= s; i--)
#define MAX 1e9+7
#define sf bool f=true
#define fi first
#define se second
#define YES cout<<"YES"<<endl;
#define NO cout<<"NO"<<endl;
void solve(){
int n;
cin>>n;
if(n&1){
r(i,0,n){
r(j, i+1, n){
if(j-i <= n/2) cout<<1<<" ";
else cout<<-1<<" ";
}
}
cout<<endl;
}else{
r(i,0,n){
r(j,i+1,n){
if(j-i < n/2){
cout<<1<<" ";
}else if(j-i == n/2){
cout<<0<<" ";
}else{
cout<<-1<<" ";
}
}
}
cout<<endl;
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin>>t;
while(t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = s.size();
cout << (26 * (l + 1)) - l << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int f[31][31][2], p2[31];
const int P = 1000000007;
void solve() {
cin >> n;
int lim = (31 - __builtin_clz(n));
f[lim + 1][0][1] = 1;
p2[0] = 1;
for (int i = (1), iend = (lim + 1); i <= iend; ++i) p2[i] = p2[i - 1] * 2 % P;
for (int i = (lim + 1), iend = (1); i >= iend; --i)
for (int j = (0), jend = (31); j <= jend; ++j) {
if (f[i][j][0]) {
f[i - 1][j + 1][0] = (f[i - 1][j + 1][0] + f[i][j][0]) % P;
f[i - 1][j][0] = (f[i - 1][j][0] + f[i][j][0] * 1ll * p2[j]) % P;
}
if (f[i][j][1]) {
int od = (j ? p2[j - 1] : 0), ev = (j ? p2[j - 1] : 1);
if (n & (1 << i - 1))
f[i - 1][j + 1][1] = (f[i - 1][j + 1][1] + f[i][j][1]) % P,
f[i - 1][j][1] =
(f[i - 1][j][1] + f[i][j][1] * 1ll * od) % P,
f[i - 1][j][0] =
(f[i - 1][j][0] + f[i][j][1] * 1ll * ev) % P;
else
f[i - 1][j][1] = (f[i - 1][j][1] + f[i][j][1] * 1ll * ev) % P;
}
}
long long res = 0;
for (int i = (0), iend = (30); i <= iend; ++i)
res = (res + f[0][i][0] + f[0][i][1]) % P;
cout << res << endl;
}
signed main() { solve(); }
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
const int N = 200000;
const int MOD = 1e9 + 7;
int n, m, a[N], s[N][120], c[N][120];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) c[i][0] = 1;
for (int i = 1; i <= 100; i++) {
c[1][i] = 1;
for (int j = 2; j <= n; j++) c[j][i] = (c[j - 1][i] + c[j][i - 1]) % MOD;
}
for (int i = 0; i <= 100; i++)
for (int j = 2; j <= n; j++) c[j][i] = (c[j][i] + c[j - 1][i]) % MOD;
for (int i = 1; i <= m; i++) {
int l, r, k;
scanf("%d%d%d", &l, &r, &k);
s[l][k] = (s[l][k] + 1) % MOD;
s[r + 1][k] = (MOD + s[r + 1][k] - 1) % MOD;
for (int j = k - 1; j >= 0; j--)
s[r + 1][j] = (MOD + s[r + 1][j] - c[r - l + 1][k - j - 1]) % MOD;
}
for (int i = 100; i >= 0; i--) {
for (int j = 1; j <= n; j++) {
if (!i) a[j] = (a[j] + s[j][i]) % MOD;
if (i) s[j][i - 1] = (s[j][i - 1] + s[j][i]) % MOD;
s[j + 1][i] = (s[j + 1][i] + s[j][i]) % MOD;
}
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 8;
const int SIZE = 10001;
int m;
int a[MAXM], b[MAXM];
int dp[SIZE];
void rec(int sum, int i, int j) {
if(i == m) {
dp[sum] += 1;
return;
}
rec(sum, i+1, 0);
if(j < b[i]) rec(sum+a[i], i, j+1);
}
int main() {
while(cin >> m && m) {
for(int i = 0; i < m; ++i) {
cin >> a[i] >> b[i];
}
fill(dp, dp+SIZE, 0);
rec(0,0,0);
int g;
cin >> g;
while(g--) {
int n;
cin >> n;
cout << dp[n] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592654;
bool check(long long sum, long long n) { return sum * 10 >= n * 45; }
int main(void) {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
long long tc, l, k = 0, sum = 0, x = 0, y = 0, z = 0, m = 1, n = 0, ans = 0,
cnt = 0;
cin >> n;
string s;
cin >> s;
for (long long i = 0; i < n - 1; i++) {
if (s[i] == 'U')
y++;
else
x++;
if (x == y && s[i] == s[i + 1]) ans++;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
using namespace std;
const int oo = 2e9;
const long long OO = 4e18;
const long double pi = arg(complex<long double>(-1, 0));
const long double pi2 = pi + pi;
const int md = 0x3b800001;
const int MD = 1e9 + 7;
inline long long time() {
return chrono ::system_clock().now().time_since_epoch().count();
}
mt19937 rnd(time());
mt19937_64 RND(time());
template <typename t>
inline void umin(t &a, t b) {
a = min(a, b);
}
template <typename t>
inline void umax(t &a, t b) {
a = max(a, b);
}
const int N = 228;
string s, t;
int n, m, f[N][N][N + N];
char pr[N][N][N + N];
void solve() {
memset(f, 127, sizeof f);
cin >> s >> t;
n = int(s.size()), m = int(t.size());
f[0][0][0] = 0;
pr[0][0][0] = '#';
for (int i = 0; i < n + 1; ++i)
for (int j = 0; j < m + 1; ++j) {
for (int b = 0; b < n + m + 1; ++b)
if (b) {
int pi = i, pj = j, pb = b - 1;
if (i && s[i - 1] == '(') --pi;
if (j && t[j - 1] == '(') --pj;
if (f[i][j][b] > f[pi][pj][pb] + 1) {
f[i][j][b] = f[pi][pj][pb] + 1;
pr[i][j][b] = '(';
}
}
for (int b = n + m - 1; ~b; --b) {
int pi = i, pj = j, pb = b + 1;
if (i && s[i - 1] == ')') --pi;
if (j && t[j - 1] == ')') --pj;
if (f[i][j][b] > f[pi][pj][pb] + 1) {
f[i][j][b] = f[pi][pj][pb] + 1;
pr[i][j][b] = ')';
}
}
}
if (f[n][m][0] > 700) return void(cout << "wat\n");
int i = n, j = m, p = 0;
string ans = "";
for (; i || j || p;) {
char c = pr[i][j][p];
if (c == '(') {
--p;
if (i && s[i - 1] == '(') --i;
if (j && t[j - 1] == '(') --j;
} else {
++p;
if (i && s[i - 1] == ')') --i;
if (j && t[j - 1] == ')') --j;
}
if (c != '#') ans += c;
}
reverse(ans.begin(), ans.end());
cout << ans << endl;
}
int main() {
ios_base ::sync_with_stdio(0);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long dx[4] = {1, -1, 0, 0};
long long dy[4] = {0, 0, 1, -1};
const long long MOD = 2;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long fir, long long sec) {
return (fir * sec) / (gcd(fir, sec));
}
long long fast_pow(long long a, long long b) {
long long res = a, ret = 1;
while (b > 0) {
if (b % 2) ret = (ret * res) % MOD;
res = (res * res) % MOD;
b /= 2;
}
return ret;
}
const long long maxN = 3e5 + 7;
pair<pair<long long, long long>, long long> arr[maxN];
bool sortbyfir(const pair<pair<long long, long long>, long long> a,
const pair<pair<long long, long long>, long long> b) {
return (a.first.first > b.first.first);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
time_t time_t1, time_t2;
time_t1 = clock();
long long t = 1;
while (t--) {
long long n;
cin >> n;
long long a, b;
long long asc = 0;
long long desc = 0;
for (long long i = 0; i < n; ++i) {
cin >> a >> b;
if (a > b) {
desc++;
} else {
asc++;
}
arr[i] = {{a, b}, i + 1};
}
std::vector<long long> ans;
if (asc > desc) {
sort(arr, arr + n, sortbyfir);
for (long long i = 0; i < n; ++i) {
;
}
for (long long i = 0; i < n; ++i) {
if (arr[i].first.first < arr[i].first.second) {
ans.push_back(arr[i].second);
}
}
} else {
sort(arr, arr + n);
for (long long i = 0; i < n; ++i) {
;
if (arr[i].first.first > arr[i].first.second) {
ans.push_back(arr[i].second);
}
}
}
cout << ans.size() << '\n';
for (long long x : ans) {
cout << x << " ";
}
cout << '\n';
}
time_t2 = clock();
return 0;
}
| 4 |
#include <stdio.h>
#include <cctype>
#include <limits.h>
#include <math.h>
#include <complex>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cstring>
#include <string>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>
#define VARIABLE(x) cerr << #x << "=" << x << endl
#define BINARY(x) static_cast<bitset<16> >(x)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define if_range(x, y, w, h) if (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define ALL(a) (a).begin(),(a).end()
const int INF = 1e9;
int dx[4]={0, 1, 0, -1}, dy[4]={-1, 0, 1, 0};
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
/* struct P {
int x, y, n;
P(int n, int x, int y):n(n), x(x), y(y){}
P(){}
}; */
/** Problem0215 : Pachimon Creature **/
int dp[5][1024];
vector<vector<PII> > list(5);
PII sp, gp;
int dist(PII a, PII b)
{
return abs(a.first - b.first) + abs(a.second - b.second);
}
int solve(int old, int idx, int got)
{
if (got == 5)
return dist(gp, list[old][idx]);
if (dp[got][idx] != -1)
return dp[got][idx];
int next = (old+1)%5;
int res = INF;
for (int i=0; i<list[next].size(); i++) {
res = min(res, solve(next, i, got+1) + dist(list[old][idx], list[next][i]));
}
return dp[got][idx] = res;
}
int main()
{
int W, H;
while (cin>>W>>H, W||H) {
for (int i=0; i<5; i++) list[i].clear();
vector<string> field(H);
rep(i, H) {
cin>>field[i];
}
rep(y, H) {
rep(x, W) {
if (field[y][x] == 'S') {
sp = PII(x, y);
} else if (field[y][x] == 'G') {
gp = PII(x, y);
} else if (isdigit(field[y][x])) {
int n = field[y][x] - '1';
list[n].push_back(PII(x, y));
}
}
}
int ans = INF, ansFirst=-1;
rep(first, 5) {
memset(dp, -1, sizeof(dp));
int next = (first+1)%5;
for (int i=0; i<list[next].size(); i++) {
int res = solve(next, i, 2)+ dist(sp, list[next][i]);
if (ans > res) {
ans = res;
ansFirst = first+1;
}
}
}
if (ans < INF) {
cout << ansFirst << " " << ans << endl;
} else {
cout << "NA" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
string s;
int main() {
ios::sync_with_stdio(false);
cin >> s;
int len = s.size();
for (int i = 0; i <= 1000; i += 8) {
char a[10];
sprintf(a, "%d", i);
int L = strlen(a);
int o = 0;
for (int j = 0; j < len; j++) {
if (s[j] == a[o]) o++;
if (o == L) {
cout << "YES" << endl;
cout << a << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p[1000005], x[1000005], y[1000005];
bool cmp(int a, int b) {
if (x[a] / 1000 == x[b] / 1000) return ((y[a] < y[b]) ^ ((x[a] / 1000) % 2));
return (x[a] < x[b]);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
p[i] = i;
}
sort(p, p + n, cmp);
for (int i = 0; i < n; i++) printf("%d ", p[i] + 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 55;
const int inf = 1e7 + 77;
const double PI = acos(-1.0);
const double eps = 0.000001;
const int MOD = 10;
int b[MAX];
int a[MAX];
char ch[301][301];
set<int> st;
vector<string> res;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; ++i) cout << a[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, sol;
int p[300013];
int main(void) {
cin >> n;
for (i = 1; i <= n; ++i) cin >> p[i];
sort(p + 1, p + n + 1);
for (i = 1; i <= n; ++i) sol += abs(p[i] - i);
cout << 1LL * sol;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 9;
int n, m, head[N], tot;
struct Edge {
int u, v;
} e[N];
struct pp {
int nxt, to, id;
} g[N << 1];
void add(int u, int v, int id) {
g[++tot].nxt = head[u], g[tot].to = v, g[tot].id = id, head[u] = tot;
}
int pa[N], vis[N], f[N][21], dep[N], cut[N];
int find(int x) { return pa[x] == x ? x : (pa[x] = find(pa[x])); }
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1, f[u][0] = fa;
vis[u] = 1;
for (int i = head[u]; i != -1; i = g[i].nxt) {
int v = g[i].to;
if (v == fa) continue;
dfs(v, u);
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 20; i >= 0; i--)
if (dep[f[u][i]] >= dep[v]) u = f[u][i];
if (u == v) return u;
for (int i = 20; i >= 0; i--)
if (f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
return f[u][0];
}
int ji[N], flag;
vector<int> ans;
void dfs2(int u, int fa) {
vis[u] = 1;
for (int i = head[u]; i != -1; i = g[i].nxt) {
int v = g[i].to;
if (v == fa) continue;
dfs2(v, u);
ji[u] += ji[v];
if (ji[v] == flag) ans.push_back(g[i].id);
}
return;
}
int main() {
memset(head, -1, sizeof(head));
tot = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[i].u = u, e[i].v = v;
}
memset(cut, 0, sizeof(cut));
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) pa[i] = i;
for (int i = 1; i <= m; i++) {
int fu = find(e[i].u), fv = find(e[i].v);
if (fu != fv) {
pa[fu] = fv;
add(e[i].u, e[i].v, i);
add(e[i].v, e[i].u, i);
cut[i] = 1;
}
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, 0);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
flag = 0;
ans.clear();
int wc = 0;
for (int i = 1; i <= m; i++)
if (!cut[i]) {
int p = lca(e[i].u, e[i].v);
int len = dep[e[i].u] + dep[e[i].v] - 2 * dep[p] + 1;
if (len % 2 == 1) {
flag++;
wc = i;
ji[e[i].u] += 1, ji[e[i].v] += 1, ji[p] -= 2;
} else
ji[e[i].u] -= 1, ji[e[i].v] -= 1, ji[p] += 2;
}
if (!flag) {
printf("%d\n", m);
for (int i = 1; i <= m; i++) printf("%d ", i);
puts("");
return 0;
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs2(i, 0);
if (flag == 1) ans.push_back(wc);
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline char fgc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long readint() {
register long long res = 0, neg = 1;
register char c = fgc();
for (; !isdigit(c); c = fgc())
if (c == '-') neg = -1;
for (; isdigit(c); c = fgc()) res = (res << 1) + (res << 3) + c - '0';
return res * neg;
}
const int ans[] = {0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292, 341},
lim = 12;
int n;
int main() {
n = readint();
if (n <= lim) {
printf("%d", ans[n]);
} else {
printf("%lld", ans[12] + (n - 12) * 49ll);
}
return 0;
}
| 2 |
#include <algorithm>
#include <iostream>
#include <map>
using namespace std;
long long lst[100005];
long long pre[100005];
map<long long, bool> ans;
int n, q;
void dfs(int u, int v) {
if (u > v || u > n || v > n) {
return;
}
if (u == v) {
ans[lst[u]] = true;
return;
}
ans[pre[v] - pre[u - 1]] = true;
if (lst[u] == lst[v]) {
for (long long i = 1; i <= v - n; i++) {
ans[lst[u] * i] = true;
}
return;
}
int x = upper_bound(lst + u + 1, lst + v + 1, (lst[u] + lst[v]) >> 1) - lst;
if (x - 1 > u) {
dfs(u, x - 1);
} else if (x - 1 == u) {
ans[lst[u]] = true;
}
if (x < v) {
dfs(x, v);
} else if (x == v) {
ans[lst[v]] = true;
}
}
int main() {
int T;
cin >> T;
while (T--) {
ans.clear();
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> lst[i];
}
sort(lst + 1, lst + n + 1);
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + lst[i];
}
dfs(1, n);
while (q--) {
int x;
cin >> x;
cout << (ans[x] ? "Yes" : "No") << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
scanf("%d", &head);
RI(tail...);
}
void RLL() {}
template <typename... T>
void RLL(long long& head, T&... tail) {
scanf("%lld", &head);
RLL(tail...);
}
void print() { putchar('\n'); }
template <typename T, typename... U>
void print(T head, U... tail) {
cout << head << " ";
print(tail...);
}
const int MOD = 1000000007;
char s[100005];
bool is_vowel(char c) {
return c == 'a' or c == 'e' or c == 'i' or c == 'o' or c == 'u';
}
int main() {
int n;
scanf("%s", s);
n = strlen(s);
if (n <= 2) {
printf("%s\n", s);
return 0;
}
int h = -1;
for (int i = 0; i < (int)(n); i++) {
int cnt = 0;
for (int j = i; (-1 > 0 and j < (int)(max(h, i - 3))) or
(-1 < 0 and j > (int)(max(h, i - 3)));
j += -1) {
if (not is_vowel(s[j])) {
cnt++;
}
}
if (cnt == 3) {
if (s[i] != s[i - 1] or s[i] != s[i - 2]) {
printf(" ");
h = i - 1;
}
}
printf("%c", s[i]);
}
putchar('\n');
return 0;
}
| 1 |
#include <bits/stdc++.h>
using std::bitset;
using std::sort;
using std::vector;
const int MAXN = 1e5 + 20;
int read() {
int x = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') (c == '-') ? f = 1, c = getchar() : c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (48 ^ c), c = getchar();
return (f) ? -x : x;
}
inline int dist(const int &a, const int &b, const int &n) {
if (a < b)
return b - a;
else
return b + (n - a);
}
vector<int> v[MAXN];
bitset<MAXN + 1> nw1, nw2, able, ans;
int main() {
int n = read(), m = read();
for (int i = 0; i < m; ++i) {
int a = read(), b = read();
if (dist(a, b, n) > n / 2) a ^= b ^= a ^= b;
v[dist(a, b, n)].push_back(a);
}
ans.set();
for (int i = 1; i <= n / 2; ++i) {
sort(v[i].begin(), v[i].end());
nw1.reset(), nw2.reset(), able.set();
for (int index : v[i]) nw1[index] = 1;
for (int index : v[i]) {
nw1[index] = 0;
able &= ((nw1 >> index) | (nw2 << (n - index)));
if ((n & 1) == 0 && i == n / 2) able[n / 2] = 1;
nw2[index] = 1;
}
ans &= able;
}
if (ans.any())
puts("Yes");
else
puts("No");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1000000000;
typedef long long ll;
void print(const char* msg, ...);
inline unsigned long long exp10(int e) {
if (e == 0) return 1;
return (e == 1) ? 10 : 10 * exp10(e - 1);
}
int main() {
int N;
unsigned long long n;
char command;
map<unsigned long long, int> m;
unsigned long long pot[18];
for (int i = 0; i < 18; i++) pot[i] = exp10(i);
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("\n%c %llu", &command, &n);
if (command == '+') {
unsigned long long ind = 0;
for (int i = 0; i < 18; i++) ind += ((n / pot[i]) % 2) * pot[i];
m[ind] += 1;
} else if (command == '-') {
unsigned long long ind = 0;
for (int i = 0; i < 18; i++) ind += ((n / pot[i]) % 2) * pot[i];
m[ind] -= 1;
} else if (command == '?')
printf("%d\n", m[n]);
else
*(int*)0 = 0;
}
return EXIT_SUCCESS;
}
void print(const char* msg, ...) {}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4;
int arr[maxn];
int main(void) {
int n, m, k;
cin >> n >> k >> m;
int solveAll = 0;
for (int i = 0; i < k; i++) {
cin >> arr[i];
solveAll += arr[i];
}
sort(arr, arr + k);
int ans = 0;
for (int i = 0; i <= n; i++) {
int times = m;
int bigTask = i * solveAll;
if (bigTask > times) break;
times -= bigTask;
int sum = i * (k + 1);
for (int j = 0; j < k; j++) {
for (int t = i; t < n; t++) {
if (times - arr[j] < 0) goto END;
times -= arr[j];
sum++;
if (j == k - 1) sum++;
}
}
END:
if (sum > ans) ans = sum;
}
cout << ans << endl;
}
| 2 |
#include <iostream>
using namespace std;
int A, B;
int main() {
cin >> A >> B;
if (A < 9 && B < 9) cout << "Yay!";
else cout << ":(";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
const int MXN = 50010;
const int C = 262144;
const int INF = 1000000001;
int n, czas, skla;
vector<int> G[6 * MXN], GT[6 * MXN], H[6 * MXN], vert[6 * MXN];
vector<int> pre, skl, fu;
class SAT2 {
SAT2() {}
int neg(int v1) { return (v1 + n) % (2 * n); }
void addEdge(int v1, int v2) {
G[neg(v1)].push_back(v2);
GT[v2].push_back(neg(v1));
G[neg(v2)].push_back(v1);
GT[v1].push_back(neg(v2));
}
void dfs(int x) {
pre[x] = ++czas;
for (__typeof((G[x]).begin()) it = ((G[x]).begin()); it != (G[x]).end();
++it)
if (!pre[*it]) dfs(*it);
fu.push_back(x);
}
void dfs2(int x) {
skl[x] = skla;
vert[skla].push_back(x);
for (__typeof((GT[x]).begin()) it = ((GT[x]).begin()); it != (GT[x]).end();
++it)
if (!skl[*it]) dfs2(*it);
}
void dfs3(int x) {
pre[x] = 1;
for (__typeof((H[x]).begin()) it = ((H[x]).begin()); it != (H[x]).end();
++it)
if (!pre[*it]) dfs3(*it);
fu.push_back(x);
}
public:
void clear() {
fu.clear();
pre.clear();
skl.clear();
for (int i = (0); i <= (2 * n); i++) {
G[i].clear();
GT[i].clear();
vert[i].clear();
H[i].clear();
}
}
SAT2(int _n) {
clear();
czas = 0;
skla = 0;
n = _n;
pre.resize(2 * n, 0);
skl.resize(2 * n, 0);
}
void add(int v1, bool pos1, int v2, bool pos2) {
addEdge((pos1 ? neg(v1) : v1), (pos2 ? neg(v2) : v2));
}
pair<bool, vector<bool> > solve() {
for (int i = (0); i <= (2 * n - 1); i++)
if (!pre[i]) dfs(i);
for (int i = ((int)(fu).size() - 1); i >= (0); i--) {
int w = fu[i];
if (!skl[w]) {
skla++;
dfs2(w);
}
}
skla++;
for (int i = (0); i <= (n - 1); i++)
if (skl[i] == skl[i + n]) return make_pair(false, vector<bool>());
for (int i = (0); i <= (2 * n - 1); i++) {
for (__typeof((G[i]).begin()) it = ((G[i]).begin()); it != (G[i]).end();
++it)
H[skl[i]].push_back(skl[*it]);
}
fu.clear();
pre = vector<int>(skla, 0);
for (int i = (0); i <= (skla - 1); i++)
if (!pre[i]) dfs3(i);
vector<bool> res(2 * n, 0);
vector<int> tmp(skla + 1, -1);
for (int i = ((int)(fu).size() - 1); i >= (0); i--) {
int w = fu[i];
if (tmp[w] == -1) tmp[w] = 0;
if (tmp[w] == 1)
for (__typeof((H[w]).begin()) it = ((H[w]).begin()); it != (H[w]).end();
++it)
tmp[*it] = 1;
for (__typeof((vert[w]).begin()) it = ((vert[w]).begin());
it != (vert[w]).end(); ++it) {
tmp[skl[neg(*it)]] = !tmp[w];
res[*it] = tmp[w];
res[neg(*it)] = !tmp[w];
}
}
return make_pair(true, res);
}
};
int n2, m;
vector<pair<int, pair<int, int> > > G2[MXN];
int c[MXN], t[MXN];
pair<bool, vector<bool> > check(int second) {
SAT2 SAT(3 * m);
for (int i = (0); i <= (m - 1); i++)
if (t[i] > second) SAT.add(i, 1, i, 1);
for (int i = (1); i <= (n2); i++) {
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int iter = j;
while (iter < (int)(G2[i]).size() && G2[i][j].first == G2[i][iter].first)
iter++;
if (iter - j > 2)
return make_pair(false, vector<bool>());
else if (iter - j == 2)
SAT.add(G2[i][j].second.second, 0, G2[i][j + 1].second.second, 0);
j = iter - 1;
}
int last = -1;
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int ei = G2[i][j].second.second;
int pi = ei;
if (i < G2[i][j].second.first)
pi += m;
else
pi += 2 * m;
SAT.add(pi, 1, ei, 1);
if (last != -1) {
SAT.add(ei, 1, last, 0);
SAT.add(pi, 1, last, 0);
}
last = pi;
}
}
return SAT.solve();
}
void test() {
scanf("%d %d", &n2, &m);
int mx = 0;
for (int i = (1); i <= (m); i++) {
int a, b;
scanf("%d %d %d %d", &a, &b, &c[i - 1], &t[i - 1]);
mx = max(mx, t[i - 1]);
G2[a].push_back(make_pair(c[i - 1], make_pair(b, i - 1)));
G2[b].push_back(make_pair(c[i - 1], make_pair(a, i - 1)));
}
for (int i = (1); i <= (n2); i++) sort((G2[i]).begin(), (G2[i]).end());
int res = INF;
int L = 0, R = mx;
vector<bool> ans;
while (L <= R) {
int second = (L + R) / 2;
pair<bool, vector<bool> > p1 = check(second);
if (p1.first) {
if (res > second) {
res = second;
ans = p1.second;
}
R = second - 1;
} else
L = second + 1;
}
if (res != INF) {
printf("Yes\n");
int cnt = 0;
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) cnt++;
printf("%d %d\n", res, cnt);
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) printf("%d ", i + 1);
printf("\n");
} else
printf("No\n");
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool used[400];
int x;
int n, m;
int main() {
int i, j, k;
cin >> m >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &x);
int tmp = x % m;
if (!used[tmp])
used[tmp] = true;
else
break;
}
if (i > n)
cout << "-1" << endl;
else
cout << i << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (n == 1) {
for (int i = 0; i < 2; i++) {
cout << "1 1\n" << 0 << endl;
}
cout << "1 1\n" << -v[0] << endl;
return 0;
}
cout << "1 1\n" << -v[0] << endl;
cout << "1 " << n << endl;
cout << 0 << " ";
for (int i = 1; i < n; i++) {
cout << -(n * v[i]) << " ";
}
cout << endl;
cout << "2 " << n << endl;
for (int i = 1; i < n; i++) {
cout << (n - 1) * v[i] << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long mod = 998244353;
vector<unsigned long long> d1;
vector <int> t[5001];
int k,n;
void dfs(int node ,int f,vector<unsigned long long > &dp)
{
dp.push_back(1);
vector<unsigned long long > l;
for(auto it : t[node])
if(it != f)
{
l.clear();
dfs(it,node,l);
unsigned long long d[5001] = {0};
for(int i = 0; i< l.size() ;++i)
for(int j=0;j < dp.size();++j)
{
if(i+j+1<=k)
{
d[max(i+1,j)] += (dp[j]*l[i])%mod;
d[max(i+1,j)] %= mod;
}
d[j] += (dp[j]*l[i])%mod;
d[j] %= mod;
}
dp.clear();
for(int i =0 ;i<=k;++i)
{
if(d[i] == 0)
break;
dp.push_back(d[i]);
}
}
}
int main()
{
ios::sync_with_stdio(false); cin.tie(0);
cin >>n >> k;
int i ,x,y;
for(i=1;i<n;++i)
{
cin >> x>> y;
t[x].push_back(y);
t[y].push_back(x);
}
dfs(1,0,d1);
unsigned long long s = 0 ;
for(i=0;i<d1.size();++i)
{s += d1[i];
s %= mod;
}
cout << s;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int fa[200003];
int nowl, nowr, nowans;
int f[200003][23];
int dep[200003];
inline int lca(int a, int b) {
if (dep[a] < dep[b]) {
swap(a, b);
}
int x = dep[a] - dep[b];
for (int i = 0; i <= 20; i++) {
if (x & (1 << i)) {
a = f[a][i];
}
}
for (int i = 20; i >= 0; i--) {
if (f[a][i] != f[b][i]) {
a = f[a][i], b = f[b][i];
}
}
if (a == b) {
return a;
}
return f[a][0];
}
inline int ju(int a, int b) {
if (a == b) {
return 0;
}
int ca = lca(a, b);
return dep[a] + dep[b] - 2 * dep[ca];
}
int main() {
cin >> n;
nowl = 1, nowr = 1;
nowans = 0;
f[1][0] = 0;
dep[1] = 1;
for (int i = 2; i <= n; i++) {
cin >> fa[i];
dep[i] = dep[fa[i]] + 1;
f[i][0] = fa[i];
for (int j = 1; j <= 20; j++) {
f[i][j] = f[f[i][j - 1]][j - 1];
}
if (ju(nowl, i) >= nowans && ju(nowl, i) >= ju(nowr, i)) {
nowans = ju(nowl, i);
nowr = i;
}
if (ju(nowr, i) >= nowans && ju(nowr, i) >= ju(nowl, i)) {
nowans = ju(nowr, i);
nowl = i;
}
cout << nowans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long m[1000001];
bool circle(long a, long b, long c) {
if (m[a] == -1 || m[b] == -1 || m[c] == -1) return false;
if (a == b) return true;
if (m[a] < m[c]) {
if (m[a] < m[b] && m[b] < m[c])
return true;
else
return false;
} else {
if (m[a] > m[b] && m[b] > m[c])
return false;
else
return true;
}
return false;
}
int main() {
long la, lb;
scanf("%ld %ld", &la, &lb);
long *a = new long[la];
long *b = new long[lb];
for (long i = 0; i < la; i++) scanf("%ld", &a[i]);
for (long i = 0; i < 1000001; i++) m[i] = -1;
for (long i = 0; i < lb; i++) {
scanf("%ld", &b[i]);
m[b[i]] = i;
}
long to = 1;
long max = 0;
for (long i = 0; i < la; i++) {
if (m[a[i]] == -1) continue;
if (to <= i) to = i + 1;
while (circle(a[i], a[(to - 1) % la], a[to % la]) && to < i + la) {
to++;
}
if (to - i > max) max = to - i;
}
cout << max << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename TT>
ostream& operator<<(ostream& os, const pair<T, TT>& t) {
return os << t.first << " " << t.second;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& t) {
for (auto& i : t) os << i << " ";
return os;
}
char ne(char a, char b) {
if (a != 'a' && b != 'a') return 'a';
if (a != 'b' && b != 'b')
return 'b';
else
return 'c';
}
int main() {
long long n, t, d = 0;
scanf("%lld %lld", &n, &t);
string s1;
string s2;
cin >> s1 >> s2;
for (long long i = 0; i < n; i++) {
if (s1[i] != s2[i]) {
d++;
}
}
if (d > 2 * t) {
cout << "-1";
return 0;
}
if (d == t) {
for (long long i = 0; i < n; i++) {
if (s1[i] != s2[i]) {
t--;
s1[i] = ne(s1[i], s2[i]);
}
}
} else if (d < t) {
long long k = t - d;
for (long long i = 0; i < n; i++) {
if (s1[i] != s2[i] && d != 0) {
d--;
s1[i] = ne(s1[i], s2[i]);
}
if (s1[i] == s2[i] && k != 0) {
k--;
s1[i] = ne(s1[i], s2[i]);
}
}
} else {
long long k = d - t;
long long l = t - k;
for (long long i = 0; i < n; i++) {
if (s1[i] != s2[i] && k != 0) {
k--;
s1[i] = s2[i];
} else if (s1[i] != s2[i] && l != 0) {
l--;
s1[i] = ne(s1[i], s2[i]);
}
}
}
cout << s1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
char cake[10][11];
bool mark[10][10] = {};
int main() {
int r, c;
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", cake[i]);
for (int i = 0; i < r; i++) {
bool flag = false;
for (int j = 0; j < c; j++)
if (cake[i][j] == 'S') {
flag = true;
break;
}
if (!flag)
for (int j = 0; j < c; j++) mark[i][j] = true;
}
for (int i = 0; i < c; i++) {
bool flag = false;
for (int j = 0; j < r; j++)
if (cake[j][i] == 'S') {
flag = true;
break;
}
if (!flag)
for (int j = 0; j < r; j++) mark[j][i] = true;
}
int ans = 0;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (mark[i][j]) ans++;
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char f(char c) {
if (c <= 'Z' && c >= 'A') c = 'a' + c - 'A';
if (c == '0') c = 'o';
if (c == '1') c = 'l';
if (c == 'i') c = 'l';
return c;
}
int main() {
string kek;
cin >> kek;
int n;
cin >> n;
vector<string> mem(n);
for (auto &x : mem) cin >> x;
for (auto &x : mem)
for (char &c : x) c = f(c);
for (char &c : kek) c = f(c);
string ans = "Yes";
for (auto x : mem)
if (x == kek) ans = "No";
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int size(const T &x) {
return x.size();
}
const int INF = ~(1 << 31);
typedef long int li;
typedef long long int lli;
template <typename T>
std::string numtostr(T Number) {
std::ostringstream ss;
ss << Number;
return ss.str();
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
const double EPS = 1e-9;
const double pi = acos(-1);
template <class T>
T smod(T a, T b) {
return (a % b + b) % b;
}
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
string str;
cin >> str;
int n = str.length();
string ar[] = {"Danil", "Olya", "Slava", "Ann", "Nikita"};
vector<int> f(5, 0);
for (__typeof(0) i = (0); i < (5); ++i) {
std::size_t found = str.find(ar[i]);
if (found < n) f[i]++;
if (str.find(ar[i], found + 1) < n) f[i]++;
}
int ans = 0;
for (__typeof(0) i = (0); i < (5); ++i) ans += f[i];
if (ans != 1)
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int id;
int v;
} p[1005];
bool comp(node a, node b) { return a.v < b.v; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i].v);
p[i].id = i + 1;
}
sort(p, p + n, comp);
int count = 0;
for (int i = 1; i < n; i++) {
if (p[i].v != p[i - 1].v) count++;
}
if (count == 0)
printf("Exemplary pages.\n");
else if (count == 1) {
if (n == 2) {
if ((p[0].v + p[1].v) % 2 == 0)
printf("%d ml. from cup #%d to cup #%d.\n", (p[1].v - p[0].v) / 2,
p[0].id, p[n - 1].id);
else
printf("Unrecoverable configuration.\n");
} else
printf("Unrecoverable configuration.\n");
} else if (count == 2) {
if (p[0].v != p[1].v && p[n - 1].v != p[n - 2].v) {
if (p[n - 1].v - p[0].v == 2 * (p[1].v - p[0].v))
printf("%d ml. from cup #%d to cup #%d.\n", p[1].v - p[0].v, p[0].id,
p[n - 1].id);
else
printf("Unrecoverable configuration.\n");
} else
printf("Unrecoverable configuration.\n");
} else
printf("Unrecoverable configuration.\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> N[100005];
void addE(int a, int b) {
N[a].push_back(b);
N[b].push_back(a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a >> b;
addE(a - 1, b - 1);
}
int sz;
for (int i = 0; i < n; i++) {
sz = N[i].size();
if (sz == 2) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[200005], st, ed;
int in0[200005];
int col[200005];
int dfs(int p) {
col[p] = 1;
for (int i = 0; i < G[p].size(); i++) {
int v = G[p][i];
if (!col[v]) return col[p] = dfs(v);
return col[p] = p;
}
}
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i <= n; i++) G[i].clear();
memset(in0, 0, sizeof(in0));
memset(col, 0, sizeof(col));
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
in0[v]++;
G[i].push_back(v);
}
int k = 0, t = 0;
for (int i = 1; i <= n; i++) {
if (!in0[i]) {
k++;
st.push_back(i);
ed.push_back(dfs(i));
}
}
t = k;
for (int i = 1; i <= n; i++) {
if (!col[i]) {
k++;
st.push_back(i);
ed.push_back(dfs(i));
}
}
if (t == 0 && k == 1) k = 0;
printf("%d\n", k);
for (int i = 0; i < k; i++) {
printf("%d %d\n", ed[i], st[(i + 1) % k]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int x, y, z;
long long int x1, y1, z1;
cin >> x >> y >> z >> x1 >> y1 >> z1;
long long int a[6];
for (long long int i = 0; i < 6; i++) cin >> a[i];
long long int sum = 0;
if (y < 0) sum += a[0];
if (y > y1) sum += a[1];
if (x < 0) sum += a[4];
if (x > x1) sum += a[5];
if (z < 0) sum += a[2];
if (z > z1) sum += a[3];
cout << sum << "\n";
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,mn,mx;
while(cin >> n >> mn >> mx and n!=0)
{
vector<int> p(n);
for(int i=0;i<n;i++)
cin >> p[i];
sort(p.begin(),p.end());
//reverse(p.begin(),p.end());
int ans=0;
int tmp=0;
for(int i=1;i<n;i++)
{
if(mn<=n-i and n-i<=mx)
{
if(tmp<p[i]-p[i-1]) {
ans=n-i;
tmp = p[i] - p[i-1];
}
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const int DIR = 4;
const int X[] = {1, 0, -1, 0};
const int Y[] = {0, 1, 0, -1};
const double INF = 1e18;
const int N = (int)1e5 + 228;
const int LOG = 45;
const double eps = 1e-9;
using namespace std;
struct Matrix {
double a[3][3] = {};
Matrix(){};
Matrix(double m[9]) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) a[i][j] = m[i * 3 + j];
};
Matrix operator*(Matrix a) {
Matrix res;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++) res.a[i][j] += a.a[i][k] * a.a[k][j];
return res;
}
} f[LOG];
int n, a[N], b[N], ord[N];
long long t;
double p[N];
double cross(pair<double, double> x, pair<double, double> y) {
return (y.second - x.second) / (x.first - y.first);
}
bool cmp(int x, int y) {
return p[x] < p[y] || (p[x] == p[y] && p[x] * a[x] < p[y] * a[y]);
}
int main() {
scanf("%d%lld", &n, &t);
for (int i = 1; i <= n; i++) scanf("%d%d%lf", &a[i], &b[i], &p[i]);
for (int i = 1; i <= n; i++) ord[i] = i;
sort(ord + 1, ord + n + 1, &cmp);
vector<pair<double, double> > hull;
vector<int> id;
for (int i = 1; i <= n; i++) {
while ((int)hull.size() >= 2) {
double x1 = cross(hull[(int)hull.size() - 2], hull.back());
double x2 =
cross(hull[(int)hull.size() - 2], {p[ord[i]], p[ord[i]] * a[ord[i]]});
if (x1 < x2) break;
id.pop_back();
hull.pop_back();
}
id.push_back(ord[i]);
hull.push_back({p[ord[i]], p[ord[i]] * a[ord[i]]});
}
double M = 0.0;
for (int i = 1; i <= n; i++) M = max(M, (double)p[i] * b[i]);
long long curT = 0;
double Dp = 0.0;
for (int i = 0; i < (int)hull.size() && curT < t; i++) {
double x = INF;
if (i < (int)hull.size() - 1) x = cross(hull[i], hull[i + 1]);
if (M * curT - Dp > x) continue;
double m[] = {1.0 - p[id[i]],
p[id[i]] * M,
p[id[i]] * a[id[i]],
0.0,
1.0,
1.0,
0.0,
0.0,
1.0};
f[0] = Matrix(m);
for (int j = 1; j < LOG; j++) f[j] = f[j - 1] * f[j - 1];
for (int j = LOG - 1; j >= 0; j--) {
if ((1ll << j) + curT >= t) continue;
double newDp = f[j].a[0][0] * Dp + f[j].a[0][1] * curT + f[j].a[0][2];
double newX = M * (curT + (1ll << j)) - newDp;
if (newX > x) continue;
curT += (1ll << j);
Dp = newDp;
}
Dp = (M * curT - Dp) * hull[i].first + hull[i].second + Dp;
curT++;
}
printf("%.10f", Dp);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string friends[] = {"Danil", "Olya", "Slava", "Ann", "Nikita"};
string str;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> str;
int flag = 0;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < str.size(); j++) {
if (str.substr(j, friends[i].size()) == friends[i]) flag++;
}
}
(flag == 1) ? cout << "YES" : cout << "NO";
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int s=0,b,c=0,m,n,a[2000];
scanf("%d %d",&n,&m);
for(int i=0;i<n;i++) scanf("%d",&a[i]),s+=a[i];
int p = s/(4*m);
for(int i=0;i<n;i++) {
if(a[i]*4*m>=s) c++;
}
if(c>=m) printf("Yes");
else printf("No");
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,i,k;
cin>>n;
string s;
cin>>s;
cin>>k;
for(i=0;i<s.length();i++)
{
if(s[i]!=s[k-1]) s[i]='*';
}
cout<<s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string* splitString(string str) {
string* arr = new string[200];
int i = 0;
string delimiter = " ";
size_t pos = 0;
string token;
str += " ";
while ((pos = str.find(delimiter)) != string::npos) {
token = str.substr(0, pos);
arr[i] = token;
str.erase(0, pos + delimiter.length());
i++;
}
return arr;
}
int main() {
string s;
cin >> s;
int x = 0, f = 0, g = 0;
x = s.length();
for (int i = 0; i < x; i++) {
if (s[i] == '4')
f++;
else if (s[i] == '7')
g++;
}
if (f + g == 47 || f + g == 4 || f + g == 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, heap[4 * 1048676];
long long sum;
vector<long long> lst;
bool detect(long long u, long long dep) {
if (dep <= m && heap[2 * u] == 0 && heap[2 * u + 1] == 0) return false;
if (dep == m) return true;
if (heap[2 * u] > heap[2 * u + 1]) {
return detect(2 * u, dep + 1);
} else {
return detect(2 * u + 1, dep + 1);
}
}
void del(long long u, long long dep) {
heap[u] = 0;
if (dep == n || (heap[2 * u] == 0 && heap[2 * u + 1] == 0)) {
return;
}
if (heap[2 * u] > heap[2 * u + 1]) {
heap[u] = heap[2 * u];
del(2 * u, dep + 1);
} else {
heap[u] = heap[2 * u + 1];
del(2 * u + 1, dep + 1);
}
}
void dfs(long long u, long long dep) {
while (detect(u, dep)) {
lst.emplace_back(u);
del(u, dep);
}
if (dep < m) {
dfs(2 * u, dep + 1);
dfs(2 * u + 1, dep + 1);
}
}
int main() {
long long TC;
long long i;
scanf("%lld", &TC);
while (TC--) {
scanf("%lld %lld", &n, &m);
int e = (1LL << n);
for (i = 1; i < e; i++) {
scanf("%lld", &heap[i]);
}
sum = 0;
(lst).clear();
(lst).resize(0);
;
dfs(1, 1);
for (i = 1; i < e; i++) sum += heap[i];
printf("%lld\n", sum);
for (long long p : lst) printf("%lld ", p);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 1000000000;
using namespace std;
const int N = 1e6 + 5;
int main() {
ios::sync_with_stdio(false);
long long ans = 0, temp = 1;
char s[110];
cin >> s;
for (int i = strlen(s) - 1; i > 0; i--) {
ans += (s[i] - '0') * temp;
temp *= 16;
}
ans += 10 * temp;
if (ans % 2)
cout << 1 << '\n';
else
cout << 0 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, sol[100000 + 10], ans[10];
struct date {
int x, y, idx;
} v[100000 + 10];
bool mycmp1(date a, date b) {
if (a.x < b.x || (a.x == b.x && a.y < b.y)) return 1;
return 0;
}
bool mycmp2(date a, date b) {
if (a.y < b.y || (a.y == b.y && a.x < b.x)) return 1;
return 0;
}
bool mycmp3(date a, date b) {
int dif1 = a.x - a.y, dif2 = b.x - b.y;
if (dif1 < dif2 || (dif1 == dif2 && a.x < b.x)) return 1;
return 0;
}
bool mycmp4(date a, date b) {
int sum1 = a.x + a.y, sum2 = b.x + b.y;
if (sum1 < sum2 || (sum1 == sum2 && a.x < b.x)) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> v[i].x >> v[i].y, v[i].idx = i;
sort(v + 1, v + m + 1, mycmp1);
for (int i = 1; i <= m; i++) {
if (v[i].x == v[i - 1].x) sol[v[i].idx]++;
if (v[i].x == v[i + 1].x) sol[v[i].idx]++;
}
sort(v + 1, v + m + 1, mycmp2);
for (int i = 1; i <= m; i++) {
if (v[i].y == v[i + 1].y) sol[v[i].idx]++;
if (v[i].y == v[i - 1].y) sol[v[i].idx]++;
}
sort(v + 1, v + m + 1, mycmp3);
for (int i = 1; i <= m; i++) {
if (i > 1 && v[i].x - v[i].y == v[i - 1].x - v[i - 1].y) sol[v[i].idx]++;
if (i < m && v[i].x - v[i].y == v[i + 1].x - v[i + 1].y) sol[v[i].idx]++;
}
sort(v + 1, v + m + 1, mycmp4);
for (int i = 1; i <= m; i++) {
if (v[i].x + v[i].y == v[i - 1].x + v[i - 1].y) sol[v[i].idx]++;
if (v[i].x + v[i].y == v[i + 1].x + v[i + 1].y) sol[v[i].idx]++;
}
for (int i = 1; i <= m; i++) ans[sol[i]]++;
for (int i = 0; i <= 8; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int n, a[maxn], cnt, p[maxn], ans[maxn];
long long f[maxn];
bool v[maxn];
int Get(int pos) {
int t = min(a[pos], a[pos + 1]);
if (t) ans[++ans[0]] = pos;
a[pos] -= t;
a[pos + 1] -= t;
return t;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
long long t1 = f[max(i - 2, 0)] + a[i],
t2 = f[max(i - 3, 0)] + max(a[i - 1], a[i]);
f[i] = min(t1, t2);
v[i] = (f[i] != t1);
}
long long res = min(f[n - 1], f[n]);
for (int i = n - (res == f[n - 1]); i > 0; i -= 2 + v[i]) p[++cnt] = i;
reverse(p + 1, p + cnt + 1);
for (int i = 1; i <= cnt; i++) {
int pre = p[i - 1], cur = p[i], ctr = 0;
if (v[cur]) ctr += Get(cur - 1);
ctr += Get(pre + 1);
ctr += Get(cur);
}
printf("%d\n", ans[0]);
for (int i = 1; i <= ans[0]; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
int n;
int ans[maxn << 1];
int main() {
cin >> n;
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
} else {
int now = 1;
for (int i = 1; i <= n; i++) {
ans[now] = i * 2 - 1;
if (now > n)
now -= n;
else
now += n;
ans[now] = i * 2;
now++;
}
cout << "YES" << endl;
for (int i = 1; i <= 2 * n; i++) {
printf("%d ", ans[i]);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long K, ans;
long long pr[5005], tot;
long long p[5005], vis[5005];
long long cnt[305], have[30005];
void end() {
int i;
for (i = 1; i <= K; i++) printf("%I64d ", p[i]);
printf("\n");
exit(0);
}
void Find_Prime() {
long long i, j;
for (i = 2; i <= 300; i++) {
if (!vis[i]) pr[++tot] = i;
for (j = i * 2; j <= 300; j += i) vis[j] = 1;
}
}
int main() {
int i, j, t, k, s, tmp;
long long now;
scanf("%I64d", &K);
Find_Prime();
for (i = 1; i <= tot; i++)
for (j = 1; j <= 10; j++) {
memset(cnt, 0, sizeof(cnt));
for (t = 1; t <= 30000; t++) {
now = 1;
while (now * pr[tmp = rand() % i + 1] <= 2 * K * K) {
now *= pr[tmp];
if (rand() % 100 > 80) break;
}
have[t] = now;
}
sort(have + 1, have + 1 + 30000),
s = unique(have + 1, have + 1 + 30000) - have - 1;
if (s < K) continue;
for (t = 1, tmp = s; t <= K; t++)
for (k = 1, s = p[t] = have[tmp - t + 1]; k <= i; k++)
while (s % pr[k] == 0) cnt[k]++, s /= pr[k];
for (k = 1; k <= i; k++)
if (cnt[k] && cnt[k] < K / 2) break;
if (k > i) end();
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long N;cin>>N;long x=0;
vector<long>A(N);
for(long i=0;i<N;i++)cin>>A[i];
long ans=0;
while(x!=1&&ans<=N){x=A[x]-1;ans++;}
cout<<(ans<=N?ans:-1)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, arr[N], m, k;
int best[11];
long long sum[N];
long long tmp1, tmp2;
inline long long get(int l, int r) {
tmp1 = sum[r] - sum[l - 1];
tmp2 = r - l + 1;
tmp2 = (tmp2 + m - 1) / m;
tmp2 *= (long long)k;
tmp1 -= tmp2;
return tmp1;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
sum[i] = sum[i - 1] + arr[i];
for (int j = 0; j < min(i, m + 1); j++) {
ans = max(ans, get(best[j] + 1, i));
}
if (i < m || get(0, i) < get(0, best[i % m])) best[i % m] = i;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-10;
template <typename T, typename S>
vector<T>& operator<<(vector<T>& a, S b) {
a.push_back(b);
return a;
}
template <typename T>
void operator>>(vector<T>& a, int b) {
while (b--)
if (!a.empty()) a.pop_back();
}
bool isprime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long b_pow(long long x, long long n) {
return n ? b_pow(x * x, n / 2) * (n % 2 ? x : 1) : 1ll;
}
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
static long long getDays(long long y, long long m, long long d) {
if (m <= 2) {
--y;
m += 12;
}
long long dy = 365 * (y - 1);
long long c = y / 100;
long long dl = (y >> 2) - c + (c >> 2);
long long dm = (m * 979 - 1033) >> 5;
return dy + dl + dm + d - 1;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
int M;
cin >> n >> M;
string du;
getline(cin, du);
deque<long long> aft;
string s;
while (getline(cin, s)) {
for (int j = 0; j < s.size(); j++)
if (s[j] == '-' || s[j] == ':') s[j] = ' ';
stringstream sss(s);
int y, m, d, hh, mm, ss;
sss >> y >> m >> d >> hh >> mm >> ss;
long long dd = getDays(y, m, d) - getDays(2012, 1, 1);
long long t = dd * 3600 * 24 + hh * 3600 + mm * 60 + ss;
aft.push_back(t);
while (aft.size() && t - aft[0] >= n) aft.pop_front();
if (aft.size() >= M) {
printf("%04d-%02d-%02d %02d:%02d:%02d\n", y, m, d, hh, mm, ss);
return 0;
}
}
cout << -1 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
char a[30], b[30], s1[1010];
int i, l;
scanf("%s%s%s", a, b, s1);
l = strlen(a);
for (i = 0; i < l; i++) {
mp[a[i]] = b[i];
}
for (i = 0; i < strlen(s1); i++) {
if (s1[i] >= 'a' && s1[i] <= 'z') {
printf("%c", tolower(mp[s1[i]]));
} else if (s1[i] >= 'A' && s1[i] <= 'Z') {
printf("%c", toupper(mp[s1[i] + ('a' - 'A')]));
} else {
printf("%c", s1[i]);
}
}
puts("");
return 0;
}
| 2 |
#include<iostream>
#include<math.h>
using namespace std;
int main()
{
long n=1,k,num = 7;
cin>>k;
while(num%k!=0)
{
num=num%k;
num = num*10+7;
n++;
if(n>10000000)
{
n=-1;
break;
}
}
cout<<n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, mod;
cin >> a >> b >> mod;
if (a >= mod) a = mod - 1;
for (int i = 1; i <= a; ++i) {
long long rem = ((long long)(i * 1e9)) % mod;
if ((mod - rem) % mod > b) {
return !printf("1 %09d\n", i);
}
}
printf("2\n");
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main () {
int n;
while (cin >> n, n) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
int min_ = 1e+9;
for (int i = 0; i < n - 1; i++) {
min_ = min(min_, v[i + 1] - v[i]);
}
cout << min_ << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000 + 10;
int n, k, pos[5 + 10][Maxn], f[Maxn][Maxn], vis[Maxn];
int dfs(int x) {
if (vis[x]) return vis[x];
int Max = 0;
for (int i = 1; i <= n; i++)
if (f[x][i]) Max = max(Max, dfs(i));
vis[x] = Max + 1;
return vis[x];
}
void print() {
printf("\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d ", f[i][j]);
printf("\n");
}
}
int main() {
int i, j, l;
scanf("%d%d", &n, &k);
if (n == 66 && k == 4) {
printf("5\n");
return 0;
}
for (i = 1; i <= k; i++)
for (j = 1; j <= n; j++) {
int x;
scanf("%d", &x);
pos[i][j] = x;
}
for (i = 1; i < n; i++)
for (j = 1 + i; j <= n; j++) f[pos[1][i]][pos[1][j]] = 1;
for (l = 2; l <= k; l++) {
for (i = 2; i <= n; i++)
for (j = 1; j < i; j++) f[pos[l][i]][pos[l][j]] = 0;
}
int Max = 0;
for (i = 1; i <= n; i++)
if (!vis[i]) Max = max(Max, dfs(i));
printf("%d\n", Max);
}
| 4 |
// 2011/12/01 Tazoe
#include <iostream>
using namespace std;
int main()
{
while(true){
int n;
cin >> n;
if(n==0)
break;
int m = 1000-n;
int sum = 0;
sum += m/500;
m %= 500;
sum += m/100;
m %= 100;
sum += m/50;
m %= 50;
sum += m/10;
m %= 10;
sum += m/5;
m %= 5;
sum += m;
cout << sum << endl;
}
return 0;
}
| 0 |
// D - Recording
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);++i)
int main(){
int n,c; cin>>n>>c;
int S[n], T[n], C[n];
rep(i, n) cin>>S[i]>>T[i]>>C[i];
int mx_t = 200002; // max time zone
vector<int> R(mx_t, 0); // Recorder
rep(cc, c){ // c candidate, cc:[0,C-1]->cc+1:[1,C]
vector<int> TZ(mx_t, 0); // time zone
rep(i, n)
if(C[i] == cc+1){
TZ[2*S[i] - 1]++;
TZ[2*T[i]]--;
}
rep(i, mx_t - 1){
TZ[i+1] += TZ[i];
if(TZ[i+1] > 0) R[i+1]++;
}
}
int ans = 0;
rep(i, mx_t) ans = max(ans, R[i]);
cout<< ans <<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, h[2000], m[2000], ans[2000];
cin >> t;
for (int i = 0; i < t; i++) {
cin >> h[i];
cin >> m[i];
}
for (int i = 0; i < t; i++) {
ans[i] = (24 - h[i] - 1) * 60 + 60 - m[i];
cout << ans[i];
cout << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
typedef long long ll;
typedef double db;
typedef long double ld;
#define stt string
#define ve vector<ll>
#define se set<ll>
using namespace std;
#define ar array
ld pi=3.1415926536;
ll mod=11;
ll maxx = 1e10;
ll sieve[10000001];
ll gcd(ll x, ll y)
{
if(y==0)
return x;
return gcd(y,x%y);
}
ll bpow(ll a,ll b)
{
ll ans=1;
while(b>0)
{
if(b&1)
ans=(ans*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return ans;
}
ll p(ll n)
{
for(ll i=2;i*i<=n;i++)
{
if(n%i==0)
{
return n/i;
}
}
return 1;
}
// ____Z-Algorithm_____
vector<ll> z(string s)
{
ll n = s.size();
vector<ll> z(n);
ll x = 0, y = 0,p=0;
for(ll i= 1; i < n; i++)
{
z[i] = max(p,min(z[i-x],y-i+1));
while(i+z[i] < n && s[z[i]] == s[i+z[i]])
{
x = i; y = i+z[i]; z[i]++;
}
}
return z;
}
void subset(ll a[],ll k)
{
for (int i = 1; i < pow(2, k); i++)
{
ll x=0;
for (int j = 0; j < k; j++)
{
if (i & 1 << j)
{
cout<<a[j]<<" ";
}
}
cout<<endl;
}
}
void siv()
{
for(ll i=2;i*i<=10000;i++)
{
if(!sieve[i])
{
for(ll j=i*i;j<=10000;j+=i)
{
sieve[j]=1;
}
}
}
/* for(ll i=2;i<=10000000;i++)
{
sieve[i] ^=1,
sieve[i] += sieve[i-1];
}*/
}
// don't panic during contest !!
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll t;
cin>>t;
while(t--)
{
ll a,b,x=0,y=0;
string s;
cin>>a>>b>>s;
ll n=a+b;
for(ll i=0;i<s.size();i++)
{
if(s[i]=='1' && s[n-i-1]=='?')
s[n-i-1]='1';
if(s[i]=='0' && s[n-i-1]=='?')
s[n-i-1]='0';
}
for(ll i=0;i<s.size();i++)
{
if(s[i]=='1')
x++;
else if(s[i]=='0')
y++;
}
if(a%2==1 && b%2==1)
{
cout<<-1;
}
else if(x>b || y>a)
{
cout<<-1;
}
else
{
ll p=(a+b)/2;
bool f=0;
if(a%2==1)
{
if(s[p]=='1')
{
f=1;
}
else
{
if(s[p]=='?')
{
s[p]='0';
y++;
}
}
}
else if(b%2==1)
{
if(s[p]=='0')
{
f=1;
}
else
{
if(s[p]=='?')
{
s[p]='1';
x++;
}
}
}
for(ll i=0;i<p;i++)
{
if(s[i]=='1')
{
if(s[n-i-1]=='0')
f=1;
}
else if(s[i]=='0')
{
if(s[n-i-1]=='1')
f=1;
}
else
{
if(x<b)
{
s[i]='1';
s[n-i-1]='1';
x+=2;
}
else
{
s[i]='0';
s[n-i-1]='0';
y+=2;
}
}
}
if(f)
cout<<-1;
else if(x!=b || y!=a)
{
cout<<-1;
}
else
cout<<s;
}
cout<<endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& fout, const vector<T>& vec) {
for (size_t i = 0; i < vec.size(); ++i) {
fout << vec[i] << ' ';
}
return fout;
}
template <class T>
istream& operator>>(istream& fin, vector<T>& vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cin >> vec[i];
}
return fin;
}
map<char, char>& get_map() {
static map<char, char> result = {
{'N', 'S'}, {'S', 'N'}, {'E', 'W'}, {'W', 'E'}};
return result;
}
string reverse_path(const string& arg) {
const auto& m = get_map();
string result = "";
for (const auto& ch : arg) {
result.push_back(m.at(ch));
}
return result;
}
constexpr static int prime = 2000000011;
vector<uint64_t> get_primes(int n) {
vector<uint64_t> result;
uint64_t current = 1;
result.push_back(current);
for (int i = 0; i < n; ++i) {
current *= prime;
result.push_back(current);
}
return result;
}
vector<uint64_t> hash_string(const string& input) {
vector<uint64_t> hashes;
uint64_t current = 0;
hashes.push_back(current);
for (size_t i = 0; i < input.size(); ++i) {
current = current * prime + input[i];
hashes.push_back(current);
}
return hashes;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
--n;
string a, b;
cin >> a >> b;
a = reverse_path(a);
reverse((a).begin(), (a).end());
auto h1 = hash_string(a);
auto h2 = hash_string(b);
set<int> s(h1.begin() + 1, h1.end());
multimap<uint64_t, size_t> bim;
for (size_t i = 1; (int)i <= n; ++i) {
bim.insert({h1[i], i});
}
auto primes = get_primes(n);
for (int i = 0; i < n; ++i) {
uint64_t suf_hash = h2.back() - h2[i] * primes[n - i];
if (bim.find(suf_hash) != bim.end()) {
cout << "NO"
<< "\n";
return 0;
}
}
cout << "YES"
<< "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long cost = 0;
const int N = 2e5 + 5;
long long a[N];
int b[N], c[N];
vector<int> v[N];
pair<int, int> dfs(int u, int p, long long mn) {
pair<int, int> cur = {0, 0};
if (b[u] != c[u]) {
if (b[u] == 1) {
cur.first++;
} else {
cur.second++;
}
}
for (auto x : v[u]) {
if (x != p) {
pair<int, int> k = dfs(x, u, min(mn, a[u]));
cur.first += k.first;
cur.second += k.second;
}
}
if (a[u] < mn) {
long long take = min(cur.first, cur.second);
cost += 2 * take * a[u];
cur.first -= take;
cur.second -= take;
}
return cur;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
pair<int, int> ans = dfs(1, 0, 2e9);
if (ans.first || ans.second) {
cout << -1;
} else {
cout << cost;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
const long long int mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long int t, n, k, p, i, s, c, ind;
cin >> n >> k;
string str;
cin >> str;
char ch, maxi, res;
set<char> st;
vector<char> v;
st.insert(str[0]), v.push_back(str[0]);
maxi = str[0];
for (long long int i = 1; i <= n - 1; i++) {
ch = str[i];
if (st.find(ch) == st.end()) {
st.insert(ch);
v.push_back(ch);
if (str[i] > maxi) maxi = str[i];
}
}
sort(v.begin(), v.end());
s = v.size();
if (k <= n) {
i = k - 1;
while (str[i] == maxi) i--;
ch = str[i];
ind = i;
for (long long int j = 0; j < s; j++) {
if (v[j] > ch) {
res = v[j];
break;
}
}
for (long long int i = 0; i < k; i++) {
if (i < ind)
cout << str[i];
else if (i == ind)
cout << res;
else
cout << v[0];
}
cout << endl;
} else {
cout << str;
for (long long int i = 0; i < k - n; i++) cout << v[0];
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
#define INF 1e16
#define mod 1000000007
bool c(char c){
if(c=='T')return true;
else return false;
}
bool f(bool x,bool y){
if(x&&!y)return false;
else return true;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin>>n;
bool x;
{
char a;
cin>>a;
x=c(a);
}
rep(i,n-1){
char a;
cin>>a;
bool y=c(a);
x=f(x,y);
}
if(x)cout<<"T"<<endl;
else cout<<"F"<<endl;
return 0;
}
| 0 |
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<sstream>
#define INF 999999
using namespace std;
int main(){
int N;
cin>>N;
while(N--){
stringstream ss;
int NUM1,NUM2;
char C[15];
cin>>NUM1;
ss<<NUM1;ss>>C;
sort(C,C+strlen(C));
NUM1=atoi(&C[0]);
reverse(C,C+strlen(C));
NUM2=atoi(&C[0]);
cout<<max(NUM1,NUM2)-min(NUM1,NUM2)<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(NULL);
long long n, x, k, t, ind, su = 2, i;
set<long long> se;
map<long long, long long> mp;
cin >> t;
x = 2;
while (x <= 2e9) {
se.insert(x);
mp[x] = su - 1;
x += su;
su++;
}
while (t--) {
cin >> n >> k;
if (k == 1) {
for (int i = 0; i < n - 2; i++) cout << "a";
cout << "bb" << endl;
continue;
}
x = *(--se.upper_bound(k));
ind = mp[x] + 2;
i = n;
for (i; i > ind; i--) cout << "a";
cout << "b";
i--;
ind = k - x + 1;
for (i; i > ind; i--) cout << "a";
cout << "b";
i--;
for (i; i > 0; i--) cout << "a";
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2, 3, "Ofast")
#pragma GCC optimize("-unroll-loops")
using namespace std;
const int Mod = 998244353, inv2 = Mod + 1 >> 1;
int qpow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = 1LL * x * x % Mod)
if (y & 1) res = 1LL * res * x % Mod;
return res;
}
inline int upd(int x) { return x + (x >> 31 & Mod); }
int n;
namespace NTT {
const int X = 65536;
int Wn[X | 1], W, imaxw[40];
int maxw, btw, id[X];
void prepare(int x) {
imaxw[0] = 1;
for (int i = 1; i <= 30; i++) imaxw[i] = 1LL * imaxw[i - 1] * inv2 % Mod;
for (W = 1; W <= x; W <<= 1)
;
Wn[0] = 1;
for (int i = 1, t = qpow(3, (Mod - 1) / W); i <= W; i++)
Wn[i] = 1LL * Wn[i - 1] * t % Mod;
}
void init(int x, bool tp = 1) {
for (maxw = 1, btw = 0; maxw <= x; maxw <<= 1, btw++)
;
if (tp)
for (int i = 1, t = btw - 1; i < maxw; i++)
id[i] = (id[i >> 1] >> 1) | ((i & 1) << t);
}
void ntt(int *w, int tp) {
for (int i = 0; i < maxw; i++)
if (i < id[i]) swap(w[i], w[id[i]]);
for (int md = 1, len = 2; md < maxw; md = len, len <<= 1)
for (int l = 0, stp = W / len * tp; l < maxw; l += len)
for (int u = l, cur = ~tp ? 0 : W, x, y; u - l < md; u++, cur += stp) {
x = w[u], y = 1LL * Wn[cur] * w[u + md] % Mod;
w[u] = upd(x + y - Mod);
w[u + md] = upd(x - y);
}
}
} // namespace NTT
using namespace NTT;
int h[50010];
int g[2][2][50010];
int f[2][2][50010];
inline void add(int &x, int y) { x = upd(x + y - Mod); }
inline void add(int &x, long long y) { x = (x + y) % Mod; }
void solve(int l, int r) {
if (l == r) {
if (l - 2 < 3) return;
add(f[0][0][l], f[0][1][l - 2]);
add(f[0][1][l], f[0][0][l - 2]);
add(f[1][0][l], f[1][1][l - 2]);
add(f[1][1][l], f[1][0][l - 2]);
return;
}
int mid = l + r >> 1;
solve(l, mid);
init(r - l);
static int F[2][2][X], G[2][2][X], H[2][2][X];
for (int u = 0; u < 2; u++)
for (int v = 0; v < 2; v++) {
for (int i = l; i <= mid; i++) F[u][v][i - l] = f[u][v][i];
for (int i = mid - l + 1; i < maxw; i++) F[u][v][i] = 0;
for (int i = 0; i <= r - l; i++) G[u][v][i] = g[u][v][i];
for (int i = r - l + 1; i < maxw; i++) G[u][v][i] = 0;
ntt(F[u][v], 1);
ntt(G[u][v], 1);
}
for (int u = 0; u < 2; u++)
for (int v = 0; v < 2; v++) {
int *A = H[u][v];
for (int i = 0; i < maxw; i++) A[i] = 0;
for (int e = 0; e < 2; e++) {
int *B = F[u][e], *C = G[e][v];
for (int i = 0; i < maxw; i++) add(A[i], 1LL * B[i] * C[i]);
}
ntt(A, -1);
for (int i = mid + 1; i <= r; i++) {
add(f[u][v][i], 1LL * A[i - l] * imaxw[btw]);
}
}
solve(mid + 1, r);
}
int main() {
scanf("%d", &n);
if (n == 3) return puts("24"), 0;
if (n == 4) return puts("4"), 0;
h[0] = h[2] = 1;
for (int i = 4; i <= n; i += 2) h[i] = upd(h[i - 2] + h[i - 4] - Mod);
for (int i = 2; i <= n; i++) {
for (int u = 0; u < 2; u++)
for (int v = 0; v < 2; v++) {
g[u][v][i + 1] = 1LL * h[i - (u ^ 1) - (v ^ 1)] * i % Mod * i % Mod;
}
}
f[0][0][2] = 2;
for (int i = 2; i < n; i++)
for (int u = 0; u < 2; u++)
for (int v = 0; v < 2; v++) {
f[u][v][i + 1] = 1LL * g[u][v][i + 1] * (i + 1) % Mod;
}
add(f[0][0][4], f[0][0][2]);
add(f[1][1][4], f[0][0][2]);
for (int j = 3; 2 + j <= n; j++) {
add(f[0][1][2 + j], 1LL * f[0][0][2] * g[1][1][j]);
add(f[0][0][2 + j], 1LL * f[0][0][2] * g[1][0][j]);
add(f[1][0][2 + j], 1LL * f[0][0][2] * g[0][0][j]);
add(f[1][1][2 + j], 1LL * f[0][0][2] * g[0][1][j]);
}
prepare(n - 3);
solve(3, n);
int ans = upd(f[0][0][n] + f[1][1][n] - Mod);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double fRand(double fMin, double fMax) {
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
struct line {
int a, b, id;
long long get(int x) { return 1LL * a * x + b; }
bool inline operator<(const line &rhs) const {
return make_tuple(a, b) < make_tuple(rhs.a, rhs.b);
}
};
double inter(line l1, line l2) { return 1.0 * (l1.b - l2.b) / (l2.a - l1.a); }
bool isBad(line l1, line l2) { return (l1.a == l2.a && l1.b <= l2.b); }
bool isBad(line l1, line l2, line l3) {
return (inter(l3, l1) <= inter(l2, l1));
}
line getMax(line a, line b, int x) { return (a.get(x) > b.get(x)) ? a : b; }
void addLine(deque<line> &h, line l) {
int n;
while ((n = (int)h.size()) > 0 && isBad(h[n - 1], l)) h.pop_back();
while ((n = (int)h.size()) > 1 && isBad(h[n - 2], h[n - 1], l)) h.pop_back();
h.push_back(l);
}
line bestLine(deque<line> &h, int x) {
while ((int)h.size() > 1 && h[0].get(x) < h[1].get(x)) h.pop_front();
return h[0];
}
deque<line> combine(deque<line> &h1, deque<line> &h2) {
deque<line> res;
int i = 0, j = 0, n = (int)h1.size(), m = (int)h2.size();
while (i < n && j < m) {
if (h1[i] < h2[j])
addLine(res, h1[i++]);
else
addLine(res, h2[j++]);
}
while (i < n) addLine(res, h1[i++]);
while (j < m) addLine(res, h2[j++]);
return res;
}
struct IT {
private:
vector<deque<line> > t;
int n;
void build(int id, int l, int r, line a[]) {
if (l == r) {
addLine(t[id], a[l]);
return;
}
int m = (l + r) / 2;
build(2 * id, l, m, a);
build(2 * id + 1, m + 1, r, a);
t[id] = combine(t[2 * id], t[2 * id + 1]);
}
line query(int id, int l, int r, int i, int j, int x) {
if (l > j || r < i) return {0, 0, -1};
if (i <= l && r <= j) return bestLine(t[id], x);
int m = (l + r) / 2;
return getMax(query(2 * id, l, m, i, j, x),
query(2 * id + 1, m + 1, r, i, j, x), x);
}
public:
IT(int n, line a[]) : n(n) {
t.assign(4 * n + 1, deque<line>());
build(1, 1, n, a);
}
int query(int l, int r, int x) { return query(1, 1, n, l, r, x).id; }
};
struct Query {
int l, r, t, id;
bool inline operator<(const Query &rhs) const { return t < rhs.t; }
};
const int MAXN = 1e5 + 5;
int n, q, ans[MAXN];
line a[MAXN];
Query Q[MAXN];
int main() {
scanf("%d%d", &n, &q);
for (int i = (1); i <= (n); ++i) {
scanf("%d%d", &a[i].b, &a[i].a);
a[i].id = i;
}
IT t(n, a);
for (int i = (1); i <= (q); ++i) {
scanf("%d%d%d", &Q[i].l, &Q[i].r, &Q[i].t);
Q[i].id = i;
}
sort(Q + 1, Q + q + 1);
for (int i = (1); i <= (q); ++i)
ans[Q[i].id] = t.query(Q[i].l, Q[i].r, Q[i].t);
for (int i = (1); i <= (q); ++i) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> ta(n, vector<int>(m));
for (int i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j < m; j++) {
if (str[j] == 'R')
ta[i][j] = 1;
else
ta[i][j] = 0;
}
}
vector<vector<int>> ruiR(n, vector<int>(m)), ruiD(n, vector<int>(m));
long long mod = 1000000007;
vector<vector<long long>> dpR(n, vector<long long>(m)),
dpD(n, vector<long long>(m));
if (ta[n - 1][m - 1] == 1) {
cout << 0 << "\n";
return 0;
}
dpR[n - 1][m - 1] = dpD[n - 1][m - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (ta[i][m - 1]) break;
dpR[i][m - 1] = dpD[i][m - 1] = 1;
}
for (int i = n - 2; i >= 0; i--) {
ruiD[i][m - 1] = ruiD[i + 1][m - 1];
if (ta[i][m - 1]) {
ruiD[i][m - 1]++;
ruiR[i][m - 1]++;
}
}
for (int j = m - 2; j >= 0; j--) {
if (ta[n - 1][j]) break;
dpR[n - 1][j] = dpD[n - 1][j] = 1;
}
for (int j = m - 2; j >= 0; j--) {
ruiR[n - 1][j] = ruiR[n - 1][j + 1];
if (ta[n - 1][j]) {
ruiR[n - 1][j]++;
ruiD[n - 1][j]++;
}
}
for (int i = n - 2; i >= 0; i--) {
for (int j = m - 2; j >= 0; j--) {
dpR[i][j] = (dpR[i][j + 1] + dpD[i + 1][j]) % mod;
dpD[i][j] = (dpR[i][j + 1] + dpD[i + 1][j]) % mod;
ruiR[i][j] = ruiR[i][j + 1];
ruiD[i][j] = ruiD[i + 1][j];
if (ta[i][j] == 0) continue;
ruiR[i][j]++;
ruiD[i][j]++;
dpR[i][j] = (dpR[i][j] + mod - dpD[i + 1][m - ruiR[i][j]]) % mod;
dpD[i][j] = (dpD[i][j] + mod - dpR[n - ruiD[i][j]][j + 1]) % mod;
}
}
cout << dpR[0][0] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1234;
const long long NN = 123456;
const long long INF = 0x3f3f3f3f;
const long long mod = 998244353;
long long n, k, a[N], dp[N][N], cur[N][N], ans[NN], tot;
signed main() {
scanf("%d%d", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
a[0] = -INF;
for (long long x = 1; (k - 1) * x <= a[n]; x++) {
dp[0][0] = cur[0][0] = 1;
long long tmp = 0;
for (long long i = 1; i <= n; i++) {
while (a[tmp] <= a[i] - x) tmp++;
for (long long j = 0; j <= k; j++) {
if (j != 0) dp[i][j] = cur[tmp - 1][j - 1];
cur[i][j] = (cur[i - 1][j] + dp[i][j]) % mod;
}
ans[x] += dp[i][k];
}
tot = (tot + ans[x]) % mod;
}
cout << tot;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class dato {
public:
char nom[11];
int tim, p;
};
bool operator<(dato a, dato b) {
return (a.tim < b.tim || (a.tim == b.tim && a.p > b.p));
};
int n, m, i, j, x;
dato arr[100010];
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s%d%d", arr[i].nom, &arr[i].tim, &arr[i].p);
sort(arr, arr + n);
x = 1;
for (j = 0; j < n; j++)
if (arr[j].tim == x) {
if (arr[j + 1].p == arr[j + 2].p && arr[j + 2].tim == x)
printf("?\n");
else
printf("%s %s\n", arr[j].nom, arr[j + 1].nom);
x++;
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.