Calculer la somme des éléments dans une matrice efficacement

Dans une interview, j'ai demandé si on m'a donné un n*m la matrice de la façon de calculer la somme des valeurs dans un sous-matrice (défini par haut-gauche, bas-droite de coordonnées).

M'a dit que je pouvais pré-processus de la matrice.

M'a dit que la matrice pourrait être énorme, et pourrait donc le sous-matrice de l'algo a dû être efficace. Je suis tombé un peu et n'a pas dit la meilleure réponse.

N'importe qui ont une bonne réponse?

est la matrice connue pour être fragmentées?
un quadtree, où chaque nœud contient la somme de ses enfants serait un soutien relativement facile de mettre à jour, mais pas aussi facile résumant comme la réponse la plus simple d'Alan.
La question commence par "Dans une interview, on m'a demandé". Alors non, pas de devoirs, à moins qu'il existe des situations où les devoirs d'une certaine manière est constitué d'entretiens...
Oups! 🙂
La matrice peut être dispersé ou dense, il a mentionné qu'il a besoin de travailler pour n'importe quel cas.

InformationsquelleAutor slippytoad | 2010-02-17

algorithm matrix

50

C'est ce qu'a Résumé la Zone Tables sont pour. http://en.wikipedia.org/wiki/Summed_area_table

Votre "prétraitement" étape consiste à construire une nouvelle matrice de même taille, où chaque entrée est la somme de la sous-matrice de la partie supérieure gauche de l'entrée. N'importe quel sous-matrice de la somme peut être calculée par la recherche du mixage et de seulement 4 entrées dans la SAT.

EDIT: Voici un exemple.

Pour la matrice initiale
```
0 1 4
2 3 2
1 2 7
```
La SAT est
```
0 1 5
2 6 12
3 9 22
```
La SAT est obtenu à l'aide de S(x,y) = (x,y) + S(x-1,y) + S(x,y-1) - S(x-1,y-1),

où S est la SAT et de matrice de a est la matrice initiale .

Si vous souhaitez calculer la somme de l'angle inférieur droit 2x2 sous-matrice, la réponse serait 22 + 0 - 3 - 5 = 14. Ce qui est évidemment le même que 3 + 2 + 2 + 7. Quelle que soit la taille de la matrice, la somme d'une sous-matrice peut être trouvé dans 4 des recherches et 3 de l'arithmétique de la fpo. La construction de la SAT est O(n), de la même façon, nécessitant seulement 4 recherches et 3 mathématiques ops par cellule.
- +1 Pour la bonne réponse. Je n'ai jamais entendu parler de ça avant. J'aurais lâché quelque chose avec un quadtree, mais c'est beaucoup mieux. C'est l'interview de trivia, à moins qu'ils voulaient quelqu'un qui savait (ou prétendu savoir) d'un algorithme particulier qui l'utilise.
- Merci Alan! Je n'ai jamais entendu parler d'un Résumé de la Zone de la Table et j'ai été à la programmation de 18 ans. J'ai dormi/bu jusqu'à l'Université si (my bad).
- J'ai été via cette idée depuis plusieurs années et jamais entendu le nom de "résumé de la zone tables" la mal écrite article de Wikipédia suggère que c'est un nom spécifique à la vision par ordinateur/graphiques champ. L'idée elle-même est assez naturel pour quelqu'un qui est familier avec la programmation dynamique, bien que trop naturel pour mériter un nom, peut-être.
- J'ai marqué ce "pas de réponse" que j'ai essayé d'appliquer l'algo définis dans le SAT wiki lien ci-dessus pour apandit l'exemple de la matrice ci-dessous: 0 1 4 2 3 2 1 2 7
- Voir ma réponse mis à jour si vous ne croyez pas que cela fonctionne. C'est assez simple, intro-à-algorithmes de trucs ici.
- C'est pourquoi l'algorithme de la section de StackOverflow est certainement le plus intéressant. Vous apprendre de nouveaux concepts de tous les jours.. seulement souhaite que je pourrais vous en souvenir.
- Votre commentaire est juste, mais le peu sur la programmation dynamique n'a tout simplement pas de sens. De toute façon, pourriez-vous partager ce que vous avez été à l'aide de cet algorithme?
- Il existe des dizaines de USACO les problèmes et les IOI problèmes (pour ne pas parler des problèmes des autres olympiades), à partir de la dernière 10 ans, qui utilisent l'idée de garder une somme cumulative (ce qui est tout c'est). C'est un assez standard DP truc. Sur le dessus de ma tête, voir, par exemple, le solution (2) Artemis de IOI 2004.
- S(x,y) = (x,y) + S(x-1,y) + S(x,y-1) - S(x-1,y-1) Il y a une soustraction en cause car lorsque nous ajoutons S[i][j-1] et S[i-1][j], S[i-1][j-1] est ajoutée deux fois que S[i-1][j-1] est commun dans les deux S[i][j-1] et S[i-1][j]...
InformationsquelleAutor Alan
5

Vous pouvez le faire par programmation Dynamique. Créer la matrice dp avec la taille n*m.
Et pour chaque i, j où
```
1 <= i <= n , 1 <= j <= m 
dp[i][j] will be : 

dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + values[i][j]
```
Et pour chaque requête, nous avons lx, rx, ly, ry où lx et rx sont en haut à gauche de coordonnées, ly et ry en bas à droite des coordonnées de la sous-matrice.
```
1 ≤ lxi ≤ rx ≤ n, 1 ≤ ly ≤ ry ≤ m

sum = dp[rx][ry]  - dp[lx - 1][ry] - dp[rx][ly - 1] + dp[lx-1][ly - 1]
```
Regarder la photo pour comprendre comment l'algorithme fonctionne.
```
OD = dp[rx][ry], OB = dp[lx - 1][ry], OC = dp[rx][ly - 1], OA = dp[lx - 1][ly - 1]
```
- C'est le meilleur moyen de cet algorithme peut être illustré! Merci! C'est exactement ce dont j'avais besoin!
InformationsquelleAutor Nurlan Sofiyev
3

Créer une nouvelle matrice où l'entrée (i,j) est la somme des éléments de la matrice d'origine qui ont inférieures ou égales i et j. Alors, pour trouver la somme des éléments de la submatrix, vous pouvez simplement utiliser un nombre constant d'opérations de base sur les coins de la submatrix de votre somme de la matrice.

En particulier, trouvez les coins top_left, bottom_left, top_right et bottom_right de votre somme de la matrice, où les trois premiers sont juste à l'extérieur de la submatrix et bottom_right est juste à l'intérieur. Ensuite, votre somme sera
```
bottom_right + top_left - bottom_left - bottom_right
```
- Dans ce cas, mon incompréhension réside avec ce qui est défini comme "prétraitement". Vous avez encore besoin du même nombre d'ajouts, n'importe quoi. Je comprends quand cette approche peut être utile, mais la question a fourni aucune information à ce sujet, le problème de contexte.
- Il n'y avait pas vraiment d'un contexte, juste une exigence que l'addition sera plus rapide que de simplement en boucle et en ajoutant. Prétraitement a été suggéré, mais pas à la mesure des quantités extrêmes de mémoire ou de stockage sont utilisés (par exemple la somme de tous les possibles de la matrice et de les stocker dans un x/y index).
- Salut Pierre, ne devrait pas le dernier "botton-droite "être" en haut à gauche' ?
InformationsquelleAutor Peter

Ci-dessous est un exemple d'implémentation en C en utilisant un Résumé de la Zone Tables concept comme l'explique l'une des réponses ci-dessus.

Python de mise en œuvre pour la même chose peut être trouvé au lien ci-dessous -
http://www.ardendertat.com/2011/09/20/programming-interview-questions-2-matrix-region-sum/

#include<stdio.h>

int pre[3][3];

int arr[3][3] = {
                {0,1,4},
                {2,3,2},
                {1,2,7}
                };

void preprocess()
{
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            if(i>0 && j>0)
            {
                 pre[i][j] = arr[i][j] + pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1];
            }
            else if(i>0 && j==0)
            {
                pre[i][j] = arr[i][j] + pre[i-1][j];
            }
            else if(j>0 && i==0)
            {
                pre[i][j] = arr[i][j] + pre[i][j-1];
            }
            else
            {
                pre[i][j] = arr[i][j];
            }                    
        }
    }
}

int subsum(int x1, int y1, int x2, int y2)
{
    preprocess();

    int ans = pre[x2][y2] - pre[x1-1][y2] - pre[x2][y1-1] + pre[x1-1][y1-1];
    return ans;
}

int main()
{            
    printf("%d\n",subsum(1,1,2,2));
    return 0;
}

pouvez-vous me dire quelles doses ce faire ? subsum(1,1,2,2)); quels sont ces nombres? 1 , 1 , 2 ,2 ?

InformationsquelleAutor learner

0

Cela devrait fonctionner. Vous avez toujours à aller à travers chaque élément de la submatrix à faire de plus et ce est la façon la plus simple.

*notez que le code suivant ne peut pas compiler, mais c'est en pseudocode
```
struct Coords{
    int x,y;
}

int SumSubMatrix(Coords topleft, Coords bottomright, int** matrix){
    int localsum = 0;
    for( int i = topleft.x; i <= bottomright.x; i++ ){
        for(int j = topleft.y; j <= bottomright.y; j++){
            localsum += matrix[i][j];
        }
    }
    return localsum;
}
 
```
Edit: Une solution de rechange pré-traitement de la méthode est de créer une autre matrice à partir de l'original contenant la ligne ou la colonne sommes. Voici un exemple:
Original:
```
0 1 4 
2 3 2 
1 2 7 
```
Ligne De La Matrice:
```
0 1 5 
2 5 7 
1 3 10 
```
Colonne De La Matrice:
```
0 1 4 
2 4 6 
3 6 13 
```
Maintenant, il suffit de prendre le point de terminaison de valeurs de x et de soustraire le point de départ des valeurs, de la sorte (pour les lignes de base):
```
for( int i = topleft.y; i >= bottomright.y; i++ ){
    localsum += matrix2[bottomright.x][i] - matrix2[topleft.x][i];
}
 
```
Maintenant, c'est soit O( n ) ou O( m )
- Dont la matrice est la matrice master2?
InformationsquelleAutor apandit

Vous devez vous connecter pour publier un commentaire.