int upperTriangleDesc(const int **A, const int N)
{
    int contador = 0;
    int i, a;
 
    for ( i = 1; i < N; i++)
    {
        for (a = 0; a <= contador; a++)
        {
            if (A[i][a] != 0) return 0; // Es incorrecta
        }
        contador++;
    }
 
    return 1 ; // Es correcta
}

int upperTriangleDesc(const int **A, const int N)
{
    int i, a;
 
    for (i = 1; i < N; i++)
    {
        for (a = 0; a <= (i-1); a++)
        {
            if (A[i][a] != 0) return 0; // Es incorrecta
        }
    }
 
    return 1 ; // Es correcta
}

•  Date cuenta que contador=i-1. Luego esa variable es redundante, innecesaria! Basta a<i
•  Desde un punto de vista purista (ojo, esto no le quita valor a lo tuyo)... no es progrmacion estructurada... saliendo del bucle interno con return

int upperTriangleDesc(const int **A, const int N)
{
    int contador = 0;
    int i, a;
 
    for ( i = 1; i < N; i++)
    {
        for (a = 0; a <= contador; a++)
        {
            if (A[i][a] != 0) return 0; // Es incorrecta
        }
        contador++;
    }
 
    return 1 ; // Es correcta
}

Hmmm.... Correcta!  

Una objección:

•  La tecnica es estructurada, pero emplea 3 variables... trinangular_superior es redundante...

Se puede conseguir una solucion estructurada y con solo 2 variables locales?

A[i][j] == 0

int upperTriangleDesc(const int **A, const int N){
    size_t i = 1; j = 0; // Declaramos e inicializamos j para poder usarlo en la condicion del bucle externo
    while(i < N && !A[i][j]){
        // El bucle interno no tiene ninguna complicacion
        while(j < i && !A[i][j]){
            ++j;
        }
        // Ahora al salir tenemos dos situaciones:
        // - (j = i) y en tal caso la matriz todavia es triangular superior -> Incrementamos i y restablecemos j a 0 para recorrer otra fila
        // - (A[i][j] != 0) y en tal caso la matriz ya no es triangular superior -> No podemos modificar i ni j para que el bucle de fuera tambien termine
        if(j == i){
            ++i;
            j = 0;
        }
    }
    // Los bucles acaban cuando:
    // Un elemento no es nulo (A[i][j] != 0) -> !triangular
    // Llegamos al final (i == N) -> SI A[N-1][N-2] == 0 ENTONCES triangular SINO !triangular
    return (i == N && !A[N-1][N-2]);
} 

• Todos los elementos de la fila son nulos -> j = i -> triangular (de momento)
• El último elemento comprobado no era nulo -> j < i

int upperTriangleDesc(const int **A, const int N){
    size_t i = 1, j = 0;
    while(i < N && !j){
        while(j < i && !A[i][j]){
            ++j;
        }
        // Al salir: SI j < i ENTONCES A[i][j] != 0 SINO SI A[i][j-1] == 0 ENTONCES triangular (de momento) SINO !triangular
        j = (j < i) || A[i][j-1];
        ++i;
    }
    // Triangular <-> j = 0
    return !j;
} 

upperTriangleDesc=A=>{
  for(i=1;i<A.length;++i) 
    for(j=0;j<i;++j)
      if(A[i][j])return 0
  ;return 1
}