tccc 2003 semi 4 275

Author: keshavnandan

Diff for: Circuits.cpp

@@ -0,0 +1,87 @@
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <set>
+#include <map>
+#include <queue>
+#include <cstring>
+#include <climits>
+using namespace std;
+typedef pair<int,int> pi;
+typedef vector<int> vi;
+typedef vector<vi> vvi;
+typedef vector<string> vs;
+typedef vector<vs> vvs;
+int M[55][55];
+int v[55];
+int n;
+
+class Circuits {
+        public:
+        int dfs(int s, int c = 0){
+            v[s] = 1;
+            int rc = 0;
+            for(int i = 0; i < n; i++){
+                if((v[i] == 0 || v[i] == 2) && M[s][i]){
+                    v[i] = 1;
+                    rc = max(rc, dfs(i)+M[s][i]);
+                }
+            }
+            v[s] = 2;
+            return rc+c;
+        }
+
+        int howLong(vector <string> connects, vector <string> costs)
+        {
+            n = costs.size();
+            for(int i = 0; i < n; i++)
+                for(int j = 0; j < n; j++)
+                    M[i][j] = 0;
+
+            for(int i = 0; i < n; i++){
+                string s = connects[i], t = costs[i];
+                int j, c;
+                stringstream ss(s), st(t);
+                while(ss>>j){
+                    st>>c;
+                    M[i][j] = c;
+                }
+            }
+            fill(v, v+55, 0);
+            int c = 0;
+            for(int i = 0; i < n; i++)
+                if(v[i] == 0) c = max(c, dfs(i));
+            return c;
+        }
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arr0[] = {"1 2",
+ "2",
+ ""}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"5 3",
+ "7",
+ ""}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 12; verify_case(0, Arg2, howLong(Arg0, Arg1)); }
+	void test_case_1() { string Arr0[] = {"1 2 3 4 5","2 3 4 5","3 4 5","4 5","5",""}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"2 2 2 2 2","2 2 2 2","2 2 2","2 2","2",""}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 10; verify_case(1, Arg2, howLong(Arg0, Arg1)); }
+	void test_case_2() { string Arr0[] = {"1","2","3","","5","6","7",""}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"2","2","2","","3","3","3",""}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 9; verify_case(2, Arg2, howLong(Arg0, Arg1)); }
+	void test_case_3() { string Arr0[] = {"","2 3 5","4 5","5 6","7","7 8","8 9","10",
+ "10 11 12","11","12","12",""}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"","3 2 9","2 4","6 9","3","1 2","1 2","5",
+ "5 6 9","2","5","3",""}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 22; verify_case(3, Arg2, howLong(Arg0, Arg1)); }
+	void test_case_4() { string Arr0[] = {"","2 3","3 4 5","4 6","5 6","7","5 7",""}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"","30 50","19 6 40","12 10","35 23","8","11 20",""}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 105; verify_case(4, Arg2, howLong(Arg0, Arg1)); }
+
+// END CUT HERE
+
+ };
+
+// BEGIN CUT HERE
+int main(){
+
+        Circuits ___test;
+        ___test.run_test(-1);
+
+}
+// END CUT HERE

Diff for: Circuits.txt

@@ -0,0 +1,81 @@
+PROBLEM STATEMENT
+An essential part of circuit design and general system optimization is critical path analysis.  On a chip, the critical path represents the longest path any signal would have to travel during execution.  In this problem we will be analyzing chip designs to determine their critical path length.  The chips in this problem will not contain any cycles, i.e. there exists no path from one component of a chip back to itself.
+
+Given a vector <string> connects representing the wiring scheme, and a vector <string> costs representing the cost of each connection, your method will return the size of the most costly path between any 2 components on the chip.  In other words, you are to find the longest path in a directed, acyclic graph.  Element j of connects will list the components of the chip that can be reached directly from the jth component (0-based). Element j of costs will list the costs of each connection mentioned in the jth element of connects.  As mentioned above, the chip will not contain any cyclic paths.  For example:
+connects = {"1 2",
+            "2",
+            ""}
+costs    = {"5 3",
+            "7",
+            ""}
+
+In this example, component 0 connects to components 1 and 2 with costs 5 and 3 respectively.  Component 1 connects to component 2 with a cost of 7.  All connections mentioned are directed.  This means a connection from component i to component j does not imply a connection from component j to component i.  Since we are looking for the longest path between any 2 components, your method would return 12.
+         
+
+
+DEFINITION
+Class:Circuits
+Method:howLong
+Parameters:vector <string>, vector <string>
+Returns:int
+Method signature:int howLong(vector <string> connects, vector <string> costs)
+
+
+CONSTRAINTS
+-connects must contain between 2 and 50 elements inclusive
+-connects must contain the same number of elements as costs
+-Each element of connects must contain between 0 and 50 characters inclusive
+-Each element of costs must contain between 0 and 50 characters inclusive
+-Element i of connects must contain the same number of integers as element i of costs
+-Each integer in each element of connects must be between 0 and the size of connects-1 inclusive
+-Each integer in each element of costs must be between 1 and 1000 inclusive
+-Each element of connects may not contain repeated integers
+-Each element of connects must be a single space delimited list of integers, each of which has no extra leading zeros.  There will be no leading or trailing whitespace.
+-Each element of costs must be a single space delimited list of integers, each of which has no extra leading zeros.  There will be no leading or trailing whitespace.
+-The circuit may not contain any cycles
+-There will be at least 1 connection.
+
+
+EXAMPLES
+
+0)
+{"1 2",
+ "2",
+ ""}
+{"5 3",
+ "7",
+ ""}
+
+Returns: 12
+
+From above
+
+1)
+{"1 2 3 4 5","2 3 4 5","3 4 5","4 5","5",""}
+{"2 2 2 2 2","2 2 2 2","2 2 2","2 2","2",""}
+
+Returns: 10
+
+The longest path goes from 0-1-2-3-4-5 for a cost of 10.
+
+2)
+{"1","2","3","","5","6","7",""}
+{"2","2","2","","3","3","3",""}
+
+Returns: 9
+
+The 0-1-2-3 path costs 6 whereas the 4-5-6-7 path costs 9
+
+3)
+{"","2 3 5","4 5","5 6","7","7 8","8 9","10",
+ "10 11 12","11","12","12",""}
+{"","3 2 9","2 4","6 9","3","1 2","1 2","5",
+ "5 6 9","2","5","3",""}
+
+Returns: 22
+
+4)
+{"","2 3","3 4 5","4 6","5 6","7","5 7",""}
+{"","30 50","19 6 40","12 10","35 23","8","11 20",""}
+
+Returns: 105