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);
}
