EULERIAN

#include <stdio.h>

#define NMAX 200
#define MMAX 19900

typedef struct stack {
          int top;
          int a[MMAX];
        } STACK;

char vecin[NMAX + 1][NMAX + 1];
int d[NMAX + 1];
STACK stk;
int path[MMAX + 1];
int pathlen;


void init(STACK* s) {
  s->top = -1;
}

int empty(STACK* s) {
  return (s->top < 0) ? 1 : 0;
}

void push(STACK* s, int x) {
  s->top++;
  s->a[s->top] = x;
}

int peek(STACK* s) {
  return s->a[s->top];
}

void pop(STACK* s) {
  s->top--;
}

void findeulerpath(int n, int startNode) {
  int u, v;

  u = startNode;
  init(&stk);
  pathlen = 0;

  push(&stk, u);
  while (!empty(&stk)) {
    u = peek(&stk);
    pop(&stk);

    v = 1;
    while ((d[u] > 0) && (v <= n)) {
      if (vecin[u][v] == 1) {
        push(&stk, u);

        vecin[u][v] = vecin[v][u] = 0;
        d[u]--;
        d[v]--;

        u = v;
        v = 1;
      } else {
          v++;
      }
    }

    path[pathlen++] = u;
  }
}


int main() {
  FILE *fin, *fout;
  int n, u, v, i;

  fin = fopen("euler.in", "r");
  fout = fopen("euler.out", "w");

  fscanf(fin, "%d", &n);
  while (fscanf(fin, "%d %d", &u, &v) == 2) {
    vecin[u][v] = vecin[v][u] = 1;
    d[u]++;
    d[v]++;
  }

  findeulerpath(n, 1);

  fprintf(fout, "%d\n", pathlen);
  for (i = 0; i < pathlen; i++) {
    fprintf(fout, "%d ", path[i]);
  }

  fclose(fin);
  fclose(fout);

  return 0;
}