Question

给出一个M X N矩阵，其初始位置在左上角单元格中，找到从初始位置到达矩阵右下角单元格的可能唯一路径的数量。
在任何时间点，可能的移动都可以向下或向右。

对于M = 5，N = 11的输入。正确的输出应该是1001。
不同的IDE的输出是不同的。

 #include<stdio.h>

 int div(int tot,int j,int n,int m)
 {
      int i;
      int fn=1;
      int fd=1;
      int f=1;
      int p;
      for(i=tot;i>=j;i--)
      {
              fn=fn*i;
      }
      for(i=n;i>=1;i--)
      {
              fd=fd*i;
      }
      p=fn/fd;

      for(i=j-1;i>=m+1;i--)
              f=f*i;
              p=p*f;

              return p;


}



int main()
{
              int M,N;
              int unqPath;
              int i,T;
              int j,path;
              int m,n;
              int flag=0;
              scanf("%d",&T);

              for(i=0;i<T;i++)
              {
                      scanf("%d",&M);
                      scanf("%d",&N);

                      if(M>=N)
    {
        path=1;
        for(j=(M-1)+(N-1);j>(M-1);j--)
        {

            path=path*j;
            if(path<=0)
            {

                unqPath=div(((M-1)+(N-1)),j+1,N-1,M-1);
                flag=1;
                printf("\n\n%d",unqPath);
                break;
            }

        }



        if(flag==0)
        {

            n=1;
            for(j=(N-1);j>=1;j--)
            {


                n=n*j;
            }

            unqPath=path/n;
            printf("%d",unqPath);
        }
    }
    else
    {
        path=1;
        for(j=(M-1)+(N-1);j>(N-1);j--)
        {


            path=path*j;
            if(path<=0)
            {
                unqPath=div((M-1)+(N-1),j+1,M-1,N-1);
                flag=1;
                printf("%d",unqPath);
                break;
            }
        }
        if(flag==0)
        {


            m=1;
            for(j=(M-1);j>=1;j--)
            {

                m=m*j;
            }
            unqPath=path/m;

            printf("\n%d",unqPath);
        }
    }
}

    return 0;
}

Answer 1

您的程序太复杂。您应该首先研究构建路径以获取时间的方式。

在给定点x，y时，您可以向下或向右移动。因此，从这一点开始的路径数是向下或向右移动时路径数的总和。
特殊情况是指该点位于只有一条路径的边界上。

因此，您将获得以下代码以及该计算的递归实现：

#include <stdio.h>

// cells are numbered (1..xmax, 1..ymax)
// x an y are position of points
// xmax and ymax are the rectangle size
int nbrpaths(int x, int y, int xmax, int ymax)
{
  if(x==xmax || y==ymax) return 1; // On a south or east border ->
                                   // only one solution: go straight right or down
  return nbrpaths(x+1,y,xmax,ymax)   // go right and find a path 
        + nbrpaths(x,y+1,xmax,ymax); // go down and find a path
}

int main()
{
  int xmax=5, ymax=11, x=1, y=1;
  int nbr=nbrpaths(x,y,xmax,ymax);
  printf("number of paths: %d\n",nbr);
}
// prints: number of paths: 1001

Answer 2

如果矩阵为n x m，则唯一路径的数量为（n + m-2）！/（（n-1）！（m-1）！）。您只需编写该公式即可。

请参阅Wikipedia中的Combination。

Answer 3

您可以这样看：

当您位于左上角并向下移动时，您将获得一个新的矩阵，其中行数少了1列，列数相同。

当您位于左上角并向右移动1格，然后向下移动时，您将得到一个新的矩阵，其行数减少了1，列数减少了。

当您在左上角移动2个垂直点然后向下移动时，您将得到一个新的矩阵，其中行数减少了1列，列数减少了2列。

以此类推。

因此，要计算（R，C）矩阵的结果，可以将其计算为多个较小矩阵的结果之和。喜欢：

count(R, C) = count(R-1, C-0) + count(R-1, C-1) + count(R-1, C-2) + ... + count(R-1, 1)

这可以通过递归来处理。像这样：

#include <stdio.h>

int count(int r, int c)
{
  if (r == 1) return 1;
  if (c == 1) return 1;
  int sum = 0;
  for (int i=0; i < c; ++i)
  {
      sum += count(r-1, c-i);
  }

  return sum;
}

int main()
{
  int r=5, c=11;
  int res=count(r,c);
  printf("Result: %d\n", res);
}

查找矩阵中唯一路径的数量

3 个答案: