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));
}
