dp选做

P1356 数列的整除性

考虑暴力，每个数可能被加上或减去，所以复杂度 $O(2^n)$。

所以考虑dp，令 $f_{i,j}$ 为选取了前 $i$ 个数后除 $k$ 是否有余数为 $j$。

所以目标状态是 $f_{n,0}$。

那么我们考虑转移：

因为 $a \bmod b+c \bmod b=(a+c) \bmod b.$

所以我们易得 $f_{i,j}=f_{i-1,(j-a[i]) \bmod k} || f_{i-1,(j+a[i]) \bmod k}.$ 

最后处理一下边界即可。

代码：

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>

using namespace std;

const int N=1e4+10;
const int M=1e2+10;

int a[N],n,k,t;
bool f[N][M];

int main(){
    scanf("%d",&t);
    while(t--){
        memset(f,0,sizeof(f));
        scanf("%d %d",&n,&k);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        f[0][0]=1;
        f[1][(a[1]%k+k)%k]=1;f[1][(-a[1]%k+k)%k]=1;
        for(int i=2;i<=n;i++){
            for(int j=0;j<k;j++){

                f[i][j]=(f[i-1][((j+a[i]%k)+k)%k])||(f[i-1][(j-a[i]%k+k)%k]);
            }
        }
        if(f[n][0]==1) printf("Divisible\n");
        else printf("Not divisible\n");
    }
    return 0;
}

---

CF467C George and Job

我们定义状态 $f_{i,j}$ 为前i个数选了j组后的最大值。

对于一个区间 $x-{i-m},x_{i-m+1}…x_i$ 我们如果选择不选，则直接继承上一个的状态。

否则我们的状态就应从 $f_{i-m,j-1}$ 处转移，因为我们比这个位置的数多了 $m$ 个数，$1$ 个区间。

然后加上 $\sum_{k=(i-m+1)}^{i} x_k $，而这个值很容易用前缀和维护。

最后，在枚举时注意下标的起始，避免出现负下标。

时间复杂度 $O(nk)$。

#include<cstdio>
#include<iostream>

using namespace std;

#define ll long long 
const int N=5e3+10;
ll sum[N],f[N][N];
ll n,m,k,x[N];

int main(){
    scanf("%lld %lld %lld",&n,&m,&k);
    for(int i=1;i<=n;i++){
        scanf("%lld",&x[i]);
        sum[i]=sum[i-1]+x[i];
    }
    for(int j=1;j<=k;j++){
        for(int i=j*m;i<=n;i++){
            f[i][j]=max(f[i-1][j],f[i-m][j-1]+sum[i]-sum[i-m]);
        }
    }
    printf("%lld",f[n][k]);
    return 0;
}

P1352 没有上司的舞会

树形dp基础题。

定义一个状态 $f_{i,0/1}$ 为第 $i$ 个点选或不选时它的最大贡献。

我们考虑第 $i$ 个点贡献不选为 $0$，选了就为本身的点权，这就是初始化。

接着从根节点开始枚举，如果选的话子树都不能选，不选的话子树有选或不选两种状态。

枚举到 $max$ 后向上合并即可，最后状态即为根节点选或不选。

#include<cstdio>
#include<iostream>

using namespace std;

const int N=6e3+10; 
int cnt,n,r[N],fa[N],u,v,root;
int f[N][2];
struct edge{
    int to,nxt;
}e[N];
int head[N];

void add(int u,int v){
    cnt++;
    e[cnt].to=v;
    e[cnt].nxt=head[u];
    head[u]=cnt;
}

void sou(int node){
    for(int i=head[node];i;i=e[i].nxt){
        int k=e[i].to;
        sou(k);
        f[node][0]+=max(f[k][1],f[k][0]); 
        f[node][1]+=f[k][0];
    }
}

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&r[i]);
        f[i][1]=r[i]; 
    } 
    for(int i=1;i<n;i++){
        scanf("%d %d",&u,&v);
        fa[u]++;
        add(v,u);
    }
    for(int i=1;i<=n;i++) if(!fa[i]) root=i;
    sou(root);
    printf("%d",max(f[root][1],f[root][0]));
    return 0;
}

 P3478 [POI2008] STA-Station

算换根dp板子罢（

两遍dfs算子树和父亲的贡献。函数名致敬同级大佬（

#include<cstdio>
#include<iostream> 

#define int long long

using namespace std;

const int N=1e6+10;
int dis[N<<1],dep[N<<1],siz[N<<1]; 
int n,u,v,cnt,ans,maxn=-1;
struct tree{
    int to,nxt;
}e[N<<1];
int head[N<<1];

void add(int u,int v){
    cnt++;
    e[cnt].to=v;
    e[cnt].nxt=head[u];
    head[u]=cnt; 
}

void sou1(int u,int fa){
    siz[u]=1;
    for(int i=head[u];i;i=e[i].nxt){
        int to=e[i].to;
        if(to==fa) continue;
        dep[to]=dep[u]+1;
        sou1(to,u);    
        siz[u]+=siz[to];
    }
}

void sou2(int u,int fa){
    for(int i=head[u];i;i=e[i].nxt){
        int to=e[i].to;
        if(to==fa) continue;
        dis[to]=dis[u]-2*siz[to]+siz[1];
        sou2(to,u);
    }
}

signed main(){
    scanf("%lld",&n);
    for(int i=1;i<n;i++){
        scanf("%lld %lld",&u,&v);
        add(u,v);
        add(v,u);
    }
    sou1(1,0);
    for(int i=1;i<=n;i++)dis[1]+=dep[i];
    sou2(1,0);
    for(int i=1;i<=n;i++){
        if(dis[i]>maxn){
            ans=i;
            maxn=dis[i];
        }
    }
    printf("%lld",ans);
    return 0;
}

P2899 [USACO08JAN]Cell Phone Network G

树形dp。

对于树上的一个点而言他可以被父亲覆盖，被自己覆盖，被儿子覆盖。

被父亲覆盖：那么他的儿子就不能被父亲覆盖（因为没信号。

被自己覆盖：儿子怎样都可以。

被儿子覆盖：它的儿子也不能选父亲，但它的儿子中至少要有一个自己有信号，所以加个变量处理。

式子可以推出变量 $k$ 可以处理掉儿子中没有一个有的的情况并转变为选他自己。

#include<cstdio>
#include<iostream>

using namespace std;

const int N=1e4+10;
const int inf=0x7ffffff;
struct edge{
    int nxt,to;
}e[N<<1];
int head[N];
int n,u,v,cnt;
int dp[N][3];

void add(int u,int v){
    cnt++;
    e[cnt].nxt=head[u];
    e[cnt].to=v;
    head[u]=cnt;
}


int minn(int x,int y,int z){
    int k=x<y?x:y;
    return k<z?k:z;
}

void sou(int fa,int u){
    int k=inf;
    for(int i=head[u];i;i=e[i].nxt){
        int v=e[i].to;
        if(v==fa) continue;
        sou(u,v);
        dp[u][0]+=min(dp[v][1],dp[v][2]);
        dp[u][1]+=minn(dp[v][1],dp[v][0],dp[v][2]);
        dp[u][2]+=min(dp[v][1],dp[v][2]);
        k=min(k,dp[v][1]-min(dp[v][2],dp[v][1]));
    }
    dp[u][2]+=k;
    dp[u][1]+=1;
}

int main(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        scanf("%d %d",&u,&v);
        add(u,v);
        add(v,u);
    }
    sou(0,1);
    printf("%d",min(dp[1][1],dp[1][2])); 
    return 0; 
} 

P3146 [USACO16OPEN]248 G

区间dp

定义状态 $f_{l,r}$ 表示区间 $[l,r)$ 合并后能得到的最大值。

枚举断点即可。

注意初始化和细节。

时间复杂度 $O(n^3)$ 可以跑过。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

const int N=250;
int f[N][N];
int n,a[N],ans=0;

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",f[i]+i);
        ans=max(ans,f[i][i]);//初始化ans防止不能合并
    } 
    for(int len=2;len<=n;len++){
        for(int i=1;i+len-1<=n;i++){//枚举区间 
            int j=len+i-1;
            for(int k=i;k<j;k++){//枚举断点 
                if(f[i][k]==f[k+1][j]&&f[i][k]/*防止没更新到也算进去*/){ 
                    f[i][j]=max(f[i][j],f[i][k]+1);
                    ans=max(ans,f[i][j]);//由于答案不一定全部能合并，所以每一次记录一下最小值 
                }
            }
        }
    }
    printf("%d",ans);
    return 0;
}