solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 2e5 + 5;
int a[N];
string ss, tt;
inline bool ok(int x) {
string o = ss;
int i, j;
for (i = 0; i < x; i++) o[a[i] - 1] = '*';
i = 0, j = 0;
for (i = 0; i < o.size(); i++) {
if (o[i] == tt[j]) ++j;
if (j == tt.size()) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
int n, t, m, T, l, k, ans, i, j, res = 0, fl;
T = 1;
for (t = 1; t <= T; t++) {
cin >> ss >> tt;
n = ss.size();
for (i = 0; i < n; i++) cin >> a[i];
int low = 0, high = n;
while (low < high) {
int mid = (low + high) / 2;
if (!ok(mid))
high = mid;
else
low = mid + 1;
}
cout << low - 1 << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 10001;
int a[N], pl, pr, vl, vr;
long long cal(int a1, int a2, int b1, int b2) {
if (pl > a1) a1 = pl;
if (pr < a2) a2 = pr;
if (a1 > a2) return 0;
if (vl > b1) b1 = vl;
if (vr < b2) b2 = vr;
if (b1 > b2) return 0;
return (long long)(a2 - a1 + 1) * (b2 - b1 + 1);
}
int main() {
int k, i, t = 1;
long long p;
for (i = 0; i < t; i++)
if (a[i] < 100000000) a[t++] = a[i] * 10 + 4, a[t++] = a[i] * 10 + 7;
a[t] = 1000000001;
while (scanf("%d%d%d%d%d", &pl, &pr, &vl, &vr, &k) == 5) {
for (i = 1, p = 0; i <= t - k; i++) {
p += cal(a[i - 1] + 1, a[i], a[i + k - 1], a[i + k] - 1);
p += cal(a[i + k - 1], a[i + k] - 1, a[i - 1] + 1, a[i]);
if (k == 1) p -= cal(a[i], a[i], a[i], a[i]);
}
printf("%.10lf\n", 1.0 * p / ((long long)(pr - pl + 1) * (vr - vl + 1)));
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
using namespace std;
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int mn = (m + n) / 3;
mn = min(min(m, n), mn);
cout << mn << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[3];
string b[3] = {"chest", "biceps", "back"};
int main() {
ios::sync_with_stdio(true);
int n;
cin >> n;
int x;
int _max = 0;
for (int i = 0; i < n; i++) {
cin >> x;
a[i % 3] += x;
if (a[_max] < a[i % 3]) {
_max = i % 3;
}
}
cout << b[_max] << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main(void){
int b1,b2,b3;
cin>>b1>>b2>>b3;
if((b3==1)||(b1==1 &&b2==1)){
cout<<"Open"<<endl;
}
else{
cout<<"Close"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
int n, m;
int head[maxn], tot;
int pre[maxn], lowlink[maxn], dfs_clock, sccno[maxn], scc_cnt, sum[maxn];
stack<int> S;
vector<int> scc[maxn], g[maxn];
int du[maxn];
void dfs(int u) {
pre[u] = lowlink[u] = ++dfs_clock;
S.push(u);
for (int i = 0; i < g[u].size(); i++)
if (!pre[g[u][i]]) {
dfs(g[u][i]);
lowlink[u] = min(lowlink[u], lowlink[g[u][i]]);
} else if (!sccno[g[u][i]])
lowlink[u] = min(lowlink[u], pre[g[u][i]]);
if (pre[u] == lowlink[u]) {
scc_cnt++;
scc[scc_cnt].clear();
int x;
do {
x = S.top();
S.pop();
sccno[x] = scc_cnt, scc[scc_cnt].push_back(x), sum[scc_cnt] += 1;
} while (x != u);
}
}
void find_scc() {
memset(pre, 0, sizeof(pre));
memset(scc, 0, sizeof(scc));
memset(sum, 0, sizeof(sum));
scc_cnt = dfs_clock = 0;
for (int i = 1; i <= n; i++)
if (!pre[i]) dfs(i);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
int x;
scanf("%d", &x);
if (i != j && x > 0) g[i].push_back(j);
}
find_scc();
if (scc_cnt > 1)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> mp;
typedef pair<ll,mp> mmp;
ll inf = 1e9;
int main(){
ll n,m,k;
ll a,b,c;
cin>>n>>m>>k;
cin>>a>>b>>c;
ll t;
cin>>t;
vector<ll> s(m);
for(ll i=0;i<m;i++)cin>>s[i];
ll rest = -1;
priority_queue<mmp> q;//残り個数，残り時間
for(ll i=0;i<m;i++){
ll time = t-(s[i]-s[0])*b;
if( time >= 0 ) rest++;
else break;
if( i == m-1 ) break;
ll cnt = time/a;
ll next = s[i] + cnt + 1;
if( next >= s[i+1] ){
rest += s[i+1]-s[i] - 1;
continue;
}else{
rest += cnt;
}
// cout<<i<<' '<<rest<<endl;
ll rest_time = time - c*(next-s[i]);
// 次の個数 ， 残り時間 ， 本当の残り個数
if( rest_time < 0 ) continue;
//cout<<i<<' '<<min(rest_time/a, s[i+1]-next)<<' '<<next<<' '<< rest_time<< ' '<<s[i+1]-next<<endl;
//cout<<cnt<<' '<<time<<' '<<rest_time<<' '<<rest_time/a<<endl;
ll add = min( rest_time/a + 1 , s[i+1]-next );
//rest_time -= c*add;
//if( rest_time < 0 ) continue;
ll rest_point = s[i+1]-next - add;
if( rest_point < 0 ) continue;
q.push( mmp( add , mp(rest_time , rest_point ) ) );
//q.push( mmp( min( rest_time/a+1 , s[i+1]-next ), mp( rest_time , s[i+1]- next - min( rest_time/a+1 , s[i+1]-next) ) ) );
}
//cout<<rest<<endl;
k-=m;
while( k>0 && !q.empty() ){
mmp now = q.top();
q.pop();
mp nn = now.second;
if( now.first < 0 ) break;
ll next_time = nn.first - c*( now.first );
// if( next_time < 0 ) continue;
// cout<<now.first<<endl;
rest += now.first;
k--;
ll add = min( max( 1ll , next_time/a +1 ) , nn.second );
ll rest_point = nn.second - add;
if( next_time > 0 )
q.push( mmp( add , mp( next_time , rest_point) ) );
//if( min(nn.first/a , nn.second ) > 0 )
//q.push( mmp( min( nn.first/a + 1 , nn.second) , mp( nn.first -c*(nn.first/a+1) , nn.second - nn.first/a -1 ) ) );
//else if( nn.first >= c ){
//q.push( mmp( 1 ,mp( nn.first - c , nn.second-1 ) ) );
//}
}
cout<<rest<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
char str[1111111];
int main() {
scanf("%s", str);
char *c = strchr(str, '^');
char *d;
d = c;
long long w1 = 0, w2 = 0;
int i = 0;
while (1) {
if ('0' <= (*d) && (*d) <= '9') w1 += ((*d) - '0') * i;
i++;
if (d == str) break;
d--;
}
d = c;
i = 0;
while (1) {
if ('0' <= (*d) && (*d) <= '9') w2 += ((*d) - '0') * i;
i++;
d++;
if ((*d) == '\0') break;
}
if (w1 == w2)
cout << "balance" << endl;
else if (w1 > w2)
cout << "left" << endl;
else
cout << "right" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
int N;
string S;
map<pair<int, int>, int> mp;
bool is(int s, int t) {
if (s == t) return true;
if (t - s < 3 || S[s] != 'm' || S[t - 1] != 'w') return false;
P p(s, t);
int r = mp[p];
if (r) return r == 1 ? true : false;
for (int i = s + 1; i < t - 1; i++) {
if (S[i] == 'e' && is(s + 1, i) && is(i + 1, t - 1)) {
mp[p] = 1;
return true;
}
}
mp[p] = -1;
return false;
}
int main()
{
cin >> S;
N = S.size();
cout << (is(0, N) ? "Cat" : "Rabbit") << endl;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
bool cards[2][201];
int N, field, rest[2];
int main()
{
while(true)
{
cin >> N;
if(!N)
break;
for(int i = 0; i <= N * 2; i++)
cards[0][i] = 0;
for(int i = 0; i < N; i++)
{
int tmp;
cin >> tmp;
cards[0][tmp] = 1;
}
for(int i = 0; i <= N * 2; i++)
{
if(!cards[0][i])
cards[1][i] = 1;
else
cards[1][i] = 0;
}
rest[0] = rest[1] = N;
field = 0;
int turn = 0;
while(rest[0] > 0 && rest[1] > 0)
{
bool b = true;
for(int i = 1; i <= 2 * N; i++)
{
if(cards[turn][i] && i > field)
{
cards[turn][i] = 0;
rest[turn]--;
field = i;
b = false;
break;
}
}
if(b)
field = 0;
turn = (turn + 1) % 2;
}
cout << rest[1] << endl << rest[0] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
const int pri[26] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, -1};
const long long mod[5] = {223092870LL, 2756205443LL, 907383479LL, 42600829LL,
97LL};
long long *f[17][5], a[maxn], ans;
int b[maxn], n, m, t;
int calc(int d, int p) {
int i, j, x, y;
long long *f0;
f0 = f[d][p];
x = y = 0;
for (i = 0; i < t; ++i) x = x * (d + 1) + b[i];
if (f0[x] == -1)
f0[x] = 1;
else
return x;
for (i = 0; i < t; ++i)
if (b[i] == d) {
for (j = 0; j < d; ++j) {
b[i] = j;
f0[x] = f0[x] * f0[calc(d, p)] % mod[p];
}
b[i] = d;
return x;
}
for (i = 0; i < t; ++i) y = y * d + b[i];
if (y < n) f0[x] = a[y] % mod[p];
return x;
}
int main() {
int i, j, k, d;
long long c;
string s;
ios::sync_with_stdio(false);
cin >> n;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 2; i <= 16; ++i) {
for (j = t = 1; j <= n; j *= i, t *= i + 1)
;
for (j = 0; j < 5; ++j) {
f[i][j] = new long long[t];
memset(f[i][j], 255, sizeof(long long) * t);
}
}
for (cin >> m; m; --m) {
cin >> d >> s >> c;
for (t = 0, j = 1; j <= n; j *= d, ++t)
;
for (j = 0; j < t; ++j) {
k = s.length() - t + j;
if (k >= 0) {
if (s[k] != '?')
b[j] = s[k] <= '9' ? s[k] - '0' : s[k] - 'A' + 10;
else
b[j] = d;
} else
b[j] = 0;
}
for (i = 0; i < 5; ++i) {
j = calc(d, i);
ans = (f[d][i][j] + c) % mod[i];
for (j = 0; j < 25; ++j)
if (mod[i] % pri[j] == 0 && ans % pri[j] == 0) break;
if (j < 25) break;
}
cout << pri[j] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long a[maxn];
int mp[250][250];
int dis[250][250];
int res = 99999999;
int n;
void floyd() {
for (int k = 0; k < n; k++) {
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
res = min(res, dis[i][j] + mp[j][k] + mp[k][i]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dis[i][j] = dis[j][i] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
}
int main() {
scanf("%d", &n);
int num = 0;
for (int i = 0; i < n; i++) {
long long tot;
scanf("%I64d", &tot);
if (tot != 0) {
a[num] = tot;
num++;
}
}
if (num >= 200) return 0 * printf("3\n");
n = num;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
mp[i][j] = mp[j][i] = 10000000;
dis[i][j] = dis[j][i] = 10000000;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (i != j && (a[i] & a[j]) > 0) {
mp[i][j] = mp[j][i] = 1;
dis[i][j] = dis[j][i] = 1;
}
}
}
for (int i = 0; i < n; i++) dis[i][i] = mp[i][i] = 0;
floyd();
if (res > 100000)
cout << "-1" << endl;
else
cout << res << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MAX_POWER = 60;
class Reader {
public:
Reader(FILE *_stream, const int _size = (1 << 16))
: size(_size), pointer(0), buffer(new char[_size]), stream(_stream) {
assert(fread(buffer, 1, size, stream) != 0);
}
template <class IntType>
IntType NextInt() {
IntType value = 0;
bool negative = false;
while ((Current() < '0' || Current() > '9') && Current() != '-')
NextPosition();
if (Current() == '-') {
negative = true;
NextPosition();
}
while (Current() >= '0' && Current() <= '9') {
value = value * 10 + Current() - '0';
NextPosition();
}
if (negative) value = -value;
return value;
}
Reader &operator>>(short &value) {
value = NextInt<short>();
return *this;
}
Reader &operator>>(int &value) {
value = NextInt<int>();
return *this;
}
Reader &operator>>(long long &value) {
value = NextInt<long long>();
return *this;
}
private:
int size, pointer;
char *buffer;
FILE *stream;
char Current() const { return buffer[pointer]; }
void NextPosition() {
if (++pointer == size) {
assert(fread(buffer, 1, size, stream) != 0);
pointer = 0;
}
}
};
vector<vector<int> > G, GT;
int V, CountSCC;
vector<int> Sign, TopologicalSort;
void DFP(const int x) {
++Sign[x];
for (const auto &y : G[x])
if (Sign[y] == 0) DFP(y);
TopologicalSort.push_back(x);
}
void DFM(const int x) {
--Sign[x];
for (const auto &y : GT[x])
if (Sign[y] == 1) DFM(y);
}
void Kosaraju() {
Sign = vector<int>(V, 0);
for (int x = 0; x < V; ++x)
if (Sign[x] == 0) DFP(x);
reverse(TopologicalSort.begin(), TopologicalSort.end());
CountSCC = 0;
for (const auto &x : TopologicalSort) {
if (Sign[x] == 1) {
++CountSCC;
DFM(x);
}
}
}
void Solve() { Kosaraju(); }
inline void AddEdge(const int x, const int y) {
G[x].push_back(y);
GT[y].push_back(x);
}
void Read() {
Reader cin = Reader(stdin);
cin >> V;
G = GT = vector<vector<int> >(V, vector<int>());
for (int x = 0; x < V; ++x) {
for (int y = 0; y < V; ++y) {
int value;
cin >> value;
if (value > 0) AddEdge(x, y);
}
}
}
void Print() {
if (CountSCC == 1)
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
Read();
Solve();
Print();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n/100 == ((n%100)%10) ? "Yes" : "No") << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int a, b, c, x, y, z;
cin >> a >> b >> c >> x >> y >> z;
int have = 0, need = 0;
if (a > x)
have += (a - x) >> 1;
else
need += x - a;
if (b > y)
have += (b - y) >> 1;
else
need += y - b;
if (c > z)
have += (c - z) >> 1;
else
need += z - c;
if (have >= need)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool first = true;
int main() {
int n;
string s;
cin >> n >> s;
string alf = "ACGT";
vector<int> k(4);
for (int i = 0; i < n; i++)
for (int ii = 0; ii < 4; ii++)
if (s[i] == alf[ii]) {
k[ii]++;
break;
}
sort(k.begin(), k.end());
if (k[3] > k[2])
cout << 1;
else {
long long ans = 1, modu = 1e9 + 7;
for (int i = 2; k[i + 1] == k[i]; i--, ans++)
;
long long p = ans;
for (int i = 0; i < n - 1; i++) ans = (ans * p) % modu;
cout << ans;
}
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int n, k;
while(cin >> n >> k, n || k){
int a[111111] = {0};
for(int i = 0; i < k; i++){
int tmp; cin >> tmp;
a[tmp]++;
}
int dp[2][111111] = {0};
for(int i = 1; i <= n; i++){
if(a[i]){
dp[0][i] = dp[0][i - 1] + 1;
dp[1][i] = dp[1][i - 1] + 1;
}
else{
dp[0][i] = 0;
dp[1][i] = dp[0][i - 1] + 1;
}
}
cout << *max_element(dp[a[0]] + 1, dp[a[0]] + n + 1) << endl;
}
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
using namespace std;
int main(){
map<char,string> table;
table[' ']="101";
table[(char)39]="000000";
table[',']="000011";
table['-']="10010001";
table['.']="010001";
table['?']="000001";
table['A']="100101";
table['B']="10011010";
table['C']="0101";
table['D']="0001";
table['E']="110";
table['F']="01001";
table['G']="10011011";
table['H']="010000";
table['I']="0111";
table['J']="10011000";
table['K']="0110";
table['L']="00100";
table['M']="10011001";
table['N']="10011110";
table['O']="00101";
table['P']="111";
table['Q']="10011111";
table['R']="1000";
table['S']="00110";
table['T']="00111";
table['U']="10011100";
table['V']="10011101";
table['W']="000010";
table['X']="10010010";
table['Y']="10010011";
table['Z']="10010000";
map<string,char> table2;
for(int i = 0; i < 26; i++){
string ms;
for(int j = 0; j < 5; j++){
if((i>>j)&1){
ms+='1';
}
else
ms+='0';
}
reverse(ms.begin(),ms.end());
table2[ms]='A'+i;
}
table2["11010"]=' ';
table2["11011"]='.';
table2["11100"]=',';
table2["11101"]='-';
table2["11110"]=(char)39;
table2["11111"]='?';
string str;
while(getline(cin,str)){
string nstr="";
for(int i = 0; i < str.size(); i++){
nstr+=table[str[i]];
}
int t=nstr.size();
if(nstr.size()%5!=0){
int add=(((nstr.size()/5)+1)*5)-nstr.size();
for(int i = 0; i < add; i++){
nstr+='0';
}
}
string fstr="";
for(int i = 0; i < nstr.size()/5; i++){
string s=nstr.substr(5*(i),5);
fstr+=table2[s];
}
cout<<fstr<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using pii = std::pair<long long, long long>;
using namespace std;
long long n, m;
char x;
pii dirs[8] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
long long valid(long long i, long long j) {
return (i >= 0 && i < n && j >= 0 && j < m);
}
long long check(long long time, vector<vector<long long>>& dist) {
vector<vector<long long>> newgrid(n, vector<long long>(m, -1));
queue<pii> q;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
if (dist[i][j] > time)
newgrid[i][j] = dist[i][j];
else if (dist[i][j] == time) {
newgrid[i][j] = dist[i][j];
q.push({i, j});
}
}
while (!q.empty()) {
pii pos = q.front();
q.pop();
if (!newgrid[pos.first][pos.second]) continue;
for (auto ne : dirs) {
long long newx = pos.first + ne.first, newy = pos.second + ne.second;
if (valid(newx, newy) && newgrid[newx][newy] == -1) {
q.push({newx, newy});
newgrid[newx][newy] = newgrid[pos.first][pos.second] - 1;
}
}
}
long long good = 1;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
if ((newgrid[i][j] >= 0) ^ (dist[i][j] >= 0)) good = 0;
return good;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
vector<vector<long long>> grid(n, vector<long long>(m)),
dist(n, vector<long long>(m, -1)), visited(n, vector<long long>(m, 0)),
pref(n, vector<long long>(m, 0));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
cin >> x;
grid[i][j] = (x == 'X');
pref[i][j] = grid[i][j];
}
for (long long i = 0; i < n; i++)
for (long long j = 1; j < m; j++) pref[i][j] += pref[i][j - 1];
for (long long i = 1; i < n; i++)
for (long long j = 0; j < m; j++) pref[i][j] += pref[i - 1][j];
queue<pii> q;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
if (grid[i][j]) {
long long good = 0;
if (i == 0 || i == n - 1 || j == 0 || j == m - 1) good = 1;
if (!good)
for (auto adj : dirs)
if (!grid[i + adj.first][j + adj.second]) good = 1;
if (good) {
q.push({i, j});
dist[i][j] = 0;
}
}
long long madepth = 0;
while (!q.empty()) {
pii pos = q.front();
q.pop();
madepth = max(madepth, dist[pos.first][pos.second]);
for (auto ne : dirs) {
long long newx = pos.first + ne.first, newy = pos.second + ne.second;
if (valid(newx, newy) && grid[newx][newy] && dist[newx][newy] == -1) {
q.push({newx, newy});
dist[newx][newy] = dist[pos.first][pos.second] + 1;
}
}
}
long long lo = 0, hi = madepth, mid;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2;
if (check(mid, dist))
lo = mid;
else
hi = mid - 1;
}
assert(lo == hi);
long long mintime = lo;
cout << mintime << "\n";
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++)
if (dist[i][j] < mintime)
cout << ".";
else
cout << "X";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void file(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
template <typename Tp>
void read(Tp &x) {
x = 0;
long long fh = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') {
fh = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= fh;
}
long long n, m;
long long a[4000005], ta[4000005], tat, cnt[4000005];
struct node {
long long num, tim;
bool operator<(node b) const { return tim < b.tim; }
};
priority_queue<node> q;
long long pn, ans[4000005], tot, sum, rst;
long long get_ps(long long x, long long y) { return (y - 1) * pn + x; }
signed main() {
long long ffl = 0;
read(n);
rst = n;
for (long long i = 1; i <= n; i++) read(a[i]), ta[++tat] = a[i];
sort(ta + 1, ta + tat + 1);
tat = unique(ta + 1, ta + tat + 1) - ta - 1;
for (long long i = 1; i <= n; i++)
a[i] = lower_bound(ta + 1, ta + tat + 1, a[i]) - ta, cnt[a[i]]++;
for (long long i = 1; i <= tat; i++) q.push((node){i, cnt[i]});
while (!q.empty()) {
node x = q.top();
q.pop();
if (x.tim * x.tim > n) {
x.tim--, q.push(x);
rst--;
ffl = 1;
continue;
}
if (!pn) {
if (rst - x.tim < x.tim * (x.tim - 1)) {
x.tim--, q.push(x);
rst--;
continue;
}
long long tmp = q.top().tim;
if (ffl && (rst - 1) % tmp < rst % x.tim) {
x.tim--, q.push(x);
rst--;
continue;
}
pn = x.tim;
}
for (long long i = 1; i <= x.tim; i++) ans[++tot] = x.num, sum++;
}
long long ppn = pn, mi = sum % pn;
for (long long i = pn; i * pn <= sum; i++) {
if (sum % i < mi) {
mi = sum % i;
ppn = i;
}
}
pn = ppn;
m = sum / pn;
if (pn > m) swap(pn, m);
printf("%lld\n", pn * m);
printf("%lld %lld\n", pn, m);
for (long long i = 1; i <= pn; i++) {
for (long long j = 2 - i, tt = 1; tt <= m; tt++, j++) {
if (j < 1) j += m;
if (j == m + 1) j = 1;
printf("%lld ", ta[ans[get_ps(i, j)]]);
}
puts("");
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, i, j, n, m, k;
vector<int> fc[100002];
int last[100002], lpr[100002];
bool enabled[100002];
char str[5];
inline int enable(int v) {
for (int _n(((int)((fc[v]).size())) - 1), i(0); i <= _n; i++) {
if (last[fc[v][i]]) return last[fc[v][i]];
}
for (int _n(((int)((fc[v]).size())) - 1), i(0); i <= _n; i++) {
last[fc[v][i]] = v;
}
enabled[v] = 1;
return 0;
}
inline void disable(int v) {
for (int _n(((int)((fc[v]).size())) - 1), i(0); i <= _n; i++) {
last[fc[v][i]] = 0;
}
enabled[v] = 0;
}
int main() {
for (int _n((100000)), i(1); i <= _n; i++) lpr[i] = i;
for (int i = 2; i * i <= 100000; ++i) {
if (lpr[i] == i) {
for (int j = i * i; j <= 100000; j += i) {
if (lpr[j] > i) lpr[j] = i;
}
}
}
for (int _n(100000), i(2); i <= _n; i++) {
a = i / lpr[i];
fc[i] = fc[a];
if (a % lpr[i] == 0) continue;
fc[i].push_back(lpr[i]);
}
scanf("%d%d", &n, &m);
for (int _n((m)-1), h(0); h <= _n; h++) {
scanf("%s", str);
if (str[0] == '+') {
scanf("%d", &a);
if (enabled[a]) {
printf("Already on\n");
continue;
}
b = enable(a);
if (b)
printf("Conflict with %d\n", b);
else
printf("Success\n");
} else {
scanf("%d", &a);
if (!enabled[a]) {
printf("Already off\n");
continue;
}
disable(a);
printf("Success\n");
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100009], dp[2007][2007];
int main() {
int t;
cin >> t;
while (t--) {
memset(a, 0, sizeof(a));
memset(dp, 0, sizeof(dp));
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 0; j <= i; j++) {
if (j == 0)
dp[i][j] = dp[i - 1][j] + (a[i] == i ? 1 : 0);
else
dp[i][j] =
max(dp[i - 1][j - 1], dp[i - 1][j] + (a[i] == (i - j) ? 1 : 0));
}
}
int res = -1;
for (int i = 0; i <= n; i++) {
if (dp[n][i] >= k) {
res = i;
break;
}
}
cout << res << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
int n, m, k, arr[1005][1005], row[1005], col[1005];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &arr[i][j]);
for (int i = 1; i <= n; ++i) row[i] = i;
for (int i = 1; i <= m; ++i) col[i] = i;
while (k--) {
int a, b;
char c;
scanf(" %c %d %d", &c, &a, &b);
if (c == 'r') {
int tmp = row[a];
row[a] = row[b];
row[b] = tmp;
} else if (c == 'c') {
int tmp = col[a];
col[a] = col[b];
col[b] = tmp;
} else
printf("%d\n", arr[row[a]][col[b]]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, l;
cin >> n >> l;
int ans=n*(l-1)+n*(n+1)/2;
if(l*(l+n-1)>0){
if(l<0) ans -= l+n-1;
else ans -= l;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, k;
scanf("%d %d", &n, &k);
int f[n], t[n], x, dif = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d", &f[i], &t[i]);
if (t[i] > k)
x = f[i] - (t[i] - k);
else
x = f[i];
if (i == 0 || x > dif) dif = x;
}
printf("%d", dif);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j;
int n, m, sum = 0;
string s, t;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == 'W') {
if (s[i + 1] == 'U' && s[i + 2] == 'B') {
if (j == 1) cout << ' ';
i = i + 2;
j = 0;
} else {
j = 1;
cout << s[i];
}
} else {
j = 1;
cout << s[i];
}
}
return 0;
}
| 1 |
#include <stdio.h>
bool is_prime(int n)
{
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
int main()
{
int N, n, k = 0;
scanf("%d", &N);
while (N--)
{
scanf("%d", &n);
if (is_prime(n))
k++;
}
printf("%d\n", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long d, n;
int grundy[500][500], offset = 210;
set<int> st;
pair<int, int> arr[30];
void pre() {
for (int x = 201; x >= -201; x--) {
for (int y = 201; y >= -201; y--) {
int i;
if ((x * x + y * y) > d * d) continue;
for (i = 0; i < n; i++) {
if (((x + arr[i].first) * (x + arr[i].first) +
(y + arr[i].second) * (y + arr[i].second)) > d * d)
;
else
st.insert(
grundy[x + offset + arr[i].first][y + offset + arr[i].second]);
}
i = 0;
while (st.find(i) != st.end()) i++;
st.clear();
grundy[x + offset][y + offset] = i;
}
}
}
int main() {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
scanf("%I64d", &n);
scanf("%I64d", &d);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i].first);
scanf("%d", &arr[i].second);
}
pre();
if (grundy[x + offset][y + offset] == 0)
printf("Dasha\n");
else
printf("Anton\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<long long> a(n), b(n), c;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << 0;
return 0;
}
long long ans = 0;
sort(a.begin(), a.end());
long long x = 0;
for (int i = 1; i < n; i++) {
if (a[i] > a[x]) {
ans++;
x++;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct process { string name; int time; };
int main()
{
int n, q, ntime = 0;
process tmp;
queue<process> que;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> tmp.name >> tmp.time;
que.push(tmp);
}
while (!que.empty()) {
tmp = que.front(); que.pop();
if (tmp.time <= q) {
ntime += tmp.time;
cout << tmp.name << ' ' << ntime << endl;
}
else {
ntime += q;
tmp.time -= q;
que.push(tmp);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; ++i) {
cin >> a[i];
}
long long int sum = accumulate(a, a + n, 0);
if (sum % n == 0) {
cout << 0 << "\n";
} else {
cout << 1 << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int s;
vector<int> a1(0);
vector<int> b1(0);
while (max(a, b)) {
a1.push_back(a % 10);
b1.push_back(b % 10);
a = a / 10;
b = b / 10;
}
int k = 0;
for (int i = 0; i < max(((int)a1.size()), ((int)b1.size())); ++i) {
if (k - 1 < a1[i]) k = a1[i] + 1;
if (k - 1 < b1[i]) k = b1[i] + 1;
}
int t = 0;
for (int i = 0; i < ((int)a1.size()); ++i) {
if (a1[i] + b1[i] + t >= k)
t = 1;
else
t = 0;
}
cout << ((int)a1.size()) + t;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 3e5 + 9;
vector<int> g[ms];
int vet[ms];
int op[ms];
int n, m, val;
int leaves;
int dfs(int node) {
int ans = 0x3f3f3f3f;
if (g[node].size() == 0) {
ans = 1;
leaves++;
} else if (op[node] == 1) {
for (auto &it : g[node]) {
ans = min(ans, dfs(it));
}
} else {
ans = 0;
for (auto &it : g[node]) ans += dfs(it);
}
return ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> op[i];
for (int i = 2; i <= n; i++) {
cin >> val;
g[val].push_back(i);
}
int val = dfs(1);
val = leaves - val + 1;
cout << val;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long double min(long double a, long double b) {
if (a < b) return a;
return b;
}
inline long double max(long double a, long double b) {
if (a < b) return b;
return a;
}
long long k, a, b;
long long solve1(long long val) {
if (val == 0)
return 0;
else if (val < 0)
return val / k * k;
else {
if (val % k == 0) return val;
long long res = val / k;
return (res + 1) * k;
}
}
long long solve2(long long val) {
if (val == 0)
return 0;
else if (val < 0) {
if (val % k == 0) return val;
long long res = val / k;
return (res - 1) * k;
} else {
if (val % k == 0) return val;
long long res = val / k;
return res * k;
}
}
int main() {
cin >> k >> a >> b;
long long res1 = solve1(a);
long long res2 = solve2(b);
long long res = 0;
if (res1 <= res2) res = (res2 - res1) / k + 1;
cout << res << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,n)for(ll i=0;i<n;i++)
using namespace std;
typedef long long ll;
int main() {
int a, b, c;
while (cin >> a >> b >> c) {
int want = 20 - a - b;
int cnt = min(10, want);
if (a <= want)cnt--; if (b <= want)cnt--; if (c <= want)cnt--;
if (want > 0 && cnt >= 4)puts("YES");
else puts("NO");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int block = 256;
int n, m, a[maxn], Begin[maxn], Next[maxn], To[maxn], e;
int dis[maxn], tot, f[maxn][block], anc[maxn], F[maxn];
struct node {
int son[2];
} Tree[maxn];
inline void Insert(int x) {
int p = 1;
for (int i = 18; i >= 0; --i) {
int c = (x >> i) & 1;
if (!Tree[p].son[c]) Tree[p].son[c] = ++tot;
p = Tree[p].son[c];
}
}
inline int Query(int x) {
int ret = 0, p = 1;
for (int i = 18; i >= 0; --i) {
int c = (x >> i) & 1;
if (Tree[p].son[c ^ 1]) {
ret |= 1 << i;
c ^= 1;
}
p = Tree[p].son[c];
}
return ret;
}
inline void add(int u, int v) {
To[++e] = v;
Next[e] = Begin[u];
Begin[u] = e;
}
inline void DFS(int u, int fa) {
for (int i = Begin[u]; i; i = Next[i]) {
int v = To[i];
if (v == fa) continue;
dis[v] = dis[u] + 1;
F[v] = u;
DFS(v, u);
}
if (dis[u] >= block) {
for (int i = (1), _end_ = (tot); i <= _end_; ++i)
Tree[i].son[0] = Tree[i].son[1] = 0;
tot = 1;
int x = u;
Insert(a[x]);
for (int i = (1), _end_ = (block - 1); i <= _end_; ++i) {
x = F[x];
Insert(a[x] ^ i);
}
anc[u] = x;
for (int i = (0), _end_ = (block - 1); i <= _end_; ++i)
f[u][i] = Query(i << 8);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1), _end_ = (n); i <= _end_; ++i) scanf("%d", &a[i]);
for (int i = (1), _end_ = (n - 1); i <= _end_; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dis[1] = 1;
DFS(1, 0);
for (int o = (1), _end_ = (m); o <= _end_; ++o) {
int u, v;
scanf("%d%d", &u, &v);
int ans = 0, x = 0;
for (x = 0; dis[anc[v]] >= dis[u]; ++x) {
ans = max(ans, f[v][x]);
v = F[anc[v]];
}
x *= block;
while (dis[v] >= dis[u]) {
ans = max(ans, a[v] ^ x);
++x;
v = F[v];
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> s1, s2;
pair<int, int> c1[2011 * 2011], c2[2011 * 2011];
long long a[2011], b[2011];
long long tmp[2011 * 2011];
int tol = 0;
int n, m;
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%I64d", &a[i]);
scanf("%d", &m);
for (i = 0; i < m; ++i) scanf("%I64d", &b[i]);
long long sa = 0, sb = 0;
int tp = 0;
long long v1 = 0, v2 = 0;
for (i = 0; i < n; ++i) sa += a[i];
for (i = 0; i < m; ++i) sb += b[i];
long long ans = llabs(sa - sb);
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
if (ans > llabs((sa - a[i] + b[j]) - (sb - b[j] + a[i]))) {
ans = llabs((sa - a[i] + b[j]) - (sb - b[j] + a[i]));
tp = 1;
v1 = a[i], v2 = b[j];
}
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < i; ++j) {
tmp[tol++] = a[i] + a[j];
}
}
sort(tmp, tmp + tol);
for (i = 0; i < tol; ++i) {
if (i == 0 || tmp[i] != tmp[i - 1]) s1.push_back(tmp[i]);
}
tol = 0;
for (i = 0; i < m; ++i) {
for (j = 0; j < i; ++j) {
tmp[tol++] = b[i] + b[j];
}
}
sort(tmp, tmp + tol);
for (i = 0; i < tol; ++i) {
if (i == 0 || tmp[i] != tmp[i - 1]) s2.push_back(tmp[i]);
}
int sz = s2.size();
for (auto v : s1) {
long long dif = sb + v - (sa - v);
int idx = lower_bound(s2.begin(), s2.end(), dif / 2) - s2.begin();
if (idx < sz) {
if (ans > llabs(sb - sa + v * 2 - s2[idx] * 2)) {
ans = llabs(sb - sa + v * 2 - s2[idx] * 2);
tp = 2;
v1 = v, v2 = s2[idx];
}
}
if (idx + 1 < sz) {
if (ans > llabs(sb - sa + v * 2 - s2[idx + 1] * 2)) {
ans = llabs(sb - sa + v * 2 - s2[idx + 1] * 2);
tp = 2;
v1 = v, v2 = s2[idx + 1];
}
}
if (idx - 1 >= 0) {
if (ans > llabs(sb - sa + v * 2 - s2[idx - 1] * 2)) {
ans = llabs(sb - sa + v * 2 - s2[idx - 1] * 2);
tp = 2;
v1 = v, v2 = s2[idx - 1];
}
}
}
printf("%I64d\n", ans);
if (tp == 0) {
printf("0\n");
} else if (tp == 1) {
printf("1\n");
int i1 = 0, i2 = 0;
for (i = 0; i < n; ++i) {
if (a[i] == v1) {
i1 = i;
break;
}
}
for (i = 0; i < m; ++i) {
if (b[i] == v2) {
i2 = i;
break;
}
}
printf("%d %d\n", i1 + 1, i2 + 1);
} else {
printf("2\n");
int i1 = 0, i2 = 0, i3 = 0, i4 = 0;
for (i = 0; i < n; ++i) {
for (j = 0; j < i; ++j) {
if (a[i] + a[j] == v1) {
i1 = i, i2 = j;
break;
}
}
}
for (i = 0; i < m; ++i) {
for (j = 0; j < i; ++j) {
if (b[i] + b[j] == v2) {
i3 = i, i4 = j;
break;
}
}
}
printf("%d %d\n%d %d\n", i1 + 1, i3 + 1, i2 + 1, i4 + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int treesize = 1 << 18;
int tree[2 * treesize];
int add[2 * treesize];
int a[maxn], pos[maxn];
vector<int> xs;
int n;
int getans(int cur)
{
return tree[cur] + add[cur];
}
void push(int cur)
{
tree[cur] += add[cur];
add[cur * 2] += add[cur];
add[cur * 2 + 1] += add[cur];
add[cur] = 0;
}
void update(int cur)
{
tree[cur] = max(getans(cur * 2), getans(cur * 2 + 1));
}
int get(int cur, int cl, int cr, int l, int r)
{
if (cl > r || cr < l) return (int)(-1e9);
if (cl >= l && cr <= r) return getans(cur);
int cm = (cl + cr) / 2;
push(cur);
return max(get(cur * 2, cl, cm, l, r), get(cur * 2 + 1, cm + 1, cr, l, r));
}
void addd(int cur, int cl, int cr, int l, int r, int t)
{
if (cl > r || cr < l) return;
if (cl >= l && cr <= r)
{
add[cur] += t;
return;
}
int cm = (cl + cr) / 2;
push(cur);
addd(cur * 2, cl, cm, l, r, t);
addd(cur * 2 + 1, cm + 1, cr, l, r, t);
update(cur);
}
int t[maxn];
int main()
{
scanf("%d", &n);
for (int i = 0; i < n; i++)
{
scanf("%d", &a[i]);
xs.push_back(a[i]);
}
sort(xs.begin(), xs.end());
xs.resize(unique(xs.begin(), xs.end()) - xs.begin());
for (int i = 0; i < n; i++) pos[i] = lower_bound(xs.begin(), xs.end(), a[i]) - xs.begin();
long long answer = 0;
for (int i = 0; i < n; i++)
{
addd(1, 0, treesize - 1, 0, pos[i] - 1, 1);
answer += t[i] = get(1, 0, treesize - 1, pos[i], pos[i]);
}
for (int i = 0; i < n; i++)
{
addd(1, 0, treesize - 1, 0, pos[i] - 1, -1);
}
for (int i = 0; i < n; i++)
{
addd(1, 0, treesize - 1, pos[i], xs.size(), 1);
}
for (int i = 0; i < (int)xs.size(); i++) addd(1, 0, treesize - 1, i, i, -xs[i]);
// for (int i = 0; i < (int)xs.size(); i++) cout << get(1, 0, treesize - 1, i, i) << endl;
// cout << answer << endl;
for (int i = n - 1; i >= 0; i--)
{
addd(1, 0, treesize - 1, pos[i], xs.size(), -1);
// cout << get(1, 0, treesize - 1, pos[i], xs.size() - 1) + xs[pos[i]] - (i - t[i]) << endl;
answer -= (get(1, 0, treesize - 1, pos[i], xs.size() - 1) + xs[pos[i]] - (i - t[i]));
}
cout << answer << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
long n;
cin >> t;
int a[t];
for (int i = 0; i < t; i++) {
cin >> a[i];
}
for (int i = 0; i < t; i++) {
if (a[i] <= 2) {
cout << 0 << endl;
} else {
n = (a[i] / 2.0);
if (a[i] % 2 == 0) {
cout << n - 1 << endl;
} else {
cout << n << endl;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
const int mod = 12345;
long long n;
int c;
int m[32];
int tt[1024], mm[1024];
int getSt(int ma, int p) {
int st = 1;
for (int i = 0; i < p; i++) {
if (m[i] == -1) continue;
st = st * m[i];
}
int x = (ma / st) % m[p];
return x;
}
int next(int ma, int p) {
if (m[p] == 1) return ma;
int st = 1;
for (int i = 0; i < p; i++) {
if (m[i] == -1) continue;
st = st * m[i];
}
int x = (ma / st) % m[p];
if (x == m[p] - 1) return ma - (m[p] - 1) * st;
return ma + st;
}
int col[128];
int bma[128][128];
int re[128][128];
void mmatr(int sz, int a[128][128], int b[128][128], int c[128][128]) {
int i, j, k;
for (i = 0; i < sz; i++) {
for (j = 0; j < sz; j++) {
c[i][j] = 0;
for (k = 0; k < sz; k++) {
c[i][j] = c[i][j] + a[i][k] * b[k][j];
if (c[i][j] >= mod) c[i][j] = c[i][j] % mod;
}
}
}
}
void mcpy(int sz, int a[128][128], int b[128][128]) {
int i, j;
for (i = 0; i < sz; i++) {
for (j = 0; j < sz; j++) {
a[i][j] = b[i][j];
}
}
}
void mpow(int sz, int ma[128][128], long long st) {
int a[128][128], b[128][128];
int i, j;
for (i = 0; i < sz; i++) {
for (j = 0; j < sz; j++) re[i][j] = 0;
re[i][i] = 1;
}
while (st > 0) {
if (st % 2 == 1) {
mmatr(sz, re, ma, a);
mcpy(sz, re, a);
}
st = st / 2;
mcpy(sz, b, ma);
mmatr(sz, ma, b, a);
mcpy(sz, ma, a);
}
}
int main() {
int i, j, k, t;
int mp = 1;
char x[8];
memset(m, -1, sizeof(m));
scanf("%I64d %d", &n, &c);
for (i = 1; i <= c; i++) {
scanf("%s %d", x, &k);
t = x[0] - 'A';
if (m[t] == -1) m[t] = 1;
m[t] = m[t] * k;
tt[i] = t;
mm[i] = k;
mp = mp * k;
}
memset(col, 0, sizeof(col));
col[0] = 1;
memset(bma, 0, sizeof(bma));
for (i = 0; i < mp; i++) {
for (j = 0; j <= 26; j++) {
if (m[j] == -1) continue;
bma[i][next(i, j)]++;
}
}
mpow(mp, bma, n);
int res = 0;
for (j = 0; j < mp; j++) {
for (k = 0; k <= 26; k++) {
if (m[k] == -1) continue;
if (m[k] == 1) continue;
int st = getSt(j, k);
for (i = 1; i <= c; i++) {
if (tt[i] == k)
if (st % mm[i] == 0) break;
}
if (i > c) break;
}
if (k <= 26) continue;
res = res + re[0][j];
if (res >= mod) res = res % mod;
}
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (k == 0 && n > 1) {
puts("No solution");
return 0;
}
printf("%d", k);
--n;
while (n--) {
printf("%c", '0');
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fi first
#define se second
const int N=2e6+1;
int n,k;
ll a[N];
int main(){
ios::sync_with_stdio(false);
cin >> n >> k;
ll l=1,r;
for(int i=1; i<=n ;i++){
cin >> a[i];
r=max(r,a[i]);
}
while(l!=r){
ll mid=(l+r)/2;
ll s=0;
for(int i=1; i<=n ;i++){
s+=(a[i]-1)/mid;
}
if(s<=k) r=mid;
else l=mid+1;
}
cout <<l << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int lst[3] = {};
int fst[3] = {};
int cmax[3] = {};
int main() {
int pos;
char cl;
long long ans = 0;
cin >> n;
for (int i = 0; i < (n); ++i) {
scanf("%d %c", &pos, &cl);
if (cl == 'G') {
if (lst[1] != 0)
ans += pos - lst[1],
cmax[1] = ((pos - lst[1]) > cmax[1]) ? (pos - lst[1]) : cmax[1];
if (lst[2] != 0)
ans += pos - lst[2],
cmax[2] = ((pos - lst[2]) > cmax[2]) ? (pos - lst[2]) : cmax[2];
if (lst[0] != 0 && cmax[1] + cmax[2] > pos - lst[0]) {
ans -= (cmax[1] + cmax[2]);
ans += pos - lst[0];
}
lst[1] = lst[2] = lst[0] = pos;
cmax[1] = cmax[2] = 0;
} else if (cl == 'R') {
if (lst[1] == 0)
lst[1] = pos;
else {
cmax[1] = ((pos - lst[1]) > cmax[1]) ? (pos - lst[1]) : cmax[1];
ans += pos - lst[1];
lst[1] = pos;
}
} else if (cl == 'B') {
if (lst[2] == 0)
lst[2] = pos;
else {
cmax[2] = ((pos - lst[2]) > cmax[2]) ? (pos - lst[2]) : cmax[2];
ans += pos - lst[2];
lst[2] = pos;
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
int main(void) {
int n, i;
ll a[200003] = {}, m1, m2, ans = 1e20;
ll* p1, * p2;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (i = 2; i < n - 1; i++) {
p1 = lower_bound(a + 1, a + i, a[i] / 2 + 1);
p2 = lower_bound(a + i + 1, a + n + 1, (a[n] + a[i]) / 2 + 1);
for (int t1 = 0; t1 < 2; t1++) {
for (int t2 = 0; t2 < 2; t2++) {
m1 = max({ *p1,a[i] - *p1,*p2 - a[i],a[n] - *p2 });
m2 = min({ *p1,a[i] - *p1,*p2 - a[i],a[n] - *p2 });
ans = min(ans, m1 - m2);
p2--;
}
p1--;
p2 += 2;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
int n, m, kk;
const int INF = 1 << 28;
while(cin >> n >> m){
if((n|m) == 0) break;
vector<vector<vector<int> > > score(2, vector<vector<int> >(m, vector<int>(m, INF)));
int a, b, cost, time;
for(int i=0; i<n; i++){
cin >> a >> b >> cost >> time;
a--;
b--;
score[0][a][b] = score[0][b][a] = cost;
score[1][a][b] = score[1][b][a] = time;
}
for (int k = 0; k < m; ++k) {
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
score[0][i][j] = min(score[0][i][j], score[0][i][k]+score[0][k][j]);
score[1][i][j] = min(score[1][i][j], score[1][i][k]+score[1][k][j]);
}
}
}
int p, q, r;
cin >> kk;
while(kk--){
cin >> p >> q >> r;
--q;
--p;
cout << score[r][p][q] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int count = 0;
for (int i = 0; i < n - 1; i++) {
while (a[i] >= a[i + 1]) {
a[i + 1]++;
count++;
}
}
cout << count << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void debug() { cout << endl; }
template <class FIRST, class... REST>
void debug(FIRST arg, REST... rest) {
cout << arg << " ";
debug(rest...);
}
template <class T>
void showary(T begin, T end) {
while (begin != end) {
cout << *begin << " ";
begin++;
}
cout << endl;
}
long long N, M, K, P;
long long h[100010], H[100010];
long long A[100010];
bool C(long long m) {
for (int i = 0; i < N; i++) H[i] = m;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
for (int i = 0; i < N; i++) {
if (H[i] - M * A[i] >= 0) continue;
que.push(pair<int, int>(H[i] / A[i] - 1, i));
}
int count = 0;
for (; count < M * K; count++) {
if (que.empty()) break;
pair<int, int> hit = que.top();
que.pop();
if (hit.first < count / K) return false;
int i = hit.second;
H[i] += P;
if (H[i] - M * A[i] >= 0) continue;
que.push(pair<int, int>(H[i] / A[i] - 1, i));
}
if (count > M * K) return false;
for (int i = 0; i < N; i++) {
if (H[i] - M * A[i] >= h[i]) continue;
count += (h[i] - (H[i] - M * A[i]) + P - 1) / P;
if (count > M * K) return false;
}
return true;
}
int main() {
cin >> N >> M >> K >> P;
for (int i = 0; i < N; i++) cin >> h[i] >> A[i];
long long lv = 0, rv = 1LL << 55;
while (rv - lv > 1) {
long long m = (lv + rv) / 2;
if (C(m))
rv = m;
else
lv = m;
}
cout << rv << endl;
}
| 5 |
#include<iostream>
#include<vector>
int n, m, count, ans;
std::vector<std::vector<int>>v;
std::vector<bool>used(8, 0);
void dfs(int num) {
used[num] = true;
count++;
if (count == n)ans++;
for (auto i : v[num]) {
if (used[i])continue;
dfs(i);
}
count--;
used[num] = false;
}
int main() {
std::cin >> n >> m;
v.resize(n);
for (int i = 0; i < m; i++) {
int a, b;
std::cin >> a >> b;
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(0);
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using namespace std;
int n, x;
void solve() {
cin >> n;
set<int> s;
for (int i = 0; i < n; i++) {
cin >> x;
if (x % 2 == 0) s.insert(x);
}
int ans = 0;
while (s.size()) {
auto it = s.end();
--it;
int val = *it;
s.erase(*--s.end());
while (!s.count(val) && val % 2 == 0) {
val /= 2;
++ans;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
if (c <= b && d >= a) {
a = max(a, c);
b = min(b, d);
if (a <= e && e <= b) b--;
cout << b - a + 1 << endl;
} else
cout << 0 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
set<int> ok;
for(int i = 0; i < m; ++i) {
int a;
cin >> a;
ok.emplace(a);
}
int ans = 0;
for(int i = 1; i <= n; ++i) {
auto it = ok.lower_bound(i);
int mn = INT_MAX;
if(it != ok.end()) {
mn = min(mn, *it - i);
}
if(it != ok.begin()) {
--it;
mn = min(mn, i - *it);
}
ans = max(ans, mn);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool func(int p, int k) {
int y = 0;
bool mark[k + 1];
memset(mark, 0, sizeof(mark));
while (p != 0) {
int t = p % 10;
if (!mark[t] && t <= k) {
mark[t] = true;
y++;
}
p /= 10;
}
if (y > k)
return true;
else
return false;
}
int main() {
int n, k, s = 0, p;
scanf("%d%d", &n, &k);
while (n--) {
cin >> p;
if (func(p, k)) s++;
}
printf("%d\n", s);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define all(v) v.begin(),v.end()
#define all1(v) v.begin()+1,v.end()
#define ittr(x,v) for(auto x=v.begin();x!=v.end();x++)
#define itpr(v) ittr(x,v) cout<<*x<<" "; cout<<"\n"
#define itppr(v) ittr(x,v) cout<<(*x).first<<" "<<(*x).second<<" "; cout<<"\n"
#define sz(x) (ll)((x).size())
#define pi acosl(-1)
#define INF 1000000000
#define INFF 1000000000000000000
typedef long long int ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef map<ll,ll> ml;
typedef set<ll> sl;
typedef pair<ll,ll> pl;
typedef vector< pl > vpl;
typedef map<pl,ll> mpl;
typedef set< pl > spl;
typedef vector<string> vst;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef vector<vb> vvb;
const ll M=1000000007;
const ll N=998244353;
ll power(ll x, ll y, ll p){ //MODULAR EXPONENTIATION
ll res=1;
x=x%p;
if(x==0)
return 0;
while(y>0){
if(y&1)
res=(res*x)%p;
y=y>>1;
x=(x*x)%p;
}
return res;
}
ll inv(ll x, ll m){ //FERMAT INVERSE
return power(x,m-2,m);
}
struct comp{ //COMPARISON ON PAIRS
template<typename T>
bool operator()(const T &a, const T &b){
if (a.first==b.first)
return (a.second<b.second);
else
return (a.first<b.second);
}
};
bool mod(const pair<ll,ll> &a, const pair<ll,ll> &b){ //COMPARATOR FOR PAIRS (SORTING)
if(a.first>=b.first||a.second>=b.second)
return false;
else
return true;
}
int bsearch(pl x, vpl &v){
ll r=sz(v)-1,l=0;
ll ans=-1;
while(l<=r){
ll mid=l+(r-l)/2;
if(v[mid].first>x.first){
r=mid-1;
ans=mid;
}
else{
l=mid+1;
}
}
return ans;
}
bool isValid(ll i, ll j, ll n, ll m){ //CHECKS FOR OVERFLOW IN MATRIX
if(i>=1&&i<=n&&j>=1&&j<=m){
return true;
}
return false;
}
/*--------------MAIN FUNCTION STARTS HERE--------------*/
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int t;
cin>>t;
while(t--){
ll n,x;
cin>>n>>x;
vl v(n);
ll sum1=0,sum2=0;
for(int i=0;i<n;i++){
cin>>v[i];
sum1+=v[i];
sum2+=(v[i]+x-1)/x;
}
sum1=(sum1+x-1)/x;
cout<<sum1<<" "<<sum2<<"\n";
}
return 0;
}
/*-----------------------------------------------------*/
/*
int t;
cin>>t;
while(t--){
}
1. DO NOT RETURN 0 FROM WITHIN WHILE(T--) LOOP, USE CONTINUE
2. INT OVERFLOWS
3. ARRAY OVERFLOWS
4. '=' AND '=='
5. IF STD::BAD_ALLOC: CHECK INPUT REDIRECTION, CHECK IF ALL INPUTS WERE READ
*/
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100 + 10;
int GCD(long long int a, long long int b) {
if (b == 0) {
return 0;
}
int res = GCD(b, a % b);
if (res == 0) {
return 1;
} else {
long long int k = a / b;
if (b & 1) {
int ans = 1 - k % 2;
return ans;
} else {
if (k % (b + 1) == 0) {
return 1;
} else {
int ans = 1 - k % (b + 1) % 2;
return ans;
}
}
}
}
int main() {
time_t t_start, t_end;
t_start = clock();
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long int a, b;
cin >> a >> b;
if (b > a) {
long long int tmp = a;
a = b;
b = tmp;
}
int res = GCD(a, b);
string ans = (res == 1 ? "First" : "Second");
cout << ans << endl;
}
t_end = clock();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M=2005;
char g[M][M];
int dp[M][M][4];
int n,m;
int main()
{
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
scanf("%s",g[i]);
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
{
if(g[i][j]=='#') continue;
dp[i][j][0]=i==0?1:(dp[i-1][j][0]+1);
dp[i][j][1]=j==0?1:(dp[i][j-1][1]+1);
}
for(int i=n-1;i>=0;i--)
for(int j=m-1;j>=0;j--)
{
if(g[i][j]=='#') continue;
dp[i][j][2]=i==n-1?1:(dp[i+1][j][2]+1);
dp[i][j][3]=j==m-1?1:(dp[i][j+1][3]+1);
}
int ans=0;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
{
if(g[i][j]=='#') continue;
ans=max(ans,dp[i][j][0]+dp[i][j][1]+dp[i][j][2]+dp[i][j][3]-3);
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
#define MAX 200005
using namespace std;
int main(){
int n, t, ti[MAX], ans = 0;
scanf("%d%d%d", &n, &t, &ti[0]);
for(int i = 1; i < n; i++){
scanf("%d", &ti[i]);
ans += min(ti[i] - ti[i-1], t);
}
ans += t;
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int gcd(unsigned long long int a, unsigned long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
string s;
getline(cin, s);
string ans = "NO";
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] != '?' && s[i] != ' ') {
if (s[i] == 'a' || s[i] == 'A' || s[i] == 'E' || s[i] == 'e' ||
s[i] == 'I' || s[i] == 'i' || s[i] == 'O' || s[i] == 'o' ||
s[i] == 'U' || s[i] == 'u' || s[i] == 'Y' || s[i] == 'y')
ans = "YES";
break;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, dem = 0;
char m[505][505];
void input() {
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> m[i][j];
}
}
return;
}
void solve() {
for (int i = 2; i < n; i++) {
for (int j = 2; j < n; j++) {
if (m[i][j] == '.') {
continue;
} else if (m[i][j] == m[i + 1][j + 1] && m[i][j] == m[i - 1][j - 1] &&
m[i][j] == m[i - 1][j + 1] && m[i][j] == m[i + 1][j - 1]) {
dem++;
}
}
}
return;
}
void output() {
cout << dem;
return;
}
int main() {
ios_base::sync_with_stdio(false);
input();
solve();
output();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
namespace UFS {
const int maxn = 1e5;
const int maxm = 2e5;
stack<pair<int, int> > s;
int ufs[maxn + 5], sz[maxn + 5], dis[maxn + 5];
int find(int x, int& d) {
d = 0;
int res = x;
while (res ^ ufs[res]) {
d ^= dis[res];
res = ufs[res];
}
return res;
}
bool unite(int x, int y, bool& tag) {
int dx, dy;
x = find(x, dx), y = find(y, dy);
if (x != y) {
if (sz[x] < sz[y]) swap(x, y);
dis[y] = dx ^ dy ^ 1;
s.push(pair<int, int>(y, ufs[y]));
s.push(pair<int, int>(x, sz[x]));
ufs[y] = x;
sz[x] += sz[y];
tag = true;
return false;
} else
tag = false;
return dx ^ dy ^ 1;
}
struct edge {
int u, v, w;
bool flag;
bool add() { return unite(u, v, flag); }
void erase() {
if (flag) {
pair<int, int> state = s.top();
s.pop();
sz[state.first] = state.second;
state = s.top();
s.pop();
ufs[state.first] = state.first;
}
flag = false;
}
} e[maxm + 5];
void init(int n) {
for (int i = 1; i <= n; ++i) ufs[i] = i, sz[i] = 1;
while (!s.empty()) s.pop();
}
} // namespace UFS
struct Edge {
Edge() {}
Edge(int _l, int _r, pair<int, int> _eg) { l = _l, r = _r, eg = _eg; }
int l, r;
pair<int, int> eg;
};
map<pair<int, int>, int> mp;
vector<int> arr[4 * maxn + 5];
vector<Edge> g;
int n, q, res[maxn + 5];
void modify(int index, int L, int R, int ML, int MR, int id) {
if (L >= ML && R <= MR) {
arr[index].push_back(id);
return;
}
int mid = L + R >> 1;
if (mid >= ML) modify(2 * index, L, mid, ML, MR, id);
if (MR > mid) modify(2 * index + 1, mid + 1, R, ML, MR, id);
}
void Erase(int index) {
for (int i = 0; i < arr[index].size(); ++i) UFS::e[arr[index][i]].erase();
}
void solve(int index, int L, int R) {
for (int i = 0; i < arr[index].size(); ++i) {
int id = arr[index][i];
if (UFS::e[id].add()) {
for (int j = 0; j <= i; ++j) UFS::e[arr[index][j]].erase();
return;
}
}
if (L == R)
res[L] = 1;
else {
int mid = L + R >> 1;
solve(2 * index, L, mid);
solve(2 * index + 1, mid + 1, R);
}
Erase(index);
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1, u, v; i <= q; ++i) {
scanf("%d %d", &u, &v);
if (u > v) swap(u, v);
if (mp.count(pair<int, int>(u, v))) {
int id = mp[pair<int, int>(u, v)];
mp.erase(pair<int, int>(u, v));
g[id].r = i - 1;
} else {
g.push_back(Edge(i, q, pair<int, int>(u, v)));
mp[pair<int, int>(u, v)] = g.size() - 1;
}
}
for (int i = 0; i < g.size(); ++i) {
modify(1, 1, q, g[i].l, g[i].r, i);
UFS::e[i].u = g[i].eg.first;
UFS::e[i].v = g[i].eg.second;
}
UFS::init(n);
solve(1, 1, q);
for (int i = 1; i <= q; ++i) {
if (res[i])
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isprime[2000050];
int sumf[2000050];
int a, b, k, i;
int hf, lf, l;
int main() {
ios::sync_with_stdio(false);
memset(isprime, true, sizeof isprime);
isprime[1] = false;
for (i = 2; i < 1000000; i++) {
if (isprime[i])
for (int j = 2 * i; j < 2000050; j += i) isprime[j] = false;
}
sumf[0] = 0;
for (i = 1; i < 2000050; i++) sumf[i] = sumf[i - 1] + isprime[i];
cin >> a >> b >> k;
hf = 0;
lf = b - a + 1;
while (hf + 1 < lf) {
l = (hf + lf) / 2;
bool flag = true;
for (i = a; i <= b - l + 1; i++) {
if ((sumf[i + l - 1] - sumf[i - 1]) < k) {
flag = false;
break;
}
}
if (!flag)
hf = l;
else
lf = l;
}
bool flag = true;
for (i = a; i <= b - lf + 1; i++) {
if ((sumf[i + lf - 1] - sumf[i - 1]) < k) {
flag = false;
break;
}
}
if (!flag)
printf("%d\n", -1);
else
printf("%d\n", lf);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
long long int n;
cin >> n;
long long int ans1 = 1000000000000000000;
std::vector<long long int> factors;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
factors.push_back(i);
factors.push_back(n / i);
}
}
for (long long int i = 0; i < factors.size(); i++) {
for (long long int j = 0; j < factors.size(); j++) {
if (n % (factors[i] * factors[j]) == 0) {
long long int a, b, c;
a = n / (factors[i] * factors[j]);
b = factors[i];
c = factors[j];
long long int tmp = ((a + 1) * (b + 2) * (c + 2)) - n;
ans1 = min(ans1, tmp);
}
}
}
long long int ans2 = 8 * n + 9;
cout << ans1 << " " << ans2;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool vowl(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool check(long long int n, long long int p) {
if (power(n, (p - 1) / 2, p) == 1) return true;
return false;
}
int main() {
int t;
cin >> t;
while (t--) {
int n, k1, k2, max1 = 0, max2 = 0;
cin >> n >> k1 >> k2;
int arr[k1], arr1[k2];
for (int i = 0; i < k1; i++) {
cin >> arr[i];
if (arr[i] > max1) {
max1 = arr[i];
}
}
for (int i = 0; i < k2; i++) {
cin >> arr1[i];
if (arr1[i] > max2) max2 = arr1[i];
}
if (max1 > max2) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
using namespace std;
int a=0;
vector<string>sts;
vector<int>ens;
int getnum(){
if(sts[a]=="*"){
int num=1;
int pe=ens[a+1];
a++;
while(a!=sts.size()&&ens[a]==pe){
num*=getnum();
}
return num;
}
else if(sts[a]=="+"){
int num=0;
int pe=ens[a+1];
a++;
while(a!=sts.size()&&ens[a]==pe){
num+=getnum();
}
return num;
}else{
int num=stoi(sts[a]);
a++;
return num;
}
}
int main()
{
while(1){
int n;cin>>n;
if(!n)break;
for(int i=0;i<n;++i){
string st;cin>>st;
int n=st.find_first_not_of(".");
sts.push_back(st.substr(n));
ens.push_back(n);
// cout<<sts[i]<<" "<<ens[i]<<endl;
}
int ans=getnum();
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i, j;
cin >> n >> i >> j;
string s;
cin >> s;
if (s[i - 1] == s[j - 1]) {
cout << '0' << endl;
} else {
cout << '1' << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
set<pair<int, int> > s, e;
long long dp[N];
int l[N], r[N];
struct Point {
int x, h, k;
bool f;
} p[2 * N];
struct temp {
int h, k;
} q[N];
int m;
bool cmp1(const temp &a, const temp &b) { return a.h > b.h; }
bool cmp(const Point &a, const Point &b) {
if (a.x != b.x) return a.x < b.x;
if (a.f != b.f) return a.f;
return a.k < b.k;
}
vector<int> tran[N];
int main() {
set<pair<int, int> >::iterator it;
int n, t;
scanf("%d%d", &n, &t);
for (int i = 0; i < n; i++) {
int h;
scanf("%d%d%d", &h, &l[i + 1], &r[i + 1]);
p[m].x = l[i + 1], p[m].h = h, p[m].k = i + 1, p[m++].f = false;
p[m].x = r[i + 1], p[m].h = h, p[m].k = i + 1, p[m++].f = true;
q[i].h = h, q[i].k = i + 1;
}
l[0] = -(1 << 30), r[0] = (1 << 30);
l[n + 1] = -(1 << 30), r[n + 1] = (1 << 30);
q[n].h = t, q[n].k = 0;
q[n + 1].h = 0, q[n + 1].k = n + 1;
sort(p, p + m, cmp);
sort(q, q + n + 2, cmp1);
s.insert(make_pair(t, 0));
s.insert(make_pair(0, n + 1));
for (int i = 0; i < m; i++) {
if (p[i].f) {
it = s.find(make_pair(p[i].h, p[i].k));
if (it != s.end()) s.erase(it);
} else {
int a, b;
it = s.lower_bound(make_pair(p[i].h, 0));
a = it->second;
--it;
b = it->second;
it = e.find(make_pair(a, b));
if (it != e.end()) e.erase(it);
e.insert(make_pair(a, p[i].k));
e.insert(make_pair(p[i].k, b));
s.insert(make_pair(p[i].h, p[i].k));
}
}
for (it = e.begin(); it != e.end(); it++)
tran[it->first].push_back(it->second);
dp[0] = (1ll << 50);
for (int i = 0; i < n + 2; i++) {
int now = q[i].k;
for (int j = 0; j < tran[now].size(); j++) {
int tag = tran[now][j];
dp[tag] = max(
dp[tag], min(dp[now], min((long long)r[now], (long long)r[tag]) -
max((long long)l[now], (long long)l[tag])));
}
}
printf("%I64d\n", dp[n + 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
namespace debug {
void err() { cout << endl; }
template <template <typename...> class T, typename t, typename... Args>
void err(T<t> a, Args... args) {
for (auto x : a) cout << x << ' ';
err(args...);
}
template <typename T, typename... Args>
void err(T a, Args... args) {
cout << a << ' ';
err(args...);
}
} // namespace debug
namespace stdio_input {
void scanf_int() {}
template <typename T, typename... Args>
void scanf_int(T &a, Args &...args) {
scanf("%d", &a);
scanf_int(args...);
}
void scanf_ll() {}
template <typename T, typename... Args>
void scanf_ll(T &a, Args &...args) {
scanf("%lld", &a);
scanf_ll(args...);
}
void scanf_double() {}
template <typename T, typename... Args>
void scanf_double(T &a, Args &...args) {
scanf("%lf", &a);
scanf_double(args...);
}
} // namespace stdio_input
namespace const_var {
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const long double eps = 1e-6;
const int mod = 1e9 + 7;
const int maxn = 3e6;
const int N = 2e5 + 10;
const int M = 1e6 + 10;
} // namespace const_var
using namespace debug;
using namespace stdio_input;
using namespace const_var;
int T = 0;
void testcase() { cout << "Case #" << (++T) << ": "; }
struct Edge {
int to, next;
} edge[M];
std::vector<int> G[N];
int Low[N], DFN[N], Stack[N], head[N], Instack[N];
int Index, top, n1, cnt;
void addedge(int u, int v) {
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void Tarjan(int u, int pre) {
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
for (int i = head[u]; ~i; i = edge[i].next) {
v = edge[i].to;
if (v == pre) continue;
if (!DFN[v]) {
Tarjan(v, u);
if (Low[u] > Low[v]) Low[u] = Low[v];
if (Low[v] >= DFN[u]) {
int vn;
++n1;
G[n1].push_back(u);
G[u].push_back(n1);
do {
vn = Stack[--top];
Instack[vn] = false;
G[vn].push_back(n1);
G[n1].push_back(vn);
} while (vn != v);
}
} else if (Instack[v] && Low[u] > DFN[v])
Low[u] = DFN[v];
}
}
const int DEG = 21;
int fa[N][DEG], dep[N];
void dfs(int u, int pre) {
fa[u][0] = pre;
dep[u] = dep[pre] + 1;
for (int i = 1; i <= DEG - 1; ++i) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
for (auto v : G[u]) {
if (v == pre) continue;
dfs(v, u);
}
}
int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int t = dep[u] - dep[v];
for (int i = 0; i < DEG; ++i) {
if (t & (1 << i)) u = fa[u][i];
}
for (int i = DEG - 1; i >= 0; --i) {
int uu = fa[u][i], vv = fa[v][i];
if (uu != vv) {
u = uu;
v = vv;
}
}
return u == v ? u : fa[u][0];
}
void work() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) {
head[i] = -1;
}
n1 = n;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
addedge(u, v);
addedge(v, u);
}
for (int i = 1; i <= n; ++i) {
if (!DFN[i]) {
Tarjan(i, i);
}
}
dfs(1, 1);
for (; q--;) {
int u, v;
cin >> u >> v;
int lca = LCA(u, v);
int ans = dep[u] + dep[v] - 2 * dep[lca];
ans >>= 1;
cout << ans << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
work();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
const int maxn = 1e5 + 10;
const int maxm = 1e6 + 10;
const long long mod = 1e9 + 7;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long l, r;
scanf("%lld%lld", &l, &r);
printf("%lld %lld\n", l, 2ll * l);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char s[100][105];
int d[100][100][11], p[100][100][11], pq[100][100][11];
string ans;
int main() {
scanf("%d%d%d", &n, &m, &k), ++k;
for (int i = 0; i < (int)(n); ++i) scanf("%s", s[i]);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j)
for (int q = 0; q < (int)(k); ++q) d[i][j][q] = -1;
for (int i = 0; i < (int)(m); ++i)
d[n - 1][i][(s[n - 1][i] - '0') % k] = s[n - 1][i] - '0';
for (int i = n - 1; i > 0; --i) {
for (int j = 0; j < (int)(m - 1); ++j)
for (int q = 0; q < (int)(k); ++q)
if (d[i][j][q] != -1) {
int cnt = d[i][j][q] + s[i - 1][j + 1] - '0';
int mo = cnt % k;
if (d[i - 1][j + 1][mo] < cnt) {
d[i - 1][j + 1][mo] = cnt;
p[i - 1][j + 1][mo] = 0;
pq[i - 1][j + 1][mo] = q;
}
}
for (int j = 1; j < m; ++j)
for (int q = 0; q < (int)(k); ++q)
if (d[i][j][q] != -1) {
int cnt = d[i][j][q] + s[i - 1][j - 1] - '0';
int mo = cnt % k;
if (d[i - 1][j - 1][mo] < cnt) {
d[i - 1][j - 1][mo] = cnt;
p[i - 1][j - 1][mo] = 1;
pq[i - 1][j - 1][mo] = q;
}
}
}
int best = 0;
for (int i = 1; i < m; ++i)
if (d[0][i][0] > d[0][best][0]) {
best = i;
}
if (d[0][best][0] == -1) {
printf("-1\n");
return 0;
}
int q = 0;
printf("%d\n", d[0][best][0]);
for (int i = 0; i < (int)(n - 1); ++i) {
if (p[i][best][q] == 0) {
ans += 'R';
q = pq[i][best][q];
--best;
} else {
ans += 'L';
q = pq[i][best][q];
++best;
}
}
reverse(ans.begin(), ans.end());
printf("%d\n%s\n", best + 1, ans.c_str());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100005;
const int INF = 0x3f3f3f3f;
const int MOD = 6700417;
template <typename T>
void debug(initializer_list<T> text) {
for (auto val : text) cerr << val << " ";
cerr << endl;
}
char s[5005];
int ans = INF, len;
long long ha, hb, Key, oriHash;
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
for (int i = (1); i <= (len); i++)
oriHash = (oriHash * 27 % MOD + (s[i] - 'a' + 1)) % MOD;
for (int i = (1); i <= (len - 1); i++) {
ha = 0, hb = 0, Key = 1;
for (int j = (i + 1); j <= (INF); j++) {
if (j > len) j -= len;
ha += (s[j] - 'a' + 1) * Key % MOD;
ha %= MOD;
hb *= 27;
hb %= MOD;
hb += (s[j] - 'a' + 1);
hb = hb % MOD;
Key = Key * 27 % MOD;
if (j == i) break;
}
if (ha == hb && ha != oriHash) ans = 1;
}
for (int l = (1); l <= (len / 2); l++) {
ha = hb = 0, Key = 1;
for (int r = (l); r <= (len / 2); r++) {
ha += (s[r] - 'a' + 1) * Key % MOD;
ha %= MOD;
hb = hb * 27 % MOD;
hb += (s[r] - 'a' + 1);
hb %= MOD;
Key = Key * 27 % MOD;
if (ha != hb) {
ans = min(ans, (l == 1 ? 0 : 2) + (r * 2 == len ? 1 : 2));
}
}
}
if (ans == INF)
puts("Impossible");
else
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, m;
int ansl = 0;
char used[MAXN] = {0};
vector<pair<pair<int, int>, int> > g[MAXN];
int ans[MAXN], sortAll[MAXN];
bool dfs(int cnt, int v = 0) {
used[v] = 1;
for (size_t i = 0; i < g[v].size(); ++i) {
if (g[v][i].first.second <= cnt) continue;
int tmp = g[v][i].first.second;
int to = g[v][i].first.first;
if (used[to] == 1) return false;
if (!used[to])
if (!dfs(cnt, to)) return false;
}
used[v] = 2;
ans[ansl++] = v;
return true;
}
bool check(int cnt) {
for (int i = 0; i < n; ++i) used[i] = 0;
ansl = 0;
for (int i = 0; i < n; ++i)
if (!used[i])
if (!dfs(cnt, i)) {
return false;
}
reverse(ans, ans + ansl);
return true;
}
int bin_search() {
int l = 0, r = m + 1;
while (l != r) {
int med = (l + r) / 2;
if (!check(sortAll[med]))
l = med + 1;
else
r = med;
}
return r;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int v, u, r;
scanf("%d%d%d", &v, &u, &r);
g[v - 1].push_back({{u - 1, r}, i});
sortAll[i] = r;
}
sortAll[0] = 0;
sortAll[m + 1] = INT_MAX / 2;
sort(sortAll, sortAll + m + 1);
int sueta = bin_search();
printf("%d ", sortAll[sueta]);
ansl = 0;
for (int i = 0; i < n; ++i) used[i] = 0;
check(sortAll[sueta]);
int top_sort[MAXN];
for (int i = 0; i < n; ++i) top_sort[ans[i]] = i;
vector<int> kek;
for (int i = 0; i < n; ++i)
for (size_t j = 0; j < g[i].size(); ++j) {
if (g[i][j].first.second <= sortAll[sueta] &&
top_sort[i] > top_sort[g[i][j].first.first])
kek.push_back(g[i][j].second);
}
printf("%d\n", kek.size());
sort(kek.begin(), kek.end());
for (size_t i = 0; i < kek.size(); ++i) printf("%d ", kek[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 1e5 + 1;
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string second, t;
cin >> second >> t;
long long pos = (int)(second).size();
for (int i = 1; i < (int)(second).size(); i++) {
if (second[i] >= t[0]) {
pos = i;
break;
}
}
for (int i = 0; i < pos; i++) {
cout << second[i];
}
cout << t[0];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
long double x;
long double y;
int cost[300005], ans[300005];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> cost[i];
}
priority_queue<pair<int, int> > ms;
for (int i = 1; i <= k; ++i) {
ms.push(make_pair(cost[i], i));
}
long long cst = 0;
for (int i = k + 1; i <= n; ++i) {
ms.push(make_pair(cost[i], i));
ans[ms.top().second] = i;
cst += 1LL * (i - ms.top().second) * (ms.top().first);
ms.pop();
}
for (int i = n + 1; i <= n + k; ++i) {
ans[ms.top().second] = i;
cst += 1LL * (i - ms.top().second) * (ms.top().first);
ms.pop();
}
cout << cst << endl;
for (int i = 1; i <= n; ++i) {
cout << ans[i] << " ";
}
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const double Pi = acos(-1);
const double e = exp(1.0);
const int mod = 1e9 + 7;
int main() {
int n, m, ans;
scanf("%d%d", &n, &m);
if (m == 1 || m == 0)
ans = 1;
else if (m == 2 && m > 3)
ans = 2;
else if (m <= n / 2)
ans = m;
else
ans = n - m;
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long power(long long x, long long p, long long MOD) {
if (p == 0) return 1 % MOD;
if (p == 1) return x % MOD;
long long res = power(x, p / 2, MOD);
res = (long long)res * res % MOD;
if (p & 1) res = (long long)res * x % MOD;
return res;
}
const long long N = 20;
long long r[N][2];
int32_t main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> r[i][0];
r[i][1] = 360 - r[i][0];
}
for (long long i = 0; i < (1LL << n); i++) {
long long cur = 0;
for (long long j = 0; j < n; j++) {
long long idx = (i >> j) & 1;
cur += r[j][idx];
cur %= 360;
}
if (cur == 0) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[5005][5005];
int main() {
long long i, j, k, c = 0, n, p, ans = 0;
cin >> k >> n;
for (i = 1; i <= k; i++)
for (j = 1; j < n; j++) a[i][j] = ++c;
for (i = 1; i <= k; i++)
for (j = n; j <= k; j++) a[i][j] = ++c;
for (i = 1; i <= k; i++) ans += a[i][n];
cout << ans << endl;
for (i = 1; i <= k; i++) {
for (j = 1; j <= k; j++) cout << a[i][j] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
void read(int &x) {
x = 0;
int flag = 1;
char ch = ' ';
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= flag;
}
void read(long long &x) {
x = 0;
int flag = 1;
char ch = ' ';
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= flag;
}
using namespace std;
int n, k;
bool tag[150010];
long long a[150010];
struct node {
long long val;
int num;
node() {}
node(long long a, int b) { val = a, num = b; }
bool operator<(const node &a) const {
return val > a.val || (val == a.val && num > a.num);
}
};
priority_queue<node> pq;
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]), pq.push(node(a[i], i));
int k = 0;
while (!pq.empty()) {
node tmp = pq.top();
pq.pop();
node tmp2;
if (pq.empty()) tag[tmp.num] = 1, k++;
while (!pq.empty()) {
tmp2 = pq.top();
pq.pop();
if (tmp2.val != tmp.val) {
k++;
tag[tmp.num] = 1;
tmp = tmp2;
if (pq.empty()) {
k++;
tag[tmp2.num] = 1;
break;
}
} else {
node tmp3 = node(tmp.val * 2, tmp2.num);
a[tmp3.num] = tmp3.val;
pq.push(tmp3);
break;
}
}
}
printf("%d\n", k);
for (int i = 1; i <= n; i++)
if (tag[i]) printf("%lld ", a[i]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
int a[511][511];
struct TPoint {
int x, y;
TPoint(int x, int y) : x(x), y(y) {}
TPoint operator+(const TPoint &p) const { return TPoint(x + p.x, y + p.y); }
TPoint operator-(const TPoint &p) const { return TPoint(x - p.x, y - p.y); }
int operator%(const TPoint &p) const { return x * p.y - y * p.x; }
int operator*(const TPoint &p) const { return x * p.x + y * p.y; }
int operator~() const { return *this * *this; }
bool operator<(const TPoint &p) const {
return make_pair(x, y) < make_pair(p.x, p.y);
}
};
bool cmp(const TPoint &a, const TPoint &b) {
if (a % b) return a % b > 0;
return ~a < ~b;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n;
while (1) {
cin >> n;
if (!n) break;
for (int i = 0; i < (int)(n); ++i) {
string s;
cin >> s;
for (int j = 0; j < (int)(n); ++j) a[i][j] = s[j] - '0';
}
vector<TPoint> p;
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(n); ++j) {
assert(a[i][j] >= 0);
if (a[i][j]) {
p.push_back(TPoint(i, j));
for (int di = 0; di < (int)(2); ++di)
for (int dj = 0; dj < (int)(2); ++dj) --a[i + di][j + dj];
}
}
TPoint O = *min_element((p).begin(), (p).end());
for (auto &w : p) w = w - O;
sort((p).begin(), (p).end(), cmp);
vector<TPoint> st;
for (auto w : p) {
while (st.size() > 1) {
TPoint prv = st.back(), pprv = st[st.size() - 2];
if ((w - pprv) % (prv - pprv) >= 0)
st.pop_back();
else
break;
}
st.push_back(w);
}
reverse((st).begin(), (st).end());
for (int i = 0; i < (int)(st.size()); ++i) {
st[i] = st[i] + O;
swap(st[i].x, st[i].y);
st[i].x += 1;
st[i].y = n - st[i].y - 1;
}
int j = min_element((st).begin(), (st).end()) - st.begin();
cout << st.size() << '\n';
for (int i = 0; i < (int)(st.size()); ++i) {
TPoint w = st[(i + j) % st.size()];
cout << w.x << ' ' << w.y << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005, mod = 1000000007;
long long int a, b, c, d, e, f, g, h[N], arr[N];
string s;
vector<pair<long long int, long long int> > v, v2;
vector<pair<pair<long long int, long long int>, long long int> > v3;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b;
for (long long int i = 1; i <= b; i++) {
long long int x, y, z;
cin >> x >> y >> z;
arr[x] += z;
arr[y] -= z;
}
for (long long int i = 1; i <= a; i++) {
if (arr[i] > 0) v.push_back(make_pair(i, arr[i]));
if (arr[i] < 0) v2.push_back(make_pair(i, -arr[i]));
}
long long int j = 0, i = 0;
while (j < v2.size() or i < v.size()) {
long long int awdasda = min(v2[j].second, v[i].second);
v3.push_back(make_pair(make_pair(v[i].first, v2[j].first), awdasda));
if ((v[i].second -= awdasda) == 0) i++;
if ((v2[j].second -= awdasda) == 0) j++;
}
cout << v3.size() << endl;
for (long long int i = 0; i < v3.size(); i++) {
cout << v3[i].first.first << ' ' << v3[i].first.second << ' '
<< v3[i].second << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie();
long long n;
cin >> n;
vector<long long> a(n + 1, 0), l(n + 1, 0), r(n + 1, 0);
vector<long long> sr(n + 1, 0), sl(n + 1, 0);
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
long long j = i - 1;
while (j >= 0 && a[j] > a[i]) j = l[j];
l[i] = j;
sl[i] = sl[j] + (i - j) * a[i];
}
long long max = 0, peekaboo;
for (long long i = n; i > 0; i--) {
long long j = i + 1;
while (j <= n && a[j] > a[i]) j = r[j];
r[i] = j;
sr[i] = sr[j] + (j - i) * a[i];
if (sr[i] + sl[i] - a[i] > max) {
max = sr[i] + sl[i] - a[i];
peekaboo = i;
}
}
for (long long i = peekaboo + 1; i <= n; i++) a[i] = min(a[i - 1], a[i]);
for (long long i = peekaboo - 1; i >= 1; i--) a[i] = min(a[i + 1], a[i]);
for (long long i = 1; i <= n; i++) cout << a[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007, N = 1e5 + 5;
int a[N], b[N], n;
vector<int> ans;
void dfs(int x) {
if (x == n) {
cout << "YES\n";
for (auto u : ans) cout << u << " ";
exit(0);
}
int t = ans[ans.size() - 1];
for (int i = 0; i <= 3; i++) {
if ((i | t) == a[x - 1] && (i & t) == b[x - 1]) {
ans.push_back(i);
dfs(x + 1);
ans.pop_back();
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) cin >> b[i];
ans.push_back(0);
dfs(1);
ans[0] = 1;
dfs(1);
ans[0] = 2;
dfs(1);
ans[0] = 3;
dfs(1);
cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, pn;
char s[111][111];
int dxy[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
struct edge {
int v, w, next;
edge() {}
edge(int _v, int _w, int _next) {
v = _v;
w = _w;
next = _next;
}
} e[200011];
int head[100011], sz;
void init() {
memset(head, -1, sizeof(head));
sz = 0;
}
void insert(int u, int v, int w) {
e[++sz] = edge(v, w, head[u]);
head[u] = sz;
}
struct node {
int v, d;
node() {}
node(int _v, int _d) {
v = _v;
d = _d;
}
bool operator<(const node &a) const { return d > a.d; }
};
priority_queue<node> pq;
bool vis[100011];
int pos[31][2], rs, cs, re, ce, dis[31][100011], lst[31][100011], pth[10000011],
tpth[10011];
char t[100011];
void dijkstra(int s, int *dis, int *lst) {
for (int i = 1; i <= n * m; ++i) dis[i] = 0x3f3f3f3f;
memset(vis, 0, sizeof(vis));
pq.push(node(s, 0));
dis[s] = 0;
lst[s] = -1;
while (!pq.empty()) {
int p = pq.top().v;
pq.pop();
if (vis[p]) continue;
vis[p] = 1;
if (::s[(p - 1) / m + 1][(p - 1) % m + 1] <= 'z' &&
::s[(p - 1) / m + 1][(p - 1) % m + 1] >= 'a' && p != s)
continue;
for (int i = head[p]; ~i; i = e[i].next)
if (dis[e[i].v] > dis[p] + e[i].w)
dis[e[i].v] = dis[p] + e[i].w, lst[e[i].v] = p,
pq.push(node(e[i].v, dis[e[i].v]));
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
init();
for (int i = 0; i <= n; ++i) s[i][0] = s[i][m + 1] = '#';
for (int i = 0; i <= m; ++i) s[0][i] = s[n + 1][i] = '#';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
for (int k = 0; k < 4; ++k)
if (s[i + dxy[k][0]][j + dxy[k][1]] != '#')
insert(((i - 1) * m + j), ((i + dxy[k][0] - 1) * m + j + dxy[k][1]),
s[i][j] >= '0' && s[i][j] <= '9' ? s[i][j] - '0' : 1);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (s[i][j] >= 'a' && s[i][j] <= 'z')
pos[s[i][j] - 'a' + 1][0] = i, pos[s[i][j] - 'a' + 1][1] = j;
scanf("%d%d%s%d%d", &rs, &cs, t + 1, &re, &ce);
pos[27][0] = rs;
pos[27][1] = cs;
pos[28][0] = re;
pos[28][1] = ce;
for (int i = 1; i <= 28; ++i)
if (pos[i][0]) dijkstra(((pos[i][0] - 1) * m + pos[i][1]), dis[i], lst[i]);
int q = strlen(t + 1);
t[0] = 'a' + 26;
t[++q] = 'a' + 27;
for (int i = 1; i <= q; ++i) {
int u = ((pos[t[i] - 'a' + 1][0] - 1) * m + pos[t[i] - 'a' + 1][1]), tn = 0;
while (~u) {
tpth[++tn] = u;
u = lst[t[i - 1] - 'a' + 1][u];
}
for (int j = tn - 1; j; --j) pth[++pn] = tpth[j];
}
pth[0] = ((rs - 1) * m + cs);
int cur = 0, ans = pn;
for (int i = 0; i <= pn; ++i) {
char c = s[(pth[i] - 1) / m + 1][(pth[i] - 1) % m + 1];
cur += c >= '0' && c <= '9' ? c - '0' : 1;
if (cur > k) {
ans = i;
break;
}
}
printf("%d %d\n", (pth[ans] - 1) / m + 1, (pth[ans] - 1) % m + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
int n, m;
int a[11][101010];
int pos[11][101010];
int h[1][11][101010];
int f[1] = {29};
int F[1][101010];
int val[11];
inline int calc(int i, int j, int L, int R) {
return (h[i][j][R] -
(long long)h[i][j][L - 1] * F[i][R - L + 1] % 1000000007 +
1000000007) %
1000000007;
}
inline bool can(int first, int len) {
for (int k = 1; k--;) {
for (int i = 1; i <= m; i++) {
int st = pos[i][first], ed = st + len - 1;
val[i] = calc(k, i, st, ed);
if (val[i] != val[1]) return false;
}
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int k = 1; k--;) {
F[k][0] = 1;
for (int i = 1; i <= n; i++)
F[k][i] = (long long)F[k][i - 1] * f[k] % 1000000007;
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", a[i] + j);
pos[i][a[i][j]] = j;
for (int k = 1; k--;) {
h[k][i][j] = ((long long)f[k] * h[k][i][j - 1] + a[i][j]) % 1000000007;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int st = 0, ed = n + 1;
for (int j = 1; j <= m; j++) smin(ed, n - pos[j][i] + 2);
while (ed - st > 1) {
int md = st + ed >> 1;
if (can(i, md))
st = md;
else
ed = md;
}
ans += st;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) cin >> a[i], b[i] = i;
sort(b.begin(), b.end(), [&a](int x, int y) { return a[x] < a[y]; });
for (int i = 1; i < n; ++i) swap(a[b[i - 1]], a[b[i]]);
for (auto x : a) cout << x << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] + a[i + 1] < k) {
ans += k - a[i + 1] - a[i];
a[i + 1] = k - a[i];
}
}
cout << ans << "\n";
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 1000;
int a[maxN], n, s = 1, q, t;
map<int, int> mp;
int main() {
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
mp[a[i]] = i;
}
for (int i = (1); i <= (n); i++) {
if (mp[i] > t)
q++;
else {
s = max(s, q);
q = 1;
}
t = mp[i];
}
s = max(s, q);
cout << n - s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v, ve;
int main() {
long long n, i, cur, ok = 0, ans, x;
cin >> n;
for (i = 0; i < n; i++) {
cin >> cur;
if (cur == 1)
v.push_back(cur);
else
ve.push_back(cur);
}
if (v.size() != 0 && ve.size() == 0) {
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
} else if (ve.size() != 0 && v.size() == 0) {
for (i = 0; i < ve.size(); i++) cout << ve[i] << " ";
} else if (v.size() != 0 && ve.size() != 0) {
cout << ve[0] << " " << v[0] << " ";
for (i = 1; i < ve.size(); i++) cout << ve[i] << " ";
for (i = 1; i < v.size(); i++) cout << v[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int p = 10000;
struct BigInteger {
int len;
int dig[1000 / 4];
BigInteger(int n = 0) {
for (len = 0; n > 0; n /= p) {
dig[len++] = n % p;
}
}
bool read() {
char s[4 * 1000 / 4];
if (scanf("%s", &s) == -1) {
return false;
}
int i, n = strlen(s), cur = 0, p = 1;
len = 0;
for (int i = 0; i < n; i++) {
cur += (s[n - i - 1] - '0') * p;
p *= 10;
if ((i + 1) % 4 == 0) {
dig[len++] = cur;
cur = 0;
p = 1;
}
}
if (cur > 0) {
dig[len++] = cur;
}
return true;
}
void print() const {
if (len == 0) {
printf("0");
} else {
int i = len - 1;
printf("%d", dig[i]);
char s[10];
sprintf(s, "%%0%dd", 4);
for (i--; i >= 0; i--) {
printf(s, dig[i]);
}
}
printf("\n");
}
BigInteger operator+(const BigInteger &b) const {
BigInteger s;
int i, d = 0;
int maxlen = len > b.len ? len : b.len;
for (i = 0; i < maxlen; i++) {
if (i < len) {
d += dig[i];
}
if (i < b.len) {
d += b.dig[i];
}
s.dig[i] = d % p;
d /= p;
}
if (d > 0) {
s.dig[i++] = d;
}
s.len = i;
return s;
}
BigInteger operator*(const int b) const {
BigInteger prod(0);
if (b == 0) {
return 0;
}
int i, d = 0;
for (i = 0; i < len; i++) {
d += dig[i] * b;
prod.dig[i] = d % p;
d /= p;
}
if (d > 0) {
prod.dig[i++] = d;
}
prod.len = i;
return prod;
}
bool operator==(const BigInteger &b) const {
if (len != b.len) {
return false;
}
for (int i = 0; i < len; i++) {
if (dig[i] != b.dig[i]) {
return false;
}
}
return true;
}
};
BigInteger p12[666];
int main(void) {
p12[0] = BigInteger(1);
for (int i = 1; i < 666; i++) p12[i] = p12[i - 1] * 12;
BigInteger a;
if (a.read()) {
bool found = false;
int i, j, k;
for (i = 0; i < 666 && !found; i++)
for (j = 0; j <= i && !found; j++) {
if (p12[i] + p12[j] == a) {
found = true;
}
}
if (!found) {
printf("NO\n");
return 0;
}
i--, j--;
printf("YES\n");
printf("1\n%d\n", i + j + 1);
printf("%d\n", (i + j) / 2);
for (k = (i + j) / 2; k >= 0; k--) {
if (k != i && k != j) {
(p12[k] + p12[i + j - k]).print();
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y;
vector<string> arr;
vector<pair<long long, long long>> col;
void solve() {
cin >> n >> m >> x >> y;
arr.resize(n);
col.resize(m);
vector<vector<pair<long long, long long>>> dp(
m + 1, vector<pair<long long, long long>>(y + 1));
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < m; i++) {
long long w = 0;
for (int j = 0; j < n; j++) {
if (arr[j][i] == '.') w++;
}
col[i] = {w, n - w};
}
for (int i = 0; i <= y; i++) dp[0][i] = {1e6, 1e6};
for (int i = 0; i <= m; i++) dp[i][0] = {0, 0};
long long mnw = 0, mnb = 0;
for (int i = 1; i <= m; i++) {
long long w = 1e6, b = 1e6;
for (int j = 1; j <= y; j++) {
if (j == 1) {
dp[i][j].first = mnb + col[i - 1].first;
dp[i][j].second = mnw + col[i - 1].second;
} else {
dp[i][j].first = dp[i - 1][j - 1].first + col[i - 1].first;
dp[i][j].second = dp[i - 1][j - 1].second + col[i - 1].second;
}
if (j >= x && j <= y) {
w = min(w, dp[i][j].first);
b = min(b, dp[i][j].second);
}
}
mnw = w;
mnb = b;
}
long long ans = 1e7;
for (int i = x; i <= y; i++) {
ans = min(ans, dp[m][i].first);
ans = min(ans, dp[m][i].second);
}
cout << ans;
}
int main() {
int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 100005;
constexpr int MAXK = 9;
struct EVENT {
long long x, type, id;
EVENT(int a = 0, int b = 0, int c = 0) : x(a), type(b), id(c){};
bool operator<(const EVENT& other) const {
return x < other.x || (x == other.x && type < other.type);
}
};
long long dp[1 << MAXK];
bool used[MAXK];
int n, m, k, id2cnt[MAXN];
pair<long long, long long> a[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k;
vector<EVENT> temp;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
temp.emplace_back(a[i].first, 1, i);
temp.emplace_back(a[i].second + 1, -1, i);
}
vector<int> gMask;
sort(temp.begin(), temp.end());
for (int i = 0; i < (1 << k); i++) {
dp[i] = LLONG_MIN;
int curMask = i;
int cnt = 0;
while (curMask > 0) {
cnt += curMask % 2;
curMask >>= 1;
}
if (cnt % 2) {
gMask.emplace_back(i);
}
}
dp[0] = 0;
int last = 0;
for (auto item : temp) {
for (auto val : gMask) {
if (dp[val] != LLONG_MIN) {
dp[val] += item.x - last;
}
}
last = item.x;
if (item.type > 0) {
int cur = 0;
while (cur < k && used[cur]) {
cur++;
}
used[cur] = true;
id2cnt[item.id] = cur;
for (int i = 0; i < (1 << k); ++i) {
if ((i & (1 << cur)) == 0) {
dp[i | (1 << cur)] = max(dp[i | (1 << cur)], dp[i]);
}
}
} else {
int cur = id2cnt[item.id];
used[cur] = false;
for (int i = (1 << k) - 1; i >= 0; --i) {
if (i & (1 << cur)) {
dp[i ^ (1 << cur)] = max(dp[i ^ (1 << cur)], dp[i]);
dp[i] = LLONG_MIN;
}
}
}
}
cout << dp[0] << endl;
return 0;
}
| 4 |
#include <iostream>
#include <cstring>
using namespace std;
bool isPrime[10001];
void setPrime( bool *p, int size )
{
memset(p, true, size);
p[0] = p[1] = false;
for(int i=2; i < size; ++i) {
if(!p[i]) continue;
for(int j=i+i; j < size; j+=i) {
p[j] = false;
}
}
}
int main( void )
{
setPrime(isPrime, 10001);
int n;
while(cin >> n, n) {
bool hit = true;
for(int i=n-2; i > 0 && hit; --i) {
if(isPrime[i]) {
if(isPrime[i+2]) {
cout << i << ' ' << i+2 << endl;
hit = false;
}
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
long long dp[MAXN][2];
int b[MAXN][2], a[MAXN];
int n;
long long dfs(int x, int op, int cur) {
if (x <= 0 || x > n) {
return 0;
}
if (dp[x][op] != 0) {
return dp[x][op];
}
if (b[x][op] == cur) {
return -1;
}
b[x][op] = cur;
int delta = op == 0 ? a[x] : -a[x];
long long ret = dfs(x + delta, 1 - op, cur);
if (ret == -1) {
return dp[x][op] = -1;
}
return dp[x][op] = ret + a[x];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", a + i);
}
for (int i = 1; i < n; ++i) {
a[1] = i;
dp[1][0] = 0;
long long ret = dfs(1, 0, i);
cout << ret << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000007;
const long long MAXN = 1000001;
bool prime[1000001];
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= 1000000; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 1000000; i += p) prime[i] = false;
}
}
}
long long bs(vector<long long> a, long long x, long long n) {
int l = 0;
int h = n - 1;
int m;
while (l <= h) {
m = (l + h) / 2;
if (a[m] >= x)
h = m - 1;
else if (a[m] < x)
l = m + 1;
}
if (a[m] >= x) m--;
return m;
}
long long power(long long x, long long y) {
long long res = 1;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long mex(vector<long long> a, int n) {
sort(a.begin(), a.end());
int j = a[0];
if (j != 0)
return 0;
else {
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
if (a[i] != a[i - 1] + 1) {
return j + 1;
} else
j++;
}
}
return j + 1;
}
}
int spf[MAXN];
void sieve() {
spf[1] = 1;
for (int i = 2; i < MAXN; i++) spf[i] = i;
for (int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (int i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (int j = i * i; j < MAXN; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long c(long long m, long long n) {
long long ans = 1;
for (int i = 1; i <= n; i++) {
ans = (ans * (m - i + 1)) / i;
}
return ans;
}
long long modInverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long pc(long long n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
long long lexo(string a, string b) {
long long n = a.length();
for (int i = 0; i < n; i++) {
if (a[i] < b[i])
return 1;
else if (b[i] < a[i])
return 0;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test;
cin >> test;
while (test--) {
long long n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long ans = 0;
long long p = -1;
if (n >= 2) {
while (a[n - 1] != 0) {
if (a[n - 1] != p - 1) {
p = a[n - 1];
a[n - 1]--;
ans++;
} else {
if (a[n - 2] == 0) {
break;
} else {
p = a[n - 2];
a[n - 2]--;
ans++;
}
}
sort(a.begin(), a.end());
}
if (ans % 2)
cout << "T"
<< "\n";
else
cout << "HL"
<< "\n";
} else {
if (a[0] > 0)
cout << "T"
<< "\n";
else
cout << "HL"
<< "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define M_MAX 20
#define N_MAX 50000
#define INFTY 1 << 29
int main(){
int n,m,c;
cin >> n>>m>>c;
int count=0;
int b[m];
for(int i=0;i<m;i++)cin >> b[i];
int a[m];
for(int j=0;j<n;j++){
int temp=c;
for(int i=0;i<m;i++){
cin >> a[i];
temp+=b[i]*a[i];
}
if(temp>0)count++;
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vb = vector<bool>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using vii = vector<ii>;
const ll MOD = 1000000007;
const int INF = 1000000000;
const double PI = 3.14159265358979323846;
ll n, d, b;
vi a, acc;
bool solve(int x) {
for (int i = x; i < (n + 1) / 2; ++i)
if (acc[min(i + (i + 1) * d + 1, n)] < (i - x + 1) * b) return false;
for (int i = x; i < n / 2; ++i)
if (n * b - acc[max(n - 1 - i - (i + 1) * d, 0ll)] < (i - x + 1) * b)
return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> d >> b;
a.resize(n);
for (int i = 0, _i = (n); i < _i; ++i) cin >> a[i];
acc.resize(n + 1);
acc[0] = 0;
partial_sum((a).begin(), (a).end(), acc.begin() + 1);
int p = n / 2 + 1, q = -1;
while (p - q > 1) {
int r = (p + q) / 2;
(solve(r) ? p : q) = r;
}
cout << p << endl;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int n,q,a,b,c;
int main(){
cin>>n;
vector<int>v(n);
for(int i=0;i<n;i++)cin>>v[i];
cin>>q;
while(q--){
cin>>a>>b;
reverse(v.begin()+a,v.begin()+b);
}
for(int i=0;i<n;i++){
if(i)cout<<' ';
cout<<v[i];
}
cout<<endl;
}
| 0 |
#include <bits/stdc++.h>
void __check(const char* expr, const char* file, unsigned int line) {
printf("%s:%u: failed check `%s'\n", file, line, expr);
abort();
}
using namespace std;
template <typename T>
bool uin(T& a, T b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T>
bool uax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
int sz(const T& t) {
return static_cast<int>(t.size());
}
template <typename T>
void shrink(std::vector<T>& v) {
std::vector<T>(v).swap(v);
}
const bool DBG = false;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v(1 + n);
for (int i = 0; i < (int)(n); ++i) {
cin >> v[i];
v[i]--;
}
v[n] = v[n - 1] ^ 1;
int prev = v[0];
array<int, 2> a;
a.fill(0);
a[prev]++;
int res = 0;
for (int i = 1; i <= n; ++i) {
int value = v[i];
if (value != prev) {
if (a[value] > 0) {
int opposite = value ^ 1;
auto local_res = min(a[opposite], a[value]) * 2;
res = max(local_res, res);
a[value] = 0;
}
}
a[value]++;
prev = value;
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, Mo = 1000000007;
long long a[N];
int fa[N], w[N], f[N];
inline int gi() {
int x = 0, o = 1;
char ch = getchar();
while (ch < '0' || ch > '9') ch == '-' ? o = -1 : 0, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return o * x;
}
inline long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
int main() {
int n, ans = 1;
cin >> n;
for (int i = 1; i <= n; i++) a[i] = gi();
for (int i = 2; i <= n; i++) fa[i] = gi();
for (int i = n; i > 1; i--) a[fa[i]] += a[i];
for (int i = 1; i <= n; i++) {
long long t = a[1] / gcd(a[1], a[i]);
if (t <= n) ++w[t];
}
for (int i = n; i; i--)
for (int j = i + i; j <= n; j += i) w[j] += w[i];
for (int i = n; i > 1; i--)
if (w[i] >= i) {
f[i] = 1;
for (int j = i + i; j <= n; j += i) f[i] = (f[i] + f[j]) % Mo;
ans = (ans + f[i]) % Mo;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p, dap = -2147483647, n, k, a[30010], s[30010], d[210][30010][4],
d2[210][30010][4], pos[30010], sum, c;
vector<int> ch[30010];
int main() {
int i, j, l;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s[i] = s[i - 1] + a[i];
}
for (i = 1; i <= k; i++) {
for (j = 1; j <= n; j++) {
d[i][j][1] = d[i][j][0] = d[i][j][2] = d[i][j][3] = d2[i][j][0] =
d2[i][j][1] = d2[i][j][2] = d2[i][j][3] = -1e9;
}
}
for (i = 1; i <= k; i++) {
for (j = i; j <= n; j++) {
if (i == 1 || i == k)
c = 1;
else
c = 2;
d[i][j][1] = max(d[i][j][1], d[i][j - 1][1] + c * a[j]);
d[i][j][0] = max(d[i][j][0], d[i][j - 1][0] - c * a[j]);
d[i][j][1] = max(d[i][j][1], d[i - 1][j - 1][0] + c * a[j]);
d[i][j][0] = max(d[i][j][0], d[i - 1][j - 1][1] - c * a[j]);
d[i][j][1] = max(d[i][j][1], d[i - 1][j - 1][3] + c * a[j]);
d[i][j][0] = max(d[i][j][0], d[i - 1][j - 1][2] - c * a[j]);
if (i != 1 && i != k)
d[i][j][2] =
max(d[i][j][2], max(d[i - 1][j - 1][2], d[i - 1][j - 1][1]));
if (i != 1 && i != k)
d[i][j][3] =
max(d[i][j][3], max(d[i - 1][j - 1][3], d[i - 1][j - 1][0]));
if (i != 1 && i != k)
d[i][j][2] = max(d[i][j][2], max(d[i][j - 1][2], d[i][j - 1][1]));
if (i != 1 && i != k)
d[i][j][3] = max(d[i][j][3], max(d[i][j - 1][3], d[i][j - 1][0]));
if (i == k) {
dap = max(dap, d[i][j][1]);
dap = max(dap, d[i][j][0]);
dap = max(dap, d[i][j][2]);
dap = max(dap, d[i][j][3]);
}
}
}
printf("%d", dap);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void __read(T &a) {
cin >> a;
}
template <typename T, typename... Args>
void __read(T &a, Args &...args) {
cin >> a;
__read(args...);
}
constexpr long long M7 = 1000000007;
constexpr long long M9 = 1000000009ll;
constexpr long long MFFT = 998244353ll;
constexpr long long E6 = 1000000ll;
constexpr long long E9 = 1000000000ll;
constexpr long long INF = 2000000000000000000ll;
template <class T>
void outv(T &a) {
for (auto &x : a) cout << x << ' ';
}
long long find_l(vector<long long> &a, long long x) {
long long l = -1;
long long r = a.size();
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (a[mid] > x)
r = mid;
else
l = mid;
}
return l;
}
void solve() {
long long n, m;
__read(n, m);
vector<long long> a(n);
for (auto &v : a) cin >> v;
long long mid = n / 2;
vector<long long> first(1 << mid);
vector<long long> second(1 << (n - mid));
for (long long i = 0; i < 1 << mid; ++i) {
long long sum = 0;
for (long long j = 0; j < mid; ++j) {
if (i & (1 << j)) {
sum = (sum + a[j]) % m;
}
}
first[i] = sum;
}
for (long long i = 0; i < 1 << (n - mid); ++i) {
long long sum = 0;
for (long long j = 0; j < (n - mid); ++j) {
if (i & (1 << j)) {
sum = (sum + a[mid + j]) % m;
}
}
second[i] = sum;
}
sort((second).begin(), (second).end());
long long res = 0;
for (auto el : second) {
res = max(res, el);
}
for (auto el : first) {
long long l = find_l(second, m - el - 1);
if (l == second.size()) continue;
res = max(res, (el + second[l]) % m);
res = max(res, el);
}
cout << res << '\n';
}
signed main(signed argc, char **argv) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
if (argc > 1 && (string)argv[1] == "local") {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
long long i = 1;
clock_t start_time, end_time;
cout << "/////Test #" << i << "/////\n";
start_time = clock();
solve();
end_time = clock();
long double seconds_pass =
(long double)(end_time - start_time) / CLOCKS_PER_SEC;
cout << "\n//Time: ";
cout << setprecision(15) << seconds_pass << '\n';
while (cin.peek() != -1) {
++i;
cout << '\n';
cout << '\n';
cout << "/////Test #" << i << "/////\n";
start_time = clock();
solve();
end_time = clock();
seconds_pass = (long double)(end_time - start_time) / CLOCKS_PER_SEC;
cout << "\n//Time: ";
cout << setprecision(15) << seconds_pass << '\n';
}
} else {
solve();
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int64_t n;
cin>>n;
int64_t m;
for(int64_t i=1;i*i<=n;i++)
if(n%i==0)
m=i+n/i-2;
cout<<m<<endl;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.