Exemple #1
0
  static void test00() {
    Aron.beg();
    PriorityQueue<Interval> queue = new PriorityQueue<Interval>();
    Stack<Interval> stack = new Stack<Interval>();
    int[] arr1 = {4, 1, 2, 6, 9};
    int[] arr2 = {5, 1, 4, 9, 10};

    for (int i = 0; i < arr1.length; i++) {
      queue.add(new Interval(arr1[i], arr2[i]));
    }
    if (queue.size() > 0) {
      stack.push(queue.remove());
    }
    while (!queue.isEmpty()) {
      Interval top = stack.peek();
      Interval inter = queue.remove();
      if (top.end < inter.begin) stack.push(inter);
      else {
        stack.peek().end = Math.max(stack.peek().end, inter.end);
      }
    }
    while (!stack.empty()) {
      System.out.println("[" + stack.peek().begin + " " + stack.peek().end + "]");
      stack.pop();
    }

    Aron.end();
  }
 private void removeBuildings(
     PriorityQueue<Building> endings, PriorityQueue<Integer> heights, List<int[]> result) {
   final Building rm = endings.poll();
   heights.remove(rm.height);
   while (endings.size() > 0 && endings.peek().to == rm.to) {
     heights.remove(endings.poll().height);
   }
   final int peek = heights.size() > 0 ? heights.peek() : 0;
   if (peek < rm.height) {
     result.add(new int[] {rm.to, peek});
   }
 }
 // Busqueda usando A*
 public static int search() {
     HashSet<State> v = new HashSet<>();
     Giros mano = new Giros();
     ArrayList<int[][]>aux;
     
     finall = inicial.createGoalState();
     Q.add(inicial);
     Node actual;
     int cont = 0;
     
     while ( !(actual = Q.remove()).estado.equals(finall.estado) ) {
         
         if(v.contains(actual.estado)) 
             continue;
         System.out.println(actual.estado+" "+actual.costo_hasta_aqui+" "+actual.costo_total);
         System.out.println("->\n"+((NodeCubo)actual).getValue() );
         
         v.add(actual.estado);
         int ca = actual.costo_hasta_aqui + 1;
         
         //Realiza Movimientos
         for( int i=0; i<12; i++ ){
             aux = mano.girar( ((Cubo)actual.getValue()).getCubo(), i);
             Node nuevo = new NodeCubo(ca, ca+Heuristica.h1((Cubo)actual.getValue()), new Cubo( aux, ((Cubo)inicial.getValue()).getColors() ) );
             Q.add( (Node)nuevo );
         }
         cont++;
     }
     return cont;
 }
Exemple #4
0
  private int getMyTarget(int[] shotAt) {

    /*PriorityTuple firstTuple=priorityList.remove();
    if(shotAt[firstTuple.getPlayerId()]>0)
    	return firstTuple.getPlayerId();

    PriorityTuple nextTuple;
    if(priorityList.size()!=0)
    	nextTuple=priorityList.remove();

    while(nextTuple.getPriority()==firstTuple.getPriority())
    {
    	if(shotAt[firstTuple.getPlayerId()]<shotAt[nextTuple.getPlayerId()])
    		return nextTuple.getPlayerId();

    	if(priorityList.size()!=0)
       		nextTuple=priorityList.remove();
    	else
    		break;
    }

    return firstTuple.getPlayerId();*/

    return priorityList.remove().getPlayerId();
  }
Exemple #5
0
  public int[] maxSlidingWindow(int[] nums, int k) {
    if (nums == null || nums.length == 0) {
      return new int[0];
    }
    int len = nums.length;
    int max = Integer.MIN_VALUE;
    PriorityQueue<Integer> heap = new PriorityQueue<Integer>(k, new heapComparator());
    for (int i = 0; i < Math.min(k, len); i++) {
      heap.add(nums[i]);
    }

    if (k >= len) {
      int[] edge = new int[1];
      edge[0] = heap.peek();
      return edge;
    }
    int[] res = new int[len - k + 1];
    int index = 0;
    for (int i = k; i < len; i++) {
      res[index] = heap.peek();
      index++;
      heap.remove(nums[i - k]);
      heap.add(nums[i]);
    }
    res[index] = heap.peek();
    return res;
  }
 /**
  * Removes a single instance of the specified element from this queue, if it is present, whether
  * or not it has expired.
  */
 public boolean remove(Object o) {
   final ReentrantLock lock = this.lock;
   lock.lock();
   try {
     return q.remove(o);
   } finally {
     lock.unlock();
   }
 }
 public static String next() {
   if (pq.peek() != null) {
     System.out.println("queue pop");
     String curUrl = pq.remove().url;
     if (!visitedUrl.contains(curUrl)) {
       visitedUrl.add(curUrl);
       return curUrl;
     } else return null;
   } else return null;
 }
Exemple #8
0
 public int dijkstra(Vertex s) {
   int count;
   Collection<Vertex> vertices_;
   Comparator<Vertex> comp;
   PriorityQueue<Vertex> fringe;
   count = 0;
   vertices_ = vertices.values();
   comp =
       new Comparator<Vertex>() {
         public int compare(Vertex i, Vertex j) {
           return (i.cost - j.cost);
         }
       };
   fringe = new PriorityQueue<Vertex>(20, comp);
   for (Vertex v : vertices_) {
     v.visited = false;
     v.cost = 999999;
   }
   s.cost = 0;
   s.parent = null;
   fringe.add(s);
   while (!fringe.isEmpty()) {
     Vertex v = fringe.remove(); // lowest-cost
     count++; // count nodes
     if (!v.visited) {
       v.visited = true;
       for (Edge e : v.edges) {
         int newcost = v.cost + e.cost;
         if (newcost < e.target.cost) {
           if (e.target.cost < 999999) // target on queue already?
           fringe.remove(e.target); // if yes, remove it.
           e.target.cost = newcost;
           e.target.parent = v;
           fringe.add(e.target);
         }
       }
     }
   }
   return count;
 }
  public static void main(String[] args) {
    PriorityQueue<GregorianCalendar> pq =
        new PriorityQueue<GregorianCalendar>(); // 优先级队列对GC设置优先级:月->日
    pq.add(new GregorianCalendar(1906, Calendar.DECEMBER, 9)); // G. Hopper
    pq.add(new GregorianCalendar(1815, Calendar.DECEMBER, 10)); // A. Lovelace
    pq.add(new GregorianCalendar(1923, Calendar.DECEMBER, 3)); // J. von Neumann
    pq.add(new GregorianCalendar(1910, Calendar.JUNE, 22)); // K. Zuse

    System.out.println("Iterating over elements...");
    for (GregorianCalendar date : pq) System.out.println(date.get(Calendar.YEAR));
    System.out.println("Removing elements...");
    while (!pq.isEmpty()) System.out.println(pq.remove().get(Calendar.YEAR));
  }
 // 保存待访问的URL及其优先级
 private static void SavePriorQueue(String filepath) throws Exception {
   BufferedWriter bw = new BufferedWriter(new FileWriter(filepath));
   PriorityQueue<UrlValue> temp = new PriorityQueue<UrlValue>();
   UrlValue cur = null;
   while (pq.peek() != null) {
     cur = pq.remove();
     temp.offer(cur);
     bw.write(cur.url + " " + cur.value);
     bw.newLine();
   }
   pq = temp;
   bw.flush();
   bw.close();
 }
 /*
  * 获取客户极坐标的排序
  *
  * */
 public Queue<Client> sortClientsByPolarCoordinate(Client[] clients) {
   Queue<Client> queue = new LinkedList<Client>();
   ClientPolarCoordinateComparator clientPolarCoordinateComparator =
       new ClientPolarCoordinateComparator();
   PriorityQueue<Client> priorityQueue =
       new PriorityQueue<Client>(clients.length - 1, clientPolarCoordinateComparator);
   for (int i = 1; i < clients.length; i++) {
     priorityQueue.add(clients[i]);
   }
   while (!priorityQueue.isEmpty()) {
     queue.add(priorityQueue.remove());
   }
   return queue;
 }
Exemple #12
0
 /**
  * 执行KNN算法,获取测试元组的类别
  *
  * @param list 训练数据集
  * @param test 测试元组
  * @param k 设定的K值
  * @return 测试元组的类别
  */
 public String knn(List<List<Double>> list, List<Double> test, int k) {
   PriorityQueue<KNNNode> pq = new PriorityQueue<KNNNode>(k, comparator);
   for (int i = 0; i < k; i++) {
     List<Double> trainTuple = list.get(i);
     Double c = trainTuple.get(0);
     KNNNode node = new KNNNode(i, getDistance(test, trainTuple), c);
     pq.add(node);
   }
   for (int i = 0; i < list.size(); i++) {
     List<Double> t = list.get(i);
     double distance = getDistance(test, t);
     KNNNode top = pq.peek();
     if (top.getDistance() > distance) {
       pq.remove();
       pq.add(new KNNNode(i, distance, t.get(0)));
     }
   }
   return getMostClass(pq);
 }
 public int[] maxSlidingWindow(int[] nums, int k) {
   int n = nums.length;
   if (n == 0) return new int[0];
   PriorityQueue<Integer> pq = new PriorityQueue<>(k, Collections.reverseOrder());
   Deque<Integer> queue = new ArrayDeque<>();
   for (int i = 0; i < k; ++i) {
     add(pq, queue, nums[i]);
   }
   if (n == k) return new int[] {pq.poll().intValue()};
   int[] max = new int[n - k + 1];
   int idx = 0;
   for (int i = k; i < n; ++i) {
     max[idx++] = pq.peek().intValue();
     pq.remove(queue.poll());
     add(pq, queue, nums[i]);
   }
   max[idx] = pq.peek().intValue();
   return max;
 }
Exemple #14
0
 public int astar(Vertex start, Vertex goal, Heuristic h) {
   int count;
   Collection<Vertex> vertices_;
   Comparator<Vertex> comp;
   PriorityQueue<Vertex> fringe;
   count = 0;
   vertices_ = vertices.values();
   comp =
       new Comparator<Vertex>() {
         public int compare(Vertex i, Vertex j) {
           return (i.cost + i.estimate - j.cost - j.estimate);
         }
       }; // use estimates
   fringe = new PriorityQueue<Vertex>(20, comp);
   for (Vertex v : vertices_) {
     v.visited = false;
     v.cost = 999999;
   }
   start.cost = 0;
   start.parent = null;
   fringe.add(start);
   while (!fringe.isEmpty()) {
     Vertex v = fringe.remove(); // lowest-cost
     count++; // count nodes
     if (v.equals(goal)) { // if the goal is found, quit
       break;
     }
     if (!v.visited) {
       v.visited = true;
       for (Edge e : v.edges) {
         int newcost = v.cost + e.cost;
         if (newcost < e.target.cost) {
           e.target.cost = newcost;
           e.target.parent = v;
           e.target.estimate = h.fn(e.target, goal); // use heuristic
           fringe.add(e.target);
         }
       }
     }
   }
   return count;
 }
Exemple #15
0
 public static void computePaths(City source) {
   source.minDistance = 0.;
   PriorityQueue<City> cityQueue = new PriorityQueue<City>();
   cityQueue.add(source);
   while (!cityQueue.isEmpty()) {
     City u = cityQueue.poll();
     // Visit each edge exiting u
     for (Route e : u.neighbours) {
       City v = e.target;
       double weight = e.weight;
       double distanceThroughU = u.minDistance + weight;
       if (distanceThroughU < v.minDistance) {
         cityQueue.remove(v);
         v.minDistance = distanceThroughU;
         v.previous = u;
         cityQueue.add(v);
       }
     }
   }
 }
Exemple #16
0
 /**
  * 获取所得到的k个最近邻元组的多数类
  *
  * @param pq 存储k个最近近邻元组的优先级队列
  * @return 多数类的名称
  */
 private String getMostClass(PriorityQueue<KNNNode> pq) {
   Map<Double, Integer> classCount = new HashMap<Double, Integer>();
   for (int i = 0; i < pq.size(); i++) {
     KNNNode node = pq.remove();
     double c = node.getC();
     if (classCount.containsKey(c)) {
       classCount.put(c, classCount.get(c) + 1);
     } else {
       classCount.put(c, 1);
     }
   }
   int maxIndex = -1;
   int maxCount = 0;
   Object[] classes = classCount.keySet().toArray();
   for (int i = 0; i < classes.length; i++) {
     if (classCount.get(classes[i]) > maxCount) {
       maxIndex = i;
       maxCount = classCount.get(classes[i]);
     }
   }
   return classes[maxIndex].toString();
 }
Exemple #17
0
 public int prim(Vertex s) {
   int cost;
   Collection<Vertex> vertices_;
   Comparator<Vertex> comp;
   PriorityQueue<Vertex> fringe;
   cost = 0;
   vertices_ = vertices.values();
   comp =
       new Comparator<Vertex>() {
         public int compare(Vertex i, Vertex j) {
           return (i.cost - j.cost);
         }
       };
   fringe = new PriorityQueue<Vertex>(20, comp);
   for (Vertex v : vertices_) {
     v.visited = false;
     v.parent = null;
     v.cost = 999999;
   }
   s.cost = 0;
   fringe.add(s);
   while (!fringe.isEmpty()) {
     Vertex v = fringe.remove(); // lowest-cost
     if (!v.visited) {
       v.visited = true;
       cost += v.cost(); // calculate cost
       for (Edge e : v.edges) {
         if ((!e.target.visited) && (e.cost < e.target.cost)) {
           e.target.cost = e.cost;
           e.target.parent = v;
           fringe.add(e.target);
         }
       }
     }
   }
   return cost;
 }
 public static void print() {
   while (pq.peek() != null) {
     System.out.println(pq.remove().url);
   }
 }
Exemple #19
0
 public static void main(String[] args) throws Exception {
   BufferedReader br = new BufferedReader(new FileReader(new File(args[0])));
   BufferedWriter bw = new BufferedWriter(new FileWriter(args[1]));
   int T = Integer.parseInt(br.readLine());
   for (int t = 1; t <= T; t++) {
     br.readLine();
     List<List<Station>> graph = new ArrayList<>();
     int N = Integer.parseInt(br.readLine());
     for (int i = 0; i < N; i++) {
       graph.add(new ArrayList<>());
       String[] line1 = br.readLine().split(" ");
       int SN = Integer.parseInt(line1[0]);
       int W = Integer.parseInt(line1[1]);
       for (int j = 0; j < SN; j++) {
         graph.get(i).add(new Station(i, j, W));
       }
       String[] dist = br.readLine().split(" ");
       for (int j = 0; j < dist.length; j++) {
         int d = Integer.parseInt(dist[j]);
         Station s1 = graph.get(i).get(j);
         Station s2 = graph.get(i).get(j + 1);
         s1.neighbors.put(s2, d);
         s2.neighbors.put(s1, d);
       }
     }
     int tunnelNum = Integer.parseInt(br.readLine());
     for (int i = 0; i < tunnelNum; i++) {
       String[] tunnel = br.readLine().split(" ");
       int l1 = Integer.parseInt(tunnel[0]) - 1;
       int s1 = Integer.parseInt(tunnel[1]) - 1;
       int l2 = Integer.parseInt(tunnel[2]) - 1;
       int s2 = Integer.parseInt(tunnel[3]) - 1;
       int d = Integer.parseInt(tunnel[4]);
       Station sta1 = graph.get(l1).get(s1);
       Station sta2 = graph.get(l2).get(s2);
       sta1.neighbors.put(sta2, d + sta2.waitTime); // add wait time to distance
       sta2.neighbors.put(sta1, d + sta1.waitTime);
       Station sta11 = sta1.cloneForTunnel();
       Station sta22 = sta2.cloneForTunnel();
       graph.get(sta1.lineNo).add(sta11);
       graph.get(sta2.lineNo).add(sta22);
       for (Station st : sta11.neighbors.keySet()) {
         sta2.neighbors.put(
             st,
             d
                 + sta11.neighbors.get(
                     st)); // don't wait, sta11 means go xsfrom sta2 to sta1 than go to other
         // tunnel
       }
       for (Station st : sta22.neighbors.keySet()) {
         sta1.neighbors.put(st, d + sta22.neighbors.get(st));
       }
     }
     int queryNum = Integer.parseInt(br.readLine());
     bw.write("Case: #" + t + ":");
     bw.newLine();
     for (int i = 0; i < queryNum; i++) {
       String[] query = br.readLine().split(" ");
       int l1 = Integer.parseInt(query[0]) - 1;
       int s1 = Integer.parseInt(query[1]) - 1;
       int l2 = Integer.parseInt(query[2]) - 1;
       int s2 = Integer.parseInt(query[3]) - 1;
       Station sta1 = graph.get(l1).get(s1);
       Station sta2 = graph.get(l2).get(s2);
       PriorityQueue<Station> pq = new PriorityQueue<>();
       sta1.dist = sta1.waitTime;
       for (List<Station> line : graph) {
         for (Station st : line) {
           pq.offer(st);
         }
       }
       Set<Station> visited = new HashSet<>();
       visited.add(sta1);
       boolean done = false;
       while (!done && !pq.isEmpty()) {
         Station st = pq.poll();
         for (Station neb : st.neighbors.keySet()) {
           if (!visited.contains(neb)) {
             neb.dist = st.dist + st.neighbors.get(neb);
             if (neb == sta2) { // reference to same object
               done = true;
               break;
             }
             visited.add(neb);
             pq.remove(neb); // because need to let pq update this item's priority level
             pq.offer(neb);
           }
         }
       }
       int ret = sta2.dist == Integer.MAX_VALUE ? -1 : sta2.dist;
       bw.write("" + ret);
       bw.newLine();
     }
   }
   bw.close();
   br.close();
 }
  public ArrayList<ArrayList<Integer>> buildingOutline(int[][] buildings) {
    // buildings [[1,3,3], [2,4,4], [5,6,1]] => temp [[1,2,3],[2,3,4],[3,4,4],[5,6,1]] => result
    // [[1,2,3],[2,4,4],[5,6,1]]
    ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
    ArrayList<ArrayList<Integer>> temp = new ArrayList<ArrayList<Integer>>();
    if (buildings == null || buildings.length == 0) return result;
    int n = buildings.length;
    Point[] points = new Point[2 * n];
    for (int i = 0; i < n; i++) {
      points[2 * i] = new Point(buildings[i][0], true, buildings[i]);
      points[2 * i + 1] = new Point(buildings[i][1], false, buildings[i]);
    }
    Comparator<Point> c1 =
        new Comparator<Point>() {
          public int compare(Point p1, Point p2) {
            return p1.pos - p2.pos;
          }
        };
    Arrays.sort(points, c1); // sort points in ascending order

    Comparator<int[]> c2 =
        new Comparator<int[]>() {
          public int compare(int[] a, int[] b) {
            return b[2] - a[2];
          }
        };
    PriorityQueue<int[]> pq = new PriorityQueue<int[]>(1, c2); // max heap of buildings
    int open = 1, pre = points[0].pos, i = 1;
    pq.offer(points[0].building);
    while (i < 2 * n) {
      Point cur = points[i++];
      if (open == 0) {
        pre = cur.pos;
      }
      if (pre != cur.pos) {
        ArrayList<Integer> newB = new ArrayList<Integer>();
        newB.add(pre);
        newB.add(cur.pos);
        newB.add(pq.peek()[2]);
        temp.add(newB);
        pre = cur.pos;
      }
      if (cur.isS) {
        open++;
        pq.offer(cur.building);
      } else {
        open--;
        pq.remove(cur.building);
      }
    }

    // merge the adjacent outlines if they have the same height
    if (temp.size() == 0) return result;
    ArrayList<Integer> preB = temp.get(0);
    int s = preB.get(0), h = preB.get(2);
    int m = temp.size();
    for (int j = 1; j < m; j++) {
      if (temp.get(j).get(2) != h) {
        ArrayList<Integer> path = new ArrayList<Integer>();
        path.add(s); // start position
        path.add(temp.get(j - 1).get(1)); // end position
        path.add(h); // height
        result.add(path);
        s = temp.get(j).get(0);
        h = temp.get(j).get(2);
      }
    }
    ArrayList<Integer> path = new ArrayList<Integer>();
    path.add(s);
    path.add(temp.get(m - 1).get(1));
    path.add(h);
    result.add(path);
    return result;
  }
  /** ***************************************************************************** */
  void addEntry(String s) {
    // System.err.println("TRACX: " + s);
    if (trace_writer != null) trace_writer.println(s);

    char s0 = s.charAt(0);
    if (s0 == 'T') { // THREAD
      if (thread_entries != null) {
        for (TraceEntry te : thread_entries) pending_entries.add(te);
        thread_entries = null;
      }
      StringTokenizer tok = new StringTokenizer(s);
      tok.nextToken();
      int id = Integer.parseInt(tok.nextToken());
      current_thread = thread_map.get(id);
      if (current_thread == null) {
        int tid = Integer.parseInt(tok.nextToken());
        String tnm = tok.nextToken("\n");
        current_thread = new ThreadData(++thread_counter, tid, tnm);
        thread_map.put(id, current_thread);
      }
      thread_entries = new ArrayList<TraceEntry>();
    } else if (s0 == 'D') { // DONE
      if (trace_writer != null) trace_writer.flush();
      if (thread_entries != null) {
        for (TraceEntry te : thread_entries) pending_entries.add(te);
        thread_entries = null;
      }
      StringTokenizer tok = new StringTokenizer(s);
      tok.nextToken();
      long time = Long.parseLong(tok.nextToken());
      if (next_time != 0) {
        int ct = 0;
        // System.err.println("TRACE: Pending size = " + pending_entries.size());
        while (!pending_entries.isEmpty() && pending_entries.peek().getTime() < next_time) {
          TraceEntry te = pending_entries.remove();
          ++ct;
          outputEntry(te);
        }
        if (ct > 0) {
          for (BdynEventUpdater eu : update_listeners) {
            eu.eventsAdded();
          }
        }
        end_time = Math.max(next_time, end_time);
      }
      next_time = time;
    } else if (s0 == 'S') {
      if (cpu_time == null) {
        StringTokenizer tok = new StringTokenizer(s);
        tok.nextToken();
        cpu_time = Boolean.parseBoolean(tok.nextToken());
      }
    } else if (cpu_time != null) {
      TraceEntry te = new TraceEntry(s, current_thread, cpu_time);
      if (thread_entries == null) pending_entries.add(te);
      else {
        thread_entries.add(te);
        if (te.isExit()) {
          int sz = thread_entries.size();
          int loc = te.getEntryLocation();
          if (sz >= 4) {
            TraceEntry t3 = thread_entries.get(sz - 2);
            if (!t3.isExit() && t3.getEntryLocation() == loc) {
              TraceEntry t2 = thread_entries.get(sz - 3);
              if (t2.isExit() && t2.getEntryLocation() == loc) {
                TraceEntry t1 = thread_entries.get(sz - 4);
                if (!t1.isExit()
                    && t1.getEntryLocation() == loc
                    && (te.getTime() - t1.getTime()) < MERGE_TIME) {
                  t1.merge(t2.getTime(), t3.getTime(), te.getTime());
                  thread_entries.remove(sz - 2);
                  thread_entries.remove(sz - 3);
                }
              }
            }
          }
        }
      }
    }
  }
Exemple #22
0
  // Pick a target to shoot
  // Parameters:
  //  prevRound - an array of previous shoots, prevRound[i] is the player that player i shot
  //              -1 if player i did not shoot
  //  alive - an array of player's status, true if the player is still alive in this round
  // Return:
  //  int - the player id to shoot, return -1 if do not shoot anyone
  //
  public int shoot(int[] prevRound, boolean[] alive) {

    if (prevRound == null) {
      return -1; // Make love, not war
    }

    System.out.println(Arrays.toString(friends));

    // Keep track of who got shot, how many times earlier
    boolean[] shotAt = new boolean[prevRound.length];
    int[] shotBy = new int[prevRound.length];
    Arrays.fill(shotBy, -1);

    for (int player = 0; player < prevRound.length; player++) {
      if (prevRound[player] == -1) continue;
      shotBy[prevRound[player]] = player;
      shotAt[prevRound[player]] = true;
    }

    // bingyi
    for (int player = 0; player < prevRound.length; player++)
      record.get(player).add(prevRound[player]);

    // yash
    // call prediction function here
    predictNextRound(next_round, record, alive);

    // summing up next_round stats
    double[] next_round_sum = new double[nplayers];

    // add the columns of prediction matrix to get player most likely to be shot at
    for (int i = 0; i < nplayers; i++) {
      for (int j = 0; j < nplayers; j++) {
        next_round_sum[i] += next_round[j][i];
      }
    }

    // d
    System.out.println("Typical " + Arrays.toString(next_round_sum));

    for (int player = 0; player < prevRound.length; player++) {
      if (prevRound[player] != -1) whoShotWhomCount[player][prevRound[player]]++;
      gaugeSeverity(player, prevRound[player], alive, shotAt, shotBy, prevRound, next_round_sum);
    }
    // you shoot; he's still alive
    if (prevRound[this.id] != -1 && alive[prevRound[this.id]]) {
      priorityList.add(new PriorityTuple(prevRound[this.id], CON));
    }

    // Printing the next_round_sum array returned
    for (int i = 0; i < next_round.length; i++) {
      for (int j = 0; j < next_round.length; j++) {
        System.out.print(next_round[i][j]);
      }
      System.out.println();
    }

    /*
       int popular_target[]=new int[prevRound.length];
       int players[]=new int[prevRound.length];

       for(int i=0;i<players.length;i++)
       {
       	players[i]=i;
       }



       //sort player and popular_target arrays to get sorted list of targets
       for(int i=0;i<popular_target.length;i++)
       {
       	for(int j=0;j<popular_target.length-1;j++)
       	{
       		if(popular_target[j]<popular_target[j+1])
       		{
       			int temp=popular_target[j];
       			popular_target[j]=popular_target[j+1];
       			popular_target[j+1]=temp;
       			temp=players[j];
       			players[j]=players[j+1];
       			players[j+1]=temp;
       		}
       	}
       }
       //We only need the most likely target, but I'm sorting the list just to get an idea of what our targets are like

       //printing players and their likeliness to be shot
       for(int j=0;j<prediction.length;j++)
    {
    	System.out.print("("+players[j]+","+popular_target[j]+") ");
    }
    System.out.println();

       */
    /*
          //shoot the most likely player if he is not a friend
          for(int i=0;i<popular_target.length;i++)
          {
          //	if((isEnemy(players[i]) || isNeutral(players[i])) && players[i]!=this.id && alive[players[i]])
          	if((isEnemy(players[i]) || Enemyus(players[i], record) || EnemyourAF(players[i], record, alive))&& players[i]!=this.id && alive[players[i]])
    {
          		return players[i];
          	}
          }
          */

    // Choose whom to shoot

    // if no enemies or neutrals are to be shot at
    if (priorityList.size() == 0) {
      priorityList.clear();
      return -1;
    }
    // yash

    // ArrayList<Integer> targets=new ArrayList<Integer>();
    int target;
    PriorityTuple firstTuple;
    double maxNextRoundSum;
    try {
      do {
        firstTuple = priorityList.remove();

        maxNextRoundSum = next_round_sum[firstTuple.playerId];
        target = firstTuple.playerId;
        // targets.add(firstTuple.playerId);
      } while (isFriend(target));
    } catch (NullPointerException e) {
      return -1;
    }

    while (priorityList.size() != 0 && firstTuple.priority == priorityList.peek().priority) {
      PriorityTuple anotherTuple = priorityList.remove();
      // targets.add(tupleToAdd.playerId);
      if (next_round_sum[anotherTuple.playerId] > maxNextRoundSum) {
        maxNextRoundSum = next_round_sum[anotherTuple.playerId];
        target = anotherTuple.playerId;
      }
    }

    priorityList.clear();
    return target;

    //        System.out.println("this is our hate most list\n");
    //        printListofArray(hate_most);
    //        if(priorityList.size()==0)
    //        	return -1;
    //
    //        attentionSeekingPrint(priorityList.toString());

    //        int myTarget=getMyTarget(shotAt);
    //        priorityList.clear();
    //    	 //bingyi
    //        printMatrix(record);
    //        //bingyi
    //        return myTarget;
  }
Exemple #23
0
  private List<Haplotype> computeHaplotypes(
      final ReadBackedPileup pileup,
      final int contextSize,
      final int locus,
      final VariantContext vc) {
    // Compute all possible haplotypes consistent with current pileup

    int haplotypesToCompute = vc.getAlternateAlleles().size() + 1;

    final PriorityQueue<Haplotype> candidateHaplotypeQueue =
        new PriorityQueue<Haplotype>(100, new HaplotypeComparator());
    final PriorityQueue<Haplotype> consensusHaplotypeQueue =
        new PriorityQueue<Haplotype>(
            MAX_CONSENSUS_HAPLOTYPES_TO_CONSIDER, new HaplotypeComparator());

    for (final PileupElement p : pileup) {
      final Haplotype haplotypeFromRead = getHaplotypeFromRead(p, contextSize, locus);
      candidateHaplotypeQueue.add(haplotypeFromRead);
    }

    // Now that priority queue has been built with all reads at context, we need to merge and find
    // possible segregating haplotypes
    Haplotype elem;
    while ((elem = candidateHaplotypeQueue.poll()) != null) {
      boolean foundHaplotypeMatch = false;
      Haplotype lastCheckedHaplotype = null;
      for (final Haplotype haplotypeFromList : consensusHaplotypeQueue) {
        final Haplotype consensusHaplotype = getConsensusHaplotype(elem, haplotypeFromList);
        if (consensusHaplotype != null) {
          foundHaplotypeMatch = true;
          if (consensusHaplotype.getQualitySum() > haplotypeFromList.getQualitySum()) {
            consensusHaplotypeQueue.remove(haplotypeFromList);
            consensusHaplotypeQueue.add(consensusHaplotype);
          }
          break;
        } else {
          lastCheckedHaplotype = haplotypeFromList;
        }
      }

      if (!foundHaplotypeMatch
          && consensusHaplotypeQueue.size() < MAX_CONSENSUS_HAPLOTYPES_TO_CONSIDER) {
        consensusHaplotypeQueue.add(elem);
      } else if (!foundHaplotypeMatch
          && lastCheckedHaplotype != null
          && elem.getQualitySum() > lastCheckedHaplotype.getQualitySum()) {
        consensusHaplotypeQueue.remove(lastCheckedHaplotype);
        consensusHaplotypeQueue.add(elem);
      }
    }

    // Now retrieve the N most popular haplotypes
    if (consensusHaplotypeQueue.size() > 0) {
      // The consensus haplotypes are in a quality-ordered priority queue, so the best haplotypes
      // are just the ones at the front of the queue
      final Haplotype haplotype1 = consensusHaplotypeQueue.poll();

      List<Haplotype> hlist = new ArrayList<Haplotype>();
      hlist.add(new Haplotype(haplotype1.getBases(), 60));

      for (int k = 1; k < haplotypesToCompute; k++) {
        Haplotype haplotype2 = consensusHaplotypeQueue.poll();
        if (haplotype2 == null) {
          haplotype2 = haplotype1;
        } // Sometimes only the reference haplotype can be found
        hlist.add(new Haplotype(haplotype2.getBases(), 20));
      }
      return hlist;
    } else return null;
  }
Exemple #24
0
  /**
   * Does Dijkstra and returns the a 1d structure that can be treated as 2d
   *
   * @param board
   * @param hero
   * @return
   */
  private static List<Vertex> doDijkstra(GameState.Board board, GameState.Hero hero) {
    List<Vertex> vertexes = new LinkedList<Vertex>();
    Vertex me = null;

    // Build the graph sans edges

    for (int row = 0; row < board.getSize(); row++) {
      for (int col = 0; col < board.getSize(); col++) {
        Vertex v = new Vertex();
        GameState.Position pos = new GameState.Position(row, col);
        int tileStart = row * board.getSize() * 2 + (col * 2);
        v.setTileType(board.getTiles().substring(tileStart, tileStart + 1 + 1));
        v.setPosition(pos);
        vertexes.add(v);
      }
    }

    // Add in the edges
    for (int i = 0; i < board.getSize() * board.getSize(); i++) {
      int row = i % (board.getSize());
      int col = i / board.getSize();

      Vertex v = vertexes.get(i);

      // Check:  Is this us?
      if (v.getPosition().getX() == hero.getPos().getX()
          && v.getPosition().getY() == hero.getPos().getY()) me = v;
      if (v.getTileType().equals("##")
          || v.getTileType().equals("[]")
          || v.getTileType().startsWith("$"))
        // Impassable tiles link to nowhere.
        continue;

      // Make sure not to link to impassable blocks that don't have a function
      // Make sure you don't link impassable blocks to other blocks (you can't go from the pub to
      // somewhere else)
      for (int j = col - 1; j <= col + 1; j += 2) {
        if (j >= 0 && j < board.getSize()) {
          Vertex adjacentV = vertexes.get(j * board.getSize() + row);
          v.getAdjacencies().add(adjacentV);
        }
      }
      for (int j = row - 1; j <= row + 1; j += 2) {
        if (j >= 0 && j < board.getSize()) {
          Vertex adjacentV = vertexes.get(col * board.getSize() + j);
          v.getAdjacencies().add(adjacentV);
        }
      }
    }

    // Zok, we have a graph constructed.  Traverse.
    PriorityQueue<Vertex> vertexQueue = new PriorityQueue<Vertex>();
    vertexQueue.add(me);
    me.setMinDistance(0);

    while (!vertexQueue.isEmpty()) {
      Vertex v = vertexQueue.poll();
      double distance = v.getMinDistance() + 1;

      for (Vertex neighbor : v.getAdjacencies()) {
        if (distance < neighbor.getMinDistance()) {
          neighbor.setMinDistance(distance);
          neighbor.setPrevious(v);
          vertexQueue.remove(neighbor);
          vertexQueue.add(neighbor);
        }
      }
    }

    return vertexes;
  }
Exemple #25
0
  /**
   * routing using A* algorithm http://en.wikipedia.org/wiki/A*_search_algorithm
   *
   * @param startNode
   * @param endNode
   * @param startTime
   * @param dayIndex
   * @param pathNodeList return path
   * @return
   */
  public static double routingAStar(
      long startNode, long endNode, int startTime, int dayIndex, ArrayList<Long> pathNodeList) {
    // System.out.println("start finding the path...");
    int debug = 0;
    double totalCost = -1;
    try {
      // test store transversal nodes
      // HashSet<Long> transversalSet = new HashSet<Long>();

      if (!OSMData.nodeHashMap.containsKey(startNode)
          || !OSMData.nodeHashMap.containsKey(endNode)) {
        System.err.println("cannot find start or end node!");
        return -1;
      }

      if (startNode == endNode) {
        System.out.println("start node is the same as end node.");
        return 0;
      }

      HashSet<Long> closedSet = new HashSet<Long>();
      HashMap<Long, NodeInfoHelper> nodeHelperCache = new HashMap<Long, NodeInfoHelper>();

      PriorityQueue<NodeInfoHelper> openSet =
          initialStartSet(startNode, endNode, startTime, dayIndex, nodeHelperCache);
      HashSet<Long> endSet = initialEndSet(endNode);

      NodeInfoHelper current = null;

      while (!openSet.isEmpty()) {
        // remove current from openset
        current = openSet.poll();

        // if(!transversalSet.contains(current.getNodeId()))
        //	transversalSet.add(current.getNodeId());

        long nodeId = current.getNodeId();
        // add current to closedset
        closedSet.add(nodeId);
        if (endSet.contains(nodeId)) { // find the destination
          current = current.getEndNodeHelper(endNode);
          totalCost = current.getCost();
          break;
        }
        // for time dependent routing
        int timeIndex =
            startTime
                + (int)
                    (current.getCost() / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL);
        if (timeIndex
            > OSMRouteParam.TIME_RANGE
                - 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights
        timeIndex = OSMRouteParam.TIME_RANGE - 1;
        LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(nodeId);
        if (adjNodeList == null) continue; // this node cannot go anywhere
        double arriveTime = current.getCost();
        // for each neighbor in neighbor_nodes(current)
        for (ToNodeInfo toNode : adjNodeList) {
          debug++;
          long toNodeId = toNode.getNodeId();
          int travelTime;
          if (toNode.isFix()) // fix time
          travelTime = toNode.getTravelTime();
          else // fetch from time array
          travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex);
          // tentative_g_score := g_score[current] + dist_between(current,neighbor)
          double costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND;
          // tentative_f_score := tentative_g_score + heuristic_cost_estimate(neighbor, goal)
          double heuristicTime = estimateHeuristic(toNodeId, endNode);
          double totalCostTime = costTime + heuristicTime;
          // if neighbor in closedset and tentative_f_score >= f_score[neighbor]
          if (closedSet.contains(toNodeId)
              && nodeHelperCache.get(toNodeId).getTotalCost() <= totalCostTime) {
            continue;
          }
          NodeInfoHelper node = null;
          // if neighbor not in openset or tentative_f_score < f_score[neighbor]
          if (!nodeHelperCache.containsKey(toNodeId)) { // neighbor not in openset
            node = new NodeInfoHelper(toNodeId);
            nodeHelperCache.put(node.getNodeId(), node);
          } else if (nodeHelperCache.get(toNodeId).getTotalCost()
              > totalCostTime) { // neighbor in openset
            node = nodeHelperCache.get(toNodeId);
            if (closedSet.contains(toNodeId)) { // neighbor in closeset
              closedSet.remove(toNodeId); // remove neighbor form colseset
            } else {
              openSet.remove(node);
            }
          }

          // neighbor need update
          if (node != null) {
            node.setCost(costTime);
            node.setHeuristic(heuristicTime);
            node.setParentId(nodeId);
            openSet.offer(node); // add neighbor to openset again
          }
        }
      }
      if (totalCost != -1) {
        long traceNodeId = current.getNodeId();
        pathNodeList.add(traceNodeId); // add end node
        traceNodeId = current.getParentId();
        while (traceNodeId != 0) {
          pathNodeList.add(traceNodeId); // add node
          current = nodeHelperCache.get(traceNodeId);
          traceNodeId = current.getParentId();
        }
        Collections.reverse(pathNodeList); // reverse the path list
        // System.out.println("find the path successful!");
      } else {
        System.out.println("can not find the path!");
      }
      // OSMOutput.generateTransversalNodeKML(transversalSet, nodeHashMap);
    } catch (Exception e) {
      e.printStackTrace();
      System.err.println(
          "tdsp: debug code " + debug + ", start node " + startNode + ", end node " + endNode);
    }
    return totalCost;
  }
Exemple #26
0
  @Override
  public void run() {
    // TODO Auto-generated method stub
    PriorityQueue<NodeInfoHelper> openSet =
        new PriorityQueue<NodeInfoHelper>(
            10000,
            new Comparator<NodeInfoHelper>() {
              public int compare(NodeInfoHelper n1, NodeInfoHelper n2) {
                return (int) (n1.getTotalCost() - n2.getTotalCost());
              }
            });
    HashSet<Long> closedSet = new HashSet<Long>();
    initialEndSet(startNode, endNode, openSet, nodeHelperCache);

    NodeInfoHelper current = null;

    // HashSet<Long> transversalSet = new HashSet<Long>();

    while (!openSet.isEmpty()) {
      // remove current from openset
      current = openSet.poll();

      long nodeId = current.getNodeId();
      // transversalSet.add(nodeId);
      // add current to closedset
      closedSet.add(nodeId);

      // check if forward searching finish
      if (sharingData.isSearchingFinish()) break;
      // add to reverse cover nodes, only add the nodes on the highway
      if (current.getCurrentLevel() == 1) sharingData.addReverseNode(nodeId);

      NodeInfo fromNodeInfo = OSMData.nodeHashMap.get(nodeId);

      LinkedList<ToNodeInfo> adjNodeList = adjListHashMap.get(nodeId);
      if (adjNodeList == null) continue; // this node cannot go anywhere
      double arriveTime = current.getCost();
      // for each neighbor in neighbor_nodes(current)
      for (ToNodeInfo toNode : adjNodeList) {
        long toNodeId = toNode.getNodeId();
        NodeInfo toNodeInfo = OSMData.nodeHashMap.get(toNodeId);
        EdgeInfo edgeInfo = fromNodeInfo.getEdgeFromNodes(toNodeInfo);
        // check if "highway" not found in param, add it
        // String highway = edgeInfo.getHighway();
        int level = 10;
        if (OSMData.hierarchyHashMap.containsKey(edgeInfo.getHighway()))
          level = OSMData.hierarchyHashMap.get(edgeInfo.getHighway());
        // 1) always level up, e.g. currently in primary, never go secondary
        // if(level > current.getCurrentLevel()) {	// do not level down
        //	continue;
        // }
        // 2) keep on highway
        if (current.getCurrentLevel() == 1 && level > 1) {
          continue;
        }
        int travelTime = toNode.getMinTravelTime();

        // tentative_g_score := g_score[current] + dist_between(current,neighbor)
        double costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND;
        // tentative_f_score := tentative_g_score + heuristic_cost_estimate(neighbor, goal)
        double heuristicTime = OSMRouting.estimateHeuristic(toNodeId, endNode);
        double totalCostTime = costTime + heuristicTime;
        // if neighbor in closedset and tentative_f_score >= f_score[neighbor]
        if (closedSet.contains(toNodeId)
            && nodeHelperCache.get(toNodeId).getTotalCost() <= totalCostTime) {
          continue;
        }
        NodeInfoHelper node = null;
        // if neighbor not in openset or tentative_f_score < f_score[neighbor]
        if (!nodeHelperCache.containsKey(toNodeId)) { // neighbor not in openset
          node = new NodeInfoHelper(toNodeId);
          nodeHelperCache.put(node.getNodeId(), node);
        } else if (nodeHelperCache.get(toNodeId).getTotalCost()
            > totalCostTime) { // neighbor in openset
          node = nodeHelperCache.get(toNodeId);
          if (closedSet.contains(toNodeId)) { // neighbor in closeset
            closedSet.remove(toNodeId); // remove neighbor form colseset
          } else {
            openSet.remove(node);
          }
        }

        // neighbor need update
        if (node != null) {
          node.setCost(costTime);
          node.setHeuristic(heuristicTime);
          node.setCurrentLevel(level);
          node.setParentId(nodeId);
          openSet.offer(node); // add neighbor to openset again
        }
      }
    }
    // OSMOutput.generateTransversalNodeKML(transversalSet, nodeHashMap, "reverse_transversal");
  }
Exemple #27
0
  @Override
  public void run() {
    HashSet<Long> closedSet = new HashSet<Long>();
    PriorityQueue<NodeInfoHelper> openSet =
        OSMRouting.initialStartSet(startNode, endNode, startTime, dayIndex, nodeHelperCache);

    NodeInfoHelper current = null;
    // test
    // HashSet<Long> transversalSet = new HashSet<Long>();
    while (!openSet.isEmpty()) {
      // remove current from openset
      current = openSet.poll();

      long nodeId = current.getNodeId();

      // transversalSet.add(nodeId);

      // add current to closedset
      closedSet.add(nodeId);

      // check reverse searching covering nodes
      if (sharingData.isNodeInReverseSet(nodeId)) {
        // we found a path, stop here
        sharingData.addIntersect(nodeId);
        if (sharingData.isSearchingFinish()) break;
        else continue;
      }

      NodeInfo fromNodeInfo = OSMData.nodeHashMap.get(nodeId);
      // for time dependent routing in forwarding search
      int timeIndex =
          startTime
              + (int)
                  (current.getCost() / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL);
      if (timeIndex
          > OSMRouteParam.TIME_RANGE
              - 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights
      timeIndex = OSMRouteParam.TIME_RANGE - 1;

      LinkedList<ToNodeInfo> adjNodeList = adjListHashMap.get(nodeId);
      if (adjNodeList == null) continue; // this node cannot go anywhere
      double arriveTime = current.getCost();
      // for each neighbor in neighbor_nodes(current)
      for (ToNodeInfo toNode : adjNodeList) {
        long toNodeId = toNode.getNodeId();
        NodeInfo toNodeInfo = OSMData.nodeHashMap.get(toNodeId);
        EdgeInfo edgeInfo = fromNodeInfo.getEdgeFromNodes(toNodeInfo);
        // check if "highway" not found in param, add it
        // String highway = edgeInfo.getHighway();
        int level = 10;
        if (OSMData.hierarchyHashMap.containsKey(edgeInfo.getHighway()))
          level = OSMData.hierarchyHashMap.get(edgeInfo.getHighway());
        // 1) always level up, e.g. currently in primary, never go secondary
        // if(level > current.getCurrentLevel()) {	// do not level down
        //	continue;
        // }
        // 2) keep on highway
        if (current.getCurrentLevel() == 1 && level > 1) {
          continue;
        }
        int travelTime;
        // forward searching is time dependent
        if (toNode.isFix()) // fix time
        travelTime = toNode.getTravelTime();
        else // fetch from time array
        travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex);

        // tentative_g_score := g_score[current] + dist_between(current,neighbor)
        double costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND;
        // tentative_f_score := tentative_g_score + heuristic_cost_estimate(neighbor, goal)
        double heuristicTime = OSMRouting.estimateHeuristic(toNodeId, endNode);
        double totalCostTime = costTime + heuristicTime;
        // if neighbor in closedset and tentative_f_score >= f_score[neighbor]
        if (closedSet.contains(toNodeId)
            && nodeHelperCache.get(toNodeId).getTotalCost() <= totalCostTime) {
          continue;
        }
        NodeInfoHelper node = null;
        // if neighbor not in openset or tentative_f_score < f_score[neighbor]
        if (!nodeHelperCache.containsKey(toNodeId)) { // neighbor not in openset
          node = new NodeInfoHelper(toNodeId);
          nodeHelperCache.put(node.getNodeId(), node);
        } else if (nodeHelperCache.get(toNodeId).getTotalCost()
            > totalCostTime) { // neighbor in openset
          node = nodeHelperCache.get(toNodeId);
          if (closedSet.contains(toNodeId)) { // neighbor in closeset
            closedSet.remove(toNodeId); // remove neighbor form colseset
          } else {
            openSet.remove(node);
          }
        }

        // neighbor need update
        if (node != null) {
          node.setCost(costTime);
          node.setHeuristic(heuristicTime);
          node.setCurrentLevel(level);
          node.setParentId(nodeId);
          openSet.offer(node); // add neighbor to openset again
        }
      }
    }
    // test
    // OSMOutput.generateTransversalNodeKML(transversalSet, "forward_transversal");
  }
  public List<Vehicle> distribute() {

    List<Vehicle> vehicles = new LinkedList<Vehicle>();
    PriorityQueue<Path> ps = getSavedPaths();
    List<Path> paths = new LinkedList<Path>();
    Path[] tmpPath = new Path[ps.size()];

    for (int j = 0; j < tmpPath.length; j++) {
      tmpPath[j] = ps.remove();
    }
    for (int j = tmpPath.length - 1; j >= 0; j--) {
      System.out.println(tmpPath[j]);
      paths.add(tmpPath[j]);
    }

    while (!isDone(vehicles)) {
      List<Path> p = new LinkedList<Path>();
      Vehicle vehicle = new Vehicle();
      if (getRemainingRequireMents(vehicles) > Vehicle.getMaxMaxLoad()) {
        vehicle.setLoad(Vehicle.getMaxMaxLoad());
      } else {
        vehicle.setLoad(getRemainingRequireMents(vehicles));
      }
      Client[] c = new Client[1];
      c[0] = clients[0];
      vehicle.setClients(c);
      boolean pathAdded = false;
      for (int i = 0; i < paths.size(); i++) {
        Path path = paths.get(i);
        if (validate(vehicle, p, path)) {
          p.add(path);
          //  System.out.println("add path " + path);
          vehicle.setClients(getPath(p));
          paths.remove(i);
          //    System.out.println("remove " + path);
          pathAdded = true;
        }
      }

      if (pathAdded) {
        vehicles.add(vehicle);
      }

      /*将已经配送过的点的边,去掉*/
      for (Vehicle v1 : vehicles) {
        for (Client client : v1.getClients()) {
          // System.out.println("Client:"+client);

          Object[] pathsArray = paths.toArray();
          for (int i = 0; i < pathsArray.length; i++) {
            Path path = (Path) pathsArray[i];
            // System.out.println("Path to validate "+ path);
            if ((path.getEnd() == client)) {
              //    System.out.println("end remove " + path);
              paths.remove(path);
            }
            if (path.getStart() == client) {
              //   System.out.println("start remove " + path);
              paths.remove(path);
            }
          }
        }
      }

      /*如果一条边上的点requirement 之和大于vehicle的载重,去掉。*/
      Object[] pathArray = paths.toArray();
      for (int i = 0; i < pathArray.length; i++) {
        Path path = (Path) pathArray[i];
        if (path.getEnd().getRequirement() + path.getStart().getRequirement()
            > vehicle.getMaxLoad()) {
          paths.remove(path);
        }
      }

      // 最后还有一些孤立的配送点需要配送
      if (paths.size() == 0) {

        List<Client> remainingClients = getRemainingClient(vehicles);
        for (Client client : remainingClients) {
          Client[] c0 = new Client[3];
          c0[0] = clients[0];
          c0[1] = client;
          c0[2] = clients[0];
          Vehicle vehicle1 = new Vehicle();
          if (getRemainingRequireMents(vehicles) > Vehicle.getMaxMaxLoad()) {
            vehicle1.setLoad(Vehicle.getMaxMaxLoad());
          } else {
            vehicle1.setLoad(getRemainingRequireMents(vehicles));
          }
          vehicle1.setClients(c0);
          vehicles.add(vehicle1);
        }
        return vehicles;
      }
    }
    return vehicles;
  }