离散数学实验，求偏序集中的极小元与极大元
实现功能：给定偏序集A，求解其极小元与极大元
输入：
输入偏序集<A, £>，A中的元素数不超过20个，分别用单个小写的英文字母表示。
输入的第一行给出A中的各个元素，两个相邻的元素之间用逗号隔开。
输入的第二行给出偏序关系£，用有序对的形式给出(只给出哈斯图中的满足覆盖的两个元素形成的有序对)，如<a,b>,<c,a>等等，两个相邻的有序对之间用逗号隔开。
输出：
输出A的极小元与极大元。
输出的第一行给出各个极小元，两个相邻元素之间用逗号隔开，输出的元素要求按照英文字母的自然顺序排列输出。
输出的第二行给出各个极大元，两个相邻元素之间用逗号隔开，输出的元素要求按照英文字母的自然顺序排列输出。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
vector<char> A; // 存储元素集合A
vector<pair<char, char>> relation; // 存储偏序关系
// 输入元素集合A
string a_str;
getline(cin, a_str);
for(char c : a_str)
{
if(islower(c))
{
A.push_back(c);
}
}
// 输入偏序关系
string r_str;
getline(cin, r_str);
for(int i = 0; i < r_str.size();)
{
if(islower(r_str[i])) // 第一个元素
{
char a = r_str[i];
i += 2;
char b = r_str[i];
i += 2;
relation.push_back(make_pair(a, b));
}
else
{
i++;
}
}
// 找出极小元和极大元
vector<char> min_elements, max_elements;
for(char c : A)
{
bool is_min_element = true;
bool is_max_element = true;
for(pair<char, char> r : relation) // 枚举所有偏序关系
{
if(r.second == c)
{
is_min_element = false;
}
if(r.first == c)
{
is_max_element = false;
}
}
if(is_min_element)
{
min_elements.push_back(c);
}
if(is_max_element)
{
max_elements.push_back(c);
}
}
// 按字典序排序并输出结果
sort(min_elements.begin(), min_elements.end());
for(char c : min_elements)
{
cout << c << ",";
}
cout << endl;
sort(max_elements.begin(), max_elements.end());
for(char c : max_elements)
{
cout << c << ",";
}
cout << endl;
return 0;
}
测试样例：
输入：
a,b,c,d,e
<a,b>,<a,c>,<c,d>,<d,e>
输出：
a,
e
- 这个问题的回答你可以参考下: https://ask.csdn.net/questions/7518296
离散数学的应用（C语言实现）
非常详细
可以参考下
https://blog.csdn.net/qq_60545192/article/details/128860324
C实现的求偏序集中的极大元与极小元，大致代码如下，可根据要求修改：
#include<cstdio>
#include<algorithm>
#include<cstring>
#define maxn 1000
#define maxm 10
using namespace std;
char s[maxn]; //储存字符
char re[maxn]; //存储关系
char pos[maxm];
int cnt[27][2]; //标记字母再偏序关系中的位置
char maxs[27]; //存储极大元
char mins[27]; //存储极大元
void setcnt() {
cnt[pos[1] - 'a'][0] = 1;
cnt[pos[3] - 'a'][1] = 1;
}
void setoutput() {
int l = strlen(s);
int i1 = 0,i2 = 0;
for (int i = 0;i < l;i++) {
if (s[i] >= 'a'&&s[i] <= 'z') {
if (cnt[s[i] - 'a'][0] == 1 && cnt[s[i] - 'a'][1] == 0) mins[i1++] = s[i];
if (cnt[s[i] - 'a'][0] == 0 && cnt[s[i] - 'a'][1] == 0) {
mins[i1++] = s[i];
maxs[i2++] = s[i];
}
if (cnt[s[i] - 'a'][0] == 0 && cnt[s[i] - 'a'][1] == 1) maxs[i2++] = s[i];
}
}
}
void output1() {
int l = strlen(mins);
for (int i = 0;i < l - 1;i++) printf("%c,", mins[i]);
printf("%c\n", mins[l - 1]);
}
void output2() {
int l = strlen(maxs);
for (int i = 0;i < l - 1;i++) printf("%c,", maxs[i]);
printf("%c\n", maxs[l - 1]);
}
int main() {
for (int i = 0;i < 27;i++) {
cnt[i][0] = 0;
cnt[i][1] = 0;
} //对cnt数组初始化
scanf("%s", s);
scanf("%s", re);
int l = strlen(re);
int post;
for (int i = 0;i < l;i++) { //分别对每一对偏序关系进行处理
if (re[i] == '<') {
post = 0;
pos[post++] = re[i];
}
else if ((re[i] >= 'a'&&re[i] <= 'z')||(re[i]==','&&re[i-1]!='<')) {
pos[post++] = re[i];
}
else if (re[i] == '>') {
pos[post] = re[i];
post = 0;
setcnt();
}
}
setoutput(); //将结果保存
output1();
output2();
return 0;
}
引用chatgpt内容作答：
运行结果：
下面是一个用C++实现的程序，可以求解给定偏序集的极小元和极大元：
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
int main() {
vector<char> elements;
set<pair<char, char>> partialOrder;
set<char> minimalElements;
set<char> maximalElements;
// 输入A中的元素
string elementsStr;
getline(cin, elementsStr);
for (int i = 0; i < elementsStr.length(); i += 2) {
elements.push_back(elementsStr[i]);
}
// 输入偏序关系£
string partialOrderStr;
getline(cin, partialOrderStr);
for (int i = 0; i < partialOrderStr.length(); i += 6) {
char x = partialOrderStr[i + 1];
char y = partialOrderStr[i + 3];
partialOrder.insert(make_pair(x, y));
}
// 检查每个元素是否为极小元和极大元
for (char element : elements) {
bool isMinimal = true;
bool isMaximal = true;
for (auto relation : partialOrder) {
if (relation.first == element && relation.second == element) {
isMinimal = false;
isMaximal = false;
break;
}
if (relation.first == element) {
isMinimal = false;
}
if (relation.second == element) {
isMaximal = false;
}
}
if (isMinimal) {
minimalElements.insert(element);
}
if (isMaximal) {
maximalElements.insert(element);
}
}
// 输出极小元
for (char minimalElement : minimalElements) {
cout << minimalElement << ",";
}
cout << endl;
// 输出极大元
for (char maximalElement : maximalElements) {
cout << maximalElement << ",";
}
cout << endl;
return 0;
}
你可以将输入偏序集的元素和偏序关系按照要求输入，然后程序将输出极小元和极大元。注意，输出的元素会按照英文字母的自然顺序排列。
戳我博客，里面有例子参考
回答部分参考、引用ChatGpt以便为您提供更准确的答案：
根据题目描述，我们需要找出给定偏序集A的极小元和极大元。偏序集是一个集合，其中的元素之间存在偏序关系£，即部分有序关系。
以下是一个示例的Python代码，用于找出偏序集A的极小元和极大元：
# 获取极小元
def get_minimal_elements(A, relations):
minimal_elements = []
for element in A:
is_minimal = True
for relation in relations:
if relation[1] == element:
is_minimal = False
break
if is_minimal:
minimal_elements.append(element)
return minimal_elements
# 获取极大元
def get_maximal_elements(A, relations):
maximal_elements = []
for element in A:
is_maximal = True
for relation in relations:
if relation[0] == element:
is_maximal = False
break
if is_maximal:
maximal_elements.append(element)
return maximal_elements
# 主程序入口
if __name__ == '__main__':
# 输入偏序集A和偏序关系£
A = input("请输入偏序集A中的元素，用逗号隔开：").split(",")
relations = []
while True:
relation_input = input("请输入偏序关系£，用逗号隔开（输入-1结束）：")
if relation_input == "-1":
break
relation = tuple(relation_input.split(","))
relations.append(relation)
# 获取极小元和极大元
minimal_elements = get_minimal_elements(A, relations)
maximal_elements = get_maximal_elements(A, relations)
# 输出结果
print("极小元：", ",".join(sorted(minimal_elements)))
print("极大元：", ",".join(sorted(maximal_elements)))
以上代码实现了根据输入的偏序集A和偏序关系£，找出偏序集的极小元和极大元。代码中使用两个函数get_minimal_elements和get_maximal_elements分别查找极小元和极大元，并按照英文字母的自然顺序进行排序后输出。
请注意，代码中假设输入的偏序集元素和偏序关系都是有效的，并且偏序关系是部分有序关系。对于无效或不符合条件的输入，代码并没有进行错误处理。