qbxt Day3 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

以后再想