public void group_inverse_times_element_equals_unit()
{
var a = new Monoid<double>(0.0, (x, y) => x + y);
var g = new Group<double>(a, (x) => -x);
Assert.That(g.Monoid.Op(4.0,g.Inverse(4.0)), Is.EqualTo(g.Monoid.Unit));
}
public void group_inverse_times_element_equals_unit()
{
var a = new Monoid <double>(0.0, (x, y) => x + y);
var g = new Group <double>(a, (x) => - x);
Assert.That(g.Monoid.Op(4.0, g.Inverse(4.0)), Is.EqualTo(g.Monoid.Unit));
}
public Monoid <Id <List <int> > > Concat(Monoid <Id <List <int> > > m)
{
return
(new Sum(new Id <Func <List <int>, Func <List <int>, List <int> > > >(x => y => x.Concat(y))
.Ap(m.Value)
.Ap(Value)));
}
public static bool IsAssociative <MONOID, T>(T x, T y, T z, IEqualityComparer <T> comparer = null)
where MONOID : struct, IMonoid <T>
{
comparer ??= EqualityComparer <T> .Default;
return(comparer.Equals(Monoid.Concat <MONOID, T>(x, Monoid.Concat <MONOID, T>(y, z)),
Monoid.Concat <MONOID, T>(Monoid.Concat <MONOID, T>(x, y), z)));
}
public static bool HasIdentity <MONOID, T>(T x, IEqualityComparer <T> comparer = null)
where MONOID : struct, IMonoid <T>
{
comparer ??= EqualityComparer <T> .Default;
return(comparer.Equals(Monoid.Concat <MONOID, T>(x, Monoid.Empty <MONOID, T>()), x) &&
comparer.Equals(Monoid.Concat <MONOID, T>(Monoid.Empty <MONOID, T>(), x), x));
}
public void Test01()
{
var mInt = from m in Monoid.make <int>()
let combine = Monoid.combine(seq(1, 2, 3, 4, 5), m)
select combine;
claim.equal(15, mInt);
}
public static void LastOrDefaultMonoidTest()
{
var m = Monoid.LastOrDefault(99);
Assert.Equal(99, m.Neutral);
Assert.Equal(5, m.Op(99, 5));
Assert.Equal(99, m.Op(5, 99));
}
public void Test05()
{
var mString = from m in Monoid.make <string>()
let combine = Monoid.combine(seq("1", "2", "3", "4", "5"), m)
select combine;
claim.equal("12345", mString);
}
public static void IntMonoidTest()
{
var intMult = new Monoid <int>(1, (x, y) => x * y);
Assert.Equal(5, intMult.Op(intMult.Neutral, 5));
Assert.Equal(5, intMult.Op(5, intMult.Neutral));
Assert.Equal(15, intMult.Op(3, 5));
}
public static void FoldMapTreeEnum(Tree <int> t)
{
var expected = t.Select(x => x * 2).ToList();
var actual = t.FoldMap(Monoid.ListAppend <int>(), x => new List <int> {
x * 2
});
Assert.Equal(expected, actual);
}
public static void UnsafeTest()
{
var x = new IntWithAddMonoid(5);
var y = new IntWithAddMonoid(7);
Assert.Equal(0, Monoid.NeutralUnsafe <IntWithAddMonoid, IntWithAddMonoid>().Value);
Assert.Equal(12, Monoid.OpUnsafe <IntWithAddMonoid, IntWithAddMonoid>()(x, y).Value);
Assert.Equal(new GenericPerson <Info>("", new Info()), Monoid.NeutralUnsafe <GenericPerson <Info>, PersonMonoid <Info> >());
}
public void CompareToNaiveTest([Range(0, 30)] int n)
{
var y = "";
bool SimpleQuery(Monoid x) => x.Value.Length <= y.Length;
var oracle = new Oracle();
var st = new SegmentTree <Monoid>(n, oracle);
Assert.That(st.Length, Is.EqualTo(n));
var stn = new SegmentTreeNaive <Monoid>(n, oracle);
for (var i = 0; i < n; i++)
{
var s = new Monoid($"a{i}");
st.Set(i, s);
stn.Set(i, s);
}
for (var i = 0; i < n; i++)
{
Assert.That(st.Get(i), Is.EqualTo(stn.Get(i)));
}
for (var l = 0; l <= n; l++)
{
for (var r = l; r <= n; r++)
{
Assert.That(st.Query(l, r), Is.EqualTo(stn.Query(l, r)));
}
}
for (var l = 0; l <= n; l++)
{
for (var r = l; r <= n; r++)
{
y = st.Query(l, r).Value;
Assert.That(st.MaxRight(l, SimpleQuery), Is.EqualTo(stn.MaxRight(l, SimpleQuery)));
Assert.That(st.MaxRight(l, SimpleQuery),
Is.EqualTo(stn.MaxRight(l, x => x.Value.Length <= y.Length)));
}
}
for (var r = 0; r <= n; r++)
{
for (var l = 0; l <= r; l++)
{
y = st.Query(l, r).Value;
Assert.That(st.MinLeft(r, SimpleQuery), Is.EqualTo(stn.MinLeft(r, SimpleQuery)));
Assert.That(st.MinLeft(r, SimpleQuery),
Is.EqualTo(stn.MinLeft(r, x => x.Value.Length <= y.Length)));
}
}
}
// O(V^2)
public AdjacencyMatrix(int v, Monoid <T> monoid, Monoid <T> comparer)
{
this.V = v;
this.Monoid = monoid;
this.Comparer = comparer;
graph = new T[v, v];
for (var i = 0; i < v; i++)
{
for (var j = 0; j < v; j++)
{
graph[i, j] = i == j ? monoid.Unit : comparer.Unit;
}
}
}
public SegmentTree(int length, Monoid <T> monoid)
{
if (length > (int.MaxValue >> 1) + 1)
{
throw new ArgumentException();
}
_size = 1;
while (_size < length)
{
_size <<= 1;
}
_tree = Enumerable.Repeat(monoid.Unit, _size << 1).ToArray();
this.Monoid = monoid;
this.Length = length;
}
public RangeGetSegmentTree(int size, Monoid <T> monoid)
{
Size = size;
Monoid = monoid;
Height = 1;
LeafCount = 1;
while (LeafCount < size)
{
Height++; LeafCount <<= 1;
}
Operators = new T[LeafCount << 1];
for (int i = 0; i < Operators.Length; i++)
{
Operators[i] = monoid.Identity;
}
}
public FenwickTree(IEnumerable <T> collection, Monoid <T> monoid)
{
var count = collection.Count();
_monoid = monoid;
_tree = new T[count + 1];
collection.ForEach((x, i) => { _tree[i + 1] = x; });
for (var i = 1; i < count; i++)
{
var j = i + (i & -i);
if (j < count)
{
_tree[j] = monoid.Append(_tree[j], _tree[i]);
}
}
}
public static void Solve()
{
var n = I;
var m = I;
var p = new long[m];
var a = new double[m];
var b = new double[m];
Repeat(m, i =>
{
p[i] = L - 1;
a[i] = D;
b[i] = D;
});
if (m == 0)
{
Console.WriteLine(1.0);
Console.WriteLine(1.0);
return;
}
var comp = new CoordinateCompressor <long>(p);
var st = SegmentTree.Create(m, Monoid.Create(
Tuple.Create(1.0, 0.0),
(x, y) => Tuple.Create(x.Item1 * y.Item1, x.Item2 * y.Item1 + y.Item2)));
var min = 1.0;
var max = 1.0;
Repeat(m, i =>
{
var cp = comp.Compress[p[i]];
st[cp] = Tuple.Create(a[i], b[i]);
var crt = st[0, m - 1];
var d = crt.Item1 + crt.Item2;
min = Min(min, d);
max = Max(max, d);
});
Console.WriteLine(min);
Console.WriteLine(max);
}
public void OneTest()
{
var oracle = new Oracle();
var identity = oracle.MonoidIdentity;
var st = new SegmentTree <Monoid>(1, oracle);
Assert.That(st.Length, Is.EqualTo(1));
Assert.That(st.QueryToAll(), Is.EqualTo(identity));
Assert.That(st.Get(0), Is.EqualTo(identity));
Assert.That(st.Query(0, 1), Is.EqualTo(identity));
var expected = new Monoid("dummy");
st.Set(0, expected);
Assert.That(st.Get(0), Is.EqualTo(expected));
Assert.That(st.Query(0, 0), Is.EqualTo(identity));
Assert.That(st.Query(0, 1), Is.EqualTo(expected));
Assert.That(st.Query(1, 1), Is.EqualTo(identity));
}
public static void IntLiftInfinityTest()
{
var intPlus = new Monoid <int>(0, (x, y) => x + y);
var intPlusInf = intPlus.LiftMonoidWithInfinity();
Assert.True(intPlusInf.Neutral.HasValue);
Assert.Equal(0, intPlusInf.Neutral.Value());
var r = intPlusInf.Op(Maybe.Just(3), Maybe.Just(8));
Assert.True(r.HasValue);
Assert.Equal(11, r.Value());
r = intPlusInf.Op(Maybe.Nothing <int>(), Maybe.Just(8));
Assert.False(r.HasValue);
r = intPlusInf.Op(Maybe.Just(3), Maybe.Nothing <int>());
Assert.False(r.HasValue);
r = intPlusInf.Op(Maybe.Nothing <int>(), Maybe.Nothing <int>());
Assert.False(r.HasValue);
}
public static void ListAppendMonoidTest()
{
var m = Monoid.ListAppend <int>();
var xs = new List <int> {
};
Assert.Empty(m.Neutral);
Assert.Equal(new int[] { 3, 4 }, m.Op(xs, new List <int> {
3, 4
}));
Assert.Equal(new int[] { 3, 4 }, xs);
xs = new List <int> {
};
Assert.Equal(new int[] { 3, 4 }, m.Op(new List <int> {
3, 4
}, xs));
Assert.Empty(xs);
}
public static void ImmutableListAppendMonoidTest()
{
var m = Monoid.ImmutableListAppend <int>();
var xs = new List <int> {
};
var ys = new List <int> {
1, 2, 3
};
var zs = new List <int> {
4, 1, 2
};
Assert.Empty(m.Neutral);
Assert.Empty(Monoid.NeutralUnsafe <IList <int>, Monoid.ListAppendImmutableMonoid <int> >());
Assert.Equal(new int[] { 1, 2, 3 }, m.Op(xs, ys));
Assert.Equal(new int[] { 1, 2, 3 }, m.Op(ys, xs));
Assert.Equal(new int[] { 1, 2, 3, 4, 1, 2 }, m.Op(ys, zs));
Assert.Empty(xs);
Assert.Equal(new int[] { 1, 2, 3 }, ys);
Assert.Equal(new int[] { 4, 1, 2 }, zs);
}
public SegmentTree(IList <T> collection, Monoid <T> monoid)
{
if (collection.Count > (int.MaxValue >> 1) + 1)
{
throw new ArgumentException();
}
_size = 1;
while (_size < collection.Count)
{
_size <<= 1;
}
_tree = new T[_size << 1];
for (var i = 0; i < _size; i++)
{
_tree[i + _size] = i < collection.Count ? collection[i] : monoid.Unit;
}
for (var i = _size - 1; i > 0; i--)
{
_tree[i] = monoid.Append(_tree[i << 1], _tree[(i << 1) + 1]);
}
this.Monoid = monoid;
this.Length = collection.Count;
}
public static void ImmutableListAppendMonoidTest_String()
{
var m = Monoid.ImmutableListAppend <string>();
var xs = new List <string> {
};
var ys = new List <string> {
"a", "b", "c"
};
var zs = new List <string> {
"d", "a", "b"
};
Assert.Empty(m.Neutral);
Assert.Empty(Monoid.NeutralUnsafe <IList <string>, Monoid.ListAppendImmutableMonoid <string> >());
Assert.Equal(new string[] { "a", "b", "c", "d", "a", "b" }, Monoid.OpUnsafe <IList <string>, Monoid.ListAppendImmutableMonoid <string> >()(ys, zs));
Assert.Equal(new string[] { "a", "b", "c" }, m.Op(xs, ys));
Assert.Equal(new string[] { "a", "b", "c" }, m.Op(ys, xs));
Assert.Equal(new string[] { "a", "b", "c", "d", "a", "b" }, m.Op(ys, zs));
Assert.Empty(xs);
Assert.Equal(new string[] { "a", "b", "c" }, ys);
Assert.Equal(new string[] { "d", "a", "b" }, zs);
}
public Vector(T[] data, Orientation direction, Monoid <T> add, Monoid <T> mult)
{
_data = data;
Direction = direction;
Ring = new SemiRing <T>(add, mult);
}
public static T runTest <T>(IEnumerable <T> list, Monoid <T> m)
{
list.Aggregate(m.MEmpty, (a, b) => m.MAppend(a, b));
}
public FenwickTree(int length, Monoid <T> monoid)
{
_tree = Enumerable.Repeat(monoid.Unit, length + 1).ToArray();
_monoid = monoid;
}
public static T Cond <T>(this Monoid <T> monoid, bool c, T then, T els) => c ? then : els;
public static T When <T>(this Monoid <T> monoid, bool c, T then) => c ? then : monoid.Identity();
public static T Appends <T>(this Monoid <T> monoid, params T[] x) => monoid.Appends((IEnumerable <T>)x);
public static T Appends <T>(this Monoid <T> monoid, IEnumerable <T> x) => x.Aggregate(monoid.Identity(), monoid.BinaryOperation);
public Vector(IEnumerable <T> data, Orientation direction, Monoid <T> add, Monoid <T> mult)
{
_data = data.ToArray();
Direction = direction;
Ring = new SemiRing <T>(add, mult);
}
public Monoid op(Monoid second)
{
return new IAMonoid (elt + ((IAMonoid) second).elt);
}
