有向图中的所有环--深度遍历暴力求解

华为软件精英挑战赛2020题目

为了方便理解题目，暴力求解了一下。。。

每个点都进行深度遍历，找到以这个点为起点的环。。。数据再大一点应该就不行了。。。

代码写得烂，仅供参考。。

 

更新，用邻接表来实现速度快了100倍。。。

 

更新，根据大佬的Java代码写了两个小的数据集。。。

https://github.com/izhangrui/HWcode2020-TestData/tree/master/C%2B%2B

 

更新，数据连通性太强了，拓扑排序只能去除一两个点，看情况使用。。。。

同一份代码，为什么用vs跑要比g++快？

100w的数据排序用太长时间了。。。是不是可以考虑排序用多线程。。。

 

更新，g++慢是因为编译的时候没加优化选项-O3。。。

 

试了一下鲲鹏服务器，感觉和笔记本差不多。。。

看这个100w和300w的结果，这用时和环数呈正比？

另外排序慢很有可能是因为生成的数据高度有序？快排貌似对有序的数据很慢。。。

 

更新，貌似可以省去对结果排序。。。

 

提交了答案，垫底。。。输出还是用的ofstream，没弄权限什么的，就是要注意输入输出路径。。

 

同一份代码在鲲鹏服务器上测试的100w数据，多线程。。。

 

 

分享一个大佬在线2s的代码，太强了。。

https://zhuanlan.zhihu.com/p/125764650

 

优化了一下，线下测试100w数据2s。。线上31.9s。。好想知道线上是什么数据。。。

 

更新：C++中在循环中创建向量感觉很费时间，代码功底太差了啊！优化不动了。。。

分享一个剪枝思路，剪掉3邻域外的点。。

一个python实现：

https://github.com/izhangrui/CodeCraft2020

 

 

更新：

dfs+3邻域剪枝+向量改数组线上能到2.1s，再加上6+1的来优化可以到1.7s。

还有就是感觉官方56环那个数据线下测评也很重要，优化代码后最好测一测56环那个数据再提交。。保证大图优化的同时，小图不要负优化（比如一开始开个300w的向量，大图不是很影响，小图影响就很大。针对小图优化内存、输入输出，针对大图优化算法？）

如果线下大图小图都提升，或者其中一个提升一个不变应该线上就会有提升吧，明天用多线程来再验证一下。。。

突然想起可以用以前提交过的代码来验证这个猜想。。。不知道大家有没有进行过相关测试。。

 

更新：6+1的python实现，线上29分。

https://github.com/izhangrui/CodeCraft2020/blob/master/CodeCraft2020_v3.py

 

 

更新：为了测试算法部分到底用了多少时间，在程序里增加了了一次找环的操作，发现线上成绩只增加了0.14，由1.78变成了1.92....也就是说找环部分只花了0.14s？所以算法的优化意义以及不大了？不知道这么分析对不对。。。

 

更新：把dfs之外的向量也都改数组了，提升了0.6s，这时间都够好几次dfs找环了。。。虽然线上提升这么多，但线下几乎没变。。。之前也试过3+4的，线下大图非常友好，提升好几倍。。。但线上就是不行。。猜测大概就是线上dfs花的时间非常少，提升好几倍也没啥提升，反而要是为了优化使用了stl的话估计还会更慢。。。

现在就只剩下一个map和两个向量，还不知道怎么优化。。。

还有就是映射id的时候改map为unordered_map快了0.2s。。

 

更新：测试了一下fscanf读数据，在程序里把数据读了两遍，线上慢了大概0.06s，也就是说对于目前数据，即使使用mmap读最多也就提升0.06s？另外，读和dfs都不怎么费时，下次再测一下写。

 

 

更新：优化了一下，fscanf+fwrite+单线程

不知道用mmap还会有多大提升。。。要开学了，暂时不弄了，大家加油！

 

更新：最终成绩0.2094...除了多线程和mmap读，算法没有什么特别的操作...实测最终dfs部分多线程不超过0.03s，单线程不超过0.09s...

看了ddd大佬的数据分析就明白了为什么之前，线下100w数据2s线上31s...对于这数据感觉很多操作都是多余的...真是服了这数据了...

https://github.com/justarandomstring/2020-Huawei-Code-Craft/tree/master/First%20Round

最后ddd真是太强了！很想赛后看看大佬们都是怎么写的代码

 

下面C++代码是之前比赛开始的时候，为了理解题意写随便写的一份代码，现在感觉已经没什么参考价值了。。。

#include "bits/stdc++.h"

using namespace std;

void dfs(const vector<vector<int>> &g, vector<vector<int>> &res, vector<int> &visit, vector<int> &path, int k, int p_o)
{
    for (int i = 0; i < g.size(); i++)
    {
        if (g[k][i] == 0)
            continue;
        if (i == p_o)
        {
            res.push_back(path); //保存找到的环
            continue;
        }
        if (visit[i] == 1)
            continue;
        visit[i] = 1;
        path.push_back(i);
        dfs(g, res, visit, path, i, p_o);
        path.pop_back();
        visit[i] = 0;
    }
}

bool cmp(vector<int> a, vector<int> b)
{
    //输出排序比较
    if (a.size() == b.size())
    {
        for (int i = 0; i < a.size(); i++)
        {
            if (a[i] == b[i])
                continue;
            return a[i] < b[i];
        }
    }
    else
        return a.size() < b.size();
    return false;
}
bool isSame(vector<int> &a, vector<int> &b)
{
    //比较两个矩阵是否一样
    if (a.size() != b.size())
        return false;
    for (int i = 0; i < a.size(); i++)
    {
        if (a[i] != b[i])
            return false;
    }
    return true;
}
void rot_vector(vector<int> &nums)
{
    //统一环的起点，最小id为起点
    int min_num = nums[0];
    int min_idx = 0;
    for (int i = 0; i < nums.size(); i++)
    {
        if (min_num > nums[i])
        {
            min_num = nums[i];
            min_idx = i;
        }
    }
    vector<int> temp(nums);
    for (int i = 0; i < nums.size(); i++)
    {
        nums[i] = temp[(i + min_idx) % nums.size()];
    }
}

int main()
{
    clock_t start_time, end_time;
    start_time = clock();
    //--------------------------数据读入-----------------------------
    ifstream infile("test_data.txt");
    vector<int> ids1;
    vector<int> ids2;
    vector<int> vals;
    int id1, id2, val;
    char c;
    while (infile >> id1 >> c >> id2 >> c >> val)
    {
        ids1.push_back(id1);
        ids2.push_back(id2);
        vals.push_back(val);
    }
    //-----------------------创建有向图-----------------------------------
    int max_id = 0;
    for (int i = 0; i < ids1.size(); i++)
    {
        if (i == 0 || max_id < ids1[i])
        {
            max_id = ids1[i];
        }
        if (max_id < ids2[i])
        {
            max_id = ids2[i];
        }
    }
    cout << max_id << endl;
    max_id += 1;
    vector<int> temp(max_id, 0);
    vector<vector<int>> g(max_id, temp);
    vector<int> visit(max_id, -1);
    for (int i = 0; i < ids1.size(); i++)
    {
        visit[ids1[i]] = 0;
        visit[ids2[i]] = 0;
    }
    for (int i = 0; i < ids1.size(); i++)
    {
        g[ids1[i]][ids2[i]] = vals[i];
    }
    //-------------------深度遍历找环------------------------------------
    vector<vector<int>> res;
    vector<int> path;
    for (int i = 0; i < visit.size(); i++)
    {
        if (visit[i] == -1)
            continue;
        visit[i] = 1;
        path.push_back(i);
        dfs(g, res, visit, path, i, i);
        visit[i] = 0;
        path.pop_back();
    }
    //-----------------将环排序去重----------------------------------------
    cout << res.size() << endl;
    vector<vector<int>> res1;
    vector<vector<int>> res2;
    for (int i = 0; i < res.size(); i++)
    {
        if (res[i].size() < 3 || res[i].size() > 7)
            continue;
        rot_vector(res[i]);
        res1.push_back(res[i]);
    }
    sort(res1.begin(), res1.end(), cmp);
    res2.push_back(res1[0]);
    for (int i = 1; i < res1.size(); i++)
    {
        if (isSame(res1[i], res1[i - 1]))
            continue;
        res2.push_back(res1[i]);
    }
    //------------------输出结果--------------------------------------------
    ofstream outfile("result.txt");
    outfile << res2.size() << endl;
    for (int i = 0; i < res2.size(); i++)
    {
        for (int j = 0; j < res2[i].size(); j++)
            outfile << res2[i][j] << ",";
        outfile << endl;
    }
    end_time = clock();
    cout << " time : " << double(end_time - start_time) / CLOCKS_PER_SEC << "s" << endl;
}