leetCode系列----Unique Paths II

这道题题目的意思是找图中的路径的数量。

一开始想着把这个图构造成一棵树（二叉树），这样看叶子节点有多少个是终点就可以判断有多少条路径了。

于是做了一个结构体：

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];