Who's Going? Can you help me?
Husk, 14 10 bytes

~f`öΠFf†€Ṗ


Takes three inputs: number of people to go, 2-row matrix of the constraints, and list of all people involved, in this order.
Returns all possible lists of people who go.
If you want to output only one list, replace the leftmost f by ḟ.
Try it online!

Explanation

The idea is to loop over the size-n subsets of p and keep those that satisfy the condition imposed by g: if the first person in a pair goes, then the second person must go too.

~f`öΠFf†€Ṗ  Implicit inputs, say n=3, g=[[1,3,3],[4,1,4]] and p=[1,2,3,4]
         Ṗ  All n-element subsets of p: [[1,2,3],[2,3,4],[1,3,4],[1,2,4]]
~f          Keep those subsets (say q=[1,2,4]) for which
  `ö        this function gives a truthy (nonzero) result:
       †     Deep map over g:
        €    index in q, or 0 if doesn't occur: [[1,0,0],[3,1,3]]
     Ff      Fold by select (filter second row by truthiness on first row): [3]
    Π        Product: 3


This program is one of those where it's really hard to explain how the program arguments are passed to the correct functions, but I'll try.
First, n is the first argument, so it can be given to Ṗ directly, making it a function that takes a list and returns its n-subsets.
The next two inputs are g and p, and the program's shape at this point is ~(f)(`öΠFf†€)(Ṗn) with parentheses added for clarity.
The operator ~ gives g to `öΠFf†€ and p to Ṗn, and combines the results with f.
Ṗnp is just the n-subsets of p, so that's simple.
The operator ` causes öΠFf†€ to take its arguments in the reverse order, so g is actually the second argument of this function.
The first argument is an element q of Ṗnp, which is extracted by f (filter).
We give q as an argument to €, which becomes a function for testing membership in q, and deep map that over the second argument, which is g.
Then ΠFf are applied to the result.
The role of ö is just to compose ΠFf†€ into one function, which we can then pass on to ` and ~f.