qbxt Day3 DP+DP+贪心

最新推荐文章于 2024-07-23 21:48:21 发布

cgoldsss

最新推荐文章于 2024-07-23 21:48:21 发布

阅读量367

点赞数 1

CC 4.0 BY-SA版权

分类专栏：考试 dp

本文链接：https://blog.youkuaiyun.com/qq_36312502/article/details/78155941

dp 同时被 2 个专栏收录

18 篇文章

订阅专栏

考试

14 篇文章

订阅专栏

本文详细介绍了树形DP和线性DP的应用及实现技巧。针对树形DP，文章给出了具体的算法流程，包括子树大小计算、父子节点确定等，并通过实例展示了如何求解节点间距离和等问题。对于线性DP，不仅提供了传统DP方法，还分享了一种创新的解决方案，通过维护特定状态来简化计算过程。

非树边——> 返祖边；

T1

这里写图片描述

树形DP?
复杂度O(n)~;
topsort(防爆栈)，或dfs处理树的信息，并求出拓扑序;
因为topsort+dfs更清晰（我作死），所以我都用了；

思路：

以1为根处理树上信息：子树大小，父结点；

f[x]:表示x的子节点到x距离和;
f[x]=f[v]+sz[v], v为x的儿子；
原因：v到x的有一条边，总和要加sz[v]*1,

g[x]:除子节点以外的所有点到x的距离和；
g[x]=g[fa[x]]+sz[1]-sz[fa[x]]+f[j]+sz[j]*2; j为兄弟，
原因：画图很清晰;
g[fa[x]]+sz[1]-sz[fa[x]]很显然；
sz[j]*2：x兄弟到x距离为2;

O(n)预处理，O(n)DP；

总结：
需要多练;

注意：
1.需要初始化1的父亲0；
2.第100行有两种情况；
3.DP的边界;

吐槽：
1.需要加手读优化（许多人没加，还没开始就超时了 hh~~）；
2.除了第一、二个测试点，其他全是极限数据10^6;
3.四个测试点答案是66666，一点也不6！！！ QAQ；

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN=2000001;
int fst[MAXN],nxt[MAXN],sz[MAXN],f[MAXN],g[MAXN],deep[MAXN];
int tot,n,num,root=1,sx[MAXN],fa[MAXN];
bool vis[MAXN];
struct hh
{
    int from,to;
}ma[MAXN];
void read(int &a)
{
    int ss=0,flag=1;
    char c=getchar();
    while(c<'0' || c>'9')
    {
        if(c=='-') flag=-1;
        c=getchar();
    }
    while(c>='0' && c<='9') ss=ss*10+c-'0',c=getchar();
    a=ss*flag;
    return;
}
void build(int f,int t)
{
    tot++;
    ma[tot]=(hh){f,t},nxt[tot]=fst[f];
    fst[f]=tot;
    return;
}
void dfs(int x,int f)
{
    sz[x]=1,fa[x]=f;
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==f) continue;
        dfs(v,x),sz[x]+=sz[v];
    }
    return;
}
void topsort()
{
    queue<int>q;
    q.push(1),vis[1]=1;
    sx[++num]=1;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=fst[x];i;i=nxt[i])
        {
            int v=ma[i].to;
            if(!vis[v])
            {
                q.push(v);
                vis[v]=1;
                sx[++num]=v;
            }
        }
    }
    return;
}
void solve()
{
    read(n);
    for(int i=1;i<n;i++)
    {
        int x,y;
        read(x),read(y);
        build(x,y);
        build(y,x);
    }
    dfs(1,0);
    topsort();
    memset(f,0,sizeof(f)),memset(g,0,sizeof(g));
    for(int i=num;i>=1;i--)
    {
        int x=sx[i];
        for(int j=fst[x];j;j=nxt[j])
        {
            int v=ma[j].to;
            if(v==fa[x]) continue;
            f[x]+=f[v]+sz[v];
        }
    }
    sz[0]=sz[1]+1;
    f[0]=f[1]+sz[1];
    for(int i=1;i<=num;i++)
    {
        int sum=0,tot=0;
        int x=sx[i];
        for(int j=fst[fa[x]];j;j=nxt[j])
        {
            int v=ma[j].to;
            if(v==x || v==fa[fa[x]]) continue;
            sum+=f[v],tot+=sz[v];
        }
        g[x]=g[fa[x]]+sz[root]-sz[fa[x]]+1+sum+2*tot;
    }
    int ans=-1,ans2;
    for(int i=1;i<=n;i++)
    {
        if(ans<f[i]+g[i])
        {
            ans=f[i]+g[i];
            ans2=i;
        }
    }
    cout<<ans2;
}
int main()
{
    solve();
    return 0;
}

T2：

这里写图片描述

O(n)的DP

注意：
因为可能答案<0;
注意初始化！！！！

总结：
对于答案可能<0的题要初始化为极小值（注意边界）；

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=100001,inf=2147438647;
typedef long long ll;
ll dp1[MAXN],dp2[MAXN],f1[MAXN],f2[MAXN];
ll n,a[MAXN],ans=-inf;
void solve()
{
    cin>>n;
    for(ll i=1;i<=n;i++) scanf("%lld",&a[i]);
    dp1[0]=dp2[n+1]=f1[0]=f2[n+1]=-inf;
    for(ll i=1;i<=n;i++)
    {
         dp1[i]=max(a[i],dp1[i-1]+a[i]);
         f1[i]=max(f1[i-1],dp1[i]);
         dp2[n-i+1]=max(a[n-i+1],dp2[n-i+2]+a[n-i+1]);
         f2[n-i+1]=max(f2[n-i+2],dp2[n-i+1]);
    }
    for(ll i=1;i<=n;i++) ans=max(ans,f1[i]+f2[i+1]);
    cout<<ans<<endl;
}
int main()
{
    solve();
    return 0;
}

还有一种做法，自己乱搞出来了（注意边界！！！）；
复杂度O(n)；
answer=max {ans[i]-ans[j]+ans[k]-ans[v]};

所以维护四个数值：
s1:第一段区间前面的数的和，ans[v]；
s2:第一段区间的和的最大值，ans[k]-ans[v];
s3: -ans[j]+ans[k]-ans[v]；
s4:两段区间的和的最大值，ans[i]-ans[j]+ans[k]-ans[v]；

先更新s4，保证其他数均在它前面，s3，s2同理；

边界：
s2,s3,s4设为极小值；

对于s1分类讨论:
若a[1]>0 则选上a[1]不会让答案更小,所以此时的s2=a[1]，s1=0；
若a[1]<0 则选上a[1]一定不会让答案更大,所以此时s2中不包含a[1];

ps. 当然若全为负，但a[1]最大，就另当别论了，此时算法是O（nlogn），需要特判，~~我懒得写了~~;

这种解法还需要特判n=2的情况；

所以直接DP更好；

~~这种方法也不差~~

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int a[1000001],n,inf=214748364,ans[1000001];
int s1,s2=-inf,s3=-inf,s4=-inf,sum;
void solve()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]),ans[i]=ans[i-1]+a[i];
    if(a[1]<0) s1=a[1];
    else s1=0;
    if(n==2) {cout<<ans[2];return;}
    for(int i=2;i<=n;i++)
    {
        s4=max(ans[i]+s3,s4);
        s3=max(-ans[i]+s2,s3);
        s2=max(ans[i]-s1,s2);
        s1=min(ans[i],s1);
    }
    cout<<s4<<endl;
    return;
}
int main()
{
    solve();
    return 0;
}

T3

这里写图片描述

以后再想