首页 > 试题广场 >

奶牛排排站

[编程题]奶牛排排站
  • 热度指数：958 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 256M，其他语言512M
  • 算法知识视频讲解
\hspace{15pt}编号为 1 到 N 的 N 头奶牛正在和农夫约翰玩一个疯狂游戏。奶牛们将自己排列成一行，并询问农夫约翰它们的排列编号是多少。此外，农夫约翰也可以给奶牛们一个排列编号，奶牛们必须重新排列成那个对应编号的排列。

\hspace{15pt}一个排列的编号指的是，考虑这个排列的全部可能排列，这个排列在全部可能排列中的字典序排名。 

\hspace{15pt}农夫约翰和奶牛们希望你能帮助他们玩这个游戏。他们有 K 个查询需要帮助。查询 i 有两个部分：C_i 是命令，可以是 `P` 或 `Q` 。

\hspace{15pt}如果 C_i 是 `P` ，那么查询的第二部分将是一个整数 A_i，这是一个排列编号。这是农夫约翰挑战奶牛们排成正确的奶牛排列。

\hspace{15pt}如果 C_i 是 `Q`，那么查询的第二部分将是 N 个不同的整数 B_{i,j}。这将表示一个奶牛排列。这是奶牛们挑战农夫约翰找出它们的排列编号。

输入描述:
\hspace{15pt}输入的第 1 行两个用空格分隔的整数 N,K \left( 1 \leqq N \leqq 20, 1 \leqq K \leqq 10^4\right)，分别表示奶牛的数量和询问的数量。
\hspace{15pt}接下来 2 \cdot K 行，每两行共同构成一次询问。每次询问的第一行有一个字符 op \left( op \in \{P,Q\} \right) 代表询问类型，随后：
\hspace{22.5pt}\bullet\若 op= \texttt{`P'} ，在下一行输入一个整数 A_i\left(1 \leqq A_i \leqq N ! \right)，表示奶牛需要排列成的顺序的编号；
\hspace{22.5pt}\bullet\若 op=\texttt{`Q'} ，在下一行输入一行 N 个用空格分隔的整数 B_{i,j} \left(1 \leqq B_{i,j} \leqq N \right)，表示此时奶牛的排列顺序。


输出描述:
\hspace{15pt}输出包含 K 行，依次分别为各个询问的结果：
\hspace{22.5pt}\bullet\对于 \texttt{`P'} 操作，输出一行 N 个用空格分隔的整数，表示对应编号的奶牛排列顺序。
\hspace{22.5pt}\bullet\对于 \texttt{`Q'} 操作，输出一行一个整数，表示对应奶牛排列顺序的排序编号。
示例1

输入

5 2
P
3
Q
1 2 5 3 4

输出

1 2 4 3 5
5

说明

农夫约翰有 5 头奶牛，并希望它们按照排列编号 3 来进行排列。

按升序字典序排列的排列：

第 1 个：1,2,3,4,5

第 2 个：1,2,3,5,4

第 3 个：1,2,4,3,5

因此，奶牛们将自己排列成奶牛排列 1,2,4,3,5。

假如奶牛们反过来排列成配置「1,2,5,3,4」，并询问农夫约翰它们此时的排列编号是多少。此时我们可以继续列表：

第 4 个：1,2,4,5,3

第 5 个：1,2,5,3,4

此时第 5 个编号对应的排列与奶牛的排列一一对应上了，所有农夫约翰可以看到答案是 5 。
算法知识视频讲解
添加回答
C++
SDU_23_高士轩头像 SDU_23_高士轩
喵呜~是康托展开板子题喵~ 
#define 喵 ;
#define 呜 (
#define 喵喵 )
#define 呜喵 [
#define 喵呜 ]
#define 呜呜 .
#define 喵喵喵 nd
#define 呜喵喵 ,
#define 喵呜喵 n
#define 呜呜喵 =
#define 喵喵呜 int
#define 呜喵呜 i
#define 喵呜呜 {
#define 呜呜呜 }
#define 喵喵喵喵 R
#define 呜喵喵喵 L
#define 喵呜喵喵 val
#define 呜呜喵喵 0
#define 喵喵呜喵 rs
#define 呜喵呜喵 ls
#define 喵呜呜喵 siz
#define 呜呜呜喵 <
#define 喵喵喵呜 1
#define 呜喵喵呜 a
#define 喵呜喵呜 r
#define 呜呜喵呜 +
#define 喵喵呜呜 j
#define 呜喵呜呜 long
#define 喵呜呜呜 if
#define 呜呜呜呜 &
#define 喵喵喵喵喵 fac
#define 呜喵喵喵喵 :
#define 喵呜喵喵喵 h
#define 呜呜喵喵喵 ++
#define 喵喵呜喵喵 ?
#define 呜喵呜喵喵 else
#define 喵呜呜喵喵 merge
#define 呜呜呜喵喵 return
#define 喵喵喵呜喵 vector
#define 呜喵喵呜喵 -
#define 喵呜喵呜喵 >
#define 呜呜喵呜喵 for
#define 喵喵呜呜喵 k
#define 呜喵呜呜喵 root
#define 喵呜呜呜喵 -1
#define 呜呜呜呜喵 M
#define 喵喵喵喵呜 unsigned
#define 呜喵喵喵呜 !
#define 喵呜喵喵呜 c
#define 呜呜喵喵呜 split_less
#define 喵喵呜喵呜 tot
#define 呜喵呜喵呜 unused
#define 喵呜呜喵呜 void
#define 呜呜呜喵呜 while
#define 喵喵喵呜呜 <=
#define 呜喵喵呜呜 bt
#define 喵呜喵呜呜 cc
#define 呜呜喵呜呜 cnt
#define 喵喵呜呜呜 node
#define 呜喵呜呜呜 split_less_eq
#define 喵呜呜呜呜 sum
#define 呜呜呜呜呜 *
#define 喵喵喵喵喵喵 +=
#define 呜喵喵喵喵喵 --
#define 喵呜喵喵喵喵 balanced_tree
#define 呜呜喵喵喵喵 p
#define 喵喵呜喵喵喵 ret
#define 呜喵呜喵喵喵 scanf
#define 喵呜呜喵喵喵 !=
#define 呜呜呜喵喵喵 &&
#define 喵喵喵呜喵喵 'P'
#define 呜喵喵呜喵喵 -=
#define 喵呜喵呜喵喵 ==
#define 呜呜喵呜喵喵 >&
#define 喵喵呜呜喵喵 cantor
#define 呜喵呜呜喵喵 del
#define 喵呜呜呜喵喵 getchar
#define 呜呜呜呜喵喵 insert
#define 喵喵喵喵呜喵 inv_cantor
#define 呜喵喵喵呜喵 printf
#define 喵呜喵喵呜喵 push_back
#define 呜呜喵喵呜喵 rank_num
#define 喵喵呜喵呜喵 struct
#define 呜喵呜喵呜喵 ||
#define 喵呜呜喵呜喵 "%d "
#define 呜呜呜喵呜喵 "%d"
#define 喵喵喵呜呜喵 "%d%d"
#define 呜喵喵呜呜喵 "%lld\n"
#define 喵呜喵呜呜喵 "%llu"
#define 呜呜喵呜呜喵 %=
#define 喵喵呜呜呜喵 'Q'
#define 呜喵呜呜呜喵 '\n'
#define 喵呜呜呜呜喵 /
#define 呜呜呜呜呜喵 2
#define 喵喵喵喵喵呜 =++
#define 呜喵喵喵喵呜 >=
#define 喵呜喵喵喵呜 char
#define 呜呜喵喵喵呜 const
#define 喵喵呜喵喵呜 empty
#define 呜喵呜喵喵呜 main
#define 喵呜呜喵喵呜 namespace
#define 呜呜呜喵喵呜 pop
#define 喵喵喵呜喵呜 push
#define 呜喵喵呜喵呜 putchar
#define 喵呜喵呜喵呜 rand
#define 呜呜喵呜喵呜 stack
#define 喵喵呜呜喵呜 std
#define 呜喵呜呜喵呜 top
#define 喵呜呜呜喵呜 using
#include <bits/stdc++.h>
喵呜呜呜喵呜 喵呜呜喵喵呜 喵喵呜呜喵呜 喵
喵喵喵喵呜 呜喵呜呜 呜喵呜呜 喵喵呜呜喵喵 呜 呜呜喵喵喵呜 喵喵喵呜喵 呜呜呜喵 喵喵呜 呜呜喵呜喵喵 呜喵喵呜 呜喵喵 喵喵呜 喵呜喵 喵喵 喵呜呜
    喵喵喵呜喵 呜呜呜喵 喵喵喵喵呜 呜喵呜呜 呜喵呜呜 喵呜喵呜喵 喵呜喵喵 呜 喵呜喵 呜呜喵呜 喵喵喵呜 呜喵喵 呜呜喵喵 喵喵 呜喵喵 喵喵喵喵喵 呜 喵呜喵 呜呜喵呜 喵喵喵呜 呜喵喵 呜呜喵喵 喵喵 喵
    喵喵喵喵喵 呜喵 呜呜喵喵 喵呜 呜呜喵 喵喵喵呜 喵
    喵喵喵喵呜 呜喵呜呜 呜喵呜呜 喵喵呜喵喵喵 呜呜喵 喵喵喵呜 喵
    呜呜喵呜喵 呜 喵喵呜 呜喵呜 呜呜喵 喵喵喵呜 喵 呜喵呜 喵喵喵呜呜 喵呜喵 喵 呜喵呜 呜呜喵喵喵 喵喵 喵喵喵喵喵 呜喵 呜喵呜 喵呜 呜呜喵 喵喵喵喵喵 呜喵 呜喵呜 喵呜呜呜喵 喵呜 呜呜呜呜呜 呜喵呜 喵
    呜呜喵呜喵 呜 喵喵呜 呜喵呜 呜呜喵 呜呜喵喵 喵 呜喵呜 呜呜呜喵 喵呜喵 喵 呜喵呜 呜呜喵喵喵 喵喵 喵呜呜
        喵喵呜 喵呜呜呜呜 呜呜喵 呜喵喵呜 呜喵 呜喵呜 喵呜 喵呜呜呜喵 呜喵喵 喵喵呜呜 呜呜喵 喵呜呜呜呜 喵
        呜呜呜喵呜 呜 喵喵呜呜 喵喵
            喵呜呜 喵呜呜呜呜 呜喵喵呜喵喵 喵呜喵喵 呜喵 喵喵呜呜 喵呜 喵 喵喵呜呜 呜喵喵呜喵喵 喵喵呜呜 呜呜呜呜 呜 呜喵喵呜喵 喵喵呜呜 喵喵 喵 呜呜呜
        喵喵呜喵喵喵 喵喵喵喵喵喵 喵呜呜呜呜 呜呜呜呜呜 喵喵喵喵喵 呜喵 喵呜喵 呜喵喵呜喵 呜喵呜 喵呜呜呜喵 喵呜 喵
        喵喵呜呜 呜呜喵 呜喵喵呜 呜喵 呜喵呜 喵呜 喵
        呜呜呜喵呜 呜 喵喵呜呜 喵喵喵呜呜 喵呜喵 喵喵
            喵呜呜 喵呜喵喵 呜喵 喵喵呜呜 喵呜 呜呜喵喵喵 喵 喵喵呜呜 喵喵喵喵喵喵 喵喵呜呜 呜呜呜呜 呜 呜喵喵呜喵 喵喵呜呜 喵喵 喵 呜呜呜
    呜呜呜
    呜呜呜喵喵 喵喵呜喵喵喵 喵
呜呜呜
喵喵呜喵呜喵 喵呜喵喵喵喵 喵呜呜
    喵喵呜 呜喵呜呜喵 呜喵喵 喵喵呜喵呜 喵
    呜呜喵呜喵呜 呜呜呜喵 喵喵呜 喵呜喵呜喵 呜喵呜喵呜 喵
    喵喵呜喵呜喵 喵喵呜呜呜 喵呜呜
        喵喵呜 喵呜喵喵 呜喵喵 喵呜呜喵 呜喵喵 喵呜喵呜呜 呜喵喵 呜喵呜喵 呜喵喵 喵喵呜喵 喵
    呜呜呜 喵
    喵喵喵呜喵 呜呜呜喵 喵喵呜呜呜 喵呜喵呜喵 喵喵喵 喵
    喵呜喵喵喵喵 呜 喵喵 呜喵喵喵喵 呜喵呜呜喵 呜 呜呜喵喵 喵喵 呜喵喵 喵喵呜喵呜 呜 呜呜喵喵 喵喵
        喵呜呜 喵喵喵 呜呜 喵呜喵喵呜喵 呜 喵喵呜呜呜 呜 喵喵 喵喵 喵 呜呜呜
    喵呜呜喵呜 呜呜喵喵呜 呜 喵喵呜 喵呜喵 呜喵喵 喵喵呜 喵呜喵喵 呜喵喵 喵喵呜 呜呜呜呜 呜喵喵喵 呜喵喵 喵喵呜 呜呜呜呜 喵喵喵喵 喵喵 喵呜呜
        喵呜呜呜 呜 呜喵喵喵呜 喵呜喵 喵喵 喵呜呜 呜喵喵喵 呜呜喵 喵喵喵喵 呜呜喵 呜呜喵喵 喵 呜呜呜喵喵 喵 呜呜呜
        喵呜呜呜 呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵呜喵喵 呜呜呜喵 喵呜喵喵 喵喵 喵呜呜
            呜喵喵喵 呜呜喵 喵呜喵 喵
            呜呜喵喵呜 呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 呜喵喵 喵呜喵喵 呜喵喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 呜喵喵 喵喵喵喵 喵喵 喵
        呜呜呜
        呜喵呜喵喵 喵呜呜
            喵喵喵喵 呜呜喵 喵呜喵 喵
            呜呜喵喵呜 呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 呜喵喵 喵呜喵喵 呜喵喵 呜喵喵喵 呜喵喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 喵喵 喵
        呜呜呜
        喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵呜呜喵 呜呜喵 喵喵喵呜 呜呜喵呜
            呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 呜呜喵呜
            呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 喵
    呜呜呜
    喵呜呜喵呜 呜喵呜呜呜 呜 喵喵呜 喵呜喵 呜喵喵 喵喵呜 喵呜喵喵 呜喵喵 喵喵呜 呜呜呜呜 呜喵喵喵 呜喵喵 喵喵呜 呜呜呜呜 喵喵喵喵 喵喵 喵呜呜
        喵呜呜呜 呜 呜喵喵喵呜 喵呜喵 喵喵
            喵呜呜 呜喵喵喵 呜呜喵 喵喵喵喵 呜呜喵 呜呜喵喵 喵 呜呜呜喵喵 喵 呜呜呜
        喵呜呜呜 呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵呜喵喵 喵喵喵呜呜 喵呜喵喵 喵喵 喵呜呜
            呜喵喵喵 呜呜喵 喵呜喵 喵
            呜喵呜呜呜 呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 呜喵喵 喵呜喵喵 呜喵喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 呜喵喵 喵喵喵喵 喵喵 喵
        呜呜呜
        呜喵呜喵喵 喵呜呜
            喵喵喵喵 呜呜喵 喵呜喵 喵
            呜喵呜呜呜 呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 呜喵喵 喵呜喵喵 呜喵喵 呜喵喵喵 呜喵喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 喵喵 喵
        呜呜呜
        喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵呜呜喵 呜呜喵 喵喵喵呜 呜呜喵呜
            呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 呜喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 呜呜喵呜
            呜 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 喵呜喵 喵呜 呜呜 喵喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 喵
    呜呜呜
    喵喵呜 喵呜呜喵喵 呜 喵喵呜 呜喵喵喵 呜喵喵 喵喵呜 喵喵喵喵 喵喵 喵呜呜
        喵呜呜呜 呜 呜喵喵喵呜 呜 呜喵喵喵 呜呜呜喵喵喵 喵喵喵喵 喵喵 喵喵 呜呜呜喵喵 呜喵喵喵 呜呜喵呜 喵喵喵喵 喵
        喵呜呜呜 呜 喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 喵呜喵呜呜 呜呜呜喵 喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 喵呜喵呜呜 喵喵 喵呜呜
            喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 喵喵呜喵 呜呜喵 喵呜呜喵喵 呜 喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 喵喵呜喵 呜喵喵 喵喵喵喵 喵喵 喵
            喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 喵呜呜喵 呜呜喵 喵喵喵呜 呜呜喵呜
                呜 喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 呜喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 呜喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 呜呜喵呜
                呜 喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 喵喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 呜喵喵喵 喵呜 呜呜 喵喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 喵
            呜呜呜喵喵 呜喵喵喵 喵
        呜呜呜
        呜喵呜喵喵 喵呜呜
            喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 呜喵呜喵 呜呜喵 喵呜呜喵喵 呜 呜喵喵喵 呜喵喵 喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 呜喵呜喵 喵喵 喵
            喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 喵呜呜喵 呜呜喵 喵喵喵呜 呜呜喵呜
                呜 喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 呜喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 呜喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 呜呜喵呜
                呜 喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 喵喵呜喵 喵喵呜喵喵 喵喵喵 呜喵 喵喵喵 呜喵 喵喵喵喵 喵呜 呜呜 喵喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵 呜呜喵喵 喵喵 喵
            呜呜呜喵喵 喵喵喵喵 喵
        呜呜呜
    呜呜呜
    喵呜呜喵呜 呜呜呜呜喵喵 呜 喵喵呜 喵呜喵喵 喵喵 喵呜呜
        喵喵呜 喵呜喵喵喵 喵
        喵呜呜呜 呜 呜喵呜喵呜 呜呜 喵喵呜喵喵呜 呜 喵喵 喵喵 喵呜呜
            喵呜喵喵喵 喵喵喵喵喵呜 喵喵呜喵呜 喵
            喵喵喵 呜呜 喵呜喵喵呜喵 呜 喵喵呜呜呜 呜 喵喵 喵喵 喵
        呜呜呜
        呜喵呜喵喵 喵呜呜
            喵呜喵喵喵 呜呜喵 呜喵呜喵呜 呜呜 呜喵呜呜喵呜 呜 喵喵 喵
            呜喵呜喵呜 呜呜 呜呜呜喵喵呜 呜 喵喵 喵
        呜呜呜
        喵喵喵 呜喵 喵呜喵喵喵 喵呜 呜呜 呜喵呜喵 呜呜喵 喵喵喵 呜喵 喵呜喵喵喵 喵呜 呜呜 喵喵呜喵 呜呜喵 呜呜喵喵 喵
        喵喵喵 呜喵 喵呜喵喵喵 喵呜 呜呜 喵呜呜喵 呜呜喵 喵喵喵呜 喵
        喵喵喵 呜喵 喵呜喵喵喵 喵呜 呜呜 喵呜喵喵 呜呜喵 喵呜喵喵 喵
        喵喵喵 呜喵 喵呜喵喵喵 喵呜 呜呜 喵呜喵呜呜 呜呜喵 喵呜喵呜喵呜 呜 喵喵 喵
        喵喵呜 呜喵喵喵 呜喵喵 喵喵喵喵 喵
        呜呜喵喵呜 呜 呜喵呜呜喵 呜喵喵 喵呜喵喵 呜喵喵 呜喵喵喵 呜喵喵 喵喵喵喵 喵喵 喵
        呜喵呜呜喵 呜呜喵 喵呜呜喵喵 呜 喵呜呜喵喵 呜 呜喵喵喵 呜喵喵 喵呜喵喵喵 喵喵 呜喵喵 喵喵喵喵 喵喵 喵
    呜呜呜
    喵呜呜喵呜 呜喵呜呜喵喵 呜 喵喵呜 喵呜喵喵 喵喵 喵呜呜
        喵喵呜 呜喵喵喵 呜喵喵 呜呜呜呜喵 呜喵喵 喵喵喵喵 喵
        呜呜喵喵呜 呜 呜喵呜呜喵 呜喵喵 喵呜喵喵 呜喵喵 呜喵喵喵 呜喵喵 喵喵喵喵 喵喵 喵
        呜喵呜呜呜 呜 喵喵喵喵 呜喵喵 喵呜喵喵 呜喵喵 呜呜呜呜喵 呜喵喵 喵喵喵喵 喵喵 喵
        喵呜呜呜 呜 呜呜呜呜喵 喵呜喵呜喵喵 喵喵呜喵呜 喵喵 喵喵呜喵呜 呜喵喵喵喵喵 喵
        呜喵呜喵喵 呜喵呜喵呜 呜呜 喵喵喵呜喵呜 呜 呜呜呜呜喵 喵喵 喵
        呜喵呜呜喵 呜呜喵 喵呜呜喵喵 呜 喵呜呜喵喵 呜 呜喵喵喵 呜喵喵 喵呜呜喵喵 呜 喵喵喵 呜喵 呜呜呜呜喵 喵呜 呜呜 呜喵呜喵 呜喵喵 喵喵喵 呜喵 呜呜呜呜喵 喵呜 呜呜 喵喵呜喵 喵喵 喵喵 呜喵喵 喵喵喵喵 喵喵 喵
    呜呜呜
    喵喵呜 呜呜喵喵呜喵 呜 喵喵呜 呜呜喵呜呜 喵喵 喵呜呜
        喵喵呜 喵呜喵呜 呜呜喵 呜喵呜呜喵 喵
        呜呜呜喵呜 呜 喵喵喵呜 喵喵 喵呜呜
            喵呜呜呜 呜 呜 呜喵喵喵呜 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 喵喵呜喵 喵喵 呜喵呜喵呜喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 喵呜呜喵 呜喵喵呜喵 喵喵喵 呜喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 喵喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵喵喵呜 呜呜喵呜呜 喵喵 喵呜呜
                喵呜呜呜 呜 呜 呜喵喵喵呜 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 呜喵呜喵 喵喵 呜喵呜喵呜喵 喵喵喵 呜喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 呜喵呜喵 喵呜 呜呜 喵呜呜喵 呜呜呜喵 呜呜喵呜呜 喵喵
                    呜呜呜喵喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 喵呜喵喵 喵
                呜喵呜喵喵 喵呜喵呜 呜呜喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 呜喵呜喵 喵
            呜呜呜
            呜喵呜喵喵 喵呜呜
                呜呜喵呜呜 喵喵喵喵喵喵 喵喵喵 呜喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 喵喵呜喵 喵呜 呜呜 喵呜呜喵 呜喵喵呜喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 喵呜呜喵 喵
                喵呜喵呜 呜呜喵 喵喵喵 呜喵 喵呜喵呜 喵呜 呜呜 喵喵呜喵 喵
            呜呜呜
        呜呜呜
    呜呜呜
呜呜呜 喵
喵呜呜喵呜 喵喵喵喵呜喵 呜 喵喵喵呜喵 呜呜呜喵 喵喵呜 呜呜喵呜喵喵 呜喵喵呜 呜喵喵 喵喵呜 喵呜喵 呜喵喵 喵喵喵喵呜 呜喵呜呜 呜喵呜呜 喵喵呜呜喵 喵喵 喵呜呜
    喵喵喵呜喵 呜呜呜喵 喵喵喵喵呜 呜喵呜呜 呜喵呜呜 喵呜喵呜喵 喵喵喵喵喵 呜 喵呜喵 呜喵喵 喵喵喵呜 喵喵 喵
    呜喵喵呜 呜呜喵 喵喵喵呜喵 呜呜呜喵 喵喵呜 喵呜喵呜喵 呜 喵呜喵 喵喵 喵 喵喵呜呜喵 呜喵喵喵喵喵 喵
    呜呜喵呜喵 呜 喵喵呜 呜喵呜 呜呜喵 呜呜呜呜呜喵 喵 呜喵呜 呜呜呜喵 喵呜喵 喵 呜喵呜 呜呜喵喵喵 喵喵
        喵喵喵喵喵 呜喵 呜喵呜 喵呜 呜呜喵 喵喵喵喵喵 呜喵 呜喵呜 喵呜呜呜喵 喵呜 呜呜呜呜呜 呜喵呜 喵
    喵呜喵喵喵喵 呜喵喵呜呜 喵
    呜呜喵呜喵 呜 喵喵呜 呜喵呜 呜呜喵 喵喵喵呜 喵 呜喵呜 喵喵喵呜呜 喵呜喵 喵 呜喵呜 呜呜喵喵喵 喵喵
        呜喵喵呜呜 呜呜 呜呜呜呜喵喵 呜 呜喵呜 喵喵 喵
    呜呜喵呜喵 呜 喵喵呜 呜喵呜 呜呜喵 呜呜喵喵 喵 呜喵呜 呜呜呜喵 喵呜喵 喵 呜喵呜 呜呜喵喵喵 喵喵 喵呜呜
        呜喵喵呜 呜喵 呜喵呜 喵呜 呜呜喵 呜喵喵呜呜 呜呜 呜呜喵喵呜喵 呜 喵喵呜呜喵 喵呜呜呜呜喵 喵喵喵喵喵 呜喵 喵呜喵 呜喵喵呜喵 呜喵呜 喵呜呜呜喵 喵呜 呜呜喵呜 喵喵喵呜 喵喵 喵
        喵喵呜呜喵 呜呜喵呜呜喵 喵喵喵喵喵 呜喵 喵呜喵 呜喵喵呜喵 呜喵呜 喵呜呜呜喵 喵呜 喵
        呜喵喵呜呜 呜呜 呜喵呜呜喵喵 呜 呜喵喵呜 呜喵 呜喵呜 喵呜 喵喵 喵
    呜呜呜
呜呜呜
喵喵呜 呜喵呜喵喵呜 呜 喵喵 喵呜呜
    喵喵呜 喵呜喵 呜喵喵 喵喵呜呜喵 喵 呜喵呜喵喵喵 呜 喵喵喵呜呜喵 呜喵喵 呜呜呜呜 喵呜喵 呜喵喵 呜呜呜呜 喵喵呜呜喵 喵喵 喵
    呜呜呜喵呜 呜 喵喵呜呜喵 呜喵喵喵喵喵 喵喵 喵呜呜
        喵呜喵喵喵呜 喵呜喵喵呜 呜呜喵 喵呜呜呜喵喵 呜 喵喵 喵
        呜呜呜喵呜 呜 喵呜喵喵呜 喵呜呜喵喵喵 喵喵喵呜喵喵 呜呜呜喵喵喵 喵呜喵喵呜 喵呜呜喵喵喵 喵喵呜呜呜喵 喵喵 喵呜喵喵呜 呜呜喵 喵呜呜呜喵喵 呜 喵喵 喵
        喵呜呜呜 呜 喵呜喵喵呜 喵呜喵呜喵喵 喵喵喵呜喵喵 喵喵 喵呜呜
            喵喵喵呜喵 呜呜呜喵 喵喵呜 喵呜喵呜喵 呜喵喵呜 喵
            喵喵喵喵呜 呜喵呜呜 呜喵呜呜 呜呜喵喵喵喵 喵 呜喵呜喵喵喵 呜 喵呜喵呜呜喵 呜喵喵 呜呜呜呜 呜呜喵喵喵喵 喵喵 喵
            喵喵喵喵呜喵 呜 呜喵喵呜 呜喵喵 喵呜喵 呜喵喵 呜呜喵喵喵喵 喵喵 喵
            呜呜喵呜喵 呜 喵喵呜 呜喵呜 呜呜喵 呜呜喵喵 喵 呜喵呜 呜呜呜喵 喵呜喵 喵 呜喵呜 呜呜喵喵喵 喵喵 呜喵喵喵呜喵 呜 喵呜呜喵呜喵 呜喵喵 呜喵喵呜 呜喵 呜喵呜 喵呜 喵喵 喵
            呜喵喵呜喵呜 呜 呜喵呜呜呜喵 喵喵 喵
        呜呜呜
        呜喵呜喵喵 喵呜呜
            喵喵喵呜喵 呜呜呜喵 喵喵呜 喵呜喵呜喵 呜喵喵呜 呜 喵呜喵 喵喵 喵
            呜呜喵呜喵 呜 喵喵呜 呜喵呜 呜呜喵 呜呜喵喵 喵 呜喵呜 呜呜呜喵 喵呜喵 喵 呜喵呜 呜呜喵喵喵 喵喵 呜喵呜喵喵喵 呜 呜呜呜喵呜喵 呜喵喵 呜呜呜呜 呜喵喵呜 呜喵 呜喵呜 喵呜 喵喵 喵
            呜喵喵喵呜喵 呜 呜喵喵呜呜喵 呜喵喵 喵喵呜呜喵喵 呜 呜喵喵呜 呜喵喵 喵呜喵 喵喵 喵喵 喵
        呜呜呜
    呜呜呜
    呜呜呜喵喵 呜呜喵喵 喵
呜呜呜


发表于 2025-11-18 21:42:20 回复(1)
Yui___头像 Yui___
不会康托展开，写了个暴力，能过40% 
#include <vector>
#include <iostream>
#include <algorithm>
#include <unordered_map>

struct VectorHash {
    size_t operator()(const std::vector<int>& v) const {
        size_t hash_val = 0;
        // 组合 vector 中每个元素的哈希值
        for (int i : v) {
            // 用异或和位移混合哈希值（避免简单累加的碰撞问题）
            hash_val ^= std::hash<int>()(i) + 0x9e3779b9 + (hash_val << 6) + (hash_val >> 2);
        }
        return hash_val;
    }
};

int main()
{
    int n = 0,k = 0;
    std::cin>>n>>k;

    std::vector<int> indexs(n);//1~n
    for(int i = 0;i<n;++i)
    {
        indexs[i] = i+1;
    }
    int cur = 1;
    std::vector<std::vector<int>> permutations(3628800);
    std::unordered_map<std::vector<int>, int, VectorHash> map;

    do{
        permutations[cur] = indexs;
        map[indexs] = cur;
        cur+=1;
    }while(std::next_permutation(indexs.begin(),indexs.end()));
    

    int t = k;
    while(t--)
    {
        char op = 0;
        std::cin>>op;

        if('P' == op)
        {
            int num = 0;
            std::cin>>num;

            for(int&it:permutations[num])
            {
                std::cout<<it<<' ';
            }
        }
        else
        {
            std::vector<int> cow_index(n);
            for(int i = 0;i < n;++i)
            {
                std::cin>>cow_index[i];
            }

            std::cout<<map[cow_index];

        }
        std::cout<<'\n';
    }
}



发表于 2025-11-18 21:21:16 回复(0)
提交观点

问题信息

难度：
2条回答 30浏览

热门推荐

相关试题

奶牛排排站

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号