笔试强训day34

ISBN号码

描述

每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔之后的五位数字代表该书在出版社的编号；最后一位为识别码。
识别码的计算方法如下：
首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
你的任务是编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出你认为是正确的ISBN号码。

输入描述：

只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。

输出描述：

共一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。

直接上去模拟就可以了

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <algorithm>

using namespace std;
int a, b, c;
char d;

string s;

int main()
{
	scanf("%d-%d-%d-%c", &a, &b, &c, &d);
	s += to_string(a) + to_string(b) + to_string(c);
	int ans = 0;

	for (int i = 1; i <= 9; ++i)
	{
		ans += i * (s[i - 1] - '0');
	}
	if (ans % 11 == 10)
	{
		if (d == 'X')cout << "Right" << endl;
		else cout << to_string(a) + "-" + to_string(b) + "-" + to_string(c) + "-" + 'X' << endl;
	}
	else {
		if (ans % 11 + '0' == d)
			cout << "Right" << endl;
		else cout<<to_string(a) + "-" + to_string(b) + "-" + to_string(c) + "-" + to_string(ans % 11) << endl;
	}
	return 0;
}

---

kotori和迷宫

kotori在一个n*m迷宫里，迷宫的最外层被岩浆淹没，无法涉足，迷宫内有k个出口。kotori只能上下左右四个方向移动。她想知道有多少出口是她能到达的，最近的出口离她有多远？

输入描述:

第一行为两个整数n和m，代表迷宫的行和列数 (1≤n,m≤30)

后面紧跟着n行长度为m的字符串来描述迷宫。'k'代表kotori开始的位置，'.'代表道路，'*'代表墙壁，'e'代表出口。保证输入合法。

输出描述:

若有出口可以抵达，则输出2个整数，第一个代表kotori可选择的出口的数量，第二个代表kotori到最近的出口的步数。（注意，kotori到达出口一定会离开迷宫）

若没有出口可以抵达，则输出-1。

BFS

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 35;
int x1, y1; // 标记起点位置
int n, m;
char arr[N][N];
int dist[N][N];
queue<pair<int, int>> q;
int dx[4] = { 0, 0, 1, -1 };
int dy[4] = { 1, -1, 0, 0 };
void bfs()
{
	memset(dist, -1, sizeof dist);
	dist[x1][y1] = 0;
	q.push({ x1, y1 });

	while (!q.empty())
	{
		auto &[x2, y2] = q.front();
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			int a = x2 + dx[i], b = y2 + dy[i];
			if (a >= 1 && a <= n && b >= 1 && b <= m && dist[a][b] == -1 &&
				arr[a][b] != '*')
			{
				dist[a][b] = dist[x2][y2] + 1;
				if (arr[a][b] != 'e')
				{
					q.push({ a, b });
				}
			}
		}
	}
}
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			cin >> arr[i][j];
			if (arr[i][j] == 'k')
			{
				x1 = i, y1 = j;
			}
		}
	}

	bfs();

	int count = 0, ret = 1e9;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			if (arr[i][j] == 'e' && dist[i][j] != -1)
			{
				count++;
				ret = min(ret, dist[i][j]);
			}
		}
	}
	if (count == 0) cout << -1 << endl;
	else cout << count << " " << ret << endl;

	return 0;
}

---

矩阵最长递增路径

描述

给定一个 n 行 m 列矩阵 matrix ，矩阵内所有数均为非负整数。 你需要在矩阵中找到一条最长路径，使这条路径上的元素是递增的。并输出这条最长路径的长度。

这个路径必须满足以下条件：

1. 对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外。

2. 你不能走重复的单元格。即每个格子最多只能走一次。

数据范围：1≤n,m≤10001≤n,m≤1000，0≤matrix[i][j]≤10000≤matri**x[i][j]≤1000

进阶：空间复杂度 O(nm)O(n**m) ，时间复杂度 O(nm)O(n**m)

例如：当输入为[[1,2,3],[4,5,6],[7,8,9]]时，对应的输出为5，

其中的一条最长递增路径如下图所示：

首先，非常逆天，没用记忆化搜索居然可以通过

class Solution {
    int n,m;
    int dx[4]{1,-1,0,0},dy[4]{0,0,1,-1};

    int dfs(vector<vector<int> >& matrix,int i,int j)
    {
        int ans = 1;
        for(int k = 0;k<4;++k)
        {
            int x = i+dx[k],y=j+dy[k];
            if(x>=0&&x<n&&y>=0&&y<m&&matrix[x][y] > matrix[i][j])
            {
                ans = max(ans,dfs(matrix,x,y)+1);
            }
        }
        return ans;
    }
public:
    int solve(vector<vector<int> >& matrix) {
        // write code here
        n = matrix.size(),m = matrix[0].size();
        int ans = 1;
        for(int i = 0;i<n;++i)
        {
            for(int j = 0;j<m;++j)
            {
                ans = max(ans,dfs(matrix,i,j));
            }
        }
        return ans;
    }
};

记忆化搜索

class Solution {
    int n,m;
    int dx[4]{1,-1,0,0},dy[4]{0,0,1,-1};
    int memo[1010][1010];
    int dfs(vector<vector<int> >& matrix,int i,int j)
    {
        if(memo[i][j]!=-1)return memo[i][j];
        int ans = 1;
        for(int k = 0;k<4;++k)
        {
            int x = i+dx[k],y=j+dy[k];
            if(x>=0&&x<n&&y>=0&&y<m&&matrix[x][y] > matrix[i][j])
            {
                ans = max(ans,dfs(matrix,x,y)+1);
            }
        }
        return memo[i][j]=ans;
    }
public:
    int solve(vector<vector<int> >& matrix) {
        // write code here
        memset(memo,-1,sizeof memo);
        n = matrix.size(),m = matrix[0].size();
        int ans = 1;
        for(int i = 0;i<n;++i)
        {
            for(int j = 0;j<m;++j)
            {
                ans = max(ans,dfs(matrix,i,j));
            }
        }
        return ans;
    }
};