abc136

A Transfer

我们有两个装水的瓶子。

瓶子1 最多可以装 A毫升水，现在里面有B 毫升水。
瓶子2 里有 C 毫升水

我们将尽可能多地从瓶子2 中转移到瓶子1 中。
瓶子2 中会剩下多少水

solution
$max(0,c-(a-b))$

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, INF = 0x3f3f3f3f, MOD = 1E9 + 7;

int main() {
    int a, b, c;
    while (cin >> a >> b >> c)
        cout << max(0, c - (a - b))<<endl;
    return 0;
}

B Uneven Numbers

找出小于等于 N 的正整数中，有奇数个数字（十进制，不包括前导零）的数的个数。

solution
计算数字的位数，可以利用“除10删除个位，模10取得个位”的方式。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, INF = 0x3f3f3f3f, MOD = 1E9 + 7;

int main() {
    int n;
    while (cin >> n) {
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            int t = i, x = 0;
            while (t) x++, t /= 10;
            ans += x % 2;
        }
        cout << ans << endl;
    }
    return 0;
}

C Build Stairs

输入 $n$ 个正整数，$h_i$ 代表着第 $i$ 个木块的高度，你把木块按从左到右的顺序摆放好，每个木块支持两个操作，每个木块只能操作一次。

1. 木块高度减1
2. 高度不变

想问你能否凑成木块的高度是上升序列的。能就输出Yes，否则输出No。
上升序列的定义：对于 $2\le i\le n$，满足 $h_{i-1}\le h_i$。

solution
要升序序列，考虑贪心策略：尽量使得左边元素小，对之后的数据更有利。
对于当前元素，如果可以-1，那就-1，中途如果有递减情况发生，就退出。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e6 + 10, INF = 0x3f3f3f3f, MOD = 1E9 + 7;
int n, a[N];
int main() {
    while (cin >> n) {
        int flag = 1;
        for (int i = 1; i <= n; i++) cin >> a[i];
        for (int i = 2; i <= n; i++) {
            if (a[i] - 1 >= a[i - 1]) a[i]--;
            if (a[i] < a[i - 1]) { 
                flag = 0; break;
            }
        }
        cout << (flag ? "Yes" : "No") << endl;
    }
    return 0;
}

上述贪心策略也可以转换为：如果 $\exists a_j-a_i\ge 2,j<i$，那么不合法。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e6 + 10, INF = 0x3f3f3f3f, MOD = 1E9 + 7;
int n,a[N];
int main() {
    while (cin >> n) {
        int flag = 1, mx = 0;
        for (int i = 1; i <= n; i++) cin >> a[i];
        for (int i = 2; i <= n; i++) {
            if (mx - a[i] >= 2) {
                flag = 0; break;
            }
            mx = max(mx, a[i]);
        }
        cout << (flag ? "Yes" : "No") << endl;
    }
    return 0;
}

D Gathering Children

给定一个由 L 和 R 组成的字符串S。
设 N 为 S 的长度。从左到右排列了 N 个正方形，从左起第 i 个正方形上写着 S 的第 i 个字符。
最左边的正方形上始终写着 R，最右边的正方形上始终写着 L。

最初，每个正方形上都站着一个孩子。每个孩子将执行以下移动 $10^{100}$ 次：
向正方形上所写字符指示的方向移动一个正方形。 L 表示左，R 表示右。

找出孩子们执行移动后站在每个正方形上的孩子数量。

solution
$10^{100}$ 是个很大的数字，明显无法模拟，需要找规律。
字符串长度不是很大，可以猜测是否具有循环节，模拟发现 在 RL 或 LR 的时候是一直循环的，可以根据奇偶情况进行讨论。

对于当前字符 s[i]

1. 当前字符为 R，向右走一步，一直走到 L，此时出现一个循环节 RL
   假设 L 的下标为 $x$, 则到 L的步数 $k=x-i$
   如果 $k$ 是偶数，那么 s[i] 最后将停在 $x$ 处，否则将停在 $x-1$ 处。
2. 当前字符为 L，向左走一步，一直走到 R，此时出现一个循环节 RL
   假设 R 的下标为 $x$, 则到 R 的步数 $k=i-x$
   如果 $k$ 是偶数，那么 s[i] 最后将停在 $x$ 处，否则将停在 $x+1$ 处。

最后使用标记数组记录停在当前位置的数量即可。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e6 + 10, INF = 0x3f3f3f3f, MOD = 1E9 + 7;
int ans[N];
int main() {
    string s;
    while (cin >> s) {
        memset(ans, 0, sizeof ans);
        int n = s.size();
        for (int i = 0; i < n; i++) {
            if (s[i] == 'R') {
                int x = s.find('L', i), k = x - i;
                if (k % 2 != 0) x--;
                ans[x]++;
            } else {
                int x = s.rfind('R', i), k = x - i;
                if (k % 2 != 0) x++;
                ans[x]++;
            }
        }
        for (int i = 0; i < n; i++)
            cout << ans[i] << " \n"[i == n - 1];
    }
    return 0;
}

E Max GCD

F Enclosed Points