第一题：相邻数对
给定 n 个不同的整数，问这些数中有多少对整数，它们的值正好相差 1。
输出格式
输入的第一行包含一个整数 n，表示给定整数的个数。
第二行包含所给定的 n 个整数。
输出格式
输出一个整数，表示值正好相差 1 的数对的个数。
数据范围
1≤n≤1000,
给定的整数为不超过 10000 的非负整数。输入样例：
6 10 2 6 3 7 8输出样例：
3样例解释
值正好相差 1 的数对包括 (2,3),(6,7),(7,8)。
解题思路：直接进行模拟即可。
以下是代码：
c++
#include<iostream>
using namespace std;
const int N = 1010;
int a[N] , n;
int main()
{
cin >> n;
for(int i = 0;i < n;i ++)
cin >> a[i];
long long res = 0;
for(int i = 0;i < n;i ++)
for(int j = i + 1;j < n;j ++)
if(abs(a[i] - a[j]) == 1) res ++;
cout << res << endl;
return 0;
}python
n = int(input())
l = list(map(int , input().split()))
res = 0
for i in range(n):
for j in range(i + 1 , n):
if abs(l[i] - l[j]) == 1:
res += 1
print(res)第二题：画图
在一个定义了直角坐标系的纸上，画一个 (x1,y1) 到 (x2,y2) 的矩形指将横坐标范围从 x1 到 x2，纵坐标范围从 y1 到 y2 之间的区域涂上颜色。
下图给出了一个画了两个矩形的例子。
第一个矩形是 (1,1) 到 (4,4)，用绿色和紫色表示。
第二个矩形是 (2,3) 到 (6,5)，用蓝色和紫色表示。
图中，一共有 15 个单位的面积被涂上颜色，其中紫色部分被涂了两次，但在计算面积时只计算一次。
在实际的涂色过程中，所有的矩形都涂成统一的颜色，图中显示不同颜色仅为说明方便。
给出所有要画的矩形，请问总共有多少个单位的面积被涂上颜色。
输入格式
输入的第一行包含一个整数 n，表示要画的矩形的个数。
接下来 n 行，每行 4 个非负整数，分别表示要画的矩形的左下角的横坐标与纵坐标，以及右上角的横坐标与纵坐标。
输出格式
输出一个整数，表示有多少个单位的面积被涂上颜色。
数据范围
1≤n≤100,
0≤ 横坐标、纵坐标 ≤100输入样例：
2 1 1 4 4 2 3 6 5输出样例：
15
解题思路：直接进行模拟即可。
以下是代码：
c++
#include<iostream>
#include<cstring>
using namespace std;
const int N = 110;
int t;
bool st[N][N];
int main()
{
memset(st , 0 , sizeof st);
cin >> t;
while(t --)
{
int a , b , c , d;
cin >> a >> b >> c >> d;
for(int i = a;i < c;i ++)
for(int j = b;j < d;j ++)
st[i][j] = true;
}
int res = 0;
for(int i = 0;i < N;i ++)
for(int j = 0;j < N;j ++)
if(st[i][j]) res ++;
cout << res << endl;
return 0;
}python
st = [[False] * 105 for i in range(105)]
for _ in range(int(input())):
a , b , c , d = map(int , input().split())
for i in range(a , c):
for j in range(b , d):
st[i][j] = True
res = 0
for i in range(101):
for j in range(101):
if st[i][j]:
res += 1
print(res)第三题：字符串匹配
给出一个字符串和多行文字，在这些文字中找到字符串出现的那些行。
你的程序还需支持大小写敏感选项：当选项打开时，表示同一个字母的大写和小写看作不同的字符；当选项关闭时，表示同一个字母的大写和小写看作相同的字符。
输入格式
输入的第一行包含一个字符串 S，由大小写英文字母组成。
第二行包含一个数字，表示大小写敏感的选项，当数字为 0 时表示大小写不敏感，当数字为 1 时表示大小写敏感。
第三行包含一个整数 n，表示给出的文字的行数。
接下来 n 行，每行包含一个字符串，字符串由大小写英文字母组成，不含空格和其他字符。
输出格式
输出多行，每行包含一个字符串，按出现的顺序依次给出那些包含了字符串 S 的行。
数据范围
1≤n≤100,
每个字符串的长度不超过 100。输入样例：
Hello 1 5 HelloWorld HiHiHelloHiHi GrepIsAGreatTool HELLO HELLOisNOTHello输出样例：
HelloWorld HiHiHelloHiHi HELLOisNOTHello样例解释
在上面的样例中，第四个字符串虽然也是
Hello，但是大小写不正确。如果将输入的第二行改为 0，则第四个字符串应该输出。
解题思路：如果判断类型是0，那么统一将所有的大写字母改成小写字母，只需要枚举每一个字母，将大写字母使用异或32即可得到小写字母。
以下是代码：
c++
#include<iostream>
#include<algorithm>
using namespace std;
string s;
int type , t;
string change(string str)
{
string res;
for(char i : str)
if(i <= 'Z') res += i ^ 32;
else res += i;
return res;
}
int main()
{
cin >> s;
cin >> type;
if(!type) s = change(s);
cin >> t;
while(t --)
{
string str;
cin >> str;
if(!type && change(str).find(s) != -1) cout << str << endl;
else if(type && str.find(s) != -1) cout << str << endl;
}
return 0;
}python
s = input()
t = int(input())
def change(s):
res = ''
for i in s:
if ord(i) <= ord('Z'):
res += chr(ord(i) + ord('a') - ord('A'))
else:
res += i
return res
if t == 0:
s = change(s)
for _ in range(int(input())):
w = input()
if t == 0:
if s in change(w):
print(w)
else:
if s in w:
print(w)第四题：最优配餐
栋栋最近开了一家餐饮连锁店，提供外卖服务。
随着连锁店越来越多，怎么合理的给客户送餐成为了一个急需解决的问题。
栋栋的连锁店所在的区域可以看成是一个 n×n的方格图（如下图所示），方格的格点上的位置上可能包含栋栋的分店（绿色标注）或者客户（蓝色标注），有一些格点是不能经过的（红色标注）。
方格图中的线表示可以行走的道路，相邻两个格点的距离为 1。
栋栋要送餐必须走可以行走的道路，而且不能经过红色标注的点。
送餐的主要成本体现在路上所花的时间，每一份餐每走一个单位的距离需要花费 1 块钱。
每个客户的需求都可以由栋栋的任意分店配送，每个分店没有配送总量的限制。
现在你得到了栋栋的客户的需求，请问在最优的送餐方式下，送这些餐需要花费多大的成本。
输入格式
输入的第一行包含四个整数 n,m,k,d，分别表示方格图的大小、栋栋的分店数量、客户的数量，以及不能经过的点的数量。
接下来 m 行，每行两个整数 xi,yi，表示栋栋的一个分店在方格图中的横坐标和纵坐标。
接下来 k 行，每行三个整数 xi,yi,ci，分别表示每个客户在方格图中的横坐标、纵坐标和订餐的量。（注意，可能有多个客户在方格图中的同一个位置）
接下来 d 行，每行两个整数，分别表示每个不能经过的点的横坐标和纵坐标。
输出格式
输出一个整数，表示最优送餐方式下所需要花费的成本。
数据范围
前 30% 的评测用例满足：1≤n≤20。
前 60% 的评测用例满足：1≤n≤100。
所有评测用例都满足：1≤n≤1000,1≤m,k,d≤n2,1≤xi,yi≤n。
可能有多个客户在同一个格点上。
每个客户的订餐量不超过 1000，每个客户所需要的餐都能被送到。输入样例：
10 2 3 3 1 1 8 8 1 5 1 2 3 3 6 7 2 1 2 2 2 6 8输出样例：
29
解题思路：使用bfs进行洪泛操作，对于每一个可以送出外卖的点加入队列，然后求出每一个可以到达的点的最短距离，最终成本就是所有的需要被送餐的点乘以需要的餐品的总数求和，即可得到答案。
以下是代码：
c++
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 1010;
int n, m, k, d;
bool g[N][N];
int dist[N][N];
queue<PII> q;
struct Target
{
int x, y, c;
}tg[N * N];
void bfs()
{
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
while (q.size())
{
auto t = q.front();
q.pop();
for (int i = 0; i < 4; i ++ )
{
int x = t.x + dx[i], y = t.y + dy[i];
if (x < 1 || x > n || y < 1 || y > n || g[x][y]) continue;
if (dist[x][y] > dist[t.x][t.y] + 1)
{
dist[x][y] = dist[t.x][t.y] + 1;
q.push({x, y});
}
}
}
}
int main()
{
scanf("%d%d%d%d", &n, &m, &k, &d);
memset(dist, 0x3f, sizeof dist);
while (m -- )
{
int x, y;
scanf("%d%d", &x, &y);
dist[x][y] = 0;
q.push({x, y});
}
for (int i = 0; i < k; i ++ )
scanf("%d%d%d", &tg[i].x, &tg[i].y, &tg[i].c);
while (d -- )
{
int x, y;
scanf("%d%d", &x, &y);
g[x][y] = true;
}
bfs();
LL res = 0;
for (int i = 0; i < k; i ++ )
res += dist[tg[i].x][tg[i].y] * tg[i].c;
printf("%lld\n", res);
return 0;
}
python
太慢了没过，还是使用c++
第五题：拼图
给出一个 n×m 的方格图，现在要用如下 L 型的积木拼到这个图中，使得方格图正好被拼满，请问总共有多少种拼法。
其中，方格图的每一个方格正好能放积木中的一块。
积木可以任意旋转。
输入格式
输入的第一行包含两个整数 n,m，表示方格图的大小。
输出格式
输出一行，表示可以放的方案数，由于方案数可能很多，所以请输出方案数除以 1e9+7的余数。
数据范围
在评测时将使用 10 个评测用例对你的程序进行评测。
评测用例 1 和 2 满足：1≤n≤30，m=2。
评测用例 3 和 4 满足：1≤n,m≤6。
评测用例 5 满足：1≤n≤100，1≤m≤6。
评测用例 6 和 7 满足：1≤n≤1000，1≤m≤6。
评测用例 8、9 和 10 满足：1≤n≤1e15，1≤m≤7。输入样例：
6 2输出样例：
4样例解释
四种拼法如下图所示：
解题思路：
前后挨着的两列摆放有对应关系，我们可以用二进制位表示同一列各位的填充状态：1填充，0未填充
f[i][j]， i 表示列号，j表示当前列的填充状态，f[i][j]表示方案数
f[i][0] = f[i-1][0]*w[0][0] + f[i-1][1]*w[1][0] + f[i-1][2] * w[2][0] +...+ f[i-1][2^m - 1]*w[2^m -1][0]
w矩阵是记录状态转移方案的矩阵，w[k][b]表示由相邻两列i, i+1 ,列i状态k转换到列i+1状态b的排布方案数
F[i] = {f[i][0],f[i][1],...,f[i][2^m - 1]}
F[i+1] = {f[i+1][0],f[i+1][1],...,f[i+1][2^m - 1]}
f[i+1][0] = f[i][0]*w[0][0] + f[i][1] * w[1][0]+...+ f[i][2^m -1] * w[2^m -1][0]
f[i+1][1] = f[i][0]*w[0][1] + f[i][1] * w[1][1]+...+ f[i][2^m -1] * w[2^m -1][1]
...
f[i+1][2^m -1] = f[i][0]*w[0][2^m -1] + f[i][1] * w[1][2^m -1]+...+ f[i][2^m -1] * w[2^m -1][2^m -1]
--> F[i+1] = F[i] * w
--> F[n] = F[n-1]* w = F[n-2]*w*w = ... = F[0]*w^n
F[0]只有一个合法状态就是f[0][2^m - 1] = 1,即第0列全部排满只有一种方案，其余方案数均为0
（学习学习）
以下是代码：
c++
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 130, mod = 1e9+7;
typedef long long LL;
int w[N][N];
LL n;
int m;
void dfs(int x,int y,int u)
{
if(u == m) w[x][y]++; // 枚举完x列的各个位，对应的方案数+1
if(x >> u & 1) return dfs(x,y,u+1); // x列第u位是非空状态，直接在看下一位
else
{
if(u && !(y >> u & 1) && !(y >> u - 1 & 1)) // 摆法1：当y列的 第u 和 u - 1位为空
dfs(x, y + (1 << u ) + (1 << u - 1), u + 1);
if(u + 1 < m && !(y >> u & 1) && !(y >> u + 1 & 1)) //摆法2：当y列的第u 和 u+1 位为空
dfs(x, y + (1 << u ) + (1 << u + 1), u + 1);
if(u + 1 <m && !(x >> u + 1 & 1)) // 列x的第u+1位也为空
{
if(!(y << u + 1 & 1)) dfs(x, y + 1<<u+1, u + 2); //摆法3，y的第u+1位为空
if(!(y << u & 1)) dfs(x, y + 1 << u, u + 2); //摆法4，y的第u位为空
}
}
}
void mulit(int c[][N], int a[][N],int b[][N])
{
static int tmp[N][N];
memset(tmp,0,sizeof tmp);
for(int i=0; i< 1<<m; i++)
for(int j = 0; j < 1<<m; j++)
for(int k = 0; k < 1<<m; k++)
tmp[i][j] = (tmp[i][j] + (LL)a[i][k] * b[k][j]) % mod; //矩阵乘法
memcpy(c,tmp,sizeof tmp);
}
int main()
{
cin >> n >> m;
for(int i=0; i< 1 <<m ; i++)
dfs(i,0,0);
int res[N][N] = {0}; //F
res[0][(1 << m )-1] = 1;
while(n)
{
if(n & 1) mulit(res,res,w);
mulit(w,w,w);
n >>= 1;
}
cout << res[0][(1 << m) - 1] << endl; //只有第一行是我们要的结果，所以是res[0],
return 0;
}
