init update

Author: wandering007

BIThrTree.cpp

@@ -0,0 +1,45 @@
+//线索二叉树
+typedef struct  BiThrNode
+{
+	TelemType data;
+	struct BiThrNode *lchild, *rchild;
+	int LTag,RTag;
+};BiThrNode,*BiThrTree;
+//以结点p为根的子树中序线索化
+void InThreading(BiThrTree p)
+{//pre是全局变量，初始化时其右孩子指针为空，便于左树的最左点开始建线索
+	if(p)
+	{
+		InThreading(p->lchild);
+		if(!p->lchild)
+		{
+			p->LTag = 1;
+			p->lchild = pre;
+		}
+		if(!pre->rchild)
+		{
+			pre->RTag = 1;
+			pre->rchild = p;
+		}
+		pre = p;
+		InOrderThreading(p->rchild);
+	}
+}
+//带头结点的中序线索化
+void InOrderThreading(BiThrTree &Thrt, BiThrTree T)
+{
+	Thrt = new BiThrNode;
+	Thrt->LTag = 0;
+	Thrt->RTag = 1;
+	Thrt->rchild = Thrt;
+	if(!T) Thrt->rchild = Thrt;
+	else 
+	{
+		Thrt->lchild = T;
+		pre = Thrt;
+		InTreading(T);
+		pre->rchild = Thrt;
+		pre->RTag = 1;
+		Thrt->rchild = pre;
+	}
+}

BellmanFord.cpp

@@ -0,0 +1,15 @@
+bool BellmanFord(int MAX_VERTEXS, int MAX_EDGES, int v)
+{//Single sourse all destination shortest paths with negative edge lengths
+	for(int i=0;i<MAX_VERTEXS;i++)
+		dist[i] = length[v][i];//initialize dist
+	for(int k=2; k<MAX_VERTEXS; k++)
+		for(int j=0;j<MAX_EDGES; j++)
+			{
+				if(dist[j].u!=INFINIT&&dist[edge[j].u]+length[edge[j].u][edge[j].v]<dist[edge[j].v])
+					dist[edge[j].v] = dist[edge[j].u]+length[edge[j].u][edge[j].v];
+			}
+	for(int i=0; i<MAX_EDGES; i++)
+		if(dist[j].u!=INFINIT&&dist[edge[i].u]+length[edge[i].u][edge[i].v]<dist[edge[i].v])
+			return FAlSE;
+	return TRUE;
+}

BinaryIndexedTree.cpp

@@ -0,0 +1,185 @@
+//A Fenwick BIT or binary indexed tree is a data structure providing efficient methods 
+//for calculation and manipulation of the prefix sums of a table of values. 
+
+//1D version
+//空间复杂度O(n), 初始化时间复杂度O(n*log n), 查询区间复杂度O(log n)
+//n —— maximum value which will have non-zero frequency
+//idx is some index of BIT. r is a position in idx of the last digit 1 (from left to right) in binary notation. 
+//BIT[idx] is sum of frequencies from index (idx - 2^r + 1) to index idx.
+//We also write that idx is responsible for indexes from (idx - 2^r + 1) to idx.
+
+//Sample C Implementation
+
+int lowbit(int x)
+{
+    return x & (-x);
+}
+
+void update(int i, int delta)
+{
+	while(i <= MaxVal)//MaxVal —— maximum value which will have non-zero frequency
+	{
+		BIT[i] += delta;
+		i += lowbit(i);
+	}
+    return;
+}
+
+int query(int k)
+{
+    int ans = 0;
+    while(k > 0)
+    {
+    	ans += BIT[k];
+    	k -= lowbit(k);
+    }
+    return ans;
+}
+
+// the actual frequency at a position idx can be calculated by calling function qeury twice
+//f[idx] = query(idx) - query(idx - 1), but the function below is faster
+int querySingle(int idx)
+{
+	int sum = BIT[idx]; // sum will be decreased
+	if (idx > 0)
+	{ // special case
+		int z = idx - lowbit(idx); // make z first
+		--idx; // idx is no important any more, so instead y, you can use idx
+		while (idx != z)
+		{ // at some iteration idx (y) will become z
+			sum -= BIT[idx]; 
+		// substruct BIT frequency which is between y and "the same path"
+			idx -= lowbit(idx);
+		}
+	}
+	return sum;
+}
+
+//Scaling the entire BIT by a constant factor c
+void scale(int c)//c is maybe not an integer
+{
+	void scale(int c)
+	{
+	   for (int i = 1 ; i <= MaxVal; i++)
+			BIT[i] *= c; 
+	  //here we assume that c is used to multiply the original frenquency(maybe divide)
+    }
+    return;
+}
+
+//Find index with given cumulative frequency
+
+// if in BIT exists more than one index with a same
+// cumulative frequency, this procedure will return 
+// some of them (we do not know which one)
+
+// bitMask - initialy, it is the greatest bit of MaxVal
+// bitMask store interval which should be searched
+int find(int cumFre)
+{
+	int idx = 0; // this var is result of function
+	
+	while ((bitMask != 0) && (idx < MaxVal))
+	{ // nobody likes overflow :)
+		int tIdx = idx + bitMask; // we make midpoint of interval
+		if (cumFre == BIT[tIdx]) // if it is equal, we just return idx
+			return tIdx;
+		else if (cumFre > BIT[tIdx])
+		{ // if BIT frequency "can fit" into cumFre, then include it
+			idx = tIdx; // update index 
+			cumFre -= BIT[tIdx]; // set frequency for next loop 
+		}
+		bitMask >>= 1; // half current interval
+	}
+	if (cumFre != 0) // maybe given cumulative frequency doesn't exist
+		return -1;
+	else
+		return idx;
+}
+// if in BIT exists more than one index with a same
+// cumulative frequency, this procedure will return 
+// the greatest one
+int findG(int cumFre){
+	int idx = 0;
+	
+	while ((bitMask != 0) && (idx < MaxVal)){
+		int tIdx = idx + bitMask;
+		if (cumFre >= BIT[tIdx])
+		{// if current cumulative frequency is equal to cumFre, 
+		 // we are still looking for higher index (if exists)
+			idx = tIdx;
+			cumFre -= BIT[tIdx];
+		}
+		bitMask >>= 1;
+	}
+	if (cumFre != 0)
+		return -1;
+	else
+		return idx;
+}
+//Time complexity: O(log MaxVal)
+
+//Sample C++ Implementation(a bit different idea)
+
+class Fenwick_BIT_Sum
+{
+    vector< int > BIT;
+    Fenwick_BIT_Sum(const vector< int >& Arg)//Arg is our array on which we are going to work
+    {
+        BIT.resize(Arg.size());
+        for(int i = 0 ; i < BIT.size(); ++i)
+            increase(i, Arg[i]);
+    }
+ 
+    // Increases value of i-th element by ''delta''.
+    void increase(int i, int delta)
+    {
+        for (; i < (int)BIT.size(); i |= i + 1)
+            BIT[i] += delta;
+    }
+ 
+    // Returns sum of elements with indexes left..right, inclusive; (zero-based);
+    int getsum(int left, int right)
+    {
+        return sum(right) - sum(left - 1); //when left equals 0 the function hopefully returns 0
+    }
+ 
+    int sum(int ind)
+    {
+        int sum = 0;
+        while (ind >= 0)
+        {
+            sum += BIT[ind];
+            ind &= ind + 1;
+            --ind;
+        }
+        return sum;
+    }
+};
+
+//2D version
+
+int lowbit(int t)
+{  
+    return t & (-t);
+}  
+
+void update(int i, int j, int delta)
+{
+    A[i][j] += delta;
+    for(int x = i; x <= MaxVal_X; x += lowbit(x))
+        for(int y = j; y <= MaxVal_Y; y += lowbit(y))
+          BIT[x][y] += delta;
+    return;
+}
+
+int query(int i, int j)
+{
+    int result = 0;
+    for(int x = i; x > 0; x -= lowbit(x)) 
+        for(int y = j; y > 0; y -= lowbit(y)) 
+           result += BIT[x][y];
+    return result;
+}
+
+//多维树状数组与一维二维树状数组实现很相似，只是在查询区间时注意容斥原理的使用