ZAFU五月多校合训

B. 进制

jbgg 今天在幼儿园学了进制转换，现在 jbgg 有一个十进制正整数 \(x\)，jbgg 好奇是否存在这样一个进制 \(p\)，使得 \(x\) 在 \(p\) 进制表示下的各个位上的数相加等于 \(y\)

\(2⩽x⩽10^{10}, 1⩽y⩽⌊\frac{x}{2}⌋\)

\(2⩽p⩽10^{18}\)

题解：构造

• \(a_0+a_1p^1+...=x\)
• \(a_0+a_1+...=y\)
• 我们考虑这样一种构造的方法：
• \(a_1=1\),\(a_0+p=x\),\(a_0+1=y\)
• \(p = x - y + 1\)
• 显然\(p\)在合法的范围内

void solve()
{
    int x, y;
    cin >> x >> y;
    cout << x - y + 1 << endl;
}

神奇的骰子

jbgg 在打一个 boss，现在他需要通过投掷一个神奇的骰子来增加自己的攻击力来打败这个 boss。这个骰子有 \(n\) 面，投掷它将等概率地投出 \(1\) 到 \(n\) 中的任意一个数字。

他可以按顺序执行如下操作:

1. 从 \(1\) 到 \(n\) 中选不同的 \(k (1⩽k⩽n)\) 个数字;
2. 消耗一次投掷次数，投掷一次骰子，直到没有投掷次数。对于每次投掷，假设投出的数字为 \(d\)，且 \(d\) 在所选的 \(k\) 个数字之中，那么可以增加 \(d\) 点攻击力且获得一次投掷次数，否则将无事发生。

现在 jbgg 只有一次投掷次数了，他希望他增加的攻击力的期望不小于 \(x\)，由于选择越大的 \(k\) 所需付出的代价越大，他希望这个 \(k\) 尽量的小，你能告诉他 \(k\) 应该选多少吗？

题解：概率与期望 + 二分

• 为了使得提升的攻击力尽可能多，我们一定会选择\(k\)个最大的数
• 那么每次投掷有\(\frac{k}{n}\)的概率增加攻击力\(\frac{n-k+1+n-k+1+...+n-k+k}{k}=\frac{n-k+1+n}{2}\)
• 投掷次数为1的概率为1，投掷次数为\(2\)的概率为\(\frac{k}{n}\)...投掷次数为\(i\)的概率为\((\frac{k}{n})^i\)
• 那么投掷次数的期望为\(\sum_{i=0}^{\infty}(\frac{k}{n})^i = \frac{n}{n-k}\)（利用等比数列求和公式）
• 所以每次\(k\)所能增加的攻击力的期望为\(\frac{k}{n} \times \frac{n-k+1+n}{2} \times \frac{n}{n-k} = \frac{k(n-k+1+n)}{2(n-k)}\)
• 二分出最小的\(k\)即可

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 2e5 + 10, M = 4e5 + 10;

int n, x;

bool check(int mid)
{
    int res = 0;
    if (n == mid)
        return true;
    res = (mid * (n - mid + 1 + n)) / (2 * (n - mid));
    return res >= x;
}

void solve()
{
    cin >> n >> x;
    int l = 1, r = n;
    while (l <= r)
    {
        int mid = l + r >> 1;
        if (check(mid))
            r = mid - 1;
        else
            l = mid + 1;
    }
    cout << l << endl;
}
signed main(void)
{
    Zeoy;
    int T = 1;
    cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

yyjj 的 windows 作业

yyjj 在为她的 windows 期末作业发愁，她决定写一个这样的小游戏：

有一个 \(n\) 行 \(m\) 列的矩形地图，开始有一个长宽均为 \(1\)，高为 \(2\) 的长方体竖直地立在 \((1,1)\) 单元格 （也就是 \(1×1\) 的那面与单元格 \((1,1)\) 接触）。玩家需要滚动长方体，使长方体到达的矩阵格点数量尽可能地多。

地图中有些单元格有障碍物，长方体在滚动过程中不能碰到障碍物。此外，长方体的任何部位都不能超出矩形地图的边界。保证单元格 \((1,1)\) 不存在障碍物，长方体可以接触到一个单元格任意多次。

yyjj 想知道通过滚动长方体的方式最多能接触到多少单元格。

\((1⩽n,m⩽100)\)

\(0\) 表示地图的这个单元格有障碍；\(1\) 表示地图的这个单元格没障碍。

题解：多状态DFS + 状态机模型

• 该题重点在于搜索状态的设置
• 我们可以设置多个状态表示当前方格上的方块是横着的、竖着的还是立着的，并且如果是横着的或者竖着的，当前方块上是可以往左侧立起来的还是可以往右侧立起来的
• 然后我们模拟其翻滚时状态的变化，得到状态机
• 比如说当前是横着的状态，可以继续保持横着的状态或者想立着的状态转移

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 1e2 + 10, M = 4e5 + 10;

int n, m;
char g[N][N];
bool mp[N][N][4][2];
// state1代表位于(x,y)的方块的状态是竖着的、横着的还是立着的，state2代表如果是横着或者竖着的状态下，现在是左边的部分还是右边的部分
// 1-竖 2-横 3-立
// 1-左边，0-右边 / 1-上边，0-下边
void dfs(int x, int y, int state1, int state2)
{
    if (x < 1 || x > n || y < 1 || y > m || g[x][y] == '0')
        return;
    if (state1 == 3)
    {
        if (mp[x][y][state1][0] || mp[x][y][state1][1])
            return;
    }
    else
    {
        if (mp[x][y][state1][state2])
            return;
    }

    mp[x][y][state1][state2] = true;
    if (state1 == 3)
    {
        if (x + 2 >= 1 && x + 2 <= n && y >= 1 && y <= m && g[x + 1][y] != '0' && g[x + 2][y] != '0')
        {
            dfs(x + 1, y, 1, 1);
            dfs(x + 2, y, 1, 0);
        }

        if (x - 2 >= 1 && x - 2 <= n && y >= 1 && y <= m && g[x - 1][y] != '0' && g[x - 2][y] != '0')
        {
            dfs(x - 1, y, 1, 0);
            dfs(x - 2, y, 1, 1);
        }

        if (x >= 1 && x <= n && y + 2 >= 1 && y + 2 <= m && g[x][y + 1] != '0' && g[x][y + 2] != '0')
        {
            dfs(x, y + 1, 2, 1);
            dfs(x, y + 2, 2, 0);
        }

        if (x >= 1 && x <= n && y - 2 >= 1 && y - 2 <= m && g[x][y - 1] != '0' && g[x][y - 2] != '0')
        {
            dfs(x, y - 1, 2, 0);
            dfs(x, y - 2, 2, 1);
        }
    }
    else if (state1 == 2 && state2 == 0)
    {
        // 保持横着的状态
        if (x - 1 >= 1 && x - 1 <= n && y >= 1 && y <= m && g[x - 1][y] != '0' && g[x - 1][y - 1] != '0')
            dfs(x - 1, y, 2, 0);
        if (x + 1 >= 1 && x + 1 <= n && y >= 1 && y <= m && g[x + 1][y] != '0' && g[x + 1][y - 1] != '0')
            dfs(x + 1, y, 2, 0);

        // 变成立着的状态
        if (x >= 1 && x <= n && y + 1 >= 1 && y + 1 <= m && g[x][y + 1] != '0')
            dfs(x, y + 1, 3, 1);
    }
    else if (state1 == 2 && state2 == 1)
    {
        // 保持横着的状态
        if (x - 1 >= 1 && x - 1 <= n && y >= 1 && y <= m && g[x - 1][y] != '0' && g[x - 1][y + 1] != '0')
            dfs(x - 1, y, 2, 1);
        if (x + 1 >= 1 && x + 1 <= n && y >= 1 && y <= m && g[x + 1][y] != '0' && g[x + 1][y + 1] != '0')
            dfs(x + 1, y, 2, 1);
        // 变成立着的状态
        if (x >= 1 && x <= n && y - 1 >= 1 && y - 1 <= m && g[x][y - 1] != '0')
            dfs(x, y - 1, 3, 1);
    }
    else if (state1 == 1 && state2 == 0)
    {
        // 保持竖着的状态
        if (x >= 1 && x <= n && y + 1 >= 1 && y + 1 <= m && g[x][y + 1] != '0' && g[x - 1][y + 1] != '0')
            dfs(x, y + 1, 1, 0);
        if (x >= 1 && x <= n && y - 1 >= 1 && y - 1 <= m && g[x][y - 1] != '0' && g[x - 1][y - 1] != '0')
            dfs(x, y - 1, 1, 0);
        // 变成立着的状态
        if (x + 1 >= 1 && x + 1 <= n && y >= 1 && y <= m && g[x + 1][y] != '0')
            dfs(x + 1, y, 3, 1);
    }
    else if (state1 == 1 && state2 == 1)
    {
        // 保持竖着的状态
        if (x >= 1 && x <= n && y + 1 >= 1 && y + 1 <= m && g[x][y + 1] != '0' && g[x + 1][y + 1] != '0')
            dfs(x, y + 1, 1, 1);
        if (x >= 1 && x <= n && y - 1 >= 1 && y - 1 <= m && g[x][y - 1] != '0' && g[x + 1][y - 1] != '0')
            dfs(x, y - 1, 1, 1);
        // 变成立着的状态
        if (x - 1 >= 1 && x - 1 <= n && y >= 1 && y <= m && g[x - 1][y] != '0')
        {
            dfs(x - 1, y, 3, 1);
        }
    }
}

void solve()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            cin >> g[i][j];
    dfs(1, 1, 3, 1);
    int ans = 0;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            if (mp[i][j][1][0] || mp[i][j][1][1] || mp[i][j][2][0] || mp[i][j][2][1] || mp[i][j][3][0] || mp[i][j][3][1])
                ans++;
    cout << ans << endl;
}
signed main(void)
{
    Zeoy;
    int T = 1;
    // cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

区间反转

jbgg 有一个长为 \(n\) 的排列，jbgg 每次只能在排列中选择任意一段连续区间进行反转。

jbgg 想用不超过 \(2n\) 次操作使得该排列递增，请你帮助他。只要在你的输出结束后能使排列递增即可通过。

题解：思维

• 我们考虑下面这种情况：
• 如果我们想要交换\(l\)和\(r\)处的值，我们可以先反转\([l,r]\)，然后再反转\([l+1,r-1]\)，这样的话就只交换了\(l\)和\(r\)处的值，其他位置保持不变
• 那么我们可以从前往后遍历排列，将对应该位置的值交换过来，然后将中间的区间在反转一次，我们发现最多反转的次数不超过\(2n\)次

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 2e5 + 10, M = 4e5 + 10;

int n;
int a[N];
unordered_map<int, int> mp;
vector<pii> ans;

void solve()
{
    cin >> n;
    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i];
        mp[a[i]] = i;
    }
    for (int i = 1; i <= n; ++i)
    {
        if (a[i] != i)
        {
            ans.push_back({i, mp[i]});
            if (mp[i] - i > 2)
                ans.push_back({i + 1, mp[i] - 1});
            int t1 = a[i], t2 = a[mp[i]];
            swap(a[i], a[mp[i]]);
            swap(mp[t1], mp[t2]);
        }
    }
    cout << ans.size() << endl;
    for (auto &[x, y] : ans)
        cout << x << " " << y << endl;
}
signed main(void)
{
    Zeoy;
    int T = 1;
    // cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}