校赛2没做，开摆

此为校赛3

佬：前12题全是签到

我：压线写完还有几个题不对（

因为要求用devc，所以抄了一堆很长的叠甲头文件，但是中间编译器坏了遂换回clion

铁咩的，为什么让用pycharm不让用clion

L1-5 不变初心数

不变初心数是指这样一种特别的数，它分别乘 2、3、4、5、6、7、8、9 时，所得乘积各位数之和却不变。例如 18 就是这样的数：18 的 2 倍是 36，3+6=9；18 的 3 倍是 54，5+4=9；…… 18 的 9 倍是 162，1+6+2=9。对于 18 而言，9 就是它的初心。本题要求你判断任一个给定的数是否有不变的初心。

输入格式：

输入在第一行中给出一个正整数 N（≤ 100）。随后 N 行，每行给出一个不超过 105 的正整数。

输出格式：

对每个给定的数字，如果它有不变的初心，就在一行中输出它的初心；否则输出 NO。

输入样例：

输出样例：

9
NO
36
NO

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <string>
#include <cctype>
#include <cstdlib>
#include <map>
#include <ctime>
#include <vector>
#include <queue>
#define LL long long
#define debug(x) cerr<<"\tdebug:"<<#x<<"="<<(x)<<endl
#define debugg(x,y) cerr<<"\tdebug:"<<(x)<<":"<<#y<<"="<<(y)<<endl
#define START clock_t __start=clock();
#define STOP fprintf(stderr,"\n\nUse Time:%fs\n",((double)(clock()-__start)/CLOCKS_PER_SEC));
using namespace std;

int chu(int x){
	int res=0;
	while(x){
		res+=x%10;
		x/=10;
	}
	return res;
}
int main(){
	int n;cin>>n;
	while(n--){
		int x;cin>>x;
		int cx=chu(x*2);
		bool fl=true;
		for(int i=3;i<10;i++){
			int temp=x*i;
			int c=chu(temp);
			if(c!=cx){
				cout<<"NO"<<endl;
				fl=false;
				break;
			}

		}
		if(fl){
			cout<<cx<<endl;
		}
	}

}

L1-6 检查密码

本题要求你帮助某网站的用户注册模块写一个密码合法性检查的小功能。该网站要求用户设置的密码必须由不少于6个字符组成，并且只能有英文字母、数字和小数点 .，还必须既有字母也有数字。

输入格式：

输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行给出一个用户设置的密码，为不超过 80 个字符的非空字符串，以回车结束。

注意： 题目保证不存在只有小数点的输入。

输出格式：

对每个用户的密码，在一行中输出系统反馈信息，分以下5种：

如果密码合法，输出Your password is wan mei.；
如果密码太短，不论合法与否，都输出Your password is tai duan le.；
如果密码长度合法，但存在不合法字符，则输出Your password is tai luan le.；
如果密码长度合法，但只有字母没有数字，则输出Your password needs shu zi.；
如果密码长度合法，但只有数字没有字母，则输出Your password needs zi mu.。

输入样例：

5
123s
zheshi.wodepw
1234.5678
WanMei23333
pass*word.6

输出样例：

Your password is tai duan le.
Your password needs shu zi.
Your password needs zi mu.
Your password is wan mei.
Your password is tai luan le.

简单题但并不好写，首先给我记住：

getline(cin,s)

isdigit isalpha

#include<bits/stdc++.h>
using namespace std;


int main(){
    int n;cin>>n;
    getchar();
    while(n--){
        string s;
        getline(cin,s);
//        getchar();
        if(s.length()<6){
            cout<<"Your password is tai duan le."<<endl;
            continue;
        }
        bool ying=false;
        bool shuzi=false;
        bool fl=true;
        for(char i : s){
            if(isdigit(i)){
                shuzi=true;
            }
            else if(isalpha(i)){
                ying=true;
            }
            else if(i=='.'){

            }
            else{
                cout<<"Your password is tai luan le."<<endl;
                fl=false;
                break;
            }
        }
        if(!fl){
            continue;
        }
        if(!ying){
            cout<<"Your password needs zi mu."<<endl;
        }
        else if(!shuzi){
            cout<<"Your password needs shu zi."<<endl;
        }
        else{
            cout<<"Your password is wan mei."<<endl;
        }

    }

}

L1-7 谷歌的招聘*

2004 年 7 月，谷歌在硅谷的 101 号公路边竖立了一块巨大的广告牌（如下图）用于招聘。内容超级简单，就是一个以 .com 结尾的网址，而前面的网址是一个 10 位素数，这个素数是自然常数 e 中最早出现的 10 位连续数字。能找出这个素数的人，就可以通过访问谷歌的这个网站进入招聘流程的下一步。

自然常数 e 是一个著名的超越数，前面若干位写出来是这样的：e = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427427466391932003059921… 其中粗体标出的 10 位数就是答案。

本题要求你编程解决一个更通用的问题：从任一给定的长度为 L 的数字中，找出最早出现的 K 位连续数字所组成的素数。

输入格式：

输入在第一行给出 2 个正整数，分别是 L（不超过 1000 的正整数，为数字长度）和 K（小于 10 的正整数）。接下来一行给出一个长度为 L 的正整数 N。

输出格式：

在一行中输出 N 中最早出现的 K 位连续数字所组成的素数。如果这样的素数不存在，则输出 404。注意，原始数字中的前导零也计算在位数之内。例如在 200236 中找 4 位素数，0023 算是解；但第一位 2 不能被当成 0002 输出，因为在原始数字中不存在这个 2 的前导零。

输入样例 1：

1 2	`20 5 23654987725541023819`

输出样例 1：

输入样例 2：

1 2	`10 3 2468001680`

输出样例 2：

///谷歌招聘
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+7;
bool bushisu[maxn];

void init(){
    bushisu[1]=true;
    memset(bushisu,false,sizeof(bushisu));
    for(int i=2;i<maxn-1;i++){
        if(!bushisu[i]) {
            for (int j = 2; j * i < maxn; j++) {
                bushisu[j*i] = true;
            }
        }
    }
}

int main(){
    init();
    int l,k;cin>>l>>k;
    string s;cin>>s;
    bool fl=false;
    for(int i=0;i<s.size();i++){
        string ns=s.substr(i,k);
//        cout<<ns<<endl;
        if(!bushisu[stoi(ns)]){
            cout<<ns;
            fl=true;
            break;
        }
    }
    if(!fl){
        cout<<404;
    }
}

L1-8 矩阵列平移

给定一个 n×n 的整数矩阵。对任一给定的正整数 k<n，我们将矩阵的偶数列的元素整体向下依次平移 1、……、k、1、……、k、…… 个位置，平移空出的位置用整数 x 补。你需要计算出结果矩阵的每一行元素的和。

输入格式：

输入第一行给出 3 个正整数：n（<100）、k（<n）、x（<100），分别如题面所述。

接下来 n 行，每行给出 n 个不超过 100 的正整数，为矩阵元素的值。数字间以空格分隔。

输出格式：

在一行中输出平移后第 1 到 n 行元素的和。数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

7 2 99
11 87 23 67 20 75 89
37 94 27 91 63 50 11
44 38 50 26 40 26 24
73 85 63 28 62 18 68
15 83 27 97 88 25 43
23 78 98 20 30 81 99
77 36 48 59 25 34 22

输出样例：

1	`440 399 369 421 302 386 428`

样例解读

需要平移的是第 2、4、6 列。给定 k=2，应该将这三列顺次整体向下平移 1、2、1 位（如果有更多列，就应该按照 1、2、1、2 …… 这个规律顺次向下平移），顶端的空位用 99 来填充。平移后的矩阵变成：

11 99 23 99 20 99 89
37 87 27 99 63 75 11
44 94 50 67 40 50 24
73 38 63 91 62 26 68
15 85 27 26 88 18 43
23 83 98 28 30 25 99
77 78 48 97 25 81 22

行列没搞好，感觉花了不少时间qwq

#include<bits/stdc++.h>
using namespace std;

int a[107][107];
void init(){
    for(int i=0;i<107;i++){
        for(int j=0;j<107;j++){
            a[i][j]=-1;
        }

    }
}
int main(){
    init();
    int n,k,x;
    cin>>n>>k>>x;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cin>>a[i][j];
        }
    }
    int cnt=1;
    for(int j=1;j<n;j+=2){//lie
        for(int i=n-1;i>=0;i--){//hang
            if(i-cnt>=0) {
                a[i][j]=a[i-cnt][j];
//                a[i+cnt][j] = a[i][j];
            }
            else{
                a[i][j]=x;
            }
        }
        cnt++;
        if(cnt>k) cnt=1;
    }
    int res= 0;
    for(int i=0;i<n;i++){
        res=0;
        for(int j=0;j<n;j++){
            if(a[i][j]==-1){
                a[i][j]=x;
            }
//            cout<<a[i][j]<<' ';
            res+=a[i][j];
        }
        if(i!=n-1)cout<<res<<' ';
        else cout<<res;
//        cout<<endl;
    }


}

L2-1 点赞狂魔

微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。然而有这么一种人，他们会通过给自己看到的一切内容点赞来狂刷存在感，这种人就被称为“点赞狂魔”。他们点赞的标签非常分散，无法体现出明显的特性。本题就要求你写个程序，通过统计每个人点赞的不同标签的数量，找出前3名点赞狂魔。

输入格式：

输入在第一行给出一个正整数N（≤100），是待统计的用户数。随后N行，每行列出一位用户的点赞标签。格式为“Name K F1⋯F**K”，其中Name是不超过8个英文小写字母的非空用户名，1≤K≤1000，F**i（i=1,⋯,K）是特性标签的编号，我们将所有特性标签从 1 到 107 编号。数字间以空格分隔。

输出格式：

统计每个人点赞的不同标签的数量，找出数量最大的前3名，在一行中顺序输出他们的用户名,其间以1个空格分隔,且行末不得有多余空格。如果有并列，则输出标签出现次数平均值最小的那个，题目保证这样的用户没有并列。若不足3人，则用-补齐缺失，例如mike jenny -就表示只有2人。

输入样例：

5
bob 11 101 102 103 104 105 106 107 108 108 107 107
peter 8 1 2 3 4 3 2 5 1
chris 12 1 2 3 4 5 6 7 8 9 1 2 3
john 10 8 7 6 5 4 3 2 1 7 5
jack 9 6 7 8 9 10 11 12 13 14

输出样例：

1	`jack chris john`

#include<bits/stdc++.h>
using namespace std;
struct zan{
    int val;
    int cnt=0;
    zan(int v,int c){
        val=v;
        c=1;
    }
};
struct peo{
    string name;
    vector<zan> z;
};
peo p[107];
bool cmp(peo &a,peo &b){
    if(a.z.size()==b.z.size()){
        int acnt=0;int bcnt=0;
        for(int i=0;i<a.z.size();i++){
            acnt+=a.z[i].cnt;
        }
        for(int i=0;i<b.z.size();i++){
            bcnt+=b.z[i].cnt;
        }
        return acnt<bcnt;

    }
    return a.z.size()>b.z.size();

}
int main(){
    int n;cin>>n;
    for(int i=0;i<n;i++){
        cin>>p[i].name;
        int k;cin>>k;
        for(int j=0;j<k;j++){
            int x;cin>>x;
            bool fl=false;
            for(int m=0;m<p[i].z.size();m++){
                if(p[i].z[m].val==x){
                    p[i].z[m].cnt++;
                    fl=true;
                }
            }
            if(!fl){
                p[i].z.push_back(zan(x,1));
            }

        }
    }
    sort(p,p+n,cmp);
    int i=0;
    for(;i<n&&i<3;i++){
        if(i!=2) cout<<p[i].name<<' ';
        else cout<<p[i].name;
    }
    if(n<3){
        for(;i<2;i++) cout<<'-'<<' ';
        cout<<'-';
    }



}

L2-2 重排链表*

给定一个单链表 L1→L2→⋯→L**n−1→L**n，请编写程序将链表重新排列为 L**n→L1→L**n−1→L2→⋯。例如：给定L为1→2→3→4→5→6，则输出应该为6→1→5→2→4→3。

输入格式：

每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址和结点总个数，即正整数N (≤105)。结点的地址是5位非负整数，NULL地址用−1表示。

接下来有N行，每行格式为：

1	`Address Data Next`

其中Address是结点地址；Data是该结点保存的数据，为不超过105的正整数；Next是下一结点的地址。题目保证给出的链表上至少有两个结点。

输出格式：

对每个测试用例，顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。

输入样例：

00100 6
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

输出样例：

68237 6 00100
00100 1 99999
99999 5 12309
12309 2 00000
00000 4 33218
33218 3 -1

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+7;

struct lis{
    int add;
    int data;
    int next;
};
lis l[maxn];
lis re[maxn];
lis zz[maxn];
int main(){
    int f_add,n;
    cin>>f_add>>n;
    for(int i=0;i<n;i++){
        int x,y,z;
        cin>>x>>y>>z;
        l[x].add=x;
        l[x].data=y;
        l[x].next=z;
    }
    for(int i=f_add,j=0;i!=-1;j++){//链表重排成对的顺序
        re[j].add=l[i].add;
        re[j].data=l[i].data;
        re[j].next=l[i].next;
        i=l[i].next;
    }
//    for(int i=0;i<n;i++){
//        cout<<re[i].add<<' '<<re[i].data<<' '<<re[i].next<<endl;
//    }
    int jj=n-1;
    int kk=0;
    for(int i=0;i<n;i++){//偶数走n 奇数走12
        if(i%2==0){
//            cout<<re[jj].add<<' '<<re[jj].data<<' '<<re[jj].next<<endl;
            zz[i].add=re[jj].add;
            zz[i].data=re[jj].data;
            zz[i].next=re[kk].add;
            if(i==n-1){
                zz[i].next=-1;
            }
            jj--;
        }
        else{
//            cout<<re[kk].add<<' '<<re[kk].data<<' '<<re[kk].next<<endl;
            zz[i].add=re[kk].add;
            zz[i].data=re[kk].data;
            zz[i].next=re[jj].add;
            if(i==n-1){
                zz[i].next=-1;
            }
            kk++;
        }

    }
    for(int i=0;i<n-1;i++){
        printf("%05d %d %05d\n",zz[i].add,zz[i].data,zz[i].next);
//        cout<<zz[i].add<<' '<<zz[i].data<<' '<<zz[i].next<<endl;
    }
    printf("%05d %d %d",zz[n-1].add,zz[n-1].data,zz[n-1].next);


}

L2-3 图着色问题*

图着色问题是一个著名的NP完全问题。给定无向图G=(V,E)，问可否用K种颜色为V中的每一个顶点分配一种颜色，使得不会有两个相邻顶点具有同一种颜色？

但本题并不是要你解决这个着色问题，而是对给定的一种颜色分配，请你判断这是否是图着色问题的一个解。

输入格式：

输入在第一行给出3个整数V（0<V≤500）、E（≥0）和K（0<K≤V），分别是无向图的顶点数、边数、以及颜色数。顶点和颜色都从1到V编号。随后E行，每行给出一条边的两个端点的编号。在图的信息给出之后，给出了一个正整数N（≤20），是待检查的颜色分配方案的个数。随后N行，每行顺次给出V个顶点的颜色（第i个数字表示第i个顶点的颜色），数字间以空格分隔。题目保证给定的无向图是合法的（即不存在自回路和重边）。

输出格式：

对每种颜色分配方案，如果是图着色问题的一个解则输出Yes，否则输出No，每句占一行。

输入样例：

6 8 3
2 1
1 3
4 6
2 5
2 4
5 4
5 6
3 6
4
1 2 3 3 1 2
4 5 6 6 4 5
1 2 3 4 5 6
2 3 4 2 3 4

输出样例：

Yes
Yes
No
No

///图着色

#include<bits/stdc++.h>
using namespace std;
const int maxn=1007;

int v,e,k;
struct node{
    int color;
    vector<int> to;
};

node N[maxn];
bool vis[maxn];
int main(){
    cin>>v>>e>>k;//顶点数、边数、以及颜色数 顶点和颜色都从1到V编号
    for(int i=0;i<e;i++){
        int x,y;
        cin>>x>>y;
        N[x].to.push_back(y);
        N[y].to.push_back(x);
    }

    int n;cin>>n;
    for(int i=0;i<n;i++){
        int k_cnt=0;
        bool fl=true;
        memset(vis,false,sizeof(vis));
        for(int j=1;j<=v;j++){//填颜色
            int temp;cin>>temp;
            if(!vis[temp]){
                vis[temp]=true;
                k_cnt++;
                if(k_cnt>k){
                    fl = false;
                }
            }
            N[j].color=temp;
        }
        for(int j=1;j<=v;j++){//对于图中每个点
            if(fl) {
                for (int jj = 0; jj < N[j].to.size(); jj++) {//遍历邻接表
                    int to_color = N[N[j].to[jj]].color;
                    if (N[j].color == to_color) {
                        fl = false;
                        break;
                    }
                }
            }
        }
        if(fl&&v!=0){
            cout<<"Yes"<<endl;
        }
        else{
            cout << "No" << endl;
        }
    }
}

L2-4 部落

在一个社区里，每个人都有自己的小圈子，还可能同时属于很多不同的朋友圈。我们认为朋友的朋友都算在一个部落里，于是要请你统计一下，在一个给定社区中，到底有多少个互不相交的部落？并且检查任意两个人是否属于同一个部落。

输入格式：

输入在第一行给出一个正整数N（≤104），是已知小圈子的个数。随后N行，每行按下列格式给出一个小圈子里的人：

K P[1] P[2] ⋯ P[K]

其中K是小圈子里的人数，P[i]（i=1,⋯,K）是小圈子里每个人的编号。这里所有人的编号从1开始连续编号，最大编号不会超过104。

之后一行给出一个非负整数Q（≤104），是查询次数。随后Q行，每行给出一对被查询的人的编号。

输出格式：

首先在一行中输出这个社区的总人数、以及互不相交的部落的个数。随后对每一次查询，如果他们属于同一个部落，则在一行中输出Y，否则输出N。

输入样例：

输出样例：

1
2
3

10 2
Y
N

开香槟了我的并查集

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+7;
int n;
int f[maxn];
bool vis[maxn];
void init(){
    for(int i=0;i<maxn;i++){
        f[i]=i;
    }
}
int find(int x){
    if(f[x]==x) return x;
    else return f[x]=find(f[x]);
}
void merge(int a,int b){
    int temp=find(a);
    f[temp]=find(b);
}
bool check(int a,int b){
    return find(a)==find(b);
}

int main(){
    cin>>n;
    init();
    int ren=0;
    for(int i=0;i<n;i++){//每个社区
        int k;cin>>k;
        int a;cin>>a;
        ren=max(ren,a);
        for(int j=1;j<k;j++){//社区中的每个人
            int x;cin>>x;
            ren=max(ren,x);
            merge(a,x);
        }
    }
    int q;cin>>q;
    cout<<ren<<' ';
    int dif=0;
    for(int i=1;i<=ren;i++){
        int temp=find(i);
        if(!vis[temp]){
            dif++;
            vis[temp]=true;
        }
    }
    cout<<dif<<endl;
    while(q--){
        int x,y;cin>>x>>y;
        if(check(x,y)) cout<<"Y"<<endl;
        else cout<<"N"<<endl;
    }
}

L3-1 森森旅游

好久没出去旅游啦！森森决定去 Z 省旅游一下。

Z 省有 n 座城市（从 1 到 n 编号）以及 m 条连接两座城市的有向旅行线路（例如自驾、长途汽车、火车、飞机、轮船等），每次经过一条旅行线路时都需要支付该线路的费用（但这个收费标准可能不止一种，例如车票跟机票一般不是一个价格）。

Z 省为了鼓励大家在省内多逛逛，推出了旅游金计划：在 i 号城市可以用 1 元现金兑换 a**i 元旅游金（只要现金足够，可以无限次兑换）。城市间的交通即可以使用现金支付路费，也可以用旅游金支付。具体来说，当通过第 j 条旅行线路时，可以用 c**j 元现金或 d**j 元旅游金支付路费。注意： 每次只能选择一种支付方式，不可同时使用现金和旅游金混合支付。但对于不同的线路，旅客可以自由选择不同的支付方式。

森森决定从 1 号城市出发，到 n 号城市去。他打算在出发前准备一些现金，并在途中的某个城市将剩余现金全部换成旅游金后继续旅游，直到到达 n 号城市为止。当然，他也可以选择在 1 号城市就兑换旅游金，或全部使用现金完成旅程。

Z 省政府会根据每个城市参与活动的情况调整汇率（即调整在某个城市 1 元现金能换多少旅游金）。现在你需要帮助森森计算一下，在每次调整之后最少需要携带多少现金才能完成他的旅程。

输入格式:

输入在第一行给出三个整数 n，m 与 q（1≤n≤105，1≤m≤2×105，1≤q≤105），依次表示城市的数量、旅行线路的数量以及汇率调整的次数。

接下来 m 行，每行给出四个整数 u，v，c 与 d（1≤u,v≤n，1≤c,d≤109），表示一条从 u 号城市通向 v 号城市的有向旅行线路。每次通过该线路需要支付 c 元现金或 d 元旅游金。数字间以空格分隔。输入保证从 1 号城市出发，一定可以通过若干条线路到达 n 号城市，但两城市间的旅行线路可能不止一条，对应不同的收费标准；也允许在城市内部游玩（即 u 和 v 相同）。

接下来的一行输入 n 个整数 a1,a2,⋯,a**n（1≤a**i≤109），其中 a**i 表示一开始在 i 号城市能用 1 元现金兑换 a**i 个旅游金。数字间以空格分隔。

接下来 q 行描述汇率的调整。第 i 行输入两个整数 x**i 与 a**i′（1≤x**i≤n，1≤a**i′≤109），表示第 i 次汇率调整后，x**i 号城市能用 1 元现金兑换 a**i′ 个旅游金，而其它城市旅游金汇率不变。请注意：每次汇率调整都是在上一次汇率调整的基础上进行的。

输出格式:

对每一次汇率调整，在对应的一行中输出调整后森森至少需要准备多少现金，才能按他的计划从 1 号城市旅行到 n 号城市。

再次提醒：如果森森决定在途中的某个城市兑换旅游金，那么他必须将剩余现金全部、一次性兑换，剩下的旅途将完全使用旅游金支付。

输入样例:

6 11 3
1 2 3 5
1 3 8 4
2 4 4 6
3 1 8 6
1 3 10 8
2 3 2 8
3 4 5 3
3 5 10 7
3 3 2 3
4 6 10 12
5 6 10 6
3 4 5 2 5 100
1 2
2 1
1 17

输出样例:

1
2
3

8
8
1

样例解释:

对于第一次汇率调整，森森可以沿着 1→2→4→6 的线路旅行，并在 2 号城市兑换旅游金；

对于第二次汇率调整，森森可以沿着 1→2→3→4→6 的线路旅行，并在 3 号城市兑换旅游金；

对于第三次汇率调整，森森可以沿着 1→3→5→6 的线路旅行，并在 1 号城市兑换旅游金。

L3-2 还原文件

一份重要文件被撕成两半，其中一半还被送进了碎纸机。我们将碎纸机里找到的纸条进行编号，如图 1 所示。然后根据断口的折线形状跟没有切碎的半张纸进行匹配，最后还原成图 2 的样子。要求你输出还原后纸条的正确拼接顺序。

图1 纸条编号

图2 还原结果

输入格式：

输入首先在第一行中给出一个正整数 N（1<N≤105），为没有切碎的半张纸上断口折线角点的个数；随后一行给出从左到右 N 个折线角点的高度值（均为不超过 100 的非负整数）。

随后一行给出一个正整数 M（≤100），为碎纸机里的纸条数量。接下去有 M 行，其中第 i 行给出编号为 i（1≤i≤M）的纸条的断口信息，格式为：

1	`K h[1] h[2] ... h[K]`

其中 K 是断口折线角点的个数（不超过 104+1），后面是从左到右 K 个折线角点的高度值。为简单起见，这个“高度”跟没有切碎的半张纸上断口折线角点的高度是一致的。

输出格式：

在一行中输出还原后纸条的正确拼接顺序。纸条编号间以一个空格分隔，行首尾不得有多余空格。

题目数据保证存在唯一解。

输入样例：

17
95 70 80 97 97 68 58 58 80 72 88 81 81 68 68 60 80
6
4 68 58 58 80
3 81 68 68
3 95 70 80
3 68 60 80
5 80 72 88 81 81
4 80 97 97 68

输出样例：

1	`3 6 1 5 2 4`

据说这是简单的模拟

L3-3 可怜的简单题

九条可怜去年出了一道题，导致一众参赛高手惨遭团灭。今年她出了一道简单题 —— 打算按照如下的方式生成一个随机的整数数列 A:

最开始，数列 A 为空。
可怜会从区间 [1,n] 中等概率随机一个整数 i 加入到数列 A 中。
如果不存在一个大于 1 的正整数 w，满足 A 中所有元素都是 w 的倍数，数组 A 将会作为随机生成的结果返回。否则，可怜将会返回第二步，继续增加 A 的长度。

现在，可怜告诉了你数列 n 的值，她希望你计算返回的数列 A 的期望长度。

输入格式：

输入一行两个整数 n,p (1≤n≤1011,n<p≤1012)，p 是一个质数。

输出格式：

在一行中输出一个整数，表示答案对 p 取模的值。具体来说，假设答案的最简分数表示为 y**x，你需要输出最小的非负整数 z 满足 y×z≡x mod p。

输入样例 1：

1	`2 998244353`

输出样例 1：

输入样例 2：

1	`100000000 998244353`

L1-5 不变初心数

输入格式：

输出格式：

输入样例：

输出样例：

L1-6 检查密码

输入格式：

输出格式：

输入样例：

输出样例：

L1-7 谷歌的招聘*

输入格式：

输出格式：

输入样例 1：

输出样例 1：

输入样例 2：

输出样例 2：

L1-8 矩阵列平移

输入格式：

输出格式：

输入样例：

输出样例：

L2-1 点赞狂魔

输入格式：

输出格式：

输入样例：

输出样例：

L2-2 重排链表*

输入格式：

输出格式：

输入样例：

输出样例：

L2-3 图着色问题*

输入格式：

输出格式：

输入样例：

输出样例：

L2-4 部落

输入格式：

输出格式：

输入样例：

输出样例：

L3-1 森森旅游

输入格式:

输出格式:

输入样例:

输出样例:

样例解释:

L3-2 还原文件

输入格式：

输出格式：

输入样例：

输出样例：

L3-3 可怜的简单题

输入格式：

输出格式：

输入样例 1：

输出样例 1：

输入样例 2：

输出样例 2：

STERNE