text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
void solve() {
int res = 0, ans = 0;
for (int i = 0; i < n; i++)
if (s[i] == '1') res++;
for (int i = n - 1; i >= 0; i--)
if (s[i] == '1') {
int j = i;
while (j >= 0 && s[j] == '1') j--;
if (i - j > 1) {
for (int x = i - 1; x > j && i - j > 1; x--) s[x] = '0';
if (j >= 0)
s[j] = '1';
else
ans++;
}
i = j + 1;
}
for (int i = 0; i < n; i++)
if (s[i] == '1') ans++;
cout << min(res, ans) << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
n = s.size();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const double EPS = 1e-5;
const long long INF64 = (long long)1e18;
int n, m = 0, ans, nxt;
string s, res;
bool f, g;
int main() {
cin >> s;
f = 1;
g = 1;
for (int i = 0; i < s.length(); i++) {
m += (s[i] == '1');
if (s[i] == '0') f = 0;
if (i > 0 && s[i] == '1') g = 0;
}
if (g) {
cout << 1;
return 0;
}
if (f) {
cout << 2;
return 0;
}
ans = m;
ans = min(ans, (int)s.length() - m + 2);
m = 0;
for (int i = 2; i < s.length() - 1; i++) {
if (s[i - 1] == '1' && s[i + 1] == '1' && s[i] == '0') s[i] = '1', m++;
if (s[i - 1] == '0' && s[i + 1] == '0' && s[i] == '1') s[i] = '0', m++;
}
if (s.length() > 1 && s[s.length() - 1] == '1' && s[s.length() - 2] == '0')
m++, s[s.length() - 1] = '0';
for (int i = s.length() - 1; i >= 0; i--) {
if (i == s.length() - 1) {
if (s[i] == '1') m += 2;
} else {
if (s[i] == '1' && s[i + 1] == '0') m += 2;
}
}
if (s[0] != s[1]) m--;
ans = min(ans, m);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int n, p[1000010];
int main() {
scanf("%s", s), n = strlen(s);
for (int i = 0; i < n; i++)
if (s[i] == '1') p[n - 1 - i] = 1;
for (int i = 0, j; i < n + 2;)
if (!p[i])
i++;
else {
j = i;
while (p[j]) j++;
if (j - i >= 2) {
p[i] = -1;
for (int k = i + 1; k < j; k++) p[k] = 0;
p[j] = 1;
}
i = j;
}
int S = 0;
for (int i = 0; i < n + 2; i++)
if (p[i] != 0) S++;
printf("%d\n", S);
}
|
#include <bits/stdc++.h>
using namespace std;
int fw[1000006];
int rev[1000006];
int main() {
int n;
string s;
cin >> s;
n = s.size();
if (s[n - 1] == '0') {
fw[n - 1] = 0;
rev[n - 1] = 2;
} else {
fw[n - 1] = 1;
rev[n - 1] = 1;
}
for (int i = n - 2; i >= 0; i--) {
if (s[i] == '0') {
fw[i] = min(fw[i + 1], rev[i + 1] + 1);
rev[i] = min(rev[i + 1] + 1, fw[i + 1] + 2);
} else {
fw[i] = fw[i + 1] + 1;
rev[i] = min(rev[i + 1], fw[i + 1] + 1);
}
}
cout << min(rev[0] + 1, fw[0]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bNull[1000003];
int bOne[1000003];
char s[1000003];
int dOne[1000003];
int dNull[1000003];
int main() {
scanf("%s", s);
int i;
int len;
for (len = 0; s[len]; len++)
;
for (i = len; i > 0; i--) s[i] = s[i - 1];
s[0] = '0';
bNull[0] = 0;
bOne[0] = 0;
for (i = 1; s[i]; i++)
if (s[i] == '1') {
bOne[i] = i;
bNull[i] = bNull[i - 1];
} else {
bNull[i] = i;
bOne[i] = bOne[i - 1];
}
dOne[0] = 1;
dNull[0] = 0;
int real;
for (i = 1; s[i]; i++) {
if (s[i - 1] == '0')
real = dNull[i - 1];
else
real = dOne[i - 1];
dOne[i] = min(real + 1, dOne[bNull[i - 1]] + 1);
dNull[i] = real;
}
if (s[i - 1] == '0')
printf("%d\n", dNull[i - 1]);
else
printf("%d\n", dOne[i - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char st[1000009];
int main() {
scanf("%s", st);
int l = strlen(st);
int ans = 0;
for (int i = l - 1; i >= 0; i--)
if (st[i] == '1') {
ans++;
st[i] = '0';
if (i) {
int j = i - 1;
bool flag = false;
while (j >= 0 && st[j] == '1') {
flag = true;
st[j] = '0';
j--;
}
if (j == -1) {
ans++;
break;
} else if (flag)
st[j] = '1';
i = j + 1;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
char c[1000006];
int a[1000006];
int b[1000006][2];
int la, n1, n;
void input() {
int i, k = 0;
scanf("%s", &c[1]);
n1 = strlen(&c[1]);
for (i = n1; i >= 1; i--) a[i] = c[n1 - i + 1] - '0';
if (a[1] == 0)
b[1][0] = 0, b[1][1] = 1;
else
b[1][0] = b[1][1] = 1;
for (i = 2; i <= n1; i++) {
if (a[i] == 0) {
b[i][0] = b[i - 1][0];
if (b[i][0] > b[i - 1][1] + 1) b[i][0] = b[i - 1][1] + 1;
b[i][1] = b[i - 1][1] + 1;
} else {
b[i][0] = b[i - 1][0] + 1;
b[i][1] = b[i - 1][1];
if (b[i][1] > b[i - 1][0] + 1) b[i][1] = b[i - 1][0] + 1;
}
}
la = b[n1][0];
if (b[n1][1] + 1 < la) la = b[n1][1] + 1;
}
void process() {}
void output() { printf("%d", la); }
int main() {
input();
process();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000, Maxm = 200000, oo = INT_MAX >> 2;
int p, q, n, t, i, x, y, ans, sum0, sum1;
string s, ch("1001");
void work(int l, int r) {
sum0 = sum1 = 0;
for (i = l; i < r; i++) {
int p = 1;
if (s[i] == '1') {
sum1++;
while (i < r - 1 && s[i + 1] == s[i]) i++, sum1++;
} else if (s[i] == '0') {
while (i < r - 1 && s[i + 1] == s[i]) i++, p++;
if (i == r - 1) break;
if (p > 2)
ans += min(2 + sum0, sum1), sum0 = sum1 = 0;
else
sum0 += p;
}
}
if (l < r) ans += min(2 + sum0, sum1);
}
int find(int l) {
int ans = -1;
int p = s.size() - 4;
for (int i = l; i <= p; i++) {
int can = 1;
for (int j = 0; j < 4; j++)
if (i + j >= s.size() || s[i + j] != ch[j]) can = 0;
if (can) return i;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> s;
int l = 0, r;
while (r = find(l) + 1) {
work(l, r);
l = r + 2;
}
work(l, s.size());
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int main() {
scanf("%s", s);
int n = strlen(s);
s[++n - 1] = '0';
bool fl = false;
int t = 0, ans = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '1')
++t;
else {
if (t == 0) continue;
if (t == 1 && !fl) {
++ans;
t = fl = 0;
continue;
}
ans += 2 - fl;
t = 0;
fl = (i + 1 < n && s[i + 1] == '1');
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int min(const int &a, const int &b) { return a > b ? b : a; }
int main() {
string str;
cin >> str;
int a = 0, b = 1;
for (int i = 0; i < str.size(); ++i) {
if (str[i] == '1')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
}
b = min(a, b) + 1;
printf("%d\n", min(a, b));
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1000006][2] = {};
int main() {
string str;
cin >> str;
dp[0][1] = 1;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '1') {
dp[i + 1][1] = dp[i][1];
dp[i + 1][0] = min(dp[i][1] + 1, dp[i][0] + 1);
} else {
dp[i + 1][0] = min(dp[i][0], dp[i][1] + 1);
dp[i + 1][1] = min(dp[i][0] + 1, dp[i][1] + 1);
}
}
int n = str.size();
int ans = min(dp[n][0], dp[n][1] + 1);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double EPS = 1e-7;
int INF = 1000000000;
int MAXINT = 2147483647;
long long INFLL = 1000000000000000000LL;
long long MAXLL = 9223372036854775807LL;
pair<int, int> M[8] = {make_pair(0, 1), make_pair(1, 0), make_pair(-1, 0),
make_pair(0, -1), make_pair(-1, 1), make_pair(-1, -1),
make_pair(1, -1), make_pair(1, 1)};
char s[1000100];
char t[1000100];
int main() {
gets(s + 5);
s[0] = '0';
s[1] = '0';
s[2] = '0';
s[3] = '0';
s[4] = '0';
int len = strlen(s);
for (int(a) = (0); (a) <= (len - 1); (a)++) t[a] = '0';
int sav = 0;
for (int(a) = (len - 1); (a) >= (0); (a)--) {
int x = s[a] - '0';
int y = sav + 3 * x;
sav = y / 2;
t[a] = y % 2 + '0';
}
int res = 0;
for (int(a) = (0); (a) <= (len - 1); (a)++) {
if ((t[a] - '0') ^ (s[a] - '0')) res++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-11;
char s[1001000];
int ans, l;
char z = '0', nz = '1';
int main() {
cin >> s;
l = strlen(s);
s[l] = z;
for (int i = 0; i < l;) {
if ((i == l - 1) || (s[i + 1] == z)) {
s[i] = z;
while (s[i] == z && i < l) i++;
} else {
swap(z, nz);
for (int j = l - 1;; j--) {
if (s[j] == z) {
s[j] = nz;
break;
} else
s[j] = z;
}
while (s[i] == z && i < l) i++;
}
ans++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int sum = 0;
if (s.size() == 1) return cout << 1, 0;
reverse(s.begin(), s.end());
for (int i = 0; i <= s.size() - 2;) {
if (s[i] == '1') {
if (s[i + 1] == '0')
sum++, i++;
else {
int l = i;
while ((s[l] == '1') && (l < s.size() - 1)) {
l++;
}
i = l;
s[i] = '1';
sum++;
}
} else
i++;
}
sum++;
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
const int N = 1000005;
char s[N];
int dp[N][2];
int one_cnts[N];
int main() {
while (cin >> (s + 1)) {
int len = strlen(s + 1);
dp[0][0] = 0;
dp[0][1] = 2;
for (int i = 1; i <= len; ++i) {
if (s[i] == '0') {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 2);
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0] + 1, dp[i - 1][1]);
dp[i][1] = min(dp[i - 1][1], dp[i - 1][0] + 2);
}
}
cout << dp[len][0] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000001];
int main() {
int a = 0, b = 1;
scanf("%s", s);
for (int i = 0; s[i]; i++) {
if (s[i] == '1')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
}
b = min(a, b) + 1;
printf("%d\n", min(a, b));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[2][1000111];
string s;
int main() {
ios ::sync_with_stdio(false);
while (cin >> s) {
int n = s.length();
for (int i = 0, _a = (n); i < _a; i++) {
if (i == 0) {
if (s[i] == '0') {
f[0][i] = 0;
f[1][i] = 0;
} else {
f[0][i] = 1;
f[1][i] = 1;
}
} else {
if (s[i] == '0') {
f[0][i] = min(f[0][i - 1], f[1][i - 1] + 1);
f[1][i] = min(f[0][i - 1] + 2, f[1][i - 1] + 1);
} else {
f[0][i] = min(f[0][i - 1] + 1, f[1][i - 1] + 2);
f[1][i] = min(f[0][i - 1] + 1, f[1][i - 1]);
}
}
}
cout << min(f[0][n - 1], f[1][n - 1] + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
char s[maxn];
int dp[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s + 1;
int len = strlen(s + 1);
int ans = 0;
int temp = 0;
s[0] = '0';
for (int i = len; i >= 0; i--) {
if (s[i] == '0') {
if (temp != 0) {
if (i == 0) {
ans++;
continue;
}
s[i] = '1';
temp = 0;
i++;
}
} else {
if (temp == 0) {
if (s[i - 1] == '1')
temp = 1, ans++;
else
temp = 0, ans++;
}
}
}
if (s[0] == '1') ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
char S[1000002];
int main() {
scanf("%s", S);
N = strlen(S);
int z = 1, o = 0;
for (int i = 0; i < N; i++) {
if (S[i] == '0') {
z = min(z, o) + 1;
} else {
o = min(z, o) + 1;
}
}
printf("%d\n", o);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-12;
const int INF = (1 << 30) - 1;
const long long LLINF = ((long long)1 << 62) - 1;
int n, m, a[100010], sum[100010];
int Sum(int l, int r) { return l == 0 ? sum[r] : sum[r] - sum[l - 1]; }
int main() {
string s;
cin >> s;
int res = 1;
int ch = 0;
for (int i = 1; i < s.length(); ++i) {
if (s[i] == '0') {
while (i < s.length() && s[i] == '0') ++i;
if (i != s.length()) ++res;
if (i < 0) break;
} else if (s[i] == '1') {
while (i < s.length() && s[i] == '1') ++i;
++res;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1000005];
int main() {
int a, b, len;
str[0] = '0';
while (cin >> (str + 1)) {
len = strlen(str);
if (len == 2) {
cout << 1 << endl;
continue;
}
int power = 1, prev = 0;
vector<int> lul;
for (int i = len - 2; i >= 0; i--) {
if (str[i] == '0' && str[i + 1] == '1') {
lul.push_back(prev);
lul.push_back(power);
} else if (str[i] == '1' && str[i + 1] == '0') {
prev = power;
}
power++;
}
len = lul.size();
int cnt = 1;
for (int i = 1; i < len; i++) {
if (lul[i] - lul[i - 1] != 1)
cnt++;
else
lul[i] = lul[i - 1];
}
cout << cnt << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
char str[MAX];
int main() {
int a = 0, b = 0, ans;
scanf("%s", str);
int n = strlen(str);
ans = 0;
for (int i = 0; i < n; i++)
if (str[i] == '1') ans++;
if (n == 1 && str[0] == '0')
printf("2\n");
else if (n == 1 && str[0] != '0')
printf("1\n");
else {
for (int i = 0; i < n; i++) {
if (str[i] == '1')
a++;
else {
if (a >= 2)
ans -= (a - 2), a = 1;
else
a = 0;
}
}
if (a >= 2) ans -= (a - 2);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
char str[N];
int dp[N][2];
int main() {
scanf("%s", str);
int len = (int)strlen(str);
if (str[len - 1] == '0') {
dp[len - 1][0] = 0;
dp[len - 1][1] = 1;
} else {
dp[len - 1][0] = 1;
dp[len - 1][1] = 1;
}
for (int i = len - 2; i >= 0; i--) {
if (str[i] == '0') {
dp[i][0] = min(dp[i + 1][0], dp[i + 1][1] + 1);
dp[i][1] = min(dp[i + 1][0] + 2, dp[i + 1][1] + 1);
} else {
dp[i][0] = min(dp[i + 1][0] + 1, dp[i + 1][1] + 2);
dp[i][1] = min(dp[i + 1][0] + 1, dp[i + 1][1]);
}
}
printf("%d\n", min(dp[0][0], dp[0][1] + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char gsz[1000010];
int val[1000110];
int main() {
cin >> gsz + 1;
int i, pos = 0, len = strlen(gsz + 1);
int cnt = 0, ans = 0;
pos = len;
while (pos) {
cnt = 0;
while (gsz[pos] == '0' && pos) pos--;
while (gsz[pos] == '1' && pos) pos--, cnt++;
ans++;
if (pos == 0 && cnt > 1) {
ans++;
break;
}
if (1 != cnt) {
gsz[pos] = '1';
}
}
ans = max(1, ans);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int main() {
int i, n, tots = 0, mx = 0, ans = 0, totone;
gets(s);
n = strlen(s);
for ((i) = 0; (i) < (n); (i)++) {
totone = 0;
tots++;
while (i < n && s[i] == '1') {
i++;
totone++;
}
mx = max(totone, mx);
if (i == n || (i == n - 1 && s[i] == '0') ||
(s[i] == '0' && s[i + 1] == '0')) {
if (mx == 1)
ans += tots;
else
ans += tots + 1;
tots = 0;
mx = 0;
while (s[i] == '0') i++;
i--;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int ssz = s.size();
int res = 1, run = 1;
for (int i = 1; i < ssz; i++) {
if (s[i] == '1') {
run++;
if (run <= 2) res++;
} else if (i + 1 < ssz && s[i + 1] == '1' && run > 1) {
res++;
} else {
run = 0;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
char Gc() {
static char now[1 << 20], *S, *T;
if (T == S) {
T = (S = now) + std::fread(now, 1, 1 << 20, stdin);
if (T == S) return EOF;
}
return *S++;
}
template <typename T>
void Read(T &x) {
x = 0;
int f = 1;
char c;
while ((c = Gc()) < '0' || c > '9')
if (c == '-') f = -1;
x = c - '0';
while ((c = Gc()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= f;
}
template <typename T, typename... Args>
void Read(T &x, Args &...args) {
Read(x);
Read(args...);
}
template <typename T>
void checkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void checkmin(T &x, T y) {
if (x > y) x = y;
}
char s[1000001];
std::size_t n;
int main(int argc, char const *argv[]) {
std::scanf("%s", s);
n = std::strlen(s);
int ans = 0, cnt = 0;
for (std::size_t i = 0; i < n; i++)
if (s[i] == '1') {
cnt = 0;
while (i < n && s[i] == '1') {
i++;
cnt++;
}
if (cnt == 1) {
ans++;
} else {
ans += 2;
while (true) {
cnt = 0;
while (i < n && s[i] == '0') {
i++;
cnt++;
}
if (i >= n) break;
if (cnt == 1) {
while (i < n && s[i] == '1') i++;
ans++;
} else if (cnt == 2) {
cnt = 0;
while (i < n && s[i] == '1') {
i++;
cnt++;
}
if (cnt == 1) {
ans++;
break;
} else {
ans += 2;
}
} else {
i--;
break;
}
}
}
}
std::printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
long long add(long long a, long long b) {
long long ret = a + b;
if (ret >= 1000000007) ret -= 1000000007;
return ret;
}
long long subtract(long long a, long long b) {
long long ret = a - b;
if (ret < 0) ret += 1000000007;
return ret;
}
long long mult(long long a, long long b) {
long long ret = a * b;
if (ret >= 1000000007) ret %= 1000000007;
return ret;
}
long long bigmod(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = mult(ret, a);
b >>= 1;
a = mult(a, a);
}
return ret;
}
long long inverse(long long n) { return bigmod(n, 1000000007 - 2); }
bool base[1000010];
vector<int> primes;
void sieve(int mx) {
mx += 10;
int x = sqrt(mx);
for (int i = 3; i <= x; i += 2)
if (base[i] == 0)
for (int j = i * i, k = i << 1; j < mx; j += k) base[j] = 1;
primes.push_back(2);
for (int i = 3; i < mx; i += 2)
if (base[i] == 0) primes.push_back(i);
}
bool checkBit(int n, int i) { return (n & (1 << i)); }
int setBit(int n, int i) { return (n | (1 << i)); }
int resetBit(int n, int i) { return (n & (~(1 << i))); }
char a[1000010];
int main() {
scanf("%s", a);
int n = strlen(a);
int last = -1;
for (int i = n - 1; i >= 0; --i)
if (a[i] == '1') {
last = i;
break;
}
int pos = 0, ans = 1, flag = 0;
while (pos < last) {
int j = pos, cnt = 0;
while (j < last && a[j] == a[pos]) ++j, ++cnt;
if (flag == 0 && a[pos] == '0') {
pos = j;
continue;
}
if (flag == 1 && a[pos] == '1') {
pos = j;
continue;
}
if (cnt == 1)
++ans;
else {
if (a[pos] == '1' && flag == 0)
++ans;
else if (a[pos] == '0' && flag == 1)
++ans;
flag ^= 1;
}
pos = j;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s = "00" + s;
int l = s.length();
int count = 0;
for (int i = l - 1; i >= 0; i--) {
if (s[i] == '1') {
if (s[i - 1] == '1') {
while (s[i] == '1') {
s[i] = '0';
i--;
}
s[i] = '1';
i++;
count++;
} else
count++;
}
}
cout << count << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1000500];
int pref[1000500];
vector<pair<int, int> > v;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
size_t n = s.length();
int l = -1, r = -1;
for (size_t i = 0; i < n; i++) {
if (s[i] == '1') {
if (l == -1)
l = i, r = i;
else
r++;
} else {
if (l != -1) {
v.push_back({l, r});
l = r = -1;
}
}
}
if (l != -1) {
v.push_back({l, r});
l = r = -1;
}
for (int i = 1; i <= n; i++) dp[i] = 1e9;
dp[1] = min(2, v[0].second - v[0].first + 1);
for (size_t i = 0; i < n; i++) {
if (s[i] == '0')
pref[i + 1] = pref[i] + 1;
else
pref[i + 1] = pref[i];
}
int mindp;
if (v.size() > 1) mindp = pref[v[1].first];
for (int i = 2; i <= v.size(); i++) {
int s0 = v[i - 1].first - v[i - 2].second - 1;
int dp1 = min(2, v[i - 1].second - v[i - 1].first + 1) + dp[i - 1];
int dp2 = 2 + mindp;
dp[i] = min(dp1, dp2);
if (i < v.size()) {
int add0 = pref[v[i].first] - pref[v[i - 1].second];
mindp = min(mindp + add0, dp[i - 1] + add0);
}
}
cout << dp[v.size()];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char buf[1000010];
*buf = '0';
cin.getline(buf + 1, 1000009);
int len = strlen(buf + 1);
int left_one[len + 1];
int left_zero[len + 1];
int dp_one[len + 1];
int dp_zero[len + 1];
int ans[len + 1];
left_zero[1] = 0;
left_one[1] = 0;
int cur_last_one = 1;
int cur_last_zero = 0;
for (int i = 2; i <= len; ++i) {
left_one[i] = cur_last_one;
left_zero[i] = cur_last_zero;
if (buf[i] == '1')
cur_last_one = i;
else
cur_last_zero = i;
}
dp_one[0] = 1;
dp_zero[0] = -1;
ans[0] = 0;
for (int i = 1; i <= len; ++i) {
dp_one[i] = min(ans[i - 1] + 1, dp_one[left_zero[i]] + 1);
dp_zero[i] = min(ans[i - 1], dp_zero[left_one[i]] + 1);
if (buf[i] == '1')
ans[i] = dp_one[i];
else
ans[i] = dp_zero[i];
}
cout << ans[len] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100;
int dp[N][2], n, a[N];
string s;
int f(int idx, bool goingOn) {
if (idx == n) {
return 0;
}
if (dp[idx][goingOn] != -1) {
return dp[idx][goingOn];
}
int ans = 100000000;
if (goingOn) {
if (a[idx] == 1) {
ans = min(ans, f(idx + 1, 1));
} else {
ans = min(ans, f(idx + 1, 1) + 1);
ans = min(ans, f(idx + 1, 0));
}
} else {
if (a[idx] == 1) {
ans = min(ans, f(idx + 1, 1) + 2);
ans = min(ans, f(idx + 1, 0) + 1);
} else {
ans = min(ans, f(idx + 1, 0));
}
}
return dp[idx][goingOn] = ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
a[i] = (s[i] == '1');
}
memset(dp, -1, sizeof dp);
cout << f(0, 0) << "\n";
}
|
#include <bits/stdc++.h>
char arr[1000005];
int main() {
arr[0] = arr[1] = '0';
scanf("%s", arr + 2);
int len = strlen(arr), ans = 0;
for (int i = len - 1; i >= 0; --i)
if (arr[i] == '1') ++ans;
for (int i = len - 1; i > 0;) {
if (arr[i] == '1' && arr[i] == arr[i - 1]) {
arr[i] = '2';
while (arr[i - 1] == '1') --i, arr[i] = '0', --ans;
arr[i - 1] = '1', ++ans;
} else if (arr[i] == '2' && arr[i] == arr[i - 1]) {
arr[i] = '1';
while (arr[i - 1] == '2') --i, arr[i] = '0', --ans;
arr[i - 1] = '2', ++ans;
} else
--i;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000000 + 10];
int n;
int dp[1000000 + 10][2];
const int inf = 100000000;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n + 2; i++)
for (int j = 0; j < 2; j++) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j < 2; j++)
if (dp[i][j] != inf) {
const int ss = s[i] == '1' ? 1 : 0;
if (ss == j) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
} else {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][j] + 1);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][j] + 1);
}
}
const int ans = dp[n + 1][0];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
static char s[1000005];
static int n;
int main(void) {
gets(s);
n = strlen(s);
int ret = 0;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '0') continue;
ret++;
if (i == 0) continue;
if (s[i - 1] == '0') continue;
while (--i >= 0 && s[i] == '1')
;
if (i >= 0)
s[i++] = 1;
else
ret++;
}
printf("%d", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int main() {
while (scanf("%s", s) != EOF) {
int len = strlen(s);
len--;
int n = 100000000, m, ii, i = 0, nn;
while (len >= 0) {
if (s[len] == '1')
m = 1;
else
m = 0;
ii = min(m + i, m + n);
nn = min(2 - m + 1 + i, 2 - m - 1 + n);
i = ii;
n = nn;
len--;
}
printf("%d\n", min(i, n));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n;
char str[N];
int dp[N][2];
int solve(int i, bool isFliped) {
if (i == n) return isFliped ? 1e9 : 0;
int &ret = dp[i][isFliped];
if (ret != -1) return ret;
if (str[i] == '1') {
if (isFliped)
ret = min(solve(i + 1, true), solve(i + 1, false) + 1);
else
ret = 1 + min(solve(i + 1, false), solve(i + 1, true));
} else {
if (isFliped)
ret = 1 + min(solve(i + 1, true), solve(i + 1, false));
else
ret = min(solve(i + 1, false), solve(i + 1, true) + 1);
}
return ret;
}
int main() {
scanf("%s", str);
n = int(strlen(str));
memset(dp, -1, sizeof dp);
printf("%d", min(solve(0, 0), 1 + solve(0, 1)));
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000009];
int main() {
s[0] = '0';
while (cin >> s + 1) {
int n = strlen(s) - 1, ans = 0;
int p = n;
while (p > 0) {
if (s[p] == '0')
p--;
else {
int one = 0;
while (p >= 0) {
if (s[p] == '1')
p--, one++;
else {
if (one == 1) {
ans++;
break;
} else {
if (s[p + 1] == '0') {
ans++;
break;
} else {
ans++;
p--;
one++;
}
}
}
if (p < 0) {
ans++;
break;
}
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int dp[1000010][2];
int main() {
scanf("%s", s);
int n = strlen(s);
dp[n][0] = 0;
dp[n][1] = 2;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '1') {
dp[i][0] = min(dp[i + 1][0] + 1, dp[i + 1][1]);
dp[i][1] = min(dp[i + 1][0] + 2, dp[i + 1][1]);
} else {
dp[i][0] = min(dp[i + 1][0], dp[i + 1][1]);
dp[i][1] = min(dp[i + 1][0] + 2, dp[i + 1][1] + 1);
}
}
printf("%d\n", min(dp[0][0], dp[0][1] + 2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 0, n = s.length(), j;
for (int i = 0; i < n;) {
if (s[i] == '1') {
j = i + 1;
while (j < n && s[j] == '1') {
j++;
}
if (j - i > 1)
ans += 2;
else
ans++;
if (j + 1 < n && s[j + 1] == '1' && j - i > 1) {
s[j] = '1';
ans--;
}
i = j;
} else
i++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char c = 0;
int n = 0, m = 1, l = 0;
while (1) {
c = cin.get();
if (c == -1) break;
l = ((n < m) ? (n) : (m)) + 1;
if (c == '1')
n = l;
else
m = l;
}
cout << n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch;
int main() {
int x = 0, y = 1;
while ((ch = getchar()) != '\n') {
int p = min(x, y) + 1;
if (ch == '1')
x = p;
else
y = p;
}
cout << x << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000100];
bool mk[1000100];
bool tem[1000100];
int mai[1000100];
int rp[1000100];
int ta[1000100];
int f(int a) {
if (a == rp[a]) return a;
return rp[a] = f(rp[a]);
}
void setmai(int ind, int tam) {
int si = f(ind);
mai[si] = max(mai[si], tam);
}
void une(int a, int b, int s) {
int sa = f(a), sb = f(b);
if (sa < sb) swap(sa, sb);
rp[sa] = sb;
if (sa != sb && s) {
ta[sb] += ta[sa];
mai[sb] = max(mai[sb], mai[sa]);
}
}
int main() {
while (scanf("%s", s) == 1) {
memset(mk, false, sizeof mk);
int tam = strlen(s);
for (int i = 0; i < tam; ++i) rp[i] = i, ta[i] = 1, mai[i] = 1;
int rsp = 0;
for (int i = 0; i < tam; ++i) {
int pnt = i;
int nu = 0;
while (pnt < tam && s[pnt] == '1') {
une(i, pnt, 0);
pnt++, nu++;
}
setmai(pnt - 1, nu);
int nz = 0;
while (pnt < tam && s[pnt] == '0') pnt++;
i = pnt - 1;
}
for (int i = 0; i < tam; ++i) {
if (s[i] == '0' && s[i - 1] == '1' && s[i + 1] == '1') {
une(i - 1, i + 1, 1);
}
}
for (int i = 0; i < tam; ++i) {
if (s[i] == '1' && mai[f(i)] == 1 && (i == 0 || s[i - 1] == '0') &&
(i == tam - 1 || s[i + 1] == '0'))
s[i] = '0', rsp++;
}
for (int i = 0; i < tam; ++i) {
if (!mk[f(i)] && s[i] == '1' && mai[f(i)] > 1)
rsp += ta[f(i)] + 1, mk[f(i)] = true;
}
printf("%d\n", rsp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
string s;
cin >> s;
int a = 0, b = 1;
for (int i = 0; i < int(s.size()); i++)
if (s[i] == '1')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
cout << a;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1001000];
int main() {
while (cin >> str) {
int len = strlen(str);
int a = 0, b = 1;
for (int i = 0; i < len; i++) {
if (str[i] == '1')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
}
cout << a << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int inf = 0x3f3f3f3f;
char s[N];
int dp[N][2];
int main() {
scanf("%s", s + 1);
dp[0][1] = 1;
dp[0][0] = 0;
for (int i = 1; s[i]; i++) {
if (s[i] == '0') {
dp[i][0] = min(dp[i - 1][1] + 1, dp[i - 1][0]);
dp[i][1] = min(dp[i - 1][1] + 1, dp[i - 1][0] + 1);
} else {
dp[i][0] = min(dp[i - 1][1] + 1, dp[i - 1][0] + 1);
dp[i][1] = min(dp[i - 1][1], dp[i - 1][0] + 1);
}
}
cout << dp[strlen(s + 1)][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char in[1000010];
int n;
int main() {
scanf("%s", in);
n = strlen(in);
int ac = 0, zero = 2, pos = 0;
for (int i = 0; i < strlen(in);)
if (in[i] == '1') {
int cnt = 0;
while (in[i + cnt] == '1') cnt++;
if (cnt == 1) {
ac++;
if (zero > 1) pos = 1;
} else if (zero == 1) {
ac++;
if (pos) ac++;
pos = 0;
} else
ac += 2, pos = 0;
i += cnt;
} else {
zero = 0;
while (in[i + zero] == '0') zero++;
i += zero;
}
printf("%d\n", ac);
}
|
#include <bits/stdc++.h>
char s[1000001];
int i, j, k, n, t, ans;
int main() {
while (scanf("%s", s) != EOF) {
t = strlen(s);
ans = 0;
n = 0;
if (t == 1 && s[0] == '1') {
printf("1\n");
continue;
}
for (i = t - 1; i >= 1; i--) {
if (s[i] == '0') continue;
n++;
if (s[i] == '1' && s[i - 1] == '0' && n == 1) {
ans++;
n = 0;
} else if (s[i] == '1' && s[i - 1] == '1')
continue;
else {
s[i] = '0';
s[i - 1] = '1';
ans++;
n = 0;
}
}
if (s[1] == '0')
ans++;
else
ans += 2;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
char src[1000005];
int main() {
scanf("%s", src);
int len = strlen(src), ans = 0;
int cnt = 0;
for (int i = len - 1; i >= 0; i--) {
if (src[i] == '1') {
if (cnt == 0) {
ans++;
}
cnt++;
} else {
if (cnt > 1) {
ans++;
cnt = 1;
} else {
cnt = 0;
}
}
}
if (cnt > 1) ans++;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string x;
cin >> x;
x = "00" + x;
int n = x.size();
int sum = 0, count = 0;
for (long long i = (n - 1); i > (-1); i--) {
if (x[i] == '1') {
sum++;
} else if (sum >= 2) {
sum = 1;
count++;
} else if (sum == 1) {
sum = 0;
count++;
}
}
cout << count;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000 + 5], res;
char s[1000000 + 5];
int main() {
scanf("%s", &s);
n = strlen(s);
for (int i = 1; i <= n; ++i) a[i] = int(s[n - i] - '0');
++n;
for (int i = 1; i <= n; ++i)
if (a[i] == 1) {
if (a[i + 1] == 1) {
while (a[i] == 1) ++i;
a[i--] = 1;
}
++res;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
s = "0" + s;
vector<int> v(int(s.size()), 0);
for (int i = int(s.size()) - 1; i >= 0; i--) {
if (s[i] == '1') {
v[i] = -1;
while (s[i] != '0') i--;
v[i] = 1;
}
}
for (int i = 1; i < int(v.size()); i++) {
if (v[i] == -1 and v[i - 1] == 1) {
v[i - 1] = 0;
v[i] = 1;
} else if (v[i] == 1 and v[i - 1] == -1) {
v[i - 1] = 0;
v[i] = -1;
}
}
int count = 0;
for (int i = 0; i < int(v.size()); i++)
if (v[i] != 0) count++;
cout << count << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int f1[1000010];
int f2[1000010];
int main() {
scanf("%s", s);
int l = strlen(s);
f2[l - 1] = 1;
if (s[l - 1] == '1')
f1[l - 1] = 1;
else
f1[l - 1] = 0;
for (int i = l - 2; i >= 0; i--) {
if (s[i] == '1') {
f2[i] = f2[i + 1];
f1[i] = ((f1[i + 1] + 1) < (f2[i] + 1) ? (f1[i + 1] + 1) : (f2[i] + 1));
} else {
f1[i] = f1[i + 1];
f2[i] = ((f2[i + 1] + 1) < (f1[i] + 1) ? (f2[i + 1] + 1) : (f1[i] + 1));
}
}
printf("%d\n", f1[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int max(int x, int y) { return x > y ? x : y; }
char s[1000001];
int a[1000001];
int num[2];
int main() {
int i, n, m;
while (~scanf("%s", s)) {
int n = strlen(s);
for (i = 0; i < n; i++) a[i] = s[i] - '0';
int ans = 0;
num[0] = 0, num[1] = 0;
for (i = 0; i < n; i++) {
if (a[i] == 0) {
if (num[1] <= 1) {
ans += num[1];
num[1] = 0;
} else if (i && a[i - 1] == 0) {
ans += num[0] + 1;
num[0] = num[1] = 0;
} else
num[0]++;
} else {
num[1]++;
}
}
if (num[1] == 1)
ans += 1;
else if (num[1] > 1) {
if (a[n - 1] == 0)
ans += num[0] + 1;
else
ans += num[0] + 2;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void checkMin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
inline void checkMax(T& a, T b) {
if (a < b) a = b;
}
const int MAXN = 1000100;
const int INF = ~0U >> 2;
int n, m, dp[2][MAXN];
char s[MAXN];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
reverse(s + 1, s + n + 1);
fill(dp[0], dp[2], INF);
dp[0][0] = 2, dp[1][0] = 0;
for (int i = 1; i <= n; ++i) {
checkMin(dp[0][i], dp[0][i - 1] + (s[i] == '0'));
checkMin(dp[0][i], dp[1][i - 1] + 2);
checkMin(dp[1][i], dp[0][i - 1] + (s[i] == '1'));
checkMin(dp[1][i], dp[1][i - 1] + (s[i] == '1'));
}
printf("%d\n", min(dp[0][n], dp[1][n]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ToInt(string& s, int len) {
int r = 0;
for (int i = 0, max_ = (len); i < max_; ++i) {
r *= 10;
r += s[i] - '0';
}
return r;
}
int GCD(int a, int b) { return b != 0 ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * (b / GCD(a, b)); }
long long Pow(long long n, long long e) {
if (e == 0) return 1;
if (e == 1)
return n;
else if (e & 1) {
long long t = Pow(n, e / 2);
return n * t * t;
} else {
long long t = Pow(n, e / 2);
return t * t;
}
}
int main() {
string s;
getline(cin, s);
s = "00" + s;
int i = (int)(s).size() - 1, res = 0;
while (i >= 0) {
if (s[i] == '0') {
--i;
continue;
}
if (s[i] == '1' && s[i - 1] == '0') {
++res;
i -= 2;
continue;
}
int j = i - 1, zeros = 0;
while (true) {
if (s[j] == '0') {
if (s[j - 1] == '0')
break;
else
++zeros;
}
--j;
}
if (i - j == 1)
++res;
else
res += 2;
res += zeros;
if (j == 1) break;
i = j;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt0, cnt1;
int main(int argc, char** argv) {
string s;
cin >> s;
int cnt0 = 0, cnt1 = 0, f = 0, p = 0, kuai = 0, hb = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0') {
p--;
if (cnt1 == 1) p--;
if (!p) {
if (cnt1 > 1)
kuai++;
else if (cnt1 == 1)
f++;
cnt1 = 0;
}
} else {
if (p == 1) {
f++;
}
cnt1++;
p = 2;
}
}
if (cnt1 == 2 && hb) f--;
if (cnt1 > 1)
kuai++;
else if (cnt1 == 1)
f++;
printf("%d", f + kuai * 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000000;
const int INF = 1 << 30;
enum { NA, CD };
char s[MAX_N + 4];
int dp[MAX_N + 1][2];
inline void setmin(int &a, int b) {
if (a > b) a = b;
}
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i <= n; i++) dp[i][NA] = dp[i][CD] = INF;
dp[0][NA] = 0;
for (int i = 0; i < n; i++) {
if (s[n - 1 - i] == '0') {
if (dp[i][NA] < INF) {
setmin(dp[i + 1][NA], dp[i][NA]);
}
if (dp[i][CD] < INF) {
setmin(dp[i + 1][NA], dp[i][CD] + 1);
setmin(dp[i + 1][CD], dp[i][CD] + 1);
}
} else {
if (dp[i][NA] < INF) {
setmin(dp[i + 1][NA], dp[i][NA] + 1);
setmin(dp[i + 1][CD], dp[i][NA] + 1);
}
if (dp[i][CD] < INF) {
setmin(dp[i + 1][CD], dp[i][CD]);
}
}
}
printf("%d\n", min(dp[n][NA], dp[n][CD] + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void superFastRead(int *a) {
char c = 0;
while (c < 33) c = fgetc(stdin);
*a = 0;
while (c > 33) {
*a = *a * 10 + c - '0';
c = fgetc(stdin);
}
}
int main() {
string s;
cin >> s;
int cnt1 = 0;
int cnt2 = 0;
int cnt3 = 0;
int n1 = 0;
int n = s.length() - 1;
while (n >= 0) {
if (s[n] == '1') {
n1++;
cnt1++;
} else {
if (n1 == 1) {
cnt2++;
n1 = 0;
}
if (n1 > 1) {
cnt3++;
n1 = 1;
}
}
n--;
}
if (n1 == 1)
cnt2++;
else {
cnt3++;
cnt2++;
}
cout << min(cnt1, cnt2 + cnt3) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000002;
int n, dp[N][2];
char a[N];
int solve(int i, int j) {
if (i == n) return j ? 1000000000 : 0;
if (dp[i][j] != -1) return dp[i][j];
if (a[i] == '0') {
if (j)
dp[i][j] = 1 + solve(i + 1, 1);
else
dp[i][j] = min(1 + solve(i + 1, 1), solve(i + 1, 0));
} else {
if (j)
dp[i][j] = min(1 + solve(i + 1, 0), solve(i + 1, 1));
else
dp[i][j] = 1 + solve(i + 1, 0);
}
return dp[i][j];
}
int main() {
scanf("%s", a);
n = strlen(a);
memset(dp, -1, sizeof dp);
cout << min(solve(0, 0), 1 + solve(0, 1));
}
|
#include <bits/stdc++.h>
using namespace std;
int one[1000001];
int zero[1000001];
char s[10000002] = "0";
int get(int id) { return s[id] == '1' ? one[id] : zero[id]; }
void solve() {
scanf("%s", s + 1);
int slen = strlen(s);
int leftZero[1000001];
int leftOne[1000001];
leftZero[0] = 0;
leftOne[0] = -1;
for (int i = 1; i < slen; ++i)
if (s[i] == '1')
leftOne[i] = i, leftZero[i] = leftZero[i - 1];
else
leftZero[i] = i, leftOne[i] = i - 1;
one[0] = 1;
zero[0] = 0;
for (int i = 1; i < slen; ++i) {
one[i] = min(one[leftZero[i - 1]] + 1, get(i - 1) + 1);
zero[i] = min(zero[leftOne[i - 1]] + 1, get(i - 1));
}
printf("%d\n", get(slen - 1));
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct classcomp {
bool operator()(const int& lhs, const int& rhs) const { return lhs < rhs; }
};
int main() {
string ss;
cin >> ss;
string s;
for (int i = 0; i < ss.size(); i++) s += ss[ss.size() - 1 - i];
s += '0';
int n = s.size();
int res = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') continue;
int j = i + 1;
while (j < s.size() && s[j] == '1') j++;
if (j < i + 2) {
res++;
continue;
}
res++;
s[j] = '1';
i = j - 1;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 5;
int dp[nmax][2];
int main() {
int n;
string s;
cin >> s;
n = s.size();
dp[0][0] = 0;
dp[0][1] = 1;
for (int i = 1; i <= n; ++i) {
dp[i][0] = min(dp[i - 1][0] + (s[i - 1] == '1'),
dp[i - 1][1] + (s[i - 1] == '0') + 1);
dp[i][1] = min(dp[i - 1][1] + (s[i - 1] == '0'),
dp[i - 1][0] + (s[i - 1] == '1') + 1);
}
cout << dp[n][0] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long P = 1e9 + 7;
long long P1 = 998244353;
const int sqr = 500;
const int arrn = 1e6 + 5;
const int arrn2 = 6e3 + 5;
void solve() {
string in;
cin >> in;
int n = in.length();
vector<vector<long long>> proc(n, vector<long long>(3, INT_MAX));
for (int i = 0; i < n; i++) {
if (i == 0) {
proc[i][1] = 1;
proc[i][2] = 2;
} else {
if (in[i] == '0') {
proc[i][0] = min(proc[i - 1][0], min(proc[i - 1][1], proc[i - 1][2]));
proc[i][1] = min(1 + proc[i - 1][1],
min(2 + proc[i - 1][2], 2 + proc[i - 1][0]));
proc[i][2] = min(1 + proc[i - 1][2],
min(2 + proc[i - 1][1], 2 + proc[i - 1][0]));
} else {
proc[i][1] =
1 + min(proc[i - 1][0], min(proc[i - 1][1], proc[i - 1][2]));
proc[i][2] =
min(2 + proc[i - 1][0], min(2 + proc[i - 1][1], proc[i - 1][2]));
}
}
}
cout << min(proc[n - 1][0], min(proc[n - 1][1], proc[n - 1][2]));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long int base = 313;
const long long int inf = 1e8;
const long long int mod = 1e9 + 7;
const int lg = 20;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string second;
cin >> second;
int ans = 0;
while (second.size()) {
int k = 0;
while (second.size() && second.back() == '0') second.pop_back();
while (second.size() && second.back() == '1') {
k++;
second.pop_back();
}
if (second.size()) second.pop_back();
if (k == 1)
ans++;
else {
second += '1';
ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int MAXN = 1000005;
int n;
string s;
int a[MAXN];
int f[MAXN][2];
inline void init() {
cin >> s;
n = (int)s.length();
for (int i = 0; i < n; ++i) a[i] = (int)(s[i] - '0');
memset(f, -1, sizeof f);
}
int rec(int x, int y) {
if (x == n) return y;
if (f[x][y] != -1) return f[x][y];
int res = n;
if (!y) {
int cur = (2 - a[x]) + rec(x + 1, 1);
res = min(res, cur);
cur = a[x] + rec(x + 1, 0);
res = min(res, cur);
} else {
int cur = (1 + a[x]) + rec(x + 1, 0);
res = min(res, cur);
cur = (1 - a[x]) + rec(x + 1, 1);
res = min(res, cur);
}
return f[x][y] = res;
}
int main() {
init();
int res = rec(0, 0);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e9;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 1e6 + 5;
long long n;
string s;
long long dp[N][2];
long long calc(long long x, long long y) {
if (x == n) {
if (y == 0)
return 0;
else
return INF;
}
long long& ans = dp[x][y];
if (ans != -1) return ans;
if (y == 0) {
if (s[x] == '1')
ans = 1 + calc(x + 1, y);
else {
ans = calc(x + 1, y);
amin(ans, 1 + calc(x + 1, !y));
}
} else {
if (s[x] == '0')
ans = 1 + calc(x + 1, y);
else {
ans = calc(x + 1, y);
amin(ans, 1 + calc(x + 1, !y));
}
}
return ans;
}
void solve() {
cin >> s;
s = '0' + s;
n = (long long)((s).size());
memset(dp, -1, sizeof(dp));
cout << calc(0, 0);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using max_pq = priority_queue<T>;
const int inf = 2e9 + 5;
const long long l_inf = 2e18 + 5;
const int mod_v = 1e9 + 7;
const int max_n = 1e5 + 5;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
template <typename T>
T gcd(T a, T b) {
while (b) {
T temp = a % b;
a = b;
b = temp;
}
return a;
}
template <typename T>
tuple<T, T, T> egcd(T a, T b) {
T x1 = 1, x2 = 0, y1 = 0, y2 = 1;
while (b) {
T q = a / b, r = a % b;
T new_x = x1 - q * x2, new_y = y1 - q * y2;
x1 = x2, y1 = y2, x2 = new_x, y2 = new_y;
a = b, b = r;
}
return make_tuple(a, x1, y1);
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
template <typename T>
inline T mod(T a, T b = mod_v) {
return (a % b + b) % b;
}
template <typename T>
inline T mod_inv(T a, T b = mod_v) {
return mod(get<1>(egcd(a, b)), b);
}
template <typename T>
inline T sum(T a, T b, T m = mod_v) {
return mod(mod(a, m) + mod(b, m), m);
}
template <typename T>
inline T difference(T a, T b, T m = mod_v) {
return mod(mod(a, m) - mod(b, m), m);
}
inline long long product(long long a, long long b, long long m = mod_v) {
return mod(mod(a, m) * mod(b, m), m);
}
inline long long quotient(long long a, long long b, long long m = mod_v) {
return mod(mod(a, m) * mod_inv(b, m), m);
}
template <typename T, typename T2>
ostream &operator<<(ostream &s, const pair<T, T2> &p) {
return s << p.first << ' ' << p.second << ' ';
}
template <typename T, typename T2>
istream &operator>>(istream &s, pair<T, T2> &p) {
return s >> p.first >> p.second;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
for (auto it : v) s << it << ' ';
return s;
}
template <typename T>
istream &operator>>(istream &s, vector<T> &v) {
for (auto it = (v).begin(), it_ = (v).end(); it != it_; ++it) s >> *it;
return s;
}
template <typename T>
void read_range(T beg, T end) {
while (beg != end) cin >> *beg++;
}
template <typename T>
void print_range(T beg, T end) {
while (beg != end) cout << *beg++ << ' ';
}
struct reader {
template <typename T>
reader &operator,(T &v) {
cin >> v;
return *this;
}
} rdr;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << ", ";
return *this;
}
} dbg;
string s;
int f(int ind) {
if (s[ind] == '0') return ind + 1;
int i = ind;
while (s[i] == '1' and i < s.size()) ++i;
if (i - ind > 1) {
;
if (i == s.size())
s.push_back('1');
else
s[i] = '1';
for (int j = ind + 1; j < i; ++j) {
;
s[j] = '0';
}
}
return i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
reverse((s).begin(), (s).end());
for (int i = 0; i < s.size();) i = f(i);
int res = 0;
for (int i = 0, i_ = (s.size()); i < i_; ++i)
if (s[i] != '0') ++res;
;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long binpow(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long binpowmod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long mod_inverse(long long n, long long p) {
return binpowmod(n, p - 2, p);
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
unsigned int onesComplement(unsigned int n) {
int number_of_bits = floor(log2(n)) + 1;
return ((1 << number_of_bits) - 1) ^ n;
}
bool comp1(pair<int, int> x, pair<int, int> y) { return x.second < y.second; }
void solve() {
string s;
cin >> s;
int n = s.length();
vector<int> pref(n + 1, 0);
for (int i = 0; i < n; ++i) {
pref[i + 1] = s[i] == '1';
pref[i + 1] += pref[i];
}
int one = 0, zero = 0, tot = 0;
for (int i = 0; i < n; ++i) tot += s[i] == '1';
int ans = tot;
reverse(s.begin(), s.end());
int dp[n + 1][3];
for (int i = 0; i <= n; ++i) dp[i][0] = 0, dp[i][1] = 0, dp[i][2] = 0;
dp[0][1] = dp[0][2] = 1e8;
for (int i = 1; i <= n; ++i) {
if (s[i - 1] == '1') {
dp[i][0] = 1e8;
dp[i][1] = min(dp[i - 1][2] + 1, dp[i - 1][1]);
dp[i][2] = dp[i - 1][0] + 1;
} else {
dp[i][0] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]});
dp[i][1] = min({dp[i - 1][2] + 1, dp[i - 1][1]}) + 1;
dp[i][2] = dp[i - 1][0] + 1;
}
}
cout << min({dp[n][0], dp[n][1], dp[n][2]});
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1111111];
int main() {
int i;
scanf("%s", s);
int t = strlen(s);
int sum1 = 0, sum0 = 0;
int ans = 0;
i = 0;
int f1 = 0;
int cont = 0;
while (i < t) {
sum1 = 0;
sum0 = 0;
while (s[i] == '1') i++, sum1++;
while (s[i] == '0') i++, sum0++;
if (sum1 == 1 && !cont) {
ans += 1;
continue;
}
if (sum0 == 1 && i < t) {
cont++;
continue;
}
ans += 2 + cont;
cont = 0;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T r;
ss >> r;
return r;
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T cube(T x) {
return x * x * x;
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const double PI = acos(-1.0);
const double eps = 1e-9;
const int dr[] = {-1, 0, +1, 0};
const int dc[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const long long mod = (long long)1e9 + 7;
char s[2000005];
int main() {
scanf("%s", s);
int n = strlen(s);
int res = 0;
int d = -1;
int num0 = 0, num1 = 0;
bool start = true;
for (int i = 0; i < (n); ++i) {
if (d == -1) {
if (s[i] == '1') {
if (s[i + 1] == '1') {
d = 1;
} else {
d = 0;
num1++;
}
} else {
d = 0;
num0++;
}
} else if (d == 0) {
if (s[i] == '1') {
if (s[i + 1] == '1') {
if (start)
res += num1;
else
res += min(num0 - 2, num1);
num0 = 0;
num1 = 0;
d = 1;
start = false;
} else {
num1++;
}
} else {
num0++;
}
} else {
if (s[i] == '0') {
res += 2;
num0 = 1;
num1 = 0;
d = 0;
start = false;
}
}
}
if (d == 0)
res += num1;
else
res += 2;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c, x, y;
string s;
int main() {
cin >> s, c = x = 1;
while ((y = x) < (n = s.length())) {
while (s[y] == s[x]) ++y;
c += (s[x] == '1' || y < n), x = y + 1;
}
cout << c;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const long long INFLL = 1e18 + 7;
const int maxN = 1e6 + 9;
string s;
int f[2];
void enter() { cin >> s; }
void process() {
f[0] = 0;
f[1] = 1;
for (int i = 0; i < s.size(); i++) {
f['1' - s[i]] = min(f[0], f[1]) + 1;
}
cout << f[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
enter();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct sub {
long long l;
long long r;
};
bool checkIfSingleZero(const string &s, long long ind) {
return ((s[ind - 1] == '1') && (s[ind + 1] == '1'));
}
long long findR(const string &s, long long ind) {
long long sz = s.size();
sz -= 1;
long long i = ind;
for (; i < sz; ++i) {
if (s[i] == '1') {
continue;
}
if ((s[i] == '0') && (s[i + 1] == '1')) {
continue;
}
break;
}
return i;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
long long szit = s.size();
long long lastOne = szit - 1;
for (long long i = szit - 1; i >= 0; --i) {
if (s[i] == '1') {
lastOne = i;
break;
}
}
string t = s.substr(0, lastOne + 1);
s = t;
long long sz = s.size();
long long sz0 = sz;
s += '1';
vector<long long> ones(sz + 2, 0), zeroes(sz + 2, 0);
vector<sub> singleZeroes;
long long leftMostOne = 0;
for (long long i = 1; i < sz;) {
if (s[i] == '0') {
if (checkIfSingleZero(s, i)) {
sub obj;
obj.l = leftMostOne + 1;
obj.r = findR(s, i + 1);
singleZeroes.push_back(obj);
i = obj.r;
} else {
++i;
}
} else {
if (s[i - 1] != '1') {
leftMostOne = i;
}
++i;
}
}
if (singleZeroes.size() > 1) {
long long itx = 0;
for (long long i = 0; i < sz;) {
if (singleZeroes[itx].l == (i + 1)) {
i = singleZeroes[itx].r;
++itx;
continue;
}
if (s[i] == '1') {
long long cnt = 0, st = i, en = i;
while ((i < sz) && (s[i] == '1')) {
en = i;
++i;
++cnt;
}
if (cnt > 1) {
for (long long it = st; it <= en; ++it) {
s[it] = '0';
}
s[st] = '1';
s[en] = '1';
}
} else {
++i;
}
}
}
for (long long i = 1; i <= sz; ++i) {
if (s[i - 1] == '1') {
ones[i] = 1;
} else {
zeroes[i] = 1;
}
ones[i] += ones[i - 1];
zeroes[i] += zeroes[i - 1];
}
ones[sz + 1] += ones[sz];
zeroes[sz + 1] += zeroes[sz];
long long l = 0, r = 0;
long long ans = 0;
sz = singleZeroes.size();
for (long long i = 0; i < sz; ++i) {
long long l0 = singleZeroes[i].l - 1, r0 = singleZeroes[i].r;
if (l0 != 0) {
r = l0;
}
ans += min(zeroes[r0] - zeroes[l0] + 2, ones[r0] - ones[l0]);
ans += (ones[r] - ones[l]);
l = r0;
if ((i == (sz - 1)) && (r0 < sz0)) {
ans += (ones[sz0] - ones[r0]);
}
}
if (sz == 0) {
ans = min(ones[sz0], zeroes[sz0] + 2);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 2;
const int inf = 1000 * 1000 * 1000 + 7;
string s;
int a[maxn];
int b[maxn];
int main() {
for (int i = 0; i < maxn; i++) {
a[i] = inf;
b[i] = inf;
}
cin >> s;
int sz = s.size();
a[0] = 1;
b[0] = 2;
for (int i = 1; i < sz; i++) {
if (s[i] - '0' == 1) {
a[i] = min(b[i - 1] + 1, a[i - 1] + 1);
b[i] = min(b[i - 1], a[i - 1] + 2);
} else {
a[i] = min(b[i - 1], a[i - 1]);
b[i] = min(b[i - 1] + 1, a[i - 1] + 2);
}
}
cout << min(a[sz - 1], b[sz - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> s;
s = "00" + s;
n = s.length();
int ans = 0;
for (int i = n - 1; i >= 1; i--) {
if (s[i] == '1') {
if (s[i - 1] == '1') {
while (s[i] == '1') {
s[i] = 0;
i--;
}
s[i] = '1';
i++;
} else {
s[i] = '0';
}
ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long i, ans, now;
int main() {
cin >> s;
for (i = s.size(); i >= 0; i--)
if (s[i] == '1') {
now = i;
while (i >= 0 && s[i] == '1') i--;
ans++;
if (now == i + 1) {
i++;
continue;
}
if (i == -1) {
ans++;
continue;
}
s[i] = '1';
i++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int MAX = 1000000;
int MIN = -1000000;
int INF = 1000000000;
int x4[4] = {0, 1, 0, -1};
int y4[4] = {1, 0, -1, 0};
int x8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int y8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int i, j, k;
int main() {
string str;
cin >> str;
str.push_back('0');
reverse(str.begin(), str.end());
str.push_back('0');
int indx = 1, ans = 1;
while (indx < str.size()) {
if (str[indx] == '1' && str[indx + 1] == '1') {
str[indx - 1] = '1';
for (i = indx; str[i] == '1'; i++) str[i] = '0';
str[i] = '1';
indx = i;
} else
indx++;
}
int satu = 0;
for (i = (0); i < (str.size()); i++) satu += (str[i] == '1');
cout << satu << endl;
{
fflush(stdin);
getchar();
};
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int chh;
const int N = 1000005, INF = ~0U >> 2;
string s;
int dp[N][2];
int main() {
int sz;
while (cin >> s) {
memset(dp, 0x3f, sizeof(dp));
s.reserve();
if (s[0] == '0')
dp[0][0] = 0, dp[0][1] = 2;
else
dp[0][0] = dp[0][1] = 1;
sz = s.size();
for (int i = (1); i <= (sz - 1); i++) {
if (s[i] == '0') {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0] + 1, dp[i - 1][1] + 1);
dp[i][1] = min(dp[i - 1][0] + 1, dp[i - 1][1]);
}
}
printf("%d\n", min(dp[sz - 1][0], dp[sz - 1][1] + 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int i, j, ans;
int main() {
cin >> s;
s = "000" + s;
for (i = s.size() - 1; i > 0; i--)
if (s[i] == '1') {
if (s[i - 1] == '0') {
ans++;
continue;
}
j = i;
ans++;
while (s[j] == '1') {
s[j] = '0';
j--;
}
s[j] = '1';
i = j + 1;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char x[1000100];
int main() {
scanf("%s", x);
int out = 0;
for (int i = strlen(x) - 1; i >= 0; i--) {
if (x[i] == '0') continue;
if (!i || x[i - 1] == '0') {
out++;
continue;
}
int e = i;
while (e && (x[e] != x[e - 1] || x[e] == '1')) out += (x[e] == '0'), e--;
out += 2;
i = e;
}
cout << out;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s = '0' + s;
int count = 0;
while (count < 30000000) {
bool flag = false;
for (int i = 0; i < s.size() - 1; i++) {
count++;
if (s[i] == '2' && s[i + 1] == '1') {
s[i] = '0';
s[i + 1] = '2';
}
if (s[i] == '1' && s[i + 1] == '1') {
if (i == 0) {
flag = true;
} else {
s[i] = '0';
s[i - 1] = '1';
s[i + 1] = '2';
}
}
}
if (flag) s = '1' + s;
if (count >= 30000000) break;
}
int sum = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1' || s[i] == '2') sum++;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1001000];
int main() {
scanf("%s", s);
int a = 1, b = 0;
for (int i = 0; i < strlen(s); ++i)
if (s[i] == '0')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
printf("%d\n", b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int score(char* c, int length) {
if (length == 0) return 0;
if (c[length - 1] == '0') return score(c, length - 1);
if (length == 1) return 1;
if (c[length - 2] == '0') return score(c, length - 2) + 1;
int i;
for (i = length - 1; c[i] == '1'; i--) c[i] = '0';
c[i] = '1';
return score(c, length) + 1;
}
int main() {
char c[1000001] = {'0'};
int i = 0, j;
while (c[i] != '\n') c[++i] = getchar();
cout << score(c, i);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[2000000];
int main() {
int len, res = 0;
scanf("%s", s + 2);
len = strlen(s + 2);
s[0] = s[1] = '0';
for (int i = len + 1; i >= 1; i--) {
if (s[i] == '2') {
s[i - 1]++;
s[i] = '0';
}
if (s[i] == '0') continue;
res++;
if (s[i - 1] == '1') s[i - 1]++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
int N, memo[1000090][2];
void ini() { memset(memo, -1, sizeof(memo)); }
int dp(int cur, int yes) {
if (cur == N) {
return yes;
}
int &ret = memo[cur][yes], use = 0;
if (ret != -1) return ret;
ret = 21474836;
if ((str[cur] == '1' && !yes) || (str[cur] == '0' && yes)) {
ret = dp(cur + 1, yes ^ 1) + 1;
ret = min(dp(cur + 1, yes) + 1, ret);
} else {
ret = min(ret, dp(cur + 1, yes));
ret = min(ret, dp(cur + 1, yes ^ 1) + 1);
}
return ret;
}
int main() {
while (cin >> str) {
N = str.size();
reverse(str.begin(), str.end());
ini();
int ret = dp(0, 0);
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
int len = s.size(), ans = 0;
for (int i = 0; i < len;) {
int c1 = 0, c0 = 0, j;
while (s[i] == '1') {
c1++;
i++;
}
j = i;
while (s[i] == '0') {
c0++;
i++;
}
if (c1 == 0)
continue;
else if (c1 == 1)
ans++;
else if (c0 == 1) {
i--;
ans++;
s[j] = '1';
} else if (c0 >= 2 || c0 == 0) {
ans += 2;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
int dp[1000001];
int len[1000001];
int main() {
cin >> str;
for (int l = 0, i = str.size() - 1; i >= 0; i--) {
if (str[i] == '0') {
if (l >= 2 && str[i - 1] != '0')
dp[i] = 1, len[i] = ++l;
else {
l = 0;
}
} else {
dp[i] = 1;
len[i] = ++l;
}
}
int ans = 0;
for (int i = 0; i < str.size(); i++) {
if (dp[i]) {
if (len[i] > 1)
ans += 2;
else
ans += 1;
int k = len[i];
while (k) {
if (str[i] == '0') ans++;
k--;
i++;
}
i--;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1000010;
int N, Min, CntZero, Best[NMAX], Last;
char S[NMAX];
int main() {
gets(S + 1);
N = strlen(S + 1);
Last = -1;
Min = 0;
CntZero = 0;
for (int i = 1; i <= N; ++i) {
if (S[i] == '0') {
Best[i] = Best[i - 1];
CntZero++;
Last = -1;
} else {
if (Last == -1) Last = i;
Best[i] =
min(Best[i - 1] + 1, min(Best[Last - 1] + 2, 2 + CntZero + Min));
}
if (Best[i] - CntZero < Min) Min = Best[i] - CntZero;
}
printf("%i\n", Best[N]);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int n;
char str[1000500];
int main() {
scanf("%s", str);
n = strlen(str);
reverse(str, str + n);
str[n] = '0';
str[n + 1] = '0';
int ans = 0;
int cur = 0, i = 0;
while (i <= n + 1) {
if (str[i] == '1')
++cur;
else if (cur > 0) {
++ans;
if (cur > 1) {
str[i] = '1';
--i;
}
cur = 0;
}
++i;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1000010];
int dp[1000010];
int main() {
int i, tmp = 0;
scanf("%s", str + 1);
int n = strlen(str + 1);
dp[n] = str[n] - '0';
for (i = n - 1; i >= 1; i--) {
if (str[i] == '1')
dp[i] = min(dp[i + 1] + 1, tmp + 2);
else {
tmp++;
dp[i] = dp[i + 1];
tmp = min(tmp, dp[i]);
}
}
printf("%d\n", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void run();
int main() {
ios::sync_with_stdio(0);
run();
}
string s;
unsigned dp[1000002][2];
void run() {
cin >> s;
int const n = s.size();
memset(dp, -0, sizeof dp);
dp[n][0] = 0, dp[n][1] = 1;
for (int i = n; i--;) {
dp[i][0] =
min(dp[i + 1][0] + (s[i] == '1'), dp[i + 1][1] + (s[i] == '0') + 1);
dp[i][1] =
min(dp[i + 1][1] + (s[i] == '0'), dp[i + 1][0] + (s[i] == '1') + 1);
}
cout << min(dp[0][0], dp[0][1] + 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
int main() {
string s;
cin >> s;
int n = s.length();
if (n == 1) return !(cout << 1 << endl);
reverse(begin(s), end(s));
vector<vector<int>> dp(n + 2, vector<int>(2));
dp[0][1] = INF;
s += '0';
for (int i = 0; i <= n; i++) {
if (s[i] == '0') {
dp[i + 1][0] = min(dp[i][0], dp[i][1] + 1);
dp[i + 1][1] = dp[i][1] + 1;
}
if (s[i] == '1') {
dp[i + 1][1] = min(dp[i][1], dp[i][0] + 1);
dp[i + 1][0] = dp[i][0] + 1;
}
}
cout << dp[n + 1][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt0, cnt1;
int main(int argc, char** argv) {
string s;
cin >> s;
int cnt0 = 0, cnt1 = 0, f = 0, p = 0, kuai = 0, hb = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0') {
p--;
if (cnt1 == 1) p--;
if (!p) {
if (cnt1 > 1)
kuai++;
else if (cnt1 == 1)
f++;
cnt1 = 0;
}
} else {
if (p == 1) {
f++;
}
cnt1++;
p = 2;
}
}
if (cnt1 == 2 && hb) f--;
if (cnt1 > 1)
kuai++;
else if (cnt1 == 1)
f++;
printf("%d", f + kuai * 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long f[2] = {0};
void solve() {
f[0] = 1;
f[1] = 0;
for (auto e : s) {
long long now = min(f[1], f[0]);
if (e == '0')
f[0] = now + 1;
else
f[1] = now + 1;
}
cout << f[1];
}
int main() {
cin >> s;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[1000111], rs[1000111];
int main() {
int ans = 1, bns = 1;
char c;
while ((c = getchar()) == '0')
;
if (c == EOF) return puts("0");
while ((c = getchar()) != EOF) {
if (c == '1')
smin(ans, bns), ans++;
else
smin(bns, ans), bns++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1000000000;
const long long int mod = 1000000000 + 7;
inline void IO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline int dcmp(long double x) { return x < -1e-12 ? -1 : (x > 1e-12); }
template <class T>
inline int CHECK(T MASK, int i) {
return (MASK >> i) & 1;
}
template <class T>
inline T ON(T MASK, int i) {
return MASK | (T(1) << i);
}
template <class T>
inline T OFF(T MASK, int i) {
return MASK & (~(T(1) << i));
}
template <typename T>
inline int CNT(T MASK) {
if (numeric_limits<T>::digits <= numeric_limits<unsigned int>::digits)
return __builtin_popcount(MASK);
else
return __builtin_popcountll(MASK);
}
template <class T>
inline int RIGHT(T MASK) {
return log2(MASK & -MASK);
}
int dx4[] = {0, 0, -1, +1};
int dy4[] = {+1, -1, 0, 0};
int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1, 0};
inline void I(int& a) { scanf("%d", &a); }
inline void I(long long int& a) { scanf("%I64d", &a); }
inline void I(unsigned long long int& a) { scanf("%I64u", &a); }
inline void I(char* a) { scanf("%s", a); }
char Iarr[2000010];
inline void I(string& a) {
scanf("%s", Iarr);
a = Iarr;
}
template <typename T, typename... Args>
void I(T& a, Args&... args) {
I(a);
I(args...);
}
inline void OUT(int a) { printf("%d", a); }
inline void OUT(long long int a) { printf("%I64d", a); }
inline void OUT(const char* a) { printf("%s", a); }
inline void OUT(char* a) { printf("%s", a); }
inline void OUT(bool a) { printf("%d", a); }
inline void OUT(string a) {
for (__typeof(a.end()) it = (a.begin()) - ((a.begin()) > (a.end()));
it != (a.end()) - ((a.begin()) > (a.end()));
it += 1 - 2 * ((a.begin()) > (a.end())))
printf("%c", *it);
}
inline void OUT(unsigned long long int a) { printf("%I64u", a); }
template <typename T, typename... Args>
void OUT(T a, Args... args) {
OUT(a);
OUT(" ");
OUT(args...);
}
template <typename... Args>
void O(Args... args) {
OUT(args...);
OUT("\n");
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, pair<T1, T2> p) {
os << "{" << p.first << ", " << p.second << "}";
return os;
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& a) {
os << "[";
for (int i = 0; i < (int)a.size(); i++) {
if (i) os << ", ";
os << a[i];
}
os << "]";
return os;
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const int M = 10010;
int main() {
string s;
I(s);
int n = (int)s.size();
int len = 0;
int ans = 0;
int zlen = 0;
bool flag;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
if (len != 0) {
if (zlen != 1) flag = 0;
if (flag)
ans++;
else {
if (len == 1)
ans++;
else
ans += 2;
}
if (len >= 2) flag = 1;
zlen = 0;
}
len = 0;
zlen++;
} else {
len++;
}
}
if (len != 0) {
if (zlen != 1) flag = 0;
if (flag)
ans++;
else {
if (len == 1)
ans++;
else
ans += 2;
}
if (len >= 2) flag = 1;
zlen = 0;
}
O(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> gr[100001];
bool vi[100001];
int v[100001];
long long ans;
long long ar[100001];
string s;
int dp[2];
int main() {
int n;
cin >> s;
int in = s.size() - 1;
while (s[in--] == '0')
;
dp[0] = dp[1] = 1;
for (int i = in; i >= 0; i--) {
if (s[i] == '1') {
dp[0] = dp[0] + 1;
} else {
dp[0] = min(dp[0], dp[1] + 1), dp[1] = min(dp[1] + 1, dp[0] + 1);
}
}
dp[0] = min(dp[1] + 1, dp[0]);
cout << dp[0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int ans = 0;
int main() {
scanf("%s", s);
int l = 0, n = 0, len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] == '1')
l++, n++;
else if (i != strlen(s) - 1 && s[i + 1] == '1' && l != 0)
l++;
else {
ans += min(n, l - n + 2);
l = 0;
n = 0;
}
}
ans += min(n, l - n + 2);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
const double pi = 3.1415926535897932384626433832795;
const double eps = 0.0000001;
const int INF = 1E9;
const int MAXN = 1000010;
int n, ans;
bool a[MAXN];
int dp[MAXN][2];
string s;
int main() {
cin >> s;
n = s.size();
while (n > 0 && s[n - 1] == '0') n--;
n--;
if (n <= 0) {
cout << 1;
return 0;
}
a[0] = 0;
for (int i = 0; i < (int)(n); i++) a[i + 1] = s[i] - '0';
n++;
for (int i = 0; i < (int)(MAXN); i++)
for (int j = 0; j < (int)(2); j++) dp[i][j] = INF;
dp[1][0] = 0;
dp[1][1] = 1;
for (int i = 1; i < n; i++) {
if (a[i])
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + 1);
else {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0]);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + 1);
}
if (!a[i]) {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + 1);
} else {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1]);
dp[i + 1][0] = min(dp[i + 1][0], dp[i][1] + 1);
}
}
ans = min(dp[n][0], dp[n][1]);
cout << ans + 1;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.