POJ 1094_Sorting It All Out

analysis

一开始看到这种传递性的题以为是tarjan,结果发现书上给的是Floyd传递闭包

对于不等式i<j,就让G[i][j]=1,其他情况G[i][j]=0

然后跑一次传递闭包,G数组里面就存好了在当前给出的不等式条件下的所有数之间的大小关系

如果存在G[i][j]=G[j][i]=0,说明不能确定大小关系
如果存在G[i][j]=G[j][i]=1,说明矛盾

至于输出方案数,直接用一个拓扑排序就可以了呗

然后就可以出算法了

code

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(int i=start;i<=end;++i)
#define anti_loop(i,start,end) for(register int i=start;i>=end;--i)
#define ll long long
#define clean(arry,num) memset(arry,num,sizeof(arry))
#define copy(arry1,arry2) memcpy(arry1,arry2,sizeof(arry1))
#define ERROR -1
#define UNFINSHED 0
#define FINSHED 1
int n,m;
const int maxn=100;
int f[maxn][maxn];
inline void debug(){
	loop(i,1,n){
		loop(j,1,n){
			printf("%d ",f[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}
inline int floyd(){
	//copy(G,f);
    loop(k,1,n){
        loop(i,1,n){
            loop(j,1,n){
                f[i][j]|=(f[i][k]&f[k][j]);
                if(f[i][j]&&f[j][i]&&i!=j)
                	return ERROR;
            }
        }
    }
    loop(i,1,n){
        loop(j,i+1,n){
        	//if(i==j)
        		//continue;
            //if(f[i][j]&&f[j][i])
                //return ERROR;
            if(f[i][j]==0&&f[j][i]==0)
                return UNFINSHED;
        }
    }
    return FINSHED;
}
int in[maxn];
struct node{
	int e;
	int nxt;
}edge[40000];
int head[maxn];
int cnt=0;
inline void addl(int u,int v){
	edge[cnt].e=v;
	edge[cnt].nxt=head[u];
	head[u]=cnt++;
}
inline void getseq(){
    clean(in,0);
    clean(head,-1);
    cnt=0;
    loop(i,1,n){
    	loop(j,1,n){
    		if(i==j)
    			continue;
    		if(f[i][j])
    			++in[j],
    			addl(i,j);
		}
	}
	queue<int>q;
	loop(i,1,n)
		if(in[i]==0)
			q.push(i);
	while(q.empty()==false){
		int f=q.front();
		q.pop();
		printf("%c",f+'A'-1);
		for(int i=head[f];i!=-1;i=edge[i].nxt){
			int v=edge[i].e;
			if(--in[v]==0)
				q.push(v);
		}
	}
	printf(".\n");
    return;
}
int main(){
    #ifndef ONLINE_JUDGE
    freopen("datain.txt","r",stdin);
    #endif // ONLINE_JUDGE
    while(scanf("%d%d",&n,&m),(n!=0&&m!=0)){
        clean(f,0);
        scanf("%d%d",&n,&m);
        char s[100];
        bool flag=false;
        loop(i,1,m){
            scanf("%s",s);
            f[s[0]-'A'+1][s[2]-'A'+1]=1;
            int res=floyd();
            if(res==ERROR&&!flag){
                printf("Inconsistency found after %d relations.\n",i);
                flag=true;
            }
            else if(i==m&&res==UNFINSHED&&!flag){
                printf("Sorted sequence cannot be determined.\n");
                flag=true;
            }
            else if(res==FINSHED&&!flag){
                printf("Sorted sequence determined after %d relations: ",i);
                getseq();
                flag=true;
            }
        }
    }
    return 0;
}

(蒟蒻实现的时候,把判断矛盾和不能确定大小关系放在了后面的一个二层循环里面,这样可能使得一些矛盾的情况在不能确定大小关系的后面被判断,从而导致一组本来矛盾的数据后面输出不能确定大小关系了)