[FEATURE]

[sakshamgaikwad-tech]

Detailed description

#include
#include
#include
using namespace std;

void bfs(int start, vector adj[], int V) {
vector visited(V, false);
queue q;

visited[start] = true;
q.push(start);

while (!q.empty()) {
    int node = q.front();
    q.pop();

    cout << node << " ";

    for (int neighbor : adj[node]) {
        if (!visited[neighbor]) {
            visited[neighbor] = true;
            q.push(neighbor);
        }
    }
}

}

Context

help me to make this code more efficient

Possible implementation

No response

Additional information

No response

[Hxrshthetic]

Do you want it more efficient in terms of complexity or at machine level? like we can improve the implementation so it becomes faster but complexity will be O(V + E) only

[sakshamgaikwad-tech]

Yes sure if u have a better efficient code then suggest me I will make changes or commit your code

[Hxrshthetic]

Ok so we can do few changes like using vector or array instead of a queue and use two integers front and back to use it like a queue which will make it faster. Also instead of using boolean vector for visited which is bit-packed and requires proxy objects, we can use uint8_t which is byte-packed and will have faster access. Next what we can do it that we can cache each node instead of accessing it again and again.

Now, the biggest performance gain will happen when we use CSR(compressed sparse row) for the graph, i.e., we store the graph is contiguous memory so that accessing becomes faster. What adjacency list does is that it stores diff vector for each node for which we make to make several memory accesses, making it slow. But the CSR has to be made and passed as one of the parameters in bfs.

If you want I can make a PR for this(either CSR or the other changes I suggested). Assign me the issue.

[github-actions]

This issue has been automatically marked as abandoned because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.