Problem:
Score : 500 points

Problem Statement

We have N camels numbered 1,2,\ldots,N.
Snuke has decided to make them line up in a row.

The happiness of Camel i will be L_i if it is among the K_i frontmost camels, and R_i otherwise.

Snuke wants to maximize the total happiness of the camels. Find the maximum possible total happiness of the camel.

Solve this problem for each of the T test cases given.

Constraints

All values in input are integers.

1 \leq T \leq 10^5

1 \leq N \leq 2 \times 10^{5}

1 \leq K_i \leq N

1 \leq L_i, R_i \leq 10^9

The sum of values of N in each input file is at most 2 \times 10^5.

Input

Input is given from Standard Input in the following format:

T
\mathrm{case}_1
\vdots
\mathrm{case}_T

Each case is given in the following format:

N
K_1 L_1 R_1
\vdots
K_N L_N R_N

Output

Print T lines. The i-th line should contain the answer to the i-th test case.

Sample Input 1

3
2
1 5 10
2 15 5
3
2 93 78
1 71 59
3 57 96
19
19 23 16
5 90 13
12 85 70
19 67 78
12 16 60
18 48 28
5 4 24
12 97 97
4 57 87
19 91 74
18 100 76
7 86 46
9 100 57
3 76 73
6 84 93
1 6 84
11 75 94
19 15 3
12 11 34

Sample Output 1

25
221
1354

In the first test case, it is optimal to line up the camels in the order 2, 1.

Camel 1 is not the frontmost camel, so its happiness will be 10.

Camel 2 is among the two frontmost camels, so its happiness will be 15.

In the second test case, it is optimal to line up the camels in the order 2, 1, 3.

Camel 1 is among the two frontmost camels, so its happiness will be 93.

Camel 2 is the frontmost camel, so its happiness will be 71.

Camel 3 is among the three frontmost camels, so its happiness will be 57.

Solution in C# (Mono-csc 3.5.0) (judge verdict: Wrong Answer)

using System;
using System.Linq;
using System.Collections.Generic;

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      //ABC031.D();
      Aising2020.E();
    }


    class Aising2020
    {
      public static void A()
      {
        var L = Read.Int();
        var R = Read.Int();
        var D = Read.Int();
        Console.WriteLine(R/D - (L-1)/D);
      }
      public static void B()
      {
        var N = Read.Int();
        var A = Read.IntN();
        Console.WriteLine(A.Select((x, i) => x % 2 == 1 && i % 2 == 0 ? 1 : 0).Sum());
      }
      public static void C()
      {
        var N = Read.Int();
        int[] count = new int[2000000];
        for(int x = 1; x <= 100; ++x)
        {
          for(int y = 1; y <= 100; ++y)
          {
            for(int z = 1; z <= 100; ++z)
            {
              var v = x * x + y * y + z * z + x * y + y * z + x * z;
              count[v]++;
            }
          }
        }
        Console.WriteLine(String.Join(Environment.NewLine, count.Skip(1).Take(N)));
      }
      public static void D()
      {
        var N = Read.Int();
        var X = Read.Str();
        var value = new int[N];
        var ans = Enumerable.Range(0, N).Select(i => -1).ToArray();
        int bit = 0;
        for(int i = 0; i < N; ++i) { bit += X[i] == '1' ? 1 : 0; }
        var p1 = bit + 1;
        var p2 = Math.Max(1, bit - 1);
        int a1 = 0, a2 = 0;
        for(int i = 0; i < N; ++i)
        {
          a1 = (a1 * 2 + (X[i] == '1' ? 1 : 0)) % p1;
          a2 = (a2 * 2 + (X[i] == '1' ? 1 : 0)) % p2;
        }
        var pow1 = 1;
        var pow2 = 1;
        for (int i = N - 1; i >= 0; --i)
        {
          if (X[i] == '1')
          {
            if (bit == 1) { ans[i] = 0; }
            else
            {
              var v = (a2 + p2 - (pow2 % p2)) % p2;
              int count = 1;
              while (v > 0)
              {
                var b = BitwiseOperation.Count1((ulong)v);
                v = v % b;
                count++;
              }
              ans[i] = count;
            }
          }
          else
          {
            var v = (a1 + pow1) % p1;
            int count = 1;
            while (v > 0)
            {
              var b = BitwiseOperation.Count1((ulong)v);
              v = v % b;
              count++;
            }
            ans[i] = count;
          }
          pow1 = (pow1 * 2) % p1;
          pow2 = (pow2 * 2) % p2;
        }
        Console.WriteLine(String.Join(Environment.NewLine, ans));
      }
      public static void E()
      {
        var T = Read.Int();
        var ans = new List<long>();
        for(int t = 0; t < T; ++t)
        {
          var N = Read.Int();
          var KLR = Enumerable.Range(0, N).Select(i => Read.LongN()).ToArray();
          //var list = new List<Tuple<bool, int, long>>();
          var listA = new List<Tuple<int, long>>();
          var listB = new List<Tuple<int, long>>();
          long sum = 0;
          foreach(var klr in KLR)
          {
            sum += Math.Min(klr[1], klr[2]);
            var D = klr[1] - klr[2];
            //if (D != 0)
            //{
            //  list.Add(new Tuple<bool, int, long>(D > 0, (int)klr[0] - 1, Math.Abs(D)));
            //}
            if (D > 0)
            {
              listA.Add(new Tuple<int, long>((int)klr[0] - 1, Math.Abs(D)));
            }
            else
            {
              listB.Add(new Tuple<int, long>(N - 1 - (int)klr[0], Math.Abs(D)));
            }
          }
          listA = listA.OrderBy(x => -x.Item2).ToList();
          listB = listB.OrderBy(x => -x.Item2).ToList();
          sum += E_Max(listA, N);
          sum += E_Max(listB, N);
          //int min = 0;
          //int max = listA.Count + 1;
          //while(min < max - 1)
          //{
          //  var mid = (min + max) / 2;
          //  if (E_OK(listA, mid))
          //  {
          //    min = mid;
          //  }
          //  else
          //  {
          //    max = mid;
          //  }
          //}
          //for(int i = 0; i < min; ++i)
          //{
          //  sum += listA[i].Item2;
          //}
          //min = 0;
          //max = listB.Count + 1;
          //while (min < max - 1)
          //{
          //  var mid = (min + max) / 2;
          //  if (E_OK(listB, mid))
          //  {
          //    min = mid;
          //  }
          //  else
          //  {
          //    max = mid;
          //  }
          //}
          //for (int i = 0; i < min; ++i)
          //{
          //  sum += listB[i].Item2;
          //}
          ans.Add(sum);
        }
        Console.WriteLine(String.Join(Environment.NewLine, ans));
      }
      static long E_Max(List<Tuple<int, long>> list, int N)
      {
        long sum = 0;
        var bit = new Util.BIT(N + 10);
        for(int i = 1; i <= N; ++i)
        {
          bit.Add(i, 1);
        }
        for(int i = 0; i < list.Count; ++i)
        {
          var idx = list[i].Item1 + 1;
          if (bit.Sum(idx) == 0) { continue; }
          int min = 1;
          int max = idx + 1;
          var bidx = bit.Sum(idx);
          while (min + 1 < max)
          {
            var mid = (min + max) / 2;
            if (bit.Sum(mid) == bidx)
            {
              max = mid;
            }
            else
            {
              min = mid;
            }
          }
          sum += list[i].Item2;
          //Console.WriteLine(min);
          bit.Add(min+1, -1);
        }
        return sum;
      }
      public static void F()
      {

      }
    }








    class Util
    {
      public static T[,] Gen<T>(int r, int c, T v)
      {
        var matrix = new T[r, c];
        for (int i = 0; i < r; ++i)
        {
          for (int j = 0; j < c; ++j)
          {
            matrix[i, j] = v;
          }
        }
        return matrix;
      }
      public static long[] ASum(long[] array)
      {
        var res = new long[array.Length + 1];
        for (int i = 0; i < array.Length; ++i)
        {
          res[i + 1] = res[i] + array[i];
        }
        return res;
      }
      public static long[,] ASum(long[,] matrix)
      {
        var N = matrix.GetLength(0);
        var M = matrix.GetLength(1);
        var res = new long[N + 1, M + 1];
        for(int i = 0; i < N; ++i)
        {
          for(int j = 0; j < M; ++j)
          {
            res[i + 1, j + 1] = res[i, j + 1] + res[i + 1, j] - res[i, j] + matrix[i, j];
          }
        }
        return res;
      }
      //public static Dictionary<T, long> Frequency<T>(T[] array)
      //{
      //  var dict = new Dictionary<T, long>();
      //  foreach (var a in array)
      //  {
      //    if (!dict.ContainsKey(a)) { dict.Add(a, 0); }
      //    dict[a]++;
      //  }
      //  return dict;
      //}
      public static MyDict<T, long> Frequency2<T>(T[] array)
      {
        var dict = new MyDict<T, long>();
        foreach (var a in array)
        {
          dict[a]++;
        }
        return dict;
      }

      public static long Power(long a, long n, long p)
      {
        long res = 1;
        long mult = a;
        for (int i = 0; i < 63; ++i)
        {
          if ((n & ((long)1 << i)) > 0)
          {
            res = (res * mult) % p;
          }
          mult = (mult * mult) % p;
        }
        return res;
      }
      public static long Inverse(long a, long p)
      {
        long b = p, c = 1, d = 0, e = 0, f = 0;
        while (b != 0)
        {
          e = a / b;
          f = b; b = a - e * b; a = f;
          f = d; d = c - e * d; c = f;
        }
        c %= p;
        return c + (c < 0 ? p : 0);
      }
      public static long[] Facts(int n, long p)
      {
        var facts = new long[n + 1];
        facts[0] = 1;
        for (int i = 1; i <= n; ++i)
        {
          facts[i] = (i * facts[i - 1]) % p;
        }
        return facts;
      }
      public static Func<int, int, long> Combin(int n, long P)
      {
        var fact = Facts(n, P);
        var inv = fact.Select(x => Inverse(x, P)).ToArray();
        return (N, M) =>
        {
          if (N < 0 || N < M || M < 0) { return 0; }
          return (((fact[N] * inv[M]) % P) * inv[N - M]) % P;
        };
      }
      public class BIT
      {
        int N; long[] array;
        public BIT(int m) { for (int n = 1; ; n *= 2) { if (n >= m) { N = n; array = new long[N + 1]; break; } } }
        public void Add(int idx, int v) { for (int x = idx; x <= N; x += x & -x) { array[x] += v; } }
        public long Sum(int idx) { long ret = 0; for (int x = idx; x > 0; x -= x & -x) { ret += array[x]; } return ret; }
      }
      public class BST<T> where T : IComparable
      {
        public class Node
        {
          public T V;
          public Node L, R;
          public int Count;
          public Node(T v) { V = v; Count = 1; }
        }
        static Random _rnd = new Random();
        public static int Count(Node t) { return t == null ? 0 : t.Count; }
        static Node Update(Node t) { t.Count = Count(t.L) + Count(t.R) + 1; return t; }
        public static Node Merge(Node l, Node r)
        {
          if (l == null || r == null) return l == null ? r : l;
          if ((double)Count(l) / (double)(Count(l) + Count(r)) > _rnd.NextDouble())
          { l.R = Merge(l.R, r); return Update(l); }
          else { r.L = Merge(l, r.L); return Update(r); }
        }
        public static Tuple<Node, Node> Split(Node t, int k)
        {
          if (t == null) return new Tuple<Node, Node>(null, null);
          if (k <= Count(t.L))
          {
            var s = Split(t.L, k);
            t.L = s.Item2;
            return new Tuple<Node, Node>(s.Item1, Update(t));
          }
          else
          {
            var s = Split(t.R, k - Count(t.L) - 1);
            t.R = s.Item1;
            return new Tuple<Node, Node>(Update(t), s.Item2);
          }
        }
        public static Node Remove(Node t, T v)
        {
          if (Find(t, v) == null) return t;
          return RemoveAt(t, LowerBound(t, v));
        }
        public static Node RemoveAt(Node t, int k)
        {
          var s = Split(t, k);
          var s2 = Split(s.Item2, 1);
          return Merge(s.Item1, s2.Item2);
        }
        public static bool Contains(Node t, T v) { return Find(t, v) != null; }
        public static Node Find(Node t, T v)
        {
          while (t != null)
          {
            var cmp = t.V.CompareTo(v);
            if (cmp > 0) t = t.L;
            else if (cmp < 0) t = t.R;
            else break;
          }
          return t;
        }

        public static Node FindByIndex(Node t, int idx)
        {
          if (t == null) return null;
          var currentIdx = Count(t) - Count(t.R) - 1;
          while (t != null)
          {
            if (currentIdx == idx) return t;
            if (currentIdx > idx)
            { t = t.L; currentIdx -= (Count(t == null ? null : t.R) + 1); }
            else { t = t.R; currentIdx += (Count(t == null ? null : t.L) + 1); }
          }
          return null;
        }
        public static int UpperBound(Node t, T v)
        {
          var torg = t;
          if (t == null) return -1;

          var ret = Int32.MaxValue;
          var idx = Count(t) - Count(t.R) - 1;
          while (t != null)
          {
            var cmp = t.V.CompareTo(v);

            if (cmp > 0)
            {
              ret = Math.Min(ret, idx);
              t = t.L;
              idx -= (Count(t == null ? null : t.R) + 1);
            }
            else if (cmp <= 0)
            {
              t = t.R;
              idx += (Count(t == null ? null : t.L) + 1);
            }
          }
          return ret == Int32.MaxValue ? Count(torg) : ret;
        }
        public static int LowerBound(Node t, T v)
        {
          var torg = t;
          if (t == null) return -1;

          var idx = Count(t) - Count(t.R) - 1;
          var ret = Int32.MaxValue;
          while (t != null)
          {
            var cmp = t.V.CompareTo(v);
            if (cmp >= 0)
            {
              if (cmp == 0) ret = Math.Min(ret, idx);
              t = t.L;
              if (t == null) ret = Math.Min(ret, idx);
              idx -= t == null ? 0 : (Count(t.R) + 1);
            }
            else if (cmp < 0)
            {
              t = t.R;
              idx += (Count(t == null ? null : t.L) + 1);
              if (t == null) return idx;
            }
          }
          return ret == Int32.MaxValue ? Count(torg) : ret;
        }
        public static Node Insert(Node t, T v)
        {
          var ub = LowerBound(t, v);
          return InsertByIdx(t, ub, v);
        }
        static Node InsertByIdx(Node t, int k, T v)
        {
          var s = Split(t, k);
          return Merge(Merge(s.Item1, new Node(v)), s.Item2);
        }
        public static IEnumerable<T> Enumerate(Node t)
        {
          var ret = new List<T>();
          Enumerate(t, ret);
          return ret;
        }
        static void Enumerate(Node t, List<T> ret)
        {
          if (t == null) return;
          Enumerate(t.L, ret);
          ret.Add(t.V);
          Enumerate(t.R, ret);
        }
      }
      public class Set<T> where T : IComparable
      {
        protected BST<T>.Node _root;
        public T this[int idx] { get { return ElementAt(idx); } }
        public int Count() { return BST<T>.Count(_root); }
        public virtual void Insert(T v)
        {
          if (_root == null) _root = new BST<T>.Node(v);
          else
          {
            if (BST<T>.Find(_root, v) != null) return;
            _root = BST<T>.Insert(_root, v);
          }
        }
        public void Clear() { _root = null; }
        public void Remove(T v) { _root = BST<T>.Remove(_root, v); }
        public bool Contains(T v) { return BST<T>.Contains(_root, v); }
        public T ElementAt(int k)
        {
          var node = BST<T>.FindByIndex(_root, k);
          if (node == null) throw new IndexOutOfRangeException();
          return node.V;
        }
        public int Count(T v) { return BST<T>.UpperBound(_root, v) - BST<T>.LowerBound(_root, v); }
        public int LowerBound(T v) { return BST<T>.LowerBound(_root, v); }
        public int UpperBound(T v) { return BST<T>.UpperBound(_root, v); }
        public Tuple<int, int> EqualRange(T v)
        {
          if (!Contains(v)) return new Tuple<int, int>(-1, -1);
          return new Tuple<int, int>(BST<T>.LowerBound(_root, v), BST<T>.UpperBound(_root, v) - 1);
        }
        public List<T> ToList() { return new List<T>(BST<T>.Enumerate(_root)); }
      }


      public class MyDict<T1, T2> : Dictionary<T1, T2>
      {
        public new T2 this[T1 key]
        {
          get { if (!base.ContainsKey(key)) { base.Add(key, default(T2)); } return base[key]; }
          set { base[key] = value; }
        }
      }
      public class PriorityQueue<T> where T : IComparable
      {
        private IComparer<T> _comparer = null; private bool _isAsc = true; private T[] _heap; private int _sz = 0;
        public PriorityQueue(int maxSize, IComparer<T> comparer) { _heap = new T[maxSize]; _comparer = comparer; }
        public PriorityQueue(int maxSize, bool isAsc = true) { _heap = new T[maxSize]; _isAsc = isAsc; }
        private int Compare(T x, T y) { if (_comparer != null) { return _comparer.Compare(x, y); } return _isAsc ? x.CompareTo(y) : y.CompareTo(x); }
        public void Push(T x) { var i = _sz++; while (i > 0) { var p = (i - 1) / 2; if (Compare(_heap[p], x) <= 0) { break; } _heap[i] = _heap[p]; i = p; } _heap[i] = x; }
        public T Pop() { T ret = _heap[0]; T x = _heap[--_sz]; int i = 0; while (i * 2 + 1 < _sz) { int a = i * 2 + 1; int b = i * 2 + 2; if (b < _sz && Compare(_heap[b], _heap[a]) < 0) { a = b; } if (Compare(_heap[a], x) >= 0) { break; } _heap[i] = _heap[a]; i = a; } _heap[i] = x; return ret; }
        public int Count() { return _sz; }
        public T Peek() { return _heap[0]; }
        public bool Contains(T x) { for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true; return false; }
      }
      public class MyTuple<T1, T2> : IComparable where T1 : IComparable<T1>
      {
        public readonly T1 Item1; public readonly T2 Item2;
        public MyTuple(T1 item1, T2 item2) { Item1 = item1; Item2 = item2; }
        public int CompareTo(object obj) { return Item1.CompareTo(((MyTuple<T1, T2>)obj).Item1); }
      }
      public static long[] Dijkstra(Dictionary<int, Dictionary<int, long>> adj, int N, int M, int start)
      {
        long INF = 1000000000000000000;
        var dist = Enumerable.Range(0, N + 1).Select(i => INF).ToArray();
        var queue = new PriorityQueue<MyTuple<long, int>>(N + M + 100);
        dist[start] = 0;
        queue.Push(new MyTuple<long, int>(0, start));
        while (queue.Count() > 0)
        {
          var kvp = queue.Pop();
          var d = kvp.Item1; var v = kvp.Item2;
          if (dist[v] < d) { continue; }
          foreach (var kvp2 in adj[v])
          {
            var newV = kvp2.Key;
            var newD = dist[v] + kvp2.Value;
            if (newD < dist[newV])
            {
              dist[newV] = newD;
              queue.Push(new MyTuple<long, int>(newD, newV));
            }
          }
        }
        return dist;
      }
    }
    class Graph
    {
      public static HashSet<int> ConnectedComponent(Dictionary<int, HashSet<int>> adj, int idx)
      {
        HashSet<int> comp = new HashSet<int>();
        comp.Add(idx);
        List<int> target = new List<int>();
        target.Add(idx);
        while (target.Count > 0)
        {
          List<int> next = new List<int>();
          foreach (var p in target)
          {
            foreach (var f in adj[p])
            {
              if (!comp.Contains(f))
              {
                next.Add(f);
                comp.Add(f);
              }
            }
          }
          target = next;
        }
        return comp;
      }
      public static int[] CalcDistance_OnTree(Dictionary<int, HashSet<int>> adj, int N, int start)
      {
        var dist = Enumerable.Range(0, N + 1).Select(i => -1).ToArray();
        dist[start] = 0;
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(start);
        while (queue.Count > 0)
        {
          var v = queue.Dequeue();
          foreach (var w in adj[v])
          {
            if (dist[w] < 0)
            {
              dist[w] = dist[v] + 1;
              queue.Enqueue(w);
            }
          }
        }
        return dist;
      }
      public static long[] CalcDistance_OnTree(Dictionary<int, Dictionary<int, long>> adj, int N, int start)
      {
        var dist = Enumerable.Range(0, N + 1).Select(i => -1L).ToArray();
        dist[start] = 0;
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(start);
        while (queue.Count > 0)
        {
          var v = queue.Dequeue();
          foreach (var t in adj[v])
          {
            var w = t.Key;
            var c = t.Value;
            if (dist[w] < 0)
            {
              dist[w] = dist[v] + c;
              queue.Enqueue(w);
            }
          }
        }
        return dist;
      }
    }
    struct MOD
    {
      public static long P = 1000000007;
      public readonly long V;

      public MOD(long a) { this.V = a % P; }
      public static implicit operator MOD(long a) { return new MOD(a); }
      public static MOD operator +(MOD a, MOD b) { return new MOD((a.V + b.V) % P); }
      public static MOD operator -(MOD a, MOD b) { return new MOD((a.V - b.V + P) % P); }
      public static MOD operator *(MOD a, MOD b) { return new MOD((a.V * b.V) % P); }
      public static MOD operator /(MOD a, MOD b) { return new MOD((a.V * b.Inverse().V) % P); }
      public MOD Inverse()
      {
        long a = V, p = P; long b = p, c = 1, d = 0, e = 0, f = 0;
        while (b != 0) { e = a / b; f = b; b = a - e * b; a = f; f = d; d = c - e * d; c = f; }
        c %= p;
        return c + (c < 0 ? p : 0);
      }
      public MOD Power(long n)
      {
        long a = V, p = P; long res = 1; long mult = a;
        for (int i = 0; i < 63; ++i) { if ((n & ((long)1 << i)) > 0) { res = (res * mult) % p; } mult = (mult * mult) % p; }
        return res;
      }
      public override string ToString() { return V.ToString(); }
    }
    class BitwiseOperation
    {
      public static int Count1(UInt64 x)
      {
        UInt64 y = (x & 0x5555555555555555) + ((x >> 1) & 0x5555555555555555);
        y = (y & 0x3333333333333333) + ((y >> 2) & 0x3333333333333333);
        y = (y & 0x0f0f0f0f0f0f0f0f) + ((y >> 4) & 0x0f0f0f0f0f0f0f0f);
        y = (y & 0x00ff00ff00ff00ff) + ((y >> 8) & 0x00ff00ff00ff00ff);
        y = (y & 0x0000ffff0000ffff) + ((y >> 16) & 0x0000ffff0000ffff);
        return (int)((y & 0x00000000ffffffff) + ((y >> 32) & 0x00000000ffffffff));
      }
      public static int MSB(UInt64 x)
      {
        if (x == 0) { return -1; }
        x |= (x >> 1);
        x |= (x >> 2);
        x |= (x >> 4);
        x |= (x >> 8);
        x |= (x >> 16);
        x |= (x >> 32);
        return Count1(x) - 1;
      }
    }

    static class Read
{
static Queue<string> queue = new Queue<string>();
static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
public static ulong[] ULongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToUInt64(s)).ToArray(); }
public static string[] StrN() { return Console.ReadLine().Split(' '); }
public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
public static long[,] LongMatrix(int r, int c) { var mat = new long[r, c]; for (int i = 0; i < r; ++i) { var x = Read.LongN(); for (int j = 0; j < c; ++j) { mat[i, j] = x[j]; } } return mat; }
public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
{
Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); if (!dict[ab[0]].Contains(ab[1])) { dict[ab[0]].Add(ab[1]); } if (!isDirectional && !dict[ab[1]].Contains(ab[0])) { dict[ab[1]].Add(ab[0]); } }
return dict;
}
public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M, bool isDirectional = false)
{
Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>(); for (int i = 0; i <= N; ++i) { dict.Add(i, new Dictionary<int, long>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); dict[ab[0]].Add(ab[1], ab[2]); if (!isDirectional) { dict[ab[1]].Add(ab[0], ab[2]); } }
return dict;
}
}
    }
}