Problem:
Score : 600 points

Problem Statement

Takahashi is playing a board game called Sugoroku.

On the board, there are N + 1 squares numbered 0 to N. Takahashi starts at Square 0, and he has to stop exactly at Square N to win the game.

The game uses a roulette with the M numbers from 1 to M. In each turn, Takahashi spins the roulette. If the number x comes up when he is at Square s, he moves to Square s+x. If this makes him go beyond Square N, he loses the game.

Additionally, some of the squares are Game Over Squares. He also loses the game if he stops at one of those squares. You are given a string S of length N + 1, representing which squares are Game Over Squares. For each i (0 \leq i \leq N), Square i is a Game Over Square if S[i] = 1 and not if S[i] = 0.

Find the sequence of numbers coming up in the roulette in which Takahashi can win the game in the fewest number of turns possible. If there are multiple such sequences, find the lexicographically smallest such sequence. If Takahashi cannot win the game, print -1.

Constraints

1 \leq N \leq 10^5

1 \leq M \leq 10^5

|S| = N + 1

S consists of 0 and 1.

S[0] = 0

S[N] = 0

Input

Input is given from Standard Input in the following format:

N M
S

Output

If Takahashi can win the game, print the lexicographically smallest sequence among the shortest sequences of numbers coming up in the roulette in which Takahashi can win the game, with spaces in between.

If Takahashi cannot win the game, print -1.

Sample Input 1

9 3
0001000100

Sample Output 1

1 3 2 3

If the numbers 1, 3, 2, 3 come up in this order, Takahashi can reach Square 9 via Square 1, 4, and 6. He cannot reach Square 9 in three or fewer turns, and this is the lexicographically smallest sequence in which he reaches Square 9 in four turns.

Sample Input 2

5 4
011110

Sample Output 2

-1

Takahashi cannot reach Square 5.

Sample Input 3

6 6
0101010

Sample Output 3

6

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

//author: camypaper
using System;
using System.Linq;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Debug = System.Diagnostics.Debug;
using SB = System.Text.StringBuilder;
using System.Numerics;
using Point = System.Numerics.Complex;
using static System.Math;
using Number = System.Int64;
using System.Runtime.CompilerServices;

namespace Program {
    public class Solver {
        Random rnd = new Random(0);
        public void Solve() {
            var n = ri;
            var m = ri;
            var s = rs;
            var dp = Enumerate(n + 1, x => INF);
            dp[n] = 0;
            var to = new int[n + 1];
            var set = new Set<long>();
            set.Add(n);
            for (int i = n - 1; i >= 0; i--) {
                if (i + m + 1 <= n && dp[i + m + 1] != INF) {
                    set.Remove(dp[i + m + 1] * 1000000 + i + m + 1);
                }
                if (s[i] == '1') continue;
                if (set.Count == 0) continue;
                dp[i] = 1 + set[0] / 1000000;
                to[i] = (int)(set[0] % 1000000);
                set.Add(dp[i] * 1000000 + i);
            }
            Debug.WriteLine(dp.AsJoinedString());
            if (dp[0] == INF) {
                Console.WriteLine(-1);
                return;
            }
            var ans = new List<int>();
            var p = 0;
            while (p != n) {
                ans.Add(to[p] - p);
                p = to[p];
            }
            Console.WriteLine(ans.AsJoinedString());
        }
        const long INF = 1L << 60;
        int ri => sc.Integer();
        long rl => sc.Long();
        double rd => sc.Double();
        string rs => sc.Scan();
        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

        static IEnumerable<int> Rep(int n) => Enumerable.Range(0, n);
        static IEnumerable<int> RRep(int n) => Enumerable.Range(0, n).Reverse();
        static T[] Enumerate<T>(int n, Func<int, T> f) {
            var a = new T[n];
            for (int i = 0; i < a.Length; ++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);
    }
    static public void Main() {
        Console.SetOut(new Program.IO.Printer(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 => 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;

        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 Set<T>
public class Set<T>
    where T : IComparable<T> {

    Node root = Node.NIL;

    public int Count { get { return root.cnt; } }
    public void Add(T v) { Insert(v, LowerBound(v)); }
    public bool Remove(T v) {
        if (EqualRange(v) == 0) return false;
        RemoveAt(LowerBound(v));
        return true;
    }
    #region Impl
    public void Insert(T v, int k) {
        root = insert(root, v, k);
    }
    public void RemoveAt(int k) {
        root = removeat(root, k);
    }
    public int EqualRange(T v) { return UpperBound(v) - LowerBound(v); }
    public int LowerBound(T v) { return lowerBound(root, v); }
    public int UpperBound(T v) { return upperBound(root, v); }
    public T this[int k] { get { return find(root, k); } }
    Node insert(Node t, T v, int k) {
        Debug.Assert(t.cnt >= k);
        if (t == Node.NIL) return new Node(v);
        if (t.lst.cnt >= k)
            t.lst = insert(t.lst, v, k);
        else
            t.rst = insert(t.rst, v, k - t.lst.cnt - 1);
        t.Update();

        if (t.lst.h - t.rst.h == -2) {
            if (t.rst.lst.h - t.rst.rst.h > 0) t.rst = rotR(t.rst);
            t = rotL(t);
        }
        else if (t.lst.h - t.rst.h == 2) {
            if (t.lst.lst.h - t.lst.rst.h < 0) t.lst = rotL(t.lst);
            t = rotR(t);
        }
        t.Update();
        return t;
    }
    Node removeat(Node t, int k) {
        Debug.Assert(t.cnt > k);
        var cnt = t.lst.cnt;
        if (cnt < k) t.rst = removeat(t.rst, k - cnt - 1);
        else if (cnt > k) t.lst = removeat(t.lst, k);
        else {
            if (cnt == 0) return t.rst;
            if (t.rst.cnt == 0) return t.lst;

            t.val = find(t, k - 1);
            t.lst = removeat(t.lst, k - 1);
        }
        t.Update();
        if (t.lst.h - t.rst.h == -2) {
            if (t.rst.lst.h - t.rst.rst.h > 0) t.rst = rotR(t.rst);
            t = rotL(t);
        }
        else if (t.lst.h - t.rst.h == 2) {
            if (t.lst.lst.h - t.lst.rst.h < 0) t.lst = rotL(t.lst);
            t = rotR(t);
        }
        else t.Update();
        return t;
    }

    int lowerBound(Node t, T v) {
        if (t.cnt == 0) return 0;
        if (v.CompareTo(t.val) <= 0) return lowerBound(t.lst, v);
        else return t.lst.cnt + 1 + lowerBound(t.rst, v);
    }
    int upperBound(Node t, T v) {
        if (t.cnt == 0) return 0;
        if (t.val.CompareTo(v) <= 0) return t.lst.cnt + 1 + upperBound(t.rst, v);
        else return upperBound(t.lst, v);
    }
    T find(Node t, int k) {
        Debug.Assert(k < t.cnt);
        if (k == t.lst.cnt) return t.val;
        else if (k < t.lst.cnt) return find(t.lst, k);
        else return find(t.rst, k - (t.lst.cnt + 1));
    }
    Node rotR(Node t) {
        var l = t.lst;
        var lr = l.rst;
        l.rst = t;
        t.lst = lr;
        t.Update();
        l.Update();
        return l;
    }
    Node rotL(Node t) {
        var r = t.rst;
        var rl = r.lst;
        t.rst = rl;
        r.lst = t;
        t.Update();
        r.Update();
        return r;
    }
    #endregion
    class Node {
        static public readonly Node NIL = new Node();
        public int h;
        public int cnt;
        internal T val;
        internal Node lst, rst;
        private Node() { }
        internal Node(T v) { h = 1; cnt = 1; val = v; lst = NIL; rst = NIL; }
        public void Update() {
            if (cnt == 0) return;
            h = 1 + Math.Max(lst.h, rst.h);
            cnt = 1 + lst.cnt + rst.cnt;
        }
        public override string ToString() {
            return string.Format("count:{0}, value:{1}", cnt, val);
        }
        public T[] Items { get { return items(this); } }
        static public T[] items(Node t) {
            var ret = new T[t.cnt];
            var ptr = 0;
            dfs(t, ref ptr, ret);
            return ret;
        }
        static void dfs(Node t, ref int ptr, T[] ret) {
            if (t == Node.NIL) return;
            dfs(t.lst, ref ptr, ret);
            ret[ptr++] = t.val;
            dfs(t.rst, ref ptr, ret);
        }
    }
    public T[] Items { get { return root.Items; } }
    public override string ToString() { return string.Format("Count = {0}", Count); }

}
#endregion