Si deux solides sont compris entre deux plans parallèles, et que tout plan parallèle à ces deux plans coupe les deux solides selon des sections de même aire, alors les volumes des deux solides sont égaux.

Polygones Réguliers

Un polygone régulier est un polygone plan dont tous les côtés et tous les angles sont égaux. À l'exception du triangle équilatéral, les deux conditions (côtés égaux et angles égaux) sont nécessaires.

Les polyèdres formés de polygones réguliers se classent en cinq catégories : polyèdres réguliers, polyèdres semi-réguliers, prismes droits, antiprismes, et polyèdres de Johnson. Les prismes et antiprismes existent en infinité, tandis qu'il existe 110 polyèdres réguliers, semi-réguliers et de Johnson combinés.

Polyèdres Réguliers

Un polyèdre régulier est un polyèdre dont toutes les faces sont des polygones réguliers congruents et dont tous les angles polyédriques sont congruents.

Cinq Polyèdres Réguliers

Les cinq polyèdres réguliers sont : le tétraèdre régulier, l'hexaèdre régulier (cube), l'octaèdre régulier, le dodécaèdre régulier et l'icosaèdre régulier.

Le théorème d'Euler prouve qu'il n'existe que cinq polyèdres réguliers en résolvant un système d'équations diophantiennes, donnant cinq solutions.

Dualité des Polyèdres Réguliers

En examinant les nombres de faces et de somets, on observe que l'hexaèdre et l'octaèdre sont duaux, le dodécaèdre et l'icosaèdre sont duaux, tandis que le tétraèdre est auto-dual.

Développements Planes

Les nombres de développements planes pour les polyèdres réguliers sont respectivement : tétraèdre (2), cube (11), octaèdre (11), dodécaèdre (43380), icosaèdre (43380). Cette relation est liée à la dualité.

Polyèdres d'Archimède

Les polyèdres d'Archimède sont des polyèdres convexes composés de polygones réguliers (pas tous de même nombre de côtés) avec des sommets idantiques, excluant les prismes et antiprismes. Il en existe treize types.

Polyèdres de Johnson

Les polyèdres de Johnson sont des polyèdres convexes à faces régulières, qui ne sont ni réguliers, ni semi-réguliers, ni prismes, ni antiprismes. En 1996, il a été prouvé qu'il en existe exactement 92.

Solides Fondamentaux

Trois solides fondamentaux : pyramides, rotondes et coupoles. Pyramides : tétraédrique et pentagonale. Coupoles : triangulaire, carrée et pentagonale. Rotonde : une seule, pentagonale, constituant la moitié d'un dodécaèdre tronqué.

Classification

Les polyèdres de Johnson se classent en : solides fondamentaux (jaune), combinaisons de solides fondamentaux (vert clair), modifications de polyèdres existants (bleu), et autres types (vert foncé).

Implémentation Algorithmique

Calcul de Surface de Formes 3D

Étant donné une grille n×n de piles de cubes 1×1×1, où chaque valeur v = grille[i][j] représente v cubes empilés à la position (i,j). Les cubes adjacents fusionnent. Retournez la surface totale résultante, incluant les faces inférieures.

Exemple 1:

Entrée: [[1,2],[3,4]]<br></br>Sortie: 34

Exemple 2:

Entrée: [[1,1,1],[1,0,1],[1,1,1]]<br></br>Sortie: 32

Exemple 3:

Entrée: [[2,2,2],[2,1,2],[2,2,2]]<br></br>Sortie: 46

Solution en C++

class Solution {
public:
    int surfaceArea(vector<vector>>& grid) {
        int n = grid.size();
        int total = 0;
        
        // Surface supérieure et inférieure
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] > 0) {
                    total += 2; // face supérieure et inférieure
                }
            }
        }
        
        // Surface latérale (directions horizontales et verticales)
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // Faces cachées avec le voisin de droite
                if (j + 1 < n) {
                    total += abs(grid[i][j] - grid[i][j+1]);
                } else {
                    total += grid[i][j]; // bord droit
                }
                
                // Faces cachées avec le voisin du bas
                if (i + 1 < n) {
                    total += abs(grid[i][j] - grid[i+1][j]);
                } else {
                    total += grid[i][j]; // bord inférieur
                }
            }
        }
        
        return total;
    }
};</vector>