Minimize the sum of a maximum of $X$ elements and $Y$ elements from $2$ different arrays so that a total of $N$ elements are chosen 
A group of $N$ people are on a hiking trip. It starts raining heavily
  and the group starts looking for places where they can be protected
  from the rain. There are $2$ enclosures nearby where people can find
  shelter. Let’s call them $A$ and $B$. Enclosure $A$ can accommodate $X$
  people, and Enclosure $B$ can accommodate $Y$ people. It is guaranteed
  that $(X + Y ) \geq N$, and so everyone can be accommodated. The people are
  numbered from $1$ to $N$. We know how far each person is from each
  enclosure. More specifically, for person $i$, $Adist[i]$ denotes how far
  the $i$ th person is from $A$ and $Bdist[i]$ denotes how far the $i$ th person
  is from $B$. The group has genuine camaraderie, so they decide that they
  want to minimize the total distance traveled by their group members
  altogether to reach their respective enclosures. Note that this may
  mean that some individuals don’t end up at the enclosure which is
  closest to them—the aim is to minimize the sum of the distances
  traveled by the members of the group. Given $N, X, Y$ and the distances,
  your aim is to compute this minimum value. 

Please note that $A[~]$ and $B[~]$ (in whatever follows below) denotes $Adist[~]$ and $Bdist[~]$ respectively.
It's given that :
$A[20] = \{3, 
11,
 20,
 31,
72,
13,
36,
41,
4, 
59,
19,
3, 
28,
23,
62,
62,
37,
20,
21,
51\}$
$B[20] = \{1,
19,
24,
13,
102,
51,
38,
40,
9,
47,
21,
49,
32,
29,
62,
59,
34,
20,
17,
54\}$
$X = 5, Y = 18, N=20$
Keeping in mind the fact that $X < Y$ (as in this question),
for solving this question, my strategy is to write another array $C[20]$ such that $C[i]=A[i]-B[i]$. 
So, to solve the problem, our $C[20]$ will look like :
$C[20] = \{2,-7,-4,18,-30,-38,-2,1,-5,12,-2,-46,-4,-6,0,3,3,0,4,-3 \}$
Here, we will sort the elements in $C$ in descending order of the absolute value of each element in $C$ though we will keep the signs intact such that $C'[20] = \{-46, -38, -30, 18, 12, -7, -6, -5, -4, -4, 4, -3, 3, 3, -2, -2, 2, 1, 0, 0\}$. Now, choose the smaller element between $A[i], B[i]$ corresponding to the $C'[i]$ (where $i$ denotes the index of the array)
When the absolute value of two different elements is same, we can choose $A[i], A[j]$ if $A[i]+A[j]<B[i]+B[j]$ otherwise, we will choose $B[i], B[j]$ if $A[i]+A[j]>B[i]+B[j]$ if we have not attained $X$ and $Y$. Otherwise, choose $A[i], B[j]$ or $B[j], A[i]$ as both of them will sum up to yield the same integer. Otherwise, choose the worst case (that maximizes their sum if any of $X$ or $Y$ is attained already). 
As per the approach, my answer is $593$ which matches the solution.
I don't know much of any graph theory or dynamic programming. But I kind of feel that this can be done with one (or maybe, both) of those. I don't have even the least of idea, so, if there's a solution using any of those, please introduce that to me and I will learn DP/graph required to understand that. Also, please check if my algorithm using greedy is fair enough. I don't find anything wrong with it. 
Also, if possible please show a rigorous proof of how the greedy process I mentioned works here (I think it works, but can't prove it RIGOROUSLY)
 A: This can be formulated and solved as an instance of the min-cost network flow problem, as follows.
Consider the following graph:
I have omitted a lot of arcs for clarity! On the left, we have a source node $s$, and on the right a sink node $t$. There are two layers of nodes between $s$ and $t$. The first layer has $N$ nodes, each representing a hiker. The second layer has 2 nodes, one for each shelter (of course, if you wanted to increase the number of shelters, you could). The $N$ edges connecting $s$ to the first layer each have a cost of 0 and a capacity of 1. For each node $i$ in the first layer, there is an edge connecting to each shelter with capacity 1. The cost of the arc between node $i$ and shelter $A$ is Adist[i], while the cost of the arc between node $i$ and shelter $B$ is Bdist[i]. Finally, between each shelter node and the sink node $t$, there is an arc with cost 0 and capacity equal to the capacity of that shelter ($X$ for $A$ and $Y$ for $B$). We then require pushing $N$ units of flow from node $s$ to node $t$. 
It turns out, when we solve the resulting min-cost flow problem (which can be done in polynomial time--see the Wikipedia article), the amount of flow on each arc will be an integer, since all the input data is integer (this is a theorem about the min-cost network flow model--see slide 14 in these slides). Hence the amount of flow on each arc $f_{iA}$ connecting hiker $i$ to shelter $A$ will be either $0$ or $1$ (and similarly for $f_{iB}$). Since node $i$ has exactly one unit of flow entering, we must have that exactly one of $f_{iA}$ or $f_{iB}$ equals one. If $f_{iA}=1$, then hiker $i$ should run to shelter $A$. Otherwise, $f_{iB}=1$, and hiker $i$ should run to shelter $B$.
Sidenote: This argument depends critically on the fact that your data are all integers. This may bother you at first (indeed, it bothered me). What if a hiker is 33.5 feet from shelter $A$? The good news is, we can just choose different units! If the hiker is 33.5 feet from shelter $A$, then they are also $10\ 210.8$ millimeters away. If we're willing to give up $0.2$ millimeters, then we can just convert everyones distances to millimeters, and round to the nearest integer. Hence, assuming that the data are all integers doesn't really cause you to lose anything.
Other sidenote: You mentioned that you don't know much graph theory. If you're like me then, this construction might seem kind of magical (how did anyone think of this?). FWIW, in my experience, I just had to see lots of examples like this, and then I started to be able to figure them out on my own. (Sorry if this comment sounds condescending--not my intention!)
A: With just two shelters, the proposed approach is probably the best method. For more than 2 shelters, the following approach is more specific, and thereby more efficient, than solving it as a min-cost flow network.
You can formulate this as a linear assignment problem, for which the Jonker-Volgenant algorithm (Python implementation) is quite efficient. The algorithm takes a $(X+Y) \times (X+Y)$ distance matrix with the $N$ hikers and $X+Y-N$ dummies as columns and $X+Y$ spots as rows. The distance between a dummy and a spot you can set to 0 (or any constant value).
An alternative algorithm called the Hungarian method. It is less efficient, but very easy to understand.
