How do I show that a DFA accepts only one word?
The case of 1-state DFA

Accepting one word is unrelated to having one state.

If there is only one state, it is necessarily starting and accepting
state, unless there is no accepting state which make the language empty.

An automaton that has only one state which is accepting is necessarily
accepting a language equal to $\Sigma_1^*$ for some subset $\Sigma_1$
of the input alphabet $\Sigma$.

Then the automaton accepts exactly one word if and only if it is the
empty word $\epsilon$, which is the case when $\Sigma_1=\emptyset$

Multi-state DFA

Now, assuming you can have more than one state (I would think that you
did not intend to have such a restriction).

You look at your DFA as a directed graph.

Acceptance of a word is equivalent to finding a path from initial
state to a final state. Since the automaton is deterministic there is
a bijection between such path and the words of the
language. Furthermore, the length of the word is equal to the length
of the path.

Finding one path between the initial state and a final state can be
done simply by tracing, starting with the initial state.
You start with a set $U$ (for untraced) containing only the initial
node, and a set $T$ (for traced once) initially empty.

Then for any state $q$ remaining in $U$, you add all nodes $q'$ with a
transition $q\to q'$ to $U$ unless they are already in $U\cup T$, and
you transfer $q$ from $U$ to $T$. You
terminate when $U$ is empty, and then all nodes in $T$ are reachable from
the initial state. Note that this is the gist of tracing garbage
collection algorithms. The complexity is linear if inclusion of a node
in a set is checkable in constant time (for example by marking the node).

Now, in order to check for multiple paths, you modify a bit the
algorithm, replacing $T$ by two sets $T_1$ (for traced once) and $T_2$
(for traced twice). You proceed as before, with the following changes, that depend on whether $q$ is in $T_1$ or not.


When $q\notin T_1$ ( $q$ was never traced, nor accessed from two paths), consider successively every transition $q\to q'$, making sure you process first a transition $q\to q$ if any exists:


if $q'$ is already in $T_2$, you ignore it
else, if it is in both $U$ and $T_1$, you ignore it
else, if it is in $T_1$, but not in $U$, you add it to $U$ (leaving it
in $T_1$ too).
else, if it is in $U$, but not in $T_1$, you add it to $T_1$ (leaving it
in $U$ too).
else, if $q'$ is in none of the sets, you add it to $U$.


Then you move the node/state $q$ to $T_1$ if it is not already in
$T_1$, or to $T_2$ if it is in $T_1$ (you may remove it from $T_1$ if
convenient for set encoding, but it does not matter). Note that $q$ may already be in $T_1$ if one of the transitions just processed is of the form $q\to q$.
When $q\in T_1$ (there are at least two paths to $q$), consider successively every transition $q\to q'$:


if $q'$ is already in $T_2$, you ignore it
else, put $q'$ in both in both $U$ and $T_1$ (it may be there already)


Then you move the node/state $q$ to $T_2$ (and you may remove it from $T_1$, if you wish).


When you terminate (with $U$ empty), you have at least two paths from
the initial state to a final state if and only if you have an
accepting state in $T_2$, or two accepting states in $T_1$.
You have at least one path if $T_1\cup T_2$ contains an accepting state, and no path it it does not.

So the necessary and sufficient condition for the existence of exactly a single word in the language is that there is a single accepting state in $T_1$ and none in $T_2$.

With proper encoding of the sets, this works in linear time (in the size of the DFA), and can be quite fast.

Note: the conditionals have been written for better readability. They can be better organized for efficiency.