One time parameter use pattern

Question

I'm wondering if the following pattern breaks any convensions or smells of poor design.
I have a complex directed-graph-like object, let's call it MyGraph.
I plan to build them by putting together smaller less complex MyGraph objects which get integrated into the whole.
The problem is that when they are integrated, their nodes are, of course, possibly linked (hence modified) to nodes in the graph they are constructing.
To sum up so far:
MyGraph subGraph1 = new MyGraph(...);
MyGraph subGraph2 = new MyGraph(...);
//WARNING! subGraph1 and subGraph 2 get modified in here!
MyGraph aGraph = new MyGraph(subGraph1, subGraph2);
//ADDITIONAL WARNING! Don't touch subGraph1 or subGraph2
//because doing so will change aGraph.
//ADDITIONAL ADDITIONAL WARNING! Don't use subGraph1 or subGraph2
//as parameters to grate a new MyGraph, because then things get REALLY ugly.So I have at least 2 possible solutions.
1. A complicated, expensive deep copy of a directed (possibly with cycles) MyGraph every time it's used in a constructor. Even though it's very likely never to be used again.
2. In the constructor check/modify a private "used" field in the parameters (ok because I have access to it) so I can't ever inadvertently re-use a MyGraph.
The second option introduces the idea of the "one-time use as parameter" pattern. Where, once used as a parameter, an object becomes invalid for any other use.
In some ways this pattern feels okay, and in others it "rubs me the wrong way".
A final consideration: this code is very generic, and is likely to be used by other developers, and I want to confuse/surprise them as little as possible.
So, finally, is option 2 ok? bad? so-so?
Would you cringe if you saw it?

Answer 1

To satisfy the curious.
Specifically, what I've done is implement "Regular Expressions" over a sequence of arbitrary objects as opposed to characters.
A bit of background:
http://forum.java.sun.com/thread.jsp?forum=4&thread=414189
I call them JOREs (Java Object Regular Expressions)
I was hoping to avoid the need to deep-copy a directed cyclical graph, because:
a. it's a bit of a pain and cpu hog
b. I really want to avoid StackOverflowErrors so all of my "recursive" functions are implemented with iteration and a Stack. That makes the copy even more of a pain and cpu hog.
It works now.
I have made JOREs immutable and have implemented a deep-copy function.
The directed graph is my FA, and I had to "invent" a sensible way of putting together complex JOREs out of simple rules and sub-JOREs. This is what it looks like to put one together:
       Rule anyStringOfLength7 = new Rule("any String of length 7"){
            public boolean accepts(Object o)
                return (o instanceof String && ((String)o).length()==7);
        Rule aNull = new Rule("a null"){
            public boolean accepts(Object o)
                return (o==null);
        Jore nullOrStringOfLength7 = Jore.createNew().or(
                Jore.createNew().then(aNull),
                Jore.createNew().then(anyStringOfLength7)
        //note that the instance methods return a new Jore, and always
        //deep-copy parameters before using them now
        Jore myJore  = Jore.createNew().then(aNull).then(nullOrStringOfLength7).finish();