tccc 03 semi 3 div 1 250

Author: keshavnandan

Diff for: ZigZag.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <set>
+#include <map>
+using namespace std;
+int a[55];
+int b[55];
+
+class ZigZag {
+        public:
+        int longestZigZag(vector <int> t)
+        {
+            int n  = t.size();
+            a[n-1] = b[n-1] = 1;
+            for(int i = n-2; i >= 0; i--){
+                int maxa = 0;
+                for(int j = i+1; j < n; j++)
+                    if(t[j] > t[i]) maxa = max(maxa, b[j]);
+                a[i] = maxa+1;
+
+                int maxb = 0;
+                for(int j = i+1; j < n; j++)
+                    if(t[j] < t[i]) maxb = max(maxb, a[j]);
+                b[i] = maxb+1;
+            }
+            return max(a[0], b[0]);
+        }
+
+// 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(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	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() { int Arr0[] = { 1, 7, 4, 9, 2, 5 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; verify_case(0, Arg1, longestZigZag(Arg0)); }
+	void test_case_1() { int Arr0[] = { 1, 17, 5, 10, 13, 15, 10, 5, 16, 8 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; verify_case(1, Arg1, longestZigZag(Arg0)); }
+	void test_case_2() { int Arr0[] = { 44 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; verify_case(2, Arg1, longestZigZag(Arg0)); }
+	void test_case_3() { int Arr0[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; verify_case(3, Arg1, longestZigZag(Arg0)); }
+	void test_case_4() { int Arr0[] = { 70, 55, 13, 2, 99, 2, 80, 80, 80, 80, 100, 19, 7, 5, 5, 5, 1000, 32, 32 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 8; verify_case(4, Arg1, longestZigZag(Arg0)); }
+	void test_case_5() { int Arr0[] = { 374, 40, 854, 203, 203, 156, 362, 279, 812, 955,
+600, 947, 978, 46, 100, 953, 670, 862, 568, 188,
+67, 669, 810, 704, 52, 861, 49, 640, 370, 908,
+477, 245, 413, 109, 659, 401, 483, 308, 609, 120,
+249, 22, 176, 279, 23, 22, 617, 462, 459, 244 }
+; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 36; verify_case(5, Arg1, longestZigZag(Arg0)); }
+
+// END CUT HERE
+
+};
+
+// BEGIN CUT HERE
+     int main()
+     {
+        ZigZag ___test;
+        ___test.run_test(-1);
+     }
+// END CUT HERE

Diff for: ZigZag.txt

@@ -0,0 +1,75 @@
+PROBLEM STATEMENT
+
+A sequence of numbers is called a zig-zag sequence if the differences
+between successive numbers strictly alternate between positive and negative.  The
+first difference (if one exists) may be either positive or negative.  A sequence with
+fewer than two elements is trivially a zig-zag sequence.
+
+
+
+For example, 1,7,4,9,2,5 is a zig-zag sequence because the differences
+(6,-3,5,-7,3) are alternately positive and negative.  In contrast, 1,4,7,2,5
+and 1,7,4,5,5 are not zig-zag sequences, the first because its first two differences are positive and
+the second because its last difference is zero.
+
+
+
+Given a sequence of integers, sequence, return the length of the longest subsequence of sequence that is
+a zig-zag sequence.  A subsequence is obtained by deleting some number of
+elements (possibly zero) from the original sequence, leaving the remaining elements in their original order.
+
+
+
+DEFINITION
+Class:ZigZag
+Method:longestZigZag
+Parameters:vector <int>
+Returns:int
+Method signature:int longestZigZag(vector <int> sequence)
+
+
+CONSTRAINTS
+-sequence contains between 1 and 50 elements, inclusive.
+-Each element of sequence is between 1 and 1000, inclusive.
+
+
+EXAMPLES
+
+0)
+{ 1, 7, 4, 9, 2, 5 }
+
+Returns: 6
+
+The entire sequence is a zig-zag sequence.
+
+1)
+{ 1, 17, 5, 10, 13, 15, 10, 5, 16, 8 }
+
+Returns: 7
+
+There are several subsequences that achieve this length.  One is 1,17,10,13,10,16,8.
+
+2)
+{ 44 }
+
+Returns: 1
+
+3)
+{ 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+
+Returns: 2
+
+4)
+{ 70, 55, 13, 2, 99, 2, 80, 80, 80, 80, 100, 19, 7, 5, 5, 5, 1000, 32, 32 }
+
+Returns: 8
+
+5)
+{ 374, 40, 854, 203, 203, 156, 362, 279, 812, 955, 
+600, 947, 978, 46, 100, 953, 670, 862, 568, 188, 
+67, 669, 810, 704, 52, 861, 49, 640, 370, 908, 
+477, 245, 413, 109, 659, 401, 483, 308, 609, 120, 
+249, 22, 176, 279, 23, 22, 617, 462, 459, 244 }
+
+
+Returns: 36