oop练习（第10周）

数组循环右移

本题要求实现一个对数组进行循环右移的简单函数：一个数组a中存有n（>0）个整数，将每个整数循环向右移m（≥0）个位置。
输入样例：

6 2
1 2 3 4 5 6

输出样例：

5 6 1 2 3 4

#include 
#define MAXN 10
int ArrayShift( int a[], int n, int m );
int main(){
    int a[MAXN], n, m;
    int i;

    scanf("%d %d", &n, &m);
    for ( i = 0; i < n; i++ ) scanf("%d", &a[i]);

    ArrayShift(a, n, m);

    for ( i = 0; i < n; i++ ) {
        if (i != 0) printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
int ArrayShift(int a[], int n, int m){
	while (m--){
	    int temp = a[n - 1];
	    for (int i = n - 1; i >= 1; i--)
		    a[i] = a[i - 1];
	  	a[0] = temp;
	}
    return a;
}

使用函数的选择法排序

本题要求实现一个用选择法对整数数组进行简单排序的函数。
输入样例：

4
5 1 7 6

输出样例：

After sorted the array is: 1 5 6 7

#include 
#define MAXN 10

void sort( int a[], int n );

int main()
{
    int i, n;
    int a[MAXN];

    scanf("%d", &n);
    for( i=0; i<n; i++ )
        scanf("%d", &a[i]);

    sort(a, n);

    printf("After sorted the array is:");
    for( i = 0; i < n; i++ )
        printf(" %d", a[i]);
    printf("\n");

    return 0;
}
void sort( int a[], int n ){
	int temp,k,min,i;
	for(k=0;k<n-1;k++){
		min=k;
		for(i=k+1;i<n;i++)
		    if(a[i]<a[min])
		        min=i;
		temp=a[min];
		a[min]=a[k];
		a[k]=temp;
    }
}

查找子串

C语言标准函数库中包括 strstr 函数，在主串中查找子串。作为练习，我们自己编写一个功能与之相同的函数。
输入样例1

This is a pencil
is

输出样例1

2

输入样例2

This is a pencil
be

输出样例2

NULL

#include 
#include 

char* StrStr(const char *txt, const char *pat);

int main()
{
    char m[1024], s[1024], *p;
    gets(m);
    gets(s);
    p = StrStr(m, s);
    if (p)
    {
        printf("%d\n", p - m);
    }
    else
    {
        puts("NULL");
    }
    return 0;
}

char* StrStr(const char *txt, const char *pat){
	char *p;
    p=txt;
	char *q;
    q=pat;
	int l1=0,l2=0,i=0,j=0;
	while(txt[l1]!='\0') 
        l1++;
	while(pat[l2]!='\0') 
        l2++;
	if(l2<=0)
		return NULL;
	while(i<l1&&j<l2){
		if(p[i]==q[j]){
			i++;
			j++;
		} 
		else{
            j=0;
			i++;
			
		}
	}
	if(j>=l2)
		return p+(i-l2);
	return NULL;
}

函数调用

编写三个函数：求两个整数的最大值、最小值、和。分别用这三个函数作为实参，再写一个计算函数compute，对两个整数进行各种计算。其中一个形参为指向具体算法函数的指针。
输入样例：

3 5

输出样例：

Max of 3 and 5 is 5
Min of 3 and 5 is 3
Sum of 3 and 5 is 8

在这里给出函数被调用进行测试的例子。例如：
#include 
using namespace std;

int max(int a, int b);
int min(int a, int b);
int sum(int a, int b);
int compute(int a, int b, int(*func)(int, int));

int main()
{
int a, b, res;
 cin >> a >> b;
res = compute(a, b, & max);
cout << "Max of " << a << " and " << b << " is " << res << endl;
res = compute(a, b, & min);
cout << "Min of " << a << " and " << b << " is " << res << endl;
res = compute(a, b, & sum);
cout << "Sum of " << a << " and " << b << " is " << res << endl;
return 0;
}

int max(int a, int b){
    return a>b?a:b;
}
int min(int a, int b){
    return a<b?a:b;
}
int sum(int a, int b){
    return a+b;
}
int compute(int a, int b, int(*func)(int, int)){
    return func(a,b);
}

求矩阵不靠边元素之和

求矩阵的所有不靠边元素之和，矩阵行的值m从键盘读入(2<=m<=10)，调用自定义函数Input实现矩阵元素从键盘输入，调用Sum函数实现求和。(只考虑float型，且不需考虑求和的结果可能超出float型能表示的范围)。
输入样例：
4

18 29.5 45 33
66 3.4 11.5 57
70 100 2 16.9
15 25.8 4.5 36

输出样例：

sum = 116.90

#include
#define M 10
#define N 4
void Input(float a[][N],int m);
float Sum(float a[][N],int m);
int main(void)
{
		float num[M][N],sum;
	
		int m;
		scanf("%d", &m);
		Input(num,m); 
	
		sum = Sum(num,m);
		printf("sum = %.2f\n", sum);
		return 0;
}

void Input (float a[][N], int m ){
    for(int i=0;i<m;i++){
        for(int j=0;j<N;j++){
            scanf("%f",&a[i][j]);
        }
    }
}
float Sum ( float a[][N], int m ){
    float sum=0;
    for(int i=1;i<m-1;i++){
        for(int j=1;j<N-1;j++){
            sum+=a[i][j];
        }
    }
    return sum;
} 

英文姓名

英美人的姓名比较复杂，一般都由三个名字组成：教名、自取名和姓氏。假设所有名字的长度均不超过30个字符。
请编写函数，根据教名、自取名和姓氏，生成完整的名字。
输入样例1

Lionel
Brockman
Richie

输出样例1

Lionel Brockman Richie

输入样例2

Karen
(空行)
Carpenter

输出样例2

Karen Carpenter

输入样例3

(空行)
(空行)
Foster

输出样例3

Foster

输入样例4

(空行)
(空行)
(空行)

输出样例4

Noname

#include 
#include 

void FullName(char *full, const char *first, const char *middle, const char *last);

int main()
{
    char full[128], first[128], middle[128], last[128];
    gets(first);
    gets(middle);
    gets(last);
    FullName(full, first, middle, last);
    puts(full);
    return 0;
}
void FullName(char* full, const char* first, const char* middle, const char* last) {
    int i = 0, j = 0;
    for (j = 0; j<strlen(first); j++) {
        full[i++] = first[j];
    }
    if (i != 0 && middle[0] != '\0') {
        full[i++] = ' ';
    }
    for (j = 0; j<strlen(middle); j++) {
        full[i++] = middle[j];
    }
    if (i != 0 && last[0] != '\0') {
        full[i++] = ' ';
    }
    for (j = 0; j<strlen(last); j++) {
        full[i++] = last[j];
    }
    if (i==0) {
        strcpy(full,"Noname");
        full[6]='\0';
    }
    else
        full[i] = '\0';
}

将整数中每一位上为偶数的数依次取出构成新数

给定函数fun的功能是：将长整型数中每一位上为偶数的数依次取出，构成一个新数放在t中。高位仍在高位，低位仍在低位。例如，当s中的数为：87653142时，t中的数为：8642。
输入样例：

87653142

输出样例：

The result is: 8642

#include  
void fun (long s, long *t);
int main()
{ long s, t;
 scanf("%ld", &s);
 fun(s, &t);
 printf("The result is: %ld\n", t);
 return 0;
}

void fun(long s,long *t){
    int d;
    long sl = 1;
    *t = 0;
    while (s>0){
        d = s%10;
        if(d%2 == 0){
            *t = d*sl + *t;
            sl *= 10;
        }
        s /= 10;
    }
}

说反话-加强版(10分)

给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

输入格式：
测试输入包含一个测试用例，在一行内给出总长度不超过500 000的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用若干个空格分开。

输出格式：
每个测试用例的输出占一行，输出倒序后的句子，并且保证单词间只有1个空格。

输入样例：
Hello World Here I Come
输出样例：
Come I Here World Hello

#include
using namespace std;
int main(){
	string s;
	int w=0,flag=1,start=0;
	getline(cin,s);
    int l=s.length();
	for(int i=0;i<l;i++){
	    if(s[i]!=' '){
		    start=i;
		    break;
	    }
    }
	for(int i=l-1;i>=0;i--){
		if(s[i]!=' '){
			flag=0;
			w++;
		}
		else if(!flag){
			flag=1;
			for(int j=i+1;j<i+1+w;j++)
			cout<<s[j];
			if(i+1!=start)
			cout<<' ';
			w=0;
		}
	}
	for(int i=start;i<start+w;i++)
	cout<<s[i];
	return 0;
}

找出3个字符串中最大的字符串

利用3×20的二维字符数组存放3个字符串，找出其中最大的字符串并输出。

输入格式:
在3行分别输入3个字符串，在字符串中不要出现换行符，空格，制表符

输出格式:
在两行中按照“The largest string is:（换行）最大字符串”的顺序输出。

输入样例:
as
qwer
zxc
输出样例:
The largest string is:
zxc

#include
using namespace std;
int main(){
    char s[3][20];
    char s1[20];
    for(int i=0;i<3;i++)
    cin>>s[i];
    if(strcmp(s[0],s[1])>0)
		strcpy(s1,s[0]);
	else
		strcpy(s1,s[1]); 
	if(strcmp(s[2],s1)>0)
    	strcpy(s1,s[2]);
    cout<<"The largest string is:"<<"\n"<<s1;
    return 0;
}

查验身份证

一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：

首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：

Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2
现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。

输入格式：
输入第一行给出正整数N（≤100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。

输出格式：
按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出All passed。

输入样例1：
4
320124198808240056
12010X198901011234
110108196711301866
37070419881216001X
输出样例1：
12010X198901011234
110108196711301866
37070419881216001X
输入样例2：
2
320124198808240056
110108196711301862
输出样例2：
All passed

#include
using namespace std;
int main() {
    int n;
    string a;;
    int b[18] = { 7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,24 };
    char c[12] = { '1','0','X','9','8','7','6','5','4','3','2' };
    int i, j;
    int flag = 1;
    cin >> n;
    for (i = 0; i < n; i++) {
        cin >> a;
        int sum = 0;
        for(j=0;j<17;j++)
            if (a[j] >= '0' || a[j]<= '9') {
                sum += (a[j] - '0') * b[j];
            }
            else {
                cout << a <<endl;
                flag = 0;
                break;
            }
        sum %= 11;
        if (a[17] != c[sum]) {
            cout << a << endl;
            flag = 0;
        }
    }
    if (flag)
        cout << "All passed" << endl;
    return 0;
}

考试座位号

每个 PAT 考生在参加考试时都会被分配两个座位号，一个是试机座位，一个是考试座位。正常情况下，考生在入场时先得到试机座位号码，入座进入试机状态后，系统会显示该考生的考试座位号码，考试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的试机座位号码求助于你，从后台查出他们的考试座位号码。

输入格式：
输入第一行给出一个正整数 N（≤1000），随后 N 行，每行给出一个考生的信息：准考证号 试机座位号 考试座位号。其中准考证号由 16 位数字组成，座位从 1 到 N 编号。输入保证每个人的准考证号都不同，并且任何时候都不会把两个人分配到同一个座位上。

考生信息之后，给出一个正整数 M（≤N），随后一行中给出 M 个待查询的试机座位号码，以空格分隔。

输出格式：
对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空格分隔。

输入样例：
4
3310120150912233 2 4
3310120150912119 4 1
3310120150912126 1 3
3310120150912002 3 2
2
3 4
输出样例：
3310120150912002 2
3310120150912119 1

#include
using namespace std;
struct student{
    char hao[20];
    int shi;
    int kao;
}a[1001];
int main(){
    int n,m;
    cin>>n;
    for(int i=0;i<n;i++){
        for(int j=0;j<16;j++)
        cin>>a[i].hao[j];
        cin>>a[i].shi>>a[i].kao;
    }
    cin>>m;
    for(int i=0;i<m;i++){
        int b;
        cin>>b;
        for(int j=0;j<n;j++){
            if(a[j].shi==b){
                for(int k=0;k<16;k++)
                cout<<a[j].hao[k];
                cout<<" "<<a[j].kao<<endl;
            }
        }
    }
    return 0;
}

小明的晚饭 (50分)

小明最近很用功学习，所以经常忘记吃饭。小明决定给自己放个假去大吃一顿，到了吃饭的地方后，小明陷入了沉思，因为他很纠结不知道吃什么,所以他全都要。小明的食量是无限的并且是个贪心的人，所以他想吃完自己支付范围内所有最贵的饭。他从最贵的饭店开始吃，若剩下的钱不足以吃当前最贵的饭店，则往下寻找较贵的饭店。直到钱财为空或者已经吃不起最便宜的饭了。当然小明是个有原则的人，他绝对不会重复吃已经吃过的餐厅。但是他学完习思考不出来该吃啥了，需要你的帮助 (Hint:小明不做其他选择，只要贵的，即使贵的饭吃的少而便宜的饭能吃的多，他也会选择最贵的)

输入格式:
输入一个p表示小明拥有的钱(1<=n<=10000)，在输入一个n表示小明有n(1<=n<=100)种选择，接下来的n行，每一行包含一个字符串表示饭店店名和在该饭店吃饭的价格。字符串长度不超过20。

输出格式:
输出小明能够吃到的饭，如果小明什么都吃不起，则输出“chitu”。

输入样例:
10 5
McDonald’s 2
KFC 6
Yifan 1
Erfan 3
Sanfan 4
输出样例:
KFC
Sanfan

#include
using namespace std;
struct dian{
    char name[22];
    int money;
}a[101];
int cmp(dian x,dian y){
    return x.money>y.money;
}
int main(){
    int p,n;
    cin>>p>>n;
    for(int i=0;i<n;i++){
        scanf("%s %d",a[i].name,&a[i].money);
    }
    sort(a,a+n,cmp);
    int flag=1;
    for(int i=0;i<n;i++){
        if(p>=a[i].money){
            flag=0;
            printf("%s\n",a[i].name);
            p-=a[i].money;
        }
    }
    if(flag)
    printf("chitu");
    return 0;
}

掉入陷阱的数字 (20分)

对任意一个自然数N
​0
​​ ，先将其各位数字相加求和，再将其和乘以3后加上1，变成一个新自然数N
​1
​​ ；然后对N
​1
​​ 重复这种操作，可以产生新自然数N
​2
​​ ；……多次重复这种操作，运算结果最终会得到一个固定不变的数N
​k
​​ ，就像掉入一个数字“陷阱”。

本题要求对输入的自然数，给出其掉入“陷阱”的过程。

输入格式:
在一行内给出一个自然数N
​0
​​ （N
​0
​​ <30000）。

输出格式:
对于输入的N
​0
​​ ，逐行输出其掉入陷阱的步骤。第i行描述N掉入陷阱的第i步，格式为： i:N
​i
​​ （i≥1）。当某一步得到的自然数结果N
​k
​​ (k≥1)与上一步N
​k−1
​​ 相同时，停止输出。

输入样例:
5
输出样例:
1:16
2:22
3:13
4:13

#include
using namespace std;
int fun(int n){
    int sum=0;
    while(n>0){
        sum+=n%10;
        n/=10;
    }
    return 3*sum+1;
}
int main(){
    int n;
    int ans;
    cin>>n;
    for(int i=1;1;i++){
        ans=fun(n);
        cout<<i<<":"<<ans<<endl;
        if(ans==n)
        break;
        else
        n=ans;
    }
    return 0;
}

鸡兔同笼 (10分)

一个笼子里面关了鸡和兔子（鸡有2只脚，兔子有4只脚，没有例外）。已经知道了笼子里面脚的总数a，问笼子里面至少有多少只动物，至多有多少只动物

输入格式:
第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数a (a < 32768)。

输出格式:
n行，每行输出对应一个输入。输出是两个正整数，第一个是最少的动物数，第二个是最多的动物数，两个正整数用空格分开。如果没有满足要求的情况出现，则输出2个0。

输入样例:
在这里给出一组输入。例如：

2
3
20
输出样例:
在这里给出相应的输出。例如：

0 0
5 10

#include
using namespace std;
int main(){
    int n, a;
    cin >> n;
    for(int i=0;i<n;i++){
        cin >> a;
        if(a%4 == 0)
        cout<< a/4 << " " << a/2 << endl;
        else if(a%4 == 2)
        cout<< (a/4)+1 << " " << a/2 << endl;
        else
        cout<< "0 0"<<endl;
    }
    return 0;
}

二维数组每行排序

一个4×5的整型二维数组，从键盘输入数据，并对该数组的每一行按从小到大的顺序排列后输出。

输入格式:
输入4行5列的矩阵，每行第一个数前没有空格，每行的每个数之间各有一个空格。

输出格式:
输出4行5列的矩阵，每行第一个数前没有空格，每个数输出占4列列宽。

输入样例:
1 5 4 2 6
3 2 5 8 4
8 5 4 1 5
9 5 1 2 6
输出样例:
1 2 4 5 6
2 3 4 5 8
1 4 5 5 8
1 2 5 6 9

#include
using namespace std;
int main(){
    int a[4][5];
    for(int i=0;i<4;i++)
        for(int j=0;j<5;j++)
        cin>>a[i][j];
    for(int i=0;i<4;i++)
    sort(a[i],a[i]+5);
    for(int i=0;i<4;i++){
        for(int j=0;j<5;j++)
        printf("%4d",a[i][j]);
        printf("\n");
    }
    return 0;
}

找出不是两个数组共有的元素 (15分)

给定两个整型数组，本题要求找出不是两者共有的元素。

输入格式:
输入分别在两行中给出两个整型数组，每行先给出正整数N（≤20），随后是N个整数，其间以空格分隔。

输出格式:
在一行中按照数字给出的顺序输出不是两数组共有的元素，数字间以空格分隔，但行末不得有多余的空格。题目保证至少存在一个这样的数字。同一数字不重复输出。

输入样例:
10 3 -5 2 8 0 3 5 -15 9 100
11 6 4 8 2 6 -5 9 0 100 8 1
输出样例:
3 5 -15 6 4 1

#include
using namespace std;
int main() {
    int n, m, a[30], b[30], c[50];
    int k = 0;
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    cin >> m;
    for (int i = 0; i < m; i++)
        cin >> b[i];
    for (int i = 0; i < n; i++) {
        int flag = 1;
        for (int j = 0; j < m; j++) {
            if (a[i] == b[j])
                flag = 0;
        }
        if (flag) {
            c[k] = a[i];
            k++;
        }
    }
    for (int i = 0; i < m; i++) {
        int flag = 1;
        for (int j = 0; j < n; j++) {
            if (b[i] == a[j])
                flag = 0;
        }
        if (flag) {
            c[k] = b[i];
            k++;
        }
    }
    int d[50];
    int o = 0;
    for (int i = 0; i < k; i++) {
        int flag = 1;
        for (int j = 0; j < i; j++) {
            if (c[i] == c[j] ) {
                flag = 0;
                break;
            }
        }
        if (flag) {
            if (i == 0)
                cout << c[i];
            else
                cout << " " << c[i];
        }
    }
    return 0;
}

求给定数num的所有真因子之积(T90103) (20分)
输入1 个正整数n (1

输出格式：每个结果输出后换行。

例：括号内是说明

输入样例:
第一个输入样例：
7
第二个输入样例：
12
输出样例:
第一个输出样例：
1
第二个输出样例：
144

#include
using namespace std;
int main(){
    int n;
    cin>>n;
    int sum=1;
    for(int i=1;i<n;i++){
        if(n%i==0)
        sum*=i;
    }
    cout<<sum;
    return 0;
}

英文单词排序

本题要求编写程序，输入若干英文单词，对这些单词按长度从小到大排序后输出。如果长度相同，按照输入的顺序不变。

输入格式：
输入为若干英文单词，每行一个，以#作为输入结束标志。其中英文单词总数不超过20个，英文单词为长度小于10的仅由小写英文字母组成的字符串。

输出格式：
输出为排序后的结果，每个单词后面都额外输出一个空格。

输入样例：
blue
red
yellow
green
purple #
输出样例：
red blue green yellow purple

#include
using namespace std;
int cmp(string x, string y) {
    return x.length() < y.length();
}
int main() {
    string ans[100];
    int i = 0, j = 0;
    while (1) {
        string ss;
        cin >> ss;
        if (ss == "#") {
            break;
        }
        ans[i++] = ss;
    }
    string t;
    for (int a = 0; a < i - 1; a++) {               //sort不稳定，不一定长度相同时不改变位置，需要冒泡排序！！！
        for (int b = i - 1; b > a; b--) {
            if (ans[b - 1].size() > ans[b].size()) {
                t = ans[b];
                ans[b] = ans[b - 1];
                ans[b - 1] = t;
            }
        }
    }
    for (j = 0; j < i; j++) {
        cout << ans[j] << " ";
    }
    return 0;
}

最长对称子串 (25分)

对给定的字符串，本题要求你输出最长对称子串的长度。例如，给定Is PAT&TAP symmetric?，最长对称子串为s PAT&TAP s，于是你应该输出11。

输入格式：
输入在一行中给出长度不超过1000的非空字符串。

输出格式：
在一行中输出最长对称子串的长度。

输入样例：
Is PAT&TAP symmetric?
输出样例：
11

#include
using namespace std;
int main() {
    string s;
    getline(cin, s);
    int len = s.length();
    int ans = 0;
    for (int i = 0; i < len; i++) {
        for (int j = 0; i - j >= 0 && i + j < len; j++) {
            if (s[i - j] != s[i + j]) 
                break;
            ans = max(ans, j * 2 + 1);
        }
        for (int j = 0; i - j >= 0 && i + j + 1 < len; j++) {
            if (s[i - j] != s[i + j + 1])
                break;
            ans = max(ans, j * 2 + 2);
        }
    }
    printf("%d\n", ans);
    return 0;
}

求迷宫最短通道 (20分)

递归求解迷宫最短通道的总步长。输入一个迷宫，求从入口通向出口的可行路径中最短的路径长度。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3

输入格式:
输入迷宫大小的整数n, 以及n行和n列的二维数组（数组元素1代表障碍物，0代表空位）

输出格式:
若有可行的通道则输出一个整数，代表求出的通道的最短步长；若没有通道则输出"No solution"

输入样例:
10
1 1 1 1 1 1 1 1 1 1
1 0 0 1 0 0 0 1 0 1
1 0 0 1 0 0 0 1 0 1
1 0 0 0 0 1 1 0 0 1
1 0 1 1 1 0 0 0 0 1
1 0 0 0 1 0 0 0 0 1
1 0 1 0 0 0 1 0 0 1
1 0 1 1 1 0 1 1 0 1
1 1 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1
输出样例：
14

#include
using namespace std;
int f[20][20];
int n,minn=1000;
int step=0;
void maze(int x,int y,int step){
	if(x==n-2&&y==n-2){
		if(step<minn)
		minn=step;
	}
	else{
		f[x][y]=1;					//将走过的位置置为 1 
		if(f[x][y+1]==0)
			maze(x,y+1,step+1);
		if(f[x][y-1]==0)
			maze(x,y-1,step+1);
		if(f[x+1][y]==0)
			maze(x+1,y,step+1);
		if(f[x-1][y]==0)
			maze(x-1,y,step+1);
		f[x][y]=0;					//回溯 0 
	}
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			cin>>f[i][j];
		
	maze(1,1,0);
	
	if(minn==1000)
	cout<<"No solution"<<endl;
	else
	cout<<minn<<endl;	
    return 0;
}