1472. Design Browser History

Description

You have a browser of one tab where you start on the homepage and you can visit another url, get back in the history number of steps or move forward in the history number of steps.

Implement the BrowserHistory class:

BrowserHistory(string homepage) Initializes the object with the homepage of the browser.
void visit(string url) Visits url from the current page. It clears up all the forward history.
string back(int steps) Move steps back in history. If you can only return x steps in the history and steps > x, you will return only x steps. Return the current url after moving back in history at most steps.
string forward(int steps) Move steps forward in history. If you can only forward x steps in the history and steps > x, you will forward only x steps. Return the current url after forwarding in history at most steps.

Example:

Input:
["BrowserHistory","visit","visit","visit","back","back","forward","visit","forward","back","back"]
[["leetcode.com"],["google.com"],["facebook.com"],["youtube.com"],[1],[1],[1],["linkedin.com"],[2],[2],[7]]
Output:
[null,null,null,null,"facebook.com","google.com","facebook.com",null,"linkedin.com","google.com","leetcode.com"]

Explanation:
BrowserHistory browserHistory = new BrowserHistory("leetcode.com");
browserHistory.visit("google.com");       // You are in "leetcode.com". Visit "google.com"
browserHistory.visit("facebook.com");     // You are in "google.com". Visit "facebook.com"
browserHistory.visit("youtube.com");      // You are in "facebook.com". Visit "youtube.com"
browserHistory.back(1);                   // You are in "youtube.com", move back to "facebook.com" return "facebook.com"
browserHistory.back(1);                   // You are in "facebook.com", move back to "google.com" return "google.com"
browserHistory.forward(1);                // You are in "google.com", move forward to "facebook.com" return "facebook.com"
browserHistory.visit("linkedin.com");     // You are in "facebook.com". Visit "linkedin.com"
browserHistory.forward(2);                // You are in "linkedin.com", you cannot move forward any steps.
browserHistory.back(2);                   // You are in "linkedin.com", move back two steps to "facebook.com" then to "google.com". return "google.com"
browserHistory.back(7);                   // You are in "google.com", you can move back only one step to "leetcode.com". return "leetcode.com"

Constraints:

1 <= homepage.length <= 20
1 <= url.length <= 20
1 <= steps <= 100
homepage and url consist of '.' or lower case English letters.
At most 5000 calls will be made to visit, back, and forward.

Solutions

Class `BrowserHistory`

Attributes:
- stk1: A stack (implemented as a list in Python) that stores the user’s browsing history up to the current page.
- stk2: A stack that temporarily holds the URLs that have been visited when the user goes back in the history.
__init__(self, homepage: str):
- Initializes the browser history with the given homepage. The homepage URL is added to stk1, and stk2 is initialized as an empty stack.
visit(self, url: str) -> None:
- Simulates visiting a new webpage. The new URL is pushed onto stk1. Since visiting a new page invalidates the forward history, stk2 is cleared.
back(self, steps: int) -> str:
- Moves back in the history by the specified number of steps. For each step, it checks if there is a previous page in stk1 (ensuring that there is always at least one page in stk1). It pops the top URL from stk1 and pushes it onto stk2. This process is repeated until either the desired number of steps is reached or there are no more pages to go back to. Returns the URL of the current page after moving back.
forward(self, steps: int) -> str:
- Moves forward in the history by the specified number of steps. For each step, it checks if there is a forward page in stk2. It pops the top URL from stk2 and pushes it onto stk1. This is repeated until either the desired number of steps is reached or there is no more forward history. Returns the URL of the current page after moving forward.

How It Works

When the user visits a new URL, it’s always added to stk1, and stk2 is cleared since the forward history no longer applies.
When the user goes back, URLs are moved from stk1 to stk2. This signifies that the user has moved back from these pages, and they now become part of the forward history.
When the user moves forward, URLs are moved back from stk2 to stk1, indicating that the user is revisiting these pages.
The top of stk1 always represents the current page.

Complexity

Time Complexity: Each method (visit, back, forward) operates in O(1) time per operation, as stack operations are constant time.
Space Complexity: O(N), where N is the total number of webpages visited. This is because each URL visited is stored in either stk1 or stk2.

class BrowserHistory {
    private Deque<String> stk1 = new ArrayDeque<>();
    private Deque<String> stk2 = new ArrayDeque<>();

    public BrowserHistory(String homepage) {
        visit(homepage);
    }

    public void visit(String url) {
        stk1.push(url);
        stk2.clear();
    }

    public String back(int steps) {
        for (; steps > 0 && stk1.size() > 1; --steps) {
            stk2.push(stk1.pop());
        }
        return stk1.peek();
    }

    public String forward(int steps) {
        for (; steps > 0 && !stk2.isEmpty(); --steps) {
            stk1.push(stk2.pop());
        }
        return stk1.peek();
    }
}

/**
 * Your BrowserHistory object will be instantiated and called as such:
 * BrowserHistory obj = new BrowserHistory(homepage);
 * obj.visit(url);
 * String param_2 = obj.back(steps);
 * String param_3 = obj.forward(steps);
 */

class BrowserHistory {
public:
    stack<string> stk1;
    stack<string> stk2;

    BrowserHistory(string homepage) {
        visit(homepage);
    }

    void visit(string url) {
        stk1.push(url);
        stk2 = stack<string>();
    }

    string back(int steps) {
        for (; steps && stk1.size() > 1; --steps) {
            stk2.push(stk1.top());
            stk1.pop();
        }
        return stk1.top();
    }

    string forward(int steps) {
        for (; steps && !stk2.empty(); --steps) {
            stk1.push(stk2.top());
            stk2.pop();
        }
        return stk1.top();
    }
};

/**
 * Your BrowserHistory object will be instantiated and called as such:
 * BrowserHistory* obj = new BrowserHistory(homepage);
 * obj->visit(url);
 * string param_2 = obj->back(steps);
 * string param_3 = obj->forward(steps);
 */

class BrowserHistory:
    def __init__(self, homepage: str):
        self.stk1 = [] # backward
        self.stk2 = [] # forward
        self.visit(homepage)

    def visit(self, url: str) -> None:
        self.stk1.append(url)
        self.stk2.clear()

    def back(self, steps: int) -> str:
        while steps and len(self.stk1) > 1:
            self.stk2.append(self.stk1.pop())
            steps -= 1
        return self.stk1[-1]

    def forward(self, steps: int) -> str:
        while steps and self.stk2:
            self.stk1.append(self.stk2.pop())
            steps -= 1
        return self.stk1[-1]


# Your BrowserHistory object will be instantiated and called as such:
# obj = BrowserHistory(homepage)
# obj.visit(url)
# param_2 = obj.back(steps)
# param_3 = obj.forward(steps)

############

class BrowserHistory:

    def __init__(self, homepage: str):
        self.his = [homepage]
        self.cur = 0


    def visit(self, url: str) -> None:
        while self.his and len(self.his) - 1 > self.cur:
            self.his.pop()
        self.his.append(url)
        self.cur += 1


    def back(self, steps: int) -> str:
        self.cur -= min(self.cur, steps)
        return self.his[self.cur]
        

    def forward(self, steps: int) -> str:
        self.cur += steps
        self.cur = min(self.cur, len(self.his) - 1)
        return self.his[self.cur]

# Your BrowserHistory object will be instantiated and called as such:
# obj = BrowserHistory(homepage)
# obj.visit(url)
# param_2 = obj.back(steps)
# param_3 = obj.forward(steps)

type BrowserHistory struct {
	stk1 []string
	stk2 []string
}

func Constructor(homepage string) BrowserHistory {
	t := BrowserHistory{[]string{}, []string{} }
	t.Visit(homepage)
	return t
}

func (this *BrowserHistory) Visit(url string) {
	this.stk1 = append(this.stk1, url)
	this.stk2 = []string{}
}

func (this *BrowserHistory) Back(steps int) string {
	for i := 0; i < steps && len(this.stk1) > 1; i++ {
		this.stk2 = append(this.stk2, this.stk1[len(this.stk1)-1])
		this.stk1 = this.stk1[:len(this.stk1)-1]
	}
	return this.stk1[len(this.stk1)-1]
}

func (this *BrowserHistory) Forward(steps int) string {
	for i := 0; i < steps && len(this.stk2) > 0; i++ {
		this.stk1 = append(this.stk1, this.stk2[len(this.stk2)-1])
		this.stk2 = this.stk2[:len(this.stk2)-1]
	}
	return this.stk1[len(this.stk1)-1]
}

/**
 * Your BrowserHistory object will be instantiated and called as such:
 * obj := Constructor(homepage);
 * obj.Visit(url);
 * param_2 := obj.Back(steps);
 * param_3 := obj.Forward(steps);
 */

1472 - Design Browser History

1472. Design Browser History

Description

Solutions

Class `BrowserHistory`

How It Works

Complexity

All Problems

All Solutions

Welcome to Subscribe On Youtube

1472. Design Browser History

Description

Solutions

Class BrowserHistory

How It Works

Complexity

All Problems

All Solutions

Class `BrowserHistory`