UVA - 1629 Cake slicing 递归记忆化搜索

原创于 2020-01-22 22:15:46 发布 · 205 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#算法 #动态规划

紫书第九章动态规划专栏收录该内容

37 篇文章

订阅专栏

本文介绍了一种基于动态规划的网格蛋糕最小切割算法，通过计算网格中特定区域的樱桃数量，确定将蛋糕切割成含有樱桃的块所需的最小切割长度。算法使用四维DP数组存储中间结果，避免重复计算，提高了效率。

问题

分析

这题还是比较明显的，状态就是网格,dp[r1][r2][c1]][c2]表示行坐标[r1,r2],列坐标[c1,c2]间的的网格蛋糕的最小切割长度
状态转移方程：
按照行来切： $d p [r 1] [r 2] [c 1] [c 2] = m i n ((c 2 - c 1 + 1) + d p [r 1] [i] [c 1] [c 2] + d p [i + 1] [r 2] [c 1] [c 2]) (r 1 < = i < r 2)$
按照列来切： $d p [r 1] [r 2] [c 1] [c 2] = m i n ((r 2 - r 1 + 1) + d p [r 1] [r 2] [c 1] [j] + d p [r 1] [r 2] [j + 1] [c 2]) (c 1 < = j < c 2)$

注意：不能切出一块没有樱桃的蛋糕
2 10 2
1 1
2 1
Case 1: 10

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <utility>
using namespace std;
const int maxn=22,Inf=100000000;
//cnt[i,j]是[1，1]到[i，j]方块中的樱桃数量，one[i,j]是[i,j]这一列从[i,1]到[i，j]的樱桃数量
int cherry[maxn][maxn],dp[maxn][maxn][maxn][maxn],cnt[maxn][maxn],one[maxn][maxn],n,m,k,kase=0; //dp[r1][r2][c1][c2]
//pair<int,int> cherry[maxn*maxn];

void init(){
    memset(cnt,0,sizeof(cnt));
    memset(one,0,sizeof(one));
    for(int i=1;i<=n;++i){
        for(int j=1;j<=m;++j){
            one[i][j]=one[i-1][j]+cherry[i][j];
        }
    }
    for(int i=1;i<=n;++i){
        for(int j=1;j<=m;++j){
            cnt[i][j]=cnt[i][j-1]+one[i][j];
        }
    }
}
//计算方块[r1,r2,c1,c2]中的樱桃数量
inline int count(int r1,int r2,int c1,int c2){
    return cnt[r2][c2]+cnt[r1-1][c1-1]-cnt[r1-1][c2]-cnt[r2][c1-1];
}

int DFS(int r1,int r2,int c1,int c2){
//    if(r2<r1 || c2<c1) return 0;
    int &ans=dp[r1][r2][c1][c2];
    if(ans>=0) return ans;

    int t=count(r1,r2,c1,c2);
    if(r2==r1 || c2==c1) return t-1;
    if(t==0) return ans=Inf;
    if(t==1) return ans=0;
    ans=Inf;
    for(int i=r1;i<r2;++i){
        if(count(r1,i,c1,c2) && count(i+1,r2,c1,c2))
            ans=min(ans,c2-c1+1+DFS(r1,i,c1,c2)+DFS(i+1,r2,c1,c2));
    }
    for(int i=c1;i<c2;++i){
        if(count(r1,r2,c1,i) && count(r1,r2,i+1,c2))
            ans=min(ans,r2-r1+1+DFS(r1,r2,c1,i)+DFS(r1,r2,i+1,c2));
    }
    return ans;
}

int main(void){
    while(cin>>n>>m>>k){
        int a,b;
        memset(cherry,0,sizeof(cherry));
        for(int i=0;i<k;++i){
            scanf("%d%d",&a,&b);
            cherry[a][b]=1;
        }
        init();
        memset(dp,-1,sizeof(dp));
        printf("Case %d: %d\n",++kase,DFS(1,n,1,m));
    }
    return 0;
}

优化了一下计算樱桃数量的数组，删除了one数组

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <utility>
using namespace std;
const int maxn=22,Inf=100000000;
//cnt[i,j]是[1，1]到[i，j]方块中的樱桃数量
int dp[maxn][maxn][maxn][maxn],cnt[maxn][maxn],n,m,k,kase=0; //dp[r1][r2][c1][c2]
//pair<int,int> cherry[maxn*maxn];
//计算cnt[i,j]的值，为下一步count函数做准备
void init(){
    for(int i=1;i<=n;++i){
        for(int j=1;j<=m;++j){
            cnt[i][j]=cnt[i][j]+cnt[i][j-1]+cnt[i-1][j]-cnt[i-1][j-1];
        }
    }
}
//计算方块[r1,r2,c1,c2]中的樱桃数量
inline int count(int r1,int r2,int c1,int c2){
    return cnt[r2][c2]+cnt[r1-1][c1-1]-cnt[r1-1][c2]-cnt[r2][c1-1];
}

int DFS(int r1,int r2,int c1,int c2){
//    if(r2<r1 || c2<c1) return 0;
    int &ans=dp[r1][r2][c1][c2];
    if(ans>=0) return ans;

    int t=count(r1,r2,c1,c2);
    if(r2==r1 || c2==c1) return t-1;
    if(t==0) return ans=Inf;
    if(t==1) return ans=0;
    ans=Inf;
    for(int i=r1;i<r2;++i){
        ans=min(ans,c2-c1+1+DFS(r1,i,c1,c2)+DFS(i+1,r2,c1,c2));
    }
    for(int i=c1;i<c2;++i){
        ans=min(ans,r2-r1+1+DFS(r1,r2,c1,i)+DFS(r1,r2,i+1,c2));
    }
    return ans;
}

int main(void){
    while(cin>>n>>m>>k){
        int a,b;
        memset(cnt,0,sizeof(cnt));
        for(int i=0;i<k;++i){
            scanf("%d%d",&a,&b);
            cnt[a][b]=1;
        }
        init();
        memset(dp,-1,sizeof(dp));
        printf("Case %d: %d\n",++kase,DFS(1,n,1,m));
    }
    return 0;
}