Coursera 算法二 week 3 Baseball Elimination

这周的作业不需要自己写算法，只需要调用库函数就行，但是有些难以理解，因此用了不少时间。

 import edu.princeton.cs.algs4.FlowEdge;
 import edu.princeton.cs.algs4.FlowNetwork;
 import edu.princeton.cs.algs4.FordFulkerson;
 import edu.princeton.cs.algs4.ST;
 import edu.princeton.cs.algs4.Queue;
 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdOut;

 public class BaseballElimination
 {
     private int numberOfTeams;
     private ST<String, Integer> st;
     private int[] wins;
     private int[] losses;
     private int[] remaining;
     private int[][] against;
     private String[] teamName;

     public BaseballElimination(String filename)
     {
         st = new ST<String, Integer>();
         In in = new In(filename);
         numberOfTeams = in.readInt();
         wins = new int[numberOfTeams];
         losses = new int[numberOfTeams];
         remaining = new int[numberOfTeams];
         teamName = new String[numberOfTeams];
         against = new int[numberOfTeams][numberOfTeams];

         for (int i = 0; i < numberOfTeams; i++)
         {
             String name = in.readString();
             st.put(name, i);
             wins[i] = in.readInt();
             losses[i] = in.readInt();
             remaining[i] = in.readInt();
             teamName[i] = name;
             for (int j = 0; j < numberOfTeams; j++)
                 against[i][j] = in.readInt();
         }
     }

     public int numberOfTeams()
     {
         return numberOfTeams;
     }

     public Iterable<String> teams()
     {
         return st.keys();
     }

     public int wins(String team)
     {
         if (!st.contains(team)) throw new IllegalArgumentException();
         int index = st.get(team);
         return wins[index];
     }

     public int losses(String team)
     {
         if (!st.contains(team)) throw new IllegalArgumentException();
         int index = st.get(team);
         return losses[index];
     }

     public int remaining(String team)
     {
         if (!st.contains(team)) throw new IllegalArgumentException();
         int index = st.get(team);
         return remaining[index];
     }

     public int against(String team1, String team2)
     {
         if (!st.contains(team1) || !st.contains(team2)) throw new IllegalArgumentException();
         int index1 = st.get(team1);
         int index2 = st.get(team2);
         return against[index1][index2];
     }

     private FlowNetwork createNetwork(String team)
     {
         int index = st.get(team);
         int num = numberOfTeams - 1;

         int V = num + 2 + num * (num - 1) / 2;
         int s = V - 2, t = V - 1;
         FlowNetwork net = new FlowNetwork(V);

         for (int i = 0; i < num; i++)
         {
             if (i < index)
             {
                 double capacity = wins[index] + remaining[index] - wins[i];
                 FlowEdge edge = new FlowEdge(i, t, capacity);
                 net.addEdge(edge);
             }
             else
             {
                 double capacity = wins[index] + remaining[index] - wins[i + 1];
                 FlowEdge edge = new FlowEdge(i, t, capacity);
                 net.addEdge(edge);
             }
         }
         int temp = num;
         for (int i = 0; i < num - 1; i++)
         {
             for (int j = i + 1; j < num; j++)
             {
                 FlowEdge edge = new FlowEdge(temp, j, Double.POSITIVE_INFINITY);
                 net.addEdge(edge);

                 edge = new FlowEdge(temp, i, Double.POSITIVE_INFINITY);
                 net.addEdge(edge);

                 int a = i, b = j;
                 if (i >= index) a++;
                 if (j >= index) b++;
                 double capacity = against[a][b];
                 edge = new FlowEdge(s, temp, capacity);
                 net.addEdge(edge);

                 temp++;
             }
         }

         return net;
     }

     public boolean isEliminated(String team)
     {
         if (!st.contains(team)) throw new IllegalArgumentException();
         int index = st.get(team);
         int num = numberOfTeams - 1;
         int V = num + 2 + num * (num - 1) / 2;
         int s = V - 2, t = V - 1;

         for (int i = 0; i < num; i++)
         {
             int j = i;
             if (j >= index) j++;
             if (wins[index] + remaining[index] < wins[j])
                 return true;
         }

         FlowNetwork net = createNetwork(team);

         FordFulkerson ff = new FordFulkerson(net, s, t);
         for (FlowEdge e : net.adj(s))
             if (e.capacity() != e.flow())
                 return true;

         return false;
     }

     public Iterable<String> certificateOfElimination(String team)
     {
         if (!st.contains(team)) throw new IllegalArgumentException();
         int index = st.get(team);
         int num = numberOfTeams - 1;
         int V = num + 2 + num * (num - 1) / 2;
         int s = V - 2, t = V - 1;
         Queue<String> certificate = new Queue<String>();

         boolean isEliminated = false;
         for (int i = 0; i < num; i++)
         {
             int j = i;
             if (j >= index) j++;
             if (wins[index] + remaining[index] < wins[j])
             {
                 isEliminated = true;
                 certificate.enqueue(teamName[j]);
             }
         }
         if (isEliminated) return certificate;

         FlowNetwork net = createNetwork(team);

         FordFulkerson ff = new FordFulkerson(net, s, t);
         for (int i = 0; i < num; i++)
         {
             if (ff.inCut(i))
             {
                 int j = i;
                 if (j >= index) j++;
                 certificate.enqueue(teamName[j]);
                 isEliminated = true;
             }
         }

         if (isEliminated) return certificate;

         return null;
     }

     public static void main(String[] args) {
         BaseballElimination division = new BaseballElimination(args[0]);
         for (String team : division.teams()) {
             if (division.isEliminated(team)) {
                 StdOut.print(team + " is eliminated by the subset R = { ");
                 for (String t : division.certificateOfElimination(team)) {
                     StdOut.print(t + " ");
                 }
                 StdOut.println("}");
             }
             else {
                 StdOut.println(team + " is not eliminated");
             }
         }
     }
 }