非树边——> 返祖边;
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
以后再想