From 0da40b78b11d7ed0ac5a22b8fbbffa06b80b290e Mon Sep 17 00:00:00 2001 From: anand kumar rai Date: Mon, 21 Oct 2019 04:11:57 +0530 Subject: [PATCH] segment tree --- AsgnsClient.java | 265 ++++++++++++++++++++++++++++++++++++ Client.java | 18 +++ ISegmentOperator.java | 6 + SegmentMaxOperator.java | 17 +++ SegmentMinOperator.java | 17 +++ SegmentProductOperator.java | 17 +++ SegmentSumOperator.java | 17 +++ SegmentTree.java | 100 ++++++++++++++ 8 files changed, 457 insertions(+) create mode 100644 AsgnsClient.java create mode 100644 Client.java create mode 100644 ISegmentOperator.java create mode 100644 SegmentMaxOperator.java create mode 100644 SegmentMinOperator.java create mode 100644 SegmentProductOperator.java create mode 100644 SegmentSumOperator.java create mode 100644 SegmentTree.java diff --git a/AsgnsClient.java b/AsgnsClient.java new file mode 100644 index 0000000..9ef033d --- /dev/null +++ b/AsgnsClient.java @@ -0,0 +1,265 @@ +package aug18; + +import java.util.Arrays; +import java.util.HashMap; + +public class AsgnsClient { + + public static void main(String[] args) { + // int n = 15; + // boolean[] primes = soe(n); + // + // HashMap ladders = new HashMap<>(); + // int left = 0; + // int right = primes.length - 1; + // while(left < right){ + // while(primes[left] == false){ + // left++; + // } + // + // while(primes[right] == false){ + // right--; + // } + // + // if(left < right){ + // ladders.put(left, right); + // left++; + // right--; + // } + // } + // + // a8bq7(0, n, "", ladders); + + // int n = 15; + // boolean[] primes = soe(n); + // + // HashMap snl = new HashMap<>(); + // int left = 0; + // int right = primes.length - 1; + // int counter = 0; + // while (left < right) { + // while (primes[left] == false) { + // left++; + // } + // + // while (primes[right] == false) { + // right--; + // } + // + // if (left < right) { + // counter++; + // + // if (counter % 2 == 1) { + // snl.put(left, right); + // } else { + // snl.put(right, left); + // } + // + // left++; + // right--; + // } + // } + // + // System.out.println(a8bq8(0, n, new int[] { 6, 5, 2, 4, 6, 5, 2, 1}, + // 0, snl)); + + // int er = 3; + // int ec = 3; + // boolean[] primes = soe((er + 1) * (ec + 1)); + // + // HashMap mnp = new HashMap<>(); + // int counter = 0; + // + // for (int i = 0; i < primes.length; i++) { + // if (primes[i] == true) { + // counter++; + // + // if (counter % 2 == 1) { + // mnp.put(i, false); + // } else { + // mnp.put(i, true); + // } + // } + // } + // + // a8bq9(0, 0, 3, 3, "", mnp); + +// boolean[][] board = new boolean[3][3]; +// nknights(1, board, "", 0); + + int a = 1; + int b = 2; + int c = a ^ b; + System.out.println(c); + } + + private static boolean a8bq8(int curr, int end, int[] dices, int diceidx, HashMap snl) { + if (curr == end) { + return true; + } + + if (diceidx == dices.length) { + return false; + } + + if (snl.containsKey(curr)) { + return a8bq8(snl.get(curr), end, dices, diceidx, snl); + } else { + if (curr + dices[diceidx] <= end) { + return a8bq8(curr + dices[diceidx], end, dices, diceidx + 1, snl); + } else { + return a8bq8(curr, end, dices, diceidx + 1, snl); + } + } + } + + public static boolean[] soe(int n) { + boolean[] primes = new boolean[n + 1]; + Arrays.fill(primes, true); + + primes[0] = primes[1] = false; + for (int tbl = 2; tbl * tbl <= n; tbl++) { + if (primes[tbl] == false) { + continue; + } + + for (int ja = 2; tbl * ja <= n; ja++) { + primes[tbl * ja] = false; + } + } + + return primes; + } + + public static void a8bq7(int curr, int end, String psf, HashMap ladders) { + if (curr == end) { + System.out.println(psf); + return; + } + + if (curr > end) { + return; + } + + if (ladders.containsKey(curr)) { + a8bq7(ladders.get(curr), end, psf + "L[" + curr + " -> " + ladders.get(curr) + "]", ladders); + } else { + for (int dice = 1; dice <= 6; dice++) { + a8bq7(curr + dice, end, psf + "D" + dice, ladders); + } + } + + } + + public static void a8bq9(int cr, int cc, int er, int ec, String psf, HashMap mnp) { + if (cr == er && cc == ec) { + System.out.println(psf + "."); + return; + } + + if (cr > er || cc > ec) { + return; + } + + int num = cr * (ec + 1) + cc + 1; + + if (mnp.containsKey(num)) { + if (mnp.get(num) == false) { + return; + } else { + a8bq9(er, ec, er, ec, psf + "PORTED", mnp); + } + } + + a8bq9(cr + 2, cc + 1, er, ec, psf + "K21 => ", mnp); + a8bq9(cr + 1, cc + 2, er, ec, psf + "K12 => ", mnp); + + if (cr == 0 || cr == er || cc == 0 || cc == ec) { + // h + int movesh = 1; + while (cc + movesh <= ec) { + a8bq9(cr, cc + movesh, er, ec, psf + "RH" + movesh + " => ", mnp); + movesh++; + } + + // v + int movesv = 1; + while (cr + movesv <= er) { + a8bq9(cr + movesv, cc, er, ec, psf + "RV" + movesv + " => ", mnp); + movesv++; + } + } + + if (cr == cc || cr + cc == ec) { + int moves = 1; + while (cr + moves <= er && cc + moves <= ec) { + a8bq9(cr + moves, cc + moves, er, ec, psf + "B" + moves + " => ", mnp); + moves++; + } + } + } + + public static void a9q18(int[] arr) { + int lo = 0, mid = 0, hi = arr.length - 1; + + while (mid <= hi) { + if (arr[mid] == 0) { + int temp = arr[mid]; + arr[mid] = arr[lo]; + arr[lo] = temp; + + lo++; + mid++; + } else if (arr[mid] == 1) { + mid++; + } else { + int temp = arr[mid]; + arr[mid] = arr[hi]; + arr[hi] = temp; + + hi--; + } + } + } + + static int counter = 0; + + public static void nknights(int cellno, boolean[][] board, String config, int kpsf) { + if (kpsf == board.length) { + counter++; + System.out.println(counter + "." + config); + return; + } + + for (int i = cellno; i <= board.length * board.length; i++) { + int cr = (i - 1) / board.length; + int cc = (i - 1) % board.length; + + if (isitsafetoplacetheknight(cr, cc, board)) { + board[cr][cc] = true; + nknights(i + 1, board, config + "[" + cr + "-" + cc + "], ", kpsf + 1); + board[cr][cc] = false; + } + } + } + + private static boolean isitsafetoplacetheknight(int cr, int cc, boolean[][] board) { + if(cr - 2 >= 0 && cc - 1 >= 0 && board[cr - 2][cc - 1] == true) { + return false; + } + + if(cr - 2 >= 0 && cc + 1 < board.length && board[cr - 2][cc + 1] == true){ + return false; + } + + if(cr - 1 >= 0 && cc - 2 >= 0 && board[cr - 1][cc - 2] == true){ + return false; + } + + if(cr - 1 >= 0 && cc + 2 < board.length && board[cr - 1][cc + 2] == true){ + return false; + } + + return true; + } +} diff --git a/Client.java b/Client.java new file mode 100644 index 0000000..656797f --- /dev/null +++ b/Client.java @@ -0,0 +1,18 @@ +package aug18; + +public class Client { + + public static void main(String[] args) { + int[] arr = {10, 2, -3, 7, 6, -4, 8, -2}; + + SegmentTree st = new SegmentTree(arr, new SegmentMinOperator()); + System.out.println(st.query(2, 5)); + System.out.println(st.query(3, 7)); + + st.changeOperator(new SegmentMaxOperator()); + + System.out.println(st.query(2, 5)); + System.out.println(st.query(3, 7)); + } + +} diff --git a/ISegmentOperator.java b/ISegmentOperator.java new file mode 100644 index 0000000..d2d3308 --- /dev/null +++ b/ISegmentOperator.java @@ -0,0 +1,6 @@ +package aug18; + +public interface ISegmentOperator { + public int operation(int lsv, int rsv); + public int defaultValue(); +} diff --git a/SegmentMaxOperator.java b/SegmentMaxOperator.java new file mode 100644 index 0000000..ad4a3d5 --- /dev/null +++ b/SegmentMaxOperator.java @@ -0,0 +1,17 @@ +package aug18; + +public class SegmentMaxOperator implements ISegmentOperator { + + @Override + public int operation(int lsv, int rsv) { + // TODO Auto-generated method stub + return Integer.max(lsv, rsv); + } + + @Override + public int defaultValue() { + // TODO Auto-generated method stub + return Integer.MIN_VALUE; + } + +} diff --git a/SegmentMinOperator.java b/SegmentMinOperator.java new file mode 100644 index 0000000..ed465f2 --- /dev/null +++ b/SegmentMinOperator.java @@ -0,0 +1,17 @@ +package aug18; + +public class SegmentMinOperator implements ISegmentOperator { + + @Override + public int operation(int lsv, int rsv) { + // TODO Auto-generated method stub + return Integer.min(lsv, rsv); + } + + @Override + public int defaultValue() { + // TODO Auto-generated method stub + return Integer.MAX_VALUE; + } + +} diff --git a/SegmentProductOperator.java b/SegmentProductOperator.java new file mode 100644 index 0000000..e4227cb --- /dev/null +++ b/SegmentProductOperator.java @@ -0,0 +1,17 @@ +package aug18; + +public class SegmentProductOperator implements ISegmentOperator { + + @Override + public int operation(int lsv, int rsv) { + // TODO Auto-generated method stub + return lsv * rsv; + } + + @Override + public int defaultValue() { + // TODO Auto-generated method stub + return 1; + } + +} diff --git a/SegmentSumOperator.java b/SegmentSumOperator.java new file mode 100644 index 0000000..d460e85 --- /dev/null +++ b/SegmentSumOperator.java @@ -0,0 +1,17 @@ +package aug18; + +public class SegmentSumOperator implements ISegmentOperator { + + @Override + public int operation(int lsv, int rsv) { + // TODO Auto-generated method stub + return lsv + rsv; + } + + @Override + public int defaultValue() { + // TODO Auto-generated method stub + return 0; + } + +} diff --git a/SegmentTree.java b/SegmentTree.java new file mode 100644 index 0000000..698d0b5 --- /dev/null +++ b/SegmentTree.java @@ -0,0 +1,100 @@ +package aug18; + +public class SegmentTree { + private class Node { + int data; + int si; + int ei; + Node left; + Node right; + } + + private Node root; + private int size; + private ISegmentOperator operator; + + public void changeOperator(ISegmentOperator operator){ + this.operator = operator; + updateToNewOperator(root); + } + + private void updateToNewOperator(Node node){ + if(node.si == node.ei){ + return; + } + + updateToNewOperator(node.left); + updateToNewOperator(node.right); + node.data = operator.operation(node.left.data, node.right.data); + } + + public SegmentTree(int[] arr, ISegmentOperator operator){ + this.operator = operator; + root = construct(arr, 0, arr.length - 1); + } + + private Node construct(int[] arr, int si, int ei){ + if(si == ei){ + Node base = new Node(); + this.size++; + + base.data = arr[si]; + base.si = base.ei = si; + return base; + } + + int mid = (si + ei) / 2; + + Node node = new Node(); + this.size++; + node.si = si; + node.ei = ei; + node.left = construct(arr, si, mid); + node.right = construct(arr, mid + 1, ei); + node.data = this.operator.operation(node.left.data, node.right.data); + + return node; + } + + public int query(int qsi, int qei){ + return query(root, qsi, qei); + } + + private int query(Node node, int qsi, int qei){ + //node entirely in the query + if(node.si >= qsi && node.ei <= qei){ + return node.data; + } + // node entirely out the query + else if(node.ei < qsi || node.si > qei){ + return this.operator.defaultValue(); + } + // overlap + else { + int lsc = query(node.left, qsi, qei); + int rsc = query(node.right, qsi, qei); + return this.operator.operation(lsc, rsc); + } + } + + public void update(int nv, int idx){ + update(root, nv, idx); + } + + private void update(Node node, int nv, int idx) { + if(node.si == idx && node.ei == idx){ + node.data = nv; + return; + } + + int mid = (node.si + node.ei) / 2; + + if(idx > mid){ + update(node.right, nv, idx); + } else { + update(node.left, nv, idx); + } + + node.data = this.operator.operation(node.left.data, node.right.data); + } +}