2024初三年后集训模拟测试3

卡布叻_周深2024-02-21 22:02

前言

难度不好说，感觉是东拼西凑的题，但是除了 \(T1\) 都相当不简单。

  • \(T1~100pts:\)

    签到题，贪心即可。

  • \(T2~70pts:\)

    读假题了，是最大 \(w_i\) 不是固定 \(w_i\) ，做法是 二分答案+DP ，不过需要单调队列优化，不会这玩意儿赛后学了好久 \(qwq\) 。

    但是读假题了还能拿 \(70pts\) 。

  • \(T3~0pts:\)

    不会，想到了树形 \(DP\) ，但建树都没建明白。

    题解给了一半，正解没给，给了个复杂度 \(O(n^2)\) 的要过 \(3e5\) ，差评！

  • \(T4~0pts:\)

    本来人手骗 \(20pts\) 的，\(continue\) 加错地方了，喜提 \(0pts\) 。

    题解更加抽象，教练发现快吃晚饭了还没有人 \(A\) ，直接又把代码放里面了；至今 2024年02月21日20:55:27 还是没人 \(A\) ，又搞来一份详细题解，把代码加上了注释。

    可怜其良苦用心，但那篇题解码风太抽象了......

T1 排序

  • 题意：

    给定 \(4n\) 个数 \(s_i\) ，分别 \(n\) 组，对于每组 \(4\) 个数 \(a,b,c,d\) ，求所有组 \(|ab-cd|\) 的最大和。

  • 解法：

    • 导入一个常识：

      已知 \(s\) ，将其拆分为 \(s=a+b\) ，若想 \(a\times b\) 尽可能小，则 \(|a-b|\) 尽可能大；若想 \(a\times b\) 尽可能大，则 \(|a-b|\) 尽可能小。

      和相同周长的 \(S_{正方形}>S_{长方形}\) 是一个道理。

    先将所有 \(s_i\) 排序，设 \(ab>cd\) 。

    将所有 \(s_i\) 分为大的和小的两组，\(a,b\) 相邻搭配，\(c,d\) 分别从两边取即可。

    直接看代码就行了，签到题。

点击查看代码

cpp 复制代码 
#include<bits/stdc++.h>
#define int long long 
#define endl '\n'
using namespace std;
const int N=4e5+10;
template<typename Tp> inline void read(Tp&x)
{
    x=0;register bool z=1;
    register char c=getchar();
    for(;c<'0'||c>'9';c=getchar()) if(c=='-') z=0;
    for(;'0'<=c&&c<='9';c=getchar()) x=(x<<1)+(x<<3)+(c^48);
    x=(z?x:~x+1);
}
int n,a[N],ans,sum;
signed main()
{
	#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif
    read(n);
    for(int i=1;i<=4*n;i++)
        read(a[i]);
    stable_sort(a+1,a+1+4*n);
    for(int i=1,j=4*n;i<=n,j>=2*n+1;i++,j-=2)
        ans+=a[j]*a[j-1]-a[i]*a[2*n-i+1];
    cout<<ans;
}

T2 牛吃草

  • 题意：

此处注意他是延伸距离最大为 \(w_i\) ，不是固定 \(w_i\) ，赛时因为这个读假题了 \(qwq\) 。

  • 部分分：

    • \(70pts:\)

      读假题的情况，二份答案+ \(O(n)的DP\) 。

      定义 \(f[i][1]\) 为第 \(i\) 个位置上放的最大覆盖长度，反之 \(f[i][0]\) 就是不放的情况。

      转移方程为:

      \(f[i][1]=\max(f[i-len[i]][1],f[i-len[i]][0])+len[i];\)

      \(f[i][0]=\max(f[i-1][1],f[i-1][0])\) 。

      此处 \(len_i\) 为其真实的 \(w_i\) ，因为他左端点顶到头就 \(1\) 了，再往前就负了，比如不管 \(w_1\) 为多少，\(len_1\) 都 \(=1\) 。

      因为读假题了， \(DP\) 自然成 \(O(n)\) 了。

      复杂度最坏情况下 \(O(n\log(n))\) ，实则只要 \(f_i>=s\) 就说明满足，跳出就行了，所以真实复杂度远小于此。
      点击查看代码

      cpp 复制代码 
      #include<bits/stdc++.h>
#define int long long 
#define endl '\n'
using namespace std;
const int N=5e5+10;
template<typename Tp> inline void read(Tp&x)
{
    x=0;register bool z=1;
    register char c=getchar();
    for(;c<'0'||c>'9';c=getchar()) if(c=='-') z=0;
    for(;'0'<=c&&c<='9';c=getchar()) x=(x<<1)+(x<<3)+(c^48);
    x=(z?x:~x+1);
}
int n,s,l,r,maxx,mid,ans,w,f[N][2];
struct aa
{
    int l,len;
}a[N];
bool DP(int x,int s)
{
    for(int i=1;i<=n;i++)
        f[i][0]=f[i][1]=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i].len>=x) 
            f[i][1]=max(f[a[i].l-1][1],f[a[i].l-1][0])+a[i].len;
        f[i][0]=max(f[i-1][1],f[i-1][0]);
        if(f[i][1]>=s||f[i][0]>=s) return 1;
    }
    return 0;
}
signed main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif
    read(n);
    for(int i=1;i<=n;i++) 
        read(w),
        a[i].l=max(1ll,i-w+1),
        a[i].len=i-a[i].l+1,
        maxx=max(maxx,a[i].len);
    read(s);
    s=ceil(double(n*s/100.0));
    l=1,r=maxx;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(DP(mid,s)) ans=max(ans,mid),l=mid+1;
        else r=mid-1;
    }
    cout<<ans;
}

    • \(90pts:\)

      把题读真了，发现还需要套一层循环。

      循环 \(j=\{i-len_i\sim i-size\}\) ，那么转移方程为：

      \(f[i][1]=\max(\{f[i][1],f[j][1]+i-j,f[j][0]+i-j\});\)

      \(f[i][0]\) 和 \(70pts\) 的一样。

      这样复杂度最坏就成了 \(O(n^2\log(n))\) ，虽然真实情况比这小，但还是会 \(TLE\) 两个点。
      点击查看代码

      cpp 复制代码 
      #include<bits/stdc++.h>
#define int long long 
#define endl '\n'
using namespace std;
const int N=5e5+10;
template<typename Tp> inline void read(Tp&x)
{
    x=0;register bool z=1;
    register char c=getchar();
    for(;c<'0'||c>'9';c=getchar()) if(c=='-') z=0;
    for(;'0'<=c&&c<='9';c=getchar()) x=(x<<1)+(x<<3)+(c^48);
    x=(z?x:~x+1);
}
int n,s,l,r,maxx,mid,ans,w,f[N][2];
struct aa
{
    int l,len;
}a[N];
bool DP(int x,int s)
{
    f[0][0]=f[0][1]=0;
    for(int i=1;i<=n;i++)
    {
        f[i][1]=0;
        for(int j=i-a[i].len;j<=i-x;j++)
            f[i][1]=max({f[i][1],f[j][1]+i-j,f[j][0]+i-j});
        f[i][0]=max(f[i-1][1],f[i-1][0]);
        if(f[i][1]>=s||f[i][0]>=s) return 1;
    }
    return 0;
}
signed main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif
    read(n);
    for(int i=1;i<=n;i++) 
        read(w),
        a[i].l=max(1ll,i-w+1),
        a[i].len=i-a[i].l+1,
        maxx=max(maxx,a[i].len);
    read(s);
    s=ceil(double(n*s/100.0));
    l=1,r=maxx;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(DP(mid,s)) ans=max(ans,mid),l=mid+1;
        else r=mid-1;
    }
    cout<<ans;
}

  • 正解：

    在 \(90pts\) 的做法上使用单调队列优化 \(DP\) 。

    ∵ 题目数据范围中给了 \(w_{i-1}\geq w_i-1\) ，

    ∴ \(i-1-w_{i-1}\leq i-1-(w_i-1)\) ，

    ∴ \(i-1-w_{i-1}\leq i-w_i\) 。

    由此，可以使用单调队列优化 \(DP\) 。

    至于这玩意之前给跳了 \(qwq\) ，反正会的肯定会的。
    点击查看代码

    cpp 复制代码 
    #include<bits/stdc++.h>
#define int long long 
#define endl '\n'
using namespace std;
const int N=5e5+10;
template<typename Tp> inline void read(Tp&x)
{
    x=0;register bool z=1;
    register char c=getchar();
    for(;c<'0'||c>'9';c=getchar()) if(c=='-') z=0;
    for(;'0'<=c&&c<='9';c=getchar()) x=(x<<1)+(x<<3)+(c^48);
    x=(z?x:~x+1);
}
int n,s,l,r,maxx,mid,ans,w,f[N][2],t,head,tail,len[N];
struct aa
{
    int id,num;
}q[N];
bool DP(int x,int s)
{
    head=1,tail=0;
    f[0][1]=f[0][0]=0;
    for(int i=1;i<=n;i++)
    {
        f[i][0]=f[i][1]=0;
        if(i>=x)
        {
            t=max(f[i-x][1],f[i-x][0])+n-(i-x);
            while(head<=tail&&q[tail].num<t) tail--;
            q[++tail].num=t;
            q[tail].id=i-x;
            while(head<=tail&&q[head].id<i-len[i]) head++;
        }
        f[i][0]=max(f[i-1][1],f[i-1][0]);
        f[i][1]=max(f[i][1],(head>tail?0:q[head].num)+i-n);
        if(f[i][1]>=s||f[i][0]>=s) return 1;
    }
    return 0;
}
signed main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif
    read(n);
    for(int i=1;i<=n;i++) 
        read(w),
        l=max(1ll,i-w+1),
        len[i]=i-l+1,
        maxx=max(maxx,len[i]);
    read(s);
    s=ceil(double(n*s/100.0));
    l=1,r=maxx;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(DP(mid,s)) ans=max(ans,mid),l=mid+1;
        else r=mid-1;
    }
    cout<<ans;
}

T3 树上的宝藏

  • 题意：

    对于一颗数上有 \(n\) 个节点，每个节点上填入 \(1\) 或 \(0\) ，\(n-1\) 条边。

    每个普通的边连接的两点最多只能有一个 \(1\) ，也就是 \([1,0],[0,1],[0,0]\) 三种情况。

    每个特殊的边连接的两点最少必须有一个 \(1\) ，也就是 \([1,0],[0,1],[1,1]\) 三种情况。

    求在第 \(i\) 条边为特殊边，其余为普通边的情况下可行的情况数量。

  • 部分分：

    • \(30pts:\) 纯暴力。

    • \(60pts:\)

      树形 \(DP\) 显然，下面说思路：

      对于第 \(i\) 条边，将其两节点 \(a,b\) 分别为根拆成两棵树，在每棵树上跑树形 \(DP\) 。

      定义 \(f[i][1]\) 为以 \(i\) 为根的数（子树）\(i\) 处为 \(1\) 的情况数，同样的 \(f[i][0]\) 就是 \(i\) 处为 \(0\) 的情况数。

      结合对于题意的分析，若根节点为 \(1\) ，则子节点必须为 \(0\) ；若根节点为 \(0\) ，则子节点可以为 \(1\) 或 \(0\) 。

      那么便有了转移方程，设 \(u,v\) 分别为根节点和叶节点：

      \(f[u][1]\times =f[v][0]\) ；

      \(f[u][0]\times =(f[v][1]+f[v][0])\) 。

      而问题来到怎么打又儿子向父亲传的树形 \(DP\) ：

      先跑一遍 \(dfs\) ，处理出每个节点的 \(son\) 与 \(father\) ，然后根据此来跑树形 \(DP\) 就可以了，具体的看代码就理解了。

      最后处理答案：

      现在以 \(a,b\) 为根的树都处理完了，需要将他们合并。

      结合上面题意的分析，特殊边时，有 \(3\) 中情况：\([1,1],[1,0],[0,1]\) 。

      对应的，\(ans=f[a][1]\times f[b][1]+f[a][1]\times f[b][0]+f[a][0]\times f[b][1]\) 。

      就结束了，别忘了 \(\bmod ~P=998244353\) 。

      最后分析复杂度：不难发现要从 \(1\sim n-1\) 每次都要跑 \(dfs\) 和树形 \(DP\) ，每次都是 \(O(n)\) 的，这样复杂度就成了 \(O(n^2)\) 。
      点击查看代码

      cpp 复制代码 
      #include<bits/stdc++.h>
#define int long long 
#define endl '\n'
using namespace std;
const int N=3e5+10,P=998244353;
template<typename Tp> inline void read(Tp&x)
{
    x=0;register bool z=1;
    register char c=getchar();
    for(;c<'0'||c>'9';c=getchar()) if(c=='-') z=0;
    for(;'0'<=c&&c<='9';c=getchar()) x=(x<<1)+(x<<3)+(c^48);
    x=(z?x:~x+1);
}
int n,x,y,tx[N],ty[N],f[N][2],ans,father[N];
vector<int>e[N],son[N];
void dfs(int x,int fa)
{
    for(int y:e[x])
    {
        if(y==fa) continue;
        father[y]=x;
        son[x].push_back(y);
        dfs(y,x);
    }
}
void dp(int x)
{
    if(!son[x].size())
    {
        f[x][0]=f[x][1]=1;
        return ;
    }
    for(int y:son[x])
        dp(y),
        (f[x][1]*=f[y][0])%=P,
        (f[x][0]*=(f[y][0]+f[y][1]))%=P;
}
signed main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif
    read(n);
    for(int i=1;i<n;i++)
        read(x),read(y),
        e[x].push_back(y),
        e[y].push_back(x),
        tx[i]=x,ty[i]=y;
    for(int i=1;i<n;i++)
    {
        int a=tx[i],b=ty[i];
        for(int j=0;j<=n;j++) 
            father[j]=f[j][0]=f[j][1]=1,
            son[j].clear();
        dfs(a,b),dp(a);
        dfs(b,a),dp(b);
        ans=(f[a][1]*f[b][1])%P+(f[a][1]*f[b][0])%P+(f[a][0]*f[b][1])%P;
        cout<<ans%P<<endl;
    }
}

  • 正解：

    和上面思路是类似的，但是解决了上面要跑 \(n-1\) 遍 \(dfs,DP\) 的问题。

    先跑两边 \(dfs\) 和树形 \(DP\) ，转移方程和上面都是一样的，处理出 \(f[i][0||1],r[i][1||0]\)。

    然后就是处理答案;

    在 \(a,b\) 合并的同时去掉 \(b\) 对 \(a\) 的影响，这里默认 \(a,b\) 分别为父亲节点和子节点。

    去除影响的思路参考上面就可以了，就是把 \(b\) 对 \(a\) 的贡献除去。

    \(ans=\dfrac{f[a][1]\times f[b][1]}{f[b][0]}+\dfrac{f[a][1]\times f[b][0]}{f[b][0]}+\dfrac{f[a][0]\times f[b][1]}{f[b][0]+f[b][1]}\) 。

    这样有了除法又有模数，需要乘法逆元。

    思路就是这样的，可能有点模棱两可，可以去问 \(wkh\) ，他讲的正解，官方题解里压根没有正解。

    至于代码实现不会，因为不会处理第二遍 \(dfs\) 的换根问题，想要代码可以找 \(wkh\) 。

    复杂度比上面少了一个 \(n\) ，\(O(n)\) 。

    另外的思路跳转 @Ishar-zdl 。

    2024年02月21日21:53:38 ，\(T3\) 的官方题解被教练放进去了，(⊙o⊙)...，就是这份 \(\large{↑}\) 。

相关推荐
陈琦煜2 天前
AcWing 1073 树的中心 树形dp （详解）
动态规划·树形dp
dengqingrui1231 个月前
【树形DP】AT_dp_p Independent Set 题解
c++·学习·算法·深度优先·图论·dp
疯狂的小强呀1 个月前
超详细讲解：DP和DDP的区别以及使用方法
算法·dp·ddp
Jcqsunny1 个月前
[dp] 小信走迷宫
算法·前缀和·动态规划·dp
源代码•宸2 个月前
Leetcode—322. 零钱兑换【中等】（memset(dp,0x3f, sizeof(dp))
c++·算法·leetcode·职场和发展·dp
Qres8212 个月前
[SCOI2014] 方伯伯的玉米田（dp+树状数组维护行列）
数据结构·dp·ds
源代码•宸2 个月前
Leetcode—72. 编辑距离【中等】
c++·算法·leetcode·dp
WJX5742 个月前
最长公共子序列
dp
sweetheart7-72 个月前
LeetCode152. 乘积最大子数组（2024秋季每日一题 2）
数据结构·算法·动态规划·dp·每日一题
源代码•宸3 个月前
Leetcode—1143. 最长公共子序列【中等】
c++·经验分享·算法·leetcode·dp
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play