Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Problem I:
Live Programming

A famous Japanese idol group, JAG48, is planning the program for its next live performance.
They have $N$ different songs, $song_1$, $song_2$, ..., and $song_N$. Each song has three integer param-
eters, $t_i$, $p_i$, and $f_i$: $t_i$ denotes the length of $song_i$, $p_i$ denotes the basic satisfaction points the
audience will get when $song_i$ is performed, and $f_i$ denotes the feature value of songi that affects
the audience's satisfaction. During the live performance, JAG48 can perform any number (but
at least one) of the $N$ songs, unless the total length of the chosen songs exceeds the length of
the live performance $T$. They can decide the order of the songs to perform, but they cannot
perform the same song twice or more.

The goal of this live performance is to maximize the total satisfaction points that the audience
will get. In addition to the basic satisfaction points of each song, the difference between the
feature values of the two songs that are performed consecutively affects the total satisfaction
points. If there is no difference, the audience will feel comfortable. However, the larger the
difference will be, the more frustrated the audience will be.

Thus, the total satisfaction points will be calculated as follows:

If $song_x$ is the first song of the live performance, the total satisfaction points just after
$song_x$ is equal to $p_x$.

If $song_x$ is the second or subsequent song of the live performance and is performed just
after $song_y$, $p_x -(f_x -f_y)^2$ is added to the total satisfaction points, because the audience
will get frustrated if $f_x$ and $f_y$ are different.

Help JAG48 find a program with the maximum total satisfaction points.

Input

The input is formatted as follows.

$N$ $T$

$t_1$ $p_1$ $f_1$

: : :

$t_N$ $p_N$ $f_N$

The first line contains two integers $N$ and $T$: the number of the available $song_s$ $N$ ($1 \leq N \leq
4,000$), and the length of the live performance $T$ ($1 \leq T \leq 4,000$).

The following $N$ lines represent the parameters of the songs. The $i$-th line of them contains three
integers, which are the parameters of $song_i$: the length $t_i$ ($1 \leq t_i \leq 4,000$), the basic satisfaction
points $p_i$ ($1 \leq p_i \leq 10^8$), and the feature value $f_i$ ($1 \leq f_i \leq 10^4$).

You can assume that there is at least one song whose length is less than or equal to $T$.

Output

Output the maximum total satisfaction points that the audience can get during the live performance.

Sample Input

2 10
10 200 1
10 100 100

Output for the Sample Input

200

Sample Input

3 15
5 100 1
5 100 2
5 100 4

Output for the Sample Input

295

Sample Input

3 10
5 200 200
5 200 201
5 300 1

Output for the Sample Input

399

Sample Input

3 20
5 100 200
5 100 201
5 300 1

Output for the Sample Input

300

Sample Input

5 61
14 49 7
31 46 4
30 55 5
52 99 1
34 70 3

Output for the Sample Input

103

Solution in C# (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
//using System.Numerics;
using Debug = System.Diagnostics.Debug;
using SB = System.Text.StringBuilder;
using Number = System.Int64;
using KV = System.Collections.Generic.KeyValuePair<int, long>;
namespace Program {
    public class Solver {
        public void Solve() {
            var n = ri;
            var T = ri;
            var a = Enumerate(n, x => new int[] { ri, ri, ri });
            var cht = Enumerate(T + 1, x => new Optimization.SimpleCHT());
            for (int i = 0; i <= T; i++)
                cht[i].AddLine(0, 2 * INF);
            var ans = 0L;
            foreach (var x in a.OrderBy(x => x[2])) {
                var dt = x[0];
                var v = x[1];
                var f = x[2];
                for (int t = T - dt; t >= 0; t--) {
                    var u = -cht[t].Get(f) - (f * f) + v;
                    if (u < -INF) u = v;
                    ans = Math.Max(ans, u);
                    cht[t + dt].AddLine(-2 * f, -u + f * f);
                }
            }
            Console.WriteLine(ans);
        }
        const long INF = 1L << 30;

        //int[] dx = { -1, 0, 1, 0 };
        //int[] dy = { 0, 1, 0, -1 };
        int ri { get { return sc.Integer(); } }
        long rl { get { return sc.Long(); } }
        double rd { get { return sc.Double(); } }
        string rs { get { return sc.Scan(); } }
        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

        static T[] Enumerate<T>(int n, Func<int, T> f) {
            var a = new T[n];
            for (int i = 0; i < n; ++i) a[i] = f(i);
            return a;
        }

        static public void Swap<T>(ref T a, ref T b) {
            var tmp = a;
            a = b;
            b = tmp;
        }
    }
}

#region main

static class Ex {
    static public string AsString(this IEnumerable<char> ie) {
        return new string(ie.ToArray());
    }

    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
        return string.Join(st, ie.Select(x => x.ToString()).ToArray());
        //return string.Join(st, ie);
    }

    static public void Main() {
        Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var solver = new Program.Solver();
        solver.Solve();
        Console.Out.Flush();
    }
}

#endregion
#region Ex

namespace Program.IO {
    using System.IO;
    using System.Text;
    using System.Globalization;

    public class Printer: StreamWriter {
        public override IFormatProvider FormatProvider {
            get { return CultureInfo.InvariantCulture; }
        }
        public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
    }

    public class StreamScanner {
        public StreamScanner(Stream stream) {
            str = stream;
        }

        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream {
            get { return isEof; }
        }

        private byte read() {
            if (isEof) return 0;
            if (ptr >= len) {
                ptr = 0;
                if ((len = str.Read(buf, 0, 1024)) <= 0) {
                    isEof = true;
                    return 0;
                }
            }
            return buf[ptr++];
        }

        public char Char() {
            byte b = 0;
            do b = read(); while ((b < 33 || 126 < b) && !isEof);
            return (char)b;
        }

        public string Scan() {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
            return sb.ToString();
        }

        public string ScanLine() {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
            return sb.ToString();
        }

        public long Long() {
            return isEof ? long.MinValue : long.Parse(Scan());
        }

        public int Integer() {
            return isEof ? int.MinValue : int.Parse(Scan());
        }

        public double Double() {
            return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture);
        }
    }
}

#endregion

#region Convex hull trick
namespace Optimization {
    using N = System.Int64;
    struct L {
        internal N a, b;
        /// <summary>
        /// u*x+v
        /// </summary>
        public L(N u, N v) : this() { a = u; b = v; }

        /// <summary>
        /// F(x)=a*x+b
        /// </summary>
        public N F(int x) { return a * x + b; }
    }
    /// <summary>
    /// ?????????????????´?????????????????????????°????min ax+b????±???????
    /// </summary>
    public class SimpleCHT {
        int s, t;
        List<L> deq = new List<L>();
        /// <summary>
        /// ax+b ?????????
        /// a?????????????°???§????????¨??????,?????????O(1)
        /// </summary>
        public void AddLine(N a, N b) {
            var l = new L(a, b);
            while (s + 1 < t && check_fast(deq[t - 2], deq[t - 1], l)) { t--; deq.RemoveAt(t); }
            deq.Add(l);
            t++;
        }
        /// <summary>
        /// x??????????¢?????????¨??????????????£?????????,?????????O(1)
        /// </summary>
        public N Get(int x) {
            while (s + 1 < t && deq[s].F(x) >= deq[s + 1].F(x)) s++;
            return deq[s].F(x);
        }

        /// <summary>
        /// x??????????¢??????§????????¨?????§????????????,O(logN)
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public N Query(int x) {
            var l = s - 1; var h = t - 1;
            while (l + 1 < h) {
                var m = (l + h) / 2;
                if (isR_fast(deq[m], deq[m + 1], x)) l = m;
                else h = m;
            }
            return deq[h].F(x);

        }

        /// <summary>
        /// ax,b????°???????
        /// </summary>
        private bool isR_fast(L l1, L l2, int x) {
            return (l1.b - l2.b) >= x * (l2.a - l1.a);
        }

        /// <summary>
        /// a*b????°???????
        /// </summary>
        private bool check_fast(L l1, L l2, L l3) {
            return (l2.a - l1.a) * (l3.b - l2.b) >= (l2.b - l1.b) * (l3.a - l2.a);
        }
    }
}
#endregion