不同路径问题

Unique Paths Problem

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

Examples

Example #1

Input: m = 3, n = 2
Output: 3
Explanation:
From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
1. Right -> Right -> Down
2. Right -> Down -> Right
3. Down -> Right -> Right

Example #2

Input: m = 7, n = 3
Output: 28


思路：
1.设置一个二维数组BOARD[N][N]
2.BOADR[0][ANY]=1,BOARD[ANY][0]=1因为只有一种路径
3.BOARD[i][j]=BOARD[i-1][j]+BOARD[i][j-1];
代码如下：

/**
 * DYNAMIC PROGRAMMING approach of solving Unique Paths problem.
 *
 * @param {number} width - Width of the board.
 * @param {number} height - Height of the board.
 * @return {number} - Number of unique paths.
 */
export default function dpUniquePaths(width, height) {
  // Init board.
  const board = Array(height).fill(null).map(() => {
    return Array(width).fill(0);
  });

  // Base case.
  // There is only one way of getting to board[0][any] and
  // there is also only one way of getting to board[any][0].
  // This is because we have a restriction of moving right
  // and down only.
  for (let rowIndex = 0; rowIndex < height; rowIndex += 1) {
    for (let columnIndex = 0; columnIndex < width; columnIndex += 1) {
      if (rowIndex === 0 || columnIndex === 0) {
        board[rowIndex][columnIndex] = 1;
      }
    }
  }

  // Now, since we have this restriction of moving only to the right
  // and down we might say that number of unique paths to the current
  // cell is a sum of numbers of unique paths to the cell above the
  // current one and to the cell to the left of current one.
  for (let rowIndex = 1; rowIndex < height; rowIndex += 1) {
    for (let columnIndex = 1; columnIndex < width; columnIndex += 1) {
      const uniquesFromTop = board[rowIndex - 1][columnIndex];
      const uniquesFromLeft = board[rowIndex][columnIndex - 1];
      board[rowIndex][columnIndex] = uniquesFromTop + uniquesFromLeft;
    }
  }

  return board[height - 1][width - 1];
}