Search in Rotated Sorted Array

1. Cho mảng số nguyên nums được sắp xếp tăng dần (các phần tử khác
nhau).
Cần tìm vị trí của một số nguyên target trong mảng đó, tuy nhiên, trước
khi tìm kiếm, mảng nums đã bị xoay đi k vị trí (k không biết trước).

Ví dụ: mảng 1 2 3 4 bị quay thành 2 3 4 1 (quay 1 vị trí)

Tổng quát: nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ...,

nums[k-1] (quay k vị trí)

Trả về vị trí của target hoặc -1 nếu không thấy.

=> Thuật toán : khởi tạo các biến left, right, mid = ( left + right )/2. Tìm
xem mid rơi vào truòng hợp nào.
- if(left > right ) return -1;
- if( a[mid] > a[left] )

a[mid]

If(target < a[mid] && target > a[left] ) right = mid – 1;

Else left = mid + 1;

- if ( a[mid] < a[left])

If(target > a[mid] && target < a[right] ) left = mid + 1;
Else right = mid – 1;
- if (a[mid] == a[left]) return mid;

2. Tìm vị trí phần tử nhỏ nhất trong mảng số nguyên nums được sắp xếp
tăng dần (nhưng bị quay như trên)
=> Thuật toán : khởi tạo các biến left, right, mid = ( left + right )/2. Tìm
xem mid rơi vào truòng hợp nào.
- if(a[left] <= a[right] ) return a[left];
- if( a[mid] > a[left] )

a[mid]

Left = mid + 1
- if ( a[mid] < a[left])
Right = mid - 1

Tìm vị trí phần tử cực đại trong mảng số nguyên nums có các phần tử
khác nhau. Phần tử cực đại là phần tử lớn hơn các phần tử bên cạnh nó.
Mặc định: phần tử ở vị trí đầu lớn hơn vị trí bên trái, phần tử ở vị trí cuối
lớn hơn vị trí bên phải.
1. Một xâu kí tự gồm các chữ cái và dấu # đại diện cho phím
Backspace. Hỏi hai xâu kí tự có bằng nhau không ?
Ví dụ: "ab#c == "ad#c" và "ab##" == "c#d#" còn "a#c" !=
"b"
=> Sử dụng stack, đọc lần lượt xâu, gặp dấu # thì pop phần
tử đầu tiên của stack ra.
2. Cho 2 dãy khoảng, firstList and secondList, với 
firstList[i] = [starti, endi]
và
secondList[j] = [startj, endj].
[1,4]  [2,5] = [2, 4]

Mỗi dãy khoảng bao gồm các khoảng được sắp xếp và
không đè lên nhau. Hãy tìm các khoảng là giao của hai dãy
này.

Mỗi khoảng [a, b] với a <= b bao gồm các số thực x sao
cho a <= x <= b. Giao của hai khoảng là một khoảng gồm
các số thực nằm trong cả hai khoảng đó.
1. Cho mảng height chứa độ cao các cọc (số dương).
height[i] là độ cao của cọc ở tọa độ i
Tìm ra 2 cọc chứa được nhiều nước nhất (xem hình dưới).

- Đặt left = 0, right = n – 1, maxS = 0;

- while(left < right), xét:
+ Nếu max < min(a[left], a[right]) * (right – left + 1) :
Max = min(a[left], a[right]) * (right – left + 1)
+ Nếu a[left] <= a[right] left ++ else right – (Vì nếu chọn cột có
chiều cao nhỏ hơn thì sẽ không thể lấy được nhiều nước hơn)
=>Độ phức tạp O(n).

2. Cho 2 xâu kí tự s và p. Tìm mọi vị trí của xâu con trên xâu
s là hoán vị của p.
- Dùng map<char, int> duyệt từng kí tự trong p, đếm số lần
xuất hiện của mỗi kí tự
- I = 0, Duyệt xâu s từ i đến I + p.size() – 1, dùng 1
map<char, int> khác đếm số lần xuất hiện của mỗi kí tự,
sau đó xoá giảm lần xuất hiện của kí tự thứ I rồi duyệt tiếp
đến kí tự thứ I + p.size().
=> Độ phức tạp : m.n ( m = s.size(), n = p.size() )
 3. Cho một dãy số nguyên dương nums và số nguyên k. Đếm
số lượng đoạn con có tích không vượt quá k.

4. Cho dãy số nguyên dương nums và số nguyên k. Tính độ

dài đoạn con bé nhất có tổng không nhỏ hơn k.
Dùng biến sum tính tổng của nums mỗi khi duyệt qua 1
phần tử.
Nếu sum > k tạm thời res = i + 1(I là vị trí tính sum hiện
tại)
Sau đó với mỗi sum tiếp theo, auto it =
map.lower_bound(sum – k ), res = min(res, I – it->first + 1)
=> O(nlogn)
5. Cho mảng 2 chiều grid[i][j] gồm các số 0, 1. Đếm số lượng
đảo gồm toàn số 1. Một đảo = các số 1 liên thông theo cạnh
của ô vuông.
6. Cho cây nhị phân theo cấu trúc dữ liệu
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
Lúc đầu các con trỏ next đặt bằng nullptr. Hãy thiết kế
thuật toán để điền giá trị con trỏ next như các mũi tên màu
đỏ ở hình dưới