vector<TreeNode*> generateTrees(int begin, int end) { vector<TreeNode*> v; if(begin > end) { v.push_back(NULL); return v; } if(begin == end) { TreeNode* t = new TreeNode(begin); v.push_back(t); return v; } for(int i = begin; i<=end; i++) { vector<TreeNode*> lVector = generateTrees(begin, i-1); vector<TreeNode*> rVector = generateTrees(i+1, end); for(int j=0; j!=lVector.size(); j++) for(int k=0; k!=rVector.size(); k++) { TreeNode* root = new TreeNode(i); root->left = lVector[j]; root->right = rVector[k]; v.push_back(root); } } return v; }
vector<TreeNode *> generateTrees(int begin , int end) { vector<TreeNode *> ret; if(begin > end ) { ret.push_back(NULL); return ret; } if(begin == end) { ret.push_back(new TreeNode(begin)); return ret; } for(int k = begin ;k <= end ;k++) { vector<TreeNode *> left = generateTrees(begin,k-1); vector<TreeNode *> right = generateTrees(k+1,end); for(int i = 0 ;i < left.size() ;i++) for(int j = 0 ; j < right.size() ; j++) { TreeNode * cur = new TreeNode(k); cur->left = left[i]; cur->right = right[j]; ret.push_back(cur); } } return ret; }
vector<TreeNode*> generateTrees(int start, int end) { vector<TreeNode*> res; if (start > end) { res.push_back(NULL); return res; } if (start == end) { res.push_back(new TreeNode(start)); return res; } vector<TreeNode*> leftNodes; vector<TreeNode*> rightNodes; for (int i=start; i<=end; i++) { leftNodes = generateTrees(start, i-1); rightNodes = generateTrees(i+1, end); for (TreeNode* left: leftNodes) { for (TreeNode* right: rightNodes) { TreeNode* root = new TreeNode(i); root->left = left; root->right = right; res.push_back(root); } } } return res; }
vector<TreeNode *> Solution::generateTrees(int i, int j) { vector<TreeNode *> result; if(i>j) { result.push_back(NULL); return result; } for(int k=i; k<=j; ++k) { vector<TreeNode *> lgroup = generateTrees(i, k-1); vector<TreeNode *> rgroup = generateTrees(k+1, j); for(int l=0; l<lgroup.size(); ++l) { TreeNode *pNodeL = lgroup[l]; for(int r=0; r<rgroup.size(); ++r) { TreeNode *pNodeR = rgroup[r]; TreeNode *pNode = new TreeNode(k); pNode->left = pNodeL; pNode->right = pNodeR; result.push_back(pNode); } } } return result; }
vector<TreeNode *> generateTrees(int start, int end) { if(start > end) return vector<TreeNode *>(1); vector<TreeNode *> rst; for(int i=start; i<=end; ++i) { vector<TreeNode *> leftTrees = generateTrees(start, i-1); vector<TreeNode *> rightTrees = generateTrees(i+1, end); for(int j=0; j<leftTrees.size(); ++j) for(int k=0; k<rightTrees.size(); ++k) { TreeNode *root = new TreeNode(i); root->left = leftTrees[j]; root->right = rightTrees[k]; rst.push_back(root); } } return rst; }
vector<TreeNode*> generateTrees(int n) { vector<int> nums(n); for (int i=0; i<n; ++i) { nums[i] = i + 1; } return generateTrees(nums, 0, n); }
vector<TreeNode *> generateTrees(int from, int to) { vector<TreeNode *> r; if(from > to) return r; if(from == to) { r.push_back(new TreeNode(from)); return r; } for(int i = from; i <= to; i++) { TreeNode * t; vector<TreeNode *> le = generateTrees(from, i - 1); vector<TreeNode *> ri = generateTrees(i + 1, to); if(le.empty()) { if(ri.empty()) { t = new TreeNode(i); t->left = NULL; t->right = NULL; r.push_back(t); continue; } for(int j = 0; j < ri.size(); j++) { t = new TreeNode(i); t->left = NULL; t->right = ri[j]; r.push_back(t); } continue; } if(ri.empty()) { for(int j = 0; j < le.size(); j++) { t = new TreeNode(i); t->right = NULL; t->left = le[j]; r.push_back(t); } continue; } for(int k = 0; k < le.size(); k++) { for(int j = 0; j < ri.size(); j++) { t = new TreeNode(i); t->left = le[k]; t->right = ri[j]; r.push_back(t); } } } return r; }
int main(){ vector<TreeNode*> res = generateTrees(3); for(int i=0;i<res.size();i++){ dfs(res[i]); printf("\n"); } return 0; }
vector<TreeNode*> generateTrees(int n) { if(n==0) { vector<TreeNode*> v; return v; } return generateTrees(1, n); }
vector<TreeNode*> generateTrees(int start, int end) { vector<TreeNode*> ret; if(start > end) { ret.push_back(NULL); return ret; } for(int i = start; i <= end; ++i) { vector<TreeNode*> vecLeft(generateTrees(start, i - 1)); vector<TreeNode*> vecRight(generateTrees(i + 1, end)); for(int l = 0; l < vecLeft.size(); ++l) for(int r = 0; r < vecRight.size(); ++r) { TreeNode *root = new TreeNode(i); root->left = vecLeft[l]; root->right = vecRight[r]; ret.push_back(root); } } return ret; }
// initialization void initEvent() { vl::Log::notify(appletInfo()); srand((unsigned int)time(NULL)); generateTrees (100.0f, 500); generateStars (100.0f, 500); generateGround(100.0f); generateLunapark(); }
vector<TreeNode *> generateTrees(int n) { vector<TreeNode *> r; if(n < 1) { r.push_back(NULL); return r; } r = generateTrees(1, n); return r; }
vector<TreeNode*> generateTrees(int start, int end) { vector<TreeNode*> res; if (start > end) { res.push_back(NULL); return res; } for (int mid=start; mid<=end; mid++) { vector<TreeNode*> leftSubTrees = generateTrees(start, mid-1); vector<TreeNode*> rightSubTrees = generateTrees(mid+1, end); for (int l=0; l<leftSubTrees.size(); l++) { for (int r=0; r<rightSubTrees.size(); r++) { TreeNode *cur = new TreeNode(mid); cur->left = leftSubTrees[l]; cur->right = rightSubTrees[r]; res.push_back(cur); } } } return res; }
vector<TreeNode *> generateTrees(int i, int j) { vector<TreeNode *> result; if(i > j) { result.push_back(NULL); return result; } for(int k=i; k<=j; ++k) { vector<TreeNode *> r1 = generateTrees(i, k-1); vector<TreeNode *> r2 = generateTrees(k+1, j); for(int m=0; m<r1.size(); ++m) for(int n=0; n<r2.size(); ++n) { TreeNode *root = new TreeNode(k); root->left = r1[m]; root->right = r2[n]; result.push_back(root); } } return result; }
vector<TreeNode *> generateTrees(int start, int end) { vector<TreeNode *> trees; if (start > end) { trees.push_back(NULL); return trees; } for (int k = start; k <= end; k++) { vector<TreeNode *> leftTrees = generateTrees(start, k-1); vector<TreeNode *> rightTrees = generateTrees(k+1, end); for (int i = 0; i < leftTrees.size(); i++) { for (int j = 0; j < rightTrees.size(); j++) { TreeNode *node = new TreeNode(k); node->left = leftTrees[i]; node->right = rightTrees[j]; trees.push_back(node); } } } return trees; }
std::vector<TreeNode*> generateTrees(int start, int end) { std::vector<TreeNode*> ret; if (start > end) { ret.push_back(NULL); return ret; } for (int i = start; i <= end; ++i) { std::vector<TreeNode*> left = generateTrees(start, i - 1); std::vector<TreeNode*> right = generateTrees(i + 1, end); for (TreeNode* l : left) for (TreeNode* r : right) { TreeNode* node = new TreeNode(i); node->left = l; node->right = r; ret.push_back(node); } } return ret; }
vector<TreeNode*> generateTrees(const vector<int> &nums, int begin, int end) { if (end - begin == 0) { return vector<TreeNode*> { nullptr }; } if (end - begin == 1) { return vector<TreeNode*> { new TreeNode(nums[begin]) }; } vector<TreeNode*> results; for (int i=begin; i<end; ++i) { auto lefts = generateTrees(nums, begin, i); auto rights = generateTrees(nums, i+1, end); for (auto left : lefts) { for (auto right : rights) { auto node = new TreeNode(nums[i]); node->left = left; node->right = right; results.push_back(node); } } } return results; }
Forest::Forest(float radius, unsigned int nTrees) : ground( "resources/ground/ground.obj", // file path glm::vec3(0.0f), // position glm::vec3(1000.0f, 1.0f, 1000.0f), // scaling vector BoundingBox( // bounding box glm::vec3(0.0f), glm::vec3(0.0f) ) ), torch( "resources/staff/staff.obj", // file path glm::vec3(20.0f, 0.0f, 10.0f), // position glm::vec3(5.0f), // scale BoundingBox( // bounding box glm::vec3(-0.5f), glm::vec3(0.5f) ) ), waterfall( "resources/waterfall/waterfall.obj", // file path glm::vec3(0.0f, 0.0f, radius), // position glm::vec3(1.0f), // scale BoundingBox(glm::vec3(0.0f), glm::vec3(0.0f)) ), river( "resources/river/river.obj", // file path glm::vec3(0.0f, 0.1f, radius), // position glm::vec3(1.0f), // scale BoundingBox(glm::vec3(0.0f), glm::vec3(0.0f)) ), fire( "resources/fire/fire.obj", // file path glm::vec3(20.0f, 9.5f, 10.0f), // position glm::vec3(0.5f, 0.7f, 0.5f), // scale BoundingBox(glm::vec3(0.0f), glm::vec3(0.0f)) ), radius(radius), randomGen(std::time(0)) { createCliffs(); generateTrees(nTrees); bgObjects.reserve(2 + cliffs.size() + trees.size()); bgObjects.push_back(&ground); bgObjects.push_back(&torch); for (auto& t : trees) { bgObjects.push_back(&t); } for (auto& c : cliffs) { bgObjects.push_back(&c); } }
vector<TreeNode *> generateTrees(int left, int right) { vector<TreeNode *> trees; if (right < left) { trees.push_back(NULL); return trees; } for (int i=left; i<=right; i++) { auto leftSubtrees = generateTrees(left, i-1); auto rightSubtrees = generateTrees(i+1, right); for (int x=0; x<leftSubtrees.size(); x++) { for (int y=0; y<rightSubtrees.size(); y++) { TreeNode *root = new TreeNode(i); root->left = leftSubtrees[x]; root->right = rightSubtrees[y]; trees.push_back(root); } } } return trees; }
int main(int argc, char **argv){ generateSlope();//generates slope vertices and normals into an array generateTrees(); generateParticles(ski1.particles.snow); generateParticles(ski2.particles.snow); setSlopeBoundary(&ski1, 0, X_WAVE_INCREMENT, 0, Z_WAVE_INCREMENT); setSlopeBoundary(&ski2, 0, X_WAVE_INCREMENT, 0, Z_WAVE_INCREMENT); //orientateSkier();//determine skier's starting orientation glutInit(&argc, argv); /*output functions*/ glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); window = glutCreateWindow("Skier"); glOrtho(-1,1,-1,1,-1,1); glEnable(GL_DEPTH_TEST); //glDisable(GL_DEPTH_TEST); glutDisplayFunc(display); glutIdleFunc(idle); glutReshapeFunc(reshape); /*input functions*/ glutMotionFunc(mouseMove); glutMouseFunc(mouseState); glutPassiveMotionFunc(mousePassiveMove); glutKeyboardFunc(keyDown); glutKeyboardUpFunc(keyUp); glutSpecialFunc(arrowKeys); glutSpecialUpFunc(arrowKeys); /*load textures*/ snowTexture = loadTexture("texture/snow.jpg", ON); trees.texture = loadTexture("texture/tree.png", OFF); snowballTexture = loadTexture("texture/snowball.png", OFF); initSkyBox(); glutMainLoop(); return EXIT_SUCCESS; }
vector<TreeNode*> generateTrees(int n) { if (n <= 0) return vector<TreeNode*>(); return generateTrees(1, n); }
vector<TreeNode *> generateTrees(int n) { return generateTrees(1,n); }
vector<TreeNode *> generateTrees(int n) { // Start typing your C/C++ solution below // DO NOT write int main() function return generateTrees(1, n); }
vector<TreeNode *> Solution::generateTrees(int n) { return generateTrees(1, n); }