int climb(int n) { if (n >= N) return 1; int k; if (a[n] == 0) { k = climb(n+1) + climb(n+2); a[n] = k; } else k = a[n]; return k; }
// static void LLLocalInventory::climb(LLInventoryCategory* cat, LLInventoryModel::cat_array_t& cats, LLInventoryModel::item_array_t& items) { LLInventoryModel* model = &gInventory; // Add this category cats.push_back(LLPointer<LLViewerInventoryCategory>((LLViewerInventoryCategory*)cat)); LLInventoryModel::cat_array_t *direct_cats; LLInventoryModel::item_array_t *direct_items; model->getDirectDescendentsOf(cat->getUUID(), direct_cats, direct_items); // Add items LLInventoryModel::item_array_t::iterator item_iter = direct_items->begin(); LLInventoryModel::item_array_t::iterator item_end = direct_items->end(); for( ; item_iter != item_end; ++item_iter) { items.push_back(*item_iter); } // Do subcategories LLInventoryModel::cat_array_t::iterator cat_iter = direct_cats->begin(); LLInventoryModel::cat_array_t::iterator cat_end = direct_cats->end(); for( ; cat_iter != cat_end; ++cat_iter) { climb(*cat_iter, cats, items); } }
int climbStairs(int n) { if (n <= 0) return 0; vector<int> dp(n+1, 0); dp[1] = 1; dp[2] = 2; climb(n, dp); return dp[n]; }
int main(void) { printf("%d\n", climb(0)); int i; for ( i = 0;i < N; i++) printf("%d ", a[i]); printf("\n"); return 0; }
//static void LLLocalInventory::saveInvCache(std::string filename, LLFolderView* folder) { LLInventoryModel* model = &gInventory; std::set<LLUUID> selected_items; folder->getSelectionList(selected_items); if(selected_items.size() < 1) { // No items selected? Wtfboom return; } LLInventoryModel::cat_array_t cats; LLInventoryModel::item_array_t items; // Make complete lists of child categories and items std::set<LLUUID>::iterator sel_iter = selected_items.begin(); std::set<LLUUID>::iterator sel_end = selected_items.end(); for( ; sel_iter != sel_end; ++sel_iter) { LLInventoryCategory* cat = model->getCategory(*sel_iter); if(cat) { climb(cat, cats, items); } } // And what about items inside a folder that wasn't selected? // I guess I will just add selected items, so long as they aren't already added for(sel_iter = selected_items.begin(); sel_iter != sel_end; ++sel_iter) { LLInventoryItem* item = model->getItem(*sel_iter); if(item) { if(std::find(items.begin(), items.end(), item) == items.end()) { items.push_back(LLPointer<LLViewerInventoryItem>((LLViewerInventoryItem*)item)); LLInventoryCategory* parent = model->getCategory(item->getParentUUID()); if(std::find(cats.begin(), cats.end(), parent) == cats.end()) { cats.push_back(LLPointer<LLViewerInventoryCategory>((LLViewerInventoryCategory*)parent)); } } } } LLInventoryModel::saveToFile(filename, cats, items); }
/** ------------------------------------------------------------------- ** @brief Process image ** ** The functions calculates the Maximally Stable Extremal Regions ** (MSERs) of image @a im using the MSER filter @a f. ** ** The filter @a f must have been initialized to be compatible with ** the dimensions of @a im. ** ** @param f MSER filter. ** @param im image data. **/ VL_EXPORT void vl_mser_process (VlMserFilt* f, vl_mser_pix const* im) { /* shortcuts */ vl_uint nel = f-> nel ; vl_uint *perm = f-> perm ; vl_uint *joins = f-> joins ; int ndims = f-> ndims ; int *dims = f-> dims ; int *subs = f-> subs ; int *dsubs = f-> dsubs ; int *strides = f-> strides ; VlMserReg *r = f-> r ; VlMserExtrReg *er = f-> er ; vl_uint *mer = f-> mer ; int delta = f-> delta ; int njoins = 0 ; int ner = 0 ; int nmer = 0 ; int nbig = 0 ; int nsmall = 0 ; int nbad = 0 ; int ndup = 0 ; int i, j, k ; /* delete any previosuly computed ellipsoid */ f-> nell = 0 ; /* ----------------------------------------------------------------- * Sort pixels by intensity * -------------------------------------------------------------- */ { vl_uint buckets [ VL_MSER_PIX_MAXVAL ] ; /* clear buckets */ memset (buckets, 0, sizeof(vl_uint) * VL_MSER_PIX_MAXVAL ) ; /* compute bucket size (how many pixels for each intensity value) */ for(i = 0 ; i < (int) nel ; ++i) { vl_mser_pix v = im [i] ; ++ buckets [v] ; } /* cumulatively add bucket sizes */ for(i = 1 ; i < VL_MSER_PIX_MAXVAL ; ++i) { buckets [i] += buckets [i-1] ; } /* empty buckets computing pixel ordering */ for(i = nel ; i >= 1 ; ) { vl_mser_pix v = im [ --i ] ; vl_uint j = -- buckets [v] ; perm [j] = i ; } } /* initialize the forest with all void nodes */ for(i = 0 ; i < (int) nel ; ++i) { r [i] .parent = VL_MSER_VOID_NODE ; } /* ----------------------------------------------------------------- * Compute regions and count extremal regions * -------------------------------------------------------------- */ /* In the following: idx : index of the current pixel val : intensity of the current pixel r_idx : index of the root of the current pixel n_idx : index of the neighbors of the current pixel nr_idx : index of the root of the neighbor of the current pixel */ /* process each pixel by increasing intensity */ for(i = 0 ; i < (int) nel ; ++i) { /* pop next node xi */ vl_uint idx = perm [i] ; vl_mser_pix val = im [idx] ; vl_uint r_idx ; /* add the pixel to the forest as a root for now */ r [idx] .parent = idx ; r [idx] .shortcut = idx ; r [idx] .area = 1 ; r [idx] .height = 1 ; r_idx = idx ; /* convert the index IDX into the subscript SUBS; also initialize DSUBS to (-1,-1,...,-1) */ { vl_uint temp = idx ; for(k = ndims - 1 ; k >= 0 ; --k) { dsubs [k] = -1 ; subs [k] = temp / strides [k] ; temp = temp % strides [k] ; } } /* examine the neighbors of the current pixel */ while (1) { vl_uint n_idx = 0 ; vl_bool good = 1 ; /* Compute the neighbor subscript as NSUBS+SUB, the corresponding neighbor index NINDEX and check that the neighbor is within the image domain. */ for(k = 0 ; k < ndims && good ; ++k) { int temp = dsubs [k] + subs [k] ; good &= (0 <= temp) && (temp < dims [k]) ; n_idx += temp * strides [k] ; } /* The neighbor should be processed if the following conditions are met: 1. The neighbor is within image boundaries. 2. The neighbor is indeed different from the current node (the opposite happens when DSUB=(0,0,...,0)). 3. The neighbor is already in the forest, meaning that it has already been processed. */ if (good && n_idx != idx && r [n_idx] .parent != VL_MSER_VOID_NODE ) { vl_mser_pix nr_val = 0 ; vl_uint nr_idx = 0 ; /* Now we join the two subtrees rooted at R_IDX = ROOT( IDX) NR_IDX = ROOT(N_IDX). Note that R_IDX = ROOT(IDX) might change as we process more neighbors, so we need keep updating it. */ r_idx = climb(r, idx) ; nr_idx = climb(r, n_idx) ; int hgt = r [ r_idx] .height ; int n_hgt = r [nr_idx] .height ; /* At this point we have three possibilities: (A) ROOT(IDX) == ROOT(NR_IDX). In this case the two trees have already been joined and we do not do anything. (B) I(ROOT(IDX)) == I(ROOT(NR_IDX)). In this case the pixel IDX is extending an extremal region with the same intensity value. Since ROOT(NR_IDX) will NOT be an extremal region of the full image, ROOT(IDX) can be safely added as children of ROOT(NR_IDX) if this reduces the height according to the union rank heuristic. (C) I(ROOT(IDX)) > I(ROOT(NR_IDX)). In this case the pixel IDX is starting a new extremal region. Thus ROOT(NR_IDX) WILL be an extremal region of the final image and the only possibility is to add ROOT(NR_IDX) as children of ROOT(IDX), which becomes parent. */ if( r_idx != nr_idx ) { /* skip if (A) */ nr_val = im [nr_idx] ; if( nr_val == val && hgt < n_hgt ) { /* ROOT(IDX) becomes the child */ r [r_idx] .parent = nr_idx ; r [r_idx] .shortcut = nr_idx ; r [nr_idx] .area += r [r_idx] .area ; r [nr_idx] .height = VL_MAX(n_hgt, hgt+1) ; joins [njoins++] = r_idx ; } else { /* cases ROOT(IDX) becomes the parent */ r [nr_idx] .parent = r_idx ; r [nr_idx] .shortcut = r_idx ; r [r_idx] .area += r [nr_idx] .area ; r [r_idx] .height = VL_MAX(hgt, n_hgt + 1) ; joins [njoins++] = nr_idx ; /* count if extremal */ if (nr_val != val) ++ ner ; } /* check b vs c */ } /* check a vs b or c */ } /* neighbor done */ /* move to next neighbor */ k = 0 ; while(++ dsubs [k] > 1) { dsubs [k++] = -1 ; if(k == ndims) goto done_all_neighbors ; } } /* next neighbor */ done_all_neighbors : ; } /* next pixel */ /* the last root is extremal too */ ++ ner ; /* save back */ f-> njoins = njoins ; f-> stats. num_extremal = ner ; /* ----------------------------------------------------------------- * Extract extremal regions * -------------------------------------------------------------- */ /* Extremal regions are extracted and stored into the array ER. The structure R is also updated so that .SHORTCUT indexes the corresponding extremal region if any (otherwise it is set to VOID). */ /* make room */ if (f-> rer < ner) { if (er) vl_free (er) ; f->er = er = vl_malloc (sizeof(VlMserExtrReg) * ner) ; f->rer = ner ; } ; /* save back */ f-> nmer = ner ; /* count again */ ner = 0 ; /* scan all regions Xi */ for(i = 0 ; i < (int) nel ; ++i) { /* pop next node xi */ vl_uint idx = perm [i] ; vl_mser_pix val = im [idx] ; vl_uint p_idx = r [idx] .parent ; vl_mser_pix p_val = im [p_idx] ; /* is extremal ? */ vl_bool is_extr = (p_val > val) || idx == p_idx ; if( is_extr ) { /* if so, add it */ er [ner] .index = idx ; er [ner] .parent = ner ; er [ner] .value = im [idx] ; er [ner] .area = r [idx] .area ; /* link this region to this extremal region */ r [idx] .shortcut = ner ; /* increase count */ ++ ner ; } else { /* link this region to void */ r [idx] .shortcut = VL_MSER_VOID_NODE ; } } /* ----------------------------------------------------------------- * Link extremal regions in a tree * -------------------------------------------------------------- */ for(i = 0 ; i < ner ; ++i) { vl_uint idx = er [i] .index ; do { idx = r[idx] .parent ; } while (r[idx] .shortcut == VL_MSER_VOID_NODE) ; er[i] .parent = r[idx] .shortcut ; er[i] .shortcut = i ; } /* ----------------------------------------------------------------- * Compute variability of +DELTA branches * -------------------------------------------------------------- */ /* For each extremal region Xi of value VAL we look for the biggest * parent that has value not greater than VAL+DELTA. This is dubbed * `top parent'. */ for(i = 0 ; i < ner ; ++i) { /* Xj is the current region the region and Xj are the parents */ int top_val = er [i] .value + delta ; int top = er [i] .shortcut ; /* examine all parents */ while (1) { int next = er [top] .parent ; int next_val = er [next] .value ; /* Break if: * - there is no node above the top or * - the next node is above the top value. */ if (next == top || next_val > top_val) break ; /* so next could be the top */ top = next ; } /* calculate branch variation */ { int area = er [i ] .area ; int area_top = er [top] .area ; er [i] .variation = (float) (area_top - area) / area ; er [i] .max_stable = 1 ; } /* Optimization: since extremal regions are processed by * increasing intensity, all next extremal regions being processed * have value at least equal to the one of Xi. If any of them has * parent the parent of Xi (this comprises the parent itself), we * can safely skip most intermediate node along the branch and * skip directly to the top to start our search. */ { int parent = er [i] .parent ; int curr = er [parent] .shortcut ; er [parent] .shortcut = VL_MAX (top, curr) ; } } /* ----------------------------------------------------------------- * Select maximally stable branches * -------------------------------------------------------------- */ nmer = ner ; for(i = 0 ; i < ner ; ++i) { vl_uint parent = er [i ] .parent ; vl_mser_pix val = er [i ] .value ; float var = er [i ] .variation ; vl_mser_pix p_val = er [parent] .value ; float p_var = er [parent] .variation ; vl_uint loser ; /* Notice that R_parent = R_{l+1} only if p_val = val + 1. If not, this and the parent region coincide and there is nothing to do. */ if(p_val > val + 1) continue ; /* decide which one to keep and put that in loser */ if(var < p_var) loser = parent ; else loser = i ; /* make loser NON maximally stable */ if(er [loser] .max_stable) { -- nmer ; er [loser] .max_stable = 0 ; } } f-> stats. num_unstable = ner - nmer ; /* ----------------------------------------------------------------- * Further filtering * -------------------------------------------------------------- */ /* It is critical for correct duplicate detection to remove regions * from the bottom (smallest one first). */ { float max_area = (float) f-> max_area * nel ; float min_area = (float) f-> min_area * nel ; float max_var = (float) f-> max_variation ; float min_div = (float) f-> min_diversity ; /* scan all extremal regions (intensity value order) */ for(i = ner-1 ; i >= 0L ; --i) { /* process only maximally stable extremal regions */ if (! er [i] .max_stable) continue ; if (er [i] .variation >= max_var ) { ++ nbad ; goto remove ; } if (er [i] .area > max_area) { ++ nbig ; goto remove ; } if (er [i] .area < min_area) { ++ nsmall ; goto remove ; } /* * Remove duplicates */ if (min_div < 1.0) { vl_uint parent = er [i] .parent ; int area, p_area ; float div ; /* check all but the root mser */ if((int) parent != i) { /* search for the maximally stable parent region */ while(! er [parent] .max_stable) { vl_uint next = er [parent] .parent ; if(next == parent) break ; parent = next ; } /* Compare with the parent region; if the current and parent * regions are too similar, keep only the parent. */ area = er [i] .area ; p_area = er [parent] .area ; div = (float) (p_area - area) / (float) p_area ; if (div < min_div) { ++ ndup ; goto remove ; } } /* remove dups end */ } continue ; remove : er [i] .max_stable = 0 ; -- nmer ; } /* check next region */ f-> stats .num_abs_unstable = nbad ; f-> stats .num_too_big = nbig ; f-> stats .num_too_small = nsmall ; f-> stats .num_duplicates = ndup ; } /* ----------------------------------------------------------------- * Save the result * -------------------------------------------------------------- */ /* make room */ if (f-> rmer < nmer) { if (mer) vl_free (mer) ; f->mer = mer = vl_malloc( sizeof(vl_uint) * nmer) ; f->rmer = nmer ; } /* save back */ f-> nmer = nmer ; j = 0 ; for (i = 0 ; i < ner ; ++i) { if (er [i] .max_stable) mer [j++] = er [i] .index ; } }
int main(void) { DDRC |= (1<<PORTC6) | (1<<PORTC7); //init LEDs //servoTx; SERVO_init(); //Init servos USART_init(); init_counters(); set_counter_1(10000); initvar(); sei(); SERVO_update_EEPROM(BROADCASTING_ID); //move_to_std(); // ------ TESTCODE FOR READING SERVO ------- //servoGoto(1, 3.14/3, 0x200); SERVO_update_EEPROM(BROADCASTING_ID); // NOTE: needs to run once for SERVO_get position to work //---------------------------- _delay_ms(3000); reset_counter_1(); set_counter_1(3000); while(1) { /* uint8_t r = USART_getRotation(); uint8_t s = USART_getSpeed(); uint8_t d = USART_getDirection(); if(s != 0 || r != 50) { std_pos_flag = 0; reset_counter_1(); } move_robot(d, r, s); if(r == 50 && s == 0 && d == 0) { _delay_ms(50); //PORTD ^= (1<<PORTD5); cli(); USART_send_ready(); sei(); } */ /*change_z(-130); move_to_std(); for(int i = 0; i < 5; ++i) { move_robot(0,50,100); //_delay_ms(2000); } _delay_ms(1000); move_to_std(); _delay_ms(1000); */ climb(); //climb_all_one_leg(); //SERVO_update_data(12); //USART_SendValue(SERVO_get_load()); USART_DecodeRxFIFO(); _delay_ms(200); } }
int main(void) { LED_INIT; //servoTx; sei(); USART_init(); MPU_init(); SERVO_init(); init_counters(); initvar(); SERVO_update_EEPROM(BROADCASTING_ID); wait(10); move_to_std(); wait_until_gyro_stable(); LED0_ON; USART_send_message("Gyro Stable"); // ------ TESTCODE FOR READING SERVO ------- //servoGoto(1, 3.14/3, 0x200); SERVO_update_EEPROM(BROADCASTING_ID); // NOTE: needs to run once for SERVO_get position to work //---------------------------- reset_counter_1(); set_counter_1(3000); uint8_t readyCounter = 0; while(1) { MPU_update(); if(USART_get_turn_flag()) { turn_degrees(USART_get_turn_angle(), USART_get_turn_dir()); } if(USART_get_climb_flag()) { climb(); } uint8_t r = USART_getRotation(); uint8_t s = USART_getSpeed(); uint8_t d = USART_getDirection(); if(s != 0 || r != 50) { std_pos_flag = 0; reset_counter_1(); readyCounter = 3; } move_robot(d, r, s); if(r == 50 && s == 0 && d == 0 && readyCounter) { cli(); USART_send_ready(); sei(); readyCounter--; } if(move_to_std_flag == 1) { move_to_std_flag = 0; move_to_std(); } /*climb(); for(int i = 0; i < 10; ++i) { move_robot(0,50,100); //wait(2000); } */ /* change_z(-120); move_to_std(); turn_degrees(180,1); // Takes a predecided number of steps forward // This is good when testing different things. wait(100); for(int i = 0; i < 10; ++i) { move_robot(0,50,100); //wait(2000); } */ USART_decode_rx_fifo(); } }
int climb(int n, vector<int>& dp) { if (dp[n]) return dp[n]; dp[n] = climb(n-1, dp) + climb(n-2, dp); return dp[n]; }