A - QQ solver (atcoder.jp)直接按题意模拟即可。
B - Caesar Cipher (atcoder.jp)按题意模拟即可
C - Graph Isomorphism (atcoder.jp)按题意模拟即可
D - Weak Takahashi (atcoder.jp) 一个非常套路的网格dp
E - Rook Path (atcoder.jp)
（1）题意
有一个H*W的网格，网格中有一个车初始在(x1,y1)这个位置，高桥操作K次后达到(x2,y2)的方案数是多少，每一次移动可以挪到一行或者这一列的任意一个位置上去，但是不能在原始位置。
（2）思路
考虑K不大，我们进行O(K)的dp。
定义dp[i][0]表示前i步操作操作完后和最终位置行列都不同的方案数
定义dp[i][1]表示前i步操作操作完后和最终位置列相同的方案数
定义dp[i][2]表示前i步操作操作完后和最终位置列相同的方案数
定义dp[i][3]表示前i步操作操作完后和最终位置行列都相同的方案数
1.首先若第i步操作想要变成行列都相同，则前(i - 1)步一定是行相同或者列相同
2.若第i步操作只要变成行相同，那么前面可能是通过行相同，但第i步走到了不同列，或者是前面i-1步行列都不同走到这行上来了，或者是前面行列都一样，走到不同的列去了。
3.若第i步操作只要变成列相同，那么前面可能是通过列相同，但第i步走到了不同行，或者是前面i-1步行列都不同走到这列上来了，或者是前面行列都一样，走到不同的行去了。
4.若第i步操作想要变成行列都不同，那么可能是通过行相同，然后走到了不同行，或者是列相同走到了不同列，或者是行列都不同又走到了行列都不同。
（3）代码
#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 1e6 + 10;
ll dp[N][4];
const ll mod = 998244353;
void solve()
{
ll h,w,k;
cin >> h >> w >> k;
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
if(x1 == x2 && y1 == y2) dp[0][3] = 1;
else if(x1 == x2) dp[0][2] = 1;
else if(y1 == y2) dp[0][1] = 1;
else dp[0][0] = 1;
//3 :行列都相同，2：行相同 1：列相同 0：行列都不同
rep(i,1,k) {
dp[i][3] = dp[i - 1][2] + dp[i - 1][1];
dp[i][2] = dp[i - 1][2] * (w - 2) % mod + dp[i - 1][0] + dp[i - 1][3] * (w - 1) % mod;
dp[i][1] = dp[i - 1][1] * (h - 2) % mod + dp[i - 1][0] + dp[i - 1][3] * (h - 1) % mod;
dp[i][0] = dp[i - 1][2] * (h - 1) % mod + dp[i - 1][1] * (w - 1) + dp[i - 1][0] * (w - 2) % mod + dp[i - 1][0] * (h - 2) % mod;
rep(j,0,3) dp[i][j] %= mod;
}
cout << dp[k][3];
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
int T = 1;
// cin >> T;
while(T --) solve();
return 0;
}F - Simple Operations on Sequence (atcoder.jp)
（1）题意
给你一个长度为N的A序列和一个长度为N的B序列，你每次可以对A的一个元素进行加1或减1，这个操作一次花费X元，你也可以对A的一个元素i进行交换，交换A[i]和A[i + 1]，这个操作花费Y元，问你使得A序列变成B序列的最小花费是多少？
（2）思路
考虑N不大，我们直接进行状压dp，dp[i]表示i这个点集我已经匹配了多少个A序列的位置，匹配了B的哪些位置需要的最小花费。
那么考虑转移首先枚举我要放的位置（也就是A未匹配的位置），我们把A[j]这个元素放到z这个位置上去，考虑前面已经放了met个，那么你一定需要交换met次。
最终输出dp[(1 << N) - 1]即可。
（3）代码
#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 20;
ll dp[1 << N];
int a[N],b[N];
void solve()
{
ll n,X,Y;
cin >> n >> X >> Y;
rep(i,0,n - 1) cin >> a[i];
rep(i,0,n - 1) cin >> b[i];
memset(dp,0x3f,sizeof(dp));
dp[0] = 0;
for(int i = 0;i < (1 << n);i ++) {
int z = __builtin_popcount(i),met = 0;
for(int j = n - 1;j >= 0;j --) {
if(!(i >> j & 1)) {
dp[i | (1 << j)] = min(dp[i | 1 << j],dp[i] + 1ll * abs(a[j] - b[z]) * X + 1ll * met * Y);
}
else met ++;
}
}
cout << dp[(1 << n) - 1];
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
int T = 1;
// cin >> T;
while(T --) solve();
return 0;
}G - Modulo Shortest Path (atcoder.jp)
（1）题意
给你两个序列A和B，你有一条从i->j的权值为(A[i] + B[j]) % M的边，问你从1走到N的最短路径是多长。
（2）思路
考虑暴力，我们建边都要N^2，显然不可行，考虑优化建边。
对于A序列我们把i向M - A[i]连一条权值为0的边，对于B序列我们把B[i]向i连一条权值为0的边，对于[0,M - 1]把0->1,1->2.....M - 2->M - 1连一条权值为1的边，这样图就变成了这样。
为什么要向M-A[i]连边而不是向A[i]连边呢？我们考虑分类讨论一下，画一下横坐标就行了。
好，现在我们的建边从N^2变成了2*N+M,显然M太大过不了，那么考虑其实有些边是用不到的，比如说0-1->2->3->4->5，难道我真要一步步跳过去？显然不可能，我们可以直接压缩成0->5。那哪些模数要用到呢，实际上就是我们建边用的M - a[i]和b[i],从小的向大的连一下即可，然后跑一个最短路就做完了。
（3）代码
#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 6e5 + 10;
vector<PII> e[N];
int a[N],b[N];
ll dis[N];
vector<int> ver;
int get(int x)
{
return lower_bound(all(ver),x) - ver.begin() + 1;
}
inline ll dij(int s,int t)
{
memset(dis,0x3f,sizeof(dis));
dis[s] = 0;
priority_queue<pair<ll,int>,vector<pair<ll,int>>,greater<pair<ll,int>>> q;
q.push({dis[s],s});
while(!q.empty()) {
auto [val,u] = q.top();
q.pop();
for(auto [v,w]: e[u]) {
if(dis[v] > val + w) {
dis[v] = val + w;
q.push({dis[v],v});
}
}
}
return dis[t];
}
void solve()
{
int n,m;
cin >> n >> m;
rep(i,1,n) {
cin >> a[i];
a[i] = (m - a[i]) % m;
ver.pb(a[i]);
}
rep(i,1,n) {
cin >> b[i];
ver.pb(b[i]);
}
sort(all(ver));
rep(i,1,n) {
a[i] = get(a[i]);
b[i] = get(b[i]);
e[i + sz(ver)].pb({a[i],0});
e[b[i]].pb({i + sz(ver),0});
}
rep(i,1,sz(ver) - 1) {
e[i].pb({i + 1,ver[i] - ver[i - 1]});
}
e[sz(ver)].pb({1,(ver[0] -ver[sz(ver) - 1] + m) % m});
cout << dij(1 + sz(ver),n + sz(ver));
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
int T = 1;
// cin >> T;
while(T --) solve();
return 0;
}
