Shulou(Shulou.com)06/02 Report--

This article mainly introduces "the use of Java combination number". In the daily operation, I believe that many people have doubts about the use of Java combination number. The editor consulted all kinds of data and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "the use of Java combination number". Next, please follow the editor to study!

Start with the title.

The original title is:

> A robot is located in the upper-left corner of a m x n grid (the starting point is marked "Start" in the following figure).

The robot can only move down or to the right one step at a time. The robot attempts to reach the lower right corner of the grid (labeled "Finish" in the following image).

> how many different paths are there in total?

> for example, the above image is a 7 x 3 grid. How many possible paths are there?

> Note: the values of m and n are no more than 100.

> example 1:

> > input: M = 3, n = 2

> > output: 3

> > explanation:

> > starting from the upper left corner, a total of 3 paths can reach the lower right corner.

> > 1. Right-> right-> Down

> > 2. Right-> Down-> right

> > 3. Down-> right-> right

> example 2:

> > input: M = 7, n = 3

> > output: 28

Positive thinking

Let's think about it in a normal way of thinking, when you are at the starting point, you have two choices, right or down, unless you are in the bottom row or the rightmost column, then you have only one choice (for example, in the bottom row. You can only go right). Other positions, you have two choices.

So, based on this idea, we can write code:

Class Solution {public int uniquePaths (int m, int n) {/ / Special case: the starting point is the end if (m = = 1 & & n = = 1) {return 1;} / / the end point is (1) return walk (1) return walk (1) } public int walk (int x, int y, int m, int n) {/ / already at the end if (x > = m & & y > = n) {return 0;} / / in the bottom row or the rightmost row of if (x > = m | y > = n) {return 1 } / / how many walks are there int down = walk (XMague y + 1, mMagna); / / how many walks are there int right = walk (x + 1, y, mMagne n) when you go to the right; / / how many walks are optimized from the current (xMague y) to (m.jue n) to return down + right;}}

Let's consider whether there is any room for optimization in this way of writing.

You should find at a glance that the first judgment if of the walk method (x > = m & & y > = n) can never be true, because the next judgment if (x > = m | | y > = n) is already a critical point, and there is already a return value directly, which is impossible to reach x > = m & y > = n. Therefore, the judgment can be deleted.

Suppose we start from the position of (1) and the end point is (3), what are the ways to get to the middle point (2)? Two kinds, first to (1) and then to (2), or (2) to (2) and then to (2)

Therefore, according to the way we wrote above, from (2p2) to the end (3p3), we will count twice, although this idea itself is correct, but this situation should be optimized. Because there are only 6 paths from (1) to (3), but there are already 2 repetitive paths, so as m and n become larger and larger, there will be more and more intermediate points, so there will be more and more repetitive paths.

This is that the front choice will have an impact on the latter choice, even if the latter choice is the same, but because the previous choice is different, it is also considered to be a different choice.

Obviously, the latter choice is more unique, and if we make the choice first, we can reduce the number of recalculation. Therefore, we can try the reverse way of thinking.

Reverse train of thought

If we do not start from the starting point, but go back from the end to the starting point. Suppose the end point is (3p3), it can only be directly reached by (2p3) and (3mag2), (2p3) can only be directly reached by (2p2) and (1p3), (1p3) can only be directly reached by (1p2), (1p2) can only be directly reached by (1jue 1), so (1p3) can only be directly reached by (1p1).

We can draw a rule: except for the points in the leftmost column and the top row, which can only be reached directly from the starting point (1), the other points (xmemy) are directly reached by (xmai 1) and (xmemy 1).

So, according to this idea, we can write code:

Class Solution {public int uniquePaths (int m, int n) {int [] [] result = new int [m] [n]; int j; for (int I = 0; I

< m; i++) { for (j = 0; j < n; j++) { if (i == 0 || j == 0) { // 最上面一排的点和最左边一列的点，只能由(1,1)到达 result[i][j] = 1; } else { // 其他的点都可以由左边的点和上面的点到达 result[i][j] = result[i - 1][j] + result[i][j - 1]; } } } return result[m - 1][n - 1]; }} 其实这样的想法就已经是动态规划的范畴了，我们看看维基上的定义 >

Dynamic programming (English: Dynamic programming, referred to as DP) is a method used in mathematics, management science, computer science, economics and bioinformatics to solve complex problems by decomposing the original problem into relatively simple sub-problems.

At first I feel a lot like divide-and-conquer, because you need to break down a big problem into sub-problems, but divide-and-conquer eventually merges the sub-problems, but dynamic planning doesn't.

Optimize

Let's consider whether there is any room for optimization in this way of writing.

The first is spatial optimization. Do we have to use two-dimensional arrays? Can I use an one-dimensional array instead?

The answer is yes, because the calculation of each point is only related to the adjacent points on the left and above, so no longer points are needed.

One-dimensional array

If you only use an one-dimensional array, you only need to store the results of the previous row, and if you calculate to the next row, replace them in turn, with the code as follows:

Class Solution {public int uniquePaths (int m, int n) {int [] dp = new int [m]; int j; for (int I = 0; I

< n; i++) { for(j = 0; j < m; j++) { if(j == 0) { dp[j] = 1; } else { // 其他的点都可以由左边的点和上面的点到达 dp[j] += dp[j-1]; } } } return dp[m-1]; }} 这样的优化，差不多就结束了。那我们是否可以从思路上进行优化呢？ 组合数 因为我们只有向右或向下两种选择，而我们一共要走的路径其实是(m-n-2)，其中有(m-1)的路径是向右，(n-1)的路径是向下，其实可以转变为： >

Pick out (mmur1) from (m-n-2), that is, the value of the combinatorial number C ((m-n-2), (mmur1))

Then we can write the code:

Class Solution {public int uniquePaths (int m, int n) {/ / use double, because the calculated value will be very large double num = 1, denom = 1; / / find a smaller number, which can reduce the number of calculations and the calculated value int small = m > n? N: M; for (int I = 1; I

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.