Reduce the
VERTEX COVER problem to the
DIRECTED HAMILTONIAN CIRCUIT problem.
These problems are defined as follows:
 VERTEX COVER: given a natural $k$ and an undirected graph $G$, is
there a cover for $G$ of size at most $k$? In other words, is there a subset
$S$ of nodes with size at most $k$ such that each edge of $G$ involves a node
from $S$?
More formally, this problem can be defined as the following set:
$\{ \langle k,G=\langle V,E\rangle\rangle \mid \exists S\subseteq V: (S\leq k\;\wedge\;\forall \{u,v\}\in E: (u\in S\;\vee\;v\in S)) \}$
 DIRECTED HAMILTONIAN CIRCUIT: given a directed graph $G$, is there a
directed cycle that visits each node of $G$ exactly once? In other words, is it
possible to order the nodes of $G$ such that there is an edge from each node to
the following node in the list and an edge from the last node to the first
node?
More formally, this problem can be defined as the following set:
$\{ G=\langle V,E\rangle \mid V=\{n_1,\ldots,n_k\}\;\wedge\;\forall i\in\{1,\ldots,k\}: \langle n_i,n_{(i\text{ mod }k)+1}\rangle\in E \}$
The input and output of the reduction conform to the following data types:

in: struct {
k: int
numnodes: int
edges: array of array [2] of int
adjacents: array of array of int
adjacencymatrix: array of array of int
}
The input is a natural number in.k and an undirected graph. The graph is
given by means of four different kinds of information: the number of nodes
in.numnodes, the list of edges in.edges, for each node the list
of its adjacent nodes in.adjacents, and the adjacency matrix
in.adjacencymatrix. The nodes are integers between $1$ and
in.numnodes, and thus, the $0$’th position of in.adjacents does
not contain useful data and should be ignored; for any other position $p$,
in.adjacents[p] is the list of nodes adjacent to $p$. For the same
reason, the $0$’th row and column of in.adjacencymatrix do not contain
useful data and should be ignored; for any other row $r$ and column $c$,
in.adjacencymatrix[r][c] is $0$ when there is no edge between the nodes
$r$ and $c$, and $1$ otherwise.
Note: The input graph has at least one node, no repeated edges, nor selfloop edges,
and the value of in.k is at most the number of nodes of the graph.

out: struct {
edges: array of array [2] of string
nodes: array of string
}
The output is a directed graph, which is described with the list of directed
edges out.edges and with the list of nodes out.nodes. An edge is
an ordered pair of nodes, directed from the first node to the second node, and
each node is represented by either an integer or a string. The list of nodes
out.nodes is optional, and contains nodes of the graph, that may or may
not appear in the list of edges. This list of nodes could be useful, for
example, for including the nodes that are not connected to any other node, if
this is considered necessary.
Note: If the output graph has no nodes, it is considered that it has a directed
cycle. If it has selfloop edges, they are taken into account since, in the
particular case of $1$node graphs, they make it possible to have a cycle.
Repeated edges are ignored.