Algorithm 矩阵中通过频率获得的总特殊值

我有一个二维有序矩阵（M x N），其中所有单元格都包含0，除了K个特殊单元格，其中包含一个特殊值，比如1。现在我需要从单元格开始，比如说（0，0），然后到达单元格（M-1，N-1）。我只能从任何单元格向右或向下移动。现在我需要在（M-1，N-1）单元格中找到每一个成功到达的地方，我收集了多少特殊值，它们的频率是多少？例如：我可以有3条路径只包含一个特殊值，我有10条路径包含2个特殊值。。。等等

我需要以相应的频率打印所有可能获得的总特殊值对，即：；（2，10）-表示有2条路径，每条路径的总特殊值为10，以此类推

似乎要找出从源到目标的所有dfs路径，并计算从源到目标获得的总特殊值的频率。但它的时间复杂度非常高

如何最小化时间复杂度，或者如果可能，如何在这里使用动态规划概念

例如：

0 0 0
0 1 1
0 0 0 

• 这里有2条路径的总特殊值=2，只有1条路径的总特殊值=0，3条路径的总特殊值=1，以此类推

---

在这个问题中，通过简单地变换图形，很容易消除可能的路径

---

将矩阵转换为有向图，其中每个节点都是一个特殊值。每个节点

（nx，ny）

仅与其他节点

（mx，my）

连接，这些节点匹配

nx。在这个问题中，通过简单地变换图形，很容易消除可能的路径

将矩阵转换为有向图，其中每个节点都是一个特殊值。每个节点
（nx，ny）
仅与其他节点连接
（mx，my）
，匹配
nx的节点不知道您是否仍然需要它，但找到了一种非常快速的方法（时间复杂度小于
O（W+H）
）：

首先，通过查找向右移动次数的移动次数的二项式系数（
c（W+H-2，W-1）
），找到可能的路径数，然后迭代每个路径，存储点以备以后使用。
代码：

//
//main.c
//
//由Xavier L'Heureux于2001年10月15日创作。
//
//这段代码返回矩阵中每个可能值的路径数，其中您只能
//向下或向右。
//
//请注意，此代码也适用于非平方矩阵
//
#包括
#包括
#定义w3
#定义h4
整数矩阵[W][H]={
{0,0,0,0},
{0,0,1,1},
{0,0,0,0}
};
整数路径（双p，双n）{
int x=W-1，y=H-1；
积分=0；
而（x！=0 | | y！=0）{
//printf（“\np:%f\nn:%f\n”，p，n）；
如果（x==0）{
y--；
点+=矩阵[x][y]；
}如果（y==0），则为else{
x--；
点+=矩阵[x][y]；
}否则，如果（p/n>=y/（双）（x+y））{
p-=n*y/（x+y）；
n-=n*y/（x+y）；
点+=矩阵[x][y]；
x--；
}否则{
n-=n*x/（x+y）；
点+=矩阵[x][y]；
y--；
}
}
返回点；
}
双c（整数n，整数k）{
双x=1.0；
int i；
对于（i=n；i>（n-k）；i--）{
x*=i；
}
对于（i=1；i不知道您是否仍然需要它，但找到了一种非常快速的方法（时间复杂度小于
O（W+H）
）：

首先，通过查找向右移动次数的移动次数的二项式系数（
c（W+H-2，W-1）
），找到可能的路径数，然后迭代每个路径，存储点以备以后使用。
代码：

//
//main.c
//
//由Xavier L'Heureux于2001年10月15日创作。
//
//这段代码返回矩阵中每个可能值的路径数，其中您只能
//向下或向右。
//
//请注意，此代码也适用于非平方矩阵
//
#包括
#包括
#定义w3
#定义h4
整数矩阵[W][H]={
{0,0,0,0},
{0,0,1,1},
{0,0,0,0}
};
整数路径（双p，双n）{
int x=W-1，y=H-1；
积分=0；
而（x！=0 | | y！=0）{
//printf（“\np:%f\nn:%f\n”，p，n）；
如果（x==0）{
y--；
点+=矩阵[x][y]；
}如果（y==0），则为else{
x--；
点+=矩阵[x][y]；
}否则，如果（p/n>=y/（双）（x+y））{
p-=n*y/（x+y）；
n-=n*y/（x+y）；
点+=矩阵[x][y]；
x--；
}否则{
n-=n*x/（x+y）；
点+=矩阵[x][y]；
y--；
}
}
返回点；
}
双c（整数n，整数k）{
双x=1.0；
int i；
对于（i=n；i>（n-k）；i--）{
x*=i；
}
对于（i=1；我可以为这个问题提供示例输入和输出吗？@abhishekbafna，请看帖子，刚刚添加了一个示例。你可以为这个问题提供示例输入和输出吗？@abhishekbafna，请看帖子，刚刚添加了一个示例。你能在代码中正确地编写最后几行吗？对于int j，使用distinct（[0，长度（点））表示[，[i]）如果y.x==n.x和p.y，但在生成相邻矩阵后，如何获得问题中所述的结果。我需要所有具有任何可实现的特殊值的路径及其频率。您必须通过一些图形分析来完成这一部分。此答案仅提供了一种减小图形大小从而加快搜索速度的方法您必须使用DFS或BFS自己进行计数。您能在代码中正确地写入最后几行吗？对于int j，使用distinct（[0，length（points）[，[i]）如果y.x==n.x和p.y，但在生成相邻矩阵后，我如何才能得到问题中所述的结果。我需要所有具有任何可实现的特殊值的路径及其频率。你必须通过一些图形分析来完成这部分。这个答案只有p
    int[][] matrix = getMatrix()
    int specialNumberCount = specialNumberCount()
    int m = getM(), n = getN()

    list points

    for int x in [0 , m[
        for int y in [0 , n[
            if(matrix[x][y] == specialValue())
                points.add(point(x , y));

    int[][] adjacencSpecial = new int[specialNumberCount][specialNumberCount];
    for int i in [0 , length(points)[
        point p = points.get(i)

        for int j in [0 , length(points)[
            if j == i
                continue
            else
                point s = points.get(j)
                if p.x <= s.x AND p.y <= s.y AND (p.x != s.x AND p.y != s.y)
                    adjacencMatrix[i][j] = 1

//
//  main.c
//
//  Created by Xavier L'Heureux on 15-10-01.
//
//  This code return the number of path for each possible value in the matrix where you can only
//   go down or right.
//
//  Note that this code work also for for non-square matrices
//

#include <stdio.h>
#include <stdlib.h>

#define W 3
#define H 4

int matrix[W][H] = {
    {0,0,0,0},
    {0,0,1,1},
    {0,0,0,0}
};

int path(double p, double n){
    int x = W - 1, y = H - 1;
    int points = 0;
    while (x != 0 || y != 0){
        //printf("\np: %f\nn: %f\n", p, n);
        if (x == 0){
            y --;
            points += matrix[x][y];
        } else if (y == 0){
            x --;
            points += matrix[x][y];
        } else if (p / n >= y / (double)(x + y)){
            p -= n * y / (x + y);
            n -= n * y / (x + y);
            points += matrix[x][y];
            x --;
        } else {
            n -= n * x / (x + y);
            points += matrix[x][y];
            y --;
        }
    }
    return points;
}

double c(int n, int k){
    double x = 1.0;
    int i;
    for (i = n; i > (n-k); i--){
        x *= i;
    }
    for (i = 1; i <= k; i++){
        x /= i;
    }
    return x;
}

int numOfPoints(){
    int points = 0;
    int x, y;
    for (x = 0; x < W; x++) {
        for (y = 0; y < W; y++) {
            points += matrix[x][y];
        }
    }
    return points;
}

int main (int argc, const char * argv[])
{
    int n = c(W + H - 2, W - 1);
    printf("%d path(s)",n);
    int maxPoints = numOfPoints() + 1;
    int *countPtr = (int *)calloc(maxPoints, sizeof (int));
    int i;
    for (i = 0; i < n; i++){
        countPtr[path(i, n)]++;
    }
    for (i = 0; i <= maxPoints; i++){
       printf("n° of path(s) with %d point(s) : \t%d\n", i, countPtr[i]);
    }
    free(countPtr);
    return 0;
}