UVa 10571 Products

考虑使用回溯法（暴力搜索）解题。

以行为序进行搜索。从第 $1$ 行开始，将第 $i$ 行给定的值 $Y_i$ 分解为两个不同的数 $a$ 和 $b$，然后选择两个不同的列，将这个两个数分配到这两列中。因为需要满足二维数组中的数互不相同，在分解 $Y_i$ 时，已经使用的数不能再次使用，所以需要标记已经使用的数。与此同时，同一列分配的数必须恰好是两个（不能多，不能少），因此需要记录第 $i$ 列已经分配的数的数量以及数的值，当第 $i$ 列已经分配了一个数，拟将再次分配一个数给该列时，需要检查这两个数的积是否为第 $i$ 列所给定的数 $X_i$。

具体细节请参考代码中的注释。

#include <bits/stdc++.h>

using namespace std;
// n，二维数组的大小
// cln，记录某列分配的两个数所在的行序号（从 0 开始计数）
// row，记录某行分配的两个数所在的列序号（从 0 开始计数）
// cv，记录某列分配的两个数的数值
// rv，记录某行分配的两个数的数值
// cnt，记录某列已经分配的数的数量
int n, cln[16][2], row[16][2], cv[16][2], rv[16][2], cnt[16];
// found，标记搜索是否已经找到可行的方案
// used，标记某个数是否已经被使用
int found, used[1024];
// X，列对应的值
// Y，行对应的值
int X[16], Y[16];
// 预先将行对应的值分解为两个不同的数
vector<pair<int, int>> y[16];

// 暴力搜索所有可能的方案
void dfs(int idx) {
    // 如果发现一种可行的方案即退出搜索过程
    if (found) return;
    // 当回溯进入第 n 层，表明找到了可行解，予以输出
    if (idx == n) {
        int g[16][16] = {0};
        for (int i = 0; i < n; i++) {
            g[i][row[i][0]] = rv[i][0];
            g[i][row[i][1]] = rv[i][1];
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j) cout << ' ';
                cout << g[i][j];
            }
            cout << '\n';
        }
        cout << '\n';
        found = 1;
        return;
    }
    // 将相乘得到 Yi 的两个不同的数分配到不同的两列中
    for (auto p : y[idx]) {
        for (int i = 0; i < n; i++) {
            if (X[i] % p.first != 0) continue; // 剪枝：第 i 列分配的数必须能够整除 Xi
            if (cnt[i] > 1) continue; // 剪枝：第 i 列分配的数恰好两个
            if (used[p.first]) continue; // 剪枝：分配给该列的数必须尚未使用
            if (cnt[i] && cv[i][0] * p.first != X[i]) continue; // 剪枝：如果该列已经分配一个数，则当前分配的数与已经分配的数之积必须等于 Xi
            for (int j = i + 1; j < n; j++) {
                if (X[j] % p.second != 0) continue; // 剪枝：同前
                if (cnt[j] > 1) continue; // 剪枝：同前
                if (used[p.second]) continue; // 剪枝：同前
                if (cnt[j] && cv[j][0] * p.second != X[j]) continue; // 剪枝：同前
                row[idx][0] = i, row[idx][1] = j; // 记录第 idx 行的两个数分配到哪两列
                rv[idx][0] = p.first, rv[idx][1] = p.second; // 记录第 idx 行分配了哪两个数
                cln[i][cnt[i]] = idx, cln[j][cnt[j]] = idx; // 记录第 i 列、第 j 列所分配的数所在的行
                cv[i][cnt[i]] = p.first, cv[j][cnt[j]] = p.second; // 记录第 i 列和第 j 列分配的数
                cnt[i]++, cnt[j]++; // 第 i 列、第 j 列 已分配的数增加 1
                used[p.first] = used[p.second] = 1; // 标记已经使用的数 
                dfs(idx + 1); // 回溯进入下一层
                cnt[i]--, cnt[j]--; // 回退，第 i 列、第 j 列已分配的数减少 1
                used[p.first] = used[p.second] = 0; // 回退，消除已使用的数标记
            }
        }
    }
}

int main(int argc, char *argv[]) {
    cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
    while (cin >> n, n) {
        for (int i = 0; i < n; i++) cin >> X[i];
        for (int i = 0; i < n; i++) {
            cin >> Y[i];
            // 预先将 Yi 拆分为两个不同数的积
            y[i].clear();
            for (int j = 1; j <= Y[i]; j++)
                if (Y[i] % j == 0 && j != Y[i] / j)
                    y[i].push_back(make_pair(j, Y[i] / j));
        }
        // 清空标记
        memset(cnt, found = 0, sizeof cnt);
        memset(used, 0, sizeof used);
        // 回溯法解题
        dfs(0);
    }
    return 0;
}