9/13

Author: Kicory

FENCE.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int N;
+int hs[20000] = {0, };
+
+int prob(int from, int to);
+
+int main(void){
+	int C;
+	cin >> C;
+	for(;C--;){
+		cin >> N;
+		for(int idx = 0; idx < N; idx++){
+			cin >> hs[idx];
+		}
+		cout << prob(0, N) << endl;
+	}
+	return 0;
+}
+
+
+int prob(int from, int to){
+	//base cases
+    if (from + 1 == to){
+        return hs[from];
+    }
+    if (from + 2 == to){
+		return max(max(hs[from], hs[to - 1]), 2 * min(hs[from], hs[to - 1]));
+    }
+	int mid = (to + from) / 2;
+	int prevA = prob(from, mid);
+	int nextA = prob(mid, to);
+
+	//Start setting.
+	int midFrom = mid - 1;
+	int midTo = mid + 1;
+	int curNophi = min(hs[midFrom], hs[midTo - 1]);
+	int midA = curNophi * 2;
+	int addedIdx;
+	while(midFrom > from || midTo < to){
+		if (midFrom == from){
+            midTo++;
+            addedIdx = midTo - 1;
+		}
+		else if (midTo == to){
+            midFrom--;
+            addedIdx = midFrom;
+		}
+		else if (hs[midFrom - 1] > hs[midTo]){
+            midFrom--;
+            addedIdx = midFrom;
+		}
+		else {
+            midTo++;
+            addedIdx = midTo - 1;
+		}
+		curNophi = min(curNophi, hs[addedIdx]);
+		midA = max(midA, curNophi * (midTo - midFrom));
+	}
+	return max(prevA, max(nextA, midA));
+}

JLIS.cpp

@@ -0,0 +1,84 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+vector<int> A;
+vector<int> B;
+vector< vector<int> > cache;
+int Alen;
+int Blen;
+
+int prob(int Astart, int Bstart);
+
+int main(void){
+	int C;
+	cin >> C;
+	for(;C--;){
+        cin >> Alen >> Blen;
+        A.clear();
+        B.clear();
+        A.resize(Alen);
+        B.resize(Blen);
+        cache.clear();
+        cache.resize(Alen + 1);
+        for(int idx = 0; idx < Alen; idx++){
+			cin >> A[idx];
+			cache[idx].clear();
+			cache[idx].resize(Blen + 1, -1);
+        }
+        cache[Alen].resize(Blen + 1, -1);
+        for(int idx = 0; idx < Blen; idx++){
+			cin >> B[idx];
+        }
+
+		int output = -1;
+        for(int Adx = 0; Adx <= Alen; Adx++){
+			for(int Bdx = 0; Bdx <= Blen; Bdx++){
+				output = max(output, prob(Adx, Bdx));
+			}
+        }
+        cout << output << endl;
+	}
+}
+
+int prob(int Astart, int Bstart){
+
+    if (Astart == Alen && Bstart == Blen){
+		return 0;
+	}
+
+
+    int& ret = cache[Astart][Bstart];
+    if (ret != -1){
+		return ret;
+    }
+
+    ret = 1;
+
+	int newBdx = Bstart;
+	for(; newBdx < Blen; newBdx++){
+		if (B[newBdx] > A[Astart]){
+			break;
+		}
+	}
+	int newAdx = Astart;
+	for(; newAdx < Alen; newAdx++){
+		if (A[newAdx] > B[Bstart]){
+			break;
+		}
+	}
+    for(int Adx = Astart + 1; Adx <= Alen; Adx++){
+        if (Adx == Alen || A[Adx] > A[Astart]){
+
+			ret = max(ret, 1 + prob(Adx, newBdx));
+        }
+    }
+    for(int Bdx = Bstart + 1; Bdx <= Blen; Bdx++){
+		if (Bdx == Blen || B[Bdx] > B[Bstart]){
+
+			ret = max(ret, 1 + prob(newAdx, Bdx));
+        }
+    }
+    return ret;
+}

LIS.cpp

@@ -0,0 +1,53 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+vector<int> L;
+vector<int> cache;
+int len;
+
+int prob(int start);
+
+int main(void){
+	int C;
+	cin >> C;
+	for(;C--;){
+		cin >> len;
+		L.clear();
+		cache.clear();
+		L.resize(len);
+		cache.resize(len);
+
+		for(int idx = 0; idx < len; idx++){
+			cin >> L[idx];
+			cache[idx] = -1;
+		}
+		int output = -1;
+		for(int idx = 0; idx < len; idx++){
+			output = max(output, prob(idx));
+		}
+		cout << output << endl;
+	}
+}
+
+//N^2 algorithm...
+int prob(int start){
+	if (start == len - 1){
+        return 1;
+	}
+
+	int& ret = cache[start];
+	if (ret != -1){
+		return ret;
+	}
+
+	int cur = L[start];
+	ret = 1;
+	for(int idx = start + 1; idx < len; idx++){
+		if (cur < L[idx]){
+			ret = max(ret, 1 + prob(idx));
+		}
+	}
+	return ret;
+}

QUADTREE.cpp

@@ -5,17 +5,33 @@ using namespace std;
 string data;
 
 string prob(string data);
+string prob_lin(string data, int& pos);
 
 int main(void){
 	int C;
 	cin >> C;
 	for(;C--;){
 		cin >> data;
-		cout << prob(data) << endl;
+		//pos is -1, like 'head' in linkedlist.
+		int pos = -1;
+		cout << prob_lin(data, pos) << endl;
 	}
 	return 0;
 }
 
+string prob_lin(string data, int& pos){
+    pos++;
+    if (data[pos] != 'x'){
+		return data.substr(pos, 1);
+    }
+	string Q[4];
+	Q[0] = prob_lin(data, pos);
+	Q[1] = prob_lin(data, pos);
+	Q[2] = prob_lin(data, pos);
+	Q[3] = prob_lin(data, pos);
+	return "x" + Q[2] + Q[3] + Q[0] + Q[1];
+}
+
 string prob(string data){
 	if (data.length() == 1){
 		return data;

TRIANGLEPATH.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+vector< vector<int> > triData;
+vector< vector<int> > cache;
+int triSize;
+
+int prob(int y, int x);
+
+int main(void){
+	int C;
+	cin >> C;
+	for(;C--;){
+		//init.
+		triData.clear();
+		cache.clear();
+		cin >> triSize;
+		triData.resize(triSize);
+		cache.resize(triSize);
+
+		for(int row = 0; row < triSize; row++){
+			triData[row].resize(row + 1);
+			cache[row].resize(row + 1);
+			for(int col = 0; col <= row; col++){
+				cin >> triData[row][col];
+				cache[row][col] = -1;
+			}
+		}
+		cout << prob(0, 0) << endl;
+	}
+}
+
+int prob(int y, int x){
+	if (cache[y][x] != -1){
+		return cache[y][x];
+	}
+    if (y == (triSize - 1)){
+		cache[y][x] = triData[y][x];
+		return triData[y][x];
+    }
+	int ret = triData[y][x] + max(prob(y + 1, x), prob(y + 1, x + 1));
+	cache[y][x] = ret;
+	return ret;
+}

WILDCARD.cpp

@@ -0,0 +1,62 @@
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <algorithm>
+#include <vector>
+
+using namespace std;
+
+char w[101];
+int wLen;
+char s[101];
+int sLen;
+
+vector<string> output;
+
+bool prob(int wStart, int sStart);
+
+int main(void){
+	int C;
+	cin >> C;
+    for(;C--;){
+		cin >> w;
+		wLen = strlen(w);
+		int sc;
+		cin >> sc;
+		for(;sc--;){
+			cin >> s;
+			sLen = strlen(s);
+			if (prob(0, 0)){
+				output.push_back(string(s));
+			}
+		}
+		sort(output.begin(), output.end());
+		for(vector<string>::iterator it = output.begin(); it != output.end(); it++){
+			cout << *it << endl;
+		}
+		output.clear();
+    }
+}
+bool prob(int wStart, int sStart){
+	if (wStart == wLen && sStart == sLen){
+		return true;
+    }
+	int wPos = wStart;
+	int sPos = sStart;
+	while(w[wPos] != '*'){
+		if (w[wPos] != '?' && w[wPos] != s[sPos]){
+			return false;
+        }
+        wPos++;
+        sPos++;
+        // finish together.
+        if (wPos == wLen && sPos == sLen){
+			return true;
+        }
+	}
+	bool ret = false;
+	for(; sPos <= sLen; sPos++){
+		ret = ret || prob(wPos + 1, sPos);
+	}
+	return ret;
+}