import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

public class DetermNetwork {
	class Node {
		public int id = 0;
		public HashSet<Node> neighbors = new HashSet<Node>();
		public HashMap<Integer, Double> values = new HashMap<Integer, Double>();
		public double threshold = 0.0;
		public boolean active = false;
		
		public Node(int id, double threshold) {
			this.id = id;
			this.threshold = threshold;
		}
		
		public String toString() {
			return id + ":" + threshold;
		}
	}
	
	Map<Integer, Node> network;
	int numNodes;
	
	public DetermNetwork ( String filename ) throws NumberFormatException, IOException {
		network = new HashMap<Integer, Node>();
		
		BufferedReader inputStream = new BufferedReader(new FileReader(filename));
		numNodes = Integer.parseInt(inputStream.readLine());
		String line;

		while ((line = inputStream.readLine()) != null) {
			String[] params = line.split(" ");
			if (params.length == 2) {
				int id = Integer.parseInt(params[0]);
				double threshold = Double.parseDouble(params[1]);
				network.put(id, new Node(id, threshold));
			} else {
				int id1 = Integer.parseInt(params[0]);
				int id2 = Integer.parseInt(params[1]);
				double bias = Double.parseDouble(params[2]);
				
				Node n1 = network.get(id1);
				Node n2 = network.get(id2);
				n1.values.put(id2, bias);
				n2.neighbors.add(n1);
			}
		}
	}
	
	private void activate (Node n, ArrayList<Node> toCheck) {
		n.active = true;
		
		Iterator<Node> neighbors = n.neighbors.iterator();
		while (neighbors.hasNext()) {
			
			Node next = neighbors.next();
			
			if (next.active == false) {
				toCheck.add(next);				
			}
			
		}
	}
	
	private double pressure (Node n) {
		double pressure = 0.0;
		
		Iterator<Integer> values = n.values.keySet().iterator();
		
		while (values.hasNext()) {
			int v = values.next();
			if (network.get(v).active) {
				pressure += n.values.get(v);
			}
		}
		
		return pressure;
	}
	
	public ArrayList<Integer> runTest(ArrayList<Integer> initialActiveNodes) {
		HashSet<Integer> activated = new HashSet<Integer>();
		ArrayList<Node> toCheck = new ArrayList<Node>();		

		Iterator<Integer> iter = initialActiveNodes.iterator();
		while (iter.hasNext()) {
			int active = iter.next();
			this.activate(network.get(active), toCheck);
			activated.add(active);
		}		
		
		while (!toCheck.isEmpty()) {
			Node n = toCheck.remove(0);
			
			double pressure = this.pressure(n);
			if (pressure >= n.threshold) {
				this.activate(n, toCheck);
				activated.add(n.id);
			}
		}
	
		ArrayList<Integer> result = new ArrayList<Integer>(activated);
		Collections.sort(result);
		return result;
	}
}