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

...
Por lo tanto la solución más sencilla parece un par de bucles que recorran esta parte de la matriz.
.....

Código

int upperTriangleDesc(const int **A, const int N){
	int triangular_superior = 1;
	for(size_t i = 1; i < N && triangular_superior; ++i)
		for(size_t j = 0; j < i && triangular_superior; ++j)
			triangular_superior = (A[i][j] == 0);
	return triangular_superior;
} 

....
Como echo de menos estas cosas de C/C++ desde que trabajo con Java
...

•  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
}

1 2 3    1 2 3    
0 4 5    0 4 5
0 0 2    0 0 0

1 2 3    1 2 3    
0 4 5    2 4 5
0 2 2    0 0 0

5
1 2 3 0 0
0 4 5 0 0 
0 0 0 1 1
0 0 0 3 1
0 0 0 0 1
upperTriangleDesc: 1
3 
1 2 3
0 4 5
0 2 0
upperTriangleDesc: 0
3 
1 2 3
0 4 5
0 0 0
upperTriangleDesc: 1

int upperTriangleDesc(const int **A, 
		      const int N)
{
// Start coding here
    return 0 ; 
}
 
int main(int argc, char *args[])
{
  int **A;
  int N;
  for( ; scanf("%d",&N)==1; )
    {
      if  ((A=(int**)malloc(N*sizeof(int *)))==NULL)
	{
	  perror("calloc");
	  exit(1);
	}
      for(int n=0;n<N;n++)
	{
	  if  ((A[n]=(int*)malloc(N*sizeof(int)))==NULL)
	    {
	      perror("calloc");
	      exit(1);
	    }
	  for(int m=0;m<N;m++)
	    if (scanf("%d",&A[n][m])!=1)
	      {
		perror("scanf");
		exit(1);
	      }
	}
      printf("upperTriangleDesc: %d\n",upperTriangleDesc((const int **)A,N));
      for(int n=0;n<N;n++)
	free(A[n]);
      free(A);
    }
  return 0;
}

typedef struct _node
{
  int info;
  struct _node *next;
} *node;
 
typedef struct _deque
{
  node first;
  node last;
}deque;
 
 
void pop_back(deque *dq)
{
  assert(dq->last != NULL);
  node prev,act;
  for(prev=NULL,act=dq->first;act!=dq->last;act=act->next)
    prev=act;
  dq->last = prev;
  if (prev) prev->next=NULL;
  else dq->first=dq->last=NULL;
  free(act);
}
 
 

 
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
 
typedef struct _node
{
  int info;
  struct _node *next;
} *node;
 
typedef struct _deque
{
  node first;
  node last;
}deque;
 
 
int print(const deque *dq){
  printf("[ ");
  node p;
  for(p=dq->first;p!=NULL ; p=p->next)
    printf("%d ",p->info);
  printf(" ]");
  printf("\n");
  return 0;
}
 
void create(deque *dq)
{
  dq->first = dq->last = NULL ;
  return;
}
 
void push_back(deque *dq,int info)
{
  node n;
  if ((n = (node)malloc(sizeof(struct _node)))==NULL)
    {
      perror("malloc");
      exit(-1);
    }
  n->info = info;
  n->next = NULL;
  node prev;
 
  if (dq->last) dq->last->next = n ;
  dq->last= n;
  if (!dq->first) dq->first=dq->last;
  return;
}
 
 
 
int top(const deque *dq)
{
  assert(dq->last != NULL);
  return dq->last->info;
}
 
void pop_back(deque *dq)
{
  assert(dq->last != NULL);
  node prev,act;
  for(prev=NULL,act=dq->first;act!=dq->last;act=act->next)
    prev=act;
  dq->last = prev;
  if (prev) prev->next=NULL;
  else dq->first=dq->last=NULL;
  free(act);
}
 
 
int empty(const deque *dq)
{
  return dq->first == NULL;
}
 
void destroy(deque *dq)
{
  node p,aux;
  for(p=dq->first ;p;p=aux)
    {
      aux=p->next;
      free(p);
    }
  return ;
}
 
int main(int argc, char *args[] )
{
  int N=10;
  deque dq;
  create(&dq);
  for(int n=0;n<N;n++)
    push_back(&dq,n);
  for( ; !empty(&dq); pop_back(&dq)) print(&dq);
  print(&dq);
  destroy(&dq);
  return 0;
 
}
 
 

[ 0 1 2 3 4 5 6 7 8 9  ]
[ 0 1 2 3 4 5 6 7 8  ]
[ 0 1 2 3 4 5 6 7  ]
[ 0 1 2 3 4 5 6  ]
[ 0 1 2 3 4 5  ]
[ 0 1 2 3 4  ]
[ 0 1 2 3  ]
[ 0 1 2  ]
[ 0 1  ]
[ 0  ]
[  ]

INICIO
    PEDIR numero
    digitos[LONGITUD_MAXIMA] // array de longitud igual al maximo numero de digitos que puede tener el numero
    numeroDigitos := calcularDigitos(numero, digitos)
...
FIN 

/*
 
  Title: Narcisist number (in  base 10)
 
  P : N == \sum i : 0 <= i <= log(N): a_i*10^i
  Q : N==\sum i : 0 <= i <= log(N): a_i^{log(N)+1}
 
 
3     2     1     0
+-----+-----+-----+
|  1  |  5  |   3 |  YES, since 153=1^3+5^3+3^3
+-----+-----+-----+
 
 
 
I ::= 0<=n<=log(N)+1 and Q[log(N)/n-1] and
      M=N/10^n and
      (n<=log(N) ->
      (\forall i : 0 <= i < 10 : pow[i]=i^n and frec[i]=FREC(i,N%10^n)))
 
!B ::= n==log (N)+1
 
B ::= n<log (N)+1  ; // i.e. M>0
 
Init:
-----
  n,pow[0..9],frec[0..9]=0,
  
  |- P -> I [n/0,M/N,pow[0..9]=[1]^10, frec[0..9]=[0]^10]
 
 
QUOTE(N,n) = log (N)+1 - n >= 0   (Cuota decreases)
 
Step:
-----
 
 n = n + 1 ; // i.e. M = M/10 ;
 
*/
 
#include <iostream>
#include <cassert>
 
using namespace std;
 
int narcisist(const unsigned long long N)
{
  unsigned long long pow[10]={1,1,1,1,1,1,1,1,1,1} ; // [0-9]^0
  unsigned long long frec[10]={0,0,0,0,0,0,0,0,0,0} ;
  unsigned long long sum,M;
  assert(N);
  for (M=N ; M ;M/=10 )  // O(log(N)
    {
      frec[M%10]+=1;
      int d;
      for (sum=d=0 ; d<10 ;d++ )  // O(1)
	{
	  pow[d]*=d;
	  sum+=pow[d]*frec[d];
	}
    }
  //  cout <<"trace " << N << " " << sum << endl;
 
  return sum==N;
 
}
 
int main (int argc, char *args[])
{
  unsigned long long N;
  for( ; cin >> N ; )
    cout << narcisist(N) << endl;
  return 0;
}
 

 g++ narcisista.cc -o main && ./main
1634
1
153
1
154
0

/*
 
An stack can be simulated by a vector
 
+-----+
|     |
+-----+ N
|  2  |
+-----+
|  1  |
+-----+
|  +  |
+-----+ 0
 
 
*/
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
 
#define MAX 100000
#define DEBUG
 
int polish (const char V[][25], const int N)
{
  int n,top;
  int S[MAX];
  for( n=top=0;n<N;n++)
  {
#ifdef DEBUG
    int i;
    for(  i=n ; i < N ; i++) printf("%s ",V[i]);
    printf("\n\n");
#endif
 
    if (strtol(V[n],NULL,10)) 
      S[top++]=atoi(V[n]);
    else
      {
	assert(top>1);
	const int a = S[--top];
	const int b = S[--top];
	if (!strcmp(V[n],"+"))
	  S[top++] = a + b;
	else if (!strcmp(V[n],"-"))
	  S[top++] = a - b;
	else if (!strcmp(V[n],"*"))
	  S[top++] = a * b;
	else if (!strcmp(V[n],"/"))
	       {
		 assert(!b);
		 S[top++] = a / b;
	       }
      }
#ifdef DEBUG
    for(  i=0 ; i < top-1 ; i++) printf("%d ",S[i]);
    printf("%d\n\n",S[top-1]);
#endif
  };
  assert(top==1);
  return S[--top];
}
 
 
int main(int argc, char* args[])
{
  char V[MAX][25];
 
  int N;
  for(N=0;scanf("%s",V[N])==1 && strcmp(V[N],"\n");N++);
  printf("%d\n",polish(V,N));
  return 0;
 
}

3 4 + 7 * 9 10 5 6 + * - - 

3 4 + 7 * 9 10 5 6 + * - - 

3

4 + 7 * 9 10 5 6 + * - - 

3 4

+ 7 * 9 10 5 6 + * - - 

7

7 * 9 10 5 6 + * - - 

7 7

* 9 10 5 6 + * - - 

49

9 10 5 6 + * - - 

49 9

10 5 6 + * - - 

49 9 10

5 6 + * - - 

49 9 10 5

6 + * - - 

49 9 10 5 6

+ * - - 

49 9 10 11

* - - 

49 9 110

- - 

49 101

- 

52

• CalgaryCorpus ya ha comentado que no es necesario operar con enteros.
• El programa solo acaba si la palabra tiene las 25 letras al menos una vez cada una! (Asumiendo que k=1 al principio, cosa que no se expresa)
• Si acaba, el programa da siempre la misma solución ABCDEFG..Z