这几天提问和回答的人都比较少，来一个一般难度的题目刺激一下。

[寻开心]

假定有一组数据，数据之间存在一个比较关系，大于，小于或者是等于
给一个排序算法，把他们按照顺序排列起来。

例如数据A和B可能是相等，但是A>C, C>B，要求排列的结果是
A C B（降序）或者 B C A（升序）的均当作有效。

要求给出算法描述和计算量分析。
排序最快的另外开帖子，多给100分。

提示：题目要求和前段时间的一个题目类似。

[loewe]

a=b b>c 无法得到 a>c
a=b b<c 也无法得到 a<c

这怎么理解的？

[loewe]

以前有道没做出的ACM题和这个差不多，大意是给出几组大小关系，然后输出他们之间存在的其他关系，比如：
input:
A<B
C>B
C<D
the output is:
A<C
A<D
B<D
另一个测试数据：
input:
A<B
C<D
output:
none

我想这个题目和楼主出的题目类型一样吧

[MaiCle]

1、A=B， A>C, C>B， =》 A>C>B

2、
a=b b>c 无法得到 a>c
a=b b<c 也无法得到 a<c

-----------------------------
敢问楼主是来寻开心的？

[zhbin99]

同意上面二位大虾说的拓扑排序的方法。
不敢不坦白说我发这篇帖子的目的是为了一些分数，其实主要思路还是上面二位大虾的。：）

算法形象的说是可以构造有向图G，每个数据上G中的节点。
如果A>B,则G中存在从A指向B的有向弧AB。
如果A＝B，则G中A、B之间不存在弧。
拓扑排序就是从G中找出入度为0的节点，放入目标集中，同时将该节点以及与该节点有关的所有弧从G中删去，重新找出入度为0的节点，加入到目标集末尾，删去该节点...，重复操作，直到G为空集。

一般的算法的复杂度应该是O((n!)^2) ?

[寻开心]

半序关系就是这样的啊。

> < 关系是可以传递的
＝ 关系是不确定的

世界不仅仅只有黑白两色，它是灰色的。

[loewe]

楼主是否可以再详细介绍一下“半序关系”，谢谢

[寻开心]

半序关系就是 > < 可以传递， = 表示没有关系

[寻开心]

用前面给出的计算任意两个点之间的关系函数，计算所有两点之间的关系，那么得到的结果就可以当作图的邻接矩阵了。

图显然是一个有向图。

有了它，再从上面找一个路径是可行的吧。
需要注意的是图当中可能包含一些孤立点，或者是孤岛。
孤立点和孤岛之间关系都是并列的，谁先谁后都可以的。

[MgAl]

"半序关系就是 > < 可以传递， = 表示没有关系"
我还是不理解，到底哪个叫半序关系？>,<,= ?还是3个合起来叫一个半序关系？

[寻开心]

合起来是半序

全序就是 a>b b>c => a>c > 可传递
a<b b<c => a<c < 可传递
a=b b=c => a=c = 可传递
a=b b>c => a>c 〉 = 之间的传递关系
a=b b<c => a<c < = 之间的传递关系
半序关系
>和<是可传递的关系
＝ 则是无法确立的关系

[loewe]

老大，前几天做ZJU的1060的时候觉得好象差不多啊

在ZJU的1060中可以对每个元素都建立两个集合，一个保存比它大的，一个保存比它小的，如果对于每个元素，两个集合个数之和是n-1（共有n个元素）的话，说明已经排序完成

[寻开心]

差不多啦。
这里要有三个集合吧。
和它等的呢？
关键就在处理和它等的部分的方法。

[loewe]

要不我写个程序试试，看在100分的份上，手上的程序写好了我就开始

老大，把分给我留着啊！

[寻开心]

呵呵
有兴趣就做做吧。
短期内不会结这个帖子的。
这个题目要是没有那个特殊的 ＝ 就没意思了
答对了的话，再给你200分

[jwd_1_cool]

不是topo就可以解决了呀？？
input:
4 5 //表示4个字母，5个关系
A<B
A<C
B>C
A=D
C=D

output:
DACB 或 ACBD 应该都是正解！

程序我大致写了下，孤立的非法情况，我没判断！

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

const int MAX_N = 100;
enum Color { WHITE, GRAY, BLACK };

Color color[MAX_N]; // the state of the Node

int source[MAX_N]; // record the parent node
int graph[MAX_N][MAX_N];
int out[MAX_N];
int N,M;
bool incon;

void DFS_Visit(int u)
{
color[u] = GRAY; // White vertex u has just been discoverd
for (int i = 0; i < N; ++i) { // Explore edge (u, i)
if(graph[u][i]==1){
if (color[i] == WHITE) {
source[i] = u;
DFS_Visit(i);
}else{
if(color[i] == GRAY) incon=true;
}
}
}
color[u] = BLACK; // Blacken u, it is finished
out[--M]=u; //PUT INTO TOPOLIST
}

void DFS()
{
for (int i = 0; i < N; ++i) {
color[i] = WHITE;
source[i] = -1;
out[i]=-1;
}
M = N;
for (int i = 0; i < N; ++i) {
if (color[i] == WHITE) {
DFS_Visit(i);
}
}
}

void TopoSort()
{
for(int i=0;i<N;i++)
cout<<char(out[i]+'A');
cout<<endl;
}


int main()
{
int n;
while(cin >> N>>n){

char a,b,c;
memset(graph,0,sizeof(graph));
for (int i = 0; i < n; ++i) {
cin>>a>>b>>c;
if(b=='<'){
graph[a-'A'][c-'A']=1;
continue;
}
if(b=='>'){
graph[c-'A'][a-'A']=1;
continue;
}
}
incon=false;
DFS();
if(!incon) TopoSort();
else cout<<"circle!!"<<endl;
}
return 0;
}


循环的非法情况，我已经输出了。
但是答案已经符合楼主要求了吧！！

[AlgorithmFanatic]

faint!
“全序就是 a>b b>c => a>c > 可传递
a<b b<c => a<c < 可传递
a=b b=c => a=c = 可传递
a=b b>c => a>c 〉 = 之间的传递关系
a=b b<c => a<c < = 之间的传递关系
半序关系
>和<是可传递的关系
＝ 则是无法确立的关系”

简直是在放屁！

基本定义都搞不懂，题目也出的不明不白。亏你们还有兴趣做。csdn原来就这个水平！

[forestassure]

to AlgorithmFanatic:
大虾为什么不说说自己的解法？如果题错了，是否可以再来一道！
希望能够从中学习！

[Icat]

如果学过了离散就好理解多了

[liangbch]

比较快的排序方法有快速排序，复杂度nlog2n,堆排序，复杂度和快速排序同。
如果数大小变化不大，可以使用桶排序。
这里的排序只涉及到数的大小比较，因此还可以用基数排序。
我在下一个帖子该出基数排序的算法。

[liangbch]

#include "stdlib.h"
#include "stdio.h"
#include "memory.h"

typedef unsigned int UINT;

void baseSort( UINT a[],UINT b[],int len,int nRep)
{
int i,j,n1,n2,h;
UINT mask;
for (mask=1,i=0;i<nRep; i++,mask <<= 1)
{
for (h=0,j=0;j<len;j++)
{
if ( ( a[j] & mask) ==0)
h++;
}
n1=0;
n2=h;
for (j=0;j<len;j++)
{
if ( ( a[j] & mask) ==0)
b[n1++]=a[j];
else
b[n2++]=a[j];
}
//----------------------------
memcpy(a,b,len*sizeof(UINT));
}
}

void genNumArr(UINT a[],int len,int maxValue)
//随机生成0..maxValue之间的数，放入数组a[]
{
for (int i=0;i<len;i++)
a[i]=rand() % (maxValue);
}

void printfNumArr(UINT a[],int len)
{
printf("\n");
for (int i=0;i<len;i++)
{
if (i==0) printf("%d",a[i]);
else printf(",%d",a[i]);
}
}

int log2(UINT x) // 计算log2(x)的整数部分
{
UINT mask=2;
int res=0;
while ( mask>0 ) // 当 mask=2^31 时， mask *2=0;
{
if (x<mask)
return res;
mask <<=1;
res++;
}
return res;
}


int main(int argc, char* argv[])
{
#define COUNT 1000
#define MAX_NUM 100

UINT a[COUNT],b[COUNT];
//------------------
genNumArr(a,COUNT,MAX_NUM); //生成 0..MAX_NUM-1 之间的书
printfNumArr(a,COUNT);
//-----------
baseSort( a, b,COUNT,log2(MAX_NUM)+1);
printfNumArr(a,COUNT);
return 0;
}

// 这是我刚刚完成的一个程序，已调试通过。使用了基数排序的算法，复杂度log2(x)*n, x为待排序数组中的最大值，n为数据的个数。
特点：1。排序速度和n,x有关，和原始数据的排列次数无关，算法稳定。
2。需要占用 数据本身2倍 的内存。
适用范围：待排序的数的大小变化不大。