CodeForces - 404C Restore Graph

Valera had an undirected connected graph without self-loops and multiple edges consisting of n vertices. The graph had an interesting property: there were at most k edges adjacent to each of its vertices. For convenience, we will assume that the graph vertices were indexed by integers from 1 to n.

One day Valera counted the shortest distances from one of the graph vertices to all other ones and wrote them out in array d. Thus, element d[i] of the array shows the shortest distance from the vertex Valera chose to vertex number i.

Then something irreparable terrible happened. Valera lost the initial graph. However, he still has the array d. Help him restore the lost graph.

Input

The first line contains two space-separated integers n and k (1 ≤ k < n ≤ 10⁵). Number n shows the number of vertices in the original graph. Number k shows that at most k edges were adjacent to each vertex in the original graph.

The second line contains space-separated integers d[1], d[2], ..., d[n] (0 ≤ d[i] < n). Number d[i] shows the shortest distance from the vertex Valera chose to the vertex number i.

Output

If Valera made a mistake in his notes and the required graph doesn't exist, print in the first line number -1. Otherwise, in the first line print integer m (0 ≤ m ≤ 10⁶) — the number of edges in the found graph.

In each of the next m lines print two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n; a_i ≠ b_i), denoting the edge that connects vertices with numbers a_i and b_i. The graph shouldn't contain self-loops and multiple edges. If there are multiple possible answers, print any of them.

Example

Input

3 2
0 1 1

Output

3
1 2
1 3
3 2

Input

4 2
2 0 1 3

Output

3
1 3
1 4
2 3

Input

3 1
0 0 0

Output

-1

题意：给出n个点每个点最多连k条边，每条边的长度都是1（如果两个点之间有边，那么这两点距离为1），给出以某个点为起点，从起点到所有点的最短距离（相当于以某个点为起点，给出了bfs跑出来的序列)，输出变的条数，和边，如果不存在这样的图输出-1

思路：距离为0的点肯定是起点如果纯在多个0肯定不存在这样的图，直接打印-1，现将所有的距离进行排序，然后反向bfs一遍就能输出原图

#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

struct node
{
    int x;
    int y;
    int w;
};

node p[110000];
vectorv;
int b[110000];

bool cmp(node a, node b)
{
    return a.w < b.w;
}

int bfs(int n, int k)
{
    node a, d;
    queueq;
    memset(b,0,sizeof(b));
    int i = 1, j;
    q.push(p[0]);
    b[p[0].x] = 1;
    while(!q.empty() && i < n)
    {
        a = q.front();
        q.pop();
        if(a.w < p[i].w - 1)
            continue;
        if(i == 1)
        {
            for(j = i; j < i + k && p[j].w == p[i].w; j++)
            {
                d.x = a.x;
                d.y = p[j].x;
                b[p[j].x] = 1;
                v.push_back(d);
                q.push(p[j]);
            }
        }
        else
        {
            for(j = i; j < i + k - 1 && p[j].w == p[i].w; j++)
            {
                d.x = a.x;
                d.y = p[j].x;
                b[p[j].x] = 1;
                v.push_back(d);
                q.push(p[j]);
            }
        }
        i = j;
    }
    for(i = 1; i <= n; i++)
    {
        if(!b[i])
            return 0;
    }
    return 1;
}

int main()
{
    ios::sync_with_stdio(false);
    int n, k, i;
    int mm;
    int flag = 1;
    cin>>n>>k;
    mm = 0;
    for(i = 0; i < n; i++)
    {
        cin>>p[i].w;
        p[i].x = i + 1;
        b[p[i].w]++;
        mm = max(mm,p[i].w);
    }
    sort(p,p+n,cmp);
    if(p[1].w == 0 || p[0].w != 0)
        flag = 0;
    if(flag)
    {
        for(i = 1; i <= mm; i++)
        {
            if(b[i] > pow(k,i))
            {
                flag = 0;
                break;
            }
        }
    }
    if(flag)
    {
        flag = bfs(n,k);
        if(flag)
        {
            n = v.size();
            cout<