bnu A Matrix 北京邀请赛A题

A Matrix

Time Limit: 2000ms

Memory Limit: 65536KB

 

64-bit integer IO format: %lld      Java class name: Main

Prev Submit Status Statistics Discuss Next

Font Size: + -

Chaos King loves permutation and matrix, now he is trying to find out some relations between them.

Now Chaos King has a permutation. He wants to transform the permutation to a matrix by the program beneath.

int f[][];
int p[];
int n;
void insert(int r, int x)
{
    for (int i=1; 1; i++)
        if (f[r][i]==0)
        {
            f[r][i]=x;
            return ;
        }
        else if (f[r][i]>x)
        {
            int tmp=f[r][i];
            f[r][i]=x;
            insert(r+1, tmp);
            return ;
        }
}
void Permutation2Matrix()
{
    for (int i=1; i<=n; i++)
        insert(1, p[i]);
}

initially, all elements in f are 0.

 

Now Chaos King has got a matrix from the program above, then he sends this matrix to you and asks you what is the initial permutation. Can you do it?

Input

First line of the input is an integer T indicating the number of cases,

 

For each test case,

• First line contains 2 integers N (1 ≤ N ≤ 10⁵), M (1 ≤ M ≤ N) indicating length of the permutation and number of rows which do not contains 0 in the matrix.
• Then M lines, the i^th line represent the ith row in the matrix.
  • The first integer in each line is P_i, indicating the number of non-zero elements in this row. Then P_i integers, indicating those elements.

 

It is guaranteed that ∑P_i=N and every element in the matrix is an integer in [1, N]. There are no 2 elements have the same value.

 

Output

For each case, first output the case number as "Case #x: ", and x is the case number.

Then output a permutation of N, indicating the answer of this test case.

 

If there are multiple answers, output the permutation with the largest alphabet order after reversal. (e.g. there are 2 answers: 1 2 3 and 1 3 2. After reversal, 1 2 3 becomes 3 2 1, and 1 3 2 becomes 2 3 1. Because 3 2 1 is larger than 2 3 1 in alphabet order, you should output 1 2 3)

 

If there is no answer, output "No solution".

 

Sample Input

2
3 2
2 1 2
1 3
2 1
2 2 1

 

Sample Output

Case #1: 1 3 2
Case #2: No solution

 

Source

2014 ACM-ICPC Beijing Invitational Programming Contest

 

 

题意：程序根据一个全排列构造出矩阵，告诉你矩阵的信息，求原来可能的全排列，满足反转后字典序最大。

 

思路：根据题意能知道信息，1.同一行的数字必须是从小到大的。同一列也是。

　　　　　　　　　　　　   2.第i行的个数不能小于第i+1行，要满足>=.

                                     如   1 

                                           2 3 这样的情况是不能存在的，因为，因为2要被挤下来，上面必须有一个数字把它挤下来。3同理。

　　　　　　　　　　　　　3.如果按题意来求，把所以的满足条件来求，先找出所以的可能，然后反转排序，求最满足的。10^5个，有多少可能？？

　　　　　　　　　　　　　　这样的方法必须要避免。

       那我们要找到一个好的切入点来做。找出一个合适的序列顺利来求。

       例子  1 2 3 4 5 6

               7                 可能的顺是 7  1 2 3 4 5 6   也可能 1 2 3 4 5 7 6 发现后者是最满足要求的，反转后最大。

                                  是说7出现在6前面，换一句话说，就是7要被6挤下来，而不是1 2 3 4 5当中的一个。

　　　　　　　　　　　　所以，我们可以从最后一行，最后一列开始枚举，分别找到上一行比它小，但最大的那个数字；

　　　　　　　　　　　　（认为就是被该数字挤下来的。）

       例子   1 2 3 4

                5 6 7

                8 9            变成

 

             我们发现1是没有和谁连接的，没有关系，我们想要使反转最大，那么越小的数字出现在前面，越好，贪心的思想。

　　　　　　　　　 那么原来的序列是  1 5 2 8 6 3 9 7 4 ，发现是可以的。就这样。

      但是也有一个例子是无解的。

              1 4

              2 3  因为3 可以连1  但是2不能连4,   4不能把2挤下去。所以2在这里发生问题了。

                     所以还需要判断上一行的数字把下一行挤下去的个数是否与下一行的个数相等。

 

代码：

 #include<iostream>
 #include<stdio.h>
 #include<cstring>
 #include<cstdlib>
 #include<vector>
 using namespace std;
 
 vector<int>Q[];
 vector<int>Hash[];
 int hxl[],len;
 
 void dfs(int x,int y,int dep)
 {
     if(x>dep)return;
     if(Hash[x][y]==-)
     {
         Hash[x][y]=-;
         hxl[++len]=Q[x][y];
         return;
     }
     dfs(x+,Hash[x][y],dep);
     hxl[++len]=Q[x][y];
     Hash[x][y]=-;
 }
 void solve(int n,int m)
 {
     for(int i=m;i>=;i--)
     {
         int k=Hash[i][];
         int s=Hash[i-][];
         for(int j=k;j>=;j--)
         {
             for(;s>=;s--)
             if(Q[i][j]>Q[i-][s]){
                 Hash[i-][s]=j;
                 s--;
                 break;
             }
         }
     }
     for(int i=;i<m;i++)
     {
         int num=;
         for(int j=;j<=Hash[i][];j++)
             if(Hash[i][j]!=-)num++;
         if(num!=Hash[i+][]){
             printf(" No solution\n");
             return;
         }
     }
     len = ;
     for(int i=;i<=m;i++)
     {
         for(int j=;j<=Q[i][];j++)
         {
             if(Hash[i][j]==-)hxl[++len]=Q[i][j];
             else if(Hash[i][j]==-)continue;
             else dfs(i,j,m);
         }
     }
     for(int i=;i<=len;i++)
     printf(" %d",hxl[i]);
     printf("\n");
 }
 int main()
 {
     int T,n,m,x,y;
     scanf("%d",&T);
     for(int t=;t<=T;t++)
     {
         scanf("%d%d",&n,&m);
         for(int i=;i<=n;i++){
             Q[i].clear();
             Hash[i].clear();
         }
         bool flag=false;
         for(int i=;i<=m;i++)
         {
             scanf("%d",&x);
             Q[i].push_back(x);
             Hash[i].push_back(x);
             for(int j=;j<=x;j++)
             {
                 scanf("%d",&y);
                 Q[i].push_back(y);
                 Hash[i].push_back(-);
                 if(j>&&Q[i][j]<=Q[i][j-]) flag=true;
             }
             if(i>&&Q[i][]>Q[i-][])flag=true;
         }
         printf("Case #%d:",t);
         if(flag==true)printf(" No solution\n");
         else{
             solve(n,m);
         }
     }
     return ;
 }