河南萌新联赛2024第（三）场：河南大学

开心消消乐（Right Version）

思路：由于l只减小，不增加，所以每次操作都需要把后面的数操作完，也就是找重复字母字段有多少个，其中遇到0需要直接跳过，很简单的题，不知道为什么过的这么少。（好可惜）

代码：

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, t = -1;
    cin >> n;
    int ans = 0;
    for(int i = 0, x; i < n; ++i) {
        cin >> x;
        if (x != t) {
            t = x;
            if (x != 0) {
                ans++;
            }
        }

    }
    cout << ans << '\n';
    return 0;
}

区间

思路：线段数问题，关于区间和只需要用懒标记记录一下区间白色最长前缀，白色最长后缀，以及最后的答案。（还没系统的学线段树，下周继续补）

代码：

求值

思路：二分问题，首先枚举x，现在已知一个数x,如果我们让B>C，那么A*x+B*y+C*z的答案就是单调上升的函数，然后我们就只需要找到这个函数往下平移V格后，最接近x轴的值，所以直接二分就能出答案

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define N 100005
int a,b,c,n,v;
int ans;
int check(int x,int y){
    ans=min(abs(a*x+b*y+(n-x-y)*c-v),ans);
    return a*x+b*y+(n-x-y)*c-v;
}
void solve(){
    cin>>a>>b>>c>>n>>v;
    if(b<c) swap(b,c);
    ans = 1e18 + 1;
    for(int i=0;i<=n;i++){
        int l=0,r=n-i;
        int mid;
        while(l<=r){
            mid=(l+r)/2;
            if(check(i,mid)>0) r=mid-1;
            else l=mid+1;
        }
        
    }
    cout<<ans<<endl;
}
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T;
    cin>>T;
    while(T--) solve();
}

魔法

题解：用三维数组表示（i，j)位置，使用k次魔法剩余的最大生命值

状态转移方程：

 dp[i][j][k]=max({dp[i][j][k],dp[i][j-1][k]-a[i][j],dp[i-1][j][k]-a[i][j]});

 if(k>0) dp[i][j][k]=max({dp[i - 1][j][k - 1], dp[i][j - 1][k - 1], dp[i][j][k]});

代码：

#include<bits/stdc++.h>
using namespace std;
#define N 100005
int n,m,h;
int ans;
int a[3010][3010];
void solve(){
    cin>>n>>m>>h;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>a[i][j];
        }
    }
vector dp(n + 1, vector<vector<int>>(m + 1, vector<int>(n + m + 1)));//这个地方不能直接放在全局，内存超限和段错误
    dp[1][1][0]=h;

    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            for(int k=0;k<=m+n;k++){
                dp[i][j][k]=max({dp[i][j][k],dp[i][j-1][k]-a[i][j],dp[i-1][j][k]-a[i][j]});
                if(k>0) dp[i][j][k]=max({dp[i - 1][j][k - 1], dp[i][j - 1][k - 1], dp[i][j][k]});
            }
        }
    }
    for(int i=0;i<=m+n;i++)
    {
        if(dp[n][m][i]>0) {
            cout<<i<<endl;
            return ;
        }
    }
}
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
//    cin>>T;
    while(T--) solve();
    return 0;
}

暴食之史莱姆

题解：

一个史莱姆能吃掉的最大应该为两侧小于它体积的第一个的史莱姆能吃掉的个数 + 1。

因为吃掉这个更小的史莱姆后其体积就会变成这个小史莱姆的体积，所以小史莱姆能吃多少，那么它就能吃多少，在此基础上还能吃掉小史莱姆。

固定一边，用单调栈维护一下该边比当前史莱姆更小的第一个位置即可。

代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i ++)
        cin >> a[i];
    stack<int> st;
    vector<int> dp1(n + 1), dp2(n + 1);
    for (int i = 1; i <= n; i ++) {
        while (st.size() && a[st.top()] > a[i]) {
            st.pop();
        }
        if (st.size()) {
            dp1[i] = max(dp1[i], dp1[st.top()] + 1);
        }
        st.push(i);
    }
    while (st.size())st.pop();
    for (int i = n; i >= 1; i --) {
        while (st.size() && a[st.top()] > a[i]) {
            st.pop();
        }
        if (st.size()) {
            dp2[i] = max(dp2[i], dp2[st.top()] + 1);
        }
        st.push(i);
    }
    for (int i = 1; i <= n; i ++)
        cout << dp1[i] + dp2[i] << " \n"[i == n];
    return 0;
}