如何将一个图分为两个图（类）？ （编辑）

Question

Basically I want to split the big graph into two (or three, depending on the size of the classes) smaller graphes of (nearly) equal size. And each node should still have at least one edge.

So I made a graph in neo4j with the nodes and edges. But now I have no idea how to continue.

"Real-World-Problem":
A friend of mine (teacher in primary school) came to me with a problem. When the children come from kindergarten into primary school, they can wish for three other childs they want to have in their class. And the teachers try to get them in one class with at least one of the three.

This is my graph so far:

CREATE (Luke:Person { name: "Luke"}),
(Jan:Person { name: "Jan"}),
(Tim:Person { name: "Tim"}),
(Finn:Person { name: "Finn"}),
(Leon:Person { name: "Leon"}),
(Niklas:Person { name: "Niklas"}),
(Tom:Person { name: "Tom"}),
(Jonas:Person { name: "Jonas"}),
(Yannic:Person { name: "Yannic"}),
(Luca:Person { name: "Luca"}),
(Leia:Person { name: "Leia"}),
(Anna:Person { name: "Anna"}),
(Sarah:Person { name: "Sarah"}),
(Hannah:Person { name: "Hannah"}),
(Michelle:Person { name: "Michelle"}),
(Laura:Person { name: "Laura"}),
(Lisa:Person { name: "Lisa"}),
(Lara:Person { name: "Lara"}),
(Lena:Person { name: "Lena"}),
(Julia:Person { name: "Julia"}),
(Luke)-[:PRIORITY {rating: 1}]->(Leia),
(Jan)-[:PRIORITY {rating: 1}]->(Tim),
(Tim)-[:PRIORITY {rating: 1}]->(Lara),
(Finn)-[:PRIORITY {rating: 1}]->(Luke),
(Leon)-[:PRIORITY {rating: 1}]->(Luca),
(Niklas)-[:PRIORITY {rating: 1}]->(Lisa),
(Tom)-[:PRIORITY {rating: 1}]->(Michelle),
(Jonas)-[:PRIORITY {rating: 1}]->(Finn),
(Yannic)-[:PRIORITY {rating: 1}]->(Tim),
(Luca)-[:PRIORITY {rating: 1}]->(Jonas),
(Leia)-[:PRIORITY {rating: 1}]->(Laura),
(Anna)-[:PRIORITY {rating: 1}]->(Tom),
(Sarah)-[:PRIORITY {rating: 1}]->(Leon),
(Hannah)-[:PRIORITY {rating: 1}]->(Niklas),
(Michelle)-[:PRIORITY {rating: 1}]->(Lena),
(Laura)-[:PRIORITY {rating: 1}]->(Leia),
(Lisa)-[:PRIORITY {rating: 1}]->(Lara),
(Lara)-[:PRIORITY {rating: 1}]->(Lisa),
(Lena)-[:PRIORITY {rating: 1}]->(Sarah),
(Julia)-[:PRIORITY {rating: 1}]->(Jonas),
(Luke)-[:PRIORITY {rating: 2}]->(Niklas),
(Jan)-[:PRIORITY {rating: 2}]->(Jonas),
(Tim)-[:PRIORITY {rating: 2}]->(Luca),
(Finn)-[:PRIORITY {rating: 2}]->(Leon),
(Leon)-[:PRIORITY {rating: 2}]->(Luke),
(Niklas)-[:PRIORITY {rating: 2}]->(Anna),
(Tom)-[:PRIORITY {rating: 2}]->(Yannic),
(Jonas)-[:PRIORITY {rating: 2}]->(Michelle),
(Yannic)-[:PRIORITY {rating: 2}]->(Hannah),
(Luca)-[:PRIORITY {rating: 2}]->(Luke),
(Leia)-[:PRIORITY {rating: 2}]->(Jan),
(Anna)-[:PRIORITY {rating: 2}]->(Lisa),
(Sarah)-[:PRIORITY {rating: 2}]->(Tim),
(Hannah)-[:PRIORITY {rating: 2}]->(Finn),
(Michelle)-[:PRIORITY {rating: 2}]->(Leon),
(Laura)-[:PRIORITY {rating: 2}]->(Tom),
(Lisa)-[:PRIORITY {rating: 2}]->(Tom),
(Lara)-[:PRIORITY {rating: 2}]->(Tim),
(Lena)-[:PRIORITY {rating: 2}]->(Yannic),
(Julia)-[:PRIORITY {rating: 2}]->(Sarah),
(Luke)-[:PRIORITY {rating: 3}]->(Michelle),
(Jan)-[:PRIORITY {rating: 3}]->(Luca),
(Tim)-[:PRIORITY {rating: 3}]->(Tom),
(Finn)-[:PRIORITY {rating: 3}]->(Lara),
(Leon)-[:PRIORITY {rating: 3}]->(Anna),
(Niklas)-[:PRIORITY {rating: 3}]->(Lara),
(Tom)-[:PRIORITY {rating: 3}]->(Lena),
(Jonas)-[:PRIORITY {rating: 3}]->(Luke),
(Yannic)-[:PRIORITY {rating: 3}]->(Leia),
(Luca)-[:PRIORITY {rating: 3}]->(Lisa),
(Leia)-[:PRIORITY {rating: 3}]->(Yannic),
(Anna)-[:PRIORITY {rating: 3}]->(Hannah),
(Sarah)-[:PRIORITY {rating: 3}]->(Lena),
(Hannah)-[:PRIORITY {rating: 3}]->(Julia),
(Michelle)-[:PRIORITY {rating: 3}]->(Luke),
(Laura)-[:PRIORITY {rating: 3}]->(Jan),
(Lisa)-[:PRIORITY {rating: 3}]->(Tim),
(Lara)-[:PRIORITY {rating: 3}]->(Finn),
(Lena)-[:PRIORITY {rating: 3}]->(Leon),
(Julia)-[:PRIORITY {rating: 3}]->(Niklas)

Answer 1

Without being able to give an exact reason why, I think your problem is in NP (comments on this is very welcome). I don't have a finished solution to offer, at least not for an optimal solution (also, knowing what the optimal solution is would require the problem to be a bit more specified. Like, do we aim for the children getting their highest possible priority satisfied? Or for getting the highest amount of ratings satisfied?). But I have an idea that might be useful.

As I read your problem statement the graph is directed and after dividing the graph into smaller components, all nodes should have at least one outgoing edge to another node within the same component (as opposed to just any edge, as all children should be in a class with someone they chose and not just with someone who chose them).

My idea is the following: Start by testing whether your graph is connected (weakly should be enough) and if so, then find 2 small cycles in the graph (or three if you want to divide the children into three classes) and make the nodes associated with these into the two "classes." Keep track of all edges going into these two classes. For the smallest class, find an ingoing edge that comes from a node that is not yet associated with a class and add it to the class. Keep doing this until they have the same size, and then you can alternate between adding a node to each of the classes until one of them has no more incomming edges from nodes not associated with a class. The rest of the nodes are then added to the other class.

If your graph is not connected you will have to take this into account, but any connected component that is smaller than the desired class-size will consist of children that gets all their priorities satisfied and could therefore just be added to one of the small cycles you start from before you start adding other nodes. A connected component that is bigger than the maximal class size (if such a limit exists) will probably need some extra calculations in order to find out who to remove without causing the constraints to be violated.

As mentioned this is neither optimal nor a finished solution, but assuming that all children made at least one wish, this should place every child in a class, and if all children made all three wishes, my intuition says that there should be a fair chance that the classes are more or less evenly sized. If not, running the code from a few different choices of start-cycles could give some alternate solutions from which to choose.

Hope that this can get you started.