## Problem: Clone Graph

Given a reference of a node in a **connected** undirected graph.

Return a **deep copy** (clone) of the graph.

Each node in the graph contains a val (`int`

) and a list (`List[Node]`

) of its neighbors.

class Node { public int val; public List<Node> neighbors; }

**Test case format:**

For simplicity sake, each node's value is the same as the node's index (1-indexed). For example, the first node with `val = 1`

, the second node with `val = 2`

, and so on. The graph is represented in the test case using an adjacency list.

**Adjacency list** is a collection of unordered **lists** used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.

The given node will always be the first node with `val = 1`

. You must return the **copy of the given node** as a reference to the cloned graph.

**Example 1:**

Input:adjList = [[2,4],[1,3],[2,4],[1,3]]Output:[[2,4],[1,3],[2,4],[1,3]]Explanation:There are 4 nodes in the graph. 1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4). 2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3). 3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4). 4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).

**Example 2:**

Input:adjList = [[]]Output:[[]]Explanation:Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.

**Example 3:**

Input:adjList = []Output:[]Explanation:This an empty graph, it does not have any nodes.

**Example 4:**

Input:adjList = [[2],[1]]Output:[[2],[1]]

**Constraints:**

`1 <= Node.val <= 100`

`Node.val`

is unique for each node.- Number of Nodes will not exceed 100.
- There is no repeated edges and no self-loops in the graph.
- The Graph is connected and all nodes can be visited starting from the given node.

DFS Graph traversal is similar to tree traversal, except due to cycles, we need to keep the list of visited nodes and backtrack if we hit a visited node

Because in the scenario below, we have to backtrack from a clone, just a list of visited nodes won't do, so we keep a dictionary that maps the visited node in the original graph to the node in the clone graph

""" # Definition for a Node. class Node: def __init__(self, val = 0, neighbors = None): self.val = val self.neighbors = neighbors if neighbors is not None else [] """ class Solution: def __init__(self): self.visited = {} def cloneGraph(self, node: 'Node') -> 'Node': if not node: return node if node in self.visited: return self.visited[node] clone = Node(node.val, []) self.visited[node] = clone if node.neighbors: for n in node.neighbors: clone.neighbors.append(self.cloneGraph(n)) return clone

Word Break

Given a **non-empty** string *s* and a dictionary *wordDict* containing a list of **non-empty** words, determine if *s* can be segmented into a space-separated sequence of one or more dictionary words.

**Note:**

- The same word in the dictionary may be reused multiple times in the segmentation.
- You may assume the dictionary does not contain duplicate words.

**Example 1:**

Input:s = "leetcode", wordDict = ["leet", "code"]Output:trueExplanation:Return true because`"leetcode"`

can be segmented as`"leet code"`

.

**Example 2:**

Input:s = "applepenapple", wordDict = ["apple", "pen"]Output:trueExplanation:Return true because`"`

applepenapple`"`

can be segmented as`"`

apple pen apple`"`

. Note that you are allowed to reuse a dictionary word.

**Example 3:**

Input:s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]Output:false

def findWordBreak(s, wordDict, seen): if not s: return True if s in seen: return seen[s] i=0 ret = False while not ret and i < len(wordDict): if s.startswith(wordDict[i]): ret = findWordBreak(s[len(wordDict[i]):], wordDict, seen) i+=1 seen[s] = ret return ret class Solution: def wordBreak(self, s: str, wordDict: List[str]) -> bool: return findWordBreak(s, wordDict, {})