poj.org 部分答案（二）

2336

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
class Solution {
public:
    Solution() {
        std::cin >> n;
        number1 = new int[n];
        for (int i = 0; i < n; i++) scanf("%d", &number1[i]);
        std::cin >> m;
        number2 = new int[m];
        for (int i = 0; i < m; i++)  scanf("%d", &number2[i]);
    }
    int binarySearch(int arr[], int target, int left, int right) {
        if (left <= right) {
            int mid = (left + right) / 2;
            if (arr[mid] == target) {
                return 1;
            }
            else if (arr[mid] < target) {
                return binarySearch(arr, target, mid + 1, right); // 修正更新边界值
            }
            else {
                return binarySearch(arr, target, left, mid - 1); // 修正更新边界值
            }
        }
        return 0;
    }
    void solve() {
        bool found = false; // 添加一个变量来标记是否找到匹配的数字对
        for (int i = 0; i < m; i++) {
            if (binarySearch(number1, 10000 - number2[i], 0, n - 1)) {
                std::cout << "YES"; // 添加换行符
                found = true; // 标记找到匹配的数字对
                break; // 找到即可跳出循环
            }
        }
        if (!found) {
            std::cout << "NO"; // 如果没有找到匹配的数字对，输出 "NO"
        }
    }
    int n, m;
    int* number1, * number2;
};
 
int main()
{
    Solution a;
    a.solve();
    return 0;
}

2503

#include 
#include 
#include 
#include 
 
class Solution {
private:
    std::map dictionary;
 
    // 解析输入行并更新字典的私有辅助函数
    void parseAndUpdateDictionary(const std::string& str) {
        std::string str1, str2;
 
        for (size_t i = 0; i < str.size(); i++) {
            if (str[i] == ' ') {
                str1 = str.substr(0, i);
                str2 = str.substr(i + 1);
                break;
            }
        }
 
        dictionary[str2] = str1;
    }
 
public:
    // 构造函数，初始化字典
    Solution() {}
 
    // 读取字典输入并初始化字典的公有方法
    void readDictionary() {
        std::string str;
 
        while (std::getline(std::cin, str) && !str.empty()) {
            parseAndUpdateDictionary(str);
        }
    }
 
    // 翻译外语单词的公有方法
    void translateWords() {
        std::string word;
 
        while (std::cin >> word) {
            if (!dictionary[word].empty()) {
                std::cout << dictionary[word] << std::endl;
            }
            else {
                std::cout << "eh\n";
            }
        }
    }
};
 
int main() {
    // 创建 Solution 对象
    Solution solution;
 
    // 读取字典输入并初始化字典
    solution.readDictionary();
 
    // 翻译外语单词
    solution.translateWords();
 
    return 0;
}
 

3714 

#include
#include
#include
#include
using namespace std;
struct node
{
	double x;
	double y;
	int type;
}a[200005];
int n;
vector temp;
bool cmp1(node &a,node &b)
{
	return a.x
}
bool cmp2(node &a,node &b)
{
	return a.y
}
double solve(int l,int r)
{
	if(l==r) return 100000000000;
	if(l==r-1&&a[l].type!=a[r].type)
	{
		return sqrt(pow(fabs(a[l].x-a[r].x),2)+pow(fabs(a[l].y-a[r].y),2));
	}
	if(l==r-1&&a[l].type==a[r].type) 
	{
		return 100000000000;
	}
	int mid = l + r >> 1;
    double d1 = solve(l, mid);
    double d2 = solve(mid + 1, r);
    double d = min(d1, d2);
	int i;
	for(i=l;i<=r;i++)
	{
		if(fabs(a[i].x-a[mid].x)push_back(a[i]);
	}
	sort(temp.begin(),temp.end(),cmp2);
	int j;
	for(i=0;isize();i++)
	{
		for(j=i+1;jsize()&&temp[j].y-temp[i].y
		{
			if(temp[i].type==temp[j].type) continue;
			double d3=sqrt(pow(fabs(temp[i].x-temp[j].x),2)+pow(fabs(temp[i].y-temp[j].y),2));
			d=min(d,d3);
		}
	}
	temp.clear();
	return d;
}
int main()
{
	int t;
	int i;
	cin>>t;
	while(t--)
	{
		int n;
		cin>>n;
		for(i=1;i<=n;i++)
		{
			cin>>a[i].x>>a[i].y;
			a[i].type=1;
		}
		for(i=n+1;i<=2*n;i++)
		{
			cin>>a[i].x>>a[i].y;
			a[i].type=2;
		}
		sort(a+1,a+2*n+1,cmp1);
		double ans=solve(1,2*n);
		printf("%.3lf\n",ans);
	}
	return 0;
}