ssh-keygen -t rsa -C "你的邮箱地址"

Enter file in which to save the key (/Users/aaaa/.ssh/id_rsa):

Host github.com
User 你的名字
IdentityFile ~/.ssh/id_rsa

Host gitlab.com
User 你的名字
IdentityFile ~/.ssh/csdn_rsa

/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int min = 0x3f3f3f3f;
#define ff(a, b, c, d) for(int a=b; a<c; a+=d)
#define mm(a, b)       memset(a, b, sizeof(a))
namespace BFS {
    int n, m;
    char maps[505][505];
    bool vis[505][505] = {false};
    int ans[505][505] = {0};
    int sx, sy, ex, ey;
    int dis[4][2] = {-1,0,0,-1,1,0,0,1};//0左1上2右3下
    struct node {
        int x, y;
        int cnt;
        node(int _x, int _y, int _cnt):x(_x),y(_y),cnt(_cnt){}
    };
    bool check(int x, int y) {
        if(x<0 || x>=n || y<0 || y>=m)
            return false;
        return maps[x][y] != '#';
    }
    void init() {
        cin >> n >> m;
        ff(i, 0, n, 1)
            ff(j, 0, m, 1) {
                cin >> maps[i][j];
                if(maps[i][j]=='S')
                    sx=i, sy=j;
                else if(maps[i][j]=='T')
                    ex=i, ey=j;
            }
    }
    int bfs() {
        vis[sx][sy] = true;
        queue<node> q;
        q.push({sx, sy, 0});

        while(!q.empty()) {
            node now = q.front();
            q.pop();

            ff(i, 0, 4, 1) {
                //cout << now.x << " " << now.y << endl;
                int x = now.x + dis[i][0];
                int y = now.y + dis[i][1];
                //cout << x << " " << y << endl;
                if(!check(x, y))
                    continue;
                if(maps[x][y] == 'T')
                    return now.cnt;
                while(check(x+dis[i][0], y+dis[i][1])) {
                    x += dis[i][0];
                    y += dis[i][1];

                    if(x==ex && y==ey)
                        return now.cnt;
                }
                if(!vis[x][y]) {
                    int cnt = now.cnt + 1;
                    q.push((node){x, y, cnt});
                    vis[x][y] = true;
                }
            }
        }
        return -1;
    }
}
using namespace BFS;
void intxt() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
}
int main() {
    intxt();
    init();
//    cout << n << " " << m << endl;
//    ff(i, 0, n, 1) {
//        ff(j, 0, m, 1)cout << maps[i][j];
//        cout << endl;
//    }
//    cout << sx << " " << sy << endl
//         << ex << " " << ey << endl;
    cout << bfs() << endl;
    return 0;
}

Writting...

/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int min = 0x3f3f3f3f;
#define ff(a, b, c, d) for(int a=b; a<c; a+=d)
#define mm(a, b)       memset(a, b, sizeof(a))

typedef struct node{
    int x, y, sum;
};
char maps[105][105];
int vis[105][105][1<<6];
int dis[4][2] = {-1,0,0,-1,1,0,0,1};
int n, m, k, sx, sy, ex, ey;
vector<pair<int, int>> keys;
bool check(int x, int y) {
    if(x<0 || x>=n || y<0 || y>=n)
        return false;
    if(maps[x][y]=='#')
        return false;

    return true;
}
int bfs() {
    mm(vis, 0);
    vis[sx][sy][0] = 0;
    queue <node> q;
    q.push((node){sx, sy, 0});

    while(!q.empty()) {
        node now = q.front();
        q.pop();
        if(now.x==ex && now.y==ey)
            return vis[now.x][now.y][now.sum];

        ff(i, 0, 4, 1) {
            int nx = now.x+dis[i][0];
            int ny = now.y+dis[i][1];
            if(!check(nx, ny))
                continue;
            if(maps[nx][ny]=='.' && vis[nx][ny][now.sum]==0) {
                vis[nx][ny][now.sum] = vis[now.x][now.y][now.sum]+1;
                q.push((node){nx, ny, now.sum});
            } else if(isdigit(maps[nx][ny])) {
                int sum = now.sum|(1<<(maps[nx][ny]-'0'));
                if(vis[nx][ny][sum])
                    continue;
                vis[nx][ny][sum] = vis[now.x][now.y][now.sum] + 1;
                q.push((node){nx, ny, sum});
            } else if(isupper(maps[nx][ny])) {
                if(now.sum&(1<<(maps[nx][ny]-'A')) && vis[nx][ny][now.sum]==0) {
                    vis[nx][ny][now.sum] = vis[now.x][now.y][now.sum]  + 1;
                    q.push((node){nx, ny, now.sum});
                }
            }
        }
    }
    return -1;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    cin >> n >> m >> k >> sx >> sy >> ex >> ey;
    ff(i, 0, n, 1)
        ff(j, 0, m, 1)
            cin >> maps[i][j];

    ff(i, 0, k, 1) {
        int x, y;
        cin >> x >> y;
        keys.push_back({x, y});
        maps[x][y] = '0' + i;
    }
    cout << bfs() << endl;
    return 0;
}

Writting...

/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki4294967295.cn/
*/
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int min = 0x3f3f3f3f;
#define ff(a, b, c, d) for(int a=b; a<c; a+=d)
#define mm(a, b)       memset(a, b, sizeof(a))


int N;
map<int, int> cnt;
typedef pair<int, int> p;
set<p, greater<p> > s;


int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    cin >> N;
    int x;
    ff(i, 0, N, 1) {
        cin >> x;
        cnt[x]++;
    }

    for(auto& x : cnt) {
        s.insert({x.second, -x.first});
    }

//    for(auto&x : cnt) {
//        cout << x.first << " " << x.second << endl;
//    }

    if(s.begin()->first > (N-1)/2+1) {
        cout << "-1" << endl;
        return 0;
    }
    //cout << "out : " << N << endl;
    for(int res, pre=0; N--; pre=res) {
        //cout << N << endl;
        int temp = s.begin()->first;
        if(temp > (N-1)/2+1) {
            auto it = s.begin();
            if(it->second == pre)
                it++;
            res = -it->second;
            if(it->first==1)
                cnt.erase(res);
            else {
                s.insert({it->first-1, it->second});
                cnt[res]--;
            }
            s.erase(it);
        } else {
            auto it = cnt.begin();
            if(it->first==pre)
                it++;
            res = it->first;
            s.erase({it->second, -res});
            if(it->second==1)
                cnt.erase(it);
            else {
                it->second--;
                s.insert({it->second, -res});
            }
        }
        cout << res << ' ';
    }
    cout << endl;
    return 0;
}

Writting...

/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int min = 0x3f3f3f3f;
#define ff(a, b, c, d) for(int a=b; a<c; a+=d)
#define mm(a, b)       memset(a, b, sizeof(a))

string input;
int cnt[26] = {0};

bool check(int x) {
    ff(i, 0, 26, 1)
        if(cnt[i]>(x-1)/2+1)
            return false;
    return true;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    cin >> input;
    int len = input.size();
    //cout << len << endl;
    ff(i, 0, len, 1)
        cnt[input[i]-'a']++;
    if(!check(len)) {
        cout << "INVALID" << endl;
        return 0;
    }
/*
    int pre = -1;
    ff(i, 0, len, 1) {
        ff(j, 0, 26, 1) {
            if(cnt[j]>0 && j!=pre) {
                cnt[j]--;
                if(check(len-1)) {
                    putchar('a'+j);
                    pre = j;
                    len--;
                    break;
                } else cnt[j]++;
            }
        }
    }
*/

    int pre = -1;
    ff(i, 0, input.size(), 1) {
        ff(j, 0, 26, 1) {
            if(cnt[j] && j!=pre) {
                cnt[j]--;
                if(check(len-1)) {
                    putchar('a'+j);
                    pre=j;
                    len--;
                    break;
                }
                else cnt[j]++;
            }
        }
    }
    cout << endl;
    return 0;
}

Writing...

/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <map>
#include <set>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>

using namespace std;
typedef long long LL;
const int min = 0x3f3f3f3f;
#define mp make_pair
namespace Geometry {
    struct Point {
        int x, y;
        Point() {}
        Point(int _x, int _y):x(_x), y(_y) {};

        bool operator < (const Point& p) const {
            //优先判断横坐标
            if(x<p.x || (x==p.x&&y<p.y))
                return true;
            return false;
        }

        bool operator == (const Point p) const {
            return (x==p.x && y==p.y);
        }
    };

    struct Line {
        Point a, b;
        double dis;
        double k;
        Line() {}
        Line(Point _a, Point _b):a(_a), b(_b) {
            dis = sqrt((_a.x-_b.x)*(_a.x-_b.x) + (_a.y-_b.y)*(_a.y-_b.y));
        }
    };

    struct Vector {
        Point a, b;
        double dis;
        Vector() {}
        Vector(Point _a, Point _b):a(_a), b(_b) {
            dis = sqrt((_a.x-_b.x)*(_a.x-_b.x) + (_a.y-_b.y)*(_a.y-_b.y));
        }
    };
}
using namespace Geometry;
bool JudgePoint(Line *l) {
    set<Point> p;
    for(int i=0; i<4; ++i) {
        p.insert(l[i].a);
        p.insert(l[i].b);
    }
    return (p.size() == 4);
}
bool JudgeRect(Line *l) {
    for(int i=1; i<4; ++i) {
        //判断是否垂直
        if((l[0].a.y-l[0].b.y)*(l[i].a.y-l[i].b.y) == -(l[0].a.x-l[0].b.x)*(l[i].a.x-l[i].b.x))
            continue;
        //判断是否平行
        if((l[0].a.y-l[0].b.y)*(l[i].a.x-l[i].b.x) == (l[0].a.x-l[0].b.x)*(l[i].a.y-l[i].b.y))
            continue;
        return false;
    }
    return true;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int T;
    cin >> T;
    while(T--) {
        Line l[4];
        int tmp1, tmp2, tmp3, tmp4;
        for (int i = 0; i < 4; ++i) {
            cin >> l[i].a.x >> l[i].a.y >> l[i].b.x >> l[i].b.y;
        }
        if(!JudgePoint(l)) {
            cout << "NO" << endl;
            continue;
        } else if(!JudgeRect(l)) {
            cout << "NO" << endl;
            continue;
        } else cout << "YES" << endl;
    }
    return 0;
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    /*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        int[][] mat = new int[4][4];
        while(T-- > 0) {
            for(int i=0; i<4; ++i) {
                for(int j=0; j<4; ++j) {
                    mat[i][j] = in.nextInt();
                }
            }
            if(!judgePoint(mat)) {
                System.out.println("NO");
                continue;
            }
            if(!judgeRect(mat))
                System.out.println("NO");
            else System.out.println("YES");
        }
        in.close();
    }

    public static boolean judgePoint(int[][] mat) {
        List<String> points = new ArrayList<String>();
        for(int i=0; i<4; ++i) {
            for(int j=0; j<4; j+=2) {
                String point = String.valueOf(mat[i][j]) + "," + String.valueOf(mat[i][j+1]);
                if(!points.contains(point)) {
                    points.add(point);
                }
            }
        }
        return (points.size() == 4);
    }

    public static boolean judgeRect(int[][] mat) {
        for(int i=1; i<4; ++i) {
            //判断是否垂直
            if((mat[0][1]-mat[0][3])*(mat[i][1]-mat[i][3]) == -(mat[0][0]-mat[0][2])*(mat[i][0]-mat[i][2])){
                continue;
            }
            //判断是否平行
            if((mat[0][1]-mat[0][3])*(mat[i][0]-mat[i][2]) == (mat[0][0]-mat[0][2])*(mat[i][1]-mat[i][3])) {
                continue;
            }
            return false;
        }
        return true;
    }
}