HDU - 1208 Pascal's Travels

Pascal's Travels Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 2443    Accepted Submission(s): 1156 Problem Description An n x n game board is populated with integers, one nonnegative integer per square. The goal is to travel along any legitimate path from the upper left corner to the lower right corner of the board. The integer in any one square dictates how large a step away from that location must be. If the step size would advance travel off the game board, then a step in that particular direction is forbidden. All steps must be either to the right or toward the bottom. Note that a 0 is a dead end which prevents any further progress.  Consider the 4 x 4 board shown in Figure 1, where the solid circle identifies the start position and the dashed circle identifies the target. Figure 2 shows the three paths from the start to the target, with the irrelevant numbers in each removed.  Figure 1 Figure 2   Input The input contains data for one to thirty boards, followed by a final line containing only the integer -1. The data for a board starts with a line containing a single positive integer n, 4 <= n <= 34, which is the number of rows in this board. This is followed by n rows of data. Each row contains n single digits, 0-9, with no spaces between them.   Output The output consists of one line for each board, containing a single integer, which is the number of paths from the upper left corner to the lower right corner. There will be fewer than 2^63 paths for any board.    Sample Input 4 2331 1213 1231 3110 4 3332 1213 1232 2120 5 11101 01111 11111 11101 11101 -1   Sample Output 3 0 7 Hint Hint Brute force methods examining every path will likely exceed the allotted time limit. 64-bit integer values are available as "__int64" values using the Visual C/C++ or "long long" values using GNU C/C++ or "int64" values using Free Pascal compilers.

题意：

       从迷宫的左上角走到右下角。你可以往右或者往下走k格，k为当前点的值。求走到右下角一共有多少条路。

题解：

       利用动态规划的思想。举个例子：

       设一个dp数组存储到当前点的路数，由图可知map[3][4],map[4][3],map[4][1]可以到达map[4][4]，所以 dp[4][4]=dp[4][3]+dp[3][ 4]+dp[4 ][1]， 这样我们只需要知道dp[4][3]，dp[3][4]和dp[4][1]就行了。我们再看有那些点可以到达dp[4][3]，dp[3][4]和dp[4][1]，还按照上面的规则逐步划 分子问题。直到推到dp[1][1]=1，也就是将dp[1][1]初始化为1，可以认为dp[1][1]到dp[1][1]有一条路。

       上面说的是逆向思维，可以用递归来实现。然而我用的是正向思维，可以用循环来实现。假设a点可以到达b点，那么b点的路数就应该 加上到达a点的路数，假设c点也可以到达b点，那么b点的路数就应该再加上可以到达c点的路数。由于dp数组开的比较大，所以加到map界限 外面也没事。

注意：

       遍历到最后一点需要跳过去，如果不跳过去会发生一些非常诡异的事情。为了调这个bug我很奔溃。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#define INT __int64
using namespace std;
int n,map[40][40];
INT dp[100][100];
int main()
{
    while(scanf("%d",&n) && n!=-1)
    {
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                scanf("%1d",&map[i][j]);
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
            {
                if(i==n-1 && j==n-1)
                    continue;
                int now=map[i][j];
                dp[i+now][j]+=dp[i][j];
                dp[i][j+now]+=dp[i][j];
            }
        printf("%lld\n",dp[n-1][n-1]);
    }
    return 0;
}