AcWing 343. 排序

Posted 2022-03-20 蒟蒻豆进阶之路

题目传送门

一、传递闭包

本题考察\\(Floyd\\)算法在传递闭包问题上的应用。给定若干对元素和若干对二元关系，并且关系具有传递性，通过传递性推导出尽量多的元素之间的关系的问题被称为传递闭包。比如\\(a < b,b < c\\),就可以推导出\\(a < c\\)，如果用图形表示出这种大小关系，就是\\(a\\)到\\(b\\)有一条有向边，\\(b\\)到\\(c\\)有一条有向边，可以推出\\(a\\)可以到达\\(c\\)，找出图中各点能够到达点的集合，就类似于\\(Floyd\\)算法求图中任意两点间的最短距离。\\(Floyd\\)求解传递闭包问题的代码如下：

void floyd()
    for(int k = 0;k < n;k++)
        for(int i = 0;i < n;i++)
            for(int j = 0;j < n;j++)
                f[i][j] |= f[i][k] & f[k][j];

只是对原来算法在状态转移方程上略加修改 就能够求解传递闭包问题了。【套路，满满的套路，你不学习就不会的套路】
f[i][j] = 1表示i可以到达j(i < j)，f[i][j] = 0表示i不可到达j。只要i能够到达k并且k能够到达j，那么i就能够到达j，这就是上面代码的含义。

对于本题而言，给定\\(n\\)个元素和一堆二元关系，依次读取每个二元关系，在读取第\\(i\\)个二元关系后，如果可以确定\\(n\\)个元素两两间的大小关系了，就输出在几对二元关系后可以确定次序，并且次序是什么；如果出现了矛盾，就是\\(A < B\\)并且\\(B < A\\)这种情况发生了就输出多少对二元关系后开始出现矛盾；如果遍历完所有的二元关系还不能确定所有元素间的大小关系，就输出无法确定。

可以发现，题目描述要求按顺序遍历二元关系，一旦前\\(i\\)个二元关系可以确定次序了就不再遍历了，即使第\\(i + 1\\)对二元关系就会出现矛盾也不去管它了。对于二元关系的处理和之前的做法一样，\\(A < B\\)，就将\\(f[0][1]\\)设为\\(1\\)，题目字母只会在\\(A\\)到\\(Z\\)间，因此可以映射为\\(0\\)到\\(25\\)这\\(26\\)个元素，如果\\(f[0][1] = f[1][0] = 1\\)，就可以推出f[0][0] = 1，此时\\(A < B\\)并且\\(A > B\\)发生矛盾，因此在f[i][i]= 1时发生矛盾。

下面详细分析下求解的步骤：首先每读取一对二元关系，就执行一遍\\(Floyd\\)算法求传递闭包，然后执行check函数判断下此时是否可以终止遍历，如果发生矛盾或者次序全部被确定就终止遍历，否则继续遍历。在确定所有的次序后，需要输出偏序关系，因此需要执行下getorder函数。注意这里的终止遍历仅仅是不再针对新增的二元关系去求传递闭包，循环还是要继续的，需要读完数据才能继续读下一组数据。

下面设计\\(check\\)函数和\\(getorder\\)函数。

int check()
    for(int i = 0;i < n;i++)
        if(f[i][i]) return 0;
    for(int i = 0;i < n;i++)
        for(int j = 0;j < i;j++)
            if(!f[i][j] && !f[j][i])    return 1;
        
    
    return 2;

如果f[i][i] = 1就发生矛盾了，可以返回了；如果f[i][j] = f[j][i] = 0表示i与j之间的偏序关系还没有确定下来，就需要继续读取下一对二元关系；如果所有的关系都确定了，就返回2。

string getorder()
    char s[26];
    for(int i = 0;i < n;i++)
        int cnt = 0;
        for(int j = 0;j < n;j++)    cnt += f[i][j];
        s[n - cnt - 1] = i + \'A\';
    
    return string(s,s + n);

确定所有元素次序后如何判断元素i在第几个位置呢？f[i][j] = 1表示i < j，因此计算下i小于元素的个数cnt，就可以判定i是第cnt + 1大的元素了。
总的代码如下：

#include <bits/stdc++.h>
// Floyd解决传送闭包问题
using namespace std;
const int N = 27;
int n;       // n个变量
int m;       // m个不等式
int g[N][N]; //原始关系
int f[N][N]; //推导的关系
void floyd() 
    //复制出来f
    memcpy(f, g, sizeof g);
    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                // i可以到达k,k可以到达j,那么i可以到达j
                //为了防止枚举其它k\'时，导致被覆盖成0,所以写成“或”的形式
                f[i][j] |= f[i][k] & f[k][j];

// 1:可以确定两两之间的关系,2:矛盾,3:不能确定两两之间的关系
int check() 
    //如果i<i，那么就是出现了矛盾
    for (int i = 0; i < n; i++)
        if (f[i][i]) return 2;
    //存在还没有识别出关系的两个点i,j,还要继续读入
    for (int i = 0; i < n; i++)
        for (int j = 0; j < i; j++)
            if (!f[i][j] && !f[j][i]) return 3;
    return 1;

//升序输出所有变量
string getorder() 
    char s[26];
    for (int i = 0; i < n; i++) 
        //这个思路很牛X!
        int cnt = 0;
        // f[i][j] = 1表示i可以到达j (i< j)
        for (int j = 0; j < n; j++) cnt += f[i][j]; //比i大的有多少个
        //举个栗子：i=0,表示字符A
        //比如比i大的有5个，共6个字符：ABCDEF
        // n - cnt - 1 = 6-5-1 = 0,也就是A放在第一个输出的位置上
        //之所以再-1，是因为下标从0开始
        s[n - cnt - 1] = i + \'A\';
    
    //转s字符数组为字符串
    return string(s, s + n);

int main() 
    // n个变量,m个不等式
    // 当输入一行 0 0 时，表示输入终止
    while (cin >> n >> m, n || m) 
        string str;
        int type = 3; // 3:不能确定两两之间的关系
        //初始化原始关系,准备读入数据
        memset(g, 0, sizeof g);
        // m条边，下面需要输出在第几个输入后有问题，所以需要用for循环
        for (int i = 1; i <= m; i++) 
            cin >> str;
            //如果不是待确定，就表示是已确定或者出现了矛盾,就没有必要再处理了
            //但是，还需要耐心的读取完毕，因为可能还有下一轮，不读入完耽误下一轮
            if (type != 3) continue;
            //变量只可能为大写字母A~Z,映射到0~25
            int a = str[0] - \'A\', b = str[2] - \'A\';
            g[a][b] = 1; //记录a<b
            //跑一遍最短路,传递闭包
            floyd();
            //检查一下现在的情况，是不是已经可以判定了
            type = check();
            //出现的矛盾
            if (type == 2)
                printf("Inconsistency found after %d relations.\\n", i);
            else if (type == 1)  //可以确定了
                //输出升序排列的所有变量
                string ans = getorder();
                printf("Sorted sequence determined after %d relations: %s.\\n", i, ans.c_str());
            
        
        //所有表达式都输入了，仍然定不下来关系
        if (type == 3) printf("Sorted sequence cannot be determined.\\n");
    
    return 0;

二、优化算法

分析上面的代码可以发现，每读取一对二元关系就去执行一次\\(floyd\\)算法，时间复杂度是\\(O(m*n^3)\\)，显然冗余度很高，新增了\\(a\\)与\\(b\\)的大小关系，只需要更改由这条边可传递下去的关系即可，比如之前执行\\(floyd\\)已经确定\\(A < C\\)，新增了\\(B < D\\)，完全没必要再去求解\\(A\\)与\\(C\\)的大小关系了。因此，如果新读入的二元关系f[a][b]已经是1了，表示之前的算法已经使用了a与b这条边了，就不需要再执行传递闭包算法了，如果f[a][b] = 0，也只需要更新与a、b有关点的关系。

如上图所示，加入a与b这条边后，我们只需要遍历能够到达a的所有点x以及b能够到达所有的点y，用平方级复杂度就可以完成加一条边后关系的更新。f[a][b] = 1，首先我们需要更新f[x][b]与f[a][y]的值为1，表示x可以到达b了，a可以到达y了，最后再更新f[x][y] = 1。注意这里的x与y都是泛指，x指的是能够到达a的点，不一定是图中标的与a直接相连的那个点，也可能是图中x的上一点，也是可以到达a的。这样一来每读入一条边最多只要平方级别复杂度就可以完成更新，总的时间复杂度为\\(O(m*n^2)\\)，效率也大幅提升了。这种方法的代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N = 27;
int n, m, f[N][N];
//  1:可以确定两两之间的关系,2:矛盾,3:不能确定两两之间的关系
int check() 
    //如果i<i，那么就是出现了矛盾
    for (int i = 0; i < n; i++)
        if (f[i][i]) return 2;
    //存在还没有识别出关系的两个点i,j,还要继续读入
    for (int i = 0; i < n; i++)
        for (int j = 0; j < i; j++)
            if (!f[i][j] && !f[j][i]) return 3;
    return 1;

//升序输出所有变量
string getorder() 
    char s[26];
    for (int i = 0; i < n; i++) 
        //这个思路很牛X!
        int cnt = 0;
        // f[i][j] = 1表示i可以到达j (i< j)
        for (int j = 0; j < n; j++) cnt += f[i][j]; //比i大的有多少个
        //举个栗子：i=0,表示字符A
        //比如比i大的有5个，共6个字符：ABCDEF
        // n - cnt - 1 = 6-5-1 = 0,也就是A放在第一个输出的位置上
        //之所以再-1，是因为下标从0开始
        s[n - cnt - 1] = i + \'A\';
    
    //转s字符数组为字符串
    return string(s, s + n);


int main() 
    // n个变量,m个不等式
    // 当输入一行 0 0 时，表示输入终止
    while (cin >> n >> m, n || m) 
        string str;
        int type = 3;
        memset(f, 0, sizeof f);
        for (int i = 1; i <= m; i++) 
            cin >> str;
            if (type != 3) continue;
            int a = str[0] - \'A\', b = str[2] - \'A\';
            if (!f[a][b])                    //如果a和b还没有确定关系
                f[a][b] = 1;                  //记录a<b
                for (int x = 0; x < n; x++)  //枚举所有节点
                    if (f[x][a]) f[x][b] = 1; //如果x<a，那么x一定小于b
                    if (f[b][x]) f[a][x] = 1; //如果b<x，那么a一定小于x
                    //外层循环找出所有小于a的点x，内层循环找出所有大于b的点y
                    //记录x,y的关系为x<y
                    for (int y = 0; y < n; y++)
                        if (f[x][a] && f[b][y]) f[x][y] = 1;
                
            
            //检查一下现在的情况，是不是已经可以判定了
            type = check();
            //出现的矛盾
            if (type == 2)
                printf("Inconsistency found after %d relations.\\n", i);
            else if (type == 1)  //可以确定了
                //输出升序排列的所有变量
                string ans = getorder();
                printf("Sorted sequence determined after %d relations: %s.\\n", i, ans.c_str());
            
        
        //所有表达式都输入了，仍然定不下来关系
        if (type == 3) printf("Sorted sequence cannot be determined.\\n");
    
    return 0;