1672364808

## Spanning Tree Protocol (STP) Explained. You heard the words Spanning Tree, now it is time to understand what it is all about. This is a tutorial that will start from the very beginning of spanning tree and you will walk away with how it begins.

We start with the very beginning, discussing how L3 uses a mechanism to prevent loops. We quickly find out that L2 does not have this mechanism and why Spanning Tree is needed. Then we enter the world of Spanning Tree. Exploring how spanning tree forms it topology and the election processes.

From there we enter into a step by step process, understanding how Spanning Tree starts to build its own topology. We learn about the Root Bridge, Root Ports, Designated Ports, Blocking ports, and so on.

If you want to really understand Spanning Tree, this is where you begin.

- Learn the Basics of Spanning Tree from Scratch
- Learn how Time-To-Live Works
- Learn What a Loop is
- Learn what a Single Point of Failure is
- Learn what Redunancy means
- Learn Why we need Spanning Tree
- Learn Why it is Called Spanning Tree
- Learn what BPDUs are
- Learn what a Root Bridge is
- Learn what a Root Port is
- Learn what a Designated Port is
- Learn what a Blocking Port is
- Learn what a Bridge-ID is
- Learn what Spanning Tree Cost is
- Learn what Spanning Tree Port-Priority is
- Learn how the Root Bridge Election Works
- Learn how the Root Port Election Works

- You should know basic Switching concepts but not 100% necessary
- Spanning Tree is a seperate lesson and can be learned without previous knowledge
- A CCNA Studnet should learn Spannning Tree after learning Networking and Switching Fundementals, but it is not 100% necessary

- This course is for those who want to learn spanning tree
- If you have no idea what spanning tree is, this course is for you
- Those who need a review of Spanning Tree
- This is not for those looking for advance Spanning Tree topics
- Those who need a review of Spanning Tree Basics
- Those who question their spanning knowledge
- This course will NOT cover Spanning Tree Timers or Port Roles
- This course will NOT cover the Listening, Learning, and Forwarding stages

#cisco #ccna

1598227320

Given a **Generic tree**, the task is to **delete** the leaf nodes from the **tree**.

** Examples:**

```
Input:
5
/ / \ \
1 2 3 8
/ / \ \
15 4 5 6
Output:
5 : 1 2 3
1 :
2 :
3 :
Explanation:
Deleted leafs are:
8, 15, 4, 5, 6
Input:
8
/ | \
9 7 2
/ | \ | / / | \ \
4 5 6 10 11 1 2 2 3
Output:
8: 9 7 2
9:
7:
2:
```

**Approach: **Follow the steps given below to solve the problem

- Take tree into the
**vector**. - Traverse the tree and check the condition:
- If current node is leaf then
- Delete the leaf from vector
- Else
- Recursively call for every child.

Below is the implementation of the above approach:

#data structures #recursion #tree #n-ary-tree #tree-traversal #data analysis

1599043260

Given a **Binary Tree** and an integer **D**, the task is to check if the distance between all pairs of same node values in the Tree is ? **D** or not. If found to be true, then print **Yes**. Otherwise, print **No**.

**Examples:**

_ D = 7 _Input:

```
1
/ \
2 3
/ \ / \
4 3 4 4
```

_ Yes _Output:

Explanation:

_The repeated value of nodes are 3 and 4. _

_The distance between the two nodes valued 3, is 3. _

_The maximum distance between any pair of nodes valued 4 is 4. _

Therefore, none of the distances exceed 7

_ D = 1 _Input:

```
3
/ \
3 3
\
3
```

_ No _Output:

**Recommended: Please try your approach on {IDE} first, before moving on to the solution.**

**Approach: **

The idea is to observe that the problem is similar to finding the distance between two nodes of a tree. But there can be multiple pairs of nodes for which we have to find the distance. Follow the steps below:

- Perform the Post Order Traversal of the given tree and find the distance between the repeated pairs of nodes.
- Find the nodes that are repeated in the tree using unordered_map.
- For each repeated node of a particular value, find the maximum possible distance between any pair.
- If that distance is >
**D**, print “No”. - If no such node value is found having a pair containing that value, exceeding **D, **then print “Yes”.

#greedy #recursion #searching #tree #binary tree #frequency-counting #postorder traversal #tree-traversal

1592667300

The Minimum Spanning Tree connects all vertices utilizing the minimum path. This is just a quick intro since we will cover MSTs in detail in a couple of later articles, but we’ll show a quick example of what an MST looks like. We’re not going to take any algorithmic approach, but instead use intuition in this example.

We can see that there are two negative edges in this graph, so most likely they’ll be part of the minimum spanning tree. We’ll start by adding those edges.

#programming #computer-science #minimum-spanning-tree #algorithms #developer

1672364808

## Spanning Tree Protocol (STP) Explained. You heard the words Spanning Tree, now it is time to understand what it is all about. This is a tutorial that will start from the very beginning of spanning tree and you will walk away with how it begins.

We start with the very beginning, discussing how L3 uses a mechanism to prevent loops. We quickly find out that L2 does not have this mechanism and why Spanning Tree is needed. Then we enter the world of Spanning Tree. Exploring how spanning tree forms it topology and the election processes.

From there we enter into a step by step process, understanding how Spanning Tree starts to build its own topology. We learn about the Root Bridge, Root Ports, Designated Ports, Blocking ports, and so on.

If you want to really understand Spanning Tree, this is where you begin.

- Learn the Basics of Spanning Tree from Scratch
- Learn how Time-To-Live Works
- Learn What a Loop is
- Learn what a Single Point of Failure is
- Learn what Redunancy means
- Learn Why we need Spanning Tree
- Learn Why it is Called Spanning Tree
- Learn what BPDUs are
- Learn what a Root Bridge is
- Learn what a Root Port is
- Learn what a Designated Port is
- Learn what a Blocking Port is
- Learn what a Bridge-ID is
- Learn what Spanning Tree Cost is
- Learn what Spanning Tree Port-Priority is
- Learn how the Root Bridge Election Works
- Learn how the Root Port Election Works

- You should know basic Switching concepts but not 100% necessary
- Spanning Tree is a seperate lesson and can be learned without previous knowledge
- A CCNA Studnet should learn Spannning Tree after learning Networking and Switching Fundementals, but it is not 100% necessary

- This course is for those who want to learn spanning tree
- If you have no idea what spanning tree is, this course is for you
- Those who need a review of Spanning Tree
- This is not for those looking for advance Spanning Tree topics
- Those who need a review of Spanning Tree Basics
- Those who question their spanning knowledge
- This course will NOT cover Spanning Tree Timers or Port Roles
- This course will NOT cover the Listening, Learning, and Forwarding stages

#cisco #ccna

1597978800

Given a string** S** of Size **N**. Initially, the value of count is **0**. The task is to find the value of count after **N** operations to remove all the **N** characters of the given string **S** where each operation is:

- In each operation, select an alphabetically the smallest character in the string
**S**and remove that character from**S**and add its index to count. - If multiple characters are present then remove the character having the smallest index.

**Note:** Consider string as 1-based indexing.

**Examples:**

_ N = 5, S = “abcab” _Input:

_ 8 _Output:

Explanation:

_Remove character ‘a’ then string becomes “bcab” and the count = 1. _

_Remove character ‘a’ then string becomes “bcb” and the count = 1 + 3 = 4. _

_Remove character ‘b’ then string becomes “cb” and the count = 4 + 1 = 5. _

_Remove character ‘b’ then string becomes “c” and the count = 5 + 2 = 7. _

Remove character ‘c’ then string becomes “” and the count = 7 + 1 = 8.

_ N = 5 S = “aabbc” _Input:

_ 5 _Output:

Explanation:

The value after 5 operations to remove all the 5 characters of String aabbc is 5.

**Recommended: Please try your approach on {IDE} first, before moving on to the solution.**

**Naive Approach: **The idea is to check if the string is empty or not. If it is not empty then following are the steps to solve the problem:

- Find the first occurrence of the smallest alphabets in the current string, let’s say
and remove it from the string.*ind* - Increase the count by **ind **+ 1.
- Repeat the above step until the string becomes empty.

Below is the implementation of the above approach:

- C++
- Java
- C#

`// C++ program for the above approach`

`#include <iostream>`

`#include <string>`

`**using**`

`**namespace**`

`std;`

`// Function to find the value after`

`// N operations to remove all the N`

`// characters of string S`

`**void**`

`charactersCount(string str,`

`**int**`

`n)`

`{`

`**int**`

`count = 0;`

`// Iterate till N`

`**while**`

`(n > 0) {`

`**char**`

`cur = str[0];`

`**int**`

`ind = 0;`

`**for**`

`(``**int**`

`j = 1; j < n; j++) {`

`**if**`

`(str[j] < cur) {`

`cur = str[j];`

`ind = j;`

`}`

`}`

`// Remove character at ind and`

`// decrease n(size of string)`

`str.erase(str.begin() + ind);`

`n--;`

`// Increase count by ind+1`

`count += ind + 1;`

`}`

`cout << count << endl;`

`}`

`// Driver Code`

`**int**`

`main()`

`{`

`// Given string str`

`string str =`

`"aabbc"``;`

`**int**`

`n = 5;`

`// Function call`

`charactersCount(str, n);`

`**return**`

`0;`

`}`

**Output:**

```
5
```

** Time Complexity:**_ O(N2)_

** Auxiliary Space:**_ O(1)_

**Efficient Approach: **This problem can be solved using the concept of Binary Index Tree or Fenwick Tree. Below are the steps:

- Initially, Store the values of indices of all the characters/alphabet in increasing order.
- Start with the smallest alphabet
**‘a’**and remove all**‘a’s**in the order of there occurrence. After removing, select the next alphabet**‘b’**, and repeat this step until all alphabets are removed. - Removing the character means that its corresponding value in the array is changed to
**0**, indicating that it is removed. - Before removing, find the position of the character in the string using the
**sum()**method in**Fenwick Tree**and add the position value to the count. - After removing all the characters in the string, the value of count is obtained.

#advanced data structure #divide and conquer #strings #tree #segment-tree #trees