牛客白小月赛45

题目链接

A 悬崖

思路

审题！每时每刻都应在跳跃。
若第一跳没到对岸，直接结束。若能到对岸则共有 n 次跳跃
数据本身不溢出 int，但相乘会爆 int，应设 ll

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
    // ios::sync_with_stdio(0);
    ll x, n;
    cin >> x >> n;
    if (n > x)
        cout << x;
    else
        cout << n * x;
    return 0;
}

B 数数

思路

观察递归函数，可知 $ans=\sum_{i=1}^n 2i-1=n^2$
数据本身不溢出 int，但相乘会爆 int，应设 ll

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
    // ios::sync_with_stdio(0);
    ll n;
    cin >> n;
    cout << n * n;
    return 0;
}

C 山楂

思路

表面上 ans=(3a+4b)i 需要考虑 a 和 b 的分配，但需要分配的山楂总数相同，对于 a b 的不通分配并不会影响总分的高低，只用考虑是否能将山楂全部利用，故全部三个一组，再将余数尽可能加入各组，即为最佳方案
当 a[i]>5 时余数可全部加入各组，a[i]<=5 时分类讨论
求解中涉及多次乘法，所有参与运算的变量都应设为 ll 防止溢出，因 nex mod 设为 int 而错了好几次！

代码

优化了分类讨论的部分

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ll a[10];
ll ans;
int main()
{
    // ios::sync_with_stdio(0);
    for (int i = 1; i <= 8; i++)
    {
        cin >> a[i];
    }
    for (int i = 1; i <= 8; i++)
    {
        ll nex = a[i] / 3;
        ll mod = a[i] % 3;
        if (a[i] == 5)
            ans += 4 * i;
        else if (a[i] >= 3)
            ans += (3 * nex + mod) * i;
        a[i + 1] += nex;
    }
    cout << ans;
    return 0;
}

D 切糕

思路

括号匹配问题，合法切法即切成的每一段均合法
易知合法段的拼接仍然合法，故应寻找最小合法段的个数 cnt，cnt-1 个断点的排列组合，有 $2^{cnt-1}$ 种切法

代码

num 记录括号是否匹配，每次归零表示前缀为合法段，可以切割，小于零则右括号多余，前缀无法合法切割，该字符串也无法合法切割
cnt 很大，用快速幂计算
能合法切割的条件为 num 始终不会小于零，且无多余左括号

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned ull;
const ll M = 1e9 + 7;
ll fp(ll b, ll p)
{
    ll ret = 1;
    while (p)
    {
        if (p & 1)
            ret = ret * b % M;
        p >>= 1;
        b = b * b % M;
    }
    return ret;
}
string str;
int cnt, flag, num;
int main()
{
    // ios::sync_with_stdio(0);
    // cin.tie(0);
    cin >> str;
    for (int i = 0; str[i] && !flag; i++)
    {
        if (str[i] == '(')
            num++;
        else
            num--;
        if (num < 0)
            flag = 1;
        if (num == 0) // 前缀合法
            cnt++;
    }
    if (flag == 0 && num == 0) // 一一匹配，且无多余括号
    {
        cout << fp(2, cnt - 1);
    }
    else
    {
        cout << -1;
    }
    return 0;
}

E 筑巢

思路

树形 DP
设一棵根节点为 1 的树，连通块要么包含根节点，要么在其子树上
初始状态
$dp[0][i]=节点舒适度$ 表示连通块包含该节点的最大舒适度
$dp[1][i]=-inf$ 表示连通块在其子树上的最大舒适度
状态转移
$dp[0][i]=\sum_{y=son_i}max(dp[y][0],dp[y][1])$
$dp[1][i]=w_{iy}+max(dp[1][y],0LL)$用 ll 修饰常数

代码

#include <bits/stdc++.h>
using namespace std;
#define LL long long
const int N = 100010;

int n, w[N];
struct Edge
{
    int to, val;
};
vector<Edge> tree[N];
LL dp[N][2];
void dfs(int x, int fa)
{
    dp[x][0] = -1e18, dp[x][1] = w[x];
    for (Edge e : tree[x])
    {
        int y = e.to, v = e.val;
        if (y != fa)
        {
            dfs(y, x);
            dp[x][0] = max(dp[x][0], max(dp[y][0], dp[y][1]));
            dp[x][1] = dp[x][1] + max(dp[y][1] + v, 0LL);
        }
    }
}
int main()
{
    cin >> n;
    for (int i = 1; i <= n; ++i)
        cin >> w[i];
    for (int i = 1; i < n; ++i)
    {
        int x, y, v;
        cin >> x >> y >> v;
        tree[x].push_back((Edge){y, v});
        tree[y].push_back((Edge){x, v});
    }
    dfs(1, 0);
    cout << max(dp[1][0], dp[1][1]);
    return 0;
}

F 交换

思路

由于询问数列长度小于 10，则可对于1~10序列执行反向指令串操作，将每个子串的操作结果存放在字典树里，每次更新最短操作数
针对字典树的存放，数据量大，但诸多叶节点不用向下扩展，故不会超出内存限制

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll M = 1e9 + 7;
pair<short, short> pr[2003];
struct
{
    int son[10] = {0};
    short mx = 5000;
} dict[12000007];
int idx = 0;
void mt(string g, short x) // 加入字典树
{
    // cout<<x<<' '<<g<<endl;
    int now = 0;
    for (int i = 0; i < 10; i++)
    {
        if (!dict[now].son[g[i] - '0'])
        {
            dict[now].son[g[i] - '0'] = ++idx;
            now = idx;
        }
        else
        {
            now = dict[now].son[g[i] - '0'];
        }
        dict[now].mx = min(dict[now].mx, x); // 更新前缀的最小操作数
    }
}
short ck(string g, int k) // 查找匹配的前缀
{
    int now = 0;
    for (int i = 0; i < k; i++)
    {
        if (!dict[now].son[g[i] - '0'])
        {
            return 5000;
        }
        else
        {
            now = dict[now].son[g[i] - '0'];
        }
    }
    return dict[now].mx;
}
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &pr[i].first, &pr[i].second);
    }
    for (int i = 1; i <= n; i++)
    {
        string tmp1 = "0123456789";
        // string tmp2="9876543210";
        if (i == 1)
            mt(tmp1, 0); //,mt(tmp2,0);
        for (int j = i; j >= 1; j--)
        {
            swap(tmp1[pr[j].first - 1], tmp1[pr[j].second - 1]);
            // swap(tmp2[pr[j].first-1],tmp2[pr[j].second-1]);
            mt(tmp1, i - j + 1);
            // mt(tmp2,i-j+1);
        }
    }
    int k, tp;
    while (m--)
    {
        string g1 = "0000000000";
        // string g2="0000000000";
        scanf("%d", &k);
        for (int i = 0; i < k; i++)
        {
            scanf("%d", &tp);
            tp--;
            g1[i] = tp + '0';
            // g2[i]=9-tp+'0';
        }
        tp = ck(g1, k);
        // cout<<g1<<' '<<g2<<endl;
        // tp=min(ck(g1,k),ck(g2,k));
        printf("%d\n", (tp == 5000) ? -1 : tp);
    }
    return 0;
}