結果

問題 No.1329 Square Sqsq
ユーザー 8UqsVg4r
提出日時 2021-01-08 21:22:54
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 3 ms / 2,000 ms
コード長 7,918 bytes
コンパイル時間 2,284 ms
コンパイル使用メモリ 175,876 KB
実行使用メモリ 6,820 KB
最終ジャッジ日時 2024-11-16 09:53:43
合計ジャッジ時間 2,494 ms
ジャッジサーバーID
(参考情報)
judge1 / judge5
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 24
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

/////////////////////////////////////////////////
///// Give me AC!!!! /////
/////////////////////////////////////////////////
//↑
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///// ACACJudge.... /////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i,N) for(int i = 0; i < (N); i++)
#define erep(i,N) for(int i = N - 1; i >= 0; i--)
const ll MOD = 1e9+7;
const ll INF = numeric_limits<ll>::max();
const int MAX = 500000;
const ld PI = (acos(-1));
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true;} return false;}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true;} return false;}
ld rad(ld a) {return a * 180 / PI;}
const int dx[8] = {1, 0, -1, 0, -1, 1, -1, 1};//2x
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};//2y
//using P = pair<int,int>;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool same(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) {
return -par[root(x)];
}
};
template <typename T> struct BIT {
private:
vector<T> array;
const int n;
public:
BIT(int _n) : array(_n + 1, 0), n(_n) {}
T sum(int i) {
T s = 0;
while (i > 0) {
s += array[i];
i -= i & -i;
}
return s;
}
T sum(int i,int j) {
T ret_i = sum(i - 1);
T ret_j = sum(j);
return ret_j - ret_i;
}
void add(int i,T x) {
while (i <= n) {
array[i] += x;
i += i & -i;
}
}
};
map<ll,ll> factorize_list;
void factorize(ll k) {
while(1){
bool p = true;
for (ll i = 2; i * i <= k; i++){
if (k % i == 0){
factorize_list[i]++;
k /= i;
p = false;
break;
}
}
if(p) {
factorize_list[k]++;
break;
}
}
return ;
}
ll mod(ll val) {
ll res = val % MOD;
if (res < 0) res += MOD;
return res;
}
char upper(char c){
if('a' <= c && c <= 'z'){
c = c - ('a' - 'A');
}
return c;
}
char lower(char c){
if('A' <= c && c <= 'Z'){
c = c + ('a' - 'A');
}
return c;
}
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
//
ll COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll Expo(ll N,ll K) {
N %= MOD;
if (K == 0) {
return 1;
}
ll Kc = K,rui = N,ans = 1;
while(Kc) {
if (Kc % 2) {
ans *= rui;
ans %= MOD;
}
rui *= rui;
rui %= MOD;
Kc /= 2;
}
return ans;
}
int dp[100050];
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a%b, y, x); //
y -= a / b * x;
return d;
}
// mod (a = -11 OK)
inline ll mod(ll a, ll m) {
return (a % m + m) % m;
}
// ( a m )
ll modinv(ll a, ll m) {
ll x, y;
extGCD(a, m, x, y);
return mod(x, m); // x % m x
}
int op(int a,int b) {
return a ^ b;
}
int e() {
return (int)0;
}
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
segtree() : segtree(0) {}
segtree(int n) : segtree(vector<S>(n, e())) {}
segtree(const vector<S>& v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = vector<S>(2 * size, e());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n) return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0) return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
struct edge {
int to;
ll cost;
};
template<class T> T sqroot(T Ex) {
T l = 0,r = min(Ex,(T)(1e9)),unit = 1e-10;//unit:long long1,long double
if (0.1 != (T)(0.1)) unit = 1;
while (r - l > unit) {
T val = (l + r) / 2;
if (val * val > Ex) r = val;
else l = val;
}
return l;//ExT
}
template<class T> using Graph = vector<vector<T>>;
#define Sugsugar cin.tie(0);ios::sync_with_stdio(false)
signed main() {
Sugsugar;
string S;
cin >> S;
cout << (S.size() + 1) / 2 << endl;
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0