abc 371 C

 由于提供的边费用 a(x, y) 中一定 x < y
 当 G 中的边对应 H 中的边时，可能边的两个端点 x > y
 需要 swap(x, y) 一下再计算
 否则记录边费用的 a(x, y) 为初始值 0，这个就是坑点
 以上问题是用 set 在此题存边的弊端
 当然，可以用矩阵方法表示边，不存在序号的问题了

abc 288、287 C

都是并查集的应用，也就是判断成环条件是两个同一集合的点相连
其中 287 对路径图有自己的定义，形成的图是一条线才能叫路径图

abc 277 C

//在主函数内建立递归的函数
std::function<void(int)> dfs = [&](int x) {
    vis.insert(x);
    ans = std::max(ans, x);
    for (auto y : adj[x]) {
        if (!vis.count(y)) {
            dfs(y);
        }
    }
};

abc 275 C

//jls用了这种方法判定正方形，这样挺高效的
int dx = x2 - x1;
int dy = y2 - y1;
if (!dx && !dy) {
    continue;
}
if (check(x1, y1) && check(x2, y2) && check(x2 - dy, y2 + dx) && check(x1 - dy, y1 + dx)) {
    ans++;
}
// 以下为我的代码，用了向量的方法
// 但由于每条边有两个向量，每个正方形有四条边，答案需要除以8
#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> PII;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string s[9];
    for (int i = 0; i < 9; i ++) cin >> s[i];
    int n = 9;
    set<PII> q;
    for (int i = 0; i < n; i ++) 
        for (int j = 0; j < n; j ++) 
            if (s[i][j] == '#') q.insert({i, j});

    long long ans = 0;
    for (auto i : q)
    {
        for (auto j : q)
        {
            if (i == j) continue;
            int x = i.first, y = i.second;
            int dx = i.first - j.first, dy = i.second - j.second;
            int a = x, b = y;
            int c = dx, d = dy;
            for (int k = 0; k < 3; k ++) 
            {
                swap(c, d);
                d = -d;
                a += c, b += d;
                if (!q.count({a, b})) break;
                if (k == 2)
                {
                    ans ++ ;
                }
            }
            a = x, b = y;
            c = dx, d = dy;
            for (int k = 0; k < 3; k ++) 
            {
                swap(c, d);
                c = -c;
                a += c, b += d;
                if (!q.count({a, b})) break;
                if (k == 2)
                {
                    ans ++ ;
                }
            }
        }
    }

    cout << ans / 8 << endl;

    return 0;
}