HOJ 2133&POJ 2964 Tourist（动态规划）

Tourist
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 1503 Accepted: 617
Description

A lazy tourist wants to visit as many interesting locations in a city as possible without going one step further than necessary. Starting from his hotel, located in the north-west corner of city, he intends to take a walk to the south-east corner of the city and then walk back. When walking to the south-east corner, he will only walk east or south, and when walking back to the north-west corner, he will only walk north or west. After studying the city map he realizes that the task is not so simple because some areas are blocked. Therefore he has kindly asked you to write a program to solve his problem.

Given the city map (a 2D grid) where the interesting locations and blocked areas are marked, determine the maximum number of interesting locations he can visit. Locations visited twice are only counted once.
Input

The first line in the input contains the number of test cases (at most 20). Then follow the cases. Each case starts with a line containing two integers, W and H (2 ≤ W, H ≤ 100), the width and the height of the city map. Then follow H lines, each containing a string with W characters with the following meaning:

‘.’ Walkable area
‘*’ Interesting location (also walkable area)
‘#’ Blocked area

You may assume that the upper-left corner (start and end point) and lower-right corner (turning point) are walkable, and that a walkable path of length H + W - 2 exists between them.
Output

For each test case, output a line containing a single integer: the maximum number of interesting locations the lazy tourist can visit.
Sample Input

2
9 7
*……..
…..**#.
..*…#
..####*#.
..#.*#.
…#**…
*……..
5 5
...
*###.
..*
.###*
...
Sample Output

7
8

经常写这种在一个矩阵里从左上角走到右下角，只能向下和向右走，这种是一个水DP。这道题目就是这类题目的升级类型。就是走到右下角还要返回左上角，以前走过的景点返回时走过都不算。我一开始天真的以为先求左上角到右下角的DP，再把图变一下，求右下角到左上角的DP，这样第二个样例就过不了。所以就要换一种方式，去的和来的不能分开DP，只能将他们和在一起才能得到正确的解。看了题解，状态是DP[i][j][k],表示到第i条斜线，去的路的横坐标是j，来的路的横坐标是k。还有的解法是i是第几步。
可以看出，如果一道题目的解法是动态规划，那么一定有其相应的状态转移方程，不能局限于题目的给的条件，

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <math.h>

using namespace std;
int dp[205][105][105];
int n,m;
int t;
char a[105][105];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&m,&n);
        for(int i=0;i<n;i++)
            scanf("%s",a[i]);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=m+n-1;i++)
        {
            for(int j=0;j<n;j++)
            {
                for(int k=0;k<n;k++)
                {
                    int y1=(i-1)-j;
                    if(y1<0)
                        continue;
                    if(y1>=m)
                        continue;
                    int y2=(i-1)-k;
                    if(y2<0)
                        continue;
                    if(y2>=m)
                        continue;
                    if(a[j][y1]=='#'||a[k][y2]=='#')
                    {dp[i][j][k]=0;continue;}
                    int ans=-2;
                    if(j-1>=0)
                        ans=max(ans,dp[i-1][j-1][k]);
                    if(k-1>=0)
                        ans=max(ans,dp[i-1][j][k-1]);
                    if(k-1>=0&&j-1>=0)
                        ans=max(ans,dp[i-1][j-1][k-1]);
                    ans=max(ans,dp[i-1][j][k]);
                    if(ans==-1)
                    {dp[i][j][k]=-1;continue;}
                    else
                        dp[i][j][k]=ans;
                    if(a[j][y1]=='*'&&y1!=y2)
                        dp[i][j][k]++;
                    if(a[k][y2]=='*'&&y1!=y2)
                        dp[i][j][k]++;
                    if(a[k][y2]=='*'&&a[j][y1]=='*'&&y1==y2)
                        dp[i][j][k]++;
                }
            }
        }
        printf("%d\n",dp[m+n-1][n-1][n-1]);


    }
    return 0;
}