Problem:
Score : 700 points

Problem Statement

You have an integer sequence of length N: a_1, a_2, ..., a_N.

You repeatedly perform the following operation until the length of the sequence becomes 1:

First, choose an element of the sequence.

If that element is at either end of the sequence, delete the element.

If that element is not at either end of the sequence, replace the element with the sum of the two elements that are adjacent to it. Then, delete those two elements.

You would like to maximize the final element that remains in the sequence.

Find the maximum possible value of the final element, and the way to achieve it.

Constraints

All input values are integers.

2 \leq N \leq 1000

|a_i| \leq 10^9

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

In the first line, print the maximum possible value of the final element in the sequence.

In the second line, print the number of operations that you perform.

In the (2+i)-th line, if the element chosen in the i-th operation is the x-th element from the left in the sequence at that moment, print x.

If there are multiple ways to achieve the maximum value of the final element, any of them may be printed.

Sample Input 1

5
1 4 3 7 5

Sample Output 1

11
3
1
4
2

The sequence would change as follows:

After the first operation: 4, 3, 7, 5

After the second operation: 4, 3, 7

After the third operation: 11(4+7)

Sample Input 2

4
100 100 -1 100

Sample Output 2

200
2
3
1

After the first operation: 100, 200(100+100)

After the second operation: 200

Sample Input 3

6
-1 -2 -3 1 2 3

Sample Output 3

4
3
2
1
2

After the first operation: -4, 1, 2, 3

After the second operation: 1, 2, 3

After the third operation: 4

Sample Input 4

9
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000

Sample Output 4

5000000000
4
2
2
2
2

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

public static class TemplateExtension
{
    public static X[] MakeArray<X>(this int count, Func<int, X> func)
    {
        var xs = new X[count];
        for (var i = 0; i < count; i++)
        {
            xs[i] = func(i);
        }
        return xs;
    }

    public static int[] Range(this int count, int start = 0)
    {
        return count.MakeArray(i => i + start);
    }

    public static string Intercalate<X>(this IEnumerable<X> @this, string separator)
    {
        return string.Join(separator, @this);
    }

    public sealed class ValueIndexPair<T>
        : Tuple<T, int>
    {
        public T Value { get { return Item1; } }
        public int Index { get { return Item2; } }

        public ValueIndexPair(T value, int index)
            : base(value, index)
        {
        }
    }

    public static IEnumerable<ValueIndexPair<X>> Indexed<X>(this IEnumerable<X> @this)
    {
        var i = 0;
        foreach (var x in @this)
        {
            yield return new ValueIndexPair<X>(x, i);
            i++;
        }
    }
}

public sealed class Scanner
{
    private readonly TextReader _reader;
    private readonly StringBuilder _sb = new StringBuilder();

    /// <summary>
    /// Reads next word separated by spaces.
    /// </summary>
    public string Word()
    {
        _sb.Clear();

        while (true)
        {
            var r = _reader.Read();

            if (r == ' ' || r == '\r' || r == '\n')
            {
                if (r == '\r' && _reader.Peek() == '\n')
                {
                    _reader.Read();
                }

                // Ignore leading spaces.
                if (_sb.Length == 0) continue;

                break;
            }
            else if (r == -1)
            {
                break;
            }
            else
            {
                _sb.Append((char)r);
            }
        }

        return _sb.ToString();
    }

    /// <summary>
    /// Reads next word as <see cref="int"/>.
    /// </summary>
    public int N()
    {
        return int.Parse(Word().Trim());
    }

    /// <summary>
    /// Reads next word as <see cref="long"/>.
    /// </summary>
    public long L()
    {
        return long.Parse(Word());
    }

    /// <summary>
    /// Reads next word as <see cref="double"/>.
    /// </summary>
    public double F()
    {
        return double.Parse(Word());
    }

    /// <summary>
    /// Reads next line and splits it by spaces.
    /// </summary>
    public X[] Words<X>(Func<string, X> func)
    {
        return _reader.ReadLine().Split(' ').Select(func).ToArray();
    }

    public Scanner(TextReader reader)
    {
        _reader = reader;
    }
}

public partial class Program
{
    private readonly TextReader _input;
    private readonly TextWriter _output;
    private readonly Scanner _scanner;

    private void WriteLine(int value)
    {
        _output.WriteLine(value);
    }

    private void WriteLine(long value)
    {
        _output.WriteLine(value);
    }

    private void WriteLine(double value)
    {
        _output.WriteLine(value.ToString(CultureInfo.InvariantCulture));
    }

    private void WriteLine(char value)
    {
        _output.WriteLine(value);
    }

    private void WriteLine(string value)
    {
        _output.WriteLine(value);
    }

    public Program(TextReader input, TextWriter output)
    {
        _input = input;
        _output = output;
        _scanner = new Scanner(input);
    }

    public static void Main(string[] args)
    {
        new Program(Console.In, Console.Out).EntryPoint();
    }
}

public class Summary
{
    public int Index;
    public long Sum;
    public bool AllNegative;
    public long Max;
    public int MaxIndex;
    public int Count;
}

public sealed partial class Program
{
    Summary Summarize(long[] A, int index)
    {
        var N = A.Length;

        var s = new Summary()
        {
            Index = index,
            Count = N,
            Sum = 0L,
            Max = A[index],
            MaxIndex = index,
            AllNegative = true
        };

        for (var i = index; i < N; i += 2)
        {
            if (A[i] > 0)
            {
                s.Sum += A[i];
                s.AllNegative = false;
            }

            if (A[i] > s.Max)
            {
                s.Max = A[i];
                s.MaxIndex = i;
            }
        }

        return s;
    }

    List<int> Instr(long[] A, Summary summary)
    {
        var N = A.Length;
        var output = new List<int>();

        if (summary.AllNegative)
        {
            var len = N;

            for (var i = 0; i < summary.MaxIndex; i++)
            {
                output.Add(1);
                len--;
            }

            while (len >= 2)
            {
                output.Add(len);
                len--;
            }

            return output;
        }
        else
        {
            var i = 0;
            var len = N;

            while (i < summary.Index)
            {
                output.Add(1);
                len--;
                i++;
            }

            // 左端にある非負整数を消去する。
            while (i + 1 < N && A[i] <= 0)
            {
                output.Add(1);
                output.Add(1);
                len -= 2;
                i += 2;
            }

            // このとき左端にある値にいくつかを合成したのを結果としたい。
            // 次の数 (i + 2) が正なら合成する。負なら間にあるものをマージして消す。
            // S x T y ...
            // T > 0 なら [2] で (S+T) y ...
            // T <= 0 なら [3] で S (x+y) ...

            while (i < N)
            {
                if (i + 2 < N && A[i + 2] > 0)
                {
                    output.Add(2);
                    len -= 2;
                    i += 2;
                }
                else if (i + 3 < N && A[i + 2] <= 0)
                {
                    output.Add(3);
                    len -= 2;
                    i += 2;
                }
                else
                {
                    break;
                }
            }

            while (len > 1)
            {
                output.Add(2);
                len--;
            }
            return output;
        }
    }

    public void EntryPoint()
    {
        var I = _scanner;
        var N = I.N();
        var A = N.MakeArray(_ => I.L());

        var s1 = Summarize(A, 0);
        var s2 = Summarize(A, 1);

        if (s1.Sum >= s2.Sum)
        {
            var instr = Instr(A, s1);
            WriteLine(s1.Sum);
            WriteLine(instr.Count);
            foreach (var i in instr)
            {
                WriteLine(i);
            }
        }
        else
        {
            var instr = Instr(A, s2);
            WriteLine(s2.Sum);
            WriteLine(instr.Count);
            foreach (var i in instr)
            {
                WriteLine(i);
            }
        }

        return;
    }
}