类别分组算法

根据输入的等式和不等式得出分类结果和所有不相等结果

template<typename T>
class ClassifyConflictDectect
{
public:
	ClassifyConflictDectect(const std::set<std::pair<T, T>>& equals = {}, const std::set<std::pair<T, T>> notEquals = {})
		: m_equals(equals), m_notEquals(notEquals)
	{
	}

	void appendEqual(const std::pair<T, T>& equal)
	{
		m_equals.emplace(equal);
	}

	void appendNotEqual(const std::pair<T, T>& notEqual)
	{
		m_notEquals.emplace(notEqual);
	}

	std::map<T, std::shared_ptr<std::set<T>>> clissifyEquals() const
	{
		std::map<T, std::shared_ptr<std::set<T>>> classify;
		for (auto& [e1, e2] : m_equals) {
			auto iter1 = classify.find(e1);
			auto iter2 = classify.find(e2);
			if (iter1 == classify.end() && iter2 == classify.end()) {
				classify[e1] = std::make_shared<std::set<T>>();
				classify[e1]->emplace(e1);
				classify[e1]->emplace(e2);
				classify[e2] = classify[e1];
			}
			else if (iter1 != classify.end() && iter2 == classify.end()) {
				classify[e1]->emplace(e2);
				classify[e2] = classify[e1];
			}
			else if (iter1 == classify.end() && iter2 != classify.end()) {
				classify[e2]->emplace(e1);
				classify[e1] = classify[e2];
			}
			else {
				auto& classifyE1 = classify[e1];
				auto& classifyE2 = classify[e2];
				classifyE1->insert(classifyE2->begin(), classifyE2->end());
				classify[e2] = classifyE1;
			}
		}
		return classify;
	}

	bool isNotEqualsConflict(std::pair<T, T>& conflictNotEqual, std::set<T>& conflictClassify, const std::map<T, std::shared_ptr<std::set<T>>>& classify) const
	{
		for (auto [ne1, ne2] : m_notEquals) {
			if (ne1 == ne2) {
				conflictNotEqual = { ne1, ne2 };
				return true;
			}

			auto equalClassifyiter = classify.find(ne1);
			if (equalClassifyiter != classify.end() && equalClassifyiter->second->count(ne2) > 0) {
				conflictClassify = *equalClassifyiter->second;
				conflictNotEqual = { ne1, ne2 };
				return true;
			}
		}
		return false;
	}

	const std::map<T, std::set<T>> notEquals(const std::map<T, std::shared_ptr<std::set<T>>>& classify) const
	{
		std::map<T, std::set<T>> nEquals;
		for (auto [ne1, ne2] : m_notEquals) {
			nEquals[ne1].emplace(ne2);
			nEquals[ne2].emplace(ne1);
		}
		for (auto& [e, classify] : classify) {
			if (nEquals.find(e) != nEquals.end()) {
				std::set<T> nes = nEquals.at(e);
				for (auto& ne : nes) {
					for (auto& c : *classify) {
						nEquals[c].emplace(ne);
						nEquals[ne].emplace(c);
					}
				}
			}
		}

		return nEquals;
	}

private:
	std::set<std::pair<T, T>> m_equals;
	std::set<std::pair<T, T>> m_notEquals;
};


int main()
{
	auto d = ClassifyConflictDectect<int>({ {1, 2}, {2, 3} }, { {3, 4} });
	auto classify = d.clissifyEquals();
	for (auto& [e1, e2s] : classify) {
		for (auto& e2 : *e2s) {
			std::cout << e1 << " e " << e2 << std::endl;
		}
	}
	auto noEquals = d.notEquals(classify);

	for (auto& [ne1,ne2s] : noEquals) {
		for (auto& ne2 : ne2s) {
			std::cout << ne1 << " ne " << ne2 << std::endl;
		}
	}
}

结果：

1 e 1
1 e 2
1 e 3
2 e 1
2 e 2
2 e 3
3 e 1
3 e 2
3 e 3
1 ne 4
2 ne 4
3 ne 4
4 ne 1
4 ne 2
4 ne 3