Unique Path

　　参考文章：http://www.leetcode.com/2010/11/unique-paths.html

　　题目描述：给定一个m×n的方格，求方格（1，1）到点（m，n）的路径条数。路径只能向右或向下走。

　　文章中给出了三种算法：

　　算法1：最容易想到的也是最原始的回溯搜索算法，递归实现回溯。

　　算法2：由于在1回溯过程中，会做很多次重复计算。为了减少重复计算，使用动态规划中的备忘录算法，将已经计算出的值保存在数组中，使用这些值计算新的值。

　　算法3：自底向上的动态规划算法，也是最简洁的算法。

　　数学公式：高中排列组合的一道题，C(m+n-2,m-1)=C(m+n-2,n-1)

　　代码如下：

#include <iostream>
#include <cassert>

using namespace std;

//纯粹的回溯算法
int backtrack(int r,int c,int m,int n)
{
    if (r==m && c==n)
    {
        return 1;
    }
    if (r>m || c>n)
    {
        return 0;
    }
    return backtrack(r+1,c,m,n)+backtrack(r,c+1,m,n);
}

const int M_MAX=100;
const int N_MAX=100;
//使用dp备忘录改进回溯算法，减少重复计算
int dpbacktrack(int r,int c,int m,int n,int mat[][N_MAX+2])
{
    if (r==m && c==n)
    {
        return 1;
    }
    if (r>m || c>n)
    {
        return 0;
    }
    if (mat[r+1][c]==-1)    //等于-1说明还没有计算过
    {
        mat[r+1][c]=dpbacktrack(r+1,c,m,n,mat);
    }
    if (mat[r][c+1]==-1)
    {
        mat[r][c+1]=dpbacktrack(r,c+1,m,n,mat);
    }
    return mat[r+1][c]+mat[r][c+1];
}

int bt(int m,int n)
{
    int mat[M_MAX+2][N_MAX+2];
    for (int i=0;i<M_MAX+2;i++)
    {
        for (int j=0;j<N_MAX+2;j++)
        {
            mat[i][j]=-1;
        }
    }
    return dpbacktrack(1,1,m,n,mat);
}

//自底向上的dp算法
int dp(int m,int n)
{
    int mat[M_MAX+2][N_MAX+2]={0};
    mat[m][n+1]=1;
    for (int r=m;r>=1;r--)
    {
        for (int c=n;c>=1;c--)
        {
            mat[r][c]=mat[r+1][c]+mat[r][c+1];
        }
    }
    return mat[1][1];
}

int main()
{
    int m=7;
    int n=4;
    cout<<dp(m,n)<<endl;
    cout<<bt(m,n)<<endl;
    cout<<backtrack(1,1,m,n)<<endl;
    return 0;
}