static void Method(string[] args) { int[] nk = ReadInts(); int n = nk[0]; int k = nk[1]; int[] array = new int[n]; for (int i = 0; i < n; i++) { array[i] = ReadInt(); } var tree = new LazySegmentTree <int, int>(610000, Max, (node, next) => Max(node.val, next), (nodeA, nodeB) => Max(nodeA.val, nodeB.val), 0, 0); int res = 0; for (int i = 0; i < n; i++) { int left = Max(0, array[i] - k); int right = array[i] + k; int val = tree.Scan(left, right) + 1; res = Max(res, val); tree.Update(array[i], array[i], val); } WriteLine(res); }
public void UpdateTest4() { var values = new List <int> { 1, 2, 3, 4, 5, 6 }; var tree = LazySegmentTree.Create(values, new MaxOperation()); Assert.AreEqual(6, tree.Query(0, values.Count - 1)); tree.Update(0, values.Count - 1, 10); // 11 12 13 14 15 16 Assert.AreEqual(16, tree.Query(0, values.Count - 1)); tree.Update(1, values.Count - 2, 10); // 11 22 23 24 25 16 Assert.AreEqual(25, tree.Query(0, values.Count - 1)); tree.Update(0, 1, 20); // 31 42 23 24 25 16 Assert.AreEqual(42, tree.Query(0, values.Count - 1)); Assert.AreEqual(31, tree.Query(0, 0)); Assert.AreEqual(42, tree.Query(1, 1)); Assert.AreEqual(23, tree.Query(2, 2)); Assert.AreEqual(24, tree.Query(3, 3)); Assert.AreEqual(25, tree.Query(4, 4)); Assert.AreEqual(16, tree.Query(5, 5)); tree.Update(1, 3, -20); // 31 22 3 4 25 16 Assert.AreEqual(31, tree.Query(0, values.Count - 1)); }
public override void Solve(IOManager io) { var n = io.ReadInt(); var queries = io.ReadInt(); var blacks = (long)(n - 2) * (n - 2); var xSegTree = new LazySegmentTree <MinInt, Updater>(Enumerable.Repeat(new MinInt(n), n).ToArray()); var ySegTree = new LazySegmentTree <MinInt, Updater>(Enumerable.Repeat(new MinInt(n), n).ToArray()); for (int q = 0; q < queries; q++) { var xy = io.ReadInt(); var coordinate = io.ReadInt(); if (xy == 1) { var white = xSegTree.Query(coordinate, coordinate + 1).Value; blacks -= white - 2; ySegTree.Update(0, white, new Updater(coordinate)); } else { var white = ySegTree.Query(coordinate, coordinate + 1).Value; blacks -= white - 2; xSegTree.Update(0, white, new Updater(coordinate)); } } io.WriteLine(blacks); }
public void NoEditTest([Values(0, 10)] int n) { var lst = new LazySegmentTree <int, int>(n, new SimpleOracle()); Assert.That(lst.Length, Is.EqualTo(n)); Assert.That(lst.QueryToAll(), Is.EqualTo(-(int)1e9)); }
public static void Solve() { var NQ = Console.ReadLine().Split(" ").Select(int.Parse).ToArray(); var(N, Q) = (NQ[0], NQ[1]); var A = Console.ReadLine().Split(" ").Select(int.Parse) .Select(x => x == 0 ? new S(1, 0, 0) : new S(0, 1, 0)).ToArray(); var lst = new LazySegmentTree <S, F>(A, new Oracle()); for (var i = 0; i < Q; i++) { var TLR = Console.ReadLine().Split(" ").Select(int.Parse).ToArray(); var(T, L, R) = (TLR[0], TLR[1], TLR[2]); L--; if (T == 1) { lst.Apply(L, R, new F(true)); } else { Console.WriteLine(lst.Query(L, R).Inversion); } } }
public void RandomTest() { const int N = 1000, MAX = 10000, T = 1000, Q = 50; var random = new Random(); var values = new List <int>(N); for (int j = 0; j < N; j++) { values.Add(random.Next(MAX)); } // Console.Error.WriteLine(values.Aggregate("", (acc, c) => acc + c.ToString() + ", ")); var tree = LazySegmentTree.Create(values, new MaxOperation()); for (int t = 0; t < T; t++) { // Update a random interval then query. int low = random.Next(N); int high = low + random.Next(N - low); int value = random.Next(MAX); // Console.Error.WriteLine("UPD: t: {0}. low: {1}. high: {2}. value: {3}", t, low, high, value); tree.Update(low, high, value); BruteForceUpdate(values, low, high, value); for (int q = 0; q < Q; q++) { int l = random.Next(N); int h = l + random.Next(N - l); // Console.Error.WriteLine("QRY: t: {0}. q: {1}. l: {2}. h: {3}", t, q, l, h); Assert.AreEqual(BruteForceQuery(values, l, h), tree.Query(l, h)); } } }
public void ArgumentOutOfRangeInSetGetTest([Values(-1, 10)] int i) { var lst = new LazySegmentTree <int, int>(10, new SimpleOracle()); Assert.Throws <ArgumentOutOfRangeException>(() => lst.Set(i, 1)); Assert.Throws <ArgumentOutOfRangeException>(() => lst.Get(i)); }
public override void Solve(IOManager io) { var n = io.ReadInt(); var queries = io.ReadInt(); long total = (long)(n - 2) * (n - 2); var xSegTree = new LazySegmentTree <MinInt, Updater>(Enumerable.Repeat(new MinInt(n), n).ToArray()); var ySegTree = new LazySegmentTree <MinInt, Updater>(Enumerable.Repeat(new MinInt(n), n).ToArray()); for (int q = 0; q < queries; q++) { var kind = io.ReadInt(); var position = io.ReadInt(); if (kind == 1) { var max = xSegTree.Query(position, position + 1).X; total -= max - 2; ySegTree.Update(0, max, new Updater(position)); } else { var max = ySegTree.Query(position, position + 1).X; total -= max - 2; xSegTree.Update(0, max, new Updater(position)); } } io.WriteLine(total); }
public static void Solve() { var(N, Q) = Scanner.Scan <int, int>(); S Operation(S a, S b) => new S(a.X * b.W + b.X, a.W * b.W); var idData = new S(0, 1); var inv9 = ModuloInteger.Inverse(9); S Mapping(int f, S x) => f == 0 ? x : new S((x.W - 1) * inv9 * f, x.W); int Composition(int f, int g) => f == 0 ? g : f; var idInt = 0; var lst = new LazySegmentTree <S, int>(N, Operation, idData, Mapping, Composition, idInt); for (var i = 0; i < N; i++) { lst.Set(i, new S(1, 10)); } for (var i = 0; i < Q; i++) { var(L, R, D) = Scanner.Scan <int, int, int>(); lst.Apply(L - 1, R, D); Console.WriteLine(lst.QueryToAll().X); } }
static void Method(string[] args) { int[] nq = ReadInts(); int n = nq[0]; int q = nq[1]; long mask = 998244353; long[] oneones = new long[n]; long[] ones = new long[n]; oneones[0] = 1; ones[0] = 1; for (int i = 1; i < n; i++) { oneones[i] = (oneones[i - 1] * 10 + 1) % mask; ones[i] = (ones[i - 1] * 10) % mask; } var tree = new LazySegmentTree <long, int>(n, (a, b) => b, (a, b) => { long val = oneones[a.len - 1] * ones[a.dig]; val *= b; val %= mask; return(val); }, (a, b) => (a.val + b.val) % mask, 1, 0); int[][] lrds = new int[q][]; for (int i = 0; i < q; i++) { lrds[i] = ReadInts(); tree.Update(lrds[i][0] - 1, lrds[i][1] - 1, lrds[i][2]); WriteLine(tree.Scan(0, n - 1)); } }
public void NullPredicateInMaxRightMinLeftTest() { var lst = new LazySegmentTree <int, int>(10, new SimpleOracle()); Assert.Throws <ArgumentNullException>(() => _ = lst.MaxRight(10, null)); Assert.Throws <ArgumentNullException>(() => _ = lst.MinLeft(0, null)); }
public override void Solve(IOManager io) { var n = io.ReadInt(); var queries = io.ReadInt(); pow10 = new ModInt[n + 1]; pow10[0] = 1; ones = new ModInt[n + 1]; ones[1] = 1; for (int i = 0; i + 1 < pow10.Length; i++) { pow10[i + 1] = pow10[i] * ModInt.Raw(10); } for (int i = 2; i < ones.Length; i++) { ones[i] = new ModInt((long)ones[i - 1].Value * 10 + 1); } var segtree = new LazySegmentTree <MonoidMod, Updater>(Enumerable.Repeat(new MonoidMod(1), n).ToArray()); for (int q = 0; q < queries; q++) { var l = io.ReadInt() - 1; var r = io.ReadInt(); var d = io.ReadString()[0] - '0'; segtree.Update(l, r, new Updater(d)); io.WriteLine(segtree.Query(0, segtree.Length).Value); } }
public void InvalidArgumentInMaxRightMinLeftTest() { var lst = new LazySegmentTree <int, int>(10, new SimpleOracle()); Assert.Throws <ArgumentException>(() => _ = lst.MaxRight(10, monoid => false)); Assert.Throws <ArgumentException>(() => _ = lst.MinLeft(0, monoid => false)); }
public void ArgumentOutOfRangeInMaxRightMinLeftTest([Values(-1, 11)] int i) { var lst = new LazySegmentTree <int, int>(10, new SimpleOracle()); Assert.Throws <ArgumentOutOfRangeException>(() => _ = lst.MaxRight(i, monoid => true)); Assert.Throws <ArgumentOutOfRangeException>(() => _ = lst.MinLeft(i, monoid => true)); }
public override void Solve(IOManager io) { var n = io.ReadInt(); var queries = io.ReadInt(); var a = new SumModInt[n]; for (int i = 0; i < a.Length; i++) { a[i] = new SumModInt(ModInt.Raw(io.ReadInt()), 1); } var segtree = new LazySegmentTree <SumModInt, AffineActor>(a); for (int q = 0; q < queries; q++) { var kind = io.ReadInt(); var l = io.ReadInt(); var r = io.ReadInt(); if (kind == 0) { var b = ModInt.Raw(io.ReadInt()); var c = ModInt.Raw(io.ReadInt()); segtree.Apply(l..r, new AffineActor(b, c)); } else { io.WriteLine(segtree.Query(l..r).Value); } } }
public void UpdateTest3() { var values = new List <int> { 1, 2, -3, -4, 8, 0 }; var tree = LazySegmentTree.Create(values, new MaxOperation()); Assert.AreEqual(8, tree.Query(0, values.Count - 1)); tree.Update(0, values.Count - 1, 1); // 2 3 -2 -3 9 1 Assert.AreEqual(9, tree.Query(0, values.Count - 1)); tree.Update(1, values.Count - 1, 2); // 2 5 0 -1 11 3 Assert.AreEqual(11, tree.Query(0, values.Count - 1)); tree.Update(2, values.Count - 1, 3); // 2 5 3 -2 14 6 Assert.AreEqual(14, tree.Query(0, values.Count - 1)); tree.Update(3, values.Count - 1, 4); // 2 5 3 2 18 10 Assert.AreEqual(18, tree.Query(0, values.Count - 1)); tree.Update(4, values.Count - 1, 5); // 2 5 3 2 23 15 Assert.AreEqual(23, tree.Query(0, values.Count - 1)); tree.Update(5, values.Count - 1, 10); // 2 5 3 2 23 25 Assert.AreEqual(25, tree.Query(0, values.Count - 1)); }
public override IEnumerable <object> Solve(TextReader inputStream) { var(height, width) = inputStream.ReadValue <int, int>(); var segTree = new LazySegmentTree <IndexAndMinInt, Offset>( Enumerable.Range(0, width).Select(i => new IndexAndMinInt(i, 0)).ToArray()); const int Inf = 1 << 28; for (int row = 0; row < height; row++) { var(a, b) = inputStream.ReadValue <int, int>(); a--; if (a > 0) { var left = segTree.Query(a - 1, a).Value; segTree.Update(a, b, new Offset(a, left + 1)); } else { segTree.Update(a, b, new Offset(a, Inf << 2)); } var min = segTree.Query(0, width).Value; if (min < Inf) { yield return(min + row + 1); } else { yield return(-1); } } }
public void InitializeTest() { Assert.DoesNotThrow(() => _ = new LazySegmentTree <int, int>(0, new SimpleOracle())); Assert.DoesNotThrow(() => _ = new LazySegmentTree <int, int>(10, new SimpleOracle())); Assert.DoesNotThrow(() => _ = new LazySegmentTree <int, int>(Array.Empty <int>(), new SimpleOracle())); Assert.DoesNotThrow(() => _ = new LazySegmentTree <int, int>(new int[10], new SimpleOracle())); Assert.Throws <ArgumentOutOfRangeException>(() => _ = new LazySegmentTree <int, int>(-1, new SimpleOracle())); }
public void QueryTest0() { var values = new List <int> { 1, 2, 3 }; var tree = LazySegmentTree.Create(values, new MaxOperation()); Assert.AreEqual(3, tree.Query(0, values.Count - 1)); }
public void QueryTest2() { var values = new List <int> { 1, 2, -3, -4, 8, 0 }; var tree = LazySegmentTree.Create(values, new MaxOperation()); Assert.Throws(typeof(ArgumentException), () => tree.Query(0, values.Count)); }
public void ArgumentOutOfRangeInApplyTest(int l, int r) { var lst = new LazySegmentTree <int, int>(10, new SimpleOracle()); if (l < 0) { Assert.Throws <ArgumentOutOfRangeException>(() => lst.Apply(l, 1)); } Assert.Throws <ArgumentOutOfRangeException>(() => lst.Apply(l, r, 1)); }
public void EdgeTest() { var lst = new LazySegmentTree <Monoid, Map>(10, new Oracle()); for (var i = 0; i < 10; i++) { lst.Set(i, new Monoid(i, i + 1, -1)); } Assert.That(lst.MaxRight(10, x => true), Is.EqualTo(10)); Assert.That(lst.MinLeft(0, x => true), Is.Zero); }
public void UpdateTest2() { var values = new List <int> { 1, 2, -3, -4, 8, 0 }; var tree = LazySegmentTree.Create(values, new MaxOperation()); Assert.AreEqual(8, tree.Query(0, values.Count - 1)); tree.Update(3, values.Count - 1, -10); Assert.AreEqual(2, tree.Query(0, values.Count - 1)); }
public void QueryNaiveTest([Range(1, 30)] int n) { for (var ph = 0; ph < 10; ph++) { var lst = new LazySegmentTree <Monoid, Map>(n, new Oracle()); var timeManager = new TimeManager(n); for (var i = 0; i < n; i++) { lst.Set(i, new Monoid(i, i + 1, -1)); } var now = 0; for (var q = 0; q < 3000; q++) { var ty = Utilities.RandomInteger(0, 3); var(l, r) = Utilities.RandomPair(0, n); switch (ty) { case 0: { var result = lst.Query(l, r); Assert.That(result.L, Is.EqualTo(l)); Assert.That(result.R, Is.EqualTo(r)); Assert.That(result.Time, Is.EqualTo(timeManager.Query(l, r))); break; } case 1: { var result = lst.Get(l); Assert.That(result.L, Is.EqualTo(l)); Assert.That(result.L + 1, Is.EqualTo(l + 1)); Assert.That(result.Time, Is.EqualTo(timeManager.Query(l, l + 1))); break; } case 2: now++; lst.Apply(l, r, new Map(now)); timeManager.Action(l, r, now); break; case 3: now++; lst.Apply(l, new Map(now)); timeManager.Action(l, l + 1, now); break; default: throw new InvalidOperationException(); } } } }
public void SimpleUsageTest() { var n = 10; var lst = new LazySegmentTree <int, int>(new int[n], new SimpleOracle()); Assert.That(lst.Length, Is.EqualTo(n)); Assert.That(lst.QueryToAll(), Is.Zero); lst.Apply(0, 3, 5); Assert.That(lst.QueryToAll(), Is.EqualTo(5)); lst.Apply(2, -10); Assert.That(lst.Query(2, 3), Is.EqualTo(-5)); Assert.That(lst.Query(2, 4), Is.Zero); }
public static void Solve() { var(W, N) = Scanner.Scan <int, int>(); var lst = new LazySegmentTree <long, long>(W, new Oracle()); for (var i = 0; i < N; i++) { var(l, r) = Scanner.Scan <int, int>(); l--; var answer = lst.Query(l, r) + 1; lst.Apply(l, r, answer); Console.WriteLine(answer); } }
public static void Solve() { var(N, M) = Scanner.Scan <int, int>(); var st = new LazySegmentTree <Monoid, long>(N, new Oracle()); for (var i = 0; i < M; i++) { var(t, l, r) = Scanner.Scan <int, int, int>(); st.Apply(l - 1, r, t); } var answer = st.QueryToAll().Value; Console.WriteLine(answer); }
public override void Solve(IOManager io) { var n = io.ReadInt(); var a = io.ReadIntArray(n); var b = io.ReadIntArray(n); var c = io.ReadIntArray(n); var segtree = new LazySegmentTree <MaxLong, Adder>(n + 1); segtree[0] = new MaxLong(b[0]); for (int i = 0; i < a.Length; i++) { segtree.Apply(0, i + 1, new Adder(a[i])); var max = segtree.Query(0, i + 1); } }
public override IEnumerable <object> Solve(TextReader inputStream) { var(height, width) = inputStream.ReadValue <int, int>(); var nearestStart = new LazySegmentTree <MinInt, Updater>(Enumerable.Range(0, width).Select(i => new MinInt(i)).ToArray()); var minWalk = new LazySegmentTree <MinInt, Updater>(Enumerable.Range(0, width).Select(i => new MinInt(0)).ToArray()); const int Inf = 1 << 28; const int NegInf = -(1 << 28); for (int row = 0; row < height; row++) { var(a, b) = inputStream.ReadValue <int, int>(); a--; if (a > 0) { nearestStart.Update(a, b, new Updater(nearestStart.Query(a - 1, a).Value)); minWalk.Update(a, b, new Updater(Inf)); minWalk.Update(a, a + 1, new Updater(a - nearestStart.Query(a, a + 1).Value)); if (b < width) { minWalk.Update(b, b + 1, new Updater(b - nearestStart.Query(b, b + 1).Value)); } } else { nearestStart.Update(a, b, new Updater(NegInf)); minWalk.Update(a, b, new Updater(Inf)); } var min = minWalk.Query(0, width).Value; if (min < Inf) { yield return(min + row + 1); } else { yield return(-1); } } }
static void Main() { int[] nq = Console.ReadLine().Split().Select(int.Parse).ToArray(); int n = nq[0]; int q = nq[1]; List <int> res = new List <int>(); LazySegmentTree <int, int> ruq = new LazySegmentTree <int, int>(n, int.MaxValue, -1, (x, y) => (y == -1 ? x : y), (x) => (x == -1 ? int.MaxValue : x)); for (int i = 0; i < q; i++) { int[] query = Console.ReadLine().Split().Select(int.Parse).ToArray(); if (query[0] == 0) { ruq.Update(query[1], query[2], query[3]); } else { res.Add(ruq.Query(query[1])); } } Console.WriteLine(string.Join("\n", res)); }