方法思路

这道题目要求构造一个二阶行列式，使其值等于给定的整数x，且行列式中的四个数都是不超过20的正整数。

二阶行列式的计算公式为：|a b; c d| = ad - bc = x

基于参考代码，我们可以采用枚举和哈希表的方式来解决：

1. 先枚举所有可能的乘积对(ad, bc)，使得ad - bc = x
   • 这等价于寻找ad = bc + x
   • 由于a、b、c、d都不超过20，所以我们可以枚举所有可能的乘积
2. 使用哈希表存储所有可能的乘积及其对应的一个乘数
   • key为乘积(i*j)，value为其中一个乘数(i)
3. 遍历哈希表，对于每个条目(A = ad)，检查是否存在另一个乘积(B = bc)使得A - B = x
   • 如果找到了这样的乘积对，就可以构造出满足条件的行列式

代码实现

Java

import java.util.*;
import java.util.Map.Entry;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int target = scanner.nextInt();
        
        // 用map来存储所有可能的乘积及其因子
        // key是乘积(i*j)，value是其中一个乘数(i)
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 1; i <= 20; i++) {
            for (int j = 1; j <= 20; j++) {
                map.put(i * j, i);
            }
        }
        
        // 行列式 |a b; c d| = a*d - b*c = target
        // 即 a*d = b*c + target
        for (Entry<Integer, Integer> entry : map.entrySet()) {
            // A是乘积a*d，查找是否存在B=b*c使得A=B+target
            int A = entry.getKey();
            int B = A - target;  // B = A - target，即 B = a*d - target = b*c
            
            // 检查是否存在乘积B=b*c
            if (B > 0 && map.containsKey(B)) {
                // 找到符合条件的乘积对
                int a = entry.getValue();     // a是A的一个因子
                int d = A / a;                // 计算d
                int b = map.get(B);           // b是B的一个因子
                int c = B / b;                // 计算c
                
                // 输出结果
                System.out.println(a + " " + b);
                System.out.println(c + " " + d);
                return;
            }
        }
        
        // 如果找不到满足条件的行列式，输出-1
        System.out.println(-1);
    }
}

Python

def solve(target):
    # 用字典来存储所有可能的乘积及其因子
    # key是乘积(i*j)，value是其中一个乘数(i)
    products = {}
    for i in range(1, 21):
        for j in range(1, 21):
            products[i * j] = i
    
    # 行列式 |a b; c d| = a*d - b*c = target
    # 即 a*d = b*c + target
    for A, a in products.items():
        # A是乘积a*d，查找是否存在B=b*c使得A=B+target
        B = A - target  # B = A - target，即 B = a*d - target = b*c
        
        # 检查是否存在乘积B=b*c
        if B > 0 and B in products:
            # 找到符合条件的乘积对
            d = A // a            # 计算d
            b = products[B]       # b是B的一个因子
            c = B // b            # 计算c
            
            # 输出结果
            print(f"{a} {b}")
            print(f"{c} {d}")
            return
    
    # 如果找不到满足条件的行列式，输出-1
    print(-1)

# 读取输入
target = int(input())
solve(target)

C++

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    int target;
    cin >> target;
    
    // 用哈希表来存储所有可能的乘积及其因子
    // key是乘积(i*j)，value是其中一个乘数(i)
    unordered_map<int, int> products;
    for (int i = 1; i <= 20; i++) {
        for (int j = 1; j <= 20; j++) {
            products[i * j] = i;
        }
    }
    
    // 行列式 |a b; c d| = a*d - b*c = target
    // 即 a*d = b*c + target
    for (const auto& entry : products) {
        // A是乘积a*d，查找是否存在B=b*c使得A=B+target
        int A = entry.first;
        int B = A - target;  // B = A - target，即 B = a*d - target = b*c
        
        // 检查是否存在乘积B=b*c
        if (B > 0 && products.find(B) != products.end()) {
            // 找到符合条件的乘积对
            int a = entry.second;       // a是A的一个因子
            int d = A / a;              // 计算d
            int b = products[B];        // b是B的一个因子
            int c = B / b;              // 计算c
            
            // 输出结果
            cout << a << " " << b << endl;
            cout << c << " " << d << endl;
            return 0;
        }
    }
    
    // 如果找不到满足条件的行列式，输出-1
    cout << -1 << endl;
    return 0;
}