Try this:
6 15
6 10 6 9 7 1

I think your answer is:
4
6 10 6 9 7 1

But answer like:
5
6 10 7 9 6 1

5 22
8 15 6 6 14
answer
4
8 15 14 6 6

to get input use this code
*********************************
char[] bytes = new char[256 * 1024];

        BufferedInputStream bufferedInputStream = new BufferedInputStream(System.in);
        InputStreamReader inputStreamReader = new InputStreamReader(bufferedInputStream);
        inputStreamReader.read(bytes);

        String string = new String(bytes);

Thank you! Russian and English statements had different constraints. Now both have 10^7 for input lengths.

That's how the pointer moves:

x = 0; y = 0
x = 1; y = 0
x = 2; y = 0
x = 3; y = 0
x = 3; y = 1
x = 4; y = 1
x = 4; y = 2
x = 4; y = 3
x = 3; y = 3
x = 2; y = 3
x = 1; y = 3
x = 0; y = 3
x = 0; y = 2
x = 0; y = 1
x = 1; y = 1
x = 2; y = 1
x = 3; y = 1
x = 4; y = 1
x = 4; y = 2
x = 4; y = 3
x = 3; y = 3
x = 2; y = 3
x = 1; y = 3
x = 0; y = 3
x = 0; y = 2
x = 0; y = 1
x = 1; y = 1
x = 2; y = 1
x = 3; y = 1
x = 4; y = 1
x = 4; y = 2
x = 4; y = 3
x = 3; y = 3
x = 2; y = 3
x = 1; y = 3
x = 0; y = 3
x = 0; y = 2
x = 0; y = 1
x = 1; y = 1
x = 2; y = 1
x = 3; y = 1
x = 4; y = 1
x = 4; y = 0
x = 5; y = 0
x = 5; y = 1
x = 5; y = 2
x = 5; y = 3

sorry, didn't notice that the letter I is omitted!! ))

use correct alphabet A B C D E F G H K

I don't have permissons to this page.
BTW, there was a bug in checker: std::unique wants sorted array.
It's fixed on Timus.

you just need dp[i][j] and store there form were you get the last piece, if it was from 1 you can rebuild the path looking dp[i-1][j], if it was from 2 you llok dp[i][j-1]. If dp[i][j] = 0 you can't solve the problem.

This is my code. Can someone tell me why do I get WA#4?

import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Scanner;

public class MartianCouncil {

    public static void main(String[] args) {
        Hashtable<Integer, TreeNode> global = new Hashtable<Integer, TreeNode>();
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        if (n == 0) {
            s.close();
            return;
        }
        s.nextLine();
        for (int i = 1; i <= n; i++) {
            TreeNode node = global.get(i);
            if (node == null) {
                node = new TreeNode(i);
                global.put(i, node);
            }
            String line = s.nextLine();
            String[] nums = line.split(" ");
            for (int j = 0; j < nums.length - 1; j++) {
                int num = Integer.parseInt(nums[j]);
                TreeNode nd = global.get(num);
                if (nd == null) {
                    nd = new TreeNode(num);
                    global.put(num, nd);
                }
                node.addChild(nd);
            }
        }
        s.close();
        print(global);
    }

    public static void print(Hashtable<Integer, TreeNode> global) {
        PriorityQueue<TreeNode> q = new PriorityQueue<TreeNode>();
        q.addAll(global.values());
        StringBuilder res = new StringBuilder("");
        while (!q.isEmpty()) {
            TreeNode nd = q.poll();
            res = res.append((res.length() == 0) ? "" : " ");
            res = res.append(nd.getNum());
        }
        System.out.print(res);
    }


    public static class TreeNode implements Comparable<MartianCouncil.TreeNode> {

        private int num = 0;
        private Collection<MartianCouncil.TreeNode> children = new HashSet<MartianCouncil.TreeNode>();
        private Collection<MartianCouncil.TreeNode> parents = new HashSet<MartianCouncil.TreeNode>();

        public TreeNode(int num) {
            this.num = num;
        }

        public int hashCode() {
            return num;
        }

        public boolean equals(Object o) {
            if (o == null) {
                return false;
            } else if (!(o instanceof MartianCouncil.TreeNode)) {
                return false;
            } else {
                return (this.hashCode() == o.hashCode());
            }
        }

        public boolean addChild(MartianCouncil.TreeNode child) {
            child.parents.add(this);
            return children.add(child);
        }

        public boolean removeChild(MartianCouncil.TreeNode child) {
            child.parents.remove(this);
            return children.remove(child);
        }

        public boolean addParent(TreeNode parent) {
            parent.children.add(this);
            return parents.add(parent);
        }

        public boolean removeParent(TreeNode parent) {
            parent.children.remove(this);
            return parents.remove(parent);
        }

        public void removeAllChildren() {
            Iterator<TreeNode> it = children.iterator();
            while (it.hasNext()) {
                TreeNode child = it.next();
                child.parents.remove(this);
            }
            children.clear();
        }

        public int getNum() {
            return num;
        }

        public Collection<TreeNode> getChildren() {
            return children;
        }

        public int getParentsNum() {
            return parents.size();
        }

        @Override
        public int compareTo(MartianCouncil.TreeNode nd) {
            return Math.round(Math.signum(this.getParentsNum() - nd.getParentsNum()));
        }

    }


    public class TreeNodeComp implements Comparator<MartianCouncil.TreeNode> {

        @Override
        public int compare(MartianCouncil.TreeNode nd1, MartianCouncil.TreeNode nd2) {
            return Math.round(Math.signum(nd1.getParentsNum() - nd2.getParentsNum()));
        }

    }

}

Excuse me.. But how could you found out that formula?

Thank you very much!I got AC!

Excuse me, but how sum of (1+2+3+...+n) can be less than (2+4+7+...+n)?

Excuse me, but how I can use your formula?

I have another way to explain this. That's not a correct one, but I got A anyway:
The indexes of the "1" are 1,2,4,7,11,..., which are 1+(0), 1+(1), 1+(1+2), 1+(1+2+3), ... , 1+((k+1)*k/2), ...
Those are "partial sums" of the sequence (1,2,3,4,5,...,k,...)
We have an input index N and we are not sure, if there is some X for which N == 1+((X+1)*X/2).
You'll have to find this X via some arithmetical operations (you can even ignore some numbers in formulas). As if X is an index in the sequence (1,2,3,4,5,...,k,...), you should find out, if it is an Integer number. Too many info, i think.

abcda
5
palindrome? 1 5
palindrome? 1 1
change 4 b
palindrome? 1 5
palindrome? 2 4