第一题：相邻数对
给定 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 += ireturn resif 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 secondusing 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列的各个位，对应的方案数+1if(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}; //Fres[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;}
