这道题题目的意思是找图中的路径的数量。
一开始想着把这个图构造成一棵树（二叉树），这样看叶子节点有多少个是终点就可以判断有多少条路径了。
于是做了一个结构体：
struct baseData {
int x; //横向偏移
int y; //纵向偏移
baseData* bottom;
//下方链接
baseData* right;
//右方链接
};
还有一个 vector<baseData*>
toDo; 用来存储没有遍历过的节点
接下来就处理toDo，直至其中不包含任何元素。处理过程如下：
baseData* head =
new
baseData();
head->x =
0;
head->y =
0;
toDo.push_back(head);
while (toDo.size()>0) {
//取出最上面的一个指针
baseData* top = toDo[toDo.size()-1];
toDo.pop_back();
//如果是终点，则进行下一次循环
if (top->x == XNUMBER-1 && top->y == YNUMBER-1) {
PATHCOUNT++;
continue;
}
//右侧一个是0
if (top->y<XNUMBER-1 && obstacleGrid[top->x][top->y+1]==0)
{
baseData* right =
new baseData();
right->x = top->x;
right->y = top->y+1;
toDo.push_back(right);
top->right = right;
}else{
top->right =
NULL;
}
//下侧一个是0
if (top->x<YNUMBER-1 && obstacleGrid[top->x+1][top->y]==0)
{
baseData* bottom =
new baseData();
bottom->x = top->x+1;
bottom->y = top->y;
toDo.push_back(bottom);
top->bottom = bottom;
}else{
top->bottom =
NULL;
}
//释放访问过的存储空间
//delete top;
}
return PATHCOUNT;
刚开始没有释放处理过的节点的内存，结果除了 堆栈溢出的问题。于是做了delete top的处理。
但是又报了一个，超时的问题。这一下子，这样的做法就完全行不通了。分析了一下,应该是频繁的new 和 delete消耗了大量的时间，尤其是当数据量比较大时尤为明显。
于是换了一个思路，既然只要一个数目。那么终点的路径数目取决于其左侧和上侧的路径的数目之和，这样就减少很多时间和上的开销。
实现如下：
int XNUMBER = obstacleGrid.size();
int YNUMBER = obstacleGrid[0].size();
vector<vector<int>> grid(obstacleGrid.size(),vector<int>(obstacleGrid[0].size()));
//计算第一个
grid[0][0] = obstacleGrid[0][0] ==
0 ? 1:0;
//计算第一行
for (int i=1; i<YNUMBER; i++) {
if (obstacleGrid[0][i]==0) {
grid[0][i] = grid[0][i-1];
}else{
grid[0][i] =
0;
}
}
//计算第一列
for (int j=1;j<XNUMBER ; j++) {
if (obstacleGrid[j][0]==0) {
grid[j][0] = grid[j-1][0];
}else{
grid[j][0] =
0;
}
}
//计算其他
for (int i=1; i<XNUMBER; i++) {
for (int j=1; j<YNUMBER; j++) {
if (obstacleGrid[i][j]==0) {
grid[i][j] = grid[i-1][j]+grid[i][j-1];
}else{
grid[i][j]=0;
}
}
}
return grid[XNUMBER-1][YNUMBER-1];