SGU updated

Author: coderxiang

SGU/148.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <cstdio>
+#include <queue>
+#include <algorithm>
+
+using namespace std;
+
+const int N = 15011;
+
+int W[N], L[N], P[N];
+int sp[N];
+
+int main () {
+	int i, j, k;
+	int m;
+	scanf ("%d", &m);
+	for (i = 1; i <= m; ++i) {
+		scanf ("%d%d%d", &W[i], &L[i], &P[i]);
+		sp[i] = sp[i - 1] + W[i];
+	}
+
+	priority_queue<pair<int,int> > pq;
+	int s = 0, best = P[m], ans = m;
+	for (i = m; i >= 1; --i) {
+		while (!pq.empty ()) {
+			int u = pq.top ().first, id = pq.top ().second;
+			if (u > sp[i - 1]) {
+				s -= P[id];
+				pq.pop ();
+			}
+			else break;
+		}
+		s += P[i];
+		if (s < best) {
+			best = s;
+			ans = i;
+		}
+		pq.push ({sp[i] - L[i], i});
+	}
+	for (i = ans; i <= m; ++i) if (sp[i] - sp[ans - 1] <= L[i])
+		printf ("%d\n", i);
+	return 0;
+}

SGU/148_MLE.java

@@ -0,0 +1,62 @@
+import java.io.*;
+import java.util.*;
+import java.math.*;
+
+
+public class Solution {
+	class P implements Comparable <P>{
+		int v, id;
+		P () {}
+		P (int v, int id) {
+			this.v = v;
+			this.id = id;
+		}
+		public int compareTo (P e) {
+			return e.v - this.v;
+		}
+	}
+	final static int N = 15011;
+	
+	void SGU149 () {
+		int [] W = new int [N];
+		int [] L = new int [N];
+		int [] P = new int [N];
+		int [] sp = new int [N];
+		int m, i;
+		@SuppressWarnings("resource")
+		Scanner in = new Scanner (new BufferedInputStream (System.in));
+		m = in.nextInt ();
+		sp[0] = 0;
+		for (i = 1; i <= m; ++i) {
+			W[i] = in.nextInt(); L[i] = in.nextInt();
+			P[i] = in.nextInt();
+			sp[i] = sp[i - 1] + W[i];
+		}
+		int ans = m, best = P[m];
+		PriorityQueue<P> pq = new PriorityQueue<P> ();
+		int s = 0;
+		for (i = m; i >= 1; --i) {
+			while (!pq.isEmpty()) {
+				P u = pq.peek();
+				if (u.v > sp[i-1]) {
+					s -= P[u.id];
+					pq.poll ();
+				}
+				else break;
+			}
+			s += P[i];
+			if (s < best) {
+				best = s;
+				ans = i;
+			}
+			pq.add(new P(sp[i] - L[i], i));
+		}
+		for (i = ans; i <= m; ++i)
+			if (sp[i] - sp[ans - 1] <= L[i])
+				System.out.printf ("%d\n", i);
+	}
+	public static void main(String[] args) {
+		Solution lebesgue = new Solution ();
+		lebesgue.SGU149 ();
+	}
+}

SGU/149.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+const int N = 10011;
+
+vector<pair<int, int> >a[N];
+int disx[N], disy[N], dis[N], n;
+bool st[N];
+int x, y, mx, my;
+
+int main () {
+	int i, j, k;
+	queue<int> q;
+	//freopen ("in", "r", stdin);
+	
+	scanf ("%d", &n);
+	for (i = 2; i <= n; ++i) {
+		scanf ("%d%d", &j, &k);
+		a[i].push_back ({j, k});
+		a[j].push_back ({i, k});
+	}
+	fill (dis, dis + n + 1, -1);
+	fill (disx, disx + n + 1, -1);
+	fill (disy, disy + n + 1, -1);
+	
+	mx = my = -1; x = y = 1;
+	q.push (1); dis[1] = 0;
+	while (!q.empty ()) {
+		int u = q.front (); q.pop ();
+		k = a[u].size ();
+		for (j = 0; j < k; ++j) {
+			int v = a[u][j].first, w = a[u][j].second;
+			if (dis[v]==-1) {
+				dis[v] = dis[u] + w;
+				if (dis[v] > mx) {
+					mx = dis[v];
+					x = v;
+				}
+				q.push (v);
+			}
+		}
+	}
+
+	q.push (x); disx[x] = 0;
+	while (!q.empty ()) {
+		int u = q.front (); q.pop ();
+		k = a[u].size ();
+		for (j = 0; j < k; ++j) {
+			int v = a[u][j].first, w = a[u][j].second;
+			if (disx[v] == -1) {
+				disx[v] = disx[u] + w;
+				if (disx[v] > my) {
+					my = disx[v];
+					y = v;
+				}
+				q.push (v);
+			}
+		}
+	}
+
+	q.push (y); disy[y] = 0;
+	while (!q.empty ()) {
+		int u = q.front (); q.pop ();
+		k = a[u].size ();
+		for (j = 0; j < k; ++j) {
+			int v = a[u][j].first, w = a[u][j].second;
+			if (disy[v] == -1) {
+				disy[v] = disy[u] + w;
+				q.push (v);
+			}
+		}
+	}
+	for (i = 1; i <= n; ++i)
+		printf ("%d\n", max (disx[i], disy[i]));
+	return 0;
+}
+
+	
+	
+	

SGU/149_MLE.java

@@ -0,0 +1,105 @@
+import java.io.BufferedInputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Scanner;
+
+
+public class Solution {
+
+	/**
+	 * @param args
+	 */
+	class E {
+		int x, d;
+		E (int x, int d) {
+			this.x = x;
+			this.d = d;
+		}
+	}
+	
+	public void solve () {
+		Scanner in = new Scanner (new BufferedInputStream (System.in));
+		int n = in.nextInt ();
+		int i, j, k;
+		
+		ArrayList<E> [] a = new ArrayList [n + 1];
+		int [] dis = new int[n];
+		int [] disx = new int[n];
+		int [] disy = new int[n];
+		
+		int mx, my, x, y;
+		
+		for (i = 0; i < n; ++i) 
+			a[i] = new ArrayList<E> ();
+		
+		for (i = 1; i < n; ++i) {
+			j = in.nextInt (); --j;
+			k = in.nextInt ();
+			a[i].add (new E (j, k));
+			a[j].add (new E (i, k));
+		}
+		
+		Arrays.fill(dis, -1);
+		Arrays.fill(disx, -1);
+		Arrays.fill(disy, -1);
+		
+		Queue<Integer> q = new LinkedList<Integer> ();
+		q.add (1); 
+		dis[1] = 0; mx = -1; my = -1; x = 0; y = 0;
+		while (!q.isEmpty()) {
+			int u = q.poll();
+			for (E e : a[u]) {
+				int v = e.x, d = e.d;
+				if (dis[v] == -1) {
+					dis[v] = dis[u] + d;
+					if (dis[v] > mx) {
+						mx = dis[v];
+						x = v;
+					}
+					q.add (v);
+				}
+			}
+		}
+		
+		q.add (x);
+		disx[x] = 0;
+		while (!q.isEmpty()) {
+			int u = q.poll ();
+			for (E e : a[u]) {
+				int v = e.x, d = e.d;
+				if (disx[v] == -1) {
+					disx[v] = disx[u] + d;
+					if (disx[v] > my) {
+						my = disx[v];
+						y = v;
+					}
+					q.add(v);
+				}
+			}
+		}
+		
+		q.add (y);
+		disy[y] = 0;
+		while (!q.isEmpty()) {
+			int u = q.poll ();
+			for (E e : a[u]) {
+				int v = e.x, d = e.d;
+				if (disy[v] == -1) {
+					disy[v] = disy[u] + d;
+					q.add(v);
+				}
+			}
+		}
+		for (i = 0; i < n; ++i)
+			System.out.printf("%d\n", Math.max (disx[i], disy[i]));
+	}
+	
+	public static void main(String[] args) {
+		Solution solution = new Solution ();
+		solution.solve ();
+	}
+		
+}
+