@@ -0,0 +1,37 @@
+class ArticulationPoints{
+	private static int time;
+	private static int[] disc, low;
+	private static boolean[] visited;
+
+	public static boolean[] articulationPoints(int[][] graph){
+		int NumberOfNodes = graph.length;
+
+		time = -1;
+		disc = new int[NumberOfNodes];
+		low = new int[NumberOfNodes];
+		visited = new boolean[NumberOfNodes];
+		java.util.Arrays.fill(low, 2*NumberOfNodes);
+
+		boolean[] isAP = new boolean[NumberOfNodes];
+		for(int i = 0; i< NumberOfNodes; i++)if(!visited[i] && graph[i] != null)apUtil(graph, isAP, i, -1);
+		return isAP;
+	}
+
+	private static void apUtil(int[][] g, boolean[] isAP, int u, int p){
+		visited[u] = true;
+		disc[u] = low[u] = ++time;
+
+		int childCount = 0;
+		for(int v:g[u]){
+			if(!visited[v]){
+				apUtil(g, isAP, v, u);
+
+				low[u] = Math.min(low[u], low[v]);
+				childCount++;
+
+				if(p != -1 && low[v] >= disc[u])isAP[u] = true;
+			}else if(v != p)low[u] = Math.min(low[u], disc[v]);
+		}
+		if(p == -1 && childCount > 1)isAP[u] = true;
+	}
+}
@@ -0,0 +1,20 @@
+class ArticulationPointsUsage{
+	//Usage example ArticulationPoint.articulationPoints()
+	public static void articulationPointsUsage(){
+		int N = 6, E = 6;
+		int[] from = new int[]{0,1,1,2,2,4};
+		int[] to = new int[]{5,4,5,3,4,5};
+
+		int[][] graph = GraphBuilder.makeGraph(N, E, from, to, true);
+		boolean[] articulationPoint = ArticulationPoints.articulationPoints(graph);
+
+		for(int i = 0; i< N; i++){
+			if(articulationPoint[i])
+				System.out.println(i+" is an articulation point");
+		}
+	}
+	
+	public static void main(String[] args){
+		articulationPointsUsage();
+	}
+}
@@ -0,0 +1,19 @@
+# Class ArticulationPoint
+
+Given a graph generated using GraphBuilder.makeGraph(), this class finds all articulation points in graph. Since GraphBuilder assumes 0-based indexing, this class also works assuming 0-based indexing.
+
+All members of this class are static, so no constructor defined.
+
+## Methods
+
+### articulationPoints
+```
+public static boolean[] articulationPoints(int[][] graph)
+```
+Returns boolean array of length $N$ where $N$ denotes the number of nodes in given graph, i-th element in this boolean array denotes whether i-th node in given graph is an articulation point or not.
+
+** Constraints **
+* graph is generated using GraphBuilder.makeGraph(), so all constraints applicable to makeGraph method applies.
+
+** Computational complexity **
+* $ O (NumberOfNodes + NumberOfEdges) $
@@ -0,0 +1,44 @@
+class Bridge{
+	private static int time;
+	private static int[] disc, low;
+	private static boolean[] visited;
+
+	public static boolean[] bridges(int[][][] graphWithEdgeInfo){
+		int edgeCount = 0;
+		for(int[][] row:graphWithEdgeInfo)edgeCount += row.length;
+		return bridges(graphWithEdgeInfo, edgeCount/2);
+	}
+
+	public static boolean[] bridges(int[][][] graphWithEdgeInfo, int edgeCount){
+		int NumberOfNodes = graphWithEdgeInfo.length;
+
+		time = -1;
+		disc = new int[NumberOfNodes];
+		low = new int[NumberOfNodes];
+		visited = new boolean[NumberOfNodes];
+		java.util.Arrays.fill(low, 2*NumberOfNodes);
+
+		boolean[] isBridge = new boolean[edgeCount];
+		for(int i = 0; i< NumberOfNodes; i++)if(!visited[i] && graphWithEdgeInfo[i] != null)bridgeUtil(graphWithEdgeInfo, isBridge, i, -1);
+		return isBridge;
+	}
+
+	private static void bridgeUtil(int[][][] g, boolean[] isBridge, int u, int parentEdge){
+		visited[u] = true;
+		disc[u] = low[u] = ++time;
+
+		for(int[] edge: g[u]){
+			int v = edge[0], edgeIndex = edge[1];
+			if(parentEdge == edgeIndex)continue;
+
+			if(visited[v])
+				low[u] = Math.min(low[u], disc[v]);
+			else{
+				bridgeUtil(g, isBridge, v, edgeIndex);
+				low[u] = Math.min(low[u], low[v]);
+
+				if(low[v] > disc[u])isBridge[edgeIndex] = true;
+			}
+		}
+	}
+}
@@ -0,0 +1,20 @@
+class BridgeUsage{
+	//Usage Example Bridge.bridges()
+	public static void bridgesUsage(){
+		int N = 6, E = 9;
+		int[] from = new int[]{0,1,1,2,2,4,4,3,1};
+		int[] to = new int[]{5,4,5,3,4,5,4,2,4};
+
+		int[][][] graph = GraphBuilder.makeGraphWithEdgeInfo(N, E, from, to, true);
+		boolean[] isBridge = Bridge.bridges(graph);
+
+		for(int i = 0; i< E; i++){
+			if(isBridge[i])
+				System.out.println(from[i] + " - " + to[i] + " is a bridge");
+		}
+	}
+	
+	public static void main(String[] args){
+		bridgesUsage();
+	}
+}
@@ -0,0 +1,32 @@
+# Class Bridge
+
+Given an undirected graph generated using GraphBuilder.makeGraphWithEdgeInfo(), this class finds all bridges in graph. Since GraphBuilder assumes 0-based indexing, this class also works assuming 0-based indexing. This class can handle multi-edges as well as self loops.
+
+All members of this class are static, so no constructor defined.
+
+## Methods
+
+### bridges
+```
+public static boolean[] bridges(int[][][] graphWithEdgeInfo, int edgeCount)
+```
+Returns boolean array of length $edgeCount$ where $EdgeCount$ denotes the number of edges in given graph, i-th element in this boolean array denotes whether i-th edge in given graph is a bridge or not. The edges are numbered as per their order in input, defined in GraphBuilder.makeGraphWithEdgeInfo()
+
+** Constraints **
+* graph is generated using GraphBuilder.makeGraphWithEdgeInfo(), so all constraints applicable to makeGraphWithEdgeInfo method applies.
+* edgeCount = Number of edges specified in GraphBuilder.makeGraphWithEdgeInfo()
+
+** Computational complexity **
+* $ O (NumberOfNodes + NumberOfEdges) $
+
+
+```
+public static boolean[] bridges(int[][][] graphWithEdgeInfo)
+```
+This method computed the number of edges in specified graph, and invokes ```boolean[] bridges(int[][][] graphWithEdgeInfo, int edgeCount)``` to return boolean array, i-th element in this boolean array denotes whether i-th edge in given graph is a bridge or not.
+
+** Constraints **
+* graph is generated using GraphBuilder.makeGraphWithEdgeInfo(), so all constraints applicable to makeGraphWithEdgeInfo method applies.
+
+** Computational complexity **
+* $ O (NumberOfNodes + NumberOfEdges) $
@@ -16,6 +16,10 @@ public FenwickTree(long[] data) {
         build(data);
     }
 
+    public void set(int p, long x){
+        add(p, x - get(p));
+    }
+
     public void add(int p, long x){
         assert(0<=p && p<_n);
         p++;
@@ -29,6 +33,10 @@ public long sum(int l, int r){
         return sum(r)-sum(l);
     }
 
+    public long get(int p){
+        return sum(p, p+1);
+    }
+
     private long sum(int r){
         long s = 0;
         while(r>0){
 
@@ -32,6 +32,19 @@ public void add(int p, long x)
 配列の第$p$要素に$x$を加える. すなわち, `a[p] += x` のこと.
 計算量: $O(\log N)$
 
+### set
+```java
+public void set(int p, long x)
+```
+配列の第$p$要素を$x$に変更する. すなわち, `a[p] = x` のこと.
+計算量: $O(\log N)$
+
+### get
+```java
+public long get(int p)
+```
+配列の第$p$要素を取得する. 計算量: $O(\log n)$
+
 ### sum
 ```java
 public long sum(int l, int r)
 
@@ -0,0 +1,31 @@
+class GraphBuilder{
+	public static int[][] makeGraph(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to, boolean undirected){
+		int[][] graph = new int[NumberOfNodes][];
+		int[] outdegree = new int[NumberOfNodes];
+		for(int i = 0; i< NumberOfEdges; i++){
+		    outdegree[from[i]]++;
+		    if(undirected)outdegree[to[i]]++;
+		}
+		for(int i = 0; i< NumberOfNodes; i++)graph[i] = new int[outdegree[i]];
+		for(int i = 0; i< NumberOfEdges; i++){
+		    graph[from[i]][--outdegree[from[i]]] = to[i];
+		    if(undirected)graph[to[i]][--outdegree[to[i]]] = from[i];
+		}
+		return graph;
+	}
+	
+	public static int[][][] makeGraphWithEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to, boolean undirected){
+		int[][][] graph = new int[NumberOfNodes][][];
+		int[] outdegree = new int[NumberOfNodes];
+		for(int i = 0; i< NumberOfEdges; i++){
+		    outdegree[from[i]]++;
+		    if(undirected)outdegree[to[i]]++;
+		}
+		for(int i = 0; i< NumberOfNodes; i++)graph[i] = new int[outdegree[i]][];
+		for(int i = 0; i< NumberOfEdges; i++){
+		    graph[from[i]][--outdegree[from[i]]] = new int[]{to[i], i, 0};
+		    if(undirected)graph[to[i]][--outdegree[to[i]]] = new int[]{from[i], i, 1};
+		}
+		return graph;
+	}
+}
@@ -0,0 +1,34 @@
+class GraphBuilderUsage{
+	//Usage Exmaple
+	public static void makeGraphUsage(){
+		int N = 6, E = 8;
+		int[] from = new int[]{0,0,0,1,1,2,2,4};
+		int[] to = new int[]{2,4,5,4,5,3,4,5};
+
+		int[][] graph = GraphBuilder.makeGraph(N, E, from, to, true);
+		for(int i = 0; i< N; i++){
+			System.out.print(i+": ");
+			for(int j:graph[i])System.out.print(j+" ");
+			System.out.println();
+		}
+	}
+
+	//Usage Example
+	public static void makeGraphWithEdgeInfoUsage(){
+		int N = 6, E = 8;
+		int[] from = new int[]{0,0,0,1,1,2,2,4};
+		int[] to = new int[]{2,4,5,4,5,3,4,5};
+
+		int[][][] graph = GraphBuilder.makeGraphWithEdgeInfo(N, E, from, to, true);
+		for(int i = 0; i< N; i++){
+			System.out.print(i+": ");
+			for(int[] j:graph[i])System.out.print("["+j[0]+", "+j[1]+", "+j[2]+"],");
+			System.out.println();
+		}
+	}
+
+	public static void main(String[] args){
+		makeGraphUsage();
+		makeGraphWithEdgeInfoUsage();
+	}
+}