fdsa

Author: Kicory

2dvector.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+vector< vector<int> > field;
+
+int main(void){
+	field.resize(5);
+	for (int c = 5; c--;){
+		field[c].push_back(c);
+	}
+	vector<int>::iterator it;
+	for(int o = 5; o--;){
+		for(it = field[o].begin(); it != field[o].end(); it++){
+			cout << *it << endl;
+		}
+	}
+}

BOARDCOVER.cpp

@@ -0,0 +1,109 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+vector< vector<bool> > field;
+int nophi;
+int width;
+
+const int bType[4][3][2] = {
+	{ {0, 0}, {0, 1}, {1, 1} },
+	{ {0, 0}, {1, 0}, {1, 1} },
+	{ {0, 0}, {1, 0}, {1, -1} },
+	{ {0, 0}, {0, 1}, {1, 0} }
+};
+
+bool isValid(int y, int x){
+    if (y >= nophi || y < 0 || x >= width || x < 0){
+		return false;
+    }
+    return true;
+}
+
+bool isFit(int y, int x, int type){
+	for(int blk = 0; blk < 3; blk++){
+        int newY = y + bType[type][blk][0];
+        int newX = x + bType[type][blk][1];
+        if (!isValid(newY, newX)){
+			return false;
+        }
+        if (field[newY][newX]){
+			return false;
+        }
+	}
+	return true;
+}
+
+void blockSet(int y, int x, int type){
+	for(int blk = 0; blk < 3; blk++){
+		int newY = y + bType[type][blk][0];
+		int newX = x + bType[type][blk][1];
+		field[newY][newX] = !field[newY][newX];
+	}
+}
+
+int prob();
+
+int main(void){
+	int C;
+	cin >> C;
+	for(;C--;){
+        cin >> nophi >> width;
+        field.clear();
+        field.resize(nophi);
+        for(int N = 0; N < nophi; N++){
+			char data[21];
+			cin >> data;
+			field[N].clear();
+			for(int W = 0; W < width; W++){
+				if (data[W] == '#'){
+					field[N].push_back(true);
+				}
+				else{
+					field[N].push_back(false);
+				}
+			}
+        }
+        cout << prob() << endl;
+	}
+}
+
+void printField(){
+	for(int N = 0; N < nophi; N++){
+		cout << endl;
+		for(int W = 0; W < width; W++){
+			cout << field[N][W];
+		}
+	}
+	cout << endl;
+}
+
+int prob(){
+
+    int y = -1, x = -1;
+    //find upper-leftmost blank position.
+    for (int yy = 0; yy < nophi; yy++){
+		for  (int xx = 0; xx < width; xx++){
+			if (!field[yy][xx]){
+				y = yy;
+				x = xx;
+				goto OUT;
+			}
+		}
+    }
+    OUT:
+    //base case
+    if (y == -1 && x == -1){
+        return 1;
+    }
+    int sum = 0;
+    for(int T = 0; T < 4; T++){
+		if (isFit(y, x, T)){
+			blockSet(y, x, T);
+			sum = sum + prob();
+			blockSet(y, x, T);
+		}
+    }
+    return sum;
+}

BOGGLE.cpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <string.h>
+
+using namespace std;
+
+const int dx[8] = {-1, -1, -1, 1, 1, 1, 0, 0};
+const int dy[8] = {-1, 0, 1, -1, 0, 1, -1, 1};
+int D[5][5];
+bool deadEnd[10][5][5];
+int target[10];
+int targetLen;
+
+bool probStart();
+void init(){
+	memset((void*)deadEnd, (int)false, sizeof(bool) * 10 * 5 * 5);
+}
+
+int main(void){
+	int C;
+	cin >> C;
+	char data[5][6];
+	for (;C--;){
+		for(int row = 0; row < 5; row++){
+			cin >> data[row];
+			for(int col = 0; col < 5; col++){
+				D[row][col] = (int)data[row][col];
+			}
+		}
+		int wordNum;
+		char word[11];
+		cin >> wordNum;
+		for(;wordNum--;){
+			init();
+            cin >> word;
+            targetLen = strlen(word);
+			for(int strIdx = 0; strIdx < targetLen; strIdx++){
+				target[strIdx] = (int)word[strIdx];
+			}
+			cout << word << ' ' << (probStart() ? "YES" : "NO") << endl;
+		}
+	}
+	return 0;
+}
+
+bool prob(int ynext, int xnext, int curLen){
+	//Exceptional cases.
+	if (ynext >= 5 || xnext >= 5 || ynext < 0 || xnext < 0){
+		return false;
+	}
+	//DP
+	if (deadEnd[curLen][ynext][xnext]){
+		return false;
+	}
+	//base case
+	if (D[ynext][xnext] != target[curLen]){
+		//dead End, fail to find word.
+		deadEnd[curLen][ynext][xnext] = true;
+		return false;
+	}
+	else if (curLen + 1 == targetLen){
+		//successful case, no more calculations needed.
+		return true;
+	}
+	//Recursive
+    for(int direction = 0; direction < 8; direction++){
+		if (prob(ynext + dy[direction], xnext + dx[direction], curLen + 1)){
+			return true;
+		}
+    }
+    deadEnd[curLen][ynext][xnext] = true;
+    return false;
+}
+
+bool probStart(){
+	for(int Y = 0;Y < 5; Y++){
+		for(int X = 0;X < 5; X++){
+            if (prob(Y, X, 0)){
+				return true;
+            }
+		}
+	}
+	return false;
+}

FESTIVAL.cpp

@@ -0,0 +1,37 @@
+#include <vector>
+#include <stdio.h>
+
+//FESTIVAL
+
+double prob(void);
+
+int main(void){
+	int C;
+	scanf("%d", &C);
+	for (int i = 0; i < C; i++){
+		printf("%.11f\n", prob());
+	}
+}
+
+double prob(void){
+	int N, teams;
+	scanf("%d %d", &N, &teams);
+	std::vector<int> priceAcc(N + 1, 0);
+	priceAcc[0] = 0;
+	for(int idx = 1; idx < N + 1; idx++){
+		int curPrice;
+		scanf("%d", &curPrice);
+		priceAcc[idx] = priceAcc[idx - 1] + curPrice;
+	}
+	double minAva = 101;
+	short from = 0, ends;
+	for(; from <= N - teams; from++){
+		for(ends = from + teams; ends <= N; ends++){
+			double newAva = (priceAcc[ends] - priceAcc[from]) / (double)(ends - from);
+			if (minAva > newAva){
+				minAva = newAva;
+			}
+		}
+	}
+	return minAva;
+}

PICNIC.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+
+using namespace std;
+
+int elemCnt;
+bool friendData[10][10];
+
+int prob(bool[10]);
+
+void init(){
+	for(int i = 0; i < 10; i++){
+		for(int j = 0; j < 10; j++){
+			friendData[i][j] = false;
+		}
+	}
+}
+
+int main(void){
+    int C;
+    cin >> C;
+    for(;C--;){
+		int pcnt;
+        cin >> elemCnt >> pcnt;
+		init();
+		for(;pcnt--;){
+			int f, s;
+            cin >> f >> s;
+			if (f > s){
+				int tmp = f;
+				f = s;
+				s = tmp;
+			}
+			friendData[f][s] = true;
+			//friendData[s][f] = true;
+		}
+		bool taken[10] = {false, };
+        cout << prob(taken) << endl;
+    }
+    return 0;
+}
+
+int prob(bool taken[10]){
+    //base case
+    int firstFree = -1;
+    for(int idx = 0; idx < elemCnt; idx++){
+		if (!taken[idx]){
+            firstFree = idx;
+            break;
+		}
+    }
+    if (firstFree == -1){
+		//A single case found.
+        return 1;
+    }
+    //recursive
+    int sum = 0;
+    for(int with = firstFree + 1; with < elemCnt; with++){
+		if (friendData[firstFree][with] && !taken[with]){
+			//Can be friend.
+			taken[firstFree] = true;
+			taken[with] = true;
+			sum = sum + prob(taken);
+			taken[firstFree] = false;
+			taken[with] = false;
+		}
+    }
+    return sum;
+}