learning r book

More specifically, read http://www.cnblogs.com/tornadomeet/archive/2013/03/14/2959138.html wrote the blog's reading book and his own understanding. The blue font is your own understanding.The model expression is to give the function relation between input and output, of course, this function has the premise hypothesis, inside can contain the parameter. At this point, if there are many training samples, it is also possible to give a training sample of

"The main topic"There lived N (nIdeasLeft-leaning tree naked, a monkey is a left-leaning tree, and then each fight will first delete the heap, the strength of the value of half inserted back to the original heap, and then merge two heap, the final output heap top can be.About left-leaning tree, see this ppt.1#include 2#include 3#include 4#include 5 using namespac

left-leaning tree (leftist trees)Tree This data structure is really a lot of, two fork heap, in fact, is a binary tree, this talk about the left side of the tree (also known as "left Heap"), is also a tree. Two fork Heap is a very good data structure, because it is very easy to understand, and only use an array, does not cause the waste of extra space, but it has a disadvantage, it is difficult to merge two binary heap, for "merge", "split" This opera

see:http://acm.sdut.edu.cn/bbs/read.php?tid=1177 Huangyuan: The characteristics and application of left-leaning tree 1. Definition: The left-leaning tree (leftist) is an implementation of a scalable heap. Left-leaning tree is a binary tree, its node in addition to the two-fork tree node with the left and right subtree pointer (right), there are two properties: Ke

Topic Link: Click to open the linkIdeas:The key to the problem is how to merge two stacks, we can use a data structure called left-leaning tree, to satisfy the nature of the heap and the nature of the collection, to support the complexity of O (logn) to delete the top element of the heap, insert an element, merge two of the heap.See the code for details:#include HDU 5818 Joint Stacks (left-leaning tree)

task plus W, if the task with the smallest weight is not unique, the weight value is not changed and a line of "ERROR" is outputInput Contains n+1 rows. The 1th line contains three positive integers n, M, K, respectively, representing the number of CPUs, the number of tasks, and the number of instructions. Line 2nd to n+1, each line containing an instruction. n≤500, m≤300000, k≤300000. guarantees that the weight of the task is within the range of a 32-bit signed integer. Ensure that a tas

As stationmaster, we are doing every day the thing that Seoer should do, is every day in the hair outside the chain, every day in writing articles, every day in exchange for links, every day looking at a variety of celebrities blog, every day in the major forums bubble, but we do not know, SEO is only a kind of network marketing, not the whole network marketing, What do we do for SEO purposes? That is, in order to achieve their own network marketing purposes, perhaps marketing specific products,

Test instructions: Give a tree with a root of 1th points, and ask how many points in the subtree of each point are less than L. N Readily smoked a, thought is a water problem, brush water does not reverse be brushed.At first, the problem is not difficult, then the sample old, and then look at the zyf2000 code. Or wrong, finally directly to her hand, the result is wrong. Rage Erase rewrite:The beginning of the thinking is the multiplication of what, but it seems not good dynamic maintenance, and

) master=i; the E[b].push_back (i); the build (i,b,c,l); - } inBuild0,0,0,0); the } the About intDfsintu) the { the intrt=u; the for(intI=0; I) + { - intto=E[u][i]; thert=Merge (Rt,dfs (to));Bayi } the while(ltree[rt].sum>m) the { -ltree[rt].sum-=Ltree[rt].cost; -ltree[rt].size--; thert=del (RT); the } theAns=max (ans, (LL) ltree[rt].size*(ll) ltree[u].key); the returnRT; - } the the voidPrint_ans () the {94printf"%lld", ans); the } the the intMa

); Update (x); returnx;}intInsertintW) {heap[++tot].d=0, heap[tot].sz=1; Heap[tot].lch=heap[tot].rch=0; Heap[tot].sum=heap[tot].w=W; returntot;}voidPopintx) {x=merge (Heap[x].lch,heap[x].rch);}intMain () {scanf ("%d%d",n,m); for(intI=1; i) {scanf ("%d%d%d",b[i],c[i],L[i]); Root[i]=Insert (c[i]); while(heap[root[i]].sum>m) pop (root[i]); } for(intI=n;i>0; i--) {ans=max (ans,1ll*heap[root[i]].sz*L[i]); Root[b[i]]=merge (Root[i],root[b[i]]); while(heap[root[b[i]]].sum>m) pop (Root[b[i]]);

(rt2==0)returnRt1; to if(heap[rt2].val>heap[rt1].val) Swap (RT1,RT2); +HEAP[RT1].R =merge (HEAP[RT1].R,RT2); -Heap[heap[rt1].r].par =Rt1; the if(heap[heap[rt1].l].dis heap[HEAP[RT2].R].dis) * swap (HEAP[RT1].L, HEAP[RT1].R); $ ElseHeap[rt1].dis = heap[HEAP[RT1].R].dis +1;Panax Notoginseng returnRt1; - } the intPush (intXinty) { + returnmerge (x, y); A } the intPop (intx) { + intL =HEAP[X].L; - intR =HEAP[X].R; $Heap[l].par =l; $Heap[r].par =R; -HEAP[X].L = HEAP[

Left side of the tree to mark, No.#include #includeusing namespaceStd;typedefLong Longll;Const intN =300005;intn,m,e,x,tt,c[n],d[n],a[n],hd[n],nxt[n],to[n],rt[n],f[n],g[n];ll H[n],v[n],s[n];vectorint>Vc[n];structnd {intL,r,d,id; ll W,ad,mu;} T[n];voidAddintXintY) {To[++e] = y, nxt[e] = hd[x], hd[x] =e;}voidPdintx) {t[t[x].l].mu*= t[x].mu, T[t[x].l].ad *= t[x].mu, T[T[X].L].W *=t[x].mu; T[t[x].r].mu*= t[x].mu, T[t[x].r].ad *= t[x].mu, T[T[X].R].W *=t[x].mu; T[t[x].l].ad+ = T[x].ad, t[t[x].r].ad +

Ref: 55806735A left-leaning tree with a piece of the class that can be stacked and partially written#include #include using namespaceStdConst intn=600005;intn,m,tot,fa[n],len[n],rt[n],d[n],cnt;Long LongP[n],sum;intRead () {intR=0, f=1;CharP=getchar (); while(p>' 9 '|| p' 0 ') {if(p=='-') f=-1; P=getchar (); } while(p>=' 0 'p' 9 ') {r=r*Ten+p-48; P=getchar (); }returnR*f;}structqwe{intL,r,dis;Long LongV;} E[n];intHbintXintY) {if(!x| |! Yreturn

Left-leaning tree is a should be used to maintain the interval, and then need to merge operations and the invention of the algorithm, in fact, the algorithm is not difficult, and the tree is a bit like, maintain a few values, and then recursive back to the time can be modified.The problem is dry:background in a ninja gang, some ninjas are selected to be dispatched to the customer and rewarded for their work. Title description in this gang, there is a

We need to enumerate the root and then choose as many points from its subtree as possible and pay no more than M, but the complexity of the violence is not right.Then consider merging the tree from bottom up (there is only one node in each tree, which is itself)Each tree is a heap, we maintain the number of nodes in the tree and the sum of the salaries, and when combined, the top salary of the heap is constantly popped up until the sum of the salary does not exceed m, then the answer is updated

->Right , y); - if(X-GT;LEFT-GT;NPL NPL) {101leftlistnodeLeft ;102X->left = x->Right ;103X->right =tmp;104 } theX-GT;NPL = X-GT;RIGHT-GT;NPL +1;106 }107 }108 returnx;109 } theleftlistnodeitems) {111QueueTmp_queue; the for(inti =0; I i)113Tmp_queue.push (NewLeftlistnode(Items[i])); the while(Tmp_queue.size () >1){ theleftlistnodeTmp_queue.front (); the Tmp_queue.pop ();117leftlistnodeTmp_queue.front ();118 Tmp_queue

https://www.lydsy.com/JudgeOnline/problem.php?id=2809The board question WA a bit because output ans has no LLD1#include 2#include 3#include 4#include 5#include 6#include 7 using namespacestd;8 Const intmaxn=100100;9 intn,m;Ten intch[maxn][2]={},siz[maxn]={},sum[maxn]={},cnt[maxn]={},rt[maxn]={}; One intfa[maxn]={},val[maxn]={},l[maxn]={}; A inty[maxn],nex[maxn]={},head[maxn]={},tot=0; - Long Longans=0; - voidInitintXintYi) { they[++tot]=yi;nex[tot]=head[x];head[x]=tot; - } - voidUpdata (intx) {