Truveris

truveris

Sure, test design techniques help us choose test scenarios and make things more efficient. But what exactly is defect localization, and how can we make it less painful? Let's start with the basics Localization is like playing detective: “Where and when did things go wrong?” Without proper localization, a defect can become a hot potato tossed between frontend, backend, and any development team. Time gets wasted, and, potentially, even the context. Think of defect localization as navigating a labyrinth, with application requests and logs as your ball of yarn. But wouldn't it be easier to have a map of this labyrinth, even a sketchy one, instead of just stumbling around with yarn? That's where the application's architecture comes in. What is application architecture? It's how the different parts of the system work together. In terms of our labyrinth metaphor, it’s how one section connects to another, which passageways lead where. I distinguish two main architectures: client-server and backend. Client-server architecture shows us how the client and server interact.
Backend architecture determines how the backend handles client requests. A few words about client-server architecture There are generally two types: Thin client
Thick client The type affects how much information the client keeps and processes on its own. There are other ways to set this up, but I'll stick to what I've actually worked with. Most mobile and web apps are thin clients. All information is stored on the server, and the client application requests data or asks for it to be processed. Registering, logging in, subscribing to notifications – all these are calls to the server. The entire processing on the server is hidden from the client. In response to the request, the client receives collected and processed information from the database or a confirmation that the request was successfully completed. In thick client applications, the client performs most of the processing itself: adding data to the database, generating reports, calculating sums, and creating documents. They are often installed locally, but not always. Examples of thick clients include offline games, AutoCAD, and some versions of 1C. Now, let's explore the backend architecture Two common approaches are: Monolithic
Microservices When almost everything is processed in one place, it's a monolith. If requests for processing are sent to other services within the system, you're likely dealing with a microservice architecture. In a monolithic architecture, pinpointing the source of a defect can be tricky, as different teams and services typically share the same codebase, meaning changes can have unexpected consequences. In the second case, services are separated, each with its own codebase, meaning changes in one service have little impact on others. Organizational structure and areas of responsibility The title sounds scary, but it just tells you who does what, and who is responsible for which part of the labyrinth (application). Imagine we have a large company: a bank, a marketplace, a food delivery service – you name it. The bigger and more complex our application, the more people work on it. And the more people there are, the more you need to divide them into teams, each responsible for their own development area. For example, one team might handle promotions, while another is responsible for payments. If our application offers different services, teams might be responsible for individual services, such as electronic document management, accounting, or government procurement. You don't need to know everything and everyone, but if there's documentation outlining which team is responsible for which area, it's best to keep it bookmarked. Putting it all together Map in hand, yarn at the ready, let's delve into our labyrinth and hunt down the source of a defect. Let's imagine a few scenarios. Scenario 1 Picture this: We're testing a website for a conversation club. We're browsing the class schedule, reading about upcoming sessions, when at some point, we spot a typo. Now, how do we figure out where it originated? Let the adventure begin! We open devTools, refresh the page, and look at the requests and responses. Since we have a thin client, we find our typo in one of the responses – it came from the backend. Now, we open the logs and search for the processing of the backend's request or response – this is our yarn from the magic ball. We can search the logs using any information from the request and response, but it's better to use unique values: request xiid, ID from the request, phone number, and so on. We find the entry and check: did we get the class information from the database or from another service? If the information came from the database, we can pass the issue to tech support to fix the typo in the database. If the information came from another service, we can pass the defect to them. Congratulations! We've conquered our first labyrinth: the defect is localized and reported. Scenario 2 Now picture we're testing a registration form. We enter an email, some data, and a made-up password. We click the registration button and unexpectedly get an error. It’s time to unravel our magic ball! We head to our beloved Network tab in devTools and see what went wrong: we repeat all the steps and check the server's response. In response to the request, we get a 400 code with an empty response body. Should we run off and file a defect against the frontend? But we still don’t know what exactly went wrong and what needs to be fixed. Often a 400 error occurs when there's a discrepancy between what the client sent and what the server expected. There could be many reasons for this, including: Outdated documentation in the task
Changes made without documentation
Typos Let's check the client's request If we have documentation, written manually or generated in Swagger or OpenAPI, let’s use it to verify that: We're sending all required parameters
Parameter values have correct data types (e.g., numeric values for int parameters) How else can we check the request? Even if we don’t have documentation, we can verify: Syntax compliance (e.g., if the request is sent in JSON format, it should follow JSON syntax)
Typos in parameter names (e.g., “mony” instead of “money”, “doby” instead of “body”)
Cyrillic characters among Latin characters (e.g., “namе” written with a Cyrillic "e") Everything’s in order? Then it’s time to continue our journey through the labyrinth to find the answer. We take our map and “descend” into the logs. Log analysis Here, two scenarios are possible: An error is logged during request processing
No error is logged, but requests are recorded In the latter case, we'll have to continue our journey through the microservice labyrinth and look for the place where our request was processed. Upon locating the error log, we'll know what exactly went wrong, which means our localization and our journey are complete! All that remains is to gather the following information for the defect report: Backend request
Error log
Recommended fix Conclusion Defect localization can be challenging. Sometimes you'll hit a wall: the log you were following doesn't lead to the error or makes things more confusing. In such situations, I usually take a couple of steps back or start from the beginning. It may take a lot of time to explore the labyrinth. The journey may be difficult, and fraught with danger: the processing of some requests can be convoluted and send requests to several different services. Sometimes it makes sense to simplify the task and contact the labyrinth's architects – the developers. Sure, test design techniques help us choose test scenarios and make things more efficient. But what exactly is defect localization, and how can we make it less painful? is Let's start with the basics Let's start with the basics Localization is like playing detective: “Where and when did things go wrong?” Without proper localization, a defect can become a hot potato tossed between frontend, backend, and any development team. Time gets wasted, and, potentially, even the context. Think of defect localization as navigating a labyrinth, with application requests and logs as your ball of yarn. But wouldn't it be easier to have a map of this labyrinth, even a sketchy one, instead of just stumbling around with yarn? That's where the application's architecture comes in. What is application architecture? What is application architecture? It's how the different parts of the system work together. In terms of our labyrinth metaphor, it’s how one section connects to another, which passageways lead where. I distinguish two main architectures: client-server and backend. Client-server architecture shows us how the client and server interact. Backend architecture determines how the backend handles client requests. Client-server architecture shows us how the client and server interact. Backend architecture determines how the backend handles client requests. A few words about client-server architecture A few words about client-server architecture There are generally two types: Thin client Thick client Thin client Thick client The type affects how much information the client keeps and processes on its own. There are other ways to set this up, but I'll stick to what I've actually worked with. Most mobile and web apps are thin clients. All information is stored on the server, and the client application requests data or asks for it to be processed. Registering, logging in, subscribing to notifications – all these are calls to the server. The entire processing on the server is hidden from the client. In response to the request, the client receives collected and processed information from the database or a confirmation that the request was successfully completed. In thick client applications, the client performs most of the processing itself: adding data to the database, generating reports, calculating sums, and creating documents. They are often installed locally, but not always. Examples of thick clients include offline games, AutoCAD, and some versions of 1C. Now, let's explore the backend architecture Now, let's explore the backend architecture Two common approaches are: Monolithic Microservices Monolithic Microservices When almost everything is processed in one place, it's a monolith. If requests for processing are sent to other services within the system, you're likely dealing with a microservice architecture. In a monolithic architecture, pinpointing the source of a defect can be tricky, as different teams and services typically share the same codebase, meaning changes can have unexpected consequences. In the second case, services are separated, each with its own codebase, meaning changes in one service have little impact on others. Organizational structure and areas of responsibility Organizational structure and areas of responsibility The title sounds scary, but it just tells you who does what, and who is responsible for which part of the labyrinth (application). Imagine we have a large company: a bank, a marketplace, a food delivery service – you name it. The bigger and more complex our application, the more people work on it. And the more people there are, the more you need to divide them into teams, each responsible for their own development area. For example, one team might handle promotions, while another is responsible for payments. If our application offers different services, teams might be responsible for individual services, such as electronic document management, accounting, or government procurement. You don't need to know everything and everyone, but if there's documentation outlining which team is responsible for which area, it's best to keep it bookmarked. Putting it all together Putting it all together Map in hand, yarn at the ready, let's delve into our labyrinth and hunt down the source of a defect. Let's imagine a few scenarios. Scenario 1 Scenario 1 Picture this: We're testing a website for a conversation club. We're browsing the class schedule, reading about upcoming sessions, when at some point, we spot a typo. Now, how do we figure out where it originated? Let the adventure begin! We open devTools, refresh the page, and look at the requests and responses. Since we have a thin client, we find our typo in one of the responses – it came from the backend. Now, we open the logs and search for the processing of the backend's request or response – this is our yarn from the magic ball. We can search the logs using any information from the request and response, but it's better to use unique values: request xiid, ID from the request, phone number, and so on. We find the entry and check: did we get the class information from the database or from another service? If the information came from the database, we can pass the issue to tech support to fix the typo in the database. If the information came from another service, we can pass the defect to them. Congratulations! We've conquered our first labyrinth: the defect is localized and reported. Scenario 2 Scenario 2 Now picture we're testing a registration form. We enter an email, some data, and a made-up password. We click the registration button and unexpectedly get an error. It’s time to unravel our magic ball! We head to our beloved Network tab in devTools and see what went wrong: we repeat all the steps and check the server's response. In response to the request, we get a 400 code with an empty response body. Should we run off and file a defect against the frontend? But we still don’t know what exactly went wrong and what needs to be fixed. Often a 400 error occurs when there's a discrepancy between what the client sent and what the server expected. There could be many reasons for this, including: Outdated documentation in the task Changes made without documentation Typos Outdated documentation in the task Changes made without documentation Typos Let's check the client's request Let's check the client's request If we have documentation, written manually or generated in Swagger or OpenAPI, let’s use it to verify that: We're sending all required parameters Parameter values have correct data types (e.g., numeric values for int parameters) We're sending all required parameters Parameter values have correct data types (e.g., numeric values for int parameters) How else can we check the request? Even if we don’t have documentation, we can verify: Syntax compliance (e.g., if the request is sent in JSON format, it should follow JSON syntax) Typos in parameter names (e.g., “mony” instead of “money”, “doby” instead of “body”) Cyrillic characters among Latin characters (e.g., “namе” written with a Cyrillic "e") Syntax compliance (e.g., if the request is sent in JSON format, it should follow JSON syntax) Typos in parameter names (e.g., “mony” instead of “money”, “doby” instead of “body”) Cyrillic characters among Latin characters (e.g., “namе” written with a Cyrillic "e") Everything’s in order? Then it’s time to continue our journey through the labyrinth to find the answer. We take our map and “descend” into the logs. Log analysis Log analysis Here, two scenarios are possible: An error is logged during request processing No error is logged, but requests are recorded An error is logged during request processing No error is logged, but requests are recorded In the latter case, we'll have to continue our journey through the microservice labyrinth and look for the place where our request was processed. Upon locating the error log, we'll know what exactly went wrong, which means our localization and our journey are complete! All that remains is to gather the following information for the defect report: Backend request Error log Recommended fix Backend request Error log Recommended fix Conclusion Conclusion Defect localization can be challenging. Sometimes you'll hit a wall: the log you were following doesn't lead to the error or makes things more confusing. In such situations, I usually take a couple of steps back or start from the beginning. It may take a lot of time to explore the labyrinth. The journey may be difficult, and fraught with danger: the processing of some requests can be convoluted and send requests to several different services. Sometimes it makes sense to simplify the task and contact the labyrinth's architects – the developers.

Defect Localization: The Art of Traversing the Labyrinth

Es liegt nicht an Ihnen; ein großer Teil der Qualitätssicherung besteht in der Fehlerlokalisierung

No eres tú; una gran parte de ser un control de calidad ES la localización de defectos

Se ei ole sinä; Suuri osa laadunvarmistuksesta on vikojen lokalisointia

それはあなたではありません。品質保証の大きな部分は欠陥の特定です

Ezali Yo Te; Un Grand Chunk ya Kozala Assurance ya Qualité EZALI Localisation ya Défaut

ມັນບໍ່ແມ່ນເຈົ້າ; ອັນໃຫຍ່ຫຼວງຂອງການຮັບປະກັນຄຸນນະພາບແມ່ນຄວາມບົກພ່ອງທ້ອງຖິ່ນ

دا تاسو نه یاست؛ د کیفیت د تضمین یوه لویه برخه د ځایی کولو نیمګړتیا ده

То ниси ти; Велики део обезбеђења квалитета је локализација дефекта

இது நீங்கள் அல்ல; ஒரு தர உத்தரவாதமாக இருப்பதில் ஒரு பெரிய பகுதி குறைபாடு உள்ளூராக்கல் ஆகும்

Ин шумо нестед; Як қисми калони кафолати сифат ин маҳаллисозии камбудиҳост

ንስኻ ኣይኮንካን፤ ዓቢ ክፋል ናይ ጽሬት ምርግጋጽ ምዃን IS Defect Localization እዩ።

Asinguwe; I-Big Chunk yokuba nguMgangatho woQinisekiso kukuPhuma kweSiphene

A Deep Dive into Path Traversal Vulnerabilities

In my , I have shown a way to unify the implementation of the most well-known graph-traversal algorithms. Now, let's make it more visually appealing and look into the performance differences. last post The story behind A few years ago, Yandex organized a contest called with an enticing prize: a ticket to a . The contest resembled a game, with participants tasked with finding optimal routes on a map and optimizing delivery using robotic couriers. Robots Couriers closed self-driving conference for professionals As I delved into the topic, I discovered that despite route finding being a solved problem, it continued to interest the professional game development community. Between 2010 and 2020, engineers , particularly beneficial for AAA games with massive maps. Reading on these optimizations was an exciting experience. made significant optimizations to the A* algorithm articles and research papers Furthermore, the contest requirements were designed to enable easy assessment of program outputs by the contest’s testing system. As a result, there was little emphasis on visualization. I found exploring this field intriguing and developing a small application that uses well-known graph algorithms to find routes on a grid map. To visualize my findings, I employed the SFML graphics library. Goal This project builds upon one of , where I demonstrated that four well-known path-finding algorithms (BFS, DFS, Dijkstra's, and A*) are not fundamentally different and can be implemented in a universal way. However, it was challenging to showcase significant performance differences among these algorithms in that project. my previous endeavors In this article, I aim to use improved test data and design something visually exciting. While the Yandex Contest task mentioned earlier aligns well with my goals, I will not solve their specific problem here since it heavily relies on their test system, which is currently unavailable. Instead, I will extract general ideas for input parameters from that contest and create my own implementation. Imaginary world Imagine a technically advanced and innovative city where the future has arrived long ago. In this city, the majority of orders are delivered by courier robots, and it has become a rarity for a person to deliver an order from a cafe. In this task, we invite you to participate in finding optimal routes to deliver orders efficiently. Let's envision the city as an N × N map. For simplicity, we assume that each robot occupies exactly one cell, and each cell can either be passable or not for the robots. In one step, a robot can move in any of the four cardinal directions (up, down, left, or right) if the target cell is free. And I'm of the original task: ignoring the rest At the beginning of the test, you need to output the number of robots you want to use to deliver orders and their initial coordinates. The construction of each robot will cost Costc rubles. Next, T iterations of the simulation will be performed. One iteration represents one virtual minute and consists of 60 seconds. At each iteration, your program will be given the number of new orders, and in response, the program should tell you what actions each robot performs (60 actions per robot). For each successfully delivered order, you will receive max(0, MaxTips - DeliveryTime) dollars in tips, where MaxTips is the maximum number of tips for one order, and DeliveryTime is the time from the moment the order appeared to its delivery in seconds. The total number of points that you earn in one test is calculated by the formula TotalTips - R × Costc, where TotalTips is the total number of tips earned, R is the number of robots used, Costc is the cost of building one robot. The Costc and MaxTips values are set in each test. If you earned less tips than you spent on making robots, your total points will be 0. You will also receive 0 points for the test if you perform any incorrect action. Input The program uses standard input to read the parameters. This approach allows us to specify test data of various complexities using input files. The first line of input contains three natural numbers: N (the size of the city map), MaxTips (the maximum number of tips per order), and Costc (the cost of building one robot). I ignored both MaxTips and Costc parameters for my first implementation and maybe will consider that in the future. Following that, each of the next N lines contains N characters representing the city map. Each string can consist of two types of characters: '#' - indicates a cell occupied by an obstacle. '.' - indicates a free space. Next, you will be provided with two natural numbers: T and D (T ≤ 100,000, D ≤ 10,000,000). T represents the number of interaction iterations, and D represents the total number of orders. Output Your task is to visualize the map and the optimal routes using the SFML graphics library. Modelling the maps I'm fond of maps represented as a grid of cells. Thus, I prefer to render all the results and map them as a grid on cell by cell basis. There is also the option to execute path search right on the grid without using any additional data structure (and I have implemented this as well for learning purposes: see in code). But because of a grid, it is easy to represent a map as a graph in one way or another. I prefer to use an adjacency list of cells for most of the algorithms like BFS, Dijkstra's, and A-Star. For algorithms like Bellman-Ford, it may make sense to use an Edges List instead of an Adjacency List. That's why if you explore the codebase, then you will find all of it, and they all are working examples. To split the logic and responsibility, I have a entity that is responsible for executing path finding according to the orders and tasks configuration that is specified via the file and related map files. Navigator App Config looks like this: App Config {
    "font": "../../data/arial.ttf",
    "map": "../../data/maps/test_29_yandex_weighten_real_map",
    "shadow": false,
    "map_": "../../data/maps/test_08_low_res_simple_map",
    "map__": "../../data/maps/test_10",
    "map___": "../../data/maps/test_07_partially_blocked_map",
    ... Note that "map_” "map__" etc. are not really configuration properties. They are ignored during the application run. Since there is no way to comment on the part of the JSON file, I use underlining in the property name so it can stay in the config file but not be used. looks like this: The map file 25 50 150
#########################
#########################
#########################
###.......#####.......###
###.......#####.......###
###.......#####.......###
###...................###
###.......#####.......###
###.......#####.......###
###...................###
######.###########.######
######.###########.######
######.###########.######
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
######.###########.######
#########################
#########################
#########################
#########################
2 4
2
6 6 4 20 This is one of the simplest examples that contain either blocked or not blocked cells. I have prepared a lot of various examples of input parameters and test data. Starting from very small parts that let you debug and learn the code, finishing with a huge piece of map (from the real existing city) that allows us to measure the performance of a Graph algorithm. How do we draw such maps? When a map contains only cells with binary state (either blocked or non-blocked), this basically means that any edge of a graph either exists or not. To find a path in the graph, we have to represent it efficiently. Like in my previous post, I have used an with the relationship as Vector[NodeId]->points to->Vector[Neighbour Nodes]: adjacency list typedef std::vector<std::vector<std::shared_ptr<Cell>>> Graph; When we exploring grids it's not really necessary to use graphs at all. We are capable to traverse grid using BFS/DFS algorithms cell by cell without thinking about edges. See method for example. _GetPathByBFSOnGrid First, the initialization code reads the file and converts it into row by row and column by column: the grid bool RectangularMap::LoadMap(const std::string& filepath, bool shadow)
{
...
  // Fill the grid.
  _verticesNumber = 0;
  for (int row = 0; row < _height; row++)
  {
    ...
    for (int col = 0; col < _width; col++)
    {
      int x = col;
      int y = row;
      if (line[col] == BLOCK_CELL)
      {
        // Create a shared pointer here to safely pass pointers between the classes.
        _grid[row][col] = std::make_shared<Cell>(x, y, line[col], blockColor, shadow, _scaleFactor);
      }
      else
      {
        ...
      }
    }
  }

  // Make a graph
  InitialiseGraph();
...
} Then, it creates an actual graph as : an adjacency list void RectangularMap::InitialiseGraph()
{
  MapBase::InitialiseGraph();
  ...
  unordered_set<int> visited;

  for (int rr = 0; rr < _grid.size(); rr++)
  {
    for (int cc = 0; cc < _grid[rr].size(); cc++)
    {
      if (_grid[rr][cc]->GetId() > -1)
      {
        for (int i = 0; i < 4; i++)
        {
          int r = rr + dr[i];
          int c = cc + dc[i];

          if (r >= 0 && c >= 0 && r < _width && c < _height &&
              _grid[r][c]->GetId() > -1)
          {
            if (_isNegativeWeighten)
            {
              ...
            }
            else
            {
              _adjacencyList[_grid[rr][cc]->GetId()].push_back(_grid[r][c]);
            }
          }
        }
      }
    }
  }
} Grid representation is useful to draw on the screen using the SFML library. We can draw (this is exactly what I do for small maps): by creating a geometric object ...
for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    _grid[j][i]->Draw(_window, _scaleFactor);
  }
}
...
sf::RectangleShape tile;
tile.setSize(sf::Vector2f(_cellSize - 5, _cellSize - 5));
tile.setPosition(sf::Vector2f(_x * _cellSize, _y * _cellSize));
tile.setFillColor(_color);
window.draw(tile); Or we can do it for larger maps: efficiently pixel by pixel sf::Uint8* pixels = new sf::Uint8[_width * _height * 4];

for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    int index = (_grid[j][i]->GetY() * _width + _grid[j][i]->GetX());

    sf::Color color = _grid[j][i]->GetColor();
    pixels[index * 4] = color.r;
    pixels[index * 4 + 1] = color.g;
    pixels[index * 4 + 2] = color.b;
    pixels[index * 4 + 3] = color.a;
  }
}

sf::Texture texture;
texture.create(_width, _height);
texture.update(pixels);
sf::Sprite sprite;
sprite.setTexture(texture);
sprite.setScale(cellSize, cellSize);
_window.draw(sprite); Finally, let's see what a map defined by file would look like. Originally, the file defined this: test_25_xmax ..............C.................
..............#.................
.............###................
............#####...............
...........#######..............
..........##1###2##.............
.........###########............
........##3######4###...........
.......###############..........
......#################.........
.....###################........
....#####################.......
.............###................
.............###................
.............###................ And a map renderred with SFML looks like this: Because I wanted all of that to be controlled by the user with the keyboard, I left all the user-behavior logic in the . I like to call it “Controller” logic. main.cpp SFML library makes it very easy to handle keyboard events: while (window.isOpen())
{
  Event event;
  while (window.pollEvent(event))
  {
    if (event.type == Event::Closed)
      window.close();

    if (event.type == Event::KeyPressed && event.key.code == Keyboard::Space)
    {
      ... Do what you need here
    }
  }
} The main idea is for user triggers (press of a SPACE button) to read the map file and rendering the map, and then by a second trigger (second press of a SPACE button) to load the routing task and calculate the shortest path between two points on the map: ...
if (navigator->IsReady())
{
  navigator->Navigate(); // Finding route between two points
}
else
{
  if (map->IsReady()) // Second SPACE press runs the routing
  {
    skipReRendering = true;
    if (navigator->LoadTasks(filepath))
    {
      navigator->SetMap(map);
    }
  }
  else // Load and draw map
  {
    drawLoading(window, font);
    if (!map->LoadMap(filepath, shadowed))
    {
      return 0;
    }
    drawProcessing(window, font);
  }
}
... We need to go deeper I wanted to play with more Graph algorithms, and they all have their limitations, so I decided to implement multi-color maps that can be represented by multi-weighted graphs. Every cell is colored, and the color means that the edge not only exists but also applies some weight (or fee, or fine, you name it). So, the edge might be blocked, half blocked, not blocked, ... you got the idea. Thus, I have implemented multi-color maps that look more joyful and look like a game-ready (example from file ): test_31_multi_weight_graph_map Some of the configuration files contain more complex maps from really existing cities, like : test_29_yandex_weighten_real_map As a challenge, now we should handle maps with very flexible configuration. essentially contains a lot of logic inside, including all the graph algorithms and even more than needed (because I like to play with things, even if it's not particularly useful for now). RectangularMap.cpp I have implemented , , , algorithms, and a number of additional "utility" algorithms like Topological Sort, Single Source Path, that are not useful for the current application state (because they work on Directly Acyclic Graphs, which are not type of Graphs I currently use), but I have some ideas to use it in future improvements. BFS#Line 598 Dijkstra#Line 299 A-Star#Line 356 Bellman-Ford#Line 428 I didn't polish all the code and didn't get it ideal enough, but it allows me (and, I hope, will allow you) to play with the code and compare performance metrics. Sorry about some commented lines here and there, maybe some dirty code...it's all way of learning :). To grasp an idea of what's inside, I recommend you review the . RectangularMap.h There are also some fun features, like a Focus feature that allows one to render only a particular part of a map. It changes focus by re-rendering the necessary part using the when the user presses the PgDown or PgUp buttons. It is pretty easy to improve this feature and implement "Zoom" functionality. Take it as a homework, if you like it. Observer pattern Focus feature with map file in work: test_29_yandex_weighten_real_map Classes diagram looks like this: Run and play I believe the most joyful part is just running this little application is playing with variations of its configuration and algorithms. You can do a lot of experiments by using various map files as input parameters with different test data as well as change the logic in the code. After starting, you need to press SPACE an application will render a map according to the configuration file, and it makes a lot of sense to start exploring from the simplest test cases and moving forward to the most complex ones. Pressing SPACE one more time executes the routing algorithms and finds the path between the start and the nearest order. BTW, It's not yet done, but it is easy to implement reading all the rest of the orders available in map configuration files and execute pathfinding to all of them. Here is the route found on the map defined by file : test_18_yandex_super_high_res It is also capable of finding routes in the maps that simulate existing cities, like : test_29_yandex_weighten_real_map Finding efficient paths between two coordinates becomes challenging for algorithms like BFS but can be easily done by A-star. Based on the cells found in the map configuration files, the application will treat the map as a weighted or non-weighted graph and will select the right algorithm for it (and you can easily change this as well). It's easy to see the difference between BFS and A-Star performance: Final words With this, I want to leave you alone and let you play with these code examples. I hope you will find it fascinating and will learn a lot from it. Stay tuned! Links JPS+: Over 100x Faster than A* by Steve Rabin A* Optimizations and Improvements by Lucho Suaya https://hackernoon.com/bfs-dfs-dijkstra-and-a-star-are-basically-the-same-algorithm-ill-show-you-why My blog https://antonyarkov.substack.com/ Also published . here

Graph Traversal Algorithms: Visualizing Performance Variations in Route Finding Algorithms

Tree traversal is a fundamental concept in computer science that involves systematically visiting each node in a tree data structure. Through tree traversal, we can process the nodes in a predetermined order, facilitating operations like searching, sorting, and evaluating expressions. In this article, we will explore three of the most widely used tree traversal methods: inorder, preorder, and postorder. Through clear and concise examples implemented in JavaScript, you will gain a solid understanding of these traversal techniques. Tree Structure Definition Before diving into the tree traversal algorithms, let's define the structure we will be using for the binary tree. The tree will consist of nodes, where each node contains a value and references to its left and right child nodes. function TreeNode(val = 0, left = null, right = null) {
  this.val = val;
  this.left = left;
  this.right = right;
} Now that we have defined the tree structure, we can proceed with exploring the three tree traversal methods. Inorder Traversal Inorder traversal follows the next pattern of visiting nodes in a binary tree - the algorithm first traverses the left subtree, then visits the current node, and finally traverses the right subtree. This ensures that the nodes are visited in ascending order if the tree represents a sorted data structure. A
   /   \
  B     C
 / \   / \
D   E F   G

// Inorder traversal result: D -> B -> E -> A -> F -> C -> G Recursive Inorder Traversal Check if the current node is null. If so, return. Recursively call the function on the left subtree. Visit the current node. Recursively call the function on the right subtree. function inorderRecursive(tree) {
  const result = [];
  
  function inorderTraverse(node) {
    if (!node) return;
        
    inorderTraverse(node.left);
    result.push(node.val);
    inorderTraverse(node.right);
  }
  
  inorderTraverse(tree);
  
  return result;
} Non-recursive Inorder Traversal Initialize an empty stack, and set the current node to the root of the tree. Iterate while the stack is not empty or the current node is not null. Push all left nodes onto the stack until reaching a null left child. Pop a node from the stack, visit it, and set the current node to its right child. Repeat step 2 until the stack is empty, and the current node is null. function inorderRecursive(tree) {
  const stack = [];
  const result = [];
  let currentNode = tree;
    
  while (currentNode || stack.length) {
    while (currentNode) {
      stack.push(currentNode);
      currentNode = currentNode.left;
    }

    const node = stack.pop();
    result.push(node.val);
    currentNode = node.right;
  }

  return result;
} Preorder Traversal In preorder traversal, the algorithm first visits the current node, then traverses the left subtree, and finally traverses the right subtree. This ordering ensures that the nodes are visited in a "top-down" manner, starting from the root and moving toward the leaves. A
   /   \
  B     C
 / \   / \
D   E F   G

// Preorder traversal result: A -> B -> D -> E -> C -> F -> G Recursive Preorder Traversal Check if the current node is null. If so, return. Visit the current node. Recursively call the function on the left subtree. Recursively call the function on the right subtree. function preorderRecursive(tree) {
  const result = [];

  function preorderTraverse(node) {
    if (!node) return;

    result.push(node.val);
    preorderTraverse(node.left);
    preorderTraverse(node.right);
  }

  preorderTraverse(tree);

  return result;
} Non-recursive Preorder Traversal Start with an empty stack, and push the root node onto the stack. Initialize an empty array to store the preorder traversal result. Enter a while loop that runs until the stack is empty. Pop a node from the stack, and visit it by adding its value to the result array. If the node has a right child, push the right child onto the stack. If the node has a left child, push the left child onto the stack. Repeat steps 3-6 until the stack is empty. function preorderTraversal(root) {
  if (!root) return [];

  const stack = [root];
  const result = [];

  while (stack.length) {
    const node = stack.pop();
    result.push(node.val);

    if (node.right) stack.push(node.right);
    if (node.left) stack.push(node.left);
  }

  return result;
} Postorder Traversal In this traversal, the algorithm first traverses the left subtree, then the right subtree, and finally visits the current node. This ordering ensures that the nodes are visited in a "bottom-up" manner, starting from the leaves and moving toward the root. A
   /   \
  B     C
 / \   / \
D   E F   G

// Postorder traversal result: D -> E -> B -> F -> G -> C -> A Recursive Postorder Traversal Check if the current node is null. If so, return. Recursively call the function on the left subtree. Recursively call the function on the right subtree. Visit the current node. function postorderRecursive(tree) {
  const result = [];

  function postorderTraverse(node) {
    if (!node) return;

    postorderTraverse(node.left);
    postorderTraverse(node.right);
    result.push(node.val);
  }

  postorderTraverse(tree);

  return result;
} Non-recursive Postorder Traversal Start with an empty stack, and push the root node onto the stack. Initialize an empty array to store the postorder traversal result. Enter a while loop that runs until the stack is empty. Get the top node from the stack (without removing it). If the node has a left child, push the left child onto the stack, and set the left child of the current node to null. If the node has a right child, push the right child onto the stack, and set the right child of the current node to null. If the node has neither a left nor a right child, it is a leaf node. Pop the node from the stack, and add its value to the result array. Repeat steps 4-7 until the stack is empty. function postorderTraversal(root) {
  if (!root) return [];

  const stack = [root];
  const result = [];

  while (stack.length) {
    const node = stack[stack.length - 1];

    if (node.left) {
      stack.push(node.left);
      node.left = null;
    } else if (node.right) {
      stack.push(node.right);
      node.right = null;
    } else {
      result.push(stack.pop().val);
    }
  }

  return result;
} Conclusion I hope that you now have a clear understanding of the differences between inorder, preorder, and postorder traversal in JavaScript. With the knowledge and examples provided, you are now equipped to apply these techniques to your own tasks and projects effectively.

Exploring Tree Traversal in JavaScript: Inorder, Preorder, and Postorder With Examples

জাভাস্ক্রিপ্টে ট্রি ট্রাভার্সাল অন্বেষণ: উদাহরণ সহ ইনঅর্ডার, প্রিঅর্ডার এবং পোস্টঅর্ডার

Erkunden der Baumdurchquerung in JavaScript: Inorder, Preorder und Postorder mit Beispielen

Explorando Tree Traversal en JavaScript: Inorder, Preorder y Postorder con ejemplos

Explorer la traversée d'arbres en JavaScript : Inorder, Preorder et Postorder avec des exemples

जावास्क्रिप्ट में ट्री ट्रैवर्सल की खोज: उदाहरणों के साथ इनऑर्डर, प्रीऑर्डर और पोस्टऑर्डर

JavaScript でのツリー トラバーサルの探索: インオーダー、プレオーダー、ポストオーダーと例

JavaScript의 트리 순회 탐색: 예제를 통한 중순, 선순, 후순

Explorando Tree Traversal em JavaScript: Inorder, Preorder e Postorder com exemplos

JavaScript'te Ağaç Geçişini Keşfetmek: Örneklerle Inorder, Preorder ve Postorder

Khám phá tính năng duyệt cây trong JavaScript: Đặt hàng trước, đặt hàng trước và đặt hàng sau với các ví dụ

探索 JavaScript 中的树遍历：带示例的中序、先序和后序

As law practice across the world slowly embraces a slew of digital technologies, the need to eventually bridge the gap between law and becomes more pronounced. technology Although transitioning to automation is a complex process, it's achievable in the long run. Moreover, studies have shown that lawyers and law firms that gravitate toward technology solutions offered by AI tools have a competitive advantage in this era. At the intersection of law and technology is seasoned American tech and IP attorney Schaefer, the founder of Traverse Legal PLC. Enrico Schaefer built , the world's first AI-enabled web application built upon 's state-of-the-art Large Language Model(LLM). By design, Traverse AI provides 24/7 client-assisted information on a range of legal issues–free of charge. Traverse AI OpenAI I recently sat down with Mr. Schaefer to discuss the impact of technology on the legal industry. Read on! Mr. Schaefer, you are practising at the intersection of law and technology. How did you get there? In 1992, I left my law firm to become the General Counsel of a technology startup in Boulder, Colorado. The company was working on new and emerging technology projects for a new and emerging technology called ‘the Internet.’ I have been ‘all in’ on technology and technology law ever since. Most people agree that there is a huge gap between law and technology. Why do they still overlap despite the advances we've seen in automation? The disconnect between technology, innovation, and law firms has to do with the general hesitancy of lawyers to change. Unlike many other industries, there has been less competition in law because of the advertising restrictions and disparity in expertise between lawyers and clients. The internet dramatically changed that dynamic by making information available to clients, previously only to lawyers. Law firms were eventually forced to change as more innovative, smaller firms integrated technology. Let's face it, lawyers get up in the morning to bill hours. Why would law firms want to be able to perform more work in less time in an hourly billing environment? We developed Traverse AI as a client intelligence tool. It provides free legal information to clients, information that they would have had to pay an hourly fee to access. Sure, we have reduced the reliance of clients on lawyers and the number of hours which might be billed. But we will have more intelligent clients better equipped for success. And we will be there to help them grow.  That is far more valuable. That is innovation. What makes one a 21st-century lawyer? A 21st-century lawyer is open to changing the way law firms operate and innovate in the business of law. There is no real threat caused by being able to provide better quality work and less time to clients. If it takes me 10 minutes to do something that used to take me an hour, that leaves me 50 minutes to do more strategic and valuable work for my client. Lawyers spend a lot of time putting out fires. In the age of AI, lawyers will spend more time helping their clients grow, innovate, and become successful. According to a recent survey, there is a growing number of lawyers across the world who believe that AI will take their jobs. Is this fear unfounded? There is still a lot of unknown. I think that lawyers who are less talented and innovative will see their jobs threatened by AI. However, the best lawyers will have their talents amplified and enhanced by AI. The best lawyers will lean into the technology. The best lawyers will become better and more sought after. The old-guard law firms will talk a big game about AI but will not be able to integrate AI at a significant level. https://youtu.be/f2vxqVNRyCs?embedable=true The larger your organization, the more people there are to convince, train, and change. Our law firms will have the greatest potential benefit from AI. They will be able to implement the AI tools that are coming more quickly, more efficiently, and more comprehensively. Do you agree that ChatGPT can and should be harnessed by lawyers? Why? ChatGPT and many other artificial intelligence tools being developed and deployed will assist lawyers and clients in identifying, analyzing, and resolving legal issues. Much of the use will be dedicated to assisting lawyers so they can do better work in less time. A percentage of work done by lawyers will no longer be necessary since clients can access answers using AI. represents an apocalypse to traditional law firms and traditional legal business models. AI IP issues have found their way into the crypto sphere. Is this an interesting development? Finally, two years ago, I beat a drum that few projects were listening to. Because these crypto and NFT projects had [FOMO](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC8283615/#:~:text=Fear%20of%20missing%20out%20(FoMO,to%20maintain%20these%20social%20connections.), they did not stop to consider the legal issues that were mission-critical to their success. They did not consider the importance of identifying, protecting, and growing their IP. NFT projects licensed digital assets without owning the copyright or in assets to which there could be no copyright. A few projects performed a trademark clearance search to make sure they could establish rights in their project name. As a result of the market downturn, these projects can now take a breath and consider IP as the threshold to their business success. With the growing adoption of blockchain technology, how do you think crypto should be regulated? As a lawyer, I spend less time thinking about a wishlist and more time considering the reality of the situation. The is putting many crypto projects, crypto exchanges, and NFT projects into the securities basket. That's the reality. Congress is taking forever to develop a regulatory scheme that will work for consumers and the blockchain industry. While many projects have downplayed the investment aspect of their business model, there are going to be projects which will fall within any and all definitions of security. SEC What's the toughest part of being a tech lawyer? It would be the amount of time you spend learning about new technology; Time spent digging in on complex software and hardware issues. Fortunately, I love technology and learning about new technology. Technology is the catalyst that changes the world. Technology is always good in that it forces people to think about important issues without change we often drift through the world without questioning how and why we do what we do. How did the Covid-19 pandemic affect legal practice in the US? COVID inflicted massive amounts of change across the entire industry. It caused courts, lawyers, law firms, law schools, law students, and judges to completely rethink notions of legal practice and court operations. Zoom hearings and remote work are now forever part of the delivery of legal services. That's for the best, and I love that we were forced to think about why we were doing certain things as lawyers, as courts, as judges, and as law schools. As mentioned above, the more dramatic the impetus to change, the more innovation potential. And I love innovation Any parting words? AI and blockchain will complement each other in ways we cannot imagine. These are two of the most powerful technologies in the history of mankind. We are about to see a decade of innovation, change, and challenge unlike we have ever seen in human history. There will be some good, and there will be some bad, but at the end of the day, we will have to think about what is best for mankind. Ultimately, we will be pushed to consider what it means to be human, what is true and whether our current economic system is as idyllic as we think. The lead image for this article was generated by HackerNoon's via the prompt "a law firm on fire". AI Image Generator

AI Represents an Apocalypse to Traditional Law Firms: Traverse AI Founder Enrico Schaefer

Over the past few years, markets have faced five significant "uncertainty shocks." The first was the 2016 Brexit vote, followed by the U.S. presidential elections, trade tensions between China and the United States, the COVID-19 pandemic, and, in 2022, the Russian invasion of Ukraine. As their cumulative effect, the global economy took a hit, and with mass layoffs, rising inflation, and high-interest rates, experts that we are staring at the face of a recession. believe “We are now expecting global growth to be around 1.7%. This is half of almost what we expected six months ago. So, the global economy is on a razor's edge. Even a small shock can trigger an outright recession,” Ayhan Kose, Director of the World Bank’s Prospects Group. says Surviving the Storm: How Businesses are Weathering the Economic Turbulence Back in June 2022, the World Bank that the world is entering a lengthy patch of weak growth owing to “significant disruptions in trade and food and fuel price shocks, all of which are contributing to high inflation and subsequent tightening in global financing conditions. ” announced “Higher energy and food prices will weigh on household demand and will affect heavily poorer segments, who devote 50 percent of their monthly spending on food and energy,” said Cristina Savescu, World Bank senior economist for the EU countries. The food crisis has worsened due to the conflict in Ukraine. The Food and Agriculture Organization's Update of the Global Report on Food Crises (GRFC) that the number of people facing acute food insecurity in mid-2022 was the highest in the six-year history of the report. A staggering 205 million people in 45 countries were facing acute food insecurity and required urgent external assistance. stated The price volatility, supply shortages, security issues, and economic uncertainty have contributed to what the International Energy Agency (IEA) is “the first truly global energy crisis, with impacts that will be felt for years to come”. calling The surge in energy prices is the most prominent change we are witnessing. According to IEA, approximately 90% of the overall increase in electricity generation expenses worldwide is attributed to elevated fuel costs. This, combined with the impact of the global pandemic, is resulting in 70 million people who consume electricity being unable to afford it, while a roaring 100 million might revert to using biomass for cooking rather than clean fuels. While higher costs for traditional fuels may encourage the transition towards sustainable alternatives, there remains a high probability that concerns over energy security could drive further investment in fossil fuel initiatives. A by energy thinks tank Ember shows that Europe’s green energy transition is already in motion. Solar and wind power generated more than a fifth (22%) of its electricity in 2022, pulling ahead of fossil gas (20%) for the first time, according to the European Electricity Review 2023. new report Businesses, in general, were reframing their operational models to assure long-term growth since the downturn spiral began with the Covid-19 outbreak, followed by a recession. These jolts prepared the retailers for the rude awakening of global inflation and the Ukraine war. Global inflation intensified, and supply chain issues that tore the economy due to Covid 19 restrictions rose to an all-time high when companies based out of the US and Europe were affected due to their supply dependencies on Russia and Ukraine. over 300,000 Supply chain issues created a ripple effect leading to a significant surge in gas prices worldwide. In 2021, the average cost per liter of gasoline in The Netherlands was around $7.11 per gallon, but by March 2022, the price had risen to approximately $9.43 per gallon, to Statista. The United States also saw a surge in gas prices, with prices reaching of $4.17 per gallon. according record-breaking levels The increase in gas prices led to an increase in shipping costs with additional charges for deliveries. For the China- EU shipping lanes, TIME “Transporting a 40-foot steel container of cargo by sea from Shanghai to Rotterdam now costs a record $10,522, a whopping 547% higher than the seasonal average over the last five years.” reports Amid economic uncertainty, rising living expenses, job insecurity, and other mounting concerns, consumers have shifted their focus to prioritizing essential purchases and reducing discretionary spending. As a result, the largest warehouse and distribution market in the United States is with its merchandise, with slowing sales of clothing, electronics, furniture, appliances, and other goods. This setback is not limited to small and mid-size retailers, as even major retailers such as have been impacted by markdowns. experiencing difficulties Walmart and Target In response to the changing consumer behaviors and cold economic headwinds, big names in the Tech and FinTech industries that hit a record high during the pandemic, are cutting down headcounts. According to , a total of 121,205 tech workers have been laid off in 2023. The reasoning behind these workforce reductions follows a common script, quoting macroeconomic environments leading to cutting operational costs and increasing profitability. Layoffs.fyi Tech-nically Speaking: How Innovation Can Save the Economy (and the Planet) The current crisis presents a rare opportunity to hit the reset button and steer the world toward a more sustainable future. With the global population growth and aging, coupled with a resurgence of extreme poverty, there is a need to enhance productivity by doing more with less and reducing natural resource consumption. To achieve this, a fundamental transformation is required across the major sectors that underpin our economies, such as healthcare systems, infrastructure, energy, and transportation. In essence, our daily lives need a significant overhaul. Industries are desperate for a revival and as it appears, technology has been crucial in maintaining the functionality of our society and economy during this crisis and can play a monumental role in driving a sustainable economic recovery. A global conducted by PR Newswire of over 1,000 professionals concluded that automation had become a fundamental technology for businesses to face the uncertain economy. study 95% of the participants regarded automation as the key component in their transformation strategies. 94% reported that it is widely used to tackle supply chain problems, and 61% strongly agree that it has also addressed staffing shortages. Furthermore, 92% of the respondents have adjusted their automation plans to some extent in response to global events that took place in the past year. Deloitte's 2022 Global Intelligent Automation survey that 74% of participants have already implemented robotic process automation (RPA). In addition, forecasts a 17.5% growth rate for the global RPA software market in 2023. reveals Gartner Inc. In this highly volatile market, companies can leverage Artificial Intelligence to collect data such as prevailing market trends, key business drivers, demographic information, real-time happenings, etc. to offer clear insights and curate personalized interfaces for enhanced user experience. According to a , 87% of marketers report positive results from personalization. survey As per a conducted by the Cambridge Centre for Alternative Finance (CCAF) at the Judge Business School of the University of Cambridge and the World Economic Forum, the use of artificial intelligence (AI) is bringing about significant changes to various models in the global financial services industry. study It showed that AI is changing how financial institutions generate and utilize insights from data, which in turn propels new forms of business model innovation and reshapes competitive environments and workforces. They are lately shifting from mainly using AI to reduce costs to utilizing its capabilities for revenue generation. The pandemic reminds us that healthy economies are directly proportional to healthy populations. The healthcare system is also under pressure due to insufficient resources and rising costs. The technology here can be used for diagnosis and suggesting treatments. Digital assistants powered by AI, for example, can assist radiologists in processing medical images and hence help with diagnosis. The shift to a clean economy represents one of the most significant challenges and opportunities of this decade, considering that fossil fuels generate This transition will require a profound overhaul of manufacturing processes, energy consumption patterns, and transportation methods. 80% of the world's energy consumption. , buses, trucks, trains, and ships, in conjunction with promoting renewable energy, can help decarbonize the transport sector, which currently contributes to almost a quarter of all global emissions. Electric cars Hydrogen-based solutions are emerging as a fast and efficient way to accelerate the transition toward sustainable energy. As part of this effort, Siemens is with Deutsche Bahn, a German railway company, to develop fuel cell trains powered by hydrogen, aimed at replacing their diesel fleet. By switching to hydrogen-based propulsion, the new trains will save approximately 330 tons of carbon dioxide annually. collaborating Smart grid technologies also have the potential to facilitate the integration of renewable sources while ensuring a reliable supply of energy. An example of this is a that has been saving a tribal community more than $200,000 annually in energy costs, while also reducing carbon emissions by 200 tons per year. smart microgrid in Northern California As it goes, technology alone cannot counter the challenges to a sustainable economy. It requires solid decisions and collective actions. Companies must invest in new technologies, even in times of crisis, while governments must implement policies and stimulus programs that drive transformation and innovation. According to McKinsey, those during the recovery. And industry leaders could potentially achieve a greater productivity increase from investments in new technology than followers (70% vs 30%), according to a . companies that invest in innovation during a crisis outperform their peers study from the World Economic Forum

Navigating Economic Downturns and The Role of Technology in Helping Industries Traverse the Unknown

অর্থনৈতিক মন্দার নেভিগেট করা এবং শিল্পকে অজানা অতিক্রম করতে সহায়তা করার ক্ষেত্রে প্রযুক্তির ভূমিকা

Bewältigung wirtschaftlicher Abschwünge und die Rolle der Technologie bei der Bewältigung des Unbekannten für Industrien

Navegando las recesiones económicas y el papel de la tecnología para ayudar a las industrias a atravesar lo desconocido

Naviguer dans les ralentissements économiques et le rôle de la technologie pour aider les industries à traverser l'inconnu

आर्थिक मंदी को नेविगेट करना और उद्योगों को अज्ञात को पार करने में प्रौद्योगिकी की भूमिका

景気後退の切り抜けと、業界が未知の世界を横断するのを支援するテクノロジーの役割

경제 침체 탐색 및 산업이 미지의 영역을 헤쳐나갈 수 있도록 지원하는 기술의 역할

Navegando em crises econômicas e o papel da tecnologia em ajudar as indústrias a atravessar o desconhecido

Ekonomik Gerilemelerle Mücadele ve Endüstrilerin Bilinmeyeni Aşmasına Yardımcı Olmada Teknolojinin Rolü

Điều hướng suy thoái kinh tế và vai trò của công nghệ trong việc giúp các ngành vượt qua những điều chưa biết

驾驭经济衰退和技术在帮助行业穿越未知中的作用

If you know about the breadth-first search algorithm, and even if you don't, you will be able to easily understand Dijkstra's algorithm as we address it in this article. The Breadth-first Search of a Graph The first algorithm that I would like to describe is the search of a graph. breadth-first What is it? Let's step back from the formal description of graphs and imagine a picture. We lay out ropes on the ground, soaked in something flammable, of the same length so that none of them intersect, but some of them touch each other at the ends. And now we light one end. How will the fire behave? It will spread evenly over the ropes to neighboring intersections until everything ignites. It is easy to generalize this picture to three-dimensional space. This is what the breadth-first search of a graph will look like in real life. Now let's describe it more formally. Let us start the breadth-first search from some vertex V. In the next moment of time, we will examine the neighbors of vertex V (a neighbor of vertex V is a vertex that shares an edge with V). And so on until all the vertices in the graph have been examined. Implementation of breadth-first search Suppose we are in some vertex during the breadth-first search process. Then we will use a queue into which we will add all the neighbors of the vertex except those that we have already visited. void bfs(int u) {
  used[u] = true;
  queue<int> q;
  q.push(u);
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    for (int i = 0; i < (int) g[u].size(); i++) {
      int v = g[u][i];
      if (!used[v]) {
        used[v] = true;
        q.push(v);
      }
    }
  }
} In this implementation, g is the adjacency list, i.e. g[u] contains a list of adjacent vertices to u (std::vector is used as a list), and used is an array that allows us to understand which vertices we have already visited. Here, breadth-first search does nothing except for the search itself. It may seem unnecessary, but it can be easily modified to find what we need, such as the distance and path from any vertex to all others. It should be noted that the edges do not have weights, i.e. the graph is unweighted. Here is an implementation of the search for distances and paths. void bfs(int u) {
  used[u] = true;
  p[u] = u;
  dist[u] = 0;
  queue<int> q;
  q.push(u);
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    for (int i = 0; i < (int) g[u].size(); i++) {
      int v = g[u][i];
      if (!used[v]) {
        used[v] = true;
        p[v] = u;
        dist[v] = dist[u] + 1;
        q.push(v);
      }
    }
  }
} Here, p is an array of ancestors, i.e. p[v] is the ancestor of vertex v, and dist[v] is the distance from the starting vertex of the traversal to vertex v. How to restore the path? It's quite easy to do, just by traversing through the array of ancestors of the required vertex. For example, recursively: void print_way(int u) {
  if (p[u] != u) {
    print_way(p[u]);
  }
  cout << u << ' ';
} Shortest paths All further reasoning will be valid only if the edge weights are non-negative. Now let's move on to weighted graphs, where the edges of the graph have a weight, such as the length of the edge, the fee for passing through it, or the time it takes to pass through it. The task is to find the shortest path from one vertex to another. In this article, I will start with the breadth-first search and I don't recall seeing such an approach anywhere else. Maybe I missed it. So let's take a look at the breadth-first search implementation again, specifically at the condition for adding to the queue. In the breadth-first search, we only add to the queue those vertices that we haven’t been to yet. Now, we will change this condition and add those vertices whose distance can be reduced. Obviously, the queue will be empty only when there are no vertices left whose distance can be reduced. The process of reducing the path from vertex V is called vertex V relaxation. It should be noted that initially, the path to all vertices is infinity (take some sufficiently large value as infinity, namely, such that no path will have a length greater than the value of infinity). This algorithm directly follows from breadth-first search, and it was the first algorithm I came up with when solving my first problem of finding the shortest paths in a graph. It is worth mentioning that this method finds the shortest paths from the vertex from which we started the algorithm to all others. Here is the implementation: const int INF = 1e+9;

vector< pair<int, int> > g[LIM]; // In g[u] there is a list of pairs: (the length of the path between vertex u and v, vertex v).

void shortcut(int u) {
  fill(dist, dist + n, INF);
  dist[u] = 0;
  p[u] = u;
  queue<int> q;
  q.push(u);
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    for (int i = 0; i < (int) g[u].size(); i++) {
      int v = g[u][i].second, len = g[u][i].first;
      if (dist[v] > dist[u] + len) {
        p[v] = u;
        dist[v] = dist[u] + len;
        q.push(v);
      }
    }
  }
} Why do we store such pairs in the adjacency list? It will become clear a little later when we improve this algorithm, but to be honest, for this implementation, the pairs can be stored the other way around. We can slightly improve the queue insertion process by introducing a bool array to mark whether the vertex that needs to be relaxed is currently in the queue. const int INF = 1e+9;

vector< pair<int, int> > g[LIM];
bool inque[LIM];

void shortcut(int u) {
  fill(dist, dist + n, INF);
  dist[u] = 0;
  p[u] = u;
  queue<int> q;
  q.push(u);
  inque[u] = true;
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    inque[u] = false;
    for (int i = 0; i < (int) g[u].size(); i++) {
      int v = g[u][i].second, len = g[u][i].first;
      if (dist[v] > dist[u] + len) {
        p[v] = u;
        dist[v] = dist[u] + len;
        if (!inque[v]) {
          q.push(v);
          inque[v] = true;
        }
      }
    }
  }
} If you take a closer look, this algorithm is very similar to the Levit algorithm, but it's not the same, even though in the worst-case scenario it has the same asymptotic complexity. Let's make a rough estimate of this. In the worst-case scenario, we will have to perform relaxation each time we pass through any edge. The total is O(n * m). The estimate is quite rough, but it's enough for the initial stage. It's also worth noting that this is the worst-case scenario, and in practice, even such an implementation works quite quickly. And now, the most interesting part!... drum roll... Let's improve our algorithm to Dijkstra's algorithm! Dijkstra's Algorithm The first optimization that comes to mind is to relax only those vertices whose current path is minimal. This idea came to me one fine day, but as it turns out, I was far from the first. The wonderful scientist Edsger Dijkstra was the first to come up with this idea. Moreover, he proved that by choosing vertices for relaxation in this way, we will perform relaxation no more than n times! Intuitively, it is clear that if the path to a certain vertex is currently minimal, we cannot make it any smaller. You can read about it on . Wikipedia Now the only thing left to do is to understand how to efficiently find the vertex with the minimum distance to it. To do this, we will use a priority queue (heap). The STL has a class that implements it and is called . I will provide an implementation that, again, directly follows from the previous (described in this article) algorithm. priority_queue void dijkstra(int u) {
  fill(dist, dist + n, INF);
  dist[u] = 0;
  p[u] = u;
  priority_queue< pair<int, int>, vector< pair<int, int> >, greater< pair<int, int> > > q;
  q.push(make_pair(0, u));
  while (!q.empty()) {
    pair<int, int> u = q.top();
    q.pop();
    if (u.first > dist[u.second]) continue;
    for (int i = 0; i < (int) g[u.second].size(); i++) {
      int v = g[u.second][i].second, len = g[u.second][i].first;
      if (dist[v] > dist[u.second] + len) {
        p[v] = u.second;
        dist[v] = dist[u.second] + len;
        q.push(make_pair(dist[v], v));
      }
    }
  }
} Most likely it's not entirely clear what's going on here. So, let's start with declaring a priority queue. Here, the first template argument is the data stored in the queue, specifically pairs of the form (distance to the vertex, vertex number). The second template argument is the container in which the data will be stored, and the third argument is the comparator (which, by the way, is found in the functional header file). Why do we need a different comparator? Because with the standard declaration of , we'll only be able to extract the vertices with the maximum distance, whereas we actually need the opposite. The asymptotic complexity of this solution to the problem is O(n * log(n) + m * log(n)). priority_queue< pair<int, int> > Indeed, we only have n relaxations, and we can find the vertex with the minimum path length to it in log(n) time (which is the asymptotic complexity of the standard priority queue implementation in the STL). It should also be noted that we may end up adding the same vertex to the queue with different paths to it. For example, we may have relaxed from vertex A, whose neighbor is vertex C, and then relaxed from vertex B, whose neighbor is also vertex C. To avoid problems related to this, we simply skip the vertices that we extracted from the queue, but whose distance from the queue is no longer relevant, i.e. greater than the current shortest path. This is why the implementation includes the line "if (u.first > dist[u.second]) continue;". Conclusion It turns out that it is actually very easy to implement Dijkstra's algorithm with a time complexity of O(n * log(n) + m * log(n)).

Exploring Graph Traversal: From Breadth-First Search to Dijkstra's Algorithm

Meriem had traversed half the length of the village street

This article will break down the process of building a versatile traverse function from scratch. But first, we need to clarify what is it exactly. What is the traverse function? Here is one of the plainest explanations I could find; A data structure contains elements, which contain data. Traversing a data structure means: “visiting” or “touching” the elements of the structure, and doing something with the data. The keywords in this definition are . visiting data structure elements and First, there is no “ ” if there is nothing to visit ( ). visiting elements Second, “data structure” is a very broad term. In the most general terms, a data structure is a collection of data stringed together somehow, arranged in some logical order, where one data point is connected to another, and so on. A data structure could be a dictionary, a , an array of items, a , and the list goes on. These are common concepts in computer science, and they have been implemented in almost every programming language albeit they might go by different names. linked list tree of nodes Data structures are almost geometrical in nature. If you were to draw a representation on a whiteboard, they would look like strips, squares, triangles, circles, and trees too. The simpler the shape, the easier it is to traverse it, and many programming languages have built-in functions for it. The easiest shape would be “strips”, like arrays. These simple data structures are trivial to traverse and the term **iteration **is typically used instead, which marks a sort of distinction in simplicity. The kind of traversing we are interested in discussing in this article is the less trivial kind; that one used to visit nodes on a complex data structure. Iteration Now that we know what traversing means, we can start sketching what the function would look like. const traverse = (target: unknown): void => {
  /** Do something here **/
}

traverse({ ... }) There is no point in traversing unless we want to do something. What we want to do on each data point is not important, only that we are able to do so. What is needed then is a to which we can delegate whatever task we want to run on each data point. callback function const traverse = (target: unknown, callback: Function): void => {
  /** 
   * Do something here, eventually invoke callback().
   **/
}

const callback = (data: unknown): void => {
  /** Do something here with data point **/
}

traverse({ ... }, callback) We will repeat the operation for each data point, which we call iteration. Support any data structure The first problem with creating a versatile traverse function is that it’ll need to know how to navigate to each data point in a data structure. We use TypeScript for the code examples. So in JavaScript, the obvious place to start is by being able to navigate to each item or key-value pair in an array or object. But are we missing out on other data structures? What about Map, WeakMap, and Set support? We can add code to iterate for those too. Except that the traverse function may also run into class instances created by anyone. Sometimes, data points don’t necessarily map to all properties on a class instance. But we don’t know what we don’t know. To overcome this problem, we need to “inform” the traverse function of other data structures and give it a set of instructions for each data point. const registeredIterableClasses: IterableClassEntry[] = []

const registerIterableClass = (entry: IterableClassEntry): void => {
  registeredIterableClasses.push(entry)
}

const traverse = (target: unknown, callback: Function): void => {
  /**
   * 1. If target is a non-iterable type, exit early.
   * 2. If the target is iterable, access registeredIterableClasses
   *    and find the correct strategy to read the iterable's references.
   * 3. Invoke callback() on each data point traversed.
   **/
}

const callback = (data: unknown): void => {
  /** Do something here with data point **/
}

traverse({ ... }, callback) Knowing how to access references to a data structure is a start. Remember, we want to make traverse() as versatile as possible. Perhaps the callback should be able to change values or remove values. What if we want to clone the data? We now realize that to give the necessary instructions to traverse() for dealing with a data structure, we need to give it more. interface IterableClassEntry {
  classRef: any // Reference to class itself as id
  instantiate: Function // use to create a new instance of the class
  getKeys: Function // use to get a list of references to each data point
  read: Function // use to read a value
  write: Function // used to update a value
  remove: Function // used to remove a reference to a value
} Support Nesting Now, we have addressed how to traverse data structures. The next issue to tackle is that data structures may contain other data structures. We can use recursion for that. We call the same traverse function on each data point being traversed so that it in turn does the same for any data points in them as well. And so on, until it encounters no more iterable data structures. const registeredIterableClasses: IterableClassEntry[] = []

const registerIterableClass = (entry: IterableClassEntry): void => {
  registeredIterableClasses.push(entry)
}

const traverse = (target: unknown, callback: Function): void => {
  /**


1. Immediately invoke callback(target).
2. If the target is iterable, access registeredIterableClasses
   and find the correct strategy to read the iterable's references.
3. Invoke traverse() on each data point traversed.
**/
}


const callback = (data: unknown): void => {
  /** Do something here with data point **/
}

traverse({ ... }, callback) Dealing with Circular References Last but not least, there are data structures that at some point reference themselves. It is a plausible scenario, you may find this on a “circular” — looking type structure, like a graph. If you were to encounter that and the algorithm does not know how to detect it, it will most likely cause an infinite loop or livelock and cause your program to run out of memory and freeze or terminate. This topic could be another article on its own. I will write about it later. Optimizations A traverse function might be quite expensive. Sometimes you may only want to run this against a slice or “depth range” and or have an exit early strategy to avoid iterating unnecessarily on other data points once you have the outcome you need from the callback. Final Result I hope this quick guide has helped you understand the key details to implement your own traverse function. If you can’t be bothered creating your own, you are in luck. I’ve already created this production-ready function for anyone to use. traverse() Also published here. Lead image

How to Build a Versatile Traverse Function from Scratch

This post is about preorder traversal of a binary tree, a method of traversing the tree in which the current node is visited before its children. The preorder traversal algorithm visits the root node first, then recursively visits the left subtree, followed by the right subtree. The result of a preorder traversal is a list of the nodes' values in the order they are visited. This post will help you to understand how to traverse a binary tree and also how to implement it in different ways. Preorder traversal is a method of traversing a binary tree where the current node is visited before its children. The algorithm visits the root node first, then recursively visits the left subtree, followed by the right subtree. The result of a preorder traversal is a list of the nodes' values in the order they are visited. In this problem, you are given the root of a binary tree represented by the class in Kotlin, which has a property for the node's value and and properties for its left and right children, respectively. Your task is to write two implementations of a function that performs a preorder traversal of the binary tree and returns a list of the nodes' values. One should be a recursive solution and the other should not use recursion. TreeNode val left right Here is the class signature of the function: fun preorderTraversal(root: TreeNode?): List<Int> The input to the function is the root node of the binary tree, and the output is a list of integers representing the values of the nodes in the order they are visited during the preorder traversal. Descriptions: Given the root of a binary tree, return the preorder traversal of its nodes' values. Do this both with a recursive solution and without using recursion. class TreeNode(var `val`: Int) {
    var left: TreeNode? = null
    var right: TreeNode? = null
} Here is a recursive solution to the problem: fun preorderTraversal(root: TreeNode?): List<Int> {
    val result = mutableListOf<Int>()
    if (root == null) return result
    result.add(root.val)
    result.addAll(preorderTraversal(root.left))
    result.addAll(preorderTraversal(root.right))
    return result
} This function does a preorder traversal of the binary tree and returns a list of the nodes' values in the order that they are visited. The algorithm works as follows: If the root node is null, return an empty list. Add the root node's value to the result list. Recursively traverse the left subtree by calling the function on the root's left child and add the returned list to the result list. Recursively traverse the right subtree by calling the function on the root's right child and add the returned list to the result list. Return the result list. This algorithm has a time complexity of O(n), where n is the number of nodes in the tree, and a space complexity of O(h), where h is the height of the tree (due to the call stack). Here is a solution using an iterative approach (i.e., without using recursion): fun preorderTraversal(root: TreeNode?): List<Int> {
val result = mutableListOf<Int>()
val stack = Stack<TreeNode>()
var current = root
while (current != null || stack.isNotEmpty()) {
    while (current != null) {
        result.add(current.val)
        stack.push(current)
        current = current.left
    }

    current = stack.pop()
    current = current.right
}
return result
} This function does a preorder traversal of the binary tree and returns a list of the nodes' values in the order that they are visited. It uses a stack to keep track of the nodes that still need to be visited. The algorithm works as follows: Initialize an empty stack and set the current node to the root of the tree. While the current node is not null or the stack is not empty: While the current node is not null: Add the current node's value to the result list. Push the current node onto the stack. Set the current node to its left child. Pop the top node from the stack and set the current node to its right child. Return the result list. This algorithm has a time complexity of O(n), where n is the number of nodes in the tree, and a space complexity of O(h), where h is the height of the tree. I hope this helps! Let me know if you have any other questions.

Kotlin Binary Tree Preorder Traversal (A Recursive Solution and Without Using Recursion)

Kotlin Binary Tree Preorder Traversal (una solución recursiva y sin usar recursividad)

Kotlin Binary Tree Preorder Traversal (une solution récursive et sans utiliser la récursivité)

कोटलिन बाइनरी ट्री प्रीऑर्डर ट्रैवर्सल (एक पुनरावर्ती समाधान और पुनरावर्तन का उपयोग किए बिना)

Kotlin Binary Tree Preorder Traversal (再帰的なソリューションであり、再帰を使用しない場合)

Traversal de pré-ordem de árvore binária Kotlin (uma solução recursiva e sem usar recursão)

Kotlin Binary Tree Preorder Traversal (Một giải pháp đệ quy và không sử dụng đệ quy)

Kotlin 二叉树前序遍历（一种递归解决方案，不使用递归）

Stories, News & Mentions about TRUVERIS

Categories

Trending Topics

Stories, News & Mentions about TRUVERIS

Truveris’s Stories on HackerNoon

Categories

Trending Topics