记忆化搜索题目总结(1)

记忆化搜索题目总结1

一. 概述

算法上依然是搜索的流程，但是搜索到的一些解用动态规划的那种思想和模式作一些保存。在求解的时候还是按着自顶向下的顺序，但是每求解一个状态，就将它的解保存下来，以后再次遇到这个状态的时候，就不必重新求解了。这种方法综合了搜索和动态规划两方面的优点。

二. 引题

POJ1579 题目链接
if a <= 0 or b <= 0 or c <= 0, then w(a, b, c) returns 1
if a > 20 or b > 20 or c > 20, then w(a, b, c) returns w(20, 20, 20)
if a < b and b < c, then w(a, b, c) returnsw(a, b, c-1) + w(a, b-1, c-1) - w(a, b-1, c)
otherwise it returns w(a-1, b, c) + w(a-1, b-1, c) + w(a-1, b, c-1) - w(a-1, b-1, c-1)

DFS做法

long long dfs(int x, int y, int z)
{
    if(x <= 0 || y <= 0 || z <= 0){
        return  1;
    }
    if(x > 20 || y > 20 || z > 20){
        x = y = z = 20;
    }

    if(x < y && y < z){
        return dfs(x, y, z - 1) + dfs(x, y - 1, z - 1) - dfs(x, y - 1, z);
    } 
    else{
        return dfs(x - 1, y, z) + dfs(x - 1, y - 1, z) + dfs(x - 1, y, z - 1) - dfs(x - 1, y - 1, z - 1);

    } 
}

上述的dfs做法可以发现计算了大量的重叠子问题，如在计算dfs(4, 4, 4)和dfs(3, 4, 5)时都需要计算dfs(3, 4, 4),都会遍历dfs(3, 4, 4)这整颗子树，花费大量时间，因此我们想到将每个状态的值记录下来，以后求解时可以直接得到该值。

记忆化搜索解法

#include<iostream>
#include<cstring>
#include<stdio.h>
using namespace std;
long long dp[21][21][21];

long long dfs(int x, int y, int z)
{
    if(x <= 0 || y <= 0 || z <= 0){
        return  1;
    }
    if(dp[x][y][z]){
        return dp[x][y][z];
    }

    if(x < y && y < z){
        dp[x][y][z] = dfs(x, y, z - 1) + dfs(x, y - 1, z - 1) - dfs(x, y - 1, z);
    } 
    else{
        dp[x][y][z] = dfs(x - 1, y, z) + dfs(x - 1, y - 1, z) + dfs(x - 1, y, z - 1) - dfs(x - 1, y - 1, z - 1);

    } 
    return dp[x][y][z];
}
int main()
{
    int i;
    int x, y, z;
    memset(dp, 0, sizeof(dp));
    while(1)
    {
        cin >> x >> y >> z;
        if(x == -1 && y == -1 && z == -1)
        {
            break;
        }

        long long ans;
        if(x <= 0 || y <= 0 || z <= 0){
            ans = 1;
        }
        else if(x > 20 || y > 20 || z > 20){
            ans = dfs(20, 20, 20);
        }
        else{
            ans = dfs(x, y, z);
        }

        printf("w(%d, %d, %d) = %lld\n", x, y, z, ans);
    }
    return 0;
}

三. 例题

数字三角形

POJ1163 题目链接
给定一个由n行数字组成的数字三角形。试设计一个算法，计算出从三角形的顶至底的一条路径，使该路径经过的数字总和最大。
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

思路：
定义dp[i][j]为第i行第j列到底部的最大数字和，
状态转移方程为dp[i][j] = max(dp[i + 1][j]， dp[i + 1][j + 1]) + array[i][j]

#include<cmath>
#include<iostream>
using namespace std;

int a[10][10];
int d[10][10];

int dp(int i,int j,int n)
{
    if(d[i][j] > 0)
    return d[i][j];
    if(i == n-1)
    return a[i][j];
    else
    {
        return d[i][j] = a[i][j] + max(dp(i+1,j,n),dp(i+1,j+1,n));
    }

}
int main()
{
    int i,j,n;
    cin>>n;
    for(i=0; i<n; i++)
    for(j=0; j<=i; j++){
        cin>>a[i][j];
    } 

    for(i=0; i<n; i++)
    for(j=0; j<=i; j++){
        d[i][j]=0;
    } 

    dp(0,0,n);
    cout << d[0][0];
    return 0;

}

滑雪

POJ1088 题目链接
Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。

思路：
定义dp[i][j]为从第i行第j列到最后的最长长度
状态转移方程：dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i+1][j], dp[i][j+1]) + 1

#include<iostream>
using namespace std;
int array[101][101];
int dp[101][101];
int r, c;
int dict[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}}; //四个方向 

int dfs(int x, int y)
{
    if(dp[x][y] > 0){
        return dp[x][y];
    }

    dp[x][y] = 1;
    int i;
    for(i=0; i<4; i++)
    {
        int dx = x + dict[i][0];
        int dy = y + dict[i][1];

        if(dx >= 1 && dx <= r && dy >= 1 && dy <= c)
        {
            if(array[dx][dy] < array[x][y])
            {
                dp[x][y] = max(dp[x][y], dfs(dx, dy) + 1);
            }
        }
    }

    return dp[x][y];
 } 
int main()
{
    int i, j, k;
    cin >> r >> c;
    for(i=1; i<=r; i++)
    for(j=1; j<=c; j++)
    {
        cin >> array[i][j];
    }

    int maxx = 0;
    for(i=1; i<=r; i++)
    for(j=1; j<=c; j++)
    {
        int cur = dfs(i, j);
        if(cur > maxx){
            maxx = cur;
        }
    }

    cout << maxx << endl;
}

矩形嵌套

nyoj16 题目链接
有n个矩形，每个矩形可以用a,b来描述，表示长和宽。矩形X(a,b)可以嵌套在矩形Y(c,d)中当且仅当a < c, b < d或者b < c, a < d（相当于旋转X90度）。例如（1,5）可以嵌套在（6,2）内，但不能嵌套在（3,4）中。你的任务是选出尽可能多的矩形排成一行，使得除最后一个外，每一个矩形都可以嵌套在下一个矩形内。

定义d[i]为第i个矩阵可嵌套的最大个数，b[i][j]为第i个矩阵是否可以嵌套进第j个矩阵。
状态转移方程：d[i] = max(d[j] ) + 1，其中b[i][j] = 1;

#include<cmath>
#include<iostream>
using namespace std;
int a[1001][2];
int b[1001][1001];  //邻接矩阵 
int d[1001];  

int dp(int i, int n)
{
    if(d[i] > 0)
    return d[i];
    int j;
    d[i] = 1;
    for(j=0; j<n; j++)
    {
        if(b[i][j] == 1)
        {
            d[i] = max(d[i], dp(j,n)+1);
        }
    }
    return d[i];
}

//先构造图 
void init(int n)
{
    int i, j;
    for(i=0; i<n; i++)
    for(j=0; j<n; j++)
    {
        if((a[i][0] < a[j][0] && a[i][1] < a[j][1]) || 
            (a[i][0] < a[j][1] && a[i][1] < a[j][0]))
        b[i][j] = 1;
    }
}
int main()
{
    int N, n, i, j, k, max=0;
    cin >> N;
    for(i=1; i<=N; i++)
    {
        max = 0;
        cin >> n;
        for(j=0; j<n; j++)
        cin >> a[j][0] >> a[j][1];
        for(j=0; j<n; j++)
        for(k=0; k<n; k++){
            b[j][k] = 0;
        } 

        for(j=0; j<n; j++){
            d[j] = 0;
        } 

        init(n);
        for(j=0; j<n; j++){
            dp(j,n);
        } 

        for(j=0; j<n; j++){
            if(d[j] > max)
            {
                max = d[j];
            }
        } 

        cout << max << endl;
    }

}

硬币问题

题目：有n种硬币，面值分别为V1,V2,…Vn,每种都有无限多。给定非负整数S，可以选用多少个硬币，使得面值之和恰好为S？输出硬币数目的最小值。

思路：
定义d[s]为面值s到面值0最少可用的硬币数目
状态转移方程：d[s] = max(d[s - v[i]] + 1)，其中s >= v[i];

int dfs(int s)
{
    if(vis[s]){
        return dp[s];
    }
    dp[s] = -(1 << 30);
    int i;
    for(i=0; i<n; i++){
        if(s >= v[i])
        {
            dp[s] = max(dp[s], dfs(s - v[i]) + 1);
        }
    }
    return dp[s];
 }

New Year and Fireworks

具体可参看Codeforces Good Bye 2016部分题解第四题

参考文献：《算法竞赛入门经典》