请忽略那个奇奇怪怪的注释

#include <bits/stdc++.h>

using namespace std;

//行,列,主副对角线
int row[4], column[4],diagonal[2];
array<array<int,4>,4> puzzle;
array<array<int,4>,4> minx;
struct Node {
    int x, y;
    int maxValue;
};
vector<Node>vec;
bool cmp(const Node x, const Node y) {
    return x.maxValue < y.maxValue;
}
bool check(){
    int sum[4]={0};
    //行和求解
    for(int i=0;i<4;i++) {
        for(int j=0;j<4;j++) {
            sum[i]+=puzzle[i][j];
            if(sum[i]>row[i])return false;
        }
    }
    for(int i=0;i<4;i++)
        if(sum[i]!=row[i])return false;

    //列和求解
    for(int i=0;i<4;i++) {
        for(int j=0;j<4;j++) {
            sum[j]+=puzzle[i][j];
            if(sum[j]>column[j])return false;
        }
    }
    for(int i=0;i<4;i++)
        if(sum[i]!=column[i])return false;

    //对角线求解
    const int sum1 = puzzle[0][0]+puzzle[1][1]+puzzle[2][2]+puzzle[3][3];
    const int sum2 = puzzle[0][3]+puzzle[1][2]+puzzle[2][1]+puzzle[3][0];

    if(sum1!=diagonal[0] || sum2!=diagonal[1])return false;

    return true;
}
int checkPos(int x,int y) {
    if(x==y)return 0;
    if(x==3-y)return 1;
    return -1;
}
//表示当前遍历哪个格子
void dfs(int k) {
    if(k==vec.size()+1) {
        for(auto i:puzzle) {
            for(auto j:i) {
                cout<<j<<' ';
            }
            cout<<endl;
        }
        exit(0);
    }
    else {
        const int x = vec[k].x;
        const int y = vec[k].y;
        int maxValue = min(min(vec[k].maxValue,row[x]),column[y]);
        const int flag = checkPos(x,y);
        if(flag==-1) {
            for(int i=maxValue;i>=0;i--) {
                if(i<=row[x] && i<column[y]) {
                    puzzle[x][y] = i;
                    row[x]-=i;
                    column[y]-=i;
                    dfs(k+1);
                    puzzle[x][y] = 0;
                    row[x]+=i;
                    column[y]+=i;
                }
            }
        }
        else {
            // ReSharper disable once CppDFAArrayIndexOutOfBounds
            maxValue = min(maxValue,diagonal[flag]);
            for(int i=maxValue;i>=0;i--) {
                if(i<=row[x] && i<column[y] && i<diagonal[flag]) {
                    puzzle[x][y] = i;
                    row[x]-=i;
                    column[y]-=i;
                    diagonal[flag]-=i;
                    dfs(k+1);
                    puzzle[x][y] = 0;
                    row[x]+=i;
                    column[y]+=i;
                    diagonal[flag]+=i;
                }
            }
        }
    }
}
int main() {
    for(int i=0;i<4;i++)cin>>row[i];
    for(int i=0;i<4;i++)cin>>column[i];
    for(int i=0;i<2;i++)cin>>diagonal[i];
    for(int i=0;i<4;i++) {
        int x,y,value;
        cin>>x>>y>>value;
        puzzle[x][y]=value;
    }
    //行内最小
    for(int i=0;i<4;i++) {
        int sum = row[i];
        for(int j=0;j<4;j++) {
            sum-=puzzle[i][j];
        }
        for(int j=0;j<4;j++) {
            minx[i][j]=sum;
        }
        row[i] = sum;
    }
    //列内最小
    for(int j=0;j<4;j++) {
        int sum = column[j];
        for(int i=0;i<4;i++) {
            sum-=puzzle[i][j];
        }
        for(int i=0;i<4;i++) {
            minx[i][j]=min(sum,minx[i][j]);
        }
        column[j] = sum;
    }
    //对角线最小
    {
        diagonal[0] = diagonal[0]-(puzzle[0][0]+puzzle[1][1]+puzzle[2][2]+puzzle[3][3]);
        diagonal[1] = diagonal[1]-(puzzle[0][3]+puzzle[1][2]+puzzle[2][1]+puzzle[3][0]);
        for(int i=0;i<4;i++) minx[i][i]=min(diagonal[0],minx[i][i]);
        for(int i=0;i<4;i++) minx[i][3-i]=min(diagonal[1],minx[i][3-i]);
    }
    //生成序列
    for(int i=0;i<4;i++) {
        for(int j=0;j<4;j++) {
            if(!puzzle[i][j]) {
                vec.push_back(Node{i,j,minx[i][j]});
            }
        }
    }
    sort(vec.begin(),vec.end(),cmp);
    dfs(0);
    return 0;
}